public void Byte_array_of_length_55()
{
byte[] input = new byte[55];
input[0] = 255;
input[1] = 128;
input[2] = 1;
byte[] expectedResultBytes = new byte[1 + input.Length];
expectedResultBytes[0] = (byte)(128 + input.Length);
expectedResultBytes[1] = input[0];
expectedResultBytes[2] = input[1];
expectedResultBytes[3] = input[2];
Rlp expectedResult = new Rlp(expectedResultBytes);
Assert.AreEqual(expectedResult, Rlp.Encode(input), "byte array");
Assert.AreEqual(expectedResult, Rlp.Encode(input.AsSpan()), "span");
}
public static Keccak CalculateReceiptRoot(this Block block, ISpecProvider specProvider, TxReceipt[] txReceipts)
{
if (txReceipts.Length == 0)
{
return(PatriciaTree.EmptyTreeHash);
}
PatriciaTree receiptTree = new PatriciaTree();
for (int i = 0; i < txReceipts.Length; i++)
{
byte[] receiptRlp = _receiptDecoder.EncodeNew(txReceipts[i], specProvider.GetSpec(block.Number).IsEip658Enabled ? RlpBehaviors.Eip658Receipts : RlpBehaviors.None);
receiptTree.Set(Rlp.Encode(i).Bytes, receiptRlp);
}
receiptTree.UpdateRootHash();
return(receiptTree.RootHash);
}
public static Keccak CalculateTxRoot(this Block block)
{
if (block.Transactions.Length == 0)
{
return(PatriciaTree.EmptyTreeHash);
}
PatriciaTree txTree = new PatriciaTree();
for (int i = 0; i < block.Transactions.Length; i++)
{
Rlp transactionRlp = _txDecoder.Encode(block.Transactions[i]);
txTree.Set(Rlp.Encode(i).Bytes, transactionRlp.Bytes);
}
txTree.UpdateRootHash();
return(txTree.RootHash);
}
public void Can_do_roundtrip_none_rlp_stream()
{
TxReceipt txReceipt = Build.A.Receipt.TestObject;
txReceipt.Bloom = new Bloom();
txReceipt.Bloom.Set(Keccak.EmptyTreeHash.Bytes);
txReceipt.GasUsedTotal = 1000;
txReceipt.PostTransactionState = TestItem.KeccakH;
ReceiptDecoder decoder = new ReceiptDecoder();
byte[] rlpStreamResult = decoder.EncodeNew(txReceipt, RlpBehaviors.None);
TxReceipt deserialized = Rlp.Decode <TxReceipt>(rlpStreamResult, RlpBehaviors.None);
Assert.AreEqual(txReceipt.GasUsedTotal, deserialized.GasUsedTotal, "gas used total");
Assert.AreEqual(txReceipt.Bloom, deserialized.Bloom, "bloom");
Assert.AreEqual(txReceipt.PostTransactionState, deserialized.PostTransactionState, "post transaction state");
}
private Keccak GetTransactionsRoot(List <Transaction> transactions)
{
if (transactions.Count == 0)
{
return(PatriciaTree.EmptyTreeHash);
}
PatriciaTree txTree = new PatriciaTree();
for (int i = 0; i < transactions.Count; i++)
{
Rlp transactionRlp = Rlp.Encode(transactions[i]);
txTree.Set(Rlp.Encode(i).Bytes, transactionRlp);
}
txTree.UpdateRootHash();
return(txTree.RootHash);
}
public ParityLikeTxTrace ParityTrace(Keccak txHash, ParityTraceTypes traceTypes)
{
byte[] traceBytes = _traceDb.Get(txHash);
if (traceBytes != null)
{
return(Rlp.Decode <ParityLikeTxTrace>(traceBytes));
}
TxReceipt txReceipt = _receiptStorage.Find(txHash);
Block block = _blockTree.FindBlock(txReceipt.BlockNumber, BlockTreeLookupOptions.RequireCanonical);
if (block == null)
{
throw new InvalidOperationException("Only historical blocks");
}
return(ParityTrace(block, txHash, traceTypes));
}
public Rlp Encode(ParityLikeTxTrace item, RlpBehaviors rlpBehaviors = RlpBehaviors.None)
{
Rlp[] traceElements = new Rlp[7];
traceElements[0] = Rlp.Encode(item.BlockHash);
traceElements[1] = Rlp.Encode(item.BlockNumber);
traceElements[2] = Rlp.Encode(item.TransactionHash);
traceElements[3] = item.TransactionPosition == null ? Rlp.OfEmptyByteArray : Rlp.Encode(item.TransactionPosition.Value);
ParityTraceAction action = item.Action;
List <Rlp> calls = new List <Rlp>();
EncodeAction(calls, action); // trace
traceElements[4] = Rlp.Encode(calls.ToArray());
traceElements[5] = EncodeChange(item.StateChanges); // stateDiff
traceElements[6] = Rlp.OfEmptySequence; // vmTrace placeholder
return(Rlp.Encode(traceElements));
}
public void Storage_proofs_when_values_are_missing_setup()
{
byte[] a = Bytes.FromHexString("0x000000000000000000000000000000000000000000aaaaaaaaaaaaaaaaaaaaaa");
byte[] b = Bytes.FromHexString("0x0000000000000000000000000bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
byte[] c = Bytes.FromHexString("0x00000000001ccccccccccccccccccccccccccccccccccccccccccccccccccccc");
byte[] d = Bytes.FromHexString("0x00000000001ddddddddddddddddddddddddddddddddddddddddddddddddddddd");
byte[] e = Bytes.FromHexString("0x00000000001eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee");
IDb memDb = new MemDb();
StateTree tree = new StateTree(memDb);
StorageTree storageTree = new StorageTree(memDb);
storageTree.Set(Keccak.Compute(a).Bytes, Rlp.Encode(Bytes.FromHexString("0xab12000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Set(Keccak.Compute(c).Bytes, Rlp.Encode(Bytes.FromHexString("0xab56000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Set(Keccak.Compute(e).Bytes, Rlp.Encode(Bytes.FromHexString("0xab9a000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Commit();
byte[] code = new byte[] { 1, 2, 3 };
Account account1 = Build.An.Account.WithBalance(1).WithStorageRoot(storageTree.RootHash).TestObject;
Account account2 = Build.An.Account.WithBalance(2).TestObject;
tree.Set(TestItem.AddressA, account1);
tree.Set(TestItem.AddressB, account2);
tree.Commit();
TreeDumper dumper = new TreeDumper();
tree.Accept(dumper, tree.RootHash, true);
Console.WriteLine(dumper.ToString());
AccountProofCollector accountProofCollector = new AccountProofCollector(TestItem.AddressA, new byte[][] { a, b, c, d, e });
tree.Accept(accountProofCollector, tree.RootHash, true);
AccountProof proof = accountProofCollector.BuildResult();
Assert.AreEqual("0xab12000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[0].Value?.ToHexString(true) ?? "0x");
Assert.AreEqual("0x00", proof.StorageProofs[1].Value?.ToHexString(true) ?? "0x");
Assert.AreEqual("0xab56000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[2].Value?.ToHexString(true) ?? "0x");
Assert.AreEqual("0x00", proof.StorageProofs[3].Value?.ToHexString(true) ?? "0x");
Assert.AreEqual("0xab9a000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[4].Value?.ToHexString(true) ?? "0x");
proof.StorageProofs[1].Proof.Should().HaveCount(3);
proof.StorageProofs[3].Proof.Should().HaveCount(2);
}
public void Test(EthashTest test)
{
BlockHeader blockHeader = Rlp.Decode <BlockHeader>(new Rlp(test.Header));
Assert.AreEqual(test.Nonce, blockHeader.Nonce, "header nonce vs test nonce");
Assert.AreEqual(test.MixHash.Bytes, blockHeader.MixHash.Bytes, "header mix hash vs test mix hash");
Keccak headerHash = Keccak.Compute(Rlp.Encode(blockHeader, RlpBehaviors.ExcludeBlockMixHashAndNonce));
Assert.AreEqual(test.HeaderHash, headerHash, "header hash");
// seed is correct
Ethash ethash = new Ethash(NullLogManager.Instance);
uint epoch = Ethash.GetEpoch(blockHeader.Number);
Assert.AreEqual(test.Seed, Ethash.GetSeedHash(epoch), "seed");
uint cacheSize = Ethash.GetCacheSize(Ethash.GetEpoch(blockHeader.Number));
Assert.AreEqual((ulong)test.CacheSize, cacheSize, "cache size requested");
IEthashDataSet cache = new EthashCache(cacheSize, test.Seed.Bytes);
Assert.AreEqual((ulong)test.CacheSize, (ulong)cache.Size, "cache size returned");
// below we confirm that headerAndNonceHashed is calculated correctly
// & that the method for calculating the result from mix hash is correct
byte[] headerAndNonceHashed = Keccak512.Compute(Bytes.Concat(headerHash.Bytes, test.Nonce.ToByteArray(Bytes.Endianness.Little))).Bytes;
byte[] resultHalfTest = Keccak.Compute(Bytes.Concat(headerAndNonceHashed, test.MixHash.Bytes)).Bytes;
Assert.AreEqual(resultHalfTest, test.Result.Bytes, "half test");
// here we confirm that the whole mix hash calculation is fine
(byte[] mixHash, byte[] result) = ethash.Hashimoto((ulong)test.FullSize, cache, headerHash, blockHeader.MixHash, test.Nonce);
Assert.AreEqual(test.MixHash.Bytes, mixHash, "mix hash");
Assert.AreEqual(test.Result.Bytes, result, "result");
// not that the test's result value suggests that the result of the PoW operation is not below difficulty / block is invalid...
// Assert.True(ethash.Validate(blockHeader), "validation");
// seems it is just testing the nonce and mix hash but not difficulty
ulong dataSetSize = Ethash.GetDataSize(epoch);
Assert.AreEqual((ulong)test.FullSize, dataSetSize, "data size requested");
}
public async Task Can_load_blocks_from_db_odd()
{
for (int chainLength = 2; chainLength <= 32; chainLength++)
{
Block genesisBlock = Build.A.Block.Genesis.TestObject;
MemDb blocksDb = new MemDb();
MemDb blockInfosDb = new MemDb();
MemDb headersDb = new MemDb();
BlockTree testTree = Build.A.BlockTree(genesisBlock).OfChainLength(chainLength).TestObject;
for (int i = 0; i < testTree.Head.Number + 1; i++)
{
Block ithBlock = testTree.FindBlock(i, BlockTreeLookupOptions.None);
blocksDb.Set(ithBlock.Hash, Rlp.Encode(ithBlock).Bytes);
headersDb.Set(ithBlock.Hash, Rlp.Encode(ithBlock.Header).Bytes);
ChainLevelInfo ithLevel = new ChainLevelInfo(true, new BlockInfo[1]
{
new BlockInfo(ithBlock.Hash, ithBlock.TotalDifficulty.Value)
});
blockInfosDb.Set(i, Rlp.Encode(ithLevel).Bytes);
}
blockInfosDb.Set(Keccak.Zero, genesisBlock.Header.Hash.Bytes);
headersDb.Set(genesisBlock.Header.Hash, Rlp.Encode(genesisBlock.Header).Bytes);
BlockTree blockTree = new BlockTree(
blocksDb,
headersDb,
blockInfosDb,
new ChainLevelInfoRepository(blockInfosDb),
OlympicSpecProvider.Instance,
NullBloomStorage.Instance,
LimboLogs.Instance);
DbBlocksLoader loader = new DbBlocksLoader(blockTree, LimboNoErrorLogger.Instance);
await blockTree.Accept(loader, CancellationToken.None);
Assert.AreEqual(testTree.Head.Hash, blockTree.BestSuggestedHeader.Hash, $"head {chainLength}");
}
}
public void Storage_proofs_have_values_set_complex_3_setup()
{
Keccak a = new Keccak("0x000000000000000000000000000000000000000000aaaaaaaaaaaaaaaaaaaaaa");
Keccak b = new Keccak("0x0000000000000000000000000bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
Keccak c = new Keccak("0x00000000001ccccccccccccccccccccccccccccccccccccccccccccccccccccc");
Keccak d = new Keccak("0x00000000001ddddddddddddddddddddddddddddddddddddddddddddddddddddd");
Keccak e = new Keccak("0x00000000001eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee");
IDb memDb = new MemDb();
StateTree tree = new StateTree(memDb);
StorageTree storageTree = new StorageTree(memDb);
storageTree.Set(a.Bytes, Rlp.Encode(Bytes.FromHexString("0xab12000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Set(b.Bytes, Rlp.Encode(Bytes.FromHexString("0xab34000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Set(c.Bytes, Rlp.Encode(Bytes.FromHexString("0xab56000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Set(d.Bytes, Rlp.Encode(Bytes.FromHexString("0xab78000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Set(e.Bytes, Rlp.Encode(Bytes.FromHexString("0xab9a000000000000000000000000000000000000000000000000000000000000000000000000000000")));
storageTree.Commit();
byte[] code = new byte[] { 1, 2, 3 };
Account account1 = Build.An.Account.WithBalance(1).WithStorageRoot(storageTree.RootHash).TestObject;
Account account2 = Build.An.Account.WithBalance(2).TestObject;
tree.Set(TestItem.AddressA, account1);
tree.Set(TestItem.AddressB, account2);
tree.Commit();
TreeDumper dumper = new TreeDumper();
tree.Accept(dumper, memDb, tree.RootHash);
Console.WriteLine(dumper.ToString());
ProofCollector proofCollector = new ProofCollector(TestItem.AddressA, new Keccak[] { a, b, c, d, e });
tree.Accept(proofCollector, memDb, tree.RootHash);
AccountProof proof = proofCollector.BuildResult();
Assert.AreEqual("0xab12000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[0].Value.ToHexString(true));
Assert.AreEqual("0xab34000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[1].Value.ToHexString(true));
Assert.AreEqual("0xab56000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[2].Value.ToHexString(true));
Assert.AreEqual("0xab78000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[3].Value.ToHexString(true));
Assert.AreEqual("0xab9a000000000000000000000000000000000000000000000000000000000000000000000000000000", proof.StorageProofs[4].Value.ToHexString(true));
}
public static Rlp BlockInfoEncodeDeprecated(BlockInfo?item, bool chainWithFinalization)
{
if (item == null)
{
return(Rlp.OfEmptySequence);
}
Rlp[] elements = new Rlp[chainWithFinalization ? 4 : 3];
elements[0] = Rlp.Encode(item.BlockHash);
elements[1] = Rlp.Encode(item.WasProcessed);
elements[2] = Rlp.Encode(item.TotalDifficulty);
if (chainWithFinalization)
{
elements[3] = Rlp.Encode(item.IsFinalized);
}
return(Rlp.Encode(elements));
}
public byte[] Serialize(PingMessage message)
{
byte typeByte = (byte)message.MessageType;
Rlp source = Encode(message.SourceAddress);
Rlp destination = Encode(message.DestinationAddress);
byte[] data = Rlp.Encode(
Rlp.Encode(message.Version),
source,
destination,
//verify if encoding is correct
Rlp.Encode(message.ExpirationTime)
).Bytes;
byte[] serializedMsg = Serialize(typeByte, data);
message.Mdc = serializedMsg.Slice(0, 32);
return(serializedMsg);
}
public void Can_decode_aura()
{
var auRaSignature = new byte[64];
new Random().NextBytes(auRaSignature);
BlockHeader header = Build.A.BlockHeader
.WithAura(100000000, auRaSignature)
.TestObject;
HeaderDecoder decoder = new();
Rlp rlp = decoder.Encode(header);
Rlp.ValueDecoderContext decoderContext = new(rlp.Bytes);
BlockHeader decoded = decoder.Decode(ref decoderContext);
decoded.Hash = decoded.CalculateHash();
Assert.AreEqual(header.Hash, decoded.Hash, "hash");
}
public void initializes_pendingValidators_from_db()
{
var blockNumber = 10;
var validators = TestItem.Addresses.Take(10).ToArray();
var blockHash = Keccak.Compute("Test");
var pendingValidators = new ContractValidator.PendingValidators(blockNumber, blockHash, validators);
var rlp = Rlp.Encode(pendingValidators);
_db[ContractValidator.PendingValidatorsKey.Bytes].Returns(rlp.Bytes);
IAuRaValidatorProcessor validator = new ContractValidator(_validator, _db, _stateProvider, _abiEncoder, _transactionProcessor, _blockTree, _receiptsStorage, _logManager, 1);
validator.SetFinalizationManager(_blockFinalizationManager);
_blockFinalizationManager.BlocksFinalized +=
Raise.EventWith(new FinalizeEventArgs(_block.Header,
Build.A.BlockHeader.WithNumber(blockNumber).WithHash(blockHash).TestObject));
validators.Select((v, i) => validator.IsValidSealer(v, i)).Should().AllBeEquivalentTo(true);
}
private static int GetContentLength(UserOperationWithEntryPoint opWithEntryPoint)
{
UserOperation op = opWithEntryPoint.UserOperation;
Address entryPoint = opWithEntryPoint.EntryPoint;
return(Rlp.LengthOf(op.Sender)
+ Rlp.LengthOf(op.Nonce)
+ Rlp.LengthOf(op.InitCode)
+ Rlp.LengthOf(op.CallData)
+ Rlp.LengthOf(op.CallGas)
+ Rlp.LengthOf(op.VerificationGas)
+ Rlp.LengthOf(op.PreVerificationGas)
+ Rlp.LengthOf(op.MaxFeePerGas)
+ Rlp.LengthOf(op.MaxPriorityFeePerGas)
+ Rlp.LengthOf(op.Paymaster)
+ Rlp.LengthOf(op.PaymasterData)
+ Rlp.LengthOf(op.Signature)
+ Rlp.LengthOf(entryPoint));
}
private static BlockBodiesMessage Deserialize(RlpStream rlpStream)
{
BlockBodiesMessage message = new BlockBodiesMessage();
message.Bodies = rlpStream.DecodeArray(ctx =>
{
int sequenceLength = rlpStream.ReadSequenceLength();
if (sequenceLength == 0)
{
return(null);
}
Transaction[] transactions = rlpStream.DecodeArray(txCtx => Rlp.Decode <Transaction>(ctx));
BlockHeader[] ommers = rlpStream.DecodeArray(txCtx => Rlp.Decode <BlockHeader>(ctx));
return(new BlockBody(transactions, ommers));
}, false);
return(message);
}
public void MarkAsProcessed(Keccak blockHash, TransactionReceipt[] receipts = null)
{
BigInteger number = LoadNumberOnly(blockHash);
(BlockInfo info, ChainLevelInfo level) = LoadInfo(number, blockHash);
if (info.WasProcessed)
{
throw new InvalidOperationException($"Marking already processed block {blockHash} as processed");
}
info.WasProcessed = true;
UpdateLevel(number, level);
if (receipts != null)
{
IReleaseSpec spec = _specProvider.GetSpec(number);
_receiptsDb.Set(blockHash, Rlp.Encode(receipts.Select(r => Rlp.Encode(r, spec.IsEip658Enabled ? RlpBehaviors.Eip658Receipts : RlpBehaviors.None)).ToArray()).Bytes);
}
}
//[TestCase(256L * 256L * 256L * 256L, (byte)(1 + 4 + 183), (byte)1)]
public void Serialized_form_is_input_prefixed_with_big_endian_length_and_prefixed_with_length_of_it_plus_183(
long inputLength, byte expectedFirstByte, byte expectedSecondByte)
{
byte[] input = new byte[inputLength];
input[0] = 255;
input[1] = 128;
input[2] = 1;
Assert.AreEqual(expectedFirstByte, Rlp.Encode(input)[0]);
Assert.AreEqual(expectedSecondByte, Rlp.Encode(input)[1]);
if (inputLength < 256)
{
for (int i = 0; i < 128; i++)
{
Assert.AreEqual(input[i], Rlp.Encode(input)[i + 1 + expectedFirstByte - 183]);
}
}
}
public void Sign(PrivateKey privateKey, Transaction tx, bool isEip155Enabled)
{
if (_logger.IsDebug)
{
_logger.Debug($"Signing transaction {tx.SenderAddress} -> {tx.To} ({tx.Value}) with data {tx.Data}");
}
Keccak hash = Keccak.Compute(Rlp.Encode(tx, true, isEip155Enabled, _chainIdValue).Bytes);
tx.Signature = Sign(privateKey, hash);
if (isEip155Enabled)
{
tx.Signature.V = tx.Signature.V + 8 + 2 * _chainIdValue;
}
if (_logger.IsDebug)
{
_logger.Debug($"Transaction {tx.SenderAddress} -> {tx.To} ({tx.Value}) signed");
}
}
public DataAssetMessage Deserialize(byte[] bytes)
{
var context = bytes.AsRlpStream();
context.ReadSequenceLength();
DataAsset dataAsset;
try
{
dataAsset = Rlp.Decode <DataAsset>(context);
}
catch (RlpException)
{
throw new InvalidDataException("DataAssset cannot be null");
}
return(new DataAssetMessage(dataAsset));
}
public void Can_do_roundtrip_ref_struct()
{
LogEntry logEntry = new LogEntry(TestItem.AddressA, new byte[] { 1, 2, 3 }, new[] { TestItem.KeccakA, TestItem.KeccakB });
Rlp rlp = Rlp.Encode(logEntry);
Rlp.ValueDecoderContext valueDecoderContext = new Rlp.ValueDecoderContext(rlp.Bytes);
LogEntryDecoder.DecodeStructRef(ref valueDecoderContext, RlpBehaviors.None, out var decoded);
Assert.That(Bytes.AreEqual(logEntry.Data, decoded.Data), "data");
Assert.That(logEntry.LoggersAddress == decoded.LoggersAddress, "address");
KeccaksIterator iterator = new KeccaksIterator(decoded.TopicsRlp);
for (int i = 0; i < logEntry.Topics.Length; i++)
{
iterator.TryGetNext(out var keccak);
Assert.That(logEntry.Topics[i] == keccak, $"topics[{i}]");
}
}
public void Can_encode_decode_tiny_extension()
{
TrieNode trieNode = new TrieNode(NodeType.Extension);
trieNode.Key = new HexPrefix(false, 5);
trieNode.SetChild(0, _tiniestLeaf);
Rlp rlp = trieNode.RlpEncode();
TrieNode decoded = new TrieNode(NodeType.Unknown, rlp);
decoded.ResolveNode(null);
TrieNode decodedTiniest = decoded.GetChild(0);
decodedTiniest.ResolveNode(null);
Assert.AreEqual(_tiniestLeaf.Value, decodedTiniest.Value, "value");
Assert.AreEqual(_tiniestLeaf.Key.ToBytes(), decodedTiniest.Key.ToBytes(), "key");
}
public void Setup_chain()
{
// Import blocks
_blockTree = Build.A.BlockTree().TestObject;
Block block1 = Rlp.Decode <Block>(new Rlp(Bytes.FromHexString(Block1Rlp)));
Block block2 = Rlp.Decode <Block>(new Rlp(Bytes.FromHexString(Block2Rlp)));
Block block3 = Rlp.Decode <Block>(new Rlp(Bytes.FromHexString(Block3Rlp)));
Block block4 = Rlp.Decode <Block>(new Rlp(Bytes.FromHexString(Block4Rlp)));
Block block5 = Rlp.Decode <Block>(new Rlp(Bytes.FromHexString(Block5Rlp)));
Block genesisBlock = CliqueTests.GetRinkebyGenesis();
// Add blocks
MineBlock(_blockTree, genesisBlock);
MineBlock(_blockTree, block1);
MineBlock(_blockTree, block2);
MineBlock(_blockTree, block3);
MineBlock(_blockTree, block4);
MineBlock(_blockTree, block5);
}
public void Long_byte_array()
{
byte[] input = new byte[1025];
input[0] = 255;
input[1] = 128;
input[2] = 1;
byte[] expectedResultBytes = new byte[1 + 2 + input.Length];
expectedResultBytes[0] = 183 + 2;
expectedResultBytes[1] = (byte)(input.Length / (16 * 16));
expectedResultBytes[2] = (byte)(input.Length % (16 * 16));
expectedResultBytes[3] = input[0];
expectedResultBytes[4] = input[1];
expectedResultBytes[5] = input[2];
Rlp expectedResult = new(expectedResultBytes);
Assert.AreEqual(expectedResult, Rlp.Encode(input), "byte array");
Assert.AreEqual(expectedResult, Rlp.Encode(input.AsSpan()), "span");
}
public void Serialize(IByteBuffer byteBuffer, StatusMessage message)
{
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);
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);
}
public void Serialize(IByteBuffer byteBuffer, T message)
{
int contentLength = 0;
for (int i = 0; i < message.Hashes.Count; i++)
{
contentLength += Rlp.LengthOf(message.Hashes[i]);
}
int totalLength = Rlp.LengthOfSequence(contentLength);
RlpStream rlpStream = new NettyRlpStream(byteBuffer);
byteBuffer.EnsureWritable(totalLength, true);
rlpStream.StartSequence(contentLength);
for (int i = 0; i < message.Hashes.Count; i++)
{
rlpStream.Encode(message.Hashes[i]);
}
}
public void Serialize(IByteBuffer byteBuffer, BlockHeadersMessage message)
{
Eth.V62.BlockHeadersMessageSerializer ethSerializer = new Eth.V62.BlockHeadersMessageSerializer();
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, true);
rlpStream.StartSequence(contentLength);
rlpStream.Encode(message.RequestId);
rlpStream.Encode(message.BufferValue);
rlpStream.Encode(ethMessage);
}
private void UpdateHeadBlock(Block block)
{
if (block.IsGenesis)
{
Genesis = block.Header;
}
Head = block.Header;
_blockInfoDb.Set(HeadAddressInDb, Rlp.Encode(Head).Bytes);
NewHeadBlock?.Invoke(this, new BlockEventArgs(block));
if (_dbBatchProcessed != null)
{
if (block.Number == _currentDbLoadBatchEnd)
{
TaskCompletionSource <object> completionSource = _dbBatchProcessed;
_dbBatchProcessed = null;
completionSource.SetResult(null);
}
}
}
public void When_moving_to_main_one_of_the_two_blocks_at_given_level_the_was_processed_check_is_executed_on_the_correct_block_index_regression()
{
MemDb blocksDb = new MemDb();
MemDb blockInfosDb = new MemDb();
BlockTree blockTree = new BlockTree(blocksDb, blockInfosDb, OlympicSpecProvider.Instance, Substitute.For <ITransactionPool>(), LimboLogs.Instance);
Block block0 = Build.A.Block.WithNumber(0).WithDifficulty(1).TestObject;
Block block1 = Build.A.Block.WithNumber(1).WithDifficulty(2).WithParent(block0).TestObject;
Block block2 = Build.A.Block.WithNumber(1).WithDifficulty(3).WithParent(block0).TestObject;
AddToMain(blockTree, block0);
blockTree.SuggestBlock(block2);
blockTree.SuggestBlock(block1);
blockTree.UpdateMainChain(block1);
BlockHeader storedInDb = Rlp.Decode <BlockHeader>(new Rlp(blockInfosDb.Get(Keccak.Zero)));
Assert.AreEqual(block1.Hash, storedInDb.Hash);
}
