public async Task newPayloadV1_can_insert_blocks_from_cache_when_syncing()
{
using MergeTestBlockchain chain = await CreateBlockChain();
IEngineRpcModule rpc = CreateEngineModule(chain);
Keccak startingHead = chain.BlockTree.HeadHash;
ExecutionPayloadV1 parentBlockRequest = new(Build.A.Block.WithNumber(2).TestObject);
ExecutionPayloadV1[] requests = CreateBlockRequestBranch(parentBlockRequest, Address.Zero, 7);
ResultWrapper <PayloadStatusV1> payloadStatus;
foreach (ExecutionPayloadV1 r in requests)
{
payloadStatus = await rpc.engine_newPayloadV1(r);
payloadStatus.Data.Status.Should().Be(nameof(PayloadStatusV1.Syncing).ToUpper());
chain.BeaconSync.IsBeaconSyncHeadersFinished().Should().BeTrue();
chain.BeaconSync.ShouldBeInBeaconHeaders().Should().BeFalse();
chain.BeaconPivot.BeaconPivotExists().Should().BeFalse();
}
int pivotNum = 3;
requests[pivotNum].TryGetBlock(out Block? pivotBlock);
// initiate sync
ForkchoiceStateV1 forkchoiceStateV1 = new(pivotBlock !.Hash, startingHead, startingHead);
ResultWrapper <ForkchoiceUpdatedV1Result> forkchoiceUpdatedResult =
await rpc.engine_forkchoiceUpdatedV1(forkchoiceStateV1);
forkchoiceUpdatedResult.Data.PayloadStatus.Status.Should()
.Be(nameof(PayloadStatusV1.Syncing).ToUpper());
// trigger insertion of blocks in cache into block tree
payloadStatus = await rpc.engine_newPayloadV1(requests[^ 1]);
public async Task finaliseBlock_should_succeed()
{
using MergeTestBlockchain chain = await CreateBlockChain();
IConsensusRpcModule rpc = CreateConsensusModule(chain);
ResultWrapper <Result> resultWrapper = await rpc.consensus_finaliseBlock(TestItem.KeccakE);
resultWrapper.Data.Should().Be(Result.OK);
}
public async Task setHead_to_unknown_block_fails()
{
using MergeTestBlockchain chain = await CreateBlockChain();
IConsensusRpcModule rpc = CreateConsensusModule(chain);
ResultWrapper <Result> setHeadResult = await rpc.consensus_setHead(TestItem.KeccakF);
setHeadResult.Data.success.Should().BeFalse();
}
private IConsensusRpcModule CreateConsensusModule(MergeTestBlockchain chain)
{
return(new ConsensusRpcModule(
new AssembleBlockHandler(chain.BlockTree, (IEth2BlockProducer)chain.BlockProducer, chain.LogManager),
new NewBlockHandler(chain.BlockTree, chain.BlockPreprocessorStep, chain.BlockchainProcessor, chain.State, chain.LogManager),
new SetHeadBlockHandler(chain.BlockTree, chain.State, chain.LogManager),
new FinaliseBlockHandler(),
chain.LogManager));
}
public virtual async Task forkchoiceUpdatedV1_should_communicate_with_boost_relay_through_http()
{
MergeConfig mergeConfig = new() { Enabled = true, SecondsPerSlot = 1, TerminalTotalDifficulty = "0" };
using MergeTestBlockchain chain = await CreateBlockChain(mergeConfig);
IJsonSerializer serializer = chain.JsonSerializer;
UInt256 timestamp = Timestamper.UnixTime.Seconds;
PayloadAttributes payloadAttributes = new() { Timestamp = timestamp, SuggestedFeeRecipient = Address.Zero, PrevRandao = Keccak.Zero };
string relayUrl = "http://localhost";
MockHttpMessageHandler mockHttp = new();
mockHttp.Expect(HttpMethod.Post, relayUrl + BoostRelay.GetPayloadAttributesPath)
.WithContent("{\"timestamp\":\"0x3e8\",\"prevRandao\":\"0x0000000000000000000000000000000000000000000000000000000000000000\",\"suggestedFeeRecipient\":\"0x0000000000000000000000000000000000000000\"}")
.Respond("application/json", "{\"timestamp\":\"0x3e9\",\"prevRandao\":\"0x03783fac2efed8fbc9ad443e592ee30e61d65f471140c10ca155e937b435b760\",\"suggestedFeeRecipient\":\"0xb7705ae4c6f81b66cdb323c65f4e8133690fc099\"}");
mockHttp.Expect(HttpMethod.Post, relayUrl + BoostRelay.SendPayloadPath)
.WithContent("{\"block\":{\"parentHash\":\"0x1c53bdbf457025f80c6971a9cf50986974eed02f0a9acaeeb49cafef10efd133\",\"feeRecipient\":\"0xb7705ae4c6f81b66cdb323c65f4e8133690fc099\",\"stateRoot\":\"0x1ef7300d8961797263939a3d29bbba4ccf1702fabf02d8ad7a20b454edb6fd2f\",\"receiptsRoot\":\"0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421\",\"logsBloom\":\"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\",\"prevRandao\":\"0x03783fac2efed8fbc9ad443e592ee30e61d65f471140c10ca155e937b435b760\",\"blockNumber\":\"0x1\",\"gasLimit\":\"0x3d0900\",\"gasUsed\":\"0x0\",\"timestamp\":\"0x3e9\",\"extraData\":\"0x\",\"baseFeePerGas\":\"0x0\",\"blockHash\":\"0xb519d89363b891216dbf9bd046f226cae9348a90ba0db00e7ade437fff7a1510\",\"transactions\":[]},\"profit\":\"0x0\"}");
DefaultHttpClient defaultHttpClient = new(mockHttp.ToHttpClient(), serializer, chain.LogManager, 1, 100);
BoostRelay boostRelay = new(defaultHttpClient, relayUrl);
BoostBlockImprovementContextFactory improvementContextFactory = new(chain.BlockProductionTrigger, TimeSpan.FromSeconds(5000), boostRelay, chain.StateReader);
TimeSpan timePerSlot = TimeSpan.FromSeconds(1000);
chain.PayloadPreparationService = new PayloadPreparationService(
chain.PostMergeBlockProducer !,
improvementContextFactory,
TimerFactory.Default,
chain.LogManager,
timePerSlot);
IEngineRpcModule rpc = CreateEngineModule(chain);
Keccak startingHead = chain.BlockTree.HeadHash;
ManualResetEvent wait = new(false);
chain.PayloadPreparationService.BlockImproved += (_, _) => wait.Set();
string payloadId = rpc.engine_forkchoiceUpdatedV1(new ForkchoiceStateV1(startingHead, Keccak.Zero, startingHead),
payloadAttributes).Result.Data
.PayloadId !;
await wait.WaitOneAsync(100, CancellationToken.None);
ResultWrapper <ExecutionPayloadV1?> response = await rpc.engine_getPayloadV1(Bytes.FromHexString(payloadId));
ExecutionPayloadV1 executionPayloadV1 = response.Data !;
executionPayloadV1.FeeRecipient.Should().Be(TestItem.AddressA);
executionPayloadV1.PrevRandao.Should().Be(TestItem.KeccakA);
mockHttp.VerifyNoOutstandingExpectation();
}
[Test]
private IEngineRpcModule CreateConsensusModule(MergeTestBlockchain chain)
{
return(new EngineRpcModule(
new AssembleBlockHandler(chain.BlockTree, chain.BlockProductionTrigger, chain.Timestamper, chain.LogManager),
new NewBlockHandler(chain.BlockTree, chain.BlockPreprocessorStep, chain.BlockchainProcessor, chain.State, new InitConfig(), chain.LogManager),
new SetHeadBlockHandler(chain.BlockTree, chain.State, chain.LogManager),
new FinaliseBlockHandler(chain.BlockFinder, chain.BlockFinalizationManager, chain.LogManager),
chain.LogManager));
}
public async Task forkChoiceUpdatedV1_unknown_block_initiates_syncing()
{
using MergeTestBlockchain chain = await CreateBlockChain();
IEngineRpcModule rpc = CreateEngineModule(chain);
Keccak? startingHead = chain.BlockTree.HeadHash;
BlockHeader parent = Build.A.BlockHeader
.WithNumber(1)
.WithHash(TestItem.KeccakA)
.WithNonce(0)
.WithDifficulty(0)
.TestObject;
Block block = Build.A.Block
.WithNumber(2)
.WithParent(parent)
.WithNonce(0)
.WithDifficulty(0)
.WithAuthor(Address.Zero)
.WithPostMergeFlag(true)
.TestObject;
await rpc.engine_newPayloadV1(new ExecutionPayloadV1(block));
// sync has not started yet
chain.BeaconSync.IsBeaconSyncHeadersFinished().Should().BeTrue();
chain.BeaconSync.IsBeaconSyncFinished(block.Header).Should().BeTrue();
chain.BeaconSync.ShouldBeInBeaconHeaders().Should().BeFalse();
chain.BeaconPivot.BeaconPivotExists().Should().BeFalse();
BlockTreePointers pointers = new()
{
BestKnownNumber = 0,
BestSuggestedHeader = chain.BlockTree.Genesis !,
BestSuggestedBody = chain.BlockTree.FindBlock(0) !,
BestKnownBeaconBlock = 0,
LowestInsertedHeader = null,
LowestInsertedBeaconHeader = null
};
AssertBlockTreePointers(chain.BlockTree, pointers);
ForkchoiceStateV1 forkchoiceStateV1 = new(block.Hash !, startingHead, startingHead);
ResultWrapper <ForkchoiceUpdatedV1Result> forkchoiceUpdatedResult =
await rpc.engine_forkchoiceUpdatedV1(forkchoiceStateV1);
forkchoiceUpdatedResult.Data.PayloadStatus.Status.Should()
.Be(nameof(PayloadStatusV1.Syncing).ToUpper());
chain.BeaconSync.ShouldBeInBeaconHeaders().Should().BeTrue();
chain.BeaconSync.IsBeaconSyncHeadersFinished().Should().BeFalse();
chain.BeaconSync.IsBeaconSyncFinished(chain.BlockTree.FindBlock(block.Hash)?.Header).Should().BeFalse();
AssertBeaconPivotValues(chain.BeaconPivot, block.Header);
pointers.LowestInsertedBeaconHeader = block.Header;
pointers.BestKnownBeaconBlock = block.Number;
pointers.LowestInsertedHeader = block.Header;
AssertBlockTreePointers(chain.BlockTree, pointers);
AssertExecutionStatusNotChangedV1(rpc, block.Hash !, startingHead, startingHead);
}
public async Task assembleBlock_should_not_create_block_with_unknown_parent()
{
using MergeTestBlockchain chain = await CreateBlockChain();
IConsensusRpcModule rpc = CreateConsensusModule(chain);
Keccak notExistingHash = TestItem.KeccakH;
AssembleBlockRequest assembleBlockRequest = new() { ParentHash = notExistingHash };
ResultWrapper <BlockRequestResult?> response = await rpc.consensus_assembleBlock(assembleBlockRequest);
response.Data.Should().BeNull();
}
private (UInt256, UInt256) AddTransactions(MergeTestBlockchain chain, ExecutionPayloadV1 executePayloadRequest,
PrivateKey from, Address to, uint count, int value, out BlockHeader parentHeader)
{
Transaction[] transactions = BuildTransactions(chain, executePayloadRequest.ParentHash, from, to, count, value,
out Account accountFrom, out parentHeader);
executePayloadRequest.SetTransactions(transactions);
UInt256 totalValue = ((int)(count * value)).GWei();
return(accountFrom.Balance - totalValue,
chain.StateReader.GetBalance(parentHeader.StateRoot !, to) + totalValue);
}
public async Task finaliseBlock_should_succeed()
{
using MergeTestBlockchain chain = await CreateBlockChain();
IEngineRpcModule rpc = CreateConsensusModule(chain);
Block block = Build.A.Block.WithParent(chain.BlockTree.Head !).TestObject;
chain.BlockTree.SuggestBlock(block);
ResultWrapper <Result> resultWrapper = await rpc.engine_finaliseBlock(block.Hash !);
resultWrapper.Data.Should().Be(Result.Ok);
}
public async Task newBlock_accepts_first_block()
{
using MergeTestBlockchain chain = await CreateBlockChain();
IConsensusRpcModule rpc = CreateConsensusModule(chain);
BlockRequestResult blockRequestResult = CreateBlockRequest(
CreateParentBlockRequestOnHead(chain.BlockTree),
TestItem.AddressD);
ResultWrapper <NewBlockResult> resultWrapper = await rpc.consensus_newBlock(blockRequestResult);
resultWrapper.Data.Valid.Should().BeTrue();
new BlockRequestResult(chain.BlockTree.BestSuggestedBody).Should().BeEquivalentTo(blockRequestResult);
}
public async Task can_progress_chain_one_by_one(int count)
{
using MergeTestBlockchain chain = await CreateBlockChain();
IConsensusRpcModule rpc = CreateConsensusModule(chain);
Keccak lastHash = (await ProduceBranch(rpc, chain.BlockTree, count, chain.BlockTree.HeadHash, true)).Last().BlockHash;
chain.BlockTree.HeadHash.Should().Be(lastHash);
Block?last = RunForAllBlocksInBranch(chain.BlockTree, chain.BlockTree.HeadHash, b => b.IsGenesis, true);
last.Should().NotBeNull();
last !.IsGenesis.Should().BeTrue();
}
public async Task setHead_no_common_branch_fails()
{
using MergeTestBlockchain chain = await CreateBlockChain();
IConsensusRpcModule rpc = CreateConsensusModule(chain);
BlockHeader parent = Build.A.BlockHeader.WithNumber(1).WithHash(TestItem.KeccakA).TestObject;
Block block = Build.A.Block.WithNumber(2).WithParent(parent).TestObject;
chain.BlockTree.SuggestBlock(block);
ResultWrapper <Result> setHeadResult = await rpc.consensus_setHead(block.Hash !);
setHeadResult.Data.success.Should().BeFalse();
}
public async Task should_return_invalid_lvh_null_on_invalid_blocks_during_the_sync()
{
using MergeTestBlockchain chain = await CreateBlockChain();
IEngineRpcModule rpc = CreateEngineModule(chain);
Keccak? startingHead = chain.BlockTree.HeadHash;
BlockHeader parent = Build.A.BlockHeader
.WithNumber(1)
.WithHash(TestItem.KeccakA)
.WithNonce(0)
.WithDifficulty(0)
.TestObject;
Block block = Build.A.Block
.WithNumber(2)
.WithParent(parent)
.WithNonce(0)
.WithDifficulty(0)
.WithAuthor(Address.Zero)
.WithPostMergeFlag(true)
.TestObject;
ExecutionPayloadV1 startingNewPayload = new(block);
await rpc.engine_newPayloadV1(startingNewPayload);
ForkchoiceStateV1 forkchoiceStateV1 = new(block.Hash !, startingHead, startingHead);
ResultWrapper <ForkchoiceUpdatedV1Result> forkchoiceUpdatedResult =
await rpc.engine_forkchoiceUpdatedV1(forkchoiceStateV1);
forkchoiceUpdatedResult.Data.PayloadStatus.Status.Should()
.Be(nameof(PayloadStatusV1.Syncing).ToUpper());
ExecutionPayloadV1[] requests = CreateBlockRequestBranch(startingNewPayload, TestItem.AddressD, 1);
foreach (ExecutionPayloadV1 r in requests)
{
ResultWrapper <PayloadStatusV1> payloadStatus = await rpc.engine_newPayloadV1(r);
payloadStatus.Data.Status.Should().Be(nameof(PayloadStatusV1.Syncing).ToUpper());
}
ExecutionPayloadV1[] invalidRequests = CreateBlockRequestBranch(requests[0], TestItem.AddressD, 1);
foreach (ExecutionPayloadV1 r in invalidRequests)
{
r.TryGetBlock(out Block? newBlock);
newBlock !.Header.GasLimit = long.MaxValue; // incorrect gas limit
newBlock.Header.Hash = newBlock.CalculateHash();
ResultWrapper <PayloadStatusV1> payloadStatus = await rpc.engine_newPayloadV1(new ExecutionPayloadV1(newBlock));
payloadStatus.Data.Status.Should().Be(nameof(PayloadStatusV1.Invalid).ToUpper());
payloadStatus.Data.LatestValidHash.Should().BeNull();
}
}
public async Task newBlock_accepts_already_known_block()
{
using MergeTestBlockchain chain = await CreateBlockChain();
IConsensusRpcModule rpc = CreateConsensusModule(chain);
Block block = Build.A.Block.WithNumber(1).WithParent(chain.BlockTree.Head).TestObject;
block.Header.Hash = new Keccak("0xdc3419cbd81455372f3e576f930560b35ec828cd6cdfbd4958499e43c68effdf");
chain.BlockTree.SuggestBlock(block);
ResultWrapper <NewBlockResult> newBlockResult = await rpc.consensus_newBlock(new BlockRequestResult(block));
newBlockResult.Data.Valid.Should().BeTrue();
}
public async Task forkchoiceUpdatedV1_should_ignore_gas_limit([Values(false, true)] bool relay)
{
MergeConfig mergeConfig = new() { Enabled = true, SecondsPerSlot = 1, TerminalTotalDifficulty = "0" };
using MergeTestBlockchain chain = await CreateBlockChain(mergeConfig);
IBlockImprovementContextFactory improvementContextFactory;
if (relay)
{
IBoostRelay boostRelay = Substitute.For <IBoostRelay>();
boostRelay.GetPayloadAttributes(Arg.Any <PayloadAttributes>(), Arg.Any <CancellationToken>())
.Returns(c => c.Arg <PayloadAttributes>());
improvementContextFactory = new BoostBlockImprovementContextFactory(chain.BlockProductionTrigger, TimeSpan.FromSeconds(5), boostRelay, chain.StateReader);
}
else
{
improvementContextFactory = new BlockImprovementContextFactory(chain.BlockProductionTrigger, TimeSpan.FromSeconds(5));
}
TimeSpan timePerSlot = TimeSpan.FromSeconds(10);
chain.PayloadPreparationService = new PayloadPreparationService(
chain.PostMergeBlockProducer !,
improvementContextFactory,
TimerFactory.Default,
chain.LogManager,
timePerSlot);
IEngineRpcModule rpc = CreateEngineModule(chain);
Keccak startingHead = chain.BlockTree.HeadHash;
UInt256 timestamp = Timestamper.UnixTime.Seconds;
Keccak random = Keccak.Zero;
Address feeRecipient = Address.Zero;
string payloadId = rpc.engine_forkchoiceUpdatedV1(new ForkchoiceStateV1(startingHead, Keccak.Zero, startingHead),
new PayloadAttributes {
Timestamp = timestamp, SuggestedFeeRecipient = feeRecipient, PrevRandao = random, GasLimit = 10_000_000L
}).Result.Data
.PayloadId !;
ResultWrapper <ExecutionPayloadV1?> response = await rpc.engine_getPayloadV1(Bytes.FromHexString(payloadId));
ExecutionPayloadV1 executionPayloadV1 = response.Data !;
executionPayloadV1.GasLimit.Should().Be(4_000_000L);
}
public async Task setHead_can_reorganize_to_any_block()
{
using MergeTestBlockchain chain = await CreateBlockChain();
IConsensusRpcModule rpc = CreateConsensusModule(chain);
async Task CanReorganizeToBlock(BlockRequestResult block, MergeTestBlockchain testChain)
{
ResultWrapper <Result> result = await rpc.consensus_setHead(block.BlockHash);
result.Data.Should().Be(Result.OK);
testChain.BlockTree.HeadHash.Should().Be(block.BlockHash);
testChain.BlockTree.Head !.Number.Should().Be(block.Number);
testChain.State.StateRoot.Should().Be(testChain.BlockTree.Head !.StateRoot !);
}
async Task CanReorganizeToAnyBlock(MergeTestBlockchain testChain, params IReadOnlyList <BlockRequestResult>[] branches)
public async Task newBlock_rejects_incorrect_input(Action <BlockRequestResult> breakerAction)
{
using MergeTestBlockchain chain = await CreateBlockChain();
IConsensusRpcModule rpc = CreateConsensusModule(chain);
BlockRequestResult assembleBlockResult = await GetAssembleBlockResult(chain, rpc);
Keccak blockHash = assembleBlockResult.BlockHash;
breakerAction(assembleBlockResult);
if (blockHash == assembleBlockResult.BlockHash && TryCalculateHash(assembleBlockResult, out var hash))
{
assembleBlockResult.BlockHash = hash;
}
ResultWrapper <NewBlockResult> newBlockResult = await rpc.consensus_newBlock(assembleBlockResult);
newBlockResult.Data.Valid.Should().BeFalse();
}
private Transaction[] BuildTransactions(MergeTestBlockchain chain, Keccak parentHash, PrivateKey from,
Address to, uint count, int value, out Account accountFrom, out BlockHeader parentHeader)
{
Transaction BuildTransaction(uint index, Account senderAccount) =>
Build.A.Transaction.WithNonce(senderAccount.Nonce + index)
.WithTimestamp(Timestamper.UnixTime.Seconds)
.WithTo(to)
.WithValue(value.GWei())
.WithGasPrice(1.GWei())
.WithChainId(chain.SpecProvider.ChainId)
.WithSenderAddress(from.Address)
.SignedAndResolved(from)
.TestObject;
parentHeader = chain.BlockTree.FindHeader(parentHash, BlockTreeLookupOptions.None) !;
Account account = chain.StateReader.GetAccount(parentHeader.StateRoot !, @from.Address) !;
accountFrom = account;
return(Enumerable.Range(0, (int)count)
.Select(i => BuildTransaction((uint)i, account)).ToArray());
}
public async Task assembleBlock_should_create_block_on_top_of_genesis()
{
using MergeTestBlockchain chain = await CreateBlockChain();
IConsensusRpcModule rpc = CreateConsensusModule(chain);
Keccak startingHead = chain.BlockTree.HeadHash;
UInt256 timestamp = Timestamper.UnixTime.Seconds;
AssembleBlockRequest assembleBlockRequest = new() { ParentHash = startingHead, Timestamp = timestamp };
ResultWrapper <BlockRequestResult?> response = await rpc.consensus_assembleBlock(assembleBlockRequest);
BlockRequestResult expected = CreateParentBlockRequestOnHead(chain.BlockTree);
expected.GasLimit = 4000000L;
expected.BlockHash = new Keccak("0xfe37027d377e75ffb161f11733d8880083378fe6236270c7a2ee1fc7efe71cfd");
expected.LogsBloom = Bloom.Empty;
expected.Miner = chain.MinerAddress;
expected.Number = 1;
expected.ParentHash = startingHead;
expected.SetTransactions(Array.Empty <Transaction>());
expected.Timestamp = timestamp;
response.Data.Should().BeEquivalentTo(expected);
}
public async Task setHead_should_change_head()
{
using MergeTestBlockchain chain = await CreateBlockChain();
IConsensusRpcModule rpc = CreateConsensusModule(chain);
Keccak startingHead = chain.BlockTree.HeadHash;
BlockRequestResult blockRequestResult = CreateBlockRequest(
CreateParentBlockRequestOnHead(chain.BlockTree),
TestItem.AddressD);
ResultWrapper <NewBlockResult> newBlockResult = await rpc.consensus_newBlock(blockRequestResult);
newBlockResult.Data.Valid.Should().BeTrue();
Keccak newHeadHash = blockRequestResult.BlockHash;
ResultWrapper <Result> setHeadResult = await rpc.consensus_setHead(newHeadHash !);
setHeadResult.Data.Should().Be(Result.OK);
Keccak actualHead = chain.BlockTree.HeadHash;
actualHead.Should().NotBe(startingHead);
actualHead.Should().Be(newHeadHash);
}
public async Task newBlock_accepts_previously_assembled_block_multiple_times([Values(1, 3)] int times)
{
using MergeTestBlockchain chain = await CreateBlockChain();
IConsensusRpcModule rpc = CreateConsensusModule(chain);
Keccak startingHead = chain.BlockTree.HeadHash;
BlockHeader startingBestSuggestedHeader = chain.BlockTree.BestSuggestedHeader !;
AssembleBlockRequest assembleBlockRequest = new() { ParentHash = startingHead };
ResultWrapper <BlockRequestResult?> assembleBlockResult = await rpc.consensus_assembleBlock(assembleBlockRequest);
assembleBlockResult.Data !.ParentHash.Should().Be(startingHead);
for (int i = 0; i < times; i++)
{
ResultWrapper <NewBlockResult> newBlockResult = await rpc.consensus_newBlock(assembleBlockResult.Data !);
newBlockResult.Data.Valid.Should().BeTrue();
}
Keccak bestSuggestedHeaderHash = chain.BlockTree.BestSuggestedHeader !.Hash !;
bestSuggestedHeaderHash.Should().Be(assembleBlockResult.Data !.BlockHash);
bestSuggestedHeaderHash.Should().NotBe(startingBestSuggestedHeader !.Hash !);
}
public async Task forkchoiceUpdatedV1_should_communicate_with_boost_relay()
{
MergeConfig mergeConfig = new() { Enabled = true, SecondsPerSlot = 1, TerminalTotalDifficulty = "0" };
using MergeTestBlockchain chain = await CreateBlockChain(mergeConfig);
IBoostRelay boostRelay = Substitute.For <IBoostRelay>();
boostRelay.GetPayloadAttributes(Arg.Any <PayloadAttributes>(), Arg.Any <CancellationToken>())
.Returns(c =>
{
PayloadAttributes payloadAttributes = c.Arg <PayloadAttributes>();
payloadAttributes.SuggestedFeeRecipient = TestItem.AddressA;
payloadAttributes.PrevRandao = TestItem.KeccakA;
payloadAttributes.Timestamp += 1;
payloadAttributes.GasLimit = 10_000_000L;
return(payloadAttributes);
});
BoostBlockImprovementContextFactory improvementContextFactory = new(chain.BlockProductionTrigger, TimeSpan.FromSeconds(5), boostRelay, chain.StateReader);
TimeSpan timePerSlot = TimeSpan.FromSeconds(10);
chain.PayloadPreparationService = new PayloadPreparationService(
chain.PostMergeBlockProducer !,
improvementContextFactory,
TimerFactory.Default,
chain.LogManager,
timePerSlot);
IEngineRpcModule rpc = CreateEngineModule(chain);
Keccak startingHead = chain.BlockTree.HeadHash;
UInt256 timestamp = Timestamper.UnixTime.Seconds;
Keccak random = Keccak.Zero;
Address feeRecipient = Address.Zero;
BoostExecutionPayloadV1?sentItem = null;
boostRelay.When(b => b.SendPayload(Arg.Any <BoostExecutionPayloadV1>(), Arg.Any <CancellationToken>()))
.Do(c => sentItem = c.Arg <BoostExecutionPayloadV1>());
ManualResetEvent wait = new(false);
chain.PayloadPreparationService.BlockImproved += (_, _) => wait.Set();
string payloadId = rpc.engine_forkchoiceUpdatedV1(new ForkchoiceStateV1(startingHead, Keccak.Zero, startingHead),
new PayloadAttributes {
Timestamp = timestamp, SuggestedFeeRecipient = feeRecipient, PrevRandao = random
}).Result.Data
.PayloadId !;
await wait.WaitOneAsync(100, CancellationToken.None);
ResultWrapper <ExecutionPayloadV1?> response = await rpc.engine_getPayloadV1(Bytes.FromHexString(payloadId));
ExecutionPayloadV1 executionPayloadV1 = response.Data !;
executionPayloadV1.FeeRecipient.Should().Be(TestItem.AddressA);
executionPayloadV1.PrevRandao.Should().Be(TestItem.KeccakA);
executionPayloadV1.GasLimit.Should().Be(10_000_000L);
executionPayloadV1.Should().BeEquivalentTo(sentItem !.Block);
sentItem.Profit.Should().Be(0);
}