public void Serialize(IByteBuffer byteBuffer, ContractCodesMessage message)
{
int innerLength = 0;
for (int i = 0; i < message.Codes.Length; i++)
{
innerLength += Rlp.LengthOf(message.Codes[i]);
}
int contentLength =
Rlp.LengthOf(message.RequestId) +
Rlp.LengthOf(message.BufferValue) +
Rlp.GetSequenceRlpLength(innerLength);
int totalLength = Rlp.GetSequenceRlpLength(contentLength);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
byteBuffer.EnsureWritable(totalLength);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.RequestId);
rlpStream.Encode(message.BufferValue);
rlpStream.StartSequence(innerLength);
for (int i = 0; i < message.Codes.Length; i++)
{
rlpStream.Encode(message.Codes[i]);
}
}
public void Serialize(IByteBuffer byteBuffer, BlockWitnessHashesMessage message)
{
NettyRlpStream nettyRlpStream = new NettyRlpStream(byteBuffer);
int hashesContentLength = message.Hashes?.Length * Rlp.LengthOfKeccakRlp ?? 0;
int contentLength = Rlp.LengthOfSequence(hashesContentLength);
contentLength += Rlp.LengthOf(message.RequestId);
int totalLength = Rlp.LengthOfSequence(contentLength);
byteBuffer.EnsureWritable(totalLength, true);
nettyRlpStream.StartSequence(contentLength);
nettyRlpStream.Encode(message.RequestId);
if (message.Hashes == null)
{
nettyRlpStream.EncodeNullObject();
}
else
{
nettyRlpStream.StartSequence(hashesContentLength);
foreach (Keccak keccak in message.Hashes)
{
nettyRlpStream.Encode(keccak);
}
}
}
public void Serialize(IByteBuffer byteBuffer, GetContractCodesMessage message)
{
// note: If there are any changes to how a hash is encoded, this will break (compression?)
// calling LengthOf for each hash would be more resistant to future changes, if we think there will be any
int requestLength = Rlp.LengthOf(Keccak.OfAnEmptyString) * 2;
int allRequestsLength = Rlp.GetSequenceRlpLength(requestLength) * message.Requests.Length;
int contentLength =
Rlp.LengthOf(message.RequestId) +
Rlp.GetSequenceRlpLength(allRequestsLength);
int totalLength = Rlp.GetSequenceRlpLength(contentLength);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
byteBuffer.EnsureWritable(totalLength);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.RequestId);
rlpStream.StartSequence(allRequestsLength);
foreach (CodeRequest request in message.Requests)
{
rlpStream.StartSequence(requestLength);
rlpStream.Encode(request.BlockHash);
rlpStream.Encode(request.AccountKey);
}
}
public void Serialize(IByteBuffer byteBuffer, GetHelperTrieProofsMessage message)
{
int innerLength = 0;
foreach (var request in message.Requests)
{
innerLength += Rlp.GetSequenceRlpLength(GetRequestLength(request));
}
int contentLength = Rlp.LengthOf(message.RequestId) +
Rlp.GetSequenceRlpLength(innerLength);
int totalLength = Rlp.GetSequenceRlpLength(contentLength);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
byteBuffer.EnsureWritable(totalLength);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.RequestId);
rlpStream.StartSequence(innerLength);
foreach (var request in message.Requests)
{
rlpStream.StartSequence(GetRequestLength(request));
rlpStream.Encode((int)request.SubType);
rlpStream.Encode(request.SectionIndex);
rlpStream.Encode(request.Key);
rlpStream.Encode(request.FromLevel);
rlpStream.Encode(request.AuxiliaryData);
}
}
public PooledTransactionsMessage Deserialize(IByteBuffer byteBuffer)
{
NettyRlpStream rlpStream = new NettyRlpStream(byteBuffer);
var txs = _txsMessageDeserializer.DeserializeTxs(rlpStream);
return(new PooledTransactionsMessage(txs));
}
public GetReceiptsMessage Deserialize(IByteBuffer byteBuffer)
{
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
Keccak[] hashes = rlpStream.DecodeArray(itemContext => itemContext.DecodeKeccak());
return(new GetReceiptsMessage(hashes));
}
public NodeDataMessage Deserialize(IByteBuffer byteBuffer)
{
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
byte[][] result = rlpStream.DecodeArray(stream => stream.DecodeByteArray());
return(new NodeDataMessage(result));
}
public GetNodeDataMessage Deserialize(IByteBuffer byteBuffer)
{
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
Keccak[] result = rlpStream.DecodeArray(stream => stream.DecodeKeccak());
return(new GetNodeDataMessage(result));
}
public void Serialize(IByteBuffer byteBuffer, NewBlockHashesMessage message)
{
NettyRlpStream nettyRlpStream = new NettyRlpStream(byteBuffer);
int contentLength = 0;
for (int i = 0; i < message.BlockHashes.Length; i++)
{
int miniContentLength = Rlp.LengthOf(message.BlockHashes[i].Item1);
miniContentLength += Rlp.LengthOf(message.BlockHashes[i].Item2);
contentLength += Rlp.GetSequenceRlpLength(miniContentLength);
}
int totalLength = Rlp.LengthOfSequence(contentLength);
byteBuffer.EnsureWritable(totalLength, true);
nettyRlpStream.StartSequence(contentLength);
for (int i = 0; i < message.BlockHashes.Length; i++)
{
int miniContentLength = Rlp.LengthOf(message.BlockHashes[i].Item1);
miniContentLength += Rlp.LengthOf(message.BlockHashes[i].Item2);
nettyRlpStream.StartSequence(miniContentLength);
nettyRlpStream.Encode(message.BlockHashes[i].Item1);
nettyRlpStream.Encode(message.BlockHashes[i].Item2);
}
}
public void Serialize(IByteBuffer byteBuffer, GetBlockHeadersMessage message)
{
int contentLength = message.StartBlockHash == null
? Rlp.LengthOf(message.StartBlockNumber)
: Rlp.LengthOf(message.StartBlockHash);
contentLength += Rlp.LengthOf(message.MaxHeaders);
contentLength += Rlp.LengthOf(message.Skip);
contentLength += Rlp.LengthOf(message.Reverse);
int totalLength = Rlp.GetSequenceRlpLength(contentLength);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
byteBuffer.EnsureWritable(totalLength, true);
rlpStream.StartSequence(contentLength);
if (message.StartBlockHash == null)
{
rlpStream.Encode(message.StartBlockNumber);
}
else
{
rlpStream.Encode(message.StartBlockHash);
}
rlpStream.Encode(message.MaxHeaders);
rlpStream.Encode(message.Skip);
rlpStream.Encode(message.Reverse);
}
public override void Serialize(IByteBuffer byteBuffer, GetByteCodesMessage message)
{
NettyRlpStream rlpStream = GetRlpStreamAndStartSequence(byteBuffer, message);
rlpStream.Encode(message.RequestId);
rlpStream.Encode(message.Hashes);
rlpStream.Encode(message.Bytes);
}
public GetBlockWitnessHashesMessage Deserialize(IByteBuffer byteBuffer)
{
NettyRlpStream rlpStream = new NettyRlpStream(byteBuffer);
rlpStream.ReadSequenceLength();
long requestId = rlpStream.DecodeLong();
var hash = rlpStream.DecodeKeccak();
return(new GetBlockWitnessHashesMessage(requestId, hash));
}
public override void Serialize(IByteBuffer byteBuffer, GetStorageRangeMessage message)
{
NettyRlpStream rlpStream = GetRlpStreamAndStartSequence(byteBuffer, message);
rlpStream.Encode(message.RequestId);
rlpStream.Encode(message.StoragetRange.RootHash);
rlpStream.Encode(message.StoragetRange.Accounts.Select(a => a.Path).ToArray()); // TODO: optimize this
rlpStream.Encode(message.StoragetRange.StartingHash);
rlpStream.Encode(message.StoragetRange.LimitHash);
rlpStream.Encode(message.ResponseBytes);
}
public void Serialize(IByteBuffer byteBuffer, GetBlockWitnessHashesMessage message)
{
NettyRlpStream nettyRlpStream = new NettyRlpStream(byteBuffer);
int contentLength =
Rlp.LengthOf(message.RequestId)
+ (message.BlockHash == null ? 1 : Rlp.LengthOfKeccakRlp);
nettyRlpStream.StartSequence(contentLength);
nettyRlpStream.Encode(message.RequestId);
nettyRlpStream.Encode(message.BlockHash);
}
public override void Serialize(IByteBuffer byteBuffer, GetAccountRangeMessage message)
{
NettyRlpStream rlpStream = GetRlpStreamAndStartSequence(byteBuffer, message);
rlpStream.Encode(message.RequestId);
rlpStream.Encode(message.AccountRange.RootHash);
rlpStream.Encode(message.AccountRange.StartingHash);
rlpStream.Encode(message.AccountRange.LimitHash ?? Keccak.MaxValue);
rlpStream.Encode(message.ResponseBytes == 0 ? 1000_000 : message.ResponseBytes);
}
public void Serialize(IByteBuffer byteBuffer, TEth66Message message)
{
int length = GetLength(message, out int contentLength);
byteBuffer.EnsureWritable(length, true);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.RequestId);
_ethMessageSerializer.Serialize(byteBuffer, message.EthMessage);
}
public void Serialize(IByteBuffer byteBuffer, NewBlockMessage message)
{
int contentLength = _blockDecoder.GetLength(message.Block, RlpBehaviors.None) + Rlp.LengthOf(message.TotalDifficulty);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
int totalLength = Rlp.LengthOfSequence(contentLength);
byteBuffer.EnsureWritable(totalLength, true);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.Block);
rlpStream.Encode(message.TotalDifficulty);
}
public void Serialize(IByteBuffer byteBuffer, NodeDataMessage message)
{
int length = GetLength(message, out int contentLength);
byteBuffer.EnsureWritable(length, true);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
rlpStream.StartSequence(contentLength);
for (int i = 0; i < message.Data.Length; i++)
{
rlpStream.Encode(message.Data[i]);
}
}
public void Serialize(IByteBuffer byteBuffer, ByteCodesMessage message)
{
(int contentLength, int codesLength) = GetLength(message);
byteBuffer.EnsureWritable(Rlp.LengthOfSequence(contentLength), true);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.RequestId);
rlpStream.StartSequence(codesLength);
for (int i = 0; i < message.Codes.Length; i++)
{
rlpStream.Encode(message.Codes[i]);
}
}
public void Serialize(IByteBuffer byteBuffer, GetBlockBodiesMessage message)
{
Eth.V62.GetBlockBodiesMessageSerializer ethSerializer = new Eth.V62.GetBlockBodiesMessageSerializer();
Rlp ethMessage = new Rlp(ethSerializer.Serialize(message.EthMessage));
int contentLength = Rlp.LengthOf(message.RequestId) + ethMessage.Length;
int totalLength = Rlp.GetSequenceRlpLength(contentLength);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
byteBuffer.EnsureWritable(totalLength);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.RequestId);
rlpStream.Encode(ethMessage);
}
public void Serialize(IByteBuffer byteBuffer, GetReceiptsMessage message)
{
Eth.V63.Messages.GetReceiptsMessageSerializer ethSerializer = new();
Rlp ethMessage = new(ethSerializer.Serialize(message.EthMessage));
int contentLength = Rlp.LengthOf(message.RequestId) + ethMessage.Length;
int totalLength = Rlp.LengthOfSequence(contentLength);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
byteBuffer.EnsureWritable(totalLength);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.RequestId);
rlpStream.Encode(ethMessage);
}
public BlockWitnessHashesMessage Deserialize(IByteBuffer byteBuffer)
{
NettyRlpStream rlpStream = new NettyRlpStream(byteBuffer);
rlpStream.ReadSequenceLength();
long requestId = rlpStream.DecodeLong();
int sequenceLength = rlpStream.ReadSequenceLength();
Keccak[] hashes = new Keccak[sequenceLength / Rlp.LengthOfKeccakRlp];
for (int i = 0; i < hashes.Length; i++)
{
hashes[i] = rlpStream.DecodeKeccak();
}
return(new BlockWitnessHashesMessage(requestId, hashes));
}
public void Serialize(IByteBuffer byteBuffer, ReceiptsMessage message)
{
Eth.V63.ReceiptsMessageSerializer ethSerializer = new Eth.V63.ReceiptsMessageSerializer(_specProvider);
Rlp ethMessage = new Rlp(ethSerializer.Serialize(message.EthMessage));
int contentLength = Rlp.LengthOf(message.RequestId) + Rlp.LengthOf(message.BufferValue) + ethMessage.Length;
int totalLength = Rlp.GetSequenceRlpLength(contentLength);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
byteBuffer.EnsureWritable(totalLength);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.RequestId);
rlpStream.Encode(message.BufferValue);
rlpStream.Encode(ethMessage);
}
public void Serialize(IByteBuffer byteBuffer, GetReceiptsMessage message)
{
int contentLength = 0;
for (int i = 0; i < message.BlockHashes.Count; i++)
{
contentLength += Rlp.LengthOf(message.BlockHashes[i]);
}
int totalLength = Rlp.LengthOfSequence(contentLength);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
byteBuffer.EnsureWritable(totalLength, true);
rlpStream.StartSequence(contentLength);
for (int i = 0; i < message.BlockHashes.Count; i++)
{
rlpStream.Encode(message.BlockHashes[i]);
}
}
public void Serialize(IByteBuffer byteBuffer, TransactionsMessage message)
{
NettyRlpStream nettyRlpStream = new NettyRlpStream(byteBuffer);
int contentLength = 0;
for (int i = 0; i < message.Transactions.Count; i++)
{
contentLength += _decoder.GetLength(message.Transactions[i], RlpBehaviors.None);
}
int totalLength = Rlp.LengthOfSequence(contentLength);
byteBuffer.EnsureWritable(totalLength, true);
nettyRlpStream.StartSequence(contentLength);
for (int i = 0; i < message.Transactions.Count; i++)
{
nettyRlpStream.Encode(message.Transactions[i]);
}
}
public void Serialize(IByteBuffer byteBuffer, BlockHeadersMessage message)
{
int contentLength = 0;
for (int i = 0; i < message.BlockHeaders.Length; i++)
{
contentLength += _headerDecoder.GetLength(message.BlockHeaders[i], RlpBehaviors.None);
}
int length = Rlp.LengthOfSequence(contentLength);
byteBuffer.EnsureWritable(length, true);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
rlpStream.StartSequence(contentLength);
for (int i = 0; i < message.BlockHeaders.Length; i++)
{
rlpStream.Encode(message.BlockHeaders[i]);
}
}
public void Serialize(IByteBuffer byteBuffer, GetBlockHeadersMessage message)
{
int length = GetLength(message, out int contentLength);
byteBuffer.EnsureWritable(length, true);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
rlpStream.StartSequence(contentLength);
if (message.StartBlockHash == null)
{
rlpStream.Encode(message.StartBlockNumber);
}
else
{
rlpStream.Encode(message.StartBlockHash);
}
rlpStream.Encode(message.MaxHeaders);
rlpStream.Encode(message.Skip);
rlpStream.Encode(message.Reverse);
}
public void Serialize(IByteBuffer byteBuffer, AnnounceMessage message)
{
NettyRlpStream rlpStream = new NettyRlpStream(byteBuffer);
int contentLength =
Rlp.LengthOf(message.HeadHash) +
Rlp.LengthOf(message.HeadBlockNo) +
Rlp.LengthOf(message.TotalDifficulty) +
Rlp.LengthOf(message.ReorgDepth) +
Rlp.OfEmptySequence.Length;
int totalLength = Rlp.LengthOfSequence(contentLength);
byteBuffer.EnsureWritable(totalLength);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.HeadHash);
rlpStream.Encode(message.HeadBlockNo);
rlpStream.Encode(message.TotalDifficulty);
rlpStream.Encode(message.ReorgDepth);
rlpStream.Encode(Rlp.OfEmptySequence);
}
public void Serialize(IByteBuffer byteBuffer, StatusMessage message)
{
int forkIdContentLength = 0;
int forkIdSequenceLength = 0;
if (message.ForkId.HasValue)
{
ForkId forkId = message.ForkId.Value;
forkIdContentLength = Rlp.LengthOf(forkId.ForkHash) + Rlp.LengthOf(forkId.Next);
forkIdSequenceLength = Rlp.LengthOfSequence(forkIdContentLength);
}
NettyRlpStream rlpStream = new NettyRlpStream(byteBuffer);
int contentLength =
Rlp.LengthOf(message.ProtocolVersion) +
Rlp.LengthOf(message.ChainId) +
Rlp.LengthOf(message.TotalDifficulty) +
Rlp.LengthOf(message.BestHash) +
Rlp.LengthOf(message.GenesisHash) +
forkIdSequenceLength;
int totalLength = Rlp.LengthOfSequence(contentLength);
byteBuffer.EnsureWritable(totalLength);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.ProtocolVersion);
rlpStream.Encode(message.ChainId);
rlpStream.Encode(message.TotalDifficulty);
rlpStream.Encode(message.BestHash);
rlpStream.Encode(message.GenesisHash);
if (message.ForkId != null)
{
ForkId forkId = message.ForkId.Value;
rlpStream.StartSequence(forkIdContentLength);
rlpStream.Encode(forkId.ForkHash);
rlpStream.Encode(forkId.Next);
}
}
public void Serialize(IByteBuffer byteBuffer, HelperTrieProofsMessage message)
{
Rlp[] proofNodesRlp = new Rlp[message.ProofNodes.Length];
for (int i = 0; i < message.ProofNodes.Length; i++)
{
proofNodesRlp[i] = Rlp.Encode(new Keccak(message.ProofNodes[i]));
}
Rlp proofsRlp = Rlp.Encode(proofNodesRlp);
Rlp[] tempAuxRlp = new Rlp[message.AuxiliaryData.Length];
for (int i = 0; i < message.AuxiliaryData.Length; i++)
{
tempAuxRlp[i] = Rlp.Encode(message.AuxiliaryData[i]);
}
Rlp auxRlp = Rlp.Encode(tempAuxRlp);
int innerContentLength = proofsRlp.Length + auxRlp.Length;
int contentLength =
Rlp.LengthOf(message.RequestId) +
Rlp.LengthOf(message.BufferValue) +
Rlp.GetSequenceRlpLength(innerContentLength);
int totalLength = Rlp.GetSequenceRlpLength(contentLength);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
byteBuffer.EnsureWritable(totalLength);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.RequestId);
rlpStream.Encode(message.BufferValue);
rlpStream.StartSequence(innerContentLength);
rlpStream.Encode(proofsRlp);
rlpStream.Encode(auxRlp);
}
