public void Throws_when_receiving_a_bodies_message_that_has_not_been_requested()
{
BlockBodiesMessage msg = new BlockBodiesMessage(Build.A.Block.TestObjectNTimes(3));
HandleIncomingStatusMessage();
Assert.Throws <SubprotocolException>(() => HandleZeroMessage(msg, Eth62MessageCode.BlockBodies));
}
protected void HandleBodies(IByteBuffer buffer, long size)
{
Metrics.Eth62BlockBodiesReceived++;
BlockBodiesMessage message = Deserialize <BlockBodiesMessage>(buffer);
_bodiesRequests.Handle(message.Bodies, size);
}
public void Can_handle_block_bodies()
{
BlockBodiesMessage msg = new BlockBodiesMessage(Build.A.Block.TestObjectNTimes(3));
HandleIncomingStatusMessage();
((ISyncPeer)_handler).GetBlockBodies(new List <Keccak>(new[] { Keccak.Zero }), CancellationToken.None);
HandleZeroMessage(msg, Eth62MessageCode.BlockBodies);
}
public void Roundtrip_with_nulls()
{
BlockBodiesMessage message = new BlockBodiesMessage {
Bodies = new BlockBody[1] {
null
}
};
var serializer = new BlockBodiesMessageSerializer();
SerializerTester.TestZero(serializer, message);
}
public async Task <BlockBody[]> BuildBlocksResponse(Keccak[] blockHashes, Response flags)
{
bool consistent = flags.HasFlag(Response.Consistent);
bool validSeals = flags.HasFlag(Response.ValidSeals);
bool noEmptySpaces = flags.HasFlag(Response.NoEmptySpace);
bool justFirst = flags.HasFlag(Response.JustFirstHeader);
bool allKnown = flags.HasFlag(Response.AllKnown);
bool timeoutOnFullBatch = flags.HasFlag(Response.TimeoutOnFullBatch);
if (timeoutOnFullBatch && blockHashes.Length == SyncBatchSize.Max)
{
throw new TimeoutException();
}
BlockHeader startHeader = _blockTree.FindHeader(blockHashes[0], false);
if (startHeader == null)
{
startHeader = Build.A.BlockHeader.WithHash(blockHashes[0]).TestObject;
}
BlockHeader[] blockHeaders = new BlockHeader[blockHashes.Length];
BlockBody[] blockBodies = new BlockBody[blockHashes.Length];
blockBodies[0] = new BlockBody(new Transaction[0], new BlockHeader[0]);
blockHeaders[0] = startHeader;
if (!justFirst)
{
for (int i = 1; i < blockHashes.Length; i++)
{
blockHeaders[i] = consistent
? Build.A.BlockHeader.WithParent(blockHeaders[i - 1]).TestObject
: Build.A.BlockHeader.WithNumber(blockHeaders[i - 1].Number + 1).TestObject;
_testHeaderMapping[startHeader.Number + i] = blockHeaders[i].Hash;
Block block = consistent
? Build.A.Block.WithHeader(blockHeaders[i]).TestObject
: Build.A.Block.WithHeader(blockHeaders[i - 1]).TestObject;
blockBodies[i] = new BlockBody(block.Transactions, block.Ommers);
if (allKnown)
{
_blockTree.SuggestBlock(block);
}
}
}
BlockBodiesMessage message = new BlockBodiesMessage(blockBodies);
byte[] messageSerialized = _bodiesSerializer.Serialize(message);
return(await Task.FromResult(_bodiesSerializer.Deserialize(messageSerialized).Bodies));
}
public void Roundtrip()
{
BlockHeader header = Build.A.BlockHeader.TestObject;
Address to = Build.An.Address.FromNumber(1).TestObject;
Transaction tx = Build.A.Transaction.WithTo(to).SignedAndResolved(new EthereumEcdsa(RopstenSpecProvider.Instance, NullLogManager.Instance), TestItem.PrivateKeyA, 1).TestObject;
BlockBodiesMessage message = new BlockBodiesMessage();
message.Bodies = new [] { new BlockBody(new [] { tx }, new [] { header }) };
var serializer = new BlockBodiesMessageSerializer();
SerializerTester.TestZero(serializer, message);
}
protected void Handle(BlockBodiesMessage message, long size)
{
Metrics.Eth62BlockBodiesReceived++;
using CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
cancellationTokenSource.CancelAfter(1000);
Request <GetBlockBodiesMessage, BlockBody[]> request = _bodiesRequests.Take(cancellationTokenSource.Token);
if (message.PacketType == Eth62MessageCode.BlockBodies)
{
request.ResponseSize = size;
request.CompletionSource.SetResult(message.Bodies);
}
}
public void Roundtrip_with_nulls()
{
BlockBodiesMessage message = new BlockBodiesMessage {
Bodies = new BlockBody[1] {
null
}
};
BlockBodiesMessageSerializer serializer = new BlockBodiesMessageSerializer();
byte[] bytes = serializer.Serialize(message);
BlockBodiesMessage deserialized = serializer.Deserialize(bytes);
Assert.AreEqual(message.Bodies.Length, deserialized.Bodies.Length, "length");
}
public void RoundTrip()
{
BlockHeader header = Build.A.BlockHeader.TestObject;
Address to = Build.An.Address.FromNumber(1).TestObject;
Transaction tx = Build.A.Transaction.WithTo(to).SignedAndResolved(new EthereumEcdsa(RopstenSpecProvider.Instance.ChainId, LimboLogs.Instance), TestItem.PrivateKeyA).TestObject;
tx.SenderAddress = null;
var ethMessage = new Network.P2P.Subprotocols.Eth.V62.BlockBodiesMessage();
ethMessage.Bodies = new[] { new BlockBody(new[] { tx }, new[] { header }) };
BlockBodiesMessage message = new BlockBodiesMessage(ethMessage, 1, 1000);
BlockBodiesMessageSerializer serializer = new BlockBodiesMessageSerializer();
SerializerTester.TestZero(serializer, message);
}
public void Roundtrip()
{
BlockHeader header = Build.A.BlockHeader.TestObject;
Transaction tx = Build.A.Transaction.SignedAndResolved(new EthereumSigner(RopstenSpecProvider.Instance, NullLogManager.Instance), TestObject.PrivateKeyA, 1).TestObject;
BlockBodiesMessage message = new BlockBodiesMessage();
message.Bodies = new [] { new BlockBody(new [] { tx }, new [] { header }) };
BlockBodiesMessageSerializer serializer = new BlockBodiesMessageSerializer();
byte[] bytes = serializer.Serialize(message);
byte[] expectedBytes = Bytes.FromHexString("f90265f90262f861f85f800182520894000000000000000000000000000000000000000101801ba0e82c81829818f96f1c53d0f283084f654d6207ccea2296122a365502c4782913a069f761f38649818a629edacc5fc0a269b4824a61356028ac4072acc9456d4f26f901fcf901f9a0ff483e972a04a9a62bb4b7d04ae403c615604e4090521ecc5bb7af67f71be09ca01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b9010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000830f424080833d090080830f424083010203a02ba5557a4c62a513c7e56d1bf13373e0da6bec016755483e91589fe1c6d212e28800000000000003e8");
Assert.True(Bytes.AreEqual(bytes, expectedBytes), "bytes");
BlockBodiesMessage deserialized = serializer.Deserialize(bytes);
Assert.AreEqual(message.Bodies.Length, deserialized.Bodies.Length, "length");
}
public void Roundtrip()
{
BlockBodiesMessage message = new BlockBodiesMessage();
message.Bodies = new (Transaction[], BlockHeader[])[0];
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()
{
BlockBodiesMessage newBlockMessage = new BlockBodiesMessage();
_ = newBlockMessage.ToString();
}
public void Ctor_with_nulls()
{
var message = new BlockBodiesMessage(new[] { Build.A.Block.TestObject, null, Build.A.Block.TestObject });
Assert.AreEqual(3, message.Bodies.Length);
}
protected virtual void HandleBodies(BlockBodiesMessage blockBodiesMessage, long size)
{
Metrics.Eth62BlockBodiesReceived++;
_bodiesRequests.Handle(blockBodiesMessage.Bodies, size);
}
