From 041d147e4c1976de37f2a54ff3512faa3330723c Mon Sep 17 00:00:00 2001 From: Dominik Zajkowski Date: Mon, 14 Jun 2021 12:00:13 +0200 Subject: [PATCH 1/2] [ETCM-842] Remove ETH61 and ETH62 as possible protocols --- .../ethereum/sync/util/CommonFakePeer.scala | 1 - .../txExecTest/util/DumpChainApp.scala | 1 - .../io/iohk/ethereum/network/PeerActor.scala | 6 +- .../ethereum/network/PeerManagerActor.scala | 4 - .../iohk/ethereum/network/p2p/Message.scala | 11 +- .../network/p2p/MessageDecoders.scala | 91 ++++++-------- .../network/p2p/messages/package.scala | 6 + .../ethereum/network/rlpx/MessageCodec.scala | 3 +- .../network/rlpx/RLPxConnectionHandler.scala | 46 +++---- .../ethereum/nodebuilder/NodeBuilder.scala | 3 +- .../network/p2p/MessageCodecSpec.scala | 6 +- .../network/p2p/MessageDecodersSpec.scala | 117 +++++------------- .../messages/MessagesSerializationSpec.scala | 19 +-- .../network/p2p/messages/NodeDataSpec.scala | 4 +- .../network/p2p/messages/ReceiptsSpec.scala | 7 +- .../rlpx/RLPxConnectionHandlerSpec.scala | 9 +- 16 files changed, 132 insertions(+), 202 deletions(-) diff --git a/src/it/scala/io/iohk/ethereum/sync/util/CommonFakePeer.scala b/src/it/scala/io/iohk/ethereum/sync/util/CommonFakePeer.scala index 5143c2491a..5ac20c221d 100644 --- a/src/it/scala/io/iohk/ethereum/sync/util/CommonFakePeer.scala +++ b/src/it/scala/io/iohk/ethereum/sync/util/CommonFakePeer.scala @@ -190,7 +190,6 @@ abstract class CommonFakePeer(peerName: String, fakePeerCustomConfig: FakePeerCu peerStatistics, handshaker, authHandshaker, - EthereumMessageDecoder, discoveryConfig, blacklist, blockchainConfig.capabilities diff --git a/src/it/scala/io/iohk/ethereum/txExecTest/util/DumpChainApp.scala b/src/it/scala/io/iohk/ethereum/txExecTest/util/DumpChainApp.scala index 98fd09b2d8..b212f9d595 100644 --- a/src/it/scala/io/iohk/ethereum/txExecTest/util/DumpChainApp.scala +++ b/src/it/scala/io/iohk/ethereum/txExecTest/util/DumpChainApp.scala @@ -113,7 +113,6 @@ object DumpChainApp extends App with NodeKeyBuilder with SecureRandomBuilder wit knownNodesManager = actorSystem.deadLetters, // TODO: fixme handshaker = handshaker, authHandshaker = authHandshaker, - messageDecoder = EthereumMessageDecoder, discoveryConfig = discoveryConfig, blacklist = blacklist, capabilities = blockchainConfig.capabilities diff --git a/src/main/scala/io/iohk/ethereum/network/PeerActor.scala b/src/main/scala/io/iohk/ethereum/network/PeerActor.scala index 7334643618..d4484c2bbc 100644 --- a/src/main/scala/io/iohk/ethereum/network/PeerActor.scala +++ b/src/main/scala/io/iohk/ethereum/network/PeerActor.scala @@ -320,13 +320,12 @@ object PeerActor { incomingConnection: Boolean, handshaker: Handshaker[R], authHandshaker: AuthHandshaker, - messageDecoder: MessageDecoder, capabilities: List[Capability] ): Props = Props( new PeerActor( peerAddress, - rlpxConnectionFactory(authHandshaker, messageDecoder, peerConfiguration.rlpxConfiguration, capabilities), + rlpxConnectionFactory(authHandshaker, peerConfiguration.rlpxConfiguration, capabilities), peerConfiguration, peerEventBus, knownNodesManager, @@ -338,13 +337,12 @@ object PeerActor { def rlpxConnectionFactory( authHandshaker: AuthHandshaker, - messageDecoder: MessageDecoder, rlpxConfiguration: RLPxConfiguration, capabilities: List[Capability] ): ActorContext => ActorRef = { ctx => ctx.actorOf( RLPxConnectionHandler - .props(NetworkMessageDecoder orElse messageDecoder, capabilities, authHandshaker, rlpxConfiguration), + .props(capabilities, authHandshaker, rlpxConfiguration), "rlpx-connection" ) } diff --git a/src/main/scala/io/iohk/ethereum/network/PeerManagerActor.scala b/src/main/scala/io/iohk/ethereum/network/PeerManagerActor.scala index 250a7f3f3c..64ed0ec0a6 100644 --- a/src/main/scala/io/iohk/ethereum/network/PeerManagerActor.scala +++ b/src/main/scala/io/iohk/ethereum/network/PeerManagerActor.scala @@ -421,7 +421,6 @@ object PeerManagerActor { peerStatistics: ActorRef, handshaker: Handshaker[R], authHandshaker: AuthHandshaker, - messageDecoder: MessageDecoder, discoveryConfig: DiscoveryConfig, blacklist: Blacklist, capabilities: List[Capability] @@ -433,7 +432,6 @@ object PeerManagerActor { knownNodesManager, handshaker, authHandshaker, - messageDecoder, capabilities ) @@ -458,7 +456,6 @@ object PeerManagerActor { knownNodesManager: ActorRef, handshaker: Handshaker[R], authHandshaker: AuthHandshaker, - messageDecoder: MessageDecoder, capabilities: List[Capability] ): (ActorContext, InetSocketAddress, Boolean) => ActorRef = { (ctx, address, incomingConnection) => val id: String = address.toString.filterNot(_ == '/') @@ -470,7 +467,6 @@ object PeerManagerActor { incomingConnection, handshaker, authHandshaker, - messageDecoder, capabilities ) ctx.actorOf(props, id) diff --git a/src/main/scala/io/iohk/ethereum/network/p2p/Message.scala b/src/main/scala/io/iohk/ethereum/network/p2p/Message.scala index d9f3f5893b..33efbae442 100644 --- a/src/main/scala/io/iohk/ethereum/network/p2p/Message.scala +++ b/src/main/scala/io/iohk/ethereum/network/p2p/Message.scala @@ -21,11 +21,10 @@ trait MessageSerializable extends Message { } trait MessageDecoder { self => - def fromBytes(`type`: Int, payload: Array[Byte], protocolVersion: Capability): Message + def fromBytes(`type`: Int, payload: Array[Byte]): Message - def orElse(otherMessageDecoder: MessageDecoder): MessageDecoder = new MessageDecoder { - override def fromBytes(`type`: Int, payload: Array[Byte], protocolVersion: Capability): Message = - Try { self.fromBytes(`type`, payload, protocolVersion) } - .getOrElse(otherMessageDecoder.fromBytes(`type`, payload, protocolVersion)) - } + def orElse(otherMessageDecoder: MessageDecoder): MessageDecoder = (`type`: Int, payload: Array[Byte]) => + Try { + self.fromBytes(`type`, payload) + }.getOrElse(otherMessageDecoder.fromBytes(`type`, payload)) } diff --git a/src/main/scala/io/iohk/ethereum/network/p2p/MessageDecoders.scala b/src/main/scala/io/iohk/ethereum/network/p2p/MessageDecoders.scala index e6344304c8..f7654b8ec0 100644 --- a/src/main/scala/io/iohk/ethereum/network/p2p/MessageDecoders.scala +++ b/src/main/scala/io/iohk/ethereum/network/p2p/MessageDecoders.scala @@ -21,7 +21,7 @@ import io.iohk.ethereum.network.p2p.messages.WireProtocol._ object NetworkMessageDecoder extends MessageDecoder { - override def fromBytes(msgCode: Int, payload: Array[Byte], protocolVersion: Capability): Message = + override def fromBytes(msgCode: Int, payload: Array[Byte]): Message = msgCode match { case Disconnect.code => payload.toDisconnect case Ping.code => payload.toPing @@ -32,75 +32,62 @@ object NetworkMessageDecoder extends MessageDecoder { } -// scalastyle:off -object EthereumMessageDecoder extends MessageDecoder { - - override def fromBytes(msgCode: Int, payload: Array[Byte], protocolVersion: Capability): Message = { - protocolVersion match { - case ETC64 => handleETC64(msgCode, payload) - case ETH63 => handleETH63(msgCode, payload) - case ETH62 => handleETH62(msgCode, payload) - case ETH61 => handleETH61(msgCode, payload) - case pv => throw new RuntimeException("Unknown protocol version: " + pv) - } - } +object ETC64MessageDecoder extends MessageDecoder { + import io.iohk.ethereum.network.p2p.messages.ETC64.Status._ + import io.iohk.ethereum.network.p2p.messages.ETC64.NewBlock._ - private def handleCommonMessages(msgCode: Int, payload: Array[Byte]): Message = { - msgCode match { - case Codes.StatusCode => - import io.iohk.ethereum.network.p2p.messages.BaseETH6XMessages.Status._ - payload.toStatus - case Codes.NewBlockCode => - import io.iohk.ethereum.network.p2p.messages.BaseETH6XMessages.NewBlock._ - payload.toNewBlock - case Codes.SignedTransactionsCode => - payload.toSignedTransactions - case _ => - throw new RuntimeException("Unknown message type: " + msgCode) - } - } - - private def handleETH61(msgCode: Int, payload: Array[Byte]): Message = { - msgCode match { - case Codes.NewBlockHashesCode => - import io.iohk.ethereum.network.p2p.messages.ETH61.NewBlockHashes._ - payload.toNewBlockHashes - case Codes.BlockHashesFromNumberCode => - payload.toBlockHashesFromNumber - case _ => handleCommonMessages(msgCode, payload) - } - } - - private def handleETH62(msgCode: Int, payload: Array[Byte]): Message = { + def fromBytes(msgCode: Int, payload: Array[Byte]): Message = { msgCode match { + case Codes.StatusCode => payload.toStatus + case Codes.NewBlockCode => payload.toNewBlock + case Codes.GetNodeDataCode => payload.toGetNodeData + case Codes.NodeDataCode => payload.toNodeData + case Codes.GetReceiptsCode => payload.toGetReceipts + case Codes.ReceiptsCode => payload.toReceipts case Codes.NewBlockHashesCode => payload.toNewBlockHashes case Codes.GetBlockHeadersCode => payload.toGetBlockHeaders case Codes.BlockHeadersCode => payload.toBlockHeaders case Codes.GetBlockBodiesCode => payload.toGetBlockBodies case Codes.BlockBodiesCode => payload.toBlockBodies - case _ => handleCommonMessages(msgCode, payload) + case Codes.BlockHashesFromNumberCode => payload.toBlockHashesFromNumber + case Codes.SignedTransactionsCode => payload.toSignedTransactions + case _ => throw new RuntimeException(s"Unknown message type: ${msgCode}") } } +} - private def handleETH63(msgCode: Int, payload: Array[Byte]): Message = { +object ETH63MessageDecoder extends MessageDecoder { + import io.iohk.ethereum.network.p2p.messages.BaseETH6XMessages.Status._ + import io.iohk.ethereum.network.p2p.messages.BaseETH6XMessages.NewBlock._ + + def fromBytes(msgCode: Int, payload: Array[Byte]): Message = { msgCode match { case Codes.GetNodeDataCode => payload.toGetNodeData case Codes.NodeDataCode => payload.toNodeData case Codes.GetReceiptsCode => payload.toGetReceipts case Codes.ReceiptsCode => payload.toReceipts - case _ => handleETH62(msgCode, payload) + case Codes.NewBlockHashesCode => payload.toNewBlockHashes + case Codes.GetBlockHeadersCode => payload.toGetBlockHeaders + case Codes.BlockHeadersCode => payload.toBlockHeaders + case Codes.GetBlockBodiesCode => payload.toGetBlockBodies + case Codes.BlockBodiesCode => payload.toBlockBodies + case Codes.BlockHashesFromNumberCode => payload.toBlockHashesFromNumber + case Codes.StatusCode => payload.toStatus + case Codes.NewBlockCode => payload.toNewBlock + case Codes.SignedTransactionsCode => payload.toSignedTransactions + case _ => throw new RuntimeException(s"Unknown message type: ${msgCode}") } } +} - private def handleETC64(msgCode: Int, payload: Array[Byte]): Message = { - msgCode match { - case Codes.StatusCode => - import io.iohk.ethereum.network.p2p.messages.ETC64.Status._ - payload.toStatus - case Codes.NewBlockCode => - import io.iohk.ethereum.network.p2p.messages.ETC64.NewBlock._ - payload.toNewBlock - case _ => handleETH63(msgCode, payload) +// scalastyle:off +object EthereumMessageDecoder { + type Decoder = (Int, Array[Byte]) => Message + def ethMessageDecoder(protocolVersion: Capability): MessageDecoder = { + protocolVersion match { + case Capability.Capabilities.Etc64Capability => ETC64MessageDecoder.fromBytes + case Capability.Capabilities.Eth63Capability => ETH63MessageDecoder.fromBytes + case _ => throw new RuntimeException(s"Unsupported Protocol Version $protocolVersion") } } } diff --git a/src/main/scala/io/iohk/ethereum/network/p2p/messages/package.scala b/src/main/scala/io/iohk/ethereum/network/p2p/messages/package.scala index 51cfceb9fd..c4dfebab71 100644 --- a/src/main/scala/io/iohk/ethereum/network/p2p/messages/package.scala +++ b/src/main/scala/io/iohk/ethereum/network/p2p/messages/package.scala @@ -5,8 +5,14 @@ package object messages { val ETH61: Capability = Capability("eth", 61.toByte) val ETH62: Capability = Capability("eth", 62.toByte) val ETH63: Capability = Capability("eth", 63.toByte) + val ETH64: Capability = Capability("eth", 64.toByte) + val ETH65: Capability = Capability("eth", 65.toByte) + val ETH66: Capability = Capability("eth", 66.toByte) + val ETC64: Capability = Capability("etc", 64.toByte) + val SNAP1: Capability = Capability("snap", 1.toByte) + val SubProtocolOffset = 0x10 } diff --git a/src/main/scala/io/iohk/ethereum/network/rlpx/MessageCodec.scala b/src/main/scala/io/iohk/ethereum/network/rlpx/MessageCodec.scala index 64819d7c18..3dbadc4b5b 100644 --- a/src/main/scala/io/iohk/ethereum/network/rlpx/MessageCodec.scala +++ b/src/main/scala/io/iohk/ethereum/network/rlpx/MessageCodec.scala @@ -19,7 +19,6 @@ object MessageCodec { class MessageCodec( frameCodec: FrameCodec, messageDecoder: MessageDecoder, - protocolVersion: Capability, val remotePeer2PeerVersion: Long ) { import MessageCodec._ @@ -43,7 +42,7 @@ class MessageCodec( } payloadTry.map { payload => - messageDecoder.fromBytes(frame.`type`, payload, protocolVersion) + messageDecoder.fromBytes(frame.`type`, payload) } } } diff --git a/src/main/scala/io/iohk/ethereum/network/rlpx/RLPxConnectionHandler.scala b/src/main/scala/io/iohk/ethereum/network/rlpx/RLPxConnectionHandler.scala index 5e4ac93b51..4db364092c 100644 --- a/src/main/scala/io/iohk/ethereum/network/rlpx/RLPxConnectionHandler.scala +++ b/src/main/scala/io/iohk/ethereum/network/rlpx/RLPxConnectionHandler.scala @@ -9,8 +9,14 @@ import cats.data.NonEmptyList import io.iohk.ethereum.network.p2p.messages.{Capability, WireProtocol} import io.iohk.ethereum.network.p2p.messages.WireProtocol.Hello import io.iohk.ethereum.network.p2p.messages.WireProtocol.Hello.HelloEnc -import io.iohk.ethereum.network.p2p.{Message, MessageDecoder, MessageSerializable, NetworkMessageDecoder} -import io.iohk.ethereum.network.rlpx.RLPxConnectionHandler.{HelloExtractor, RLPxConfiguration} +import io.iohk.ethereum.network.p2p.{ + EthereumMessageDecoder, + Message, + MessageDecoder, + MessageSerializable, + NetworkMessageDecoder +} +import io.iohk.ethereum.network.rlpx.RLPxConnectionHandler.{HelloCodec, RLPxConfiguration} import io.iohk.ethereum.utils.ByteUtils import org.bouncycastle.util.encoders.Hex @@ -30,12 +36,11 @@ import scala.util.{Failure, Success, Try} * 4. once handshake is done (and secure connection established) actor can send/receive messages (`handshaked` state) */ class RLPxConnectionHandler( - messageDecoder: MessageDecoder, capabilities: List[Capability], authHandshaker: AuthHandshaker, - messageCodecFactory: (FrameCodec, MessageDecoder, Capability, Long) => MessageCodec, + messageCodecFactory: (FrameCodec, Capability, Long) => MessageCodec, rlpxConfiguration: RLPxConfiguration, - extractor: Secrets => HelloExtractor + extractor: Secrets => HelloCodec ) extends Actor with ActorLogging { @@ -172,7 +177,7 @@ class RLPxConnectionHandler( } def awaitInitialHello( - extractor: HelloExtractor, + extractor: HelloCodec, cancellableAckTimeout: Option[CancellableAckTimeout] = None, seqNumber: Int = 0 ): Receive = @@ -183,7 +188,7 @@ class RLPxConnectionHandler( ) orElse handleReceiveHello(extractor, cancellableAckTimeout, seqNumber) private def handleSendHello( - extractor: HelloExtractor, + extractor: HelloCodec, cancellableAckTimeout: Option[CancellableAckTimeout] = None, seqNumber: Int = 0 ): Receive = { @@ -211,7 +216,7 @@ class RLPxConnectionHandler( } private def handleReceiveHello( - extractor: HelloExtractor, + extractor: HelloCodec, cancellableAckTimeout: Option[CancellableAckTimeout] = None, seqNumber: Int = 0 ): Receive = { case Received(data) => @@ -241,9 +246,9 @@ class RLPxConnectionHandler( } } - private def negotiateCodec(hello: Hello, extractor: HelloExtractor): Option[(MessageCodec, Capability)] = + private def negotiateCodec(hello: Hello, extractor: HelloCodec): Option[(MessageCodec, Capability)] = Capability.negotiate(hello.capabilities.toList, capabilities).map { negotiated => - (messageCodecFactory(extractor.frameCodec, messageDecoder, negotiated, hello.p2pVersion), negotiated) + (messageCodecFactory(extractor.frameCodec, negotiated, hello.p2pVersion), negotiated) } private def processFrames(frames: Seq[Frame], messageCodec: MessageCodec): Unit = @@ -373,29 +378,28 @@ class RLPxConnectionHandler( object RLPxConnectionHandler { def props( - messageDecoder: MessageDecoder, capabilities: List[Capability], authHandshaker: AuthHandshaker, rlpxConfiguration: RLPxConfiguration ): Props = Props( new RLPxConnectionHandler( - messageDecoder, capabilities, authHandshaker, - messageCodecFactory, + ethMessageCodecFactory, rlpxConfiguration, - HelloExtractor.apply + HelloCodec.apply ) ) - def messageCodecFactory( + def ethMessageCodecFactory( frameCodec: FrameCodec, - messageDecoder: MessageDecoder, - protocolVersion: Capability, + negotiated: Capability, p2pVersion: Long - ): MessageCodec = - new MessageCodec(frameCodec, messageDecoder, protocolVersion, p2pVersion) + ): MessageCodec = { + val md = EthereumMessageDecoder.ethMessageDecoder(negotiated) orElse NetworkMessageDecoder + new MessageCodec(frameCodec, md, p2pVersion) + } case class ConnectTo(uri: URI) @@ -424,7 +428,7 @@ object RLPxConnectionHandler { val waitForTcpAckTimeout: FiniteDuration } - case class HelloExtractor(secrets: Secrets) { + case class HelloCodec(secrets: Secrets) { import MessageCodec._ lazy val frameCodec = new FrameCodec(secrets) @@ -448,7 +452,7 @@ object RLPxConnectionHandler { private def extractHello(frame: Frame): Option[Hello] = { val frameData = frame.payload.toArray if (frame.`type` == Hello.code) { - val m = NetworkMessageDecoder.fromBytes(frame.`type`, frameData, Capability.Capabilities.Eth63Capability) + val m = NetworkMessageDecoder.fromBytes(frame.`type`, frameData) Some(m.asInstanceOf[Hello]) } else { None diff --git a/src/main/scala/io/iohk/ethereum/nodebuilder/NodeBuilder.scala b/src/main/scala/io/iohk/ethereum/nodebuilder/NodeBuilder.scala index 09d70da818..7c1c014058 100644 --- a/src/main/scala/io/iohk/ethereum/nodebuilder/NodeBuilder.scala +++ b/src/main/scala/io/iohk/ethereum/nodebuilder/NodeBuilder.scala @@ -24,7 +24,7 @@ import io.iohk.ethereum.network.EtcPeerManagerActor.PeerInfo import io.iohk.ethereum.network.PeerManagerActor.PeerConfiguration import io.iohk.ethereum.network.discovery.{DiscoveryConfig, DiscoveryServiceBuilder, PeerDiscoveryManager} import io.iohk.ethereum.network.handshaker.{EtcHandshaker, EtcHandshakerConfiguration, Handshaker} -import io.iohk.ethereum.network.p2p.EthereumMessageDecoder +import io.iohk.ethereum.network.p2p.{EthereumMessageDecoder, NetworkMessageDecoder} import io.iohk.ethereum.network.rlpx.AuthHandshaker import io.iohk.ethereum.network.{PeerManagerActor, ServerActor, _} import io.iohk.ethereum.ommers.OmmersPool @@ -245,7 +245,6 @@ trait PeerManagerActorBuilder { peerStatistics, handshaker, authHandshaker, - EthereumMessageDecoder, discoveryConfig, blacklist, blockchainConfig.capabilities diff --git a/src/test/scala/io/iohk/ethereum/network/p2p/MessageCodecSpec.scala b/src/test/scala/io/iohk/ethereum/network/p2p/MessageCodecSpec.scala index 96a99fa4d0..048b95a133 100644 --- a/src/test/scala/io/iohk/ethereum/network/p2p/MessageCodecSpec.scala +++ b/src/test/scala/io/iohk/ethereum/network/p2p/MessageCodecSpec.scala @@ -98,10 +98,10 @@ class MessageCodecSpec extends AnyFlatSpec with Matchers { genesisHash = ByteString(1) ) - val decoder = NetworkMessageDecoder orElse EthereumMessageDecoder + val decoder = NetworkMessageDecoder.orElse(EthereumMessageDecoder.ethMessageDecoder(Eth63Capability)) - val messageCodec = new MessageCodec(frameCodec, decoder, ProtocolVersions.ETH63, negotiatedLocalP2PVersion) - val remoteMessageCodec = new MessageCodec(remoteFrameCodec, decoder, ProtocolVersions.ETH63, negotiatedRemoteP2PVersion) + val messageCodec = new MessageCodec(frameCodec, decoder, negotiatedLocalP2PVersion) + val remoteMessageCodec = new MessageCodec(remoteFrameCodec, decoder, negotiatedRemoteP2PVersion) } diff --git a/src/test/scala/io/iohk/ethereum/network/p2p/MessageDecodersSpec.scala b/src/test/scala/io/iohk/ethereum/network/p2p/MessageDecodersSpec.scala index 3007fb4a5e..e6324ce58d 100644 --- a/src/test/scala/io/iohk/ethereum/network/p2p/MessageDecodersSpec.scala +++ b/src/test/scala/io/iohk/ethereum/network/p2p/MessageDecodersSpec.scala @@ -13,7 +13,7 @@ import org.scalatest.matchers.should.Matchers class MessageDecodersSpec extends AnyFlatSpec with Matchers with SecureRandomBuilder { - val decode = EthereumMessageDecoder.fromBytes _ + def decode: Capability => MessageDecoder = EthereumMessageDecoder.ethMessageDecoder _ val exampleHash = ByteString(Hex.decode("fccdbfe911f9df0a6cc0107d1240f76dfdd1d301b65fdc3cd2ae62752affbef6")) @@ -40,39 +40,31 @@ class MessageDecodersSpec extends AnyFlatSpec with Matchers with SecureRandomBui ) ) ) - NetworkMessageDecoder.fromBytes(WireProtocol.Hello.code, helloBytes, ProtocolVersions.ETH61) shouldBe hello - NetworkMessageDecoder.fromBytes(WireProtocol.Hello.code, helloBytes, ProtocolVersions.ETH62) shouldBe hello - NetworkMessageDecoder.fromBytes(WireProtocol.Hello.code, helloBytes, ProtocolVersions.ETH63) shouldBe hello - NetworkMessageDecoder.fromBytes(WireProtocol.Hello.code, helloBytes, ProtocolVersions.ETC64) shouldBe hello + NetworkMessageDecoder.fromBytes(WireProtocol.Hello.code, helloBytes) shouldBe hello } it should "decode NewBlockHashes message for all supported versions of protocol" in { - val newBlockHashesETH61 = ETH61.NewBlockHashes(Seq(exampleHash, exampleHash)) - val NewBlockHashesETH62bytes: Array[Byte] = Hex.decode( "f846e2a0fccdbfe911f9df0a6cc0107d1240f76dfdd1d301b65fdc3cd2ae62752affbef601e2a0fccdbfe911f9df0a6cc0107d1240f76dfdd1d301b65fdc3cd2ae62752affbef602" ) val newBlockHashesETH62 = ETH62.NewBlockHashes(Seq(ETH62.BlockHash(exampleHash, 1), ETH62.BlockHash(exampleHash, 2))) - decode(Codes.NewBlockHashesCode, NewBlockHashesETH61bytes, ProtocolVersions.ETH61) shouldBe newBlockHashesETH61 - decode(Codes.NewBlockHashesCode, NewBlockHashesETH62bytes, ProtocolVersions.ETH62) shouldBe newBlockHashesETH62 - decode(Codes.NewBlockHashesCode, NewBlockHashesETH62bytes, ProtocolVersions.ETH63) shouldBe newBlockHashesETH62 - decode(Codes.NewBlockHashesCode, NewBlockHashesETH62bytes, ProtocolVersions.ETC64) shouldBe newBlockHashesETH62 + decode(ProtocolVersions.ETH63).fromBytes(Codes.NewBlockHashesCode, NewBlockHashesETH62bytes) shouldBe newBlockHashesETH62 + decode(ProtocolVersions.ETC64).fromBytes(Codes.NewBlockHashesCode, NewBlockHashesETH62bytes) shouldBe newBlockHashesETH62 } it should "not decode message from older version of protocol as newer version" in { assertThrows[RuntimeException] { - decode(Codes.NewBlockHashesCode, NewBlockHashesETH61bytes, ProtocolVersions.ETH62) + decode(ProtocolVersions.ETH62).fromBytes(Codes.NewBlockHashesCode, NewBlockHashesETH61bytes) } } it should "decode BlockHashesFromNumber message for all supported versions of protocol" in { val blockHashesFromNumber = ETH61.BlockHashesFromNumber(12, 40) - decode( + decode(ProtocolVersions.ETH63).fromBytes( Codes.BlockHashesFromNumberCode, - blockHashesFromNumberBytes, - ProtocolVersions.ETH61 + blockHashesFromNumberBytes ) shouldBe blockHashesFromNumber } @@ -80,104 +72,64 @@ class MessageDecodersSpec extends AnyFlatSpec with Matchers with SecureRandomBui val getBlockHeaders = ETH62.GetBlockHeaders(Left(1), 1, 1, false) val getBlockHeadersBytes: Array[Byte] = getBlockHeaders.toBytes - assertThrows[RuntimeException] { - decode(Codes.GetBlockHeadersCode, getBlockHeadersBytes, ProtocolVersions.ETH61) - } - decode(Codes.GetBlockHeadersCode, getBlockHeadersBytes, ProtocolVersions.ETH62) shouldBe getBlockHeaders - decode(Codes.GetBlockHeadersCode, getBlockHeadersBytes, ProtocolVersions.ETH63) shouldBe getBlockHeaders - decode(Codes.GetBlockHeadersCode, getBlockHeadersBytes, ProtocolVersions.ETC64) shouldBe getBlockHeaders + decode(ProtocolVersions.ETH63).fromBytes(Codes.GetBlockHeadersCode, getBlockHeadersBytes) shouldBe getBlockHeaders + decode(ProtocolVersions.ETC64).fromBytes(Codes.GetBlockHeadersCode, getBlockHeadersBytes) shouldBe getBlockHeaders } it should "decode BlockHeaders message for all supported versions of protocol" in { val blockHeaders = ETH62.BlockHeaders(ObjectGenerators.seqBlockHeaderGen.sample.get) val blockHeadersBytes: Array[Byte] = blockHeaders.toBytes - assertThrows[RuntimeException] { - decode(Codes.BlockHeadersCode, blockHeadersBytes, ProtocolVersions.ETH61) - } - decode(Codes.BlockHeadersCode, blockHeadersBytes, ProtocolVersions.ETH62) shouldBe blockHeaders - decode(Codes.BlockHeadersCode, blockHeadersBytes, ProtocolVersions.ETH63) shouldBe blockHeaders - decode(Codes.BlockHeadersCode, blockHeadersBytes, ProtocolVersions.ETC64) shouldBe blockHeaders + decode(ProtocolVersions.ETH63).fromBytes(Codes.BlockHeadersCode, blockHeadersBytes) shouldBe blockHeaders + decode(ProtocolVersions.ETC64).fromBytes(Codes.BlockHeadersCode, blockHeadersBytes) shouldBe blockHeaders } it should "decode GetBlockBodies message for all supported versions of protocol" in { val getBlockBodies = ETH62.GetBlockBodies(Seq(exampleHash)) val getBlockBodiesBytes: Array[Byte] = getBlockBodies.toBytes - assertThrows[RuntimeException] { - decode(Codes.GetBlockBodiesCode, getBlockBodiesBytes, ProtocolVersions.ETH61) - } - decode(Codes.GetBlockBodiesCode, getBlockBodiesBytes, ProtocolVersions.ETH62) shouldBe getBlockBodies - decode(Codes.GetBlockBodiesCode, getBlockBodiesBytes, ProtocolVersions.ETH63) shouldBe getBlockBodies - decode(Codes.GetBlockBodiesCode, getBlockBodiesBytes, ProtocolVersions.ETC64) shouldBe getBlockBodies + decode(ProtocolVersions.ETH63).fromBytes(Codes.GetBlockBodiesCode, getBlockBodiesBytes) shouldBe getBlockBodies + decode(ProtocolVersions.ETC64).fromBytes(Codes.GetBlockBodiesCode, getBlockBodiesBytes) shouldBe getBlockBodies } it should "decode BlockBodies message for all supported versions of protocol" in { val blockBodies = ETH62.BlockBodies(Seq(Fixtures.Blocks.Block3125369.body, Fixtures.Blocks.DaoForkBlock.body)) val blockBodiesBytes: Array[Byte] = blockBodies.toBytes - assertThrows[RuntimeException] { - decode(Codes.BlockBodiesCode, blockBodiesBytes, ProtocolVersions.ETH61) - } - decode(Codes.BlockBodiesCode, blockBodiesBytes, ProtocolVersions.ETH62) shouldBe blockBodies - decode(Codes.BlockBodiesCode, blockBodiesBytes, ProtocolVersions.ETH63) shouldBe blockBodies - decode(Codes.BlockBodiesCode, blockBodiesBytes, ProtocolVersions.ETC64) shouldBe blockBodies + decode(ProtocolVersions.ETH63).fromBytes(Codes.BlockBodiesCode, blockBodiesBytes) shouldBe blockBodies + decode(ProtocolVersions.ETC64).fromBytes(Codes.BlockBodiesCode, blockBodiesBytes) shouldBe blockBodies } it should "decode GetNodeData message for all supported versions of protocol" in { val getNodeData = ETH63.GetNodeData(Seq(exampleHash)) val getNodeDataBytes: Array[Byte] = getNodeData.toBytes - assertThrows[RuntimeException] { - decode(Codes.GetNodeDataCode, getNodeDataBytes, ProtocolVersions.ETH61) - } - assertThrows[RuntimeException] { - decode(Codes.GetNodeDataCode, getNodeDataBytes, ProtocolVersions.ETH62) - } - decode(Codes.GetNodeDataCode, getNodeDataBytes, ProtocolVersions.ETH63) shouldBe getNodeData - decode(Codes.GetNodeDataCode, getNodeDataBytes, ProtocolVersions.ETC64) shouldBe getNodeData + decode(ProtocolVersions.ETH63).fromBytes(Codes.GetNodeDataCode, getNodeDataBytes) shouldBe getNodeData + decode(ProtocolVersions.ETC64).fromBytes(Codes.GetNodeDataCode, getNodeDataBytes) shouldBe getNodeData } it should "decode NodeData message for all supported versions of protocol" in { val nodeData = ETH63.NodeData(Seq(exampleHash)) val nodeDataBytes: Array[Byte] = nodeData.toBytes - assertThrows[RuntimeException] { - decode(Codes.NodeDataCode, nodeDataBytes, ProtocolVersions.ETH61) - } - assertThrows[RuntimeException] { - decode(Codes.NodeDataCode, nodeDataBytes, ProtocolVersions.ETH62) - } - decode(Codes.NodeDataCode, nodeDataBytes, ProtocolVersions.ETH63) shouldBe nodeData - decode(Codes.NodeDataCode, nodeDataBytes, ProtocolVersions.ETC64) shouldBe nodeData + decode(ProtocolVersions.ETH63).fromBytes(Codes.NodeDataCode, nodeDataBytes) shouldBe nodeData + decode(ProtocolVersions.ETC64).fromBytes(Codes.NodeDataCode, nodeDataBytes) shouldBe nodeData } it should "decode GetReceipts message for all supported versions of protocol" in { val getReceipts = ETH63.GetReceipts(Seq(exampleHash)) val getReceiptsBytes: Array[Byte] = getReceipts.toBytes - assertThrows[RuntimeException] { - decode(Codes.GetReceiptsCode, getReceiptsBytes, ProtocolVersions.ETH61) - } - assertThrows[RuntimeException] { - decode(Codes.GetReceiptsCode, getReceiptsBytes, ProtocolVersions.ETH62) - } - decode(Codes.GetReceiptsCode, getReceiptsBytes, ProtocolVersions.ETH63) shouldBe getReceipts - decode(Codes.GetReceiptsCode, getReceiptsBytes, ProtocolVersions.ETC64) shouldBe getReceipts + decode(ProtocolVersions.ETH63).fromBytes(Codes.GetReceiptsCode, getReceiptsBytes) shouldBe getReceipts + decode(ProtocolVersions.ETC64).fromBytes(Codes.GetReceiptsCode, getReceiptsBytes) shouldBe getReceipts } it should "decode Receipts message for all supported versions of protocol" in { val receipts = ETH63.Receipts(ObjectGenerators.receiptsGen(3).sample.get) val receiptsBytes: Array[Byte] = receipts.toBytes - assertThrows[RuntimeException] { - decode(Codes.ReceiptsCode, receiptsBytes, ProtocolVersions.ETH61) - } - assertThrows[RuntimeException] { - decode(Codes.ReceiptsCode, receiptsBytes, ProtocolVersions.ETH62) - } - decode(Codes.ReceiptsCode, receiptsBytes, ProtocolVersions.ETH63) shouldBe receipts - decode(Codes.ReceiptsCode, receiptsBytes, ProtocolVersions.ETC64) shouldBe receipts + decode(ProtocolVersions.ETH63).fromBytes(Codes.ReceiptsCode, receiptsBytes) shouldBe receipts + decode(ProtocolVersions.ETC64).fromBytes(Codes.ReceiptsCode, receiptsBytes) shouldBe receipts } it should "decode Status message for all supported versions of protocol" in { @@ -185,11 +137,8 @@ class MessageDecodersSpec extends AnyFlatSpec with Matchers with SecureRandomBui val status63Bytes: Array[Byte] = status63.toBytes val status64 = ETC64.Status(ProtocolVersions.ETH63.version, 1, ChainWeight(1, BigInt(100)), exampleHash, exampleHash) - // it's not 100 % true as Status message was different in ETH61, but we are not supporting old message - decode(Codes.StatusCode, status63Bytes, ProtocolVersions.ETH61) shouldBe status63 - decode(Codes.StatusCode, status63Bytes, ProtocolVersions.ETH62) shouldBe status63 - decode(Codes.StatusCode, status63Bytes, ProtocolVersions.ETH63) shouldBe status63 - decode(Codes.StatusCode, status64.toBytes, ProtocolVersions.ETC64) shouldBe status64 + decode(ProtocolVersions.ETH63).fromBytes(Codes.StatusCode, status63Bytes) shouldBe status63 + decode(ProtocolVersions.ETC64).fromBytes(Codes.StatusCode, status64.toBytes) shouldBe status64 } it should "decode NewBlock message for all supported versions of protocol" in { @@ -197,31 +146,27 @@ class MessageDecodersSpec extends AnyFlatSpec with Matchers with SecureRandomBui val newBlock63Bytes: Array[Byte] = newBlock63.toBytes val newBlock64 = ObjectGenerators.newBlock64Gen(secureRandom, None).sample.get - decode(Codes.NewBlockCode, newBlock63Bytes, ProtocolVersions.ETH61) shouldBe newBlock63 - decode(Codes.NewBlockCode, newBlock63Bytes, ProtocolVersions.ETH62) shouldBe newBlock63 - decode(Codes.NewBlockCode, newBlock63Bytes, ProtocolVersions.ETH63) shouldBe newBlock63 - decode(Codes.NewBlockCode, newBlock64.toBytes, ProtocolVersions.ETC64) shouldBe newBlock64 + decode(ProtocolVersions.ETH63).fromBytes(Codes.NewBlockCode, newBlock63Bytes) shouldBe newBlock63 + decode(ProtocolVersions.ETC64).fromBytes(Codes.NewBlockCode, newBlock64.toBytes) shouldBe newBlock64 } it should "decode SignedTransactions message for all supported versions of protocol" in { val signedTransactions = SignedTransactions(ObjectGenerators.signedTxSeqGen(3, secureRandom, None).sample.get) val signedTransactionsBytes: Array[Byte] = signedTransactions.toBytes - decode(Codes.SignedTransactionsCode, signedTransactionsBytes, ProtocolVersions.ETH61) shouldBe signedTransactions - decode(Codes.SignedTransactionsCode, signedTransactionsBytes, ProtocolVersions.ETH62) shouldBe signedTransactions - decode(Codes.SignedTransactionsCode, signedTransactionsBytes, ProtocolVersions.ETH63) shouldBe signedTransactions - decode(Codes.SignedTransactionsCode, signedTransactionsBytes, ProtocolVersions.ETC64) shouldBe signedTransactions + decode(ProtocolVersions.ETH63).fromBytes(Codes.SignedTransactionsCode, signedTransactionsBytes) shouldBe signedTransactions + decode(ProtocolVersions.ETC64).fromBytes(Codes.SignedTransactionsCode, signedTransactionsBytes) shouldBe signedTransactions } it should "not decode message not existing in given protocol" in { assertThrows[RuntimeException] { - decode(Codes.SignedTransactionsCode, blockHashesFromNumberBytes, ProtocolVersions.ETH62) + decode(ProtocolVersions.ETH63).fromBytes(Codes.SignedTransactionsCode, blockHashesFromNumberBytes) } } it should "not decode message of not supported protocol" in { assertThrows[RuntimeException] { - decode(Codes.NewBlockHashesCode, NewBlockHashesETH61bytes, ProtocolVersions.ETH61.copy(version = 60)) + decode(ProtocolVersions.ETH61).fromBytes(Codes.NewBlockHashesCode, NewBlockHashesETH61bytes) } } } diff --git a/src/test/scala/io/iohk/ethereum/network/p2p/messages/MessagesSerializationSpec.scala b/src/test/scala/io/iohk/ethereum/network/p2p/messages/MessagesSerializationSpec.scala index bbe8a179b4..fa98ad00c3 100644 --- a/src/test/scala/io/iohk/ethereum/network/p2p/messages/MessagesSerializationSpec.scala +++ b/src/test/scala/io/iohk/ethereum/network/p2p/messages/MessagesSerializationSpec.scala @@ -91,12 +91,14 @@ class MessagesSerializationSpec extends AnyWordSpec with ScalaCheckPropertyCheck } } - "ETH61" when { - val version = ProtocolVersions.ETH61 + "support ETH61 messages as ETH63" when { + val version = ProtocolVersions.ETH63 "encoding and decoding NewBlockHashes" should { - "return same result" in { + "throw for unsupported message version" in { val msg = ETH61.NewBlockHashes(Seq(ByteString("23"), ByteString("10"), ByteString("36"))) - verify(msg, (m: ETH61.NewBlockHashes) => m.toBytes, Codes.NewBlockHashesCode, version) + assertThrows[RuntimeException] { + verify(msg, (m: ETH61.NewBlockHashes) => m.toBytes, Codes.NewBlockHashesCode, version) + } } } @@ -108,8 +110,8 @@ class MessagesSerializationSpec extends AnyWordSpec with ScalaCheckPropertyCheck } } - "ETH62" when { - val version = ProtocolVersions.ETH62 + "support ETH62 messages as ETH63" when { + val version = ProtocolVersions.ETH63 "encoding and decoding NewBlockHashes" should { "return same result" in { val msg = ETH62.NewBlockHashes(Seq(BlockHash(ByteString("hash1"), 1), BlockHash(ByteString("hash2"), 2))) @@ -156,9 +158,8 @@ class MessagesSerializationSpec extends AnyWordSpec with ScalaCheckPropertyCheck } } - val messageDecoder = NetworkMessageDecoder orElse EthereumMessageDecoder - def verify[T](msg: T, encode: T => Array[Byte], code: Int, version: Capability): Unit = - messageDecoder.fromBytes(code, encode(msg), version) shouldEqual msg + messageDecoder(version).fromBytes(code, encode(msg)) shouldEqual msg + private def messageDecoder(version: Capability) = NetworkMessageDecoder orElse EthereumMessageDecoder.ethMessageDecoder(version) } diff --git a/src/test/scala/io/iohk/ethereum/network/p2p/messages/NodeDataSpec.scala b/src/test/scala/io/iohk/ethereum/network/p2p/messages/NodeDataSpec.scala index 60d89b9042..6be89cc98c 100644 --- a/src/test/scala/io/iohk/ethereum/network/p2p/messages/NodeDataSpec.scala +++ b/src/test/scala/io/iohk/ethereum/network/p2p/messages/NodeDataSpec.scala @@ -79,7 +79,7 @@ class NodeDataSpec extends AnyFlatSpec with Matchers { } it should "be decoded properly" in { - val result = EthereumMessageDecoder.fromBytes(Codes.NodeDataCode, encode(encodedNodeData), ProtocolVersions.ETH63) + val result = EthereumMessageDecoder.ethMessageDecoder(ProtocolVersions.ETH63).fromBytes(Codes.NodeDataCode, encode(encodedNodeData)) result match { case m: NodeData => @@ -93,7 +93,7 @@ class NodeDataSpec extends AnyFlatSpec with Matchers { } it should "be decoded previously encoded value" in { - EthereumMessageDecoder.fromBytes(Codes.NodeDataCode, nodeData.toBytes, ProtocolVersions.ETH63) shouldBe nodeData + EthereumMessageDecoder.ethMessageDecoder(ProtocolVersions.ETH63).fromBytes(Codes.NodeDataCode, nodeData.toBytes) shouldBe nodeData } it should "decode branch node with values in leafs that looks like RLP list" in { diff --git a/src/test/scala/io/iohk/ethereum/network/p2p/messages/ReceiptsSpec.scala b/src/test/scala/io/iohk/ethereum/network/p2p/messages/ReceiptsSpec.scala index da9e819b85..f4456b9ae3 100644 --- a/src/test/scala/io/iohk/ethereum/network/p2p/messages/ReceiptsSpec.scala +++ b/src/test/scala/io/iohk/ethereum/network/p2p/messages/ReceiptsSpec.scala @@ -51,14 +51,13 @@ class ReceiptsSpec extends AnyFlatSpec with Matchers { } it should "decode receipts" in { - EthereumMessageDecoder.fromBytes( + EthereumMessageDecoder.ethMessageDecoder(ProtocolVersions.ETH63).fromBytes( Codes.ReceiptsCode, - encode(encodedReceipts), - ProtocolVersions.ETH63 + encode(encodedReceipts) ) shouldBe receipts } it should "decode encoded receipts" in { - EthereumMessageDecoder.fromBytes(Codes.ReceiptsCode, receipts.toBytes, ProtocolVersions.ETH63) shouldBe receipts + EthereumMessageDecoder.ethMessageDecoder(ProtocolVersions.ETH63).fromBytes(Codes.ReceiptsCode, receipts.toBytes) shouldBe receipts } } diff --git a/src/test/scala/io/iohk/ethereum/network/rlpx/RLPxConnectionHandlerSpec.scala b/src/test/scala/io/iohk/ethereum/network/rlpx/RLPxConnectionHandlerSpec.scala index 127661d6f3..e664790e7a 100644 --- a/src/test/scala/io/iohk/ethereum/network/rlpx/RLPxConnectionHandlerSpec.scala +++ b/src/test/scala/io/iohk/ethereum/network/rlpx/RLPxConnectionHandlerSpec.scala @@ -10,7 +10,7 @@ import io.iohk.ethereum.{Timeouts, WithActorSystemShutDown} import io.iohk.ethereum.network.p2p.{MessageDecoder, MessageSerializable} import io.iohk.ethereum.network.p2p.messages.{Capability, ProtocolVersions} import io.iohk.ethereum.network.p2p.messages.WireProtocol.{Hello, Ping} -import io.iohk.ethereum.network.rlpx.RLPxConnectionHandler.{HelloExtractor, InitialHelloReceived, MessageReceived, RLPxConfiguration} +import io.iohk.ethereum.network.rlpx.RLPxConnectionHandler.{HelloCodec, InitialHelloReceived, MessageReceived, RLPxConfiguration} import io.iohk.ethereum.security.SecureRandomBuilder import org.scalamock.scalatest.MockFactory @@ -176,14 +176,14 @@ class RLPxConnectionHandlerSpec //Mock parameters for RLPxConnectionHandler val mockMessageDecoder = new MessageDecoder { - override def fromBytes(`type`: Int, payload: Array[Byte], protocolVersion: Capability) = + override def fromBytes(`type`: Int, payload: Array[Byte]) = throw new Exception("Mock message decoder fails to decode all messages") } val protocolVersion = ProtocolVersions.ETH63 val mockHandshaker = mock[AuthHandshaker] val connection = TestProbe() val mockMessageCodec = mock[MessageCodec] - val mockHelloExtractor: HelloExtractor = mock[HelloExtractor] + val mockHelloExtractor: HelloCodec = mock[HelloCodec] val uri = new URI( "enode://18a551bee469c2e02de660ab01dede06503c986f6b8520cb5a65ad122df88b17b285e3fef09a40a0d44f99e014f8616cf1ebc2e094f96c6e09e2f390f5d34857@47.90.36.129:30303" @@ -202,10 +202,9 @@ class RLPxConnectionHandlerSpec val rlpxConnection = TestActorRef( Props( new RLPxConnectionHandler( - mockMessageDecoder, protocolVersion:: Nil, mockHandshaker, - (_, _, _, _) => mockMessageCodec, + (_, _, _) => mockMessageCodec, rlpxConfiguration, _ => mockHelloExtractor ) { From 61f471cce61a42509011a494de694aef39c17eab Mon Sep 17 00:00:00 2001 From: Dominik Zajkowski Date: Wed, 16 Jun 2021 10:32:46 +0200 Subject: [PATCH 2/2] [ETCM-842] Apply PR remarks --- .../io/iohk/ethereum/network/p2p/MessageDecoders.scala | 6 +++--- .../scala/io/iohk/ethereum/nodebuilder/NodeBuilder.scala | 1 - .../network/p2p/messages/MessagesSerializationSpec.scala | 9 +++------ 3 files changed, 6 insertions(+), 10 deletions(-) diff --git a/src/main/scala/io/iohk/ethereum/network/p2p/MessageDecoders.scala b/src/main/scala/io/iohk/ethereum/network/p2p/MessageDecoders.scala index f7654b8ec0..763c68c0ff 100644 --- a/src/main/scala/io/iohk/ethereum/network/p2p/MessageDecoders.scala +++ b/src/main/scala/io/iohk/ethereum/network/p2p/MessageDecoders.scala @@ -27,7 +27,7 @@ object NetworkMessageDecoder extends MessageDecoder { case Ping.code => payload.toPing case Pong.code => payload.toPong case Hello.code => payload.toHello - case _ => throw new RuntimeException(s"Unknown message type: ${msgCode}") + case _ => throw new RuntimeException(s"Unknown message type: $msgCode") } } @@ -51,7 +51,7 @@ object ETC64MessageDecoder extends MessageDecoder { case Codes.BlockBodiesCode => payload.toBlockBodies case Codes.BlockHashesFromNumberCode => payload.toBlockHashesFromNumber case Codes.SignedTransactionsCode => payload.toSignedTransactions - case _ => throw new RuntimeException(s"Unknown message type: ${msgCode}") + case _ => throw new RuntimeException(s"Unknown message type: $msgCode") } } } @@ -75,7 +75,7 @@ object ETH63MessageDecoder extends MessageDecoder { case Codes.StatusCode => payload.toStatus case Codes.NewBlockCode => payload.toNewBlock case Codes.SignedTransactionsCode => payload.toSignedTransactions - case _ => throw new RuntimeException(s"Unknown message type: ${msgCode}") + case _ => throw new RuntimeException(s"Unknown message type: $msgCode") } } } diff --git a/src/main/scala/io/iohk/ethereum/nodebuilder/NodeBuilder.scala b/src/main/scala/io/iohk/ethereum/nodebuilder/NodeBuilder.scala index 7c1c014058..1a08b4ead3 100644 --- a/src/main/scala/io/iohk/ethereum/nodebuilder/NodeBuilder.scala +++ b/src/main/scala/io/iohk/ethereum/nodebuilder/NodeBuilder.scala @@ -24,7 +24,6 @@ import io.iohk.ethereum.network.EtcPeerManagerActor.PeerInfo import io.iohk.ethereum.network.PeerManagerActor.PeerConfiguration import io.iohk.ethereum.network.discovery.{DiscoveryConfig, DiscoveryServiceBuilder, PeerDiscoveryManager} import io.iohk.ethereum.network.handshaker.{EtcHandshaker, EtcHandshakerConfiguration, Handshaker} -import io.iohk.ethereum.network.p2p.{EthereumMessageDecoder, NetworkMessageDecoder} import io.iohk.ethereum.network.rlpx.AuthHandshaker import io.iohk.ethereum.network.{PeerManagerActor, ServerActor, _} import io.iohk.ethereum.ommers.OmmersPool diff --git a/src/test/scala/io/iohk/ethereum/network/p2p/messages/MessagesSerializationSpec.scala b/src/test/scala/io/iohk/ethereum/network/p2p/messages/MessagesSerializationSpec.scala index fa98ad00c3..96e0346ca6 100644 --- a/src/test/scala/io/iohk/ethereum/network/p2p/messages/MessagesSerializationSpec.scala +++ b/src/test/scala/io/iohk/ethereum/network/p2p/messages/MessagesSerializationSpec.scala @@ -91,9 +91,9 @@ class MessagesSerializationSpec extends AnyWordSpec with ScalaCheckPropertyCheck } } - "support ETH61 messages as ETH63" when { + "ETH63" when { val version = ProtocolVersions.ETH63 - "encoding and decoding NewBlockHashes" should { + "encoding and decoding ETH61.NewBlockHashes" should { "throw for unsupported message version" in { val msg = ETH61.NewBlockHashes(Seq(ByteString("23"), ByteString("10"), ByteString("36"))) assertThrows[RuntimeException] { @@ -108,11 +108,8 @@ class MessagesSerializationSpec extends AnyWordSpec with ScalaCheckPropertyCheck verify(msg, (m: BlockHashesFromNumber) => m.toBytes, Codes.BlockHashesFromNumberCode, version) } } - } - "support ETH62 messages as ETH63" when { - val version = ProtocolVersions.ETH63 - "encoding and decoding NewBlockHashes" should { + "encoding and decoding ETH62.NewBlockHashes" should { "return same result" in { val msg = ETH62.NewBlockHashes(Seq(BlockHash(ByteString("hash1"), 1), BlockHash(ByteString("hash2"), 2))) verify(msg, (m: ETH62.NewBlockHashes) => m.toBytes, Codes.NewBlockHashesCode, version)