public void Roundtrip_hash() { GetBlockHeadersMessage message = new GetBlockHeadersMessage(); message.MaxHeaders = 1; message.Skip = 2; message.Reverse = 1; message.StartingBlockHash = Keccak.OfAnEmptyString; GetBlockHeadersMessageSerializer serializer = new GetBlockHeadersMessageSerializer(); byte[] bytes = serializer.Serialize(message); byte[] expectedBytes = Bytes.FromHexString("e4a0c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470010201"); Assert.True(Bytes.AreEqual(bytes, expectedBytes), "bytes"); GetBlockHeadersMessage deserialized = serializer.Deserialize(bytes); Assert.AreEqual(message.StartingBlockHash, deserialized.StartingBlockHash, $"{nameof(message.StartingBlockHash)}"); Assert.AreEqual(message.MaxHeaders, deserialized.MaxHeaders, $"{nameof(message.MaxHeaders)}"); Assert.AreEqual(message.Reverse, deserialized.Reverse, $"{nameof(message.Reverse)}"); Assert.AreEqual(message.Skip, deserialized.Skip, $"{nameof(message.Skip)}"); SerializerTester.Test(serializer, message); SerializerTester.TestZero(serializer, message); }
public void Get_headers_from_genesis() { var svc = Build.A.SerializationService().WithEth().TestObject; var session = Substitute.For <IP2PSession>(); var syncManager = Substitute.For <ISynchronizationManager>(); var blockTree = Substitute.For <IBlockTree>(); var transactionPool = Substitute.For <ITransactionPool>(); var timestamp = Substitute.For <ITimestamp>(); Block genesisBlock = Build.A.Block.Genesis.TestObject; syncManager.Head.Returns(genesisBlock.Header); syncManager.Genesis.Returns(genesisBlock.Header); var handler = new Eth62ProtocolHandler(session, svc, syncManager, LimboLogs.Instance, new PerfService(LimboLogs.Instance), blockTree, transactionPool, timestamp); handler.Init(); var msg = new GetBlockHeadersMessage(); msg.StartingBlockHash = TestObject.KeccakA; msg.MaxHeaders = 3; msg.Skip = 1; msg.Reverse = 1; var statusMsg = new StatusMessage(); statusMsg.GenesisHash = genesisBlock.Hash; handler.HandleMessage(new Packet(Protocol.Eth, statusMsg.PacketType, svc.Serialize(statusMsg))); handler.HandleMessage(new Packet(Protocol.Eth, msg.PacketType, svc.Serialize(msg))); syncManager.Received().Find(TestObject.KeccakA, 3, 1, true); }
public void Get_headers_when_blocks_are_missing_in_the_middle() { var headers = new BlockHeader[5]; headers[0] = Build.A.BlockHeader.TestObject; headers[1] = Build.A.BlockHeader.TestObject; headers[2] = null; headers[3] = Build.A.BlockHeader.TestObject; headers[4] = Build.A.BlockHeader.TestObject; _syncManager.FindHash(100).Returns(TestItem.KeccakA); _syncManager.FindHeaders(TestItem.KeccakA, 5, 1, true) .Returns(headers); _syncManager.Head.Returns(_genesisBlock.Header); _syncManager.Genesis.Returns(_genesisBlock.Header); var msg = new GetBlockHeadersMessage(); msg.StartBlockNumber = 100; msg.MaxHeaders = 5; msg.Skip = 1; msg.Reverse = 1; HandleIncomingStatusMessage(); HandleZeroMessage(msg, Eth62MessageCode.GetBlockHeaders); _session.Received().DeliverMessage(Arg.Is <BlockHeadersMessage>(bhm => bhm.BlockHeaders.Length == 5)); _syncManager.Received().FindHash(100); }
public void Roundtrip_zero() { GetBlockHeadersMessage message = new GetBlockHeadersMessage(); message.MaxHeaders = 1; message.Skip = 2; message.Reverse = 0; message.StartingBlockNumber = 100; GetBlockHeadersMessageSerializer serializer = new GetBlockHeadersMessageSerializer(); byte[] bytes = serializer.Serialize(message); byte[] expectedBytes = Bytes.FromHexString("c464010280"); Assert.AreEqual(expectedBytes, bytes, "bytes"); GetBlockHeadersMessage deserialized = serializer.Deserialize(bytes); Assert.AreEqual(message.StartingBlockNumber, deserialized.StartingBlockNumber, $"{nameof(message.StartingBlockNumber)}"); Assert.AreEqual(message.MaxHeaders, deserialized.MaxHeaders, $"{nameof(message.MaxHeaders)}"); Assert.AreEqual(message.Reverse, deserialized.Reverse, $"{nameof(message.Reverse)}"); Assert.AreEqual(message.Skip, deserialized.Skip, $"{nameof(message.Skip)}"); SerializerTester.Test(serializer, message); SerializerTester.TestZero(serializer, message); }
public void Get_headers_when_blocks_are_missing() { var svc = Build.A.SerializationService().WithEth().TestObject; var session = Substitute.For <IP2PSession>(); var syncManager = Substitute.For <ISynchronizationManager>(); var blockTree = Substitute.For <IBlockTree>(); var transactionPool = Substitute.For <ITransactionPool>(); var timestamp = Substitute.For <ITimestamp>(); syncManager.Find(null, Arg.Any <int>(), Arg.Any <int>(), Arg.Any <bool>()).Throws(new ArgumentNullException()); Block genesisBlock = Build.A.Block.Genesis.TestObject; syncManager.Head.Returns(genesisBlock.Header); syncManager.Genesis.Returns(genesisBlock.Header); var handler = new Eth62ProtocolHandler(session, svc, syncManager, LimboLogs.Instance, new PerfService(LimboLogs.Instance), blockTree, transactionPool, timestamp); handler.Init(); var msg = new GetBlockHeadersMessage(); msg.StartingBlockNumber = 1920000; msg.MaxHeaders = 3; msg.Skip = 1; msg.Reverse = 1; var statusMsg = new StatusMessage(); statusMsg.GenesisHash = genesisBlock.Hash; handler.HandleMessage(new Packet(Protocol.Eth, statusMsg.PacketType, svc.Serialize(statusMsg))); handler.HandleMessage(new Packet(Protocol.Eth, msg.PacketType, svc.Serialize(msg))); syncManager.Received().Find(1920000); }
async Task <BlockHeader> ISyncPeer.GetHeadBlockHeader(Keccak hash, CancellationToken token) { GetBlockHeadersMessage msg = new GetBlockHeadersMessage(); msg.StartingBlockHash = hash ?? _remoteHeadBlockHash; msg.MaxHeaders = 1; msg.Reverse = 0; msg.Skip = 0; BlockHeader[] headers = await SendRequest(msg, token); return(headers.Length > 0 ? headers[0] : null); }
private async Task <BlockHeader[]> SendRequest(GetBlockHeadersMessage message, CancellationToken token) { if (_headersRequests.IsAddingCompleted || _isDisposed) { throw new TimeoutException("Session disposed"); } if (Logger.IsTrace) { Logger.Trace($"Sending headers request to {Session.Node:c}:"); Logger.Trace($" Starting blockhash: {message.StartingBlockHash}"); Logger.Trace($" Starting number: {message.StartingBlockNumber}"); Logger.Trace($" Skip: {message.Skip}"); Logger.Trace($" Reverse: {message.Reverse}"); Logger.Trace($" Max headers: {message.MaxHeaders}"); } Request <GetBlockHeadersMessage, BlockHeader[]> request = new Request <GetBlockHeadersMessage, BlockHeader[]>(message); _headersRequests.Add(request, token); request.StartMeasuringTime(); Send(request.Message); Task <BlockHeader[]> task = request.CompletionSource.Task; using CancellationTokenSource delayCancellation = new CancellationTokenSource(); using CancellationTokenSource compositeCancellation = CancellationTokenSource.CreateLinkedTokenSource(token, delayCancellation.Token); Task firstTask = await Task.WhenAny(task, Task.Delay(Timeouts.Eth, compositeCancellation.Token)); if (firstTask.IsCanceled) { token.ThrowIfCancellationRequested(); } if (firstTask == task) { delayCancellation.Cancel(); long elapsed = request.FinishMeasuringTime(); long bytesPerMillisecond = (long)((decimal)request.ResponseSize / Math.Max(1, elapsed)); if (Logger.IsTrace) { Logger.Trace($"{this} speed is {request.ResponseSize}/{elapsed} = {bytesPerMillisecond}"); } StatsManager.ReportTransferSpeedEvent(Session.Node, TransferSpeedType.Headers, bytesPerMillisecond); return(task.Result); } StatsManager.ReportTransferSpeedEvent(Session.Node, TransferSpeedType.Headers, 0); throw new TimeoutException($"{Session} Request timeout in {nameof(GetBlockHeadersMessage)} with {message.MaxHeaders} max headers"); }
public void Get_headers_from_genesis() { var svc = Build.A.SerializationService().WithEth().TestObject; var session = Substitute.For <ISession>(); var syncManager = Substitute.For <ISyncServer>(); var transactionPool = Substitute.For <ITxPool>(); Block genesisBlock = Build.A.Block.Genesis.TestObject; syncManager.Head.Returns(genesisBlock.Header); syncManager.Genesis.Returns(genesisBlock.Header); var handler = new Eth62ProtocolHandler( session, svc, new NodeStatsManager(new StatsConfig(), LimboLogs.Instance), syncManager, LimboLogs.Instance, transactionPool); handler.Init(); var msg = new GetBlockHeadersMessage(); msg.StartingBlockHash = TestItem.KeccakA; msg.MaxHeaders = 3; msg.Skip = 1; msg.Reverse = 1; var statusMsg = new StatusMessage(); statusMsg.GenesisHash = genesisBlock.Hash; IByteBuffer statusPacket = svc.ZeroSerialize(statusMsg); statusPacket.ReadByte(); IByteBuffer getBlockHeadersPacket = svc.ZeroSerialize(msg); getBlockHeadersPacket.ReadByte(); handler.HandleMessage(new ZeroPacket(statusPacket) { PacketType = 0 }); handler.HandleMessage(new ZeroPacket(getBlockHeadersPacket) { PacketType = Eth62MessageCode.GetBlockHeaders }); syncManager.Received().FindHeaders(TestItem.KeccakA, 3, 1, true); }
public void Get_headers_when_blocks_are_missing_in_the_middle() { var svc = Build.A.SerializationService().WithEth().TestObject; var headers = new BlockHeader[5]; headers[0] = Build.A.BlockHeader.TestObject; headers[1] = Build.A.BlockHeader.TestObject; headers[2] = null; headers[3] = Build.A.BlockHeader.TestObject; headers[4] = Build.A.BlockHeader.TestObject; var session = Substitute.For <ISession>(); var syncManager = Substitute.For <ISyncServer>(); var transactionPool = Substitute.For <ITxPool>(); syncManager.FindHash(1920000).Returns(TestItem.KeccakA); syncManager.FindHeaders(TestItem.KeccakA, 5, 1, true) .Returns(headers); Block genesisBlock = Build.A.Block.Genesis.TestObject; syncManager.Head.Returns(genesisBlock.Header); syncManager.Genesis.Returns(genesisBlock.Header); var handler = new Eth62ProtocolHandler( session, svc, new NodeStatsManager(new StatsConfig(), LimboLogs.Instance), syncManager, LimboLogs.Instance, new PerfService(LimboLogs.Instance), transactionPool); handler.Init(); var msg = new GetBlockHeadersMessage(); msg.StartingBlockNumber = 1920000; msg.MaxHeaders = 5; msg.Skip = 1; msg.Reverse = 1; var statusMsg = new StatusMessage(); statusMsg.GenesisHash = genesisBlock.Hash; handler.HandleMessage(new Packet(Protocol.Eth, statusMsg.PacketType, svc.Serialize(statusMsg))); handler.HandleMessage(new Packet(Protocol.Eth, msg.PacketType, svc.Serialize(msg))); session.Received().DeliverMessage(Arg.Is <BlockHeadersMessage>(bhm => bhm.BlockHeaders.Length == 5)); syncManager.Received().FindHash(1920000); }
public void Get_headers_from_genesis() { var msg = new GetBlockHeadersMessage(); msg.StartBlockHash = TestItem.KeccakA; msg.MaxHeaders = 3; msg.Skip = 1; msg.Reverse = 1; HandleIncomingStatusMessage(); HandleZeroMessage(msg, Eth62MessageCode.GetBlockHeaders); _syncManager.Received().FindHeaders(TestItem.KeccakA, 3, 1, true); }
public void RoundTripWithNumber() { var ethMessage = new Network.P2P.Subprotocols.Eth.V62.Messages.GetBlockHeadersMessage(); ethMessage.StartBlockNumber = 1; ethMessage.MaxHeaders = 10; ethMessage.Skip = 2; ethMessage.Reverse = 0; var message = new GetBlockHeadersMessage(ethMessage, 2); GetBlockHeadersMessageSerializer serializer = new(); SerializerTester.TestZero(serializer, message, "c602c4010a0280"); }
public void RoundTripWithHash() { var ethMessage = new Network.P2P.Subprotocols.Eth.V62.Messages.GetBlockHeadersMessage(); ethMessage.StartBlockHash = Keccak.Compute("1"); ethMessage.MaxHeaders = 10; ethMessage.Skip = 2; ethMessage.Reverse = 0; var message = new GetBlockHeadersMessage(ethMessage, 2); GetBlockHeadersMessageSerializer serializer = new(); SerializerTester.TestZero(serializer, message, "e602e4a0c89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc60a0280"); }
public void RoundTrip_hash() { var ethMessage = new Network.P2P.Subprotocols.Eth.V62.Messages.GetBlockHeadersMessage { StartBlockHash = new Keccak("0x00000000000000000000000000000000000000000000000000000000deadc0de"), StartBlockNumber = 0, MaxHeaders = 5, Skip = 5, Reverse = 0 }; var message = new GetBlockHeadersMessage(1111, ethMessage); GetBlockHeadersMessageSerializer serializer = new(); SerializerTester.TestZero(serializer, message, "e8820457e4a000000000000000000000000000000000000000000000000000000000deadc0de050580"); }
public void Roundtrip_hash() { GetBlockHeadersMessage message = new GetBlockHeadersMessage(); message.MaxHeaders = 1; message.Skip = 2; message.Reverse = 1; message.StartingBlockNumber = 100; GetBlockHeadersMessageSerializer serializer = new GetBlockHeadersMessageSerializer(); byte[] bytes = serializer.Serialize(message); GetBlockHeadersMessage deserialized = serializer.Deserialize(bytes); Assert.AreEqual(message.StartingBlockNumber, deserialized.StartingBlockNumber, $"{nameof(message.StartingBlockNumber)}"); Assert.AreEqual(message.MaxHeaders, deserialized.MaxHeaders, $"{nameof(message.MaxHeaders)}"); Assert.AreEqual(message.Reverse, deserialized.Reverse, $"{nameof(message.Reverse)}"); Assert.AreEqual(message.Skip, deserialized.Skip, $"{nameof(message.Skip)}"); }
public void RoundTrip_number() { var ethMessage = new Network.P2P.Subprotocols.Eth.V62.Messages.GetBlockHeadersMessage { StartBlockHash = null, StartBlockNumber = 9999, MaxHeaders = 5, Skip = 5, Reverse = 0 }; var message = new GetBlockHeadersMessage(1111, ethMessage); GetBlockHeadersMessageSerializer serializer = new(); SerializerTester.TestZero(serializer, message, "ca820457c682270f050580"); }
async Task <BlockHeader[]> ISyncPeer.GetBlockHeaders(Keccak blockHash, int maxBlocks, int skip, CancellationToken token) { if (maxBlocks == 0) { return(new BlockHeader[0]); } GetBlockHeadersMessage msg = new GetBlockHeadersMessage(); msg.MaxHeaders = maxBlocks; msg.Reverse = 0; msg.Skip = skip; msg.StartingBlockHash = blockHash; BlockHeader[] headers = await SendRequest(msg, token); return(headers); }
async Task <BlockHeader[]> ISyncPeer.GetBlockHeaders(long number, int maxBlocks, int skip, CancellationToken token) { if (maxBlocks == 0) { return(Array.Empty <BlockHeader>()); } GetBlockHeadersMessage msg = new GetBlockHeadersMessage(); msg.MaxHeaders = maxBlocks; msg.Reverse = 0; msg.Skip = skip; msg.StartBlockNumber = number; BlockHeader[] headers = await SendRequest(msg, token); return(headers); }
public void Roundtrip_number() { GetBlockHeadersMessage message = new GetBlockHeadersMessage(); message.MaxHeaders = 1; message.Skip = 2; message.Reverse = 1; message.StartingBlockHash = Keccak.OfAnEmptyString; GetBlockHeadersMessageSerializer serializer = new GetBlockHeadersMessageSerializer(); byte[] bytes = serializer.Serialize(message); GetBlockHeadersMessage deserialized = serializer.Deserialize(bytes); Assert.AreEqual(message.StartingBlockHash, deserialized.StartingBlockHash, $"{nameof(message.StartingBlockHash)}"); Assert.AreEqual(message.MaxHeaders, deserialized.MaxHeaders, $"{nameof(message.MaxHeaders)}"); Assert.AreEqual(message.Reverse, deserialized.Reverse, $"{nameof(message.Reverse)}"); Assert.AreEqual(message.Skip, deserialized.Skip, $"{nameof(message.Skip)}"); }
public void Receiving_request_before_status_fails() { var msg = new GetBlockHeadersMessage(); msg.StartBlockHash = TestItem.KeccakA; msg.MaxHeaders = 3; msg.Skip = 1; msg.Reverse = 1; IByteBuffer packet = _svc.ZeroSerialize(msg); packet.ReadByte(); Assert.Throws <SubprotocolException>( () => _handler.HandleMessage(new ZeroPacket(packet) { PacketType = Eth62MessageCode.GetBlockHeaders })); }
public void Hardcoded_1920000_works_fine() { var svc = Build.A.SerializationService().WithEth().TestObject; var headers = new BlockHeader[5]; headers[0] = Build.A.BlockHeader.TestObject; headers[1] = Build.A.BlockHeader.TestObject; headers[2] = Build.A.BlockHeader.TestObject; var session = Substitute.For <ISession>(); var syncManager = Substitute.For <ISyncServer>(); var transactionPool = Substitute.For <ITxPool>(); Block genesisBlock = Build.A.Block.Genesis.TestObject; syncManager.Head.Returns(genesisBlock.Header); syncManager.Genesis.Returns(genesisBlock.Header); var handler = new Eth62ProtocolHandler( session, svc, new NodeStatsManager(new StatsConfig(), LimboLogs.Instance), syncManager, LimboLogs.Instance, transactionPool); handler.Init(); var msg = new GetBlockHeadersMessage(); msg.StartingBlockNumber = 1920000; msg.MaxHeaders = 1; msg.Skip = 1; msg.Reverse = 1; var statusMsg = new StatusMessage(); statusMsg.GenesisHash = genesisBlock.Hash; handler.HandleMessage(new Packet(Protocol.Eth, statusMsg.PacketType, svc.Serialize(statusMsg))); handler.HandleMessage(new Packet(Protocol.Eth, msg.PacketType, svc.Serialize(msg))); session.Received().DeliverMessage(Arg.Is <BlockHeadersMessage>(bhm => bhm.BlockHeaders.Length == 1)); }
protected BlockHeadersMessage FulfillBlockHeadersRequest(GetBlockHeadersMessage msg) { if (msg.MaxHeaders > 1024) { throw new EthSyncException("Incoming headers request for more than 1024 headers"); } Keccak startingHash = msg.StartBlockHash; if (startingHash == null) { startingHash = SyncServer.FindHash(msg.StartBlockNumber); } BlockHeader[] headers = startingHash == null ? Array.Empty <BlockHeader>() : SyncServer.FindHeaders(startingHash, (int)msg.MaxHeaders, (int)msg.Skip, msg.Reverse == 1); headers = FixHeadersForGeth(headers); return(new BlockHeadersMessage(headers)); }
protected void Handle(GetBlockHeadersMessage getBlockHeadersMessage) { Metrics.Eth62GetBlockHeadersReceived++; Stopwatch stopwatch = Stopwatch.StartNew(); if (Logger.IsTrace) { Logger.Trace($"Received headers request from {Session.Node:c}:"); Logger.Trace($" MaxHeaders: {getBlockHeadersMessage.MaxHeaders}"); Logger.Trace($" Reverse: {getBlockHeadersMessage.Reverse}"); Logger.Trace($" Skip: {getBlockHeadersMessage.Skip}"); Logger.Trace($" StartingBlockhash: {getBlockHeadersMessage.StartBlockHash}"); Logger.Trace($" StartingBlockNumber: {getBlockHeadersMessage.StartBlockNumber}"); } // // to clearly state that this client is an ETH client and not ETC (and avoid disconnections on reversed sync) // // also to improve performance as this is the most common request // if (getBlockHeadersMessage.StartingBlockNumber == 1920000 && getBlockHeadersMessage.MaxHeaders == 1) // { // // hardcoded response // // Packet packet = new Packet(ProtocolCode, Eth62MessageCode.BlockHeaders, Bytes.FromHexString("f90210f9020da0a218e2c611f21232d857e3c8cecdcdf1f65f25a4477f98f6f47e4063807f2308a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d4934794bcdfc35b86bedf72f0cda046a3c16829a2ef41d1a0c5e389416116e3696cce82ec4533cce33efccb24ce245ae9546a4b8f0d5e9a75a07701df8e07169452554d14aadd7bfa256d4a1d0355c1d174ab373e3e2d0a3743a026cf9d9422e9dd95aedc7914db690b92bab6902f5221d62694a2fa5d065f534bb90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008638c3bf2616aa831d4c008347e7c08301482084578f7aa88d64616f2d686172642d666f726ba05b5acbf4bf305f948bd7be176047b20623e1417f75597341a059729165b9239788bede87201de42426")); // // Session.DeliverMessage(packet); // LazyInitializer.EnsureInitialized(ref _eth1920000HeaderMessage, () => Deserialize<BlockHeadersMessage>(Bytes.FromHexString("f90210f9020da0a218e2c611f21232d857e3c8cecdcdf1f65f25a4477f98f6f47e4063807f2308a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d4934794bcdfc35b86bedf72f0cda046a3c16829a2ef41d1a0c5e389416116e3696cce82ec4533cce33efccb24ce245ae9546a4b8f0d5e9a75a07701df8e07169452554d14aadd7bfa256d4a1d0355c1d174ab373e3e2d0a3743a026cf9d9422e9dd95aedc7914db690b92bab6902f5221d62694a2fa5d065f534bb90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008638c3bf2616aa831d4c008347e7c08301482084578f7aa88d64616f2d686172642d666f726ba05b5acbf4bf305f948bd7be176047b20623e1417f75597341a059729165b9239788bede87201de42426"))); // Session.DeliverMessage(_eth1920000HeaderMessage); // // if (Logger.IsTrace) Logger.Trace($"OUT hardcoded 1920000 BlockHeaders to {Node:c}"); // return; // } Send(FulfillBlockHeadersRequest(getBlockHeadersMessage)); stopwatch.Stop(); if (Logger.IsTrace) { Logger.Trace($"OUT {Counter:D5} BlockHeaders to {Node:c} in {stopwatch.Elapsed.TotalMilliseconds}ms"); } }
public override void HandleMessage(ZeroPacket message) { int size = message.Content.ReadableBytes; switch (message.PacketType) { case Eth66MessageCode.GetBlockHeaders: GetBlockHeadersMessage getBlockHeadersMessage = Deserialize <GetBlockHeadersMessage>(message.Content); Metrics.Eth66GetBlockHeadersReceived++; ReportIn(getBlockHeadersMessage); Handle(getBlockHeadersMessage); break; case Eth66MessageCode.BlockHeaders: BlockHeadersMessage headersMsg = Deserialize <BlockHeadersMessage>(message.Content); Metrics.Eth66BlockHeadersReceived++; ReportIn(headersMsg); Handle(headersMsg.EthMessage, size); break; case Eth66MessageCode.GetBlockBodies: GetBlockBodiesMessage getBodiesMsg = Deserialize <GetBlockBodiesMessage>(message.Content); Metrics.Eth66GetBlockBodiesReceived++; ReportIn(getBodiesMsg); Handle(getBodiesMsg); break; case Eth66MessageCode.BlockBodies: BlockBodiesMessage bodiesMsg = Deserialize <BlockBodiesMessage>(message.Content); Metrics.Eth66BlockBodiesReceived++; ReportIn(bodiesMsg); HandleBodies(bodiesMsg.EthMessage, size); break; case Eth66MessageCode.GetPooledTransactions: GetPooledTransactionsMessage getPooledTxMsg = Deserialize <GetPooledTransactionsMessage>(message.Content); Metrics.Eth66GetPooledTransactionsReceived++; ReportIn(getPooledTxMsg); Handle(getPooledTxMsg); break; case Eth66MessageCode.PooledTransactions: PooledTransactionsMessage pooledTxMsg = Deserialize <PooledTransactionsMessage>(message.Content); Metrics.Eth66PooledTransactionsReceived++; ReportIn(pooledTxMsg); Handle(pooledTxMsg.EthMessage); break; case Eth66MessageCode.GetReceipts: GetReceiptsMessage getReceiptsMessage = Deserialize <GetReceiptsMessage>(message.Content); Metrics.Eth66GetReceiptsReceived++; ReportIn(getReceiptsMessage); Handle(getReceiptsMessage); break; case Eth66MessageCode.Receipts: ReceiptsMessage receiptsMessage = Deserialize <ReceiptsMessage>(message.Content); Metrics.Eth66ReceiptsReceived++; ReportIn(receiptsMessage); Handle(receiptsMessage.EthMessage, size); break; case Eth66MessageCode.GetNodeData: GetNodeDataMessage getNodeDataMessage = Deserialize <GetNodeDataMessage>(message.Content); Metrics.Eth66GetNodeDataReceived++; ReportIn(getNodeDataMessage); Handle(getNodeDataMessage); break; case Eth66MessageCode.NodeData: NodeDataMessage nodeDataMessage = Deserialize <NodeDataMessage>(message.Content); Metrics.Eth66NodeDataReceived++; ReportIn(nodeDataMessage); Handle(nodeDataMessage.EthMessage, size); break; default: base.HandleMessage(message); break; } }
public void To_string() { GetBlockHeadersMessage newBlockMessage = new GetBlockHeadersMessage(); _ = newBlockMessage.ToString(); }
private void Handle(GetBlockHeadersMessage getBlockHeaders) { V62.Messages.BlockHeadersMessage ethBlockHeadersMessage = FulfillBlockHeadersRequest(getBlockHeaders.EthMessage); Send(new BlockHeadersMessage(getBlockHeaders.RequestId, ethBlockHeadersMessage)); }
public void Get_headers_when_blocks_are_missing_at_the_end() { var svc = Build.A.SerializationService().WithEth().TestObject; var headers = new BlockHeader[5]; headers[0] = Build.A.BlockHeader.TestObject; headers[1] = Build.A.BlockHeader.TestObject; headers[2] = Build.A.BlockHeader.TestObject; var session = Substitute.For <ISession>(); var syncManager = Substitute.For <ISyncServer>(); var transactionPool = Substitute.For <ITxPool>(); syncManager.FindHash(100).Returns(TestItem.KeccakA); syncManager.FindHeaders(TestItem.KeccakA, 5, 1, true) .Returns(headers); Block genesisBlock = Build.A.Block.Genesis.TestObject; syncManager.Head.Returns(genesisBlock.Header); syncManager.Genesis.Returns(genesisBlock.Header); var handler = new Eth62ProtocolHandler( session, svc, new NodeStatsManager(new StatsConfig(), LimboLogs.Instance), syncManager, LimboLogs.Instance, transactionPool); handler.Init(); var msg = new GetBlockHeadersMessage(); msg.StartingBlockNumber = 100; msg.MaxHeaders = 5; msg.Skip = 1; msg.Reverse = 1; var statusMsg = new StatusMessage(); statusMsg.GenesisHash = genesisBlock.Hash; IByteBuffer statusPacket = svc.ZeroSerialize(statusMsg); statusPacket.ReadByte(); IByteBuffer getBlockHeadersPacket = svc.ZeroSerialize(msg); getBlockHeadersPacket.ReadByte(); handler.HandleMessage(new ZeroPacket(statusPacket) { PacketType = 0 }); handler.HandleMessage(new ZeroPacket(getBlockHeadersPacket) { PacketType = Eth62MessageCode.GetBlockHeaders }); session.Received().DeliverMessage(Arg.Is <BlockHeadersMessage>(bhm => bhm.BlockHeaders.Length == 3)); syncManager.Received().FindHash(100); }