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);
}
