From 60608c9010ab4b577818d30c53a1d5587d9d145d Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Fri, 12 Apr 2024 13:41:48 +0530 Subject: [PATCH 01/44] add params for eip2935 --- .../Blockchain/TestBlockchain.cs | 6 +++++ .../Nethermind.Core/Eip2935Constants.cs | 19 ++++++++++++++++ .../Nethermind.Core/Specs/IReleaseSpec.cs | 9 +++++++- .../MainnetSpecProviderTests.cs | 15 +++++++++++++ .../OverridableReleaseSpec.cs | 2 ++ .../ChainSpecStyle/ChainParameters.cs | 2 ++ .../ChainSpecBasedSpecProvider.cs | 2 ++ .../ChainSpecStyle/ChainSpecLoader.cs | 2 ++ .../Json/ChainSpecParamsJson.cs | 2 ++ .../Nethermind.Specs/Forks/18_Prague.cs | 22 +++++++++++++++++++ .../Nethermind.Specs/MainnetSpecProvider.cs | 5 +++-- .../Nethermind.Specs/ReleaseSpec.cs | 9 ++++++++ .../SystemTransactionReleaseSpec.cs | 2 ++ 13 files changed, 94 insertions(+), 3 deletions(-) create mode 100644 src/Nethermind/Nethermind.Core/Eip2935Constants.cs create mode 100644 src/Nethermind/Nethermind.Specs/Forks/18_Prague.cs diff --git a/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs b/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs index 9131ce20ba1..b038088c34e 100644 --- a/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs +++ b/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs @@ -129,6 +129,12 @@ protected virtual async Task Build(ISpecProvider? specProvider = State.CreateAccount(SpecProvider.GenesisSpec.Eip4788ContractAddress, 1); } + // Eip2935 + if (specProvider?.GenesisSpec?.IsBlockHashInStateAvailable ?? false) + { + State.CreateAccount(SpecProvider.GenesisSpec.Eip2935ContractAddress, 1); + } + State.CreateAccount(TestItem.AddressA, (initialValues ?? InitialValue)); State.CreateAccount(TestItem.AddressB, (initialValues ?? InitialValue)); State.CreateAccount(TestItem.AddressC, (initialValues ?? InitialValue)); diff --git a/src/Nethermind/Nethermind.Core/Eip2935Constants.cs b/src/Nethermind/Nethermind.Core/Eip2935Constants.cs new file mode 100644 index 00000000000..eba7142871a --- /dev/null +++ b/src/Nethermind/Nethermind.Core/Eip2935Constants.cs @@ -0,0 +1,19 @@ +// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using Nethermind.Int256; + +namespace Nethermind.Core; + +/// +/// Represents the EIP-4788 parameters. +/// +public static class Eip2935Constants +{ + /// + /// Gets the HISTORY_STORAGE_ADDRESS parameter. + /// + public static readonly Address BlockHashHistoryAddress = new("0xfffffffffffffffffffffffffffffffffffffffe"); + + public static readonly long RingBufferSize = 256; +} diff --git a/src/Nethermind/Nethermind.Core/Specs/IReleaseSpec.cs b/src/Nethermind/Nethermind.Core/Specs/IReleaseSpec.cs index f7e8519de72..22232309ee7 100644 --- a/src/Nethermind/Nethermind.Core/Specs/IReleaseSpec.cs +++ b/src/Nethermind/Nethermind.Core/Specs/IReleaseSpec.cs @@ -273,6 +273,12 @@ public interface IReleaseSpec : IEip1559Spec, IReceiptSpec bool IsEip4788Enabled { get; } Address Eip4788ContractAddress { get; } + /// + /// Save historical block hashes in state + /// + bool IsEip2935Enabled { get; } + Address Eip2935ContractAddress { get; } + /// /// SELFDESTRUCT only in same transaction /// @@ -288,7 +294,7 @@ public interface IReleaseSpec : IEip1559Spec, IReceiptSpec public ulong Eip4844TransitionTimestamp { get; } - // STATE related + // STATE related public bool ClearEmptyAccountWhenTouched => IsEip158Enabled; // VM @@ -359,6 +365,7 @@ public interface IReleaseSpec : IEip1559Spec, IReceiptSpec public bool SelfdestructOnlyOnSameTransaction => IsEip6780Enabled; public bool IsBeaconBlockRootAvailable => IsEip4788Enabled; + public bool IsBlockHashInStateAvailable => IsEip2935Enabled; public bool MCopyIncluded => IsEip5656Enabled; public bool BlobBaseFeeEnabled => IsEip4844Enabled; } diff --git a/src/Nethermind/Nethermind.Specs.Test/MainnetSpecProviderTests.cs b/src/Nethermind/Nethermind.Specs.Test/MainnetSpecProviderTests.cs index 095ece65f81..9809cdb69fa 100644 --- a/src/Nethermind/Nethermind.Specs.Test/MainnetSpecProviderTests.cs +++ b/src/Nethermind/Nethermind.Specs.Test/MainnetSpecProviderTests.cs @@ -57,6 +57,21 @@ public void Cancun_eips(long blockNumber, ulong timestamp, bool isEnabled) } } + [TestCase(MainnetSpecProvider.ParisBlockNumber, MainnetSpecProvider.CancunBlockTimestamp, false)] + [TestCase(MainnetSpecProvider.ParisBlockNumber, MainnetSpecProvider.PragueBlockTimestamp, true)] + public void Prague_eips(long blockNumber, ulong timestamp, bool isEnabled) + { + _specProvider.GetSpec(new ForkActivation(blockNumber, timestamp)).IsEip2935Enabled.Should().Be(isEnabled); + if (isEnabled) + { + _specProvider.GetSpec(new ForkActivation(blockNumber, timestamp)).Eip2935ContractAddress.Should().NotBeNull(); + } + else + { + _specProvider.GetSpec(new ForkActivation(blockNumber, timestamp)).Eip2935ContractAddress.Should().BeNull(); + } + } + [Test] public void Dao_block_number_is_correct() { diff --git a/src/Nethermind/Nethermind.Specs.Test/OverridableReleaseSpec.cs b/src/Nethermind/Nethermind.Specs.Test/OverridableReleaseSpec.cs index b36a57071d0..13de7306664 100644 --- a/src/Nethermind/Nethermind.Specs.Test/OverridableReleaseSpec.cs +++ b/src/Nethermind/Nethermind.Specs.Test/OverridableReleaseSpec.cs @@ -157,6 +157,8 @@ public ulong Eip4844TransitionTimestamp public bool IsEip6780Enabled => _spec.IsEip6780Enabled; public bool IsEip4788Enabled => _spec.IsEip4788Enabled; public Address Eip4788ContractAddress => _spec.Eip4788ContractAddress; + public bool IsEip2935Enabled => _spec.IsEip2935Enabled; + public Address Eip2935ContractAddress => _spec.Eip2935ContractAddress; public UInt256 ForkBaseFee => _spec.ForkBaseFee; public UInt256 BaseFeeMaxChangeDenominator => _spec.BaseFeeMaxChangeDenominator; public long ElasticityMultiplier => _spec.ElasticityMultiplier; diff --git a/src/Nethermind/Nethermind.Specs/ChainSpecStyle/ChainParameters.cs b/src/Nethermind/Nethermind.Specs/ChainSpecStyle/ChainParameters.cs index 817250bc01e..41fa983d646 100644 --- a/src/Nethermind/Nethermind.Specs/ChainSpecStyle/ChainParameters.cs +++ b/src/Nethermind/Nethermind.Specs/ChainSpecStyle/ChainParameters.cs @@ -117,6 +117,8 @@ public class ChainParameters public ulong? Eip6780TransitionTimestamp { get; set; } public ulong? Eip4788TransitionTimestamp { get; set; } public Address Eip4788ContractAddress { get; set; } + public ulong? Eip2935TransitionTimestamp { get; set; } + public Address Eip2935ContractAddress { get; set; } #region EIP-4844 parameters /// diff --git a/src/Nethermind/Nethermind.Specs/ChainSpecStyle/ChainSpecBasedSpecProvider.cs b/src/Nethermind/Nethermind.Specs/ChainSpecStyle/ChainSpecBasedSpecProvider.cs index 7aad4bac04f..f2b2a6fbce8 100644 --- a/src/Nethermind/Nethermind.Specs/ChainSpecStyle/ChainSpecBasedSpecProvider.cs +++ b/src/Nethermind/Nethermind.Specs/ChainSpecStyle/ChainSpecBasedSpecProvider.cs @@ -251,6 +251,8 @@ private static ReleaseSpec CreateReleaseSpec(ChainSpec chainSpec, long releaseSt releaseSpec.IsEip6780Enabled = (chainSpec.Parameters.Eip6780TransitionTimestamp ?? ulong.MaxValue) <= releaseStartTimestamp; releaseSpec.IsEip4788Enabled = (chainSpec.Parameters.Eip4788TransitionTimestamp ?? ulong.MaxValue) <= releaseStartTimestamp; releaseSpec.Eip4788ContractAddress = chainSpec.Parameters.Eip4788ContractAddress; + releaseSpec.IsEip2935Enabled = (chainSpec.Parameters.Eip2935TransitionTimestamp ?? ulong.MaxValue) <= releaseStartTimestamp; + releaseSpec.Eip2935ContractAddress = chainSpec.Parameters.Eip2935ContractAddress; return releaseSpec; } diff --git a/src/Nethermind/Nethermind.Specs/ChainSpecStyle/ChainSpecLoader.cs b/src/Nethermind/Nethermind.Specs/ChainSpecStyle/ChainSpecLoader.cs index db4155117c8..512a4537cdf 100644 --- a/src/Nethermind/Nethermind.Specs/ChainSpecStyle/ChainSpecLoader.cs +++ b/src/Nethermind/Nethermind.Specs/ChainSpecStyle/ChainSpecLoader.cs @@ -143,6 +143,8 @@ private void LoadParameters(ChainSpecJson chainSpecJson, ChainSpec chainSpec) Eip6780TransitionTimestamp = chainSpecJson.Params.Eip6780TransitionTimestamp, Eip4788TransitionTimestamp = chainSpecJson.Params.Eip4788TransitionTimestamp, Eip4788ContractAddress = chainSpecJson.Params.Eip4788ContractAddress ?? Eip4788Constants.BeaconRootsAddress, + Eip2935TransitionTimestamp = chainSpecJson.Params.Eip2935TransitionTimestamp, + Eip2935ContractAddress = chainSpecJson.Params.Eip2935ContractAddress ?? Eip2935Constants.BlockHashHistoryAddress, TransactionPermissionContract = chainSpecJson.Params.TransactionPermissionContract, TransactionPermissionContractTransition = chainSpecJson.Params.TransactionPermissionContractTransition, ValidateChainIdTransition = chainSpecJson.Params.ValidateChainIdTransition, diff --git a/src/Nethermind/Nethermind.Specs/ChainSpecStyle/Json/ChainSpecParamsJson.cs b/src/Nethermind/Nethermind.Specs/ChainSpecStyle/Json/ChainSpecParamsJson.cs index 5f22e8e6a85..283f755d9f0 100644 --- a/src/Nethermind/Nethermind.Specs/ChainSpecStyle/Json/ChainSpecParamsJson.cs +++ b/src/Nethermind/Nethermind.Specs/ChainSpecStyle/Json/ChainSpecParamsJson.cs @@ -141,6 +141,8 @@ internal class ChainSpecParamsJson public ulong? Eip6780TransitionTimestamp { get; set; } public ulong? Eip4788TransitionTimestamp { get; set; } public Address Eip4788ContractAddress { get; set; } + public ulong? Eip2935TransitionTimestamp { get; set; } + public Address Eip2935ContractAddress { get; set; } public UInt256? Eip4844BlobGasPriceUpdateFraction { get; set; } public ulong? Eip4844MaxBlobGasPerBlock { get; set; } public UInt256? Eip4844MinBlobGasPrice { get; set; } diff --git a/src/Nethermind/Nethermind.Specs/Forks/18_Prague.cs b/src/Nethermind/Nethermind.Specs/Forks/18_Prague.cs new file mode 100644 index 00000000000..0365673472f --- /dev/null +++ b/src/Nethermind/Nethermind.Specs/Forks/18_Prague.cs @@ -0,0 +1,22 @@ +// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System.Threading; +using Nethermind.Core; +using Nethermind.Core.Specs; + +namespace Nethermind.Specs.Forks; + +public class Prague: Cancun { + private static IReleaseSpec _instance; + + protected Prague() + { + Name = "Prague"; + IsEip2935Enabled = true; + Eip2935ContractAddress = Eip2935Constants.BlockHashHistoryAddress; + } + + public new static IReleaseSpec Instance => LazyInitializer.EnsureInitialized(ref _instance, () => new Prague()); + +} diff --git a/src/Nethermind/Nethermind.Specs/MainnetSpecProvider.cs b/src/Nethermind/Nethermind.Specs/MainnetSpecProvider.cs index 4108dffe7b8..ce8148f311a 100644 --- a/src/Nethermind/Nethermind.Specs/MainnetSpecProvider.cs +++ b/src/Nethermind/Nethermind.Specs/MainnetSpecProvider.cs @@ -47,7 +47,8 @@ public class MainnetSpecProvider : ISpecProvider { BlockNumber: < ParisBlockNumber } => GrayGlacier.Instance, { Timestamp: null } or { Timestamp: < ShanghaiBlockTimestamp } => Paris.Instance, { Timestamp: < CancunBlockTimestamp } => Shanghai.Instance, - _ => Cancun.Instance + { Timestamp: < PragueBlockTimestamp } => Cancun.Instance, + _ => Prague.Instance }; public void UpdateMergeTransitionInfo(long? blockNumber, UInt256? terminalTotalDifficulty = null) @@ -86,7 +87,7 @@ public void UpdateMergeTransitionInfo(long? blockNumber, UInt256? terminalTotalD (ForkActivation)GrayGlacierBlockNumber, ShanghaiActivation, CancunActivation, - //PragueActivation, + PragueActivation, //OsakaActivation }; diff --git a/src/Nethermind/Nethermind.Specs/ReleaseSpec.cs b/src/Nethermind/Nethermind.Specs/ReleaseSpec.cs index 5de83c8356b..810bf7987b8 100644 --- a/src/Nethermind/Nethermind.Specs/ReleaseSpec.cs +++ b/src/Nethermind/Nethermind.Specs/ReleaseSpec.cs @@ -91,5 +91,14 @@ public Address Eip4788ContractAddress get => IsEip4788Enabled ? _eip4788ContractAddress : null; set => _eip4788ContractAddress = value; } + + public bool IsEip2935Enabled { get; set; } + + private Address _eip2935ContractAddress; + public Address Eip2935ContractAddress + { + get => IsEip2935Enabled ? _eip2935ContractAddress : null; + set => _eip2935ContractAddress = value; + } } } diff --git a/src/Nethermind/Nethermind.Specs/SystemTransactionReleaseSpec.cs b/src/Nethermind/Nethermind.Specs/SystemTransactionReleaseSpec.cs index 8774d7a03ae..9226f4af9db 100644 --- a/src/Nethermind/Nethermind.Specs/SystemTransactionReleaseSpec.cs +++ b/src/Nethermind/Nethermind.Specs/SystemTransactionReleaseSpec.cs @@ -130,6 +130,8 @@ public bool IsEip158IgnoredAccount(Address address) public bool IsEip6780Enabled => _spec.IsEip6780Enabled; public bool IsEip4788Enabled => _spec.IsEip4788Enabled; public Address Eip4788ContractAddress => _spec.Eip4788ContractAddress; + public bool IsEip2935Enabled => _spec.IsEip2935Enabled; + public Address Eip2935ContractAddress => _spec.Eip2935ContractAddress; public UInt256 ForkBaseFee => _spec.ForkBaseFee; public UInt256 BaseFeeMaxChangeDenominator => _spec.BaseFeeMaxChangeDenominator; public long ElasticityMultiplier => _spec.ElasticityMultiplier; From 37513497753b2f4ec7b363d32e36f00fb56fd4fb Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Fri, 12 Apr 2024 13:41:56 +0530 Subject: [PATCH 02/44] Add handler --- .../BlockHashInStateHandler.cs | 39 +++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs diff --git a/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs b/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs new file mode 100644 index 00000000000..df0b7829afc --- /dev/null +++ b/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs @@ -0,0 +1,39 @@ +// SPDX-FileCopyrightText:2023 Demerzel Solutions Limited +// SPDX-License-Identifier:LGPL-3.0-only + +using System; +using Nethermind.Core; +using Nethermind.Core.Crypto; +using Nethermind.Core.Extensions; +using Nethermind.Core.Specs; +using Nethermind.Evm.Tracing; +using Nethermind.Int256; +using Nethermind.State; + +namespace Nethermind.Blockchain.BlockHashInState; + +public interface IBlockHashInStateHandler +{ + public void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec, IWorldState stateProvider, IBlockTracer blockTracer); +} + +public class BlockHashInStateHandler : IBlockHashInStateHandler +{ + + public void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec, IWorldState stateProvider, IBlockTracer blockTracer) + { + if (!spec.IsEip2935Enabled || + blockHeader.IsGenesis || + blockHeader.ParentHash is null) return; + Address? eip2935Account = spec.Eip2935ContractAddress ?? Eip2935Constants.BlockHashHistoryAddress; + + if (!stateProvider.AccountExists(eip2935Account)) + return; + + Hash256 parentBlockHash = blockHeader.ParentHash; + var blockIndex = new UInt256((ulong)((blockHeader.Number - 1) % Eip2935Constants.RingBufferSize)); + + StorageCell blockHashStoreCell = new(eip2935Account, blockIndex); + stateProvider.Set(blockHashStoreCell, parentBlockHash.Bytes.WithoutLeadingZeros().ToArray()); + } +} From 1cb6d5414f56a5406121ad212bcfd74b9c9ef27e Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Fri, 12 Apr 2024 14:07:53 +0530 Subject: [PATCH 03/44] Add block tree to block processor --- ...ctionRpcModuleTests.TestAccountAbstractionRpcBlockchain.cs | 1 + .../Nethermind.Blockchain.Test/BlockProcessorTests.cs | 3 +++ .../Producers/DevBlockproducerTests.cs | 1 + src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs | 1 + .../Nethermind.Clique.Test/CliqueBlockProducerTests.cs | 2 ++ .../Nethermind.Consensus.AuRa/AuRaBlockProcessor.cs | 1 + src/Nethermind/Nethermind.Consensus.Clique/CliquePlugin.cs | 1 + src/Nethermind/Nethermind.Consensus.Ethash/NethDevPlugin.cs | 1 + .../Nethermind.Consensus/Processing/BlockProcessor.cs | 4 +++- .../Processing/ReadOnlyChainProcessingEnv.cs | 1 + .../Nethermind.Consensus/Producers/BlockProducerEnvFactory.cs | 1 + .../Nethermind.Core.Test/Blockchain/TestBlockchain.cs | 1 + src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs | 2 ++ .../Modules/Trace/ParityStyleTracerTests.cs | 1 + .../Nethermind.Merge.AuRa.Test/AuRaMergeEngineModuleTests.cs | 1 + .../Nethermind.Merge.Plugin.Test/EngineModuleTests.Setup.cs | 1 + .../MevRpcModuleTests.TestMevRpcBlockchain.cs | 1 + .../Nethermind.Optimism/InitializeBlockchainOptimism.cs | 1 + src/Nethermind/Nethermind.Optimism/OptimismBlockProcessor.cs | 4 +++- .../Nethermind.Optimism/OptimismBlockProducerEnvFactory.cs | 1 + .../Nethermind.Synchronization.Test/SyncThreadTests.cs | 2 ++ 21 files changed, 30 insertions(+), 2 deletions(-) diff --git a/src/Nethermind/Nethermind.AccountAbstraction.Test/AccountAbstractionRpcModuleTests.TestAccountAbstractionRpcBlockchain.cs b/src/Nethermind/Nethermind.AccountAbstraction.Test/AccountAbstractionRpcModuleTests.TestAccountAbstractionRpcBlockchain.cs index c56265edd8a..f594f974315 100644 --- a/src/Nethermind/Nethermind.AccountAbstraction.Test/AccountAbstractionRpcModuleTests.TestAccountAbstractionRpcBlockchain.cs +++ b/src/Nethermind/Nethermind.AccountAbstraction.Test/AccountAbstractionRpcModuleTests.TestAccountAbstractionRpcBlockchain.cs @@ -190,6 +190,7 @@ protected override BlockProcessor CreateBlockProcessor() State, ReceiptStorage, NullWitnessCollector.Instance, + BlockTree, LogManager); AbiParameterConverter.RegisterFactory(new AbiTypeFactory(new AbiTuple())); diff --git a/src/Nethermind/Nethermind.Blockchain.Test/BlockProcessorTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/BlockProcessorTests.cs index 50c870d1040..422b29d59d0 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/BlockProcessorTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/BlockProcessorTests.cs @@ -49,6 +49,7 @@ public void Prepared_block_contains_author_field() stateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, + Substitute.For(), LimboLogs.Instance); BlockHeader header = Build.A.BlockHeader.WithAuthor(TestItem.AddressD).TestObject; @@ -80,6 +81,7 @@ public void Can_store_a_witness() stateProvider, NullReceiptStorage.Instance, witnessCollector, + Substitute.For(), LimboLogs.Instance); BlockHeader header = Build.A.BlockHeader.WithAuthor(TestItem.AddressD).TestObject; @@ -109,6 +111,7 @@ public void Recovers_state_on_cancel() stateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, + Substitute.For(), LimboLogs.Instance); BlockHeader header = Build.A.BlockHeader.WithNumber(1).WithAuthor(TestItem.AddressD).TestObject; diff --git a/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs index 71409777e35..b88cc0810d4 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs @@ -73,6 +73,7 @@ public void Test() stateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, + blockTree, LimboLogs.Instance); BlockchainProcessor blockchainProcessor = new( blockTree, diff --git a/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs index e252a296774..e21a236931e 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs @@ -75,6 +75,7 @@ public void Setup() stateProvider, NullReceiptStorage.Instance, new WitnessCollector(memDbProvider.StateDb, LimboLogs.Instance), + _blockTree, LimboLogs.Instance); _blockchainProcessor = new BlockchainProcessor( _blockTree, diff --git a/src/Nethermind/Nethermind.Clique.Test/CliqueBlockProducerTests.cs b/src/Nethermind/Nethermind.Clique.Test/CliqueBlockProducerTests.cs index b4b0386a81e..60437fd51fd 100644 --- a/src/Nethermind/Nethermind.Clique.Test/CliqueBlockProducerTests.cs +++ b/src/Nethermind/Nethermind.Clique.Test/CliqueBlockProducerTests.cs @@ -137,6 +137,7 @@ public On CreateNode(PrivateKey privateKey, bool withGenesisAlreadyProcessed = f stateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, + blockTree, nodeLogManager); BlockchainProcessor processor = new(blockTree, blockProcessor, new AuthorRecoveryStep(snapshotManager), stateReader, nodeLogManager, BlockchainProcessor.Options.NoReceipts); @@ -156,6 +157,7 @@ public On CreateNode(PrivateKey privateKey, bool withGenesisAlreadyProcessed = f minerStateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, + blockTree, nodeLogManager); BlockchainProcessor minerProcessor = new(blockTree, minerBlockProcessor, new AuthorRecoveryStep(snapshotManager), stateReader, nodeLogManager, BlockchainProcessor.Options.NoReceipts); diff --git a/src/Nethermind/Nethermind.Consensus.AuRa/AuRaBlockProcessor.cs b/src/Nethermind/Nethermind.Consensus.AuRa/AuRaBlockProcessor.cs index 42885a70090..dab1eeeb9b6 100644 --- a/src/Nethermind/Nethermind.Consensus.AuRa/AuRaBlockProcessor.cs +++ b/src/Nethermind/Nethermind.Consensus.AuRa/AuRaBlockProcessor.cs @@ -52,6 +52,7 @@ public class AuRaBlockProcessor : BlockProcessor stateProvider, receiptStorage, NullWitnessCollector.Instance, + blockTree, logManager, withdrawalProcessor) { diff --git a/src/Nethermind/Nethermind.Consensus.Clique/CliquePlugin.cs b/src/Nethermind/Nethermind.Consensus.Clique/CliquePlugin.cs index c416e75cea0..851a35c3e14 100644 --- a/src/Nethermind/Nethermind.Consensus.Clique/CliquePlugin.cs +++ b/src/Nethermind/Nethermind.Consensus.Clique/CliquePlugin.cs @@ -107,6 +107,7 @@ public Task InitBlockProducer(IBlockProductionTrigger? blockProd producerEnv.StateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, + getFromApi.BlockTree, getFromApi.LogManager, new BlockProductionWithdrawalProcessor(new WithdrawalProcessor(producerEnv.StateProvider, getFromApi.LogManager))); diff --git a/src/Nethermind/Nethermind.Consensus.Ethash/NethDevPlugin.cs b/src/Nethermind/Nethermind.Consensus.Ethash/NethDevPlugin.cs index 7220b3c2bba..70c3b8fdffb 100644 --- a/src/Nethermind/Nethermind.Consensus.Ethash/NethDevPlugin.cs +++ b/src/Nethermind/Nethermind.Consensus.Ethash/NethDevPlugin.cs @@ -77,6 +77,7 @@ public Task InitBlockProducer(IBlockProductionTrigger? blockProd producerEnv.StateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, + getFromApi.BlockTree, getFromApi.LogManager); IBlockchainProcessor producerChainProcessor = new BlockchainProcessor( diff --git a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs index f388bf592c2..31fae4e65a0 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs @@ -39,7 +39,7 @@ public partial class BlockProcessor : IBlockProcessor private readonly IBlockValidator _blockValidator; private readonly IRewardCalculator _rewardCalculator; private readonly IBlockProcessor.IBlockTransactionsExecutor _blockTransactionsExecutor; - + private readonly IBlockTree _blockTree; private const int MaxUncommittedBlocks = 64; /// @@ -56,6 +56,7 @@ public partial class BlockProcessor : IBlockProcessor IWorldState? stateProvider, IReceiptStorage? receiptStorage, IWitnessCollector? witnessCollector, + IBlockTree? blockTree, ILogManager? logManager, IWithdrawalProcessor? withdrawalProcessor = null, IReceiptsRootCalculator? receiptsRootCalculator = null) @@ -71,6 +72,7 @@ public partial class BlockProcessor : IBlockProcessor _blockTransactionsExecutor = blockTransactionsExecutor ?? throw new ArgumentNullException(nameof(blockTransactionsExecutor)); _receiptsRootCalculator = receiptsRootCalculator ?? ReceiptsRootCalculator.Instance; _beaconBlockRootHandler = new BeaconBlockRootHandler(); + _blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree)); ReceiptsTracer = new BlockReceiptsTracer(); } diff --git a/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyChainProcessingEnv.cs b/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyChainProcessingEnv.cs index 6fff1bc71d9..d2bdeb765e8 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyChainProcessingEnv.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyChainProcessingEnv.cs @@ -48,6 +48,7 @@ public class ReadOnlyChainProcessingEnv : IDisposable StateProvider, receiptStorage, NullWitnessCollector.Instance, + _txEnv.BlockTree, logManager); _blockProcessingQueue = new BlockchainProcessor(_txEnv.BlockTree, BlockProcessor, recoveryStep, _txEnv.StateReader, logManager, BlockchainProcessor.Options.NoReceipts); diff --git a/src/Nethermind/Nethermind.Consensus/Producers/BlockProducerEnvFactory.cs b/src/Nethermind/Nethermind.Consensus/Producers/BlockProducerEnvFactory.cs index 3a4f595ca23..ea2fd4f4ae5 100644 --- a/src/Nethermind/Nethermind.Consensus/Producers/BlockProducerEnvFactory.cs +++ b/src/Nethermind/Nethermind.Consensus/Producers/BlockProducerEnvFactory.cs @@ -142,6 +142,7 @@ public virtual BlockProducerEnv Create(ITxSource? additionalTxSource = null) readOnlyTxProcessingEnv.StateProvider, receiptStorage, NullWitnessCollector.Instance, + _blockTree, logManager, new BlockProductionWithdrawalProcessor(new WithdrawalProcessor(readOnlyTxProcessingEnv.StateProvider, logManager))); diff --git a/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs b/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs index b038088c34e..1e895750452 100644 --- a/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs +++ b/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs @@ -356,6 +356,7 @@ protected virtual async Task AddBlocksOnStart() State, ReceiptStorage, NullWitnessCollector.Instance, + BlockTree, LogManager); public async Task WaitForNewHead() diff --git a/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs b/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs index 5b8a5202835..cc8b8ad085c 100644 --- a/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs +++ b/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs @@ -217,6 +217,7 @@ protected virtual BlockProcessor CreateBlockProcessor() if (_api.DbProvider is null) throw new StepDependencyException(nameof(_api.DbProvider)); if (_api.RewardCalculatorSource is null) throw new StepDependencyException(nameof(_api.RewardCalculatorSource)); if (_api.TransactionProcessor is null) throw new StepDependencyException(nameof(_api.TransactionProcessor)); + if (_api.BlockTree is null) throw new StepDependencyException(nameof(_api.BlockTree)); IWorldState worldState = _api.WorldState!; @@ -228,6 +229,7 @@ protected virtual BlockProcessor CreateBlockProcessor() worldState, _api.ReceiptStorage, _api.WitnessCollector, + _api.BlockTree, _api.LogManager); } diff --git a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Trace/ParityStyleTracerTests.cs b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Trace/ParityStyleTracerTests.cs index e5dec786b18..f20f7dfe448 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Trace/ParityStyleTracerTests.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Trace/ParityStyleTracerTests.cs @@ -74,6 +74,7 @@ public void Setup() stateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, + _blockTree, LimboLogs.Instance); RecoverSignatures txRecovery = new(new EthereumEcdsa(TestBlockchainIds.ChainId, LimboLogs.Instance), NullTxPool.Instance, specProvider, LimboLogs.Instance); diff --git a/src/Nethermind/Nethermind.Merge.AuRa.Test/AuRaMergeEngineModuleTests.cs b/src/Nethermind/Nethermind.Merge.AuRa.Test/AuRaMergeEngineModuleTests.cs index 8a8d3d562fe..1f932373024 100644 --- a/src/Nethermind/Nethermind.Merge.AuRa.Test/AuRaMergeEngineModuleTests.cs +++ b/src/Nethermind/Nethermind.Merge.AuRa.Test/AuRaMergeEngineModuleTests.cs @@ -131,6 +131,7 @@ protected override IBlockProcessor CreateBlockProcessor() State, ReceiptStorage, NullWitnessCollector.Instance, + BlockTree, LogManager, WithdrawalProcessor); diff --git a/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.Setup.cs b/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.Setup.cs index cd10b95848b..61989e766a7 100644 --- a/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.Setup.cs +++ b/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.Setup.cs @@ -235,6 +235,7 @@ protected override IBlockProcessor CreateBlockProcessor() State, ReceiptStorage, NullWitnessCollector.Instance, + BlockTree, LogManager, WithdrawalProcessor); diff --git a/src/Nethermind/Nethermind.Mev.Test/MevRpcModuleTests.TestMevRpcBlockchain.cs b/src/Nethermind/Nethermind.Mev.Test/MevRpcModuleTests.TestMevRpcBlockchain.cs index c0a3b4b1168..bfaa34fba1d 100644 --- a/src/Nethermind/Nethermind.Mev.Test/MevRpcModuleTests.TestMevRpcBlockchain.cs +++ b/src/Nethermind/Nethermind.Mev.Test/MevRpcModuleTests.TestMevRpcBlockchain.cs @@ -201,6 +201,7 @@ protected override BlockProcessor CreateBlockProcessor() State, ReceiptStorage, NullWitnessCollector.Instance, + BlockTree, LogManager); _tracerFactory = new TracerFactory( diff --git a/src/Nethermind/Nethermind.Optimism/InitializeBlockchainOptimism.cs b/src/Nethermind/Nethermind.Optimism/InitializeBlockchainOptimism.cs index fb7b53726ff..f756ab72986 100644 --- a/src/Nethermind/Nethermind.Optimism/InitializeBlockchainOptimism.cs +++ b/src/Nethermind/Nethermind.Optimism/InitializeBlockchainOptimism.cs @@ -102,6 +102,7 @@ protected override BlockProcessor CreateBlockProcessor() _api.WorldState, _api.ReceiptStorage, _api.WitnessCollector, + _api.BlockTree, _api.LogManager, _api.SpecHelper, contractRewriter); diff --git a/src/Nethermind/Nethermind.Optimism/OptimismBlockProcessor.cs b/src/Nethermind/Nethermind.Optimism/OptimismBlockProcessor.cs index f289c36f041..c5117b4a937 100644 --- a/src/Nethermind/Nethermind.Optimism/OptimismBlockProcessor.cs +++ b/src/Nethermind/Nethermind.Optimism/OptimismBlockProcessor.cs @@ -2,6 +2,7 @@ // SPDX-License-Identifier: LGPL-3.0-only using System; +using Nethermind.Blockchain; using Nethermind.Blockchain.Receipts; using Nethermind.Consensus.Processing; using Nethermind.Consensus.Rewards; @@ -28,12 +29,13 @@ public class OptimismBlockProcessor : BlockProcessor IWorldState? stateProvider, IReceiptStorage? receiptStorage, IWitnessCollector? witnessCollector, + IBlockTree? blockTree, ILogManager? logManager, IOPConfigHelper opConfigHelper, Create2DeployerContractRewriter contractRewriter, IWithdrawalProcessor? withdrawalProcessor = null) : base(specProvider, blockValidator, rewardCalculator, blockTransactionsExecutor, - stateProvider, receiptStorage, witnessCollector, logManager, withdrawalProcessor, OptimismReceiptsRootCalculator.Instance) + stateProvider, receiptStorage, witnessCollector, blockTree, logManager, withdrawalProcessor, OptimismReceiptsRootCalculator.Instance) { ArgumentNullException.ThrowIfNull(stateProvider); _contractRewriter = contractRewriter; diff --git a/src/Nethermind/Nethermind.Optimism/OptimismBlockProducerEnvFactory.cs b/src/Nethermind/Nethermind.Optimism/OptimismBlockProducerEnvFactory.cs index 42df6a18aa3..cbccf1f919b 100644 --- a/src/Nethermind/Nethermind.Optimism/OptimismBlockProducerEnvFactory.cs +++ b/src/Nethermind/Nethermind.Optimism/OptimismBlockProducerEnvFactory.cs @@ -88,6 +88,7 @@ public class OptimismBlockProducerEnvFactory : BlockProducerEnvFactory readOnlyTxProcessingEnv.StateProvider, receiptStorage, NullWitnessCollector.Instance, + _blockTree, logManager, _specHelper, new Create2DeployerContractRewriter(_specHelper, _specProvider, _blockTree), diff --git a/src/Nethermind/Nethermind.Synchronization.Test/SyncThreadTests.cs b/src/Nethermind/Nethermind.Synchronization.Test/SyncThreadTests.cs index 0111224a4f1..d43acede2a0 100644 --- a/src/Nethermind/Nethermind.Synchronization.Test/SyncThreadTests.cs +++ b/src/Nethermind/Nethermind.Synchronization.Test/SyncThreadTests.cs @@ -299,6 +299,7 @@ private SyncTestContext CreateSyncManager(int index) stateProvider, receiptStorage, NullWitnessCollector.Instance, + tree, logManager); RecoverSignatures step = new(ecdsa, txPool, specProvider, logManager); @@ -321,6 +322,7 @@ private SyncTestContext CreateSyncManager(int index) devState, receiptStorage, NullWitnessCollector.Instance, + tree, logManager); BlockchainProcessor devChainProcessor = new(tree, devBlockProcessor, step, stateReader, logManager, From edac2d4aad43d21401993111df7977e8645a6d0f Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Fri, 12 Apr 2024 21:37:53 +0530 Subject: [PATCH 04/44] Add init thing --- .../Processing/BlockProcessor.cs | 39 +++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs index 31fae4e65a0..c0101ab4919 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs @@ -3,10 +3,13 @@ using System; using System.Collections.Generic; +using System.IO; using System.Numerics; using System.Runtime.InteropServices; using System.Threading; using Nethermind.Blockchain; +using Nethermind.Blockchain.BlockHashInState; +using Nethermind.Blockchain.Find; using Nethermind.Blockchain.Receipts; using Nethermind.Consensus.BeaconBlockRoot; using Nethermind.Consensus.Rewards; @@ -36,6 +39,7 @@ public partial class BlockProcessor : IBlockProcessor private readonly IWitnessCollector _witnessCollector; private readonly IWithdrawalProcessor _withdrawalProcessor; private readonly IBeaconBlockRootHandler _beaconBlockRootHandler; + private readonly IBlockHashInStateHandler _blockHashInStateHandlerHandler; private readonly IBlockValidator _blockValidator; private readonly IRewardCalculator _rewardCalculator; private readonly IBlockProcessor.IBlockTransactionsExecutor _blockTransactionsExecutor; @@ -72,6 +76,7 @@ public partial class BlockProcessor : IBlockProcessor _blockTransactionsExecutor = blockTransactionsExecutor ?? throw new ArgumentNullException(nameof(blockTransactionsExecutor)); _receiptsRootCalculator = receiptsRootCalculator ?? ReceiptsRootCalculator.Instance; _beaconBlockRootHandler = new BeaconBlockRootHandler(); + _blockHashInStateHandlerHandler = new BlockHashInStateHandler(); _blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree)); ReceiptsTracer = new BlockReceiptsTracer(); @@ -223,6 +228,23 @@ private void ValidateProcessedBlock(Block suggestedBlock, ProcessingOptions opti } } + private void InitEip2935History(BlockHeader currentBlock, IReleaseSpec spec, IWorldState stateProvider) + { + long current = currentBlock.Number; + BlockHeader header = currentBlock; + for (var i = 0; i < Math.Min(256, current); i++) + { + // an extract check - dont think it is needed + if (header.IsGenesis) break; + _blockHashInStateHandlerHandler.AddParentBlockHashToState(header, spec, stateProvider, NullBlockTracer.Instance); + header = _blockTree.FindParentHeader(currentBlock, BlockTreeLookupOptions.TotalDifficultyNotNeeded); + if (header is null) + { + throw new InvalidDataException("Parent header cannot be found when executing BLOCKHASH operation"); + } + } + } + private bool ShouldComputeStateRoot(BlockHeader header) => !header.IsGenesis || !_specProvider.GenesisStateUnavailable; @@ -238,6 +260,23 @@ private void ValidateProcessedBlock(Block suggestedBlock, ProcessingOptions opti ReceiptsTracer.StartNewBlockTrace(block); _beaconBlockRootHandler.ApplyContractStateChanges(block, spec, _stateProvider); + + if (spec.IsEip2935Enabled) + { + // TODO: find a better way to handle this - no need to have this check everytime + // this would just be true on the fork block + BlockHeader parentHeader = _blockTree.FindParentHeader(block.Header, BlockTreeLookupOptions.None); + if (parentHeader is not null && parentHeader!.Timestamp < spec.Eip2935TransitionTimeStamp) + { + InitEip2935History(block.Header, spec, _stateProvider); + } + else + { + _blockHashInStateHandlerHandler.AddParentBlockHashToState(block.Header, spec, _stateProvider, ReceiptsTracer); + } + } + + _stateProvider.Commit(spec); TxReceipt[] receipts = _blockTransactionsExecutor.ProcessTransactions(block, options, ReceiptsTracer, spec); From c06bd4c60e05b1fac60ecb710cf64b5beda8a6d3 Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Tue, 16 Apr 2024 21:01:37 +0530 Subject: [PATCH 05/44] refactor --- .../BlockHashInStateHandler.cs | 24 ++++++++++++++++- .../Processing/BlockProcessor.cs | 26 +++---------------- .../Nethermind.Core/Specs/IReleaseSpec.cs | 1 + .../OverridableReleaseSpec.cs | 13 ++++++++++ .../Nethermind.Specs/ReleaseSpec.cs | 2 ++ .../SystemTransactionReleaseSpec.cs | 1 + 6 files changed, 44 insertions(+), 23 deletions(-) diff --git a/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs b/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs index df0b7829afc..960ce672134 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs +++ b/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs @@ -2,6 +2,8 @@ // SPDX-License-Identifier:LGPL-3.0-only using System; +using System.IO; +using Nethermind.Blockchain.Find; using Nethermind.Core; using Nethermind.Core.Crypto; using Nethermind.Core.Extensions; @@ -14,12 +16,32 @@ namespace Nethermind.Blockchain.BlockHashInState; public interface IBlockHashInStateHandler { + public void InitEip2935History(BlockHeader currentBlock, IReleaseSpec spec, IWorldState stateProvider); public void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec, IWorldState stateProvider, IBlockTracer blockTracer); } -public class BlockHashInStateHandler : IBlockHashInStateHandler +public class BlockHashInStateHandler(IBlockTree blockTree) : IBlockHashInStateHandler { + private readonly IBlockTree _blockTree = blockTree; + + public void InitEip2935History(BlockHeader currentBlock, IReleaseSpec spec, IWorldState stateProvider) + { + long current = currentBlock.Number; + BlockHeader header = currentBlock; + for (var i = 0; i < Math.Min(256, current); i++) + { + // an extract check - don't think it is needed + if (header.IsGenesis) break; + AddParentBlockHashToState(header, spec, stateProvider, NullBlockTracer.Instance); + header = _blockTree.FindParentHeader(currentBlock, BlockTreeLookupOptions.TotalDifficultyNotNeeded); + if (header is null) + { + throw new InvalidDataException("Parent header cannot be found when executing BLOCKHASH operation"); + } + } + } + public void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec, IWorldState stateProvider, IBlockTracer blockTracer) { if (!spec.IsEip2935Enabled || diff --git a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs index c0101ab4919..8cd452db24d 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs @@ -75,10 +75,9 @@ public partial class BlockProcessor : IBlockProcessor _rewardCalculator = rewardCalculator ?? throw new ArgumentNullException(nameof(rewardCalculator)); _blockTransactionsExecutor = blockTransactionsExecutor ?? throw new ArgumentNullException(nameof(blockTransactionsExecutor)); _receiptsRootCalculator = receiptsRootCalculator ?? ReceiptsRootCalculator.Instance; - _beaconBlockRootHandler = new BeaconBlockRootHandler(); - _blockHashInStateHandlerHandler = new BlockHashInStateHandler(); _blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree)); - + _beaconBlockRootHandler = new BeaconBlockRootHandler(); + _blockHashInStateHandlerHandler = new BlockHashInStateHandler(_blockTree); ReceiptsTracer = new BlockReceiptsTracer(); } @@ -228,23 +227,6 @@ private void ValidateProcessedBlock(Block suggestedBlock, ProcessingOptions opti } } - private void InitEip2935History(BlockHeader currentBlock, IReleaseSpec spec, IWorldState stateProvider) - { - long current = currentBlock.Number; - BlockHeader header = currentBlock; - for (var i = 0; i < Math.Min(256, current); i++) - { - // an extract check - dont think it is needed - if (header.IsGenesis) break; - _blockHashInStateHandlerHandler.AddParentBlockHashToState(header, spec, stateProvider, NullBlockTracer.Instance); - header = _blockTree.FindParentHeader(currentBlock, BlockTreeLookupOptions.TotalDifficultyNotNeeded); - if (header is null) - { - throw new InvalidDataException("Parent header cannot be found when executing BLOCKHASH operation"); - } - } - } - private bool ShouldComputeStateRoot(BlockHeader header) => !header.IsGenesis || !_specProvider.GenesisStateUnavailable; @@ -266,9 +248,9 @@ private void InitEip2935History(BlockHeader currentBlock, IReleaseSpec spec, IWo // TODO: find a better way to handle this - no need to have this check everytime // this would just be true on the fork block BlockHeader parentHeader = _blockTree.FindParentHeader(block.Header, BlockTreeLookupOptions.None); - if (parentHeader is not null && parentHeader!.Timestamp < spec.Eip2935TransitionTimeStamp) + if (parentHeader is not null && parentHeader!.Timestamp < spec.Eip2935TransitionTimestamp) { - InitEip2935History(block.Header, spec, _stateProvider); + _blockHashInStateHandlerHandler.InitEip2935History(block.Header, spec, _stateProvider); } else { diff --git a/src/Nethermind/Nethermind.Core/Specs/IReleaseSpec.cs b/src/Nethermind/Nethermind.Core/Specs/IReleaseSpec.cs index 22232309ee7..d7d5d32a8c6 100644 --- a/src/Nethermind/Nethermind.Core/Specs/IReleaseSpec.cs +++ b/src/Nethermind/Nethermind.Core/Specs/IReleaseSpec.cs @@ -278,6 +278,7 @@ public interface IReleaseSpec : IEip1559Spec, IReceiptSpec /// bool IsEip2935Enabled { get; } Address Eip2935ContractAddress { get; } + public ulong Eip2935TransitionTimestamp { get; } /// /// SELFDESTRUCT only in same transaction diff --git a/src/Nethermind/Nethermind.Specs.Test/OverridableReleaseSpec.cs b/src/Nethermind/Nethermind.Specs.Test/OverridableReleaseSpec.cs index 13de7306664..c03262e5510 100644 --- a/src/Nethermind/Nethermind.Specs.Test/OverridableReleaseSpec.cs +++ b/src/Nethermind/Nethermind.Specs.Test/OverridableReleaseSpec.cs @@ -147,6 +147,19 @@ public ulong Eip4844TransitionTimestamp } } + private ulong? _overridenEip2935TransitionTimeStamp; + public ulong Eip2935TransitionTimestamp + { + get + { + return _overridenEip2935TransitionTimeStamp ?? _spec.Eip2935TransitionTimestamp; + } + set + { + _overridenEip2935TransitionTimeStamp = value; + } + } + public bool IsEip1153Enabled => _spec.IsEip1153Enabled; public bool IsEip3651Enabled => _spec.IsEip3651Enabled; public bool IsEip3855Enabled => _spec.IsEip3855Enabled; diff --git a/src/Nethermind/Nethermind.Specs/ReleaseSpec.cs b/src/Nethermind/Nethermind.Specs/ReleaseSpec.cs index 810bf7987b8..7d0f08e4ae7 100644 --- a/src/Nethermind/Nethermind.Specs/ReleaseSpec.cs +++ b/src/Nethermind/Nethermind.Specs/ReleaseSpec.cs @@ -100,5 +100,7 @@ public Address Eip2935ContractAddress get => IsEip2935Enabled ? _eip2935ContractAddress : null; set => _eip2935ContractAddress = value; } + + public ulong Eip2935TransitionTimestamp { get; set; } } } diff --git a/src/Nethermind/Nethermind.Specs/SystemTransactionReleaseSpec.cs b/src/Nethermind/Nethermind.Specs/SystemTransactionReleaseSpec.cs index 9226f4af9db..66f9bb2c756 100644 --- a/src/Nethermind/Nethermind.Specs/SystemTransactionReleaseSpec.cs +++ b/src/Nethermind/Nethermind.Specs/SystemTransactionReleaseSpec.cs @@ -132,6 +132,7 @@ public bool IsEip158IgnoredAccount(Address address) public Address Eip4788ContractAddress => _spec.Eip4788ContractAddress; public bool IsEip2935Enabled => _spec.IsEip2935Enabled; public Address Eip2935ContractAddress => _spec.Eip2935ContractAddress; + public ulong Eip2935TransitionTimestamp => _spec.Eip2935TransitionTimestamp; public UInt256 ForkBaseFee => _spec.ForkBaseFee; public UInt256 BaseFeeMaxChangeDenominator => _spec.BaseFeeMaxChangeDenominator; public long ElasticityMultiplier => _spec.ElasticityMultiplier; From 87d724cbcf7b9e9eeb3958dcb6762d15395ba1ae Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Wed, 17 Apr 2024 08:25:17 +0530 Subject: [PATCH 06/44] use block hash from state --- .../BlockHashInState/BlockHashInStateHandler.cs | 6 +++--- .../Processing/BlockProcessor.cs | 2 +- src/Nethermind/Nethermind.Evm/VirtualMachine.cs | 15 ++++++++++++++- 3 files changed, 18 insertions(+), 5 deletions(-) diff --git a/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs b/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs index 960ce672134..c14c1d8b90c 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs +++ b/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs @@ -16,7 +16,7 @@ namespace Nethermind.Blockchain.BlockHashInState; public interface IBlockHashInStateHandler { - public void InitEip2935History(BlockHeader currentBlock, IReleaseSpec spec, IWorldState stateProvider); + public void InitHistoryOnForkBlock(BlockHeader currentBlock, IReleaseSpec spec, IWorldState stateProvider); public void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec, IWorldState stateProvider, IBlockTracer blockTracer); } @@ -25,11 +25,11 @@ public class BlockHashInStateHandler(IBlockTree blockTree) : IBlockHashInStateHa private readonly IBlockTree _blockTree = blockTree; - public void InitEip2935History(BlockHeader currentBlock, IReleaseSpec spec, IWorldState stateProvider) + public void InitHistoryOnForkBlock(BlockHeader currentBlock, IReleaseSpec spec, IWorldState stateProvider) { long current = currentBlock.Number; BlockHeader header = currentBlock; - for (var i = 0; i < Math.Min(256, current); i++) + for (var i = 0; i < Math.Min(Eip2935Constants.RingBufferSize, current); i++) { // an extract check - don't think it is needed if (header.IsGenesis) break; diff --git a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs index 8cd452db24d..d3bb9376801 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs @@ -250,7 +250,7 @@ private void ValidateProcessedBlock(Block suggestedBlock, ProcessingOptions opti BlockHeader parentHeader = _blockTree.FindParentHeader(block.Header, BlockTreeLookupOptions.None); if (parentHeader is not null && parentHeader!.Timestamp < spec.Eip2935TransitionTimestamp) { - _blockHashInStateHandlerHandler.InitEip2935History(block.Header, spec, _stateProvider); + _blockHashInStateHandlerHandler.InitHistoryOnForkBlock(block.Header, spec, _stateProvider); } else { diff --git a/src/Nethermind/Nethermind.Evm/VirtualMachine.cs b/src/Nethermind/Nethermind.Evm/VirtualMachine.cs index 64a9c11ea86..792e26ccc7b 100644 --- a/src/Nethermind/Nethermind.Evm/VirtualMachine.cs +++ b/src/Nethermind/Nethermind.Evm/VirtualMachine.cs @@ -1480,7 +1480,11 @@ private CallResult ExecuteCall(EvmState vmState, ReadOnlyM if (!stack.PopUInt256(out a)) goto StackUnderflow; long number = a > long.MaxValue ? long.MaxValue : (long)a; - Hash256 blockHash = _blockhashProvider.GetBlockhash(blkCtx.Header, number); + + Hash256 blockHash = spec.IsBlockHashInStateAvailable + ? GetBlockHashFromState(number) + : _blockhashProvider.GetBlockhash(blkCtx.Header, number); + stack.PushBytes(blockHash is not null ? blockHash.Bytes : BytesZero32); if (typeof(TLogger) == typeof(IsTracing)) @@ -1492,6 +1496,15 @@ private CallResult ExecuteCall(EvmState vmState, ReadOnlyM } break; + + Hash256? GetBlockHashFromState(long blockNumber) + { + var blockIndex = new UInt256((ulong)((blockNumber - 1) % Eip2935Constants.RingBufferSize)); + StorageCell blockHashStoreCell = new(spec.Eip2935ContractAddress, blockIndex); + ReadOnlySpan data = _worldState.Get(blockHashStoreCell); + if (data.Length < 32) return null; + return new Hash256(data); + } } case Instruction.COINBASE: { From 7677f1b8d28dedf64afc186125b02440d6d7a808 Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Thu, 18 Apr 2024 02:45:51 +0530 Subject: [PATCH 07/44] refactor for simpler tests --- .../BlockHashInState/BlockHashInStateHandler.cs | 16 +++++++--------- .../Processing/BlockProcessor.cs | 4 ++-- 2 files changed, 9 insertions(+), 11 deletions(-) diff --git a/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs b/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs index c14c1d8b90c..57154f4092b 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs +++ b/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs @@ -16,28 +16,26 @@ namespace Nethermind.Blockchain.BlockHashInState; public interface IBlockHashInStateHandler { - public void InitHistoryOnForkBlock(BlockHeader currentBlock, IReleaseSpec spec, IWorldState stateProvider); + public void InitHistoryOnForkBlock(IBlockTree blockTree, BlockHeader currentBlock, IReleaseSpec spec, IWorldState stateProvider); public void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec, IWorldState stateProvider, IBlockTracer blockTracer); } -public class BlockHashInStateHandler(IBlockTree blockTree) : IBlockHashInStateHandler +public class BlockHashInStateHandler : IBlockHashInStateHandler { - - private readonly IBlockTree _blockTree = blockTree; - - public void InitHistoryOnForkBlock(BlockHeader currentBlock, IReleaseSpec spec, IWorldState stateProvider) + public void InitHistoryOnForkBlock(IBlockTree blockTree, BlockHeader currentBlock, IReleaseSpec spec, IWorldState stateProvider) { long current = currentBlock.Number; BlockHeader header = currentBlock; for (var i = 0; i < Math.Min(Eip2935Constants.RingBufferSize, current); i++) { - // an extract check - don't think it is needed + // an extra check - don't think it is needed if (header.IsGenesis) break; AddParentBlockHashToState(header, spec, stateProvider, NullBlockTracer.Instance); - header = _blockTree.FindParentHeader(currentBlock, BlockTreeLookupOptions.TotalDifficultyNotNeeded); + header = blockTree.FindParentHeader(currentBlock, BlockTreeLookupOptions.TotalDifficultyNotNeeded); if (header is null) { - throw new InvalidDataException("Parent header cannot be found when executing BLOCKHASH operation"); + throw new InvalidDataException( + "Parent header cannot be found when initializing BlockHashInState history"); } } } diff --git a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs index d3bb9376801..f7ff98fa991 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs @@ -77,7 +77,7 @@ public partial class BlockProcessor : IBlockProcessor _receiptsRootCalculator = receiptsRootCalculator ?? ReceiptsRootCalculator.Instance; _blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree)); _beaconBlockRootHandler = new BeaconBlockRootHandler(); - _blockHashInStateHandlerHandler = new BlockHashInStateHandler(_blockTree); + _blockHashInStateHandlerHandler = new BlockHashInStateHandler(); ReceiptsTracer = new BlockReceiptsTracer(); } @@ -250,7 +250,7 @@ private void ValidateProcessedBlock(Block suggestedBlock, ProcessingOptions opti BlockHeader parentHeader = _blockTree.FindParentHeader(block.Header, BlockTreeLookupOptions.None); if (parentHeader is not null && parentHeader!.Timestamp < spec.Eip2935TransitionTimestamp) { - _blockHashInStateHandlerHandler.InitHistoryOnForkBlock(block.Header, spec, _stateProvider); + _blockHashInStateHandlerHandler.InitHistoryOnForkBlock(_blockTree, block.Header, spec, _stateProvider); } else { From 9c8483ac3e01d33e193725f5dd79e73011bfc0aa Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Thu, 18 Apr 2024 02:47:55 +0530 Subject: [PATCH 08/44] remove tracer --- .../BlockHashInState/BlockHashInStateHandler.cs | 6 +++--- .../Nethermind.Consensus/Processing/BlockProcessor.cs | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs b/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs index 57154f4092b..450dcbe4b1e 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs +++ b/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs @@ -17,7 +17,7 @@ namespace Nethermind.Blockchain.BlockHashInState; public interface IBlockHashInStateHandler { public void InitHistoryOnForkBlock(IBlockTree blockTree, BlockHeader currentBlock, IReleaseSpec spec, IWorldState stateProvider); - public void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec, IWorldState stateProvider, IBlockTracer blockTracer); + public void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec, IWorldState stateProvider); } public class BlockHashInStateHandler : IBlockHashInStateHandler @@ -30,7 +30,7 @@ public void InitHistoryOnForkBlock(IBlockTree blockTree, BlockHeader currentBloc { // an extra check - don't think it is needed if (header.IsGenesis) break; - AddParentBlockHashToState(header, spec, stateProvider, NullBlockTracer.Instance); + AddParentBlockHashToState(header, spec, stateProvider); header = blockTree.FindParentHeader(currentBlock, BlockTreeLookupOptions.TotalDifficultyNotNeeded); if (header is null) { @@ -40,7 +40,7 @@ public void InitHistoryOnForkBlock(IBlockTree blockTree, BlockHeader currentBloc } } - public void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec, IWorldState stateProvider, IBlockTracer blockTracer) + public void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec, IWorldState stateProvider) { if (!spec.IsEip2935Enabled || blockHeader.IsGenesis || diff --git a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs index f7ff98fa991..12d2dcbe3c6 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs @@ -254,7 +254,7 @@ private void ValidateProcessedBlock(Block suggestedBlock, ProcessingOptions opti } else { - _blockHashInStateHandlerHandler.AddParentBlockHashToState(block.Header, spec, _stateProvider, ReceiptsTracer); + _blockHashInStateHandlerHandler.AddParentBlockHashToState(block.Header, spec, _stateProvider); } } From f8ce7de518ca79239568ba5f20b54afb9c07350b Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Thu, 18 Apr 2024 03:01:28 +0530 Subject: [PATCH 09/44] add block hash to v3 test --- .../EngineModuleTests.HelperFunctions.cs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs b/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs index 42df50543de..bd1a928da4a 100644 --- a/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs +++ b/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs @@ -7,6 +7,7 @@ using System.Linq.Expressions; using System.Threading.Tasks; using Nethermind.Blockchain; +using Nethermind.Blockchain.BlockHashInState; using Nethermind.Blockchain.Find; using Nethermind.Core; using Nethermind.Core.Crypto; @@ -32,6 +33,7 @@ public partial class EngineModuleTests { private static readonly DateTime Timestamp = DateTimeOffset.FromUnixTimeSeconds(1000).UtcDateTime; private static readonly IBeaconBlockRootHandler _beaconBlockRootHandler = new BeaconBlockRootHandler(); + private static readonly IBlockHashInStateHandler _blockHashInStateHandler = new BlockHashInStateHandler(); private ITimestamper Timestamper { get; } = new ManualTimestamper(Timestamp); private void AssertExecutionStatusChanged(IBlockFinder blockFinder, Hash256 headBlockHash, Hash256 finalizedBlockHash, Hash256 safeBlockHash) @@ -115,6 +117,7 @@ private ExecutionPayload CreateParentBlockRequestOnHead(IBlockTree blockTree) Snapshot before = chain.State.TakeSnapshot(); _beaconBlockRootHandler.ApplyContractStateChanges(block!, chain.SpecProvider.GenesisSpec, chain.State); + _blockHashInStateHandler.AddParentBlockHashToState(block!.Header, chain.SpecProvider.GenesisSpec, chain.State); chain.WithdrawalProcessor?.ProcessWithdrawals(block!, chain.SpecProvider.GenesisSpec); chain.State.Commit(chain.SpecProvider.GenesisSpec); From 9aed99601573deaf5ee35f500eea9bd2ea466071 Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Thu, 18 Apr 2024 03:03:29 +0530 Subject: [PATCH 10/44] reafc --- .../BlockHashInState/BlockHashInStateHandler.cs | 6 ------ .../BlockHashInState/IBlockHashInStateHandler.cs | 14 ++++++++++++++ 2 files changed, 14 insertions(+), 6 deletions(-) create mode 100644 src/Nethermind/Nethermind.Blockchain/BlockHashInState/IBlockHashInStateHandler.cs diff --git a/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs b/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs index 450dcbe4b1e..ce5ade715cd 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs +++ b/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs @@ -14,12 +14,6 @@ namespace Nethermind.Blockchain.BlockHashInState; -public interface IBlockHashInStateHandler -{ - public void InitHistoryOnForkBlock(IBlockTree blockTree, BlockHeader currentBlock, IReleaseSpec spec, IWorldState stateProvider); - public void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec, IWorldState stateProvider); -} - public class BlockHashInStateHandler : IBlockHashInStateHandler { public void InitHistoryOnForkBlock(IBlockTree blockTree, BlockHeader currentBlock, IReleaseSpec spec, IWorldState stateProvider) diff --git a/src/Nethermind/Nethermind.Blockchain/BlockHashInState/IBlockHashInStateHandler.cs b/src/Nethermind/Nethermind.Blockchain/BlockHashInState/IBlockHashInStateHandler.cs new file mode 100644 index 00000000000..e3dd17fca52 --- /dev/null +++ b/src/Nethermind/Nethermind.Blockchain/BlockHashInState/IBlockHashInStateHandler.cs @@ -0,0 +1,14 @@ +// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using Nethermind.Core; +using Nethermind.Core.Specs; +using Nethermind.State; + +namespace Nethermind.Blockchain.BlockHashInState; + +public interface IBlockHashInStateHandler +{ + public void InitHistoryOnForkBlock(IBlockTree blockTree, BlockHeader currentBlock, IReleaseSpec spec, IWorldState stateProvider); + public void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec, IWorldState stateProvider); +} From b2d14d7b58aeed6fc1444a1728261b09b11a55ed Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Thu, 18 Apr 2024 03:43:43 +0530 Subject: [PATCH 11/44] query from handler also - how to get this in evm? --- .../BlockHashInState/BlockHashInStateHandler.cs | 10 ++++++++++ .../BlockHashInState/IBlockHashInStateHandler.cs | 2 ++ 2 files changed, 12 insertions(+) diff --git a/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs b/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs index ce5ade715cd..12f2f327c03 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs +++ b/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs @@ -50,4 +50,14 @@ public void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec StorageCell blockHashStoreCell = new(eip2935Account, blockIndex); stateProvider.Set(blockHashStoreCell, parentBlockHash.Bytes.WithoutLeadingZeros().ToArray()); } + + public Hash256? GetBlockHashFromState(long blockNumber, IReleaseSpec spec, IWorldState stateProvider) + { + var blockIndex = new UInt256((ulong)((blockNumber - 1) % Eip2935Constants.RingBufferSize)); + Address? eip2935Account = spec.Eip2935ContractAddress ?? Eip2935Constants.BlockHashHistoryAddress; + StorageCell blockHashStoreCell = new(eip2935Account, blockIndex); + ReadOnlySpan data = stateProvider.Get(blockHashStoreCell); + if (data.Length < 32) return null; + return new Hash256(data); + } } diff --git a/src/Nethermind/Nethermind.Blockchain/BlockHashInState/IBlockHashInStateHandler.cs b/src/Nethermind/Nethermind.Blockchain/BlockHashInState/IBlockHashInStateHandler.cs index e3dd17fca52..90cb130827b 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockHashInState/IBlockHashInStateHandler.cs +++ b/src/Nethermind/Nethermind.Blockchain/BlockHashInState/IBlockHashInStateHandler.cs @@ -2,6 +2,7 @@ // SPDX-License-Identifier: LGPL-3.0-only using Nethermind.Core; +using Nethermind.Core.Crypto; using Nethermind.Core.Specs; using Nethermind.State; @@ -11,4 +12,5 @@ public interface IBlockHashInStateHandler { public void InitHistoryOnForkBlock(IBlockTree blockTree, BlockHeader currentBlock, IReleaseSpec spec, IWorldState stateProvider); public void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec, IWorldState stateProvider); + public Hash256? GetBlockHashFromState(long blockNumber, IReleaseSpec spec, IWorldState stateProvider); } From 7183f999dfa9beb5389e6e798ac3737e0c43eb1c Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Thu, 18 Apr 2024 09:46:16 +0530 Subject: [PATCH 12/44] query from handler in vm --- .../BlockHashInStateExtension.cs | 34 +++++++++++++++++++ .../Processing/BlockProcessor.cs | 1 + .../BlockHashInStateHandler.cs | 22 ++---------- .../IBlockHashInStateHandler.cs | 3 +- .../Nethermind.Evm/VirtualMachine.cs | 14 +++----- .../EngineModuleTests.HelperFunctions.cs | 1 + 6 files changed, 43 insertions(+), 32 deletions(-) create mode 100644 src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs rename src/Nethermind/{Nethermind.Blockchain => Nethermind.Evm}/BlockHashInState/BlockHashInStateHandler.cs (67%) rename src/Nethermind/{Nethermind.Blockchain => Nethermind.Evm}/BlockHashInState/IBlockHashInStateHandler.cs (72%) diff --git a/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs b/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs new file mode 100644 index 00000000000..e15cc231e33 --- /dev/null +++ b/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs @@ -0,0 +1,34 @@ +// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using System.IO; +using Nethermind.Blockchain.Find; +using Nethermind.Core; +using Nethermind.Core.Specs; +using Nethermind.Evm.BlockHashInState; +using Nethermind.State; + +namespace Nethermind.Blockchain.BlockHashInState; + +public static class BlockHashInStateExtension +{ + public static void InitHistoryOnForkBlock(this IBlockHashInStateHandler handler,IBlockTree blockTree, BlockHeader currentBlock, + IReleaseSpec spec, IWorldState stateProvider) + { + long current = currentBlock.Number; + BlockHeader header = currentBlock; + for (var i = 0; i < Math.Min(Eip2935Constants.RingBufferSize, current); i++) + { + // an extra check - don't think it is needed + if (header.IsGenesis) break; + handler.AddParentBlockHashToState(header, spec, stateProvider); + header = blockTree.FindParentHeader(currentBlock, BlockTreeLookupOptions.TotalDifficultyNotNeeded); + if (header is null) + { + throw new InvalidDataException( + "Parent header cannot be found when initializing BlockHashInState history"); + } + } + } +} diff --git a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs index 12d2dcbe3c6..cfd007a4681 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs @@ -20,6 +20,7 @@ using Nethermind.Core.Specs; using Nethermind.Crypto; using Nethermind.Evm; +using Nethermind.Evm.BlockHashInState; using Nethermind.Evm.Tracing; using Nethermind.Int256; using Nethermind.Logging; diff --git a/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs b/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs similarity index 67% rename from src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs rename to src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs index 12f2f327c03..2df3ac7b9f1 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockHashInState/BlockHashInStateHandler.cs +++ b/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs @@ -3,11 +3,11 @@ using System; using System.IO; -using Nethermind.Blockchain.Find; using Nethermind.Core; using Nethermind.Core.Crypto; using Nethermind.Core.Extensions; using Nethermind.Core.Specs; +using Nethermind.Evm.BlockHashInState; using Nethermind.Evm.Tracing; using Nethermind.Int256; using Nethermind.State; @@ -16,24 +16,6 @@ namespace Nethermind.Blockchain.BlockHashInState; public class BlockHashInStateHandler : IBlockHashInStateHandler { - public void InitHistoryOnForkBlock(IBlockTree blockTree, BlockHeader currentBlock, IReleaseSpec spec, IWorldState stateProvider) - { - long current = currentBlock.Number; - BlockHeader header = currentBlock; - for (var i = 0; i < Math.Min(Eip2935Constants.RingBufferSize, current); i++) - { - // an extra check - don't think it is needed - if (header.IsGenesis) break; - AddParentBlockHashToState(header, spec, stateProvider); - header = blockTree.FindParentHeader(currentBlock, BlockTreeLookupOptions.TotalDifficultyNotNeeded); - if (header is null) - { - throw new InvalidDataException( - "Parent header cannot be found when initializing BlockHashInState history"); - } - } - } - public void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec, IWorldState stateProvider) { if (!spec.IsEip2935Enabled || @@ -50,7 +32,7 @@ public void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec StorageCell blockHashStoreCell = new(eip2935Account, blockIndex); stateProvider.Set(blockHashStoreCell, parentBlockHash.Bytes.WithoutLeadingZeros().ToArray()); } - + public Hash256? GetBlockHashFromState(long blockNumber, IReleaseSpec spec, IWorldState stateProvider) { var blockIndex = new UInt256((ulong)((blockNumber - 1) % Eip2935Constants.RingBufferSize)); diff --git a/src/Nethermind/Nethermind.Blockchain/BlockHashInState/IBlockHashInStateHandler.cs b/src/Nethermind/Nethermind.Evm/BlockHashInState/IBlockHashInStateHandler.cs similarity index 72% rename from src/Nethermind/Nethermind.Blockchain/BlockHashInState/IBlockHashInStateHandler.cs rename to src/Nethermind/Nethermind.Evm/BlockHashInState/IBlockHashInStateHandler.cs index 90cb130827b..2c749ac0cfc 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockHashInState/IBlockHashInStateHandler.cs +++ b/src/Nethermind/Nethermind.Evm/BlockHashInState/IBlockHashInStateHandler.cs @@ -6,11 +6,10 @@ using Nethermind.Core.Specs; using Nethermind.State; -namespace Nethermind.Blockchain.BlockHashInState; +namespace Nethermind.Evm.BlockHashInState; public interface IBlockHashInStateHandler { - public void InitHistoryOnForkBlock(IBlockTree blockTree, BlockHeader currentBlock, IReleaseSpec spec, IWorldState stateProvider); public void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec, IWorldState stateProvider); public Hash256? GetBlockHashFromState(long blockNumber, IReleaseSpec spec, IWorldState stateProvider); } diff --git a/src/Nethermind/Nethermind.Evm/VirtualMachine.cs b/src/Nethermind/Nethermind.Evm/VirtualMachine.cs index 792e26ccc7b..06d3c2ac29e 100644 --- a/src/Nethermind/Nethermind.Evm/VirtualMachine.cs +++ b/src/Nethermind/Nethermind.Evm/VirtualMachine.cs @@ -21,6 +21,8 @@ using System.Diagnostics; using System.Runtime.InteropServices; using System.Runtime.Intrinsics; +using Nethermind.Blockchain.BlockHashInState; +using Nethermind.Evm.BlockHashInState; using static Nethermind.Evm.VirtualMachine; using static System.Runtime.CompilerServices.Unsafe; using ValueHash256 = Nethermind.Core.Crypto.ValueHash256; @@ -188,6 +190,7 @@ internal sealed class VirtualMachine : IVirtualMachine where TLogger : private readonly byte[] _chainId; private readonly IBlockhashProvider _blockhashProvider; + private readonly IBlockHashInStateHandler _blockHashInStateHandler = new BlockHashInStateHandler(); private readonly ISpecProvider _specProvider; private readonly ILogger _logger; private IWorldState _worldState; @@ -1482,7 +1485,7 @@ private CallResult ExecuteCall(EvmState vmState, ReadOnlyM long number = a > long.MaxValue ? long.MaxValue : (long)a; Hash256 blockHash = spec.IsBlockHashInStateAvailable - ? GetBlockHashFromState(number) + ? _blockHashInStateHandler.GetBlockHashFromState(number, spec, _worldState) : _blockhashProvider.GetBlockhash(blkCtx.Header, number); stack.PushBytes(blockHash is not null ? blockHash.Bytes : BytesZero32); @@ -1496,15 +1499,6 @@ private CallResult ExecuteCall(EvmState vmState, ReadOnlyM } break; - - Hash256? GetBlockHashFromState(long blockNumber) - { - var blockIndex = new UInt256((ulong)((blockNumber - 1) % Eip2935Constants.RingBufferSize)); - StorageCell blockHashStoreCell = new(spec.Eip2935ContractAddress, blockIndex); - ReadOnlySpan data = _worldState.Get(blockHashStoreCell); - if (data.Length < 32) return null; - return new Hash256(data); - } } case Instruction.COINBASE: { diff --git a/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs b/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs index bd1a928da4a..7106f468250 100644 --- a/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs +++ b/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs @@ -25,6 +25,7 @@ using Nethermind.Consensus.BeaconBlockRoot; using Nethermind.Consensus.Withdrawals; using Nethermind.Core.Test.Blockchain; +using Nethermind.Evm.BlockHashInState; namespace Nethermind.Merge.Plugin.Test { From 7a600e708769947f1540cee38efe40c3cb866143 Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Fri, 19 Apr 2024 15:30:40 +0530 Subject: [PATCH 13/44] modify blockHash provider instead --- .../BlockhashProviderTests.cs | 25 ++++++++++--------- .../BlockHashInStateExtension.cs | 8 +++--- .../BlockhashProvider.cs | 13 +++++++++- .../Processing/BlockProcessor.cs | 13 +++------- .../TestBlockhashProvider.cs | 4 ++- .../BlockHashInStateHandler.cs | 7 +++--- .../IBlockHashInStateHandler.cs | 15 ----------- .../Nethermind.Evm/IBlockhashProvider.cs | 4 ++- .../Nethermind.Evm/VirtualMachine.cs | 7 +----- .../EngineModuleTests.HelperFunctions.cs | 8 +----- 10 files changed, 43 insertions(+), 61 deletions(-) delete mode 100644 src/Nethermind/Nethermind.Evm/BlockHashInState/IBlockHashInStateHandler.cs diff --git a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs index 9728dfb5475..771dfb1d05e 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs @@ -5,6 +5,7 @@ using Nethermind.Core.Crypto; using Nethermind.Core.Test.Builders; using Nethermind.Logging; +using Nethermind.Specs.Forks; using NUnit.Framework; namespace Nethermind.Blockchain.Test @@ -24,7 +25,7 @@ public void Can_get_parent_only_headers() BlockhashProvider provider = new(tree, LimboLogs.Instance); BlockHeader? head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None); Block current = Build.A.Block.WithParent(head!).TestObject; - Hash256 result = provider.GetBlockhash(current.Header, chainLength - 1); + Hash256 result = provider.GetBlockhash(current.Header, chainLength - 1, Frontier.Instance); Assert.That(result, Is.EqualTo(head?.Hash)); } @@ -39,7 +40,7 @@ public void Can_lookup_up_to_256_before_with_headers_only() BlockhashProvider provider = new(tree, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256 result = provider.GetBlockhash(current.Header, chainLength - 256); + Hash256 result = provider.GetBlockhash(current.Header, chainLength - 256, Frontier.Instance); Assert.That(result, Is.EqualTo(tree.FindHeader(256, BlockTreeLookupOptions.None)!.Hash)); } @@ -54,7 +55,7 @@ public void Can_lookup_up_to_256_before_with_headers_only_and_competing_branches BlockhashProvider provider = new(tree, LimboLogs.Instance); Block current = Build.A.Block.WithParent(headBlock).TestObject; long lookupNumber = chainLength - 256; - Hash256 result = provider.GetBlockhash(current.Header, lookupNumber); + Hash256 result = provider.GetBlockhash(current.Header, lookupNumber, Frontier.Instance); Assert.NotNull(result); } @@ -71,7 +72,7 @@ public void Can_lookup_up_to_256_before_soon_after_fast_sync() tree.SuggestBlock(current); tree.UpdateMainChain(current); long lookupNumber = chainLength - 256; - Hash256 result = provider.GetBlockhash(current.Header, lookupNumber); + Hash256 result = provider.GetBlockhash(current.Header, lookupNumber, Frontier.Instance); Assert.NotNull(result); } @@ -94,7 +95,7 @@ public void Can_lookup_up_to_256_before_some_blocks_after_fast_sync() } long lookupNumber = current.Number - 256; - Hash256 result = provider.GetBlockhash(current.Header, lookupNumber); + Hash256 result = provider.GetBlockhash(current.Header, lookupNumber, Frontier.Instance); Assert.NotNull(result); } @@ -115,7 +116,7 @@ public void Can_handle_non_main_chain_in_fast_sync() BlockhashProvider provider = new(tree, LimboLogs.Instance); - Hash256 result = provider.GetBlockhash(current.Header, 509); + Hash256 result = provider.GetBlockhash(current.Header, 509, Frontier.Instance); Assert.NotNull(result); } @@ -131,7 +132,7 @@ public void Can_get_parent_hash() BlockhashProvider provider = new(tree, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256 result = provider.GetBlockhash(current.Header, chainLength - 1); + Hash256 result = provider.GetBlockhash(current.Header, chainLength - 1, Frontier.Instance); Assert.That(result, Is.EqualTo(head.Hash)); } @@ -146,7 +147,7 @@ public void Cannot_ask_for_self() BlockhashProvider provider = new(tree, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256 result = provider.GetBlockhash(current.Header, chainLength); + Hash256 result = provider.GetBlockhash(current.Header, chainLength, Frontier.Instance); Assert.Null(result); } @@ -161,7 +162,7 @@ public void Cannot_ask_about_future() BlockhashProvider provider = new(tree, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256 result = provider.GetBlockhash(current.Header, chainLength + 1); + Hash256 result = provider.GetBlockhash(current.Header, chainLength + 1, Frontier.Instance); Assert.Null(result); } @@ -176,7 +177,7 @@ public void Can_lookup_up_to_256_before() BlockhashProvider provider = new(tree, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256 result = provider.GetBlockhash(current.Header, chainLength - 256); + Hash256 result = provider.GetBlockhash(current.Header, chainLength - 256, Frontier.Instance); Assert.That(result, Is.EqualTo(tree.FindHeader(256, BlockTreeLookupOptions.None)!.Hash)); } @@ -191,7 +192,7 @@ public void No_lookup_more_than_256_before() BlockhashProvider provider = new(tree, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256 result = provider.GetBlockhash(current.Header, chainLength - 257); + Hash256 result = provider.GetBlockhash(current.Header, chainLength - 257, Frontier.Instance); Assert.Null(result); } @@ -206,7 +207,7 @@ public void UInt_256_overflow() BlockhashProvider provider = new(tree, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256 result = provider.GetBlockhash(current.Header, 127); + Hash256 result = provider.GetBlockhash(current.Header, 127, Frontier.Instance); Assert.That(result, Is.EqualTo(head.Hash)); } } diff --git a/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs b/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs index e15cc231e33..2d82e526f25 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs +++ b/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs @@ -3,17 +3,17 @@ using System; using System.IO; +using Nethermind.Blockchain.BlockHashInState; using Nethermind.Blockchain.Find; using Nethermind.Core; using Nethermind.Core.Specs; -using Nethermind.Evm.BlockHashInState; using Nethermind.State; -namespace Nethermind.Blockchain.BlockHashInState; +namespace Nethermind.Blockchain; public static class BlockHashInStateExtension { - public static void InitHistoryOnForkBlock(this IBlockHashInStateHandler handler,IBlockTree blockTree, BlockHeader currentBlock, + public static void InitHistoryOnForkBlock(IBlockTree blockTree, BlockHeader currentBlock, IReleaseSpec spec, IWorldState stateProvider) { long current = currentBlock.Number; @@ -22,7 +22,7 @@ public static class BlockHashInStateExtension { // an extra check - don't think it is needed if (header.IsGenesis) break; - handler.AddParentBlockHashToState(header, spec, stateProvider); + BlockHashInStateHandler.AddParentBlockHashToState(header, spec, stateProvider); header = blockTree.FindParentHeader(currentBlock, BlockTreeLookupOptions.TotalDifficultyNotNeeded); if (header is null) { diff --git a/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs b/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs index 065211ac7a2..d53caa0ae9d 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs +++ b/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs @@ -3,11 +3,15 @@ using System; using System.IO; +using Nethermind.Blockchain.BlockHashInState; using Nethermind.Blockchain.Find; using Nethermind.Core; using Nethermind.Core.Crypto; +using Nethermind.Core.Specs; using Nethermind.Evm; +using Nethermind.Int256; using Nethermind.Logging; +using Nethermind.State; namespace Nethermind.Blockchain { @@ -23,8 +27,15 @@ public BlockhashProvider(IBlockTree blockTree, ILogManager? logManager) _logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager)); } - public Hash256 GetBlockhash(BlockHeader currentBlock, in long number) + public Hash256? GetBlockhash(BlockHeader currentBlock, in long number, IReleaseSpec spec, IWorldState? stateProvider = null) { + + if (spec.IsBlockHashInStateAvailable) + { + ArgumentNullException.ThrowIfNull(stateProvider); + return BlockHashInStateHandler.GetBlockHashFromState(number, spec, stateProvider); + } + long current = currentBlock.Number; if (number >= current || number < current - Math.Min(current, _maxDepth)) { diff --git a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs index cfd007a4681..35c795fdc59 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs @@ -3,7 +3,6 @@ using System; using System.Collections.Generic; -using System.IO; using System.Numerics; using System.Runtime.InteropServices; using System.Threading; @@ -20,7 +19,6 @@ using Nethermind.Core.Specs; using Nethermind.Crypto; using Nethermind.Evm; -using Nethermind.Evm.BlockHashInState; using Nethermind.Evm.Tracing; using Nethermind.Int256; using Nethermind.Logging; @@ -40,7 +38,6 @@ public partial class BlockProcessor : IBlockProcessor private readonly IWitnessCollector _witnessCollector; private readonly IWithdrawalProcessor _withdrawalProcessor; private readonly IBeaconBlockRootHandler _beaconBlockRootHandler; - private readonly IBlockHashInStateHandler _blockHashInStateHandlerHandler; private readonly IBlockValidator _blockValidator; private readonly IRewardCalculator _rewardCalculator; private readonly IBlockProcessor.IBlockTransactionsExecutor _blockTransactionsExecutor; @@ -78,7 +75,6 @@ public partial class BlockProcessor : IBlockProcessor _receiptsRootCalculator = receiptsRootCalculator ?? ReceiptsRootCalculator.Instance; _blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree)); _beaconBlockRootHandler = new BeaconBlockRootHandler(); - _blockHashInStateHandlerHandler = new BlockHashInStateHandler(); ReceiptsTracer = new BlockReceiptsTracer(); } @@ -250,13 +246,10 @@ private void ValidateProcessedBlock(Block suggestedBlock, ProcessingOptions opti // this would just be true on the fork block BlockHeader parentHeader = _blockTree.FindParentHeader(block.Header, BlockTreeLookupOptions.None); if (parentHeader is not null && parentHeader!.Timestamp < spec.Eip2935TransitionTimestamp) - { - _blockHashInStateHandlerHandler.InitHistoryOnForkBlock(_blockTree, block.Header, spec, _stateProvider); - } + BlockHashInStateExtension.InitHistoryOnForkBlock(_blockTree, block.Header, spec, _stateProvider); else - { - _blockHashInStateHandlerHandler.AddParentBlockHashToState(block.Header, spec, _stateProvider); - } + BlockHashInStateHandler.AddParentBlockHashToState(block.Header, spec, _stateProvider); + } diff --git a/src/Nethermind/Nethermind.Evm.Test/TestBlockhashProvider.cs b/src/Nethermind/Nethermind.Evm.Test/TestBlockhashProvider.cs index b95fb719cc8..f7f18c53626 100644 --- a/src/Nethermind/Nethermind.Evm.Test/TestBlockhashProvider.cs +++ b/src/Nethermind/Nethermind.Evm.Test/TestBlockhashProvider.cs @@ -3,6 +3,8 @@ using Nethermind.Core; using Nethermind.Core.Crypto; +using Nethermind.Core.Specs; +using Nethermind.State; namespace Nethermind.Evm.Test { @@ -14,7 +16,7 @@ private TestBlockhashProvider() { } - public Hash256 GetBlockhash(BlockHeader currentBlock, in long number) + public Hash256 GetBlockhash(BlockHeader currentBlock, in long number, IReleaseSpec spec, IWorldState stateProvider) { return Keccak.Compute(number.ToString()); } diff --git a/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs b/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs index 2df3ac7b9f1..3871a1cad4d 100644 --- a/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs +++ b/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs @@ -7,16 +7,15 @@ using Nethermind.Core.Crypto; using Nethermind.Core.Extensions; using Nethermind.Core.Specs; -using Nethermind.Evm.BlockHashInState; using Nethermind.Evm.Tracing; using Nethermind.Int256; using Nethermind.State; namespace Nethermind.Blockchain.BlockHashInState; -public class BlockHashInStateHandler : IBlockHashInStateHandler +public static class BlockHashInStateHandler { - public void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec, IWorldState stateProvider) + public static void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec, IWorldState stateProvider) { if (!spec.IsEip2935Enabled || blockHeader.IsGenesis || @@ -33,7 +32,7 @@ public void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec stateProvider.Set(blockHashStoreCell, parentBlockHash.Bytes.WithoutLeadingZeros().ToArray()); } - public Hash256? GetBlockHashFromState(long blockNumber, IReleaseSpec spec, IWorldState stateProvider) + public static Hash256? GetBlockHashFromState(long blockNumber, IReleaseSpec spec, IWorldState stateProvider) { var blockIndex = new UInt256((ulong)((blockNumber - 1) % Eip2935Constants.RingBufferSize)); Address? eip2935Account = spec.Eip2935ContractAddress ?? Eip2935Constants.BlockHashHistoryAddress; diff --git a/src/Nethermind/Nethermind.Evm/BlockHashInState/IBlockHashInStateHandler.cs b/src/Nethermind/Nethermind.Evm/BlockHashInState/IBlockHashInStateHandler.cs deleted file mode 100644 index 2c749ac0cfc..00000000000 --- a/src/Nethermind/Nethermind.Evm/BlockHashInState/IBlockHashInStateHandler.cs +++ /dev/null @@ -1,15 +0,0 @@ -// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using Nethermind.Core; -using Nethermind.Core.Crypto; -using Nethermind.Core.Specs; -using Nethermind.State; - -namespace Nethermind.Evm.BlockHashInState; - -public interface IBlockHashInStateHandler -{ - public void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec, IWorldState stateProvider); - public Hash256? GetBlockHashFromState(long blockNumber, IReleaseSpec spec, IWorldState stateProvider); -} diff --git a/src/Nethermind/Nethermind.Evm/IBlockhashProvider.cs b/src/Nethermind/Nethermind.Evm/IBlockhashProvider.cs index 3cbc1b9335d..a7684303fca 100644 --- a/src/Nethermind/Nethermind.Evm/IBlockhashProvider.cs +++ b/src/Nethermind/Nethermind.Evm/IBlockhashProvider.cs @@ -3,11 +3,13 @@ using Nethermind.Core; using Nethermind.Core.Crypto; +using Nethermind.Core.Specs; +using Nethermind.State; namespace Nethermind.Evm { public interface IBlockhashProvider { - Hash256 GetBlockhash(BlockHeader currentBlock, in long number); + Hash256? GetBlockhash(BlockHeader currentBlock, in long number, IReleaseSpec spec, IWorldState stateProvider); } } diff --git a/src/Nethermind/Nethermind.Evm/VirtualMachine.cs b/src/Nethermind/Nethermind.Evm/VirtualMachine.cs index 06d3c2ac29e..66902fd37ff 100644 --- a/src/Nethermind/Nethermind.Evm/VirtualMachine.cs +++ b/src/Nethermind/Nethermind.Evm/VirtualMachine.cs @@ -19,10 +19,8 @@ using Nethermind.State; using System.Diagnostics.CodeAnalysis; using System.Diagnostics; -using System.Runtime.InteropServices; using System.Runtime.Intrinsics; using Nethermind.Blockchain.BlockHashInState; -using Nethermind.Evm.BlockHashInState; using static Nethermind.Evm.VirtualMachine; using static System.Runtime.CompilerServices.Unsafe; using ValueHash256 = Nethermind.Core.Crypto.ValueHash256; @@ -190,7 +188,6 @@ internal sealed class VirtualMachine : IVirtualMachine where TLogger : private readonly byte[] _chainId; private readonly IBlockhashProvider _blockhashProvider; - private readonly IBlockHashInStateHandler _blockHashInStateHandler = new BlockHashInStateHandler(); private readonly ISpecProvider _specProvider; private readonly ILogger _logger; private IWorldState _worldState; @@ -1484,9 +1481,7 @@ private CallResult ExecuteCall(EvmState vmState, ReadOnlyM if (!stack.PopUInt256(out a)) goto StackUnderflow; long number = a > long.MaxValue ? long.MaxValue : (long)a; - Hash256 blockHash = spec.IsBlockHashInStateAvailable - ? _blockHashInStateHandler.GetBlockHashFromState(number, spec, _worldState) - : _blockhashProvider.GetBlockhash(blkCtx.Header, number); + Hash256? blockHash = _blockhashProvider.GetBlockhash(blkCtx.Header, number, spec, _worldState); stack.PushBytes(blockHash is not null ? blockHash.Bytes : BytesZero32); diff --git a/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs b/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs index 7106f468250..3cd3bf5874d 100644 --- a/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs +++ b/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs @@ -2,7 +2,6 @@ // SPDX-License-Identifier: LGPL-3.0-only using System; -using System.Collections.Generic; using System.Linq; using System.Linq.Expressions; using System.Threading.Tasks; @@ -21,11 +20,7 @@ using Nethermind.Specs; using Nethermind.Specs.Forks; using Nethermind.State; -using Nethermind.Core.Specs; using Nethermind.Consensus.BeaconBlockRoot; -using Nethermind.Consensus.Withdrawals; -using Nethermind.Core.Test.Blockchain; -using Nethermind.Evm.BlockHashInState; namespace Nethermind.Merge.Plugin.Test { @@ -34,7 +29,6 @@ public partial class EngineModuleTests { private static readonly DateTime Timestamp = DateTimeOffset.FromUnixTimeSeconds(1000).UtcDateTime; private static readonly IBeaconBlockRootHandler _beaconBlockRootHandler = new BeaconBlockRootHandler(); - private static readonly IBlockHashInStateHandler _blockHashInStateHandler = new BlockHashInStateHandler(); private ITimestamper Timestamper { get; } = new ManualTimestamper(Timestamp); private void AssertExecutionStatusChanged(IBlockFinder blockFinder, Hash256 headBlockHash, Hash256 finalizedBlockHash, Hash256 safeBlockHash) @@ -118,7 +112,7 @@ private ExecutionPayload CreateParentBlockRequestOnHead(IBlockTree blockTree) Snapshot before = chain.State.TakeSnapshot(); _beaconBlockRootHandler.ApplyContractStateChanges(block!, chain.SpecProvider.GenesisSpec, chain.State); - _blockHashInStateHandler.AddParentBlockHashToState(block!.Header, chain.SpecProvider.GenesisSpec, chain.State); + BlockHashInStateHandler.AddParentBlockHashToState(block!.Header, chain.SpecProvider.GenesisSpec, chain.State); chain.WithdrawalProcessor?.ProcessWithdrawals(block!, chain.SpecProvider.GenesisSpec); chain.State.Commit(chain.SpecProvider.GenesisSpec); From ed9a04e474a2d0bf57bf58983bab08eea120febe Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Fri, 19 Apr 2024 15:31:40 +0530 Subject: [PATCH 14/44] account for null --- .../BlockhashProviderTests.cs | 24 +++++++++---------- 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs index 771dfb1d05e..149954da7da 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs @@ -25,7 +25,7 @@ public void Can_get_parent_only_headers() BlockhashProvider provider = new(tree, LimboLogs.Instance); BlockHeader? head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None); Block current = Build.A.Block.WithParent(head!).TestObject; - Hash256 result = provider.GetBlockhash(current.Header, chainLength - 1, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, chainLength - 1, Frontier.Instance); Assert.That(result, Is.EqualTo(head?.Hash)); } @@ -40,7 +40,7 @@ public void Can_lookup_up_to_256_before_with_headers_only() BlockhashProvider provider = new(tree, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256 result = provider.GetBlockhash(current.Header, chainLength - 256, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, chainLength - 256, Frontier.Instance); Assert.That(result, Is.EqualTo(tree.FindHeader(256, BlockTreeLookupOptions.None)!.Hash)); } @@ -55,7 +55,7 @@ public void Can_lookup_up_to_256_before_with_headers_only_and_competing_branches BlockhashProvider provider = new(tree, LimboLogs.Instance); Block current = Build.A.Block.WithParent(headBlock).TestObject; long lookupNumber = chainLength - 256; - Hash256 result = provider.GetBlockhash(current.Header, lookupNumber, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, lookupNumber, Frontier.Instance); Assert.NotNull(result); } @@ -72,7 +72,7 @@ public void Can_lookup_up_to_256_before_soon_after_fast_sync() tree.SuggestBlock(current); tree.UpdateMainChain(current); long lookupNumber = chainLength - 256; - Hash256 result = provider.GetBlockhash(current.Header, lookupNumber, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, lookupNumber, Frontier.Instance); Assert.NotNull(result); } @@ -95,7 +95,7 @@ public void Can_lookup_up_to_256_before_some_blocks_after_fast_sync() } long lookupNumber = current.Number - 256; - Hash256 result = provider.GetBlockhash(current.Header, lookupNumber, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, lookupNumber, Frontier.Instance); Assert.NotNull(result); } @@ -116,7 +116,7 @@ public void Can_handle_non_main_chain_in_fast_sync() BlockhashProvider provider = new(tree, LimboLogs.Instance); - Hash256 result = provider.GetBlockhash(current.Header, 509, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, 509, Frontier.Instance); Assert.NotNull(result); } @@ -132,7 +132,7 @@ public void Can_get_parent_hash() BlockhashProvider provider = new(tree, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256 result = provider.GetBlockhash(current.Header, chainLength - 1, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, chainLength - 1, Frontier.Instance); Assert.That(result, Is.EqualTo(head.Hash)); } @@ -147,7 +147,7 @@ public void Cannot_ask_for_self() BlockhashProvider provider = new(tree, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256 result = provider.GetBlockhash(current.Header, chainLength, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, chainLength, Frontier.Instance); Assert.Null(result); } @@ -162,7 +162,7 @@ public void Cannot_ask_about_future() BlockhashProvider provider = new(tree, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256 result = provider.GetBlockhash(current.Header, chainLength + 1, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, chainLength + 1, Frontier.Instance); Assert.Null(result); } @@ -177,7 +177,7 @@ public void Can_lookup_up_to_256_before() BlockhashProvider provider = new(tree, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256 result = provider.GetBlockhash(current.Header, chainLength - 256, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, chainLength - 256, Frontier.Instance); Assert.That(result, Is.EqualTo(tree.FindHeader(256, BlockTreeLookupOptions.None)!.Hash)); } @@ -192,7 +192,7 @@ public void No_lookup_more_than_256_before() BlockhashProvider provider = new(tree, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256 result = provider.GetBlockhash(current.Header, chainLength - 257, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, chainLength - 257, Frontier.Instance); Assert.Null(result); } @@ -207,7 +207,7 @@ public void UInt_256_overflow() BlockhashProvider provider = new(tree, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256 result = provider.GetBlockhash(current.Header, 127, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, 127, Frontier.Instance); Assert.That(result, Is.EqualTo(head.Hash)); } } From da2c3e7c2c0b1be93ed8f61c7337a125cd783eaa Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Fri, 19 Apr 2024 16:40:50 +0530 Subject: [PATCH 15/44] fix errors --- .../BlockHashInStateExtension.cs | 4 ++-- .../Nethermind.Blockchain/BlockhashProvider.cs | 3 +-- .../Processing/BlockProcessor.cs | 2 +- .../BlockHashInState/BlockHashInStateHandler.cs | 16 +++++----------- src/Nethermind/Nethermind.Evm/VirtualMachine.cs | 1 - .../EngineModuleTests.HelperFunctions.cs | 2 +- 6 files changed, 10 insertions(+), 18 deletions(-) diff --git a/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs b/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs index 2d82e526f25..e4ba4414598 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs +++ b/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs @@ -3,10 +3,10 @@ using System; using System.IO; -using Nethermind.Blockchain.BlockHashInState; using Nethermind.Blockchain.Find; using Nethermind.Core; using Nethermind.Core.Specs; +using Nethermind.Evm.BlockHashInState; using Nethermind.State; namespace Nethermind.Blockchain; @@ -23,7 +23,7 @@ public static class BlockHashInStateExtension // an extra check - don't think it is needed if (header.IsGenesis) break; BlockHashInStateHandler.AddParentBlockHashToState(header, spec, stateProvider); - header = blockTree.FindParentHeader(currentBlock, BlockTreeLookupOptions.TotalDifficultyNotNeeded); + header = blockTree.FindParentHeader(header, BlockTreeLookupOptions.TotalDifficultyNotNeeded); if (header is null) { throw new InvalidDataException( diff --git a/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs b/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs index d53caa0ae9d..97855666e74 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs +++ b/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs @@ -3,13 +3,12 @@ using System; using System.IO; -using Nethermind.Blockchain.BlockHashInState; using Nethermind.Blockchain.Find; using Nethermind.Core; using Nethermind.Core.Crypto; using Nethermind.Core.Specs; using Nethermind.Evm; -using Nethermind.Int256; +using Nethermind.Evm.BlockHashInState; using Nethermind.Logging; using Nethermind.State; diff --git a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs index 35c795fdc59..c4b1429ae85 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs @@ -7,7 +7,6 @@ using System.Runtime.InteropServices; using System.Threading; using Nethermind.Blockchain; -using Nethermind.Blockchain.BlockHashInState; using Nethermind.Blockchain.Find; using Nethermind.Blockchain.Receipts; using Nethermind.Consensus.BeaconBlockRoot; @@ -19,6 +18,7 @@ using Nethermind.Core.Specs; using Nethermind.Crypto; using Nethermind.Evm; +using Nethermind.Evm.BlockHashInState; using Nethermind.Evm.Tracing; using Nethermind.Int256; using Nethermind.Logging; diff --git a/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs b/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs index 3871a1cad4d..c5a2b9c9cb4 100644 --- a/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs +++ b/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs @@ -2,28 +2,23 @@ // SPDX-License-Identifier:LGPL-3.0-only using System; -using System.IO; using Nethermind.Core; using Nethermind.Core.Crypto; using Nethermind.Core.Extensions; using Nethermind.Core.Specs; -using Nethermind.Evm.Tracing; using Nethermind.Int256; using Nethermind.State; -namespace Nethermind.Blockchain.BlockHashInState; +namespace Nethermind.Evm.BlockHashInState; public static class BlockHashInStateHandler { public static void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec, IWorldState stateProvider) { - if (!spec.IsEip2935Enabled || - blockHeader.IsGenesis || - blockHeader.ParentHash is null) return; + if (!spec.IsEip2935Enabled || blockHeader.IsGenesis || blockHeader.ParentHash is null) return; Address? eip2935Account = spec.Eip2935ContractAddress ?? Eip2935Constants.BlockHashHistoryAddress; - if (!stateProvider.AccountExists(eip2935Account)) - return; + if (!stateProvider.AccountExists(eip2935Account)) return; Hash256 parentBlockHash = blockHeader.ParentHash; var blockIndex = new UInt256((ulong)((blockHeader.Number - 1) % Eip2935Constants.RingBufferSize)); @@ -34,11 +29,10 @@ public static void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSp public static Hash256? GetBlockHashFromState(long blockNumber, IReleaseSpec spec, IWorldState stateProvider) { - var blockIndex = new UInt256((ulong)((blockNumber - 1) % Eip2935Constants.RingBufferSize)); + var blockIndex = new UInt256((ulong)(blockNumber % Eip2935Constants.RingBufferSize)); Address? eip2935Account = spec.Eip2935ContractAddress ?? Eip2935Constants.BlockHashHistoryAddress; StorageCell blockHashStoreCell = new(eip2935Account, blockIndex); ReadOnlySpan data = stateProvider.Get(blockHashStoreCell); - if (data.Length < 32) return null; - return new Hash256(data); + return data.Length < 32 ? null : new Hash256(data); } } diff --git a/src/Nethermind/Nethermind.Evm/VirtualMachine.cs b/src/Nethermind/Nethermind.Evm/VirtualMachine.cs index 66902fd37ff..098e310df35 100644 --- a/src/Nethermind/Nethermind.Evm/VirtualMachine.cs +++ b/src/Nethermind/Nethermind.Evm/VirtualMachine.cs @@ -20,7 +20,6 @@ using System.Diagnostics.CodeAnalysis; using System.Diagnostics; using System.Runtime.Intrinsics; -using Nethermind.Blockchain.BlockHashInState; using static Nethermind.Evm.VirtualMachine; using static System.Runtime.CompilerServices.Unsafe; using ValueHash256 = Nethermind.Core.Crypto.ValueHash256; diff --git a/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs b/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs index 3cd3bf5874d..0dcecb0b67d 100644 --- a/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs +++ b/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs @@ -6,7 +6,6 @@ using System.Linq.Expressions; using System.Threading.Tasks; using Nethermind.Blockchain; -using Nethermind.Blockchain.BlockHashInState; using Nethermind.Blockchain.Find; using Nethermind.Core; using Nethermind.Core.Crypto; @@ -21,6 +20,7 @@ using Nethermind.Specs.Forks; using Nethermind.State; using Nethermind.Consensus.BeaconBlockRoot; +using Nethermind.Evm.BlockHashInState; namespace Nethermind.Merge.Plugin.Test { From 30f48d2948a142af4e20cf15a8fc7af06270348b Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Fri, 19 Apr 2024 16:50:10 +0530 Subject: [PATCH 16/44] add one test --- .../BlockhashProviderTests.cs | 32 +++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs index 149954da7da..5474bf537aa 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs @@ -4,8 +4,11 @@ using Nethermind.Core; using Nethermind.Core.Crypto; using Nethermind.Core.Test.Builders; +using Nethermind.Db; using Nethermind.Logging; using Nethermind.Specs.Forks; +using Nethermind.State; +using Nethermind.Trie.Pruning; using NUnit.Framework; namespace Nethermind.Blockchain.Test @@ -13,6 +16,13 @@ namespace Nethermind.Blockchain.Test [TestFixture] public class BlockhashProviderTests { + private IWorldState _worldState; + [SetUp] + public void Setup() + { + var trieStore = new TrieStore(new MemDb(), LimboLogs.Instance); + _worldState = new WorldState(trieStore, new MemDb(), SimpleConsoleLogManager.Instance); + } [Test, Timeout(Timeout.MaxTestTime)] public void Can_get_parent_only_headers() { @@ -29,6 +39,28 @@ public void Can_get_parent_only_headers() Assert.That(result, Is.EqualTo(head?.Hash)); } + [Test, Timeout(Timeout.MaxTestTime)] + public void Can_get_parent_only_headers_post_eip2935() + { + const int chainLength = 512; + + _worldState.CreateAccount(Eip2935Constants.BlockHashHistoryAddress, 0, 1); + + Block genesis = Build.A.Block.Genesis.TestObject; + BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(chainLength).TestObject; + + BlockhashProvider provider = new(tree, SimpleConsoleLogManager.Instance); + + BlockHeader? head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None); + Block current = Build.A.Block.WithParent(head!).TestObject; + + BlockHashInStateExtension.InitHistoryOnForkBlock(tree, current.Header, Prague.Instance, _worldState); + _worldState.Commit(Prague.Instance); + + Hash256? result = provider.GetBlockhash(current.Header, chainLength - 1, Prague.Instance, _worldState); + Assert.That(result, Is.EqualTo(head?.Hash)); + } + [Test, Timeout(Timeout.MaxTestTime)] public void Can_lookup_up_to_256_before_with_headers_only() { From e71bf5c6eec6dadc5490ee928ee8cd848ee27927 Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Fri, 19 Apr 2024 19:27:03 +0530 Subject: [PATCH 17/44] whitespace --- src/Nethermind/Nethermind.Network/P2P/P2PMessageKey.cs | 2 +- src/Nethermind/Nethermind.Specs/Forks/18_Prague.cs | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/Nethermind/Nethermind.Network/P2P/P2PMessageKey.cs b/src/Nethermind/Nethermind.Network/P2P/P2PMessageKey.cs index 8f4e62c8c57..17bcacfb843 100644 --- a/src/Nethermind/Nethermind.Network/P2P/P2PMessageKey.cs +++ b/src/Nethermind/Nethermind.Network/P2P/P2PMessageKey.cs @@ -59,7 +59,7 @@ private string GetMessageType() if (!MessageNames.TryGetValue((Protocol.Protocol, PacketType), out string messageName)) { #if DEBUG - throw new NotImplementedException($"Message name for protocol {Protocol.Protocol} message id {PacketType} not set."); + throw new NotImplementedException($"Message name for protocol {Protocol.Protocol} message id {PacketType} not set."); #else return PacketType.ToString(); // Just use the integer directly then #endif diff --git a/src/Nethermind/Nethermind.Specs/Forks/18_Prague.cs b/src/Nethermind/Nethermind.Specs/Forks/18_Prague.cs index 0365673472f..ad951de82aa 100644 --- a/src/Nethermind/Nethermind.Specs/Forks/18_Prague.cs +++ b/src/Nethermind/Nethermind.Specs/Forks/18_Prague.cs @@ -7,7 +7,8 @@ namespace Nethermind.Specs.Forks; -public class Prague: Cancun { +public class Prague : Cancun +{ private static IReleaseSpec _instance; protected Prague() From 00df46dbbe51c387eeaf2d472fbfade505efd2b5 Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Fri, 19 Apr 2024 19:38:52 +0530 Subject: [PATCH 18/44] add test to check correct implementation is being used --- .../Nethermind.Evm.Test/Eip2935Tests.cs | 54 +++++++++++++++++++ .../TestBlockhashProvider.cs | 4 +- 2 files changed, 57 insertions(+), 1 deletion(-) create mode 100644 src/Nethermind/Nethermind.Evm.Test/Eip2935Tests.cs diff --git a/src/Nethermind/Nethermind.Evm.Test/Eip2935Tests.cs b/src/Nethermind/Nethermind.Evm.Test/Eip2935Tests.cs new file mode 100644 index 00000000000..bc623cfb4cb --- /dev/null +++ b/src/Nethermind/Nethermind.Evm.Test/Eip2935Tests.cs @@ -0,0 +1,54 @@ +// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using FluentAssertions; +using Nethermind.Core; +using Nethermind.Core.Crypto; +using Nethermind.Core.Specs; +using Nethermind.Evm.Tracing; +using Nethermind.Specs; +using NUnit.Framework; + +namespace Nethermind.Evm.Test; + +[TestFixture] +public class Eip2935Tests : VirtualMachineTestsBase +{ + protected override long BlockNumber => MainnetSpecProvider.ParisBlockNumber; + protected override ulong Timestamp => MainnetSpecProvider.PragueBlockTimestamp; + + + public override void Setup() + { + base.Setup(); + TestState.CreateAccount(Eip2935Constants.BlockHashHistoryAddress, 1); + TestState.Commit(SpecProvider.GenesisSpec); + TestState.CommitTree(0); + } + + + [TestCase(MainnetSpecProvider.CancunBlockTimestamp, false)] + [TestCase(MainnetSpecProvider.PragueBlockTimestamp, true)] + public void CorrectBlockhashBeingUsed(ulong timestamp, bool eipEnabled) + { + const long blockNumber = 256; + byte[] bytecode = + Prepare.EvmCode + .PushData(blockNumber) + .Op(Instruction.BLOCKHASH) + .PushData(0) + .Op(Instruction.MSTORE) + .PushData(32) + .PushData(0) + .Op(Instruction.RETURN) + .Done; + + + (Block block, Transaction transaction) = PrepareTx(new ForkActivation(BlockNumber, timestamp), 100000, bytecode); + CallOutputTracer callOutputTracer = new(); + _processor.Execute(transaction, block.Header, callOutputTracer); + + long expected = eipEnabled ? blockNumber + Eip2935Constants.RingBufferSize : blockNumber; + callOutputTracer.ReturnValue!.Should().BeEquivalentTo(Keccak.Compute(expected.ToString()).BytesToArray()); + } +} diff --git a/src/Nethermind/Nethermind.Evm.Test/TestBlockhashProvider.cs b/src/Nethermind/Nethermind.Evm.Test/TestBlockhashProvider.cs index f7f18c53626..058ddaea441 100644 --- a/src/Nethermind/Nethermind.Evm.Test/TestBlockhashProvider.cs +++ b/src/Nethermind/Nethermind.Evm.Test/TestBlockhashProvider.cs @@ -18,7 +18,9 @@ private TestBlockhashProvider() public Hash256 GetBlockhash(BlockHeader currentBlock, in long number, IReleaseSpec spec, IWorldState stateProvider) { - return Keccak.Compute(number.ToString()); + if (spec.IsBlockHashInStateAvailable) + return Keccak.Compute((Eip2935Constants.RingBufferSize + number).ToString()); + return Keccak.Compute((number).ToString()); } } } From 00f7248e99fc8699de9ea1d6855463e6e4c429f5 Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Fri, 19 Apr 2024 19:57:46 +0530 Subject: [PATCH 19/44] fix other solutions --- src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs | 1 + src/Nethermind/Ethereum.Test.Base/TestBlockhashProvider.cs | 4 +++- .../Nethermind.Evm.Benchmark/TestBlockhashProvider.cs | 4 +++- .../Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs | 2 +- 4 files changed, 8 insertions(+), 3 deletions(-) diff --git a/src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs b/src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs index aadcf1750a2..98dd868d8ba 100644 --- a/src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs +++ b/src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs @@ -166,6 +166,7 @@ protected async Task RunTest(BlockchainTest test, Stopwatch? stateProvider, receiptStorage, NullWitnessCollector.Instance, + blockTree, _logManager); IBlockchainProcessor blockchainProcessor = new BlockchainProcessor( diff --git a/src/Nethermind/Ethereum.Test.Base/TestBlockhashProvider.cs b/src/Nethermind/Ethereum.Test.Base/TestBlockhashProvider.cs index 786ddde0b16..9ad97dfcc80 100644 --- a/src/Nethermind/Ethereum.Test.Base/TestBlockhashProvider.cs +++ b/src/Nethermind/Ethereum.Test.Base/TestBlockhashProvider.cs @@ -3,13 +3,15 @@ using Nethermind.Core; using Nethermind.Core.Crypto; +using Nethermind.Core.Specs; using Nethermind.Evm; +using Nethermind.State; namespace Ethereum.Test.Base { public class TestBlockhashProvider : IBlockhashProvider { - public Hash256 GetBlockhash(BlockHeader currentBlock, in long number) + public Hash256 GetBlockhash(BlockHeader currentBlock, in long number, IReleaseSpec spec, IWorldState stateProvider) { if (number != 0) return Keccak.Zero; diff --git a/src/Nethermind/Nethermind.Evm.Benchmark/TestBlockhashProvider.cs b/src/Nethermind/Nethermind.Evm.Benchmark/TestBlockhashProvider.cs index c95162989f5..f6b8454dfe1 100644 --- a/src/Nethermind/Nethermind.Evm.Benchmark/TestBlockhashProvider.cs +++ b/src/Nethermind/Nethermind.Evm.Benchmark/TestBlockhashProvider.cs @@ -3,12 +3,14 @@ using Nethermind.Core; using Nethermind.Core.Crypto; +using Nethermind.Core.Specs; +using Nethermind.State; namespace Nethermind.Evm.Benchmark { public class TestBlockhashProvider : IBlockhashProvider { - public Hash256 GetBlockhash(BlockHeader currentBlock, in long number) + public Hash256 GetBlockhash(BlockHeader currentBlock, in long number, IReleaseSpec spec, IWorldState stateProvider) { return Keccak.Compute(number.ToString()); } diff --git a/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs b/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs index 78641dbe1ed..ea072ebdc34 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs @@ -93,7 +93,7 @@ TransactionProcessor transactionProcessor IBlockProcessor.IBlockTransactionsExecutor transactionsExecutor = new BlockProcessor.BlockValidationTransactionsExecutor(transactionProcessor, stateProvider); BlockProcessor blockProcessor = new(specProvider, Always.Valid, new RewardCalculator(specProvider), transactionsExecutor, - stateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, LimboLogs.Instance); + stateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, blockTree, LimboLogs.Instance); EthereumEcdsa ecdsa = new(specProvider.ChainId, LimboLogs.Instance); BlockchainProcessor blockchainProcessor = new( From 96d5e0235718466df5ac911cacd56062fada0bfa Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Fri, 19 Apr 2024 19:57:55 +0530 Subject: [PATCH 20/44] update test --- .../BlockhashProviderTests.cs | 54 +++++++++++-------- 1 file changed, 31 insertions(+), 23 deletions(-) diff --git a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs index 5474bf537aa..aa766c4dc54 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs @@ -5,6 +5,7 @@ using Nethermind.Core.Crypto; using Nethermind.Core.Test.Builders; using Nethermind.Db; +using Nethermind.Evm.BlockHashInState; using Nethermind.Logging; using Nethermind.Specs.Forks; using Nethermind.State; @@ -21,7 +22,9 @@ public class BlockhashProviderTests public void Setup() { var trieStore = new TrieStore(new MemDb(), LimboLogs.Instance); - _worldState = new WorldState(trieStore, new MemDb(), SimpleConsoleLogManager.Instance); + _worldState = new WorldState(trieStore, new MemDb(), LimboLogs.Instance); + _worldState.CreateAccount(Eip2935Constants.BlockHashHistoryAddress, 0, 1); + _worldState.Commit(Frontier.Instance); } [Test, Timeout(Timeout.MaxTestTime)] public void Can_get_parent_only_headers() @@ -39,28 +42,6 @@ public void Can_get_parent_only_headers() Assert.That(result, Is.EqualTo(head?.Hash)); } - [Test, Timeout(Timeout.MaxTestTime)] - public void Can_get_parent_only_headers_post_eip2935() - { - const int chainLength = 512; - - _worldState.CreateAccount(Eip2935Constants.BlockHashHistoryAddress, 0, 1); - - Block genesis = Build.A.Block.Genesis.TestObject; - BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(chainLength).TestObject; - - BlockhashProvider provider = new(tree, SimpleConsoleLogManager.Instance); - - BlockHeader? head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None); - Block current = Build.A.Block.WithParent(head!).TestObject; - - BlockHashInStateExtension.InitHistoryOnForkBlock(tree, current.Header, Prague.Instance, _worldState); - _worldState.Commit(Prague.Instance); - - Hash256? result = provider.GetBlockhash(current.Header, chainLength - 1, Prague.Instance, _worldState); - Assert.That(result, Is.EqualTo(head?.Hash)); - } - [Test, Timeout(Timeout.MaxTestTime)] public void Can_lookup_up_to_256_before_with_headers_only() { @@ -242,5 +223,32 @@ public void UInt_256_overflow() Hash256? result = provider.GetBlockhash(current.Header, 127, Frontier.Instance); Assert.That(result, Is.EqualTo(head.Hash)); } + + [Test, Timeout(Timeout.MaxTestTime)] + public void Eip2935_init_block_history_and_then_get_hash() + { + const int chainLength = 512; + + Block genesis = Build.A.Block.Genesis.TestObject; + BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(chainLength).TestObject; + + BlockhashProvider provider = new(tree, LimboLogs.Instance); + + BlockHeader? head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None); + Block current = Build.A.Block.WithParent(head!).TestObject; + + BlockHashInStateExtension.InitHistoryOnForkBlock(tree, current.Header, Prague.Instance, _worldState); + _worldState.Commit(Prague.Instance); + + Hash256? result = provider.GetBlockhash(current.Header, chainLength - 1, Prague.Instance, _worldState); + Assert.That(result, Is.EqualTo(head?.Hash)); + + tree.SuggestHeader(current.Header); + head = current.Header; + current = Build.A.Block.WithParent(head!).TestObject; + BlockHashInStateHandler.AddParentBlockHashToState(current.Header, Prague.Instance, _worldState); + result = provider.GetBlockhash(current.Header, chainLength , Prague.Instance, _worldState); + Assert.That(result, Is.EqualTo(head?.Hash)); + } } } From 88047c3c5b8655e44b7c9ac2bd642c0847271dca Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Fri, 19 Apr 2024 20:24:25 +0530 Subject: [PATCH 21/44] whitespaces --- .../Nethermind.Blockchain.Test/BlockhashProviderTests.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs index aa766c4dc54..5a2d4f55f53 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs @@ -247,7 +247,7 @@ public void Eip2935_init_block_history_and_then_get_hash() head = current.Header; current = Build.A.Block.WithParent(head!).TestObject; BlockHashInStateHandler.AddParentBlockHashToState(current.Header, Prague.Instance, _worldState); - result = provider.GetBlockhash(current.Header, chainLength , Prague.Instance, _worldState); + result = provider.GetBlockhash(current.Header, chainLength, Prague.Instance, _worldState); Assert.That(result, Is.EqualTo(head?.Hash)); } } From 0e55089cc006cd6f95ab4c5aa2787cc6c1b39427 Mon Sep 17 00:00:00 2001 From: MarekM25 Date: Mon, 22 Apr 2024 15:07:07 +0200 Subject: [PATCH 22/44] cosmetic --- src/Nethermind/Nethermind.Core/Eip2935Constants.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Nethermind/Nethermind.Core/Eip2935Constants.cs b/src/Nethermind/Nethermind.Core/Eip2935Constants.cs index eba7142871a..6d4f0d548ef 100644 --- a/src/Nethermind/Nethermind.Core/Eip2935Constants.cs +++ b/src/Nethermind/Nethermind.Core/Eip2935Constants.cs @@ -6,7 +6,7 @@ namespace Nethermind.Core; /// -/// Represents the EIP-4788 parameters. +/// Represents the EIP-2935 parameters. /// public static class Eip2935Constants { From 374607a8321c239a18ef83fee01826db97d098b4 Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Mon, 22 Apr 2024 19:09:21 +0530 Subject: [PATCH 23/44] fix constants --- .../Nethermind.Blockchain/BlockHashInStateExtension.cs | 2 +- src/Nethermind/Nethermind.Core/Eip2935Constants.cs | 5 +++-- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs b/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs index e4ba4414598..ccb9bb85f9b 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs +++ b/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs @@ -18,7 +18,7 @@ public static class BlockHashInStateExtension { long current = currentBlock.Number; BlockHeader header = currentBlock; - for (var i = 0; i < Math.Min(Eip2935Constants.RingBufferSize, current); i++) + for (var i = 0; i < Math.Min(Eip2935Constants.BlockHashOldWindow, current); i++) { // an extra check - don't think it is needed if (header.IsGenesis) break; diff --git a/src/Nethermind/Nethermind.Core/Eip2935Constants.cs b/src/Nethermind/Nethermind.Core/Eip2935Constants.cs index 6d4f0d548ef..d004345d5da 100644 --- a/src/Nethermind/Nethermind.Core/Eip2935Constants.cs +++ b/src/Nethermind/Nethermind.Core/Eip2935Constants.cs @@ -13,7 +13,8 @@ public static class Eip2935Constants /// /// Gets the HISTORY_STORAGE_ADDRESS parameter. /// - public static readonly Address BlockHashHistoryAddress = new("0xfffffffffffffffffffffffffffffffffffffffe"); + public static readonly Address BlockHashHistoryAddress = new("0x25a219378dad9b3503c8268c9ca836a52427a4fb"); - public static readonly long RingBufferSize = 256; + public static readonly long RingBufferSize = 8192; + public static readonly long BlockHashOldWindow = 256; } From 619972cb26ee035ff576c2bac92e087636e7b2ce Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Mon, 22 Apr 2024 19:19:53 +0530 Subject: [PATCH 24/44] get block hash --- .../Nethermind.Blockchain/BlockhashProvider.cs | 5 ++--- .../BlockHashInState/BlockHashInStateHandler.cs | 9 +++++++-- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs b/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs index 97855666e74..5f52bb5a1a9 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs +++ b/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs @@ -28,14 +28,13 @@ public BlockhashProvider(IBlockTree blockTree, ILogManager? logManager) public Hash256? GetBlockhash(BlockHeader currentBlock, in long number, IReleaseSpec spec, IWorldState? stateProvider = null) { - + long current = currentBlock.Number; if (spec.IsBlockHashInStateAvailable) { ArgumentNullException.ThrowIfNull(stateProvider); - return BlockHashInStateHandler.GetBlockHashFromState(number, spec, stateProvider); + return BlockHashInStateHandler.GetBlockHashFromState(current, number, spec, stateProvider); } - long current = currentBlock.Number; if (number >= current || number < current - Math.Min(current, _maxDepth)) { return null; diff --git a/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs b/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs index c5a2b9c9cb4..47e06680f01 100644 --- a/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs +++ b/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs @@ -27,9 +27,14 @@ public static void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSp stateProvider.Set(blockHashStoreCell, parentBlockHash.Bytes.WithoutLeadingZeros().ToArray()); } - public static Hash256? GetBlockHashFromState(long blockNumber, IReleaseSpec spec, IWorldState stateProvider) + public static Hash256? GetBlockHashFromState(long currentBlockNumber, long requiredBlockNumber, IReleaseSpec spec, IWorldState stateProvider) { - var blockIndex = new UInt256((ulong)(blockNumber % Eip2935Constants.RingBufferSize)); + if (requiredBlockNumber >= currentBlockNumber || requiredBlockNumber < + currentBlockNumber - Math.Min(currentBlockNumber, Eip2935Constants.RingBufferSize)) + { + return null; + } + var blockIndex = new UInt256((ulong)(requiredBlockNumber % Eip2935Constants.RingBufferSize)); Address? eip2935Account = spec.Eip2935ContractAddress ?? Eip2935Constants.BlockHashHistoryAddress; StorageCell blockHashStoreCell = new(eip2935Account, blockIndex); ReadOnlySpan data = stateProvider.Get(blockHashStoreCell); From 52ddf96ba28369a8b0074f52311c0e0d8aab2db5 Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Mon, 22 Apr 2024 19:54:42 +0530 Subject: [PATCH 25/44] fix get block hash --- .../BlockHashInState/BlockHashInStateHandler.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs b/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs index 47e06680f01..99b1b984584 100644 --- a/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs +++ b/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs @@ -29,8 +29,8 @@ public static void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSp public static Hash256? GetBlockHashFromState(long currentBlockNumber, long requiredBlockNumber, IReleaseSpec spec, IWorldState stateProvider) { - if (requiredBlockNumber >= currentBlockNumber || requiredBlockNumber < - currentBlockNumber - Math.Min(currentBlockNumber, Eip2935Constants.RingBufferSize)) + if (requiredBlockNumber >= currentBlockNumber || + requiredBlockNumber + Eip2935Constants.RingBufferSize < currentBlockNumber) { return null; } From aa72dc9d1f7cbcd93f18e162f3fd792b3e3c724f Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Tue, 23 Apr 2024 10:33:56 +0530 Subject: [PATCH 26/44] eip clarification --- .../Nethermind.Blockchain/BlockHashInStateExtension.cs | 2 +- src/Nethermind/Nethermind.Core/Eip2935Constants.cs | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs b/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs index ccb9bb85f9b..e4ba4414598 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs +++ b/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs @@ -18,7 +18,7 @@ public static class BlockHashInStateExtension { long current = currentBlock.Number; BlockHeader header = currentBlock; - for (var i = 0; i < Math.Min(Eip2935Constants.BlockHashOldWindow, current); i++) + for (var i = 0; i < Math.Min(Eip2935Constants.RingBufferSize, current); i++) { // an extra check - don't think it is needed if (header.IsGenesis) break; diff --git a/src/Nethermind/Nethermind.Core/Eip2935Constants.cs b/src/Nethermind/Nethermind.Core/Eip2935Constants.cs index d004345d5da..8df633f7954 100644 --- a/src/Nethermind/Nethermind.Core/Eip2935Constants.cs +++ b/src/Nethermind/Nethermind.Core/Eip2935Constants.cs @@ -16,5 +16,4 @@ public static class Eip2935Constants public static readonly Address BlockHashHistoryAddress = new("0x25a219378dad9b3503c8268c9ca836a52427a4fb"); public static readonly long RingBufferSize = 8192; - public static readonly long BlockHashOldWindow = 256; } From 69657fd42ea96c8d02024a0d672444373e479551 Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Thu, 25 Apr 2024 08:26:31 +0530 Subject: [PATCH 27/44] consolidate the interfaces --- .../BlockhashProviderTests.cs | 61 +++++++------- .../Producers/DevBlockproducerTests.cs | 2 +- .../Nethermind.Blockchain.Test/ReorgTests.cs | 2 +- .../BlockHashInStateExtension.cs | 20 +---- .../BlockhashProvider.cs | 18 +++-- .../Nethermind.Blockchain/BlockhashStore.cs | 79 +++++++++++++++++++ .../CliqueBlockProducerTests.cs | 2 +- .../Processing/BlockProcessor.cs | 7 +- .../Processing/ReadOnlyTxProcessingEnv.cs | 2 +- .../Blockchain/TestBlockchain.cs | 2 +- .../EvmPooledMemoryTests.cs | 2 +- .../TestBlockhashProvider.cs | 9 ++- .../Tracing/GasEstimationTests.cs | 2 +- .../TransactionProcessorEip4844Tests.cs | 2 +- .../TransactionProcessorFeeTests.cs | 2 +- .../TransactionProcessorTests.cs | 2 +- .../VirtualMachineTestsBase.cs | 2 +- .../BlockHashInStateHandler.cs | 43 ---------- .../Nethermind.Evm/IBlockhashProvider.cs | 2 +- .../Nethermind.Evm/Nethermind.Evm.csproj | 3 + .../Nethermind.Evm/VirtualMachine.cs | 2 +- .../Steps/InitializeBlockchain.cs | 3 +- .../Modules/Trace/ParityStyleTracerTests.cs | 2 +- .../EngineModuleTests.HelperFunctions.cs | 4 +- .../SyncThreadTests.cs | 2 +- 25 files changed, 154 insertions(+), 123 deletions(-) create mode 100644 src/Nethermind/Nethermind.Blockchain/BlockhashStore.cs delete mode 100644 src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs diff --git a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs index 5a2d4f55f53..3fb97facc30 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs @@ -5,8 +5,8 @@ using Nethermind.Core.Crypto; using Nethermind.Core.Test.Builders; using Nethermind.Db; -using Nethermind.Evm.BlockHashInState; using Nethermind.Logging; +using Nethermind.Specs; using Nethermind.Specs.Forks; using Nethermind.State; using Nethermind.Trie.Pruning; @@ -35,10 +35,10 @@ public void Can_get_parent_only_headers() BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); BlockHeader? head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None); Block current = Build.A.Block.WithParent(head!).TestObject; - Hash256? result = provider.GetBlockhash(current.Header, chainLength - 1, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, chainLength - 1); Assert.That(result, Is.EqualTo(head?.Hash)); } @@ -50,10 +50,10 @@ public void Can_lookup_up_to_256_before_with_headers_only() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256? result = provider.GetBlockhash(current.Header, chainLength - 256, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, chainLength - 256); Assert.That(result, Is.EqualTo(tree.FindHeader(256, BlockTreeLookupOptions.None)!.Hash)); } @@ -65,10 +65,10 @@ public void Can_lookup_up_to_256_before_with_headers_only_and_competing_branches Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(out Block headBlock, chainLength).OfChainLength(out Block _, chainLength, 1).TestObject; - BlockhashProvider provider = new(tree, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); Block current = Build.A.Block.WithParent(headBlock).TestObject; long lookupNumber = chainLength - 256; - Hash256? result = provider.GetBlockhash(current.Header, lookupNumber, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, lookupNumber); Assert.NotNull(result); } @@ -80,12 +80,12 @@ public void Can_lookup_up_to_256_before_soon_after_fast_sync() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(out Block headBlock, chainLength).OfChainLength(out Block _, chainLength, 1).TestObject; - BlockhashProvider provider = new(tree, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); Block current = Build.A.Block.WithParent(headBlock).TestObject; tree.SuggestBlock(current); tree.UpdateMainChain(current); long lookupNumber = chainLength - 256; - Hash256? result = provider.GetBlockhash(current.Header, lookupNumber, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, lookupNumber); Assert.NotNull(result); } @@ -97,7 +97,7 @@ public void Can_lookup_up_to_256_before_some_blocks_after_fast_sync() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(out Block headBlock, chainLength).OfChainLength(out Block _, chainLength, 1).TestObject; - BlockhashProvider provider = new(tree, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); Block current = Build.A.Block.WithParent(headBlock).TestObject; for (int i = 0; i < 6; i++) @@ -108,7 +108,7 @@ public void Can_lookup_up_to_256_before_some_blocks_after_fast_sync() } long lookupNumber = current.Number - 256; - Hash256? result = provider.GetBlockhash(current.Header, lookupNumber, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, lookupNumber); Assert.NotNull(result); } @@ -127,9 +127,9 @@ public void Can_handle_non_main_chain_in_fast_sync() current = Build.A.Block.WithParent(current).TestObject; } - BlockhashProvider provider = new(tree, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); - Hash256? result = provider.GetBlockhash(current.Header, 509, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, 509); Assert.NotNull(result); } @@ -142,10 +142,10 @@ public void Can_get_parent_hash() BlockTree tree = Build.A.BlockTree(genesis).OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256? result = provider.GetBlockhash(current.Header, chainLength - 1, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, chainLength - 1); Assert.That(result, Is.EqualTo(head.Hash)); } @@ -157,10 +157,10 @@ public void Cannot_ask_for_self() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256? result = provider.GetBlockhash(current.Header, chainLength, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, chainLength); Assert.Null(result); } @@ -172,10 +172,10 @@ public void Cannot_ask_about_future() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256? result = provider.GetBlockhash(current.Header, chainLength + 1, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, chainLength + 1); Assert.Null(result); } @@ -187,10 +187,10 @@ public void Can_lookup_up_to_256_before() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256? result = provider.GetBlockhash(current.Header, chainLength - 256, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, chainLength - 256); Assert.That(result, Is.EqualTo(tree.FindHeader(256, BlockTreeLookupOptions.None)!.Hash)); } @@ -202,10 +202,10 @@ public void No_lookup_more_than_256_before() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256? result = provider.GetBlockhash(current.Header, chainLength - 257, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, chainLength - 257); Assert.Null(result); } @@ -217,10 +217,10 @@ public void UInt_256_overflow() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; - Hash256? result = provider.GetBlockhash(current.Header, 127, Frontier.Instance); + Hash256? result = provider.GetBlockhash(current.Header, 127); Assert.That(result, Is.EqualTo(head.Hash)); } @@ -232,22 +232,23 @@ public void Eip2935_init_block_history_and_then_get_hash() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Prague.Instance), _worldState, LimboLogs.Instance); + BlockhashStore store = new BlockhashStore(tree, new TestSpecProvider(Prague.Instance), _worldState); BlockHeader? head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None); Block current = Build.A.Block.WithParent(head!).TestObject; - BlockHashInStateExtension.InitHistoryOnForkBlock(tree, current.Header, Prague.Instance, _worldState); + store.InitHistoryOnForkBlock(current.Header); _worldState.Commit(Prague.Instance); - Hash256? result = provider.GetBlockhash(current.Header, chainLength - 1, Prague.Instance, _worldState); + Hash256? result = provider.GetBlockhash(current.Header, chainLength - 1); Assert.That(result, Is.EqualTo(head?.Hash)); tree.SuggestHeader(current.Header); head = current.Header; current = Build.A.Block.WithParent(head!).TestObject; - BlockHashInStateHandler.AddParentBlockHashToState(current.Header, Prague.Instance, _worldState); - result = provider.GetBlockhash(current.Header, chainLength, Prague.Instance, _worldState); + store.AddParentBlockHashToState(current.Header); + result = provider.GetBlockhash(current.Header, chainLength); Assert.That(result, Is.EqualTo(head?.Hash)); } } diff --git a/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs index b88cc0810d4..9f65fe8e99f 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs @@ -55,7 +55,7 @@ public void Test() dbProvider.RegisteredDbs[DbNames.Code], LimboLogs.Instance); StateReader stateReader = new(trieStore, dbProvider.GetDb(DbNames.State), LimboLogs.Instance); - BlockhashProvider blockhashProvider = new(blockTree, LimboLogs.Instance); + BlockhashProvider blockhashProvider = new(blockTree, specProvider, stateProvider, LimboLogs.Instance); VirtualMachine virtualMachine = new( blockhashProvider, specProvider, diff --git a/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs index e21a236931e..d207b36595d 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs @@ -56,7 +56,7 @@ public void Setup() new TxValidator(specProvider.ChainId), LimboLogs.Instance, transactionComparerProvider.GetDefaultComparer()); - BlockhashProvider blockhashProvider = new(_blockTree, LimboLogs.Instance); + BlockhashProvider blockhashProvider = new(_blockTree, specProvider, stateProvider, LimboLogs.Instance); VirtualMachine virtualMachine = new( blockhashProvider, specProvider, diff --git a/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs b/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs index e4ba4414598..f1a23bee016 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs +++ b/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs @@ -6,29 +6,11 @@ using Nethermind.Blockchain.Find; using Nethermind.Core; using Nethermind.Core.Specs; -using Nethermind.Evm.BlockHashInState; using Nethermind.State; namespace Nethermind.Blockchain; public static class BlockHashInStateExtension { - public static void InitHistoryOnForkBlock(IBlockTree blockTree, BlockHeader currentBlock, - IReleaseSpec spec, IWorldState stateProvider) - { - long current = currentBlock.Number; - BlockHeader header = currentBlock; - for (var i = 0; i < Math.Min(Eip2935Constants.RingBufferSize, current); i++) - { - // an extra check - don't think it is needed - if (header.IsGenesis) break; - BlockHashInStateHandler.AddParentBlockHashToState(header, spec, stateProvider); - header = blockTree.FindParentHeader(header, BlockTreeLookupOptions.TotalDifficultyNotNeeded); - if (header is null) - { - throw new InvalidDataException( - "Parent header cannot be found when initializing BlockHashInState history"); - } - } - } + } diff --git a/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs b/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs index 5f52bb5a1a9..6171144a0fb 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs +++ b/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs @@ -8,7 +8,6 @@ using Nethermind.Core.Crypto; using Nethermind.Core.Specs; using Nethermind.Evm; -using Nethermind.Evm.BlockHashInState; using Nethermind.Logging; using Nethermind.State; @@ -18,23 +17,30 @@ public class BlockhashProvider : IBlockhashProvider { private static readonly int _maxDepth = 256; private readonly IBlockTree _blockTree; + private readonly ISpecProvider _specProvider; + private readonly IWorldState _worldState; + private readonly IBlockhashStore _blockhashStore; private readonly ILogger _logger; - public BlockhashProvider(IBlockTree blockTree, ILogManager? logManager) + public BlockhashProvider(IBlockTree blockTree, ISpecProvider specProvider, IWorldState worldState, ILogManager? logManager) { _blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree)); + _specProvider = specProvider; + _worldState = worldState; + _blockhashStore = new BlockhashStore(blockTree, specProvider, worldState); _logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager)); } - public Hash256? GetBlockhash(BlockHeader currentBlock, in long number, IReleaseSpec spec, IWorldState? stateProvider = null) + public Hash256? GetBlockhash(BlockHeader currentBlock, in long number) { - long current = currentBlock.Number; + IReleaseSpec? spec = _specProvider.GetSpec(currentBlock); + if (spec.IsBlockHashInStateAvailable) { - ArgumentNullException.ThrowIfNull(stateProvider); - return BlockHashInStateHandler.GetBlockHashFromState(current, number, spec, stateProvider); + return _blockhashStore.GetBlockHashFromState(currentBlock, number); } + long current = currentBlock.Number; if (number >= current || number < current - Math.Min(current, _maxDepth)) { return null; diff --git a/src/Nethermind/Nethermind.Blockchain/BlockhashStore.cs b/src/Nethermind/Nethermind.Blockchain/BlockhashStore.cs new file mode 100644 index 00000000000..1846d6136e6 --- /dev/null +++ b/src/Nethermind/Nethermind.Blockchain/BlockhashStore.cs @@ -0,0 +1,79 @@ +// SPDX-FileCopyrightText:2023 Demerzel Solutions Limited +// SPDX-License-Identifier:LGPL-3.0-only + +using System; +using System.IO; +using Nethermind.Blockchain.Find; +using Nethermind.Core; +using Nethermind.Core.Crypto; +using Nethermind.Core.Extensions; +using Nethermind.Core.Specs; +using Nethermind.Int256; +using Nethermind.State; + +namespace Nethermind.Blockchain; + +public interface IBlockhashStore +{ + public void InitHistoryOnForkBlock(BlockHeader currentBlock); + public void AddParentBlockHashToState(BlockHeader blockHeader); + public Hash256? GetBlockHashFromState(BlockHeader currentBlockHeader, long requiredBlockNumber); +} +public class BlockhashStore: IBlockhashStore +{ + public BlockhashStore(IBlockFinder blockFinder, ISpecProvider specProvider, IWorldState worldState) + { + _blockFinder = blockFinder; + _specProvider = specProvider; + _worldState = worldState; + } + private readonly IBlockFinder _blockFinder; + private readonly ISpecProvider _specProvider; + private readonly IWorldState _worldState; + public void InitHistoryOnForkBlock(BlockHeader currentBlock) + { + long current = currentBlock.Number; + BlockHeader header = currentBlock; + for (var i = 0; i < Math.Min(Eip2935Constants.RingBufferSize, current); i++) + { + // an extra check - don't think it is needed + if (header.IsGenesis) break; + AddParentBlockHashToState(header); + header = _blockFinder.FindParentHeader(header, BlockTreeLookupOptions.TotalDifficultyNotNeeded); + if (header is null) + { + throw new InvalidDataException( + "Parent header cannot be found when initializing BlockHashInState history"); + } + } + } + public void AddParentBlockHashToState(BlockHeader blockHeader) + { + var spec = _specProvider.GetSpec(blockHeader); + if (!spec.IsEip2935Enabled || blockHeader.IsGenesis || blockHeader.ParentHash is null) return; + Address? eip2935Account = spec.Eip2935ContractAddress ?? Eip2935Constants.BlockHashHistoryAddress; + + if (!_worldState.AccountExists(eip2935Account)) return; + + Hash256 parentBlockHash = blockHeader.ParentHash; + var blockIndex = new UInt256((ulong)((blockHeader.Number - 1) % Eip2935Constants.RingBufferSize)); + + StorageCell blockHashStoreCell = new(eip2935Account, blockIndex); + _worldState.Set(blockHashStoreCell, parentBlockHash.Bytes.WithoutLeadingZeros().ToArray()); + } + + public Hash256? GetBlockHashFromState(BlockHeader currentHeader, long requiredBlockNumber) + { + var spec = _specProvider.GetSpec(currentHeader); + if (requiredBlockNumber >= currentHeader.Number || + requiredBlockNumber + Eip2935Constants.RingBufferSize < currentHeader.Number) + { + return null; + } + var blockIndex = new UInt256((ulong)(requiredBlockNumber % Eip2935Constants.RingBufferSize)); + Address? eip2935Account = spec.Eip2935ContractAddress ?? Eip2935Constants.BlockHashHistoryAddress; + StorageCell blockHashStoreCell = new(eip2935Account, blockIndex); + ReadOnlySpan data = _worldState.Get(blockHashStoreCell); + return data.Length < 32 ? null : new Hash256(data); + } +} diff --git a/src/Nethermind/Nethermind.Clique.Test/CliqueBlockProducerTests.cs b/src/Nethermind/Nethermind.Clique.Test/CliqueBlockProducerTests.cs index 60437fd51fd..2e5366b3552 100644 --- a/src/Nethermind/Nethermind.Clique.Test/CliqueBlockProducerTests.cs +++ b/src/Nethermind/Nethermind.Clique.Test/CliqueBlockProducerTests.cs @@ -115,7 +115,7 @@ public On CreateNode(PrivateKey privateKey, bool withGenesisAlreadyProcessed = f transactionComparerProvider.GetDefaultComparer()); _pools[privateKey] = txPool; - BlockhashProvider blockhashProvider = new(blockTree, LimboLogs.Instance); + BlockhashProvider blockhashProvider = new(blockTree, specProvider, stateProvider, LimboLogs.Instance); _blockTrees.Add(privateKey, blockTree); SnapshotManager snapshotManager = new(_cliqueConfig, blocksDb, blockTree, _ethereumEcdsa, nodeLogManager); diff --git a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs index c4b1429ae85..154aea5103a 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs @@ -18,7 +18,6 @@ using Nethermind.Core.Specs; using Nethermind.Crypto; using Nethermind.Evm; -using Nethermind.Evm.BlockHashInState; using Nethermind.Evm.Tracing; using Nethermind.Int256; using Nethermind.Logging; @@ -42,6 +41,7 @@ public partial class BlockProcessor : IBlockProcessor private readonly IRewardCalculator _rewardCalculator; private readonly IBlockProcessor.IBlockTransactionsExecutor _blockTransactionsExecutor; private readonly IBlockTree _blockTree; + private readonly IBlockhashStore _blockhashStore; private const int MaxUncommittedBlocks = 64; /// @@ -75,6 +75,7 @@ public partial class BlockProcessor : IBlockProcessor _receiptsRootCalculator = receiptsRootCalculator ?? ReceiptsRootCalculator.Instance; _blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree)); _beaconBlockRootHandler = new BeaconBlockRootHandler(); + _blockhashStore = new BlockhashStore(_blockTree, _specProvider, _stateProvider); ReceiptsTracer = new BlockReceiptsTracer(); } @@ -246,9 +247,9 @@ private void ValidateProcessedBlock(Block suggestedBlock, ProcessingOptions opti // this would just be true on the fork block BlockHeader parentHeader = _blockTree.FindParentHeader(block.Header, BlockTreeLookupOptions.None); if (parentHeader is not null && parentHeader!.Timestamp < spec.Eip2935TransitionTimestamp) - BlockHashInStateExtension.InitHistoryOnForkBlock(_blockTree, block.Header, spec, _stateProvider); + _blockhashStore.InitHistoryOnForkBlock(block.Header); else - BlockHashInStateHandler.AddParentBlockHashToState(block.Header, spec, _stateProvider); + _blockhashStore.AddParentBlockHashToState(block.Header); } diff --git a/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyTxProcessingEnv.cs b/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyTxProcessingEnv.cs index 060b52ca5dc..47671734515 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyTxProcessingEnv.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyTxProcessingEnv.cs @@ -45,7 +45,7 @@ public class ReadOnlyTxProcessingEnv : IReadOnlyTxProcessorSource StateProvider = worldStateManager.CreateResettableWorldState(); BlockTree = readOnlyBlockTree ?? throw new ArgumentNullException(nameof(readOnlyBlockTree)); - BlockhashProvider = new BlockhashProvider(BlockTree, logManager); + BlockhashProvider = new BlockhashProvider(BlockTree, specProvider, StateProvider, logManager); Machine = new VirtualMachine(BlockhashProvider, specProvider, logManager); TransactionProcessor = new TransactionProcessor(specProvider, StateProvider, Machine, logManager); diff --git a/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs b/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs index 1e895750452..24e47467107 100644 --- a/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs +++ b/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs @@ -171,7 +171,7 @@ protected virtual async Task Build(ISpecProvider? specProvider = _trieStoreWatcher = new TrieStoreBoundaryWatcher(WorldStateManager, BlockTree, LogManager); ReceiptStorage = new InMemoryReceiptStorage(blockTree: BlockTree); - VirtualMachine virtualMachine = new(new BlockhashProvider(BlockTree, LogManager), SpecProvider, LogManager); + VirtualMachine virtualMachine = new(new BlockhashProvider(BlockTree, SpecProvider, State, LogManager), SpecProvider, LogManager); TxProcessor = new TransactionProcessor(SpecProvider, State, virtualMachine, LogManager); BlockPreprocessorStep = new RecoverSignatures(EthereumEcdsa, TxPool, SpecProvider, LogManager); HeaderValidator = new HeaderValidator(BlockTree, Always.Valid, SpecProvider, LogManager); diff --git a/src/Nethermind/Nethermind.Evm.Test/EvmPooledMemoryTests.cs b/src/Nethermind/Nethermind.Evm.Test/EvmPooledMemoryTests.cs index 29542672d18..b41031802bd 100644 --- a/src/Nethermind/Nethermind.Evm.Test/EvmPooledMemoryTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/EvmPooledMemoryTests.cs @@ -159,7 +159,7 @@ private static string run(byte[] input) LimboLogs.Instance); ISpecProvider specProvider = new TestSpecProvider(London.Instance); VirtualMachine virtualMachine = new( - Nethermind.Evm.Test.TestBlockhashProvider.Instance, + new TestBlockhashProvider(specProvider), specProvider, LimboLogs.Instance); TransactionProcessor transactionProcessor = new TransactionProcessor( diff --git a/src/Nethermind/Nethermind.Evm.Test/TestBlockhashProvider.cs b/src/Nethermind/Nethermind.Evm.Test/TestBlockhashProvider.cs index 058ddaea441..d3dc562cc21 100644 --- a/src/Nethermind/Nethermind.Evm.Test/TestBlockhashProvider.cs +++ b/src/Nethermind/Nethermind.Evm.Test/TestBlockhashProvider.cs @@ -10,14 +10,15 @@ namespace Nethermind.Evm.Test { public class TestBlockhashProvider : IBlockhashProvider { - public static TestBlockhashProvider Instance = new(); - - private TestBlockhashProvider() + private readonly ISpecProvider _specProvider; + public TestBlockhashProvider(ISpecProvider specProvider) { + _specProvider = specProvider; } - public Hash256 GetBlockhash(BlockHeader currentBlock, in long number, IReleaseSpec spec, IWorldState stateProvider) + public Hash256 GetBlockhash(BlockHeader currentBlock, in long number) { + var spec = _specProvider.GetSpec(currentBlock); if (spec.IsBlockHashInStateAvailable) return Keccak.Compute((Eip2935Constants.RingBufferSize + number).ToString()); return Keccak.Compute((number).ToString()); diff --git a/src/Nethermind/Nethermind.Evm.Test/Tracing/GasEstimationTests.cs b/src/Nethermind/Nethermind.Evm.Test/Tracing/GasEstimationTests.cs index df61919ce62..fd09ad2b167 100644 --- a/src/Nethermind/Nethermind.Evm.Test/Tracing/GasEstimationTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/Tracing/GasEstimationTests.cs @@ -363,7 +363,7 @@ public TestEnvironment() _stateProvider.Commit(_specProvider.GenesisSpec); _stateProvider.CommitTree(0); - VirtualMachine virtualMachine = new(TestBlockhashProvider.Instance, _specProvider, LimboLogs.Instance); + VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance); _transactionProcessor = new TransactionProcessor(_specProvider, _stateProvider, virtualMachine, LimboLogs.Instance); _ethereumEcdsa = new EthereumEcdsa(_specProvider.ChainId, LimboLogs.Instance); diff --git a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip4844Tests.cs b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip4844Tests.cs index 7a72a46e358..7312cf923f7 100644 --- a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip4844Tests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip4844Tests.cs @@ -35,7 +35,7 @@ public void Setup() _specProvider = new TestSpecProvider(Cancun.Instance); TrieStore trieStore = new(stateDb, LimboLogs.Instance); _stateProvider = new WorldState(trieStore, new MemDb(), LimboLogs.Instance); - VirtualMachine virtualMachine = new(TestBlockhashProvider.Instance, _specProvider, LimboLogs.Instance); + VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance); _transactionProcessor = new TransactionProcessor(_specProvider, _stateProvider, virtualMachine, LimboLogs.Instance); _ethereumEcdsa = new EthereumEcdsa(_specProvider.ChainId, LimboLogs.Instance); } diff --git a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorFeeTests.cs b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorFeeTests.cs index d7f530768f3..09d61e31b55 100644 --- a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorFeeTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorFeeTests.cs @@ -42,7 +42,7 @@ public void Setup() _stateProvider.Commit(_specProvider.GenesisSpec); _stateProvider.CommitTree(0); - VirtualMachine virtualMachine = new(TestBlockhashProvider.Instance, _specProvider, LimboLogs.Instance); + VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance); _transactionProcessor = new TransactionProcessor(_specProvider, _stateProvider, virtualMachine, LimboLogs.Instance); _ethereumEcdsa = new EthereumEcdsa(_specProvider.ChainId, LimboLogs.Instance); } diff --git a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorTests.cs b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorTests.cs index afe85bcc78d..5d30cc00eee 100644 --- a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorTests.cs @@ -58,7 +58,7 @@ public void Setup() _stateProvider.Commit(_specProvider.GenesisSpec); _stateProvider.CommitTree(0); - VirtualMachine virtualMachine = new(TestBlockhashProvider.Instance, _specProvider, LimboLogs.Instance); + VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance); _transactionProcessor = new TransactionProcessor(_specProvider, _stateProvider, virtualMachine, LimboLogs.Instance); _ethereumEcdsa = new EthereumEcdsa(_specProvider.ChainId, LimboLogs.Instance); } diff --git a/src/Nethermind/Nethermind.Evm.Test/VirtualMachineTestsBase.cs b/src/Nethermind/Nethermind.Evm.Test/VirtualMachineTestsBase.cs index da4554f0314..5985f35d3d5 100644 --- a/src/Nethermind/Nethermind.Evm.Test/VirtualMachineTestsBase.cs +++ b/src/Nethermind/Nethermind.Evm.Test/VirtualMachineTestsBase.cs @@ -66,7 +66,7 @@ public virtual void Setup() ITrieStore trieStore = new TrieStore(_stateDb, logManager); TestState = new WorldState(trieStore, codeDb, logManager); _ethereumEcdsa = new EthereumEcdsa(SpecProvider.ChainId, logManager); - IBlockhashProvider blockhashProvider = TestBlockhashProvider.Instance; + IBlockhashProvider blockhashProvider = new TestBlockhashProvider(SpecProvider); Machine = new VirtualMachine(blockhashProvider, SpecProvider, logManager); _processor = new TransactionProcessor(SpecProvider, TestState, Machine, logManager); } diff --git a/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs b/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs deleted file mode 100644 index 99b1b984584..00000000000 --- a/src/Nethermind/Nethermind.Evm/BlockHashInState/BlockHashInStateHandler.cs +++ /dev/null @@ -1,43 +0,0 @@ -// SPDX-FileCopyrightText:2023 Demerzel Solutions Limited -// SPDX-License-Identifier:LGPL-3.0-only - -using System; -using Nethermind.Core; -using Nethermind.Core.Crypto; -using Nethermind.Core.Extensions; -using Nethermind.Core.Specs; -using Nethermind.Int256; -using Nethermind.State; - -namespace Nethermind.Evm.BlockHashInState; - -public static class BlockHashInStateHandler -{ - public static void AddParentBlockHashToState(BlockHeader blockHeader, IReleaseSpec spec, IWorldState stateProvider) - { - if (!spec.IsEip2935Enabled || blockHeader.IsGenesis || blockHeader.ParentHash is null) return; - Address? eip2935Account = spec.Eip2935ContractAddress ?? Eip2935Constants.BlockHashHistoryAddress; - - if (!stateProvider.AccountExists(eip2935Account)) return; - - Hash256 parentBlockHash = blockHeader.ParentHash; - var blockIndex = new UInt256((ulong)((blockHeader.Number - 1) % Eip2935Constants.RingBufferSize)); - - StorageCell blockHashStoreCell = new(eip2935Account, blockIndex); - stateProvider.Set(blockHashStoreCell, parentBlockHash.Bytes.WithoutLeadingZeros().ToArray()); - } - - public static Hash256? GetBlockHashFromState(long currentBlockNumber, long requiredBlockNumber, IReleaseSpec spec, IWorldState stateProvider) - { - if (requiredBlockNumber >= currentBlockNumber || - requiredBlockNumber + Eip2935Constants.RingBufferSize < currentBlockNumber) - { - return null; - } - var blockIndex = new UInt256((ulong)(requiredBlockNumber % Eip2935Constants.RingBufferSize)); - Address? eip2935Account = spec.Eip2935ContractAddress ?? Eip2935Constants.BlockHashHistoryAddress; - StorageCell blockHashStoreCell = new(eip2935Account, blockIndex); - ReadOnlySpan data = stateProvider.Get(blockHashStoreCell); - return data.Length < 32 ? null : new Hash256(data); - } -} diff --git a/src/Nethermind/Nethermind.Evm/IBlockhashProvider.cs b/src/Nethermind/Nethermind.Evm/IBlockhashProvider.cs index a7684303fca..bdbd27d52fc 100644 --- a/src/Nethermind/Nethermind.Evm/IBlockhashProvider.cs +++ b/src/Nethermind/Nethermind.Evm/IBlockhashProvider.cs @@ -10,6 +10,6 @@ namespace Nethermind.Evm { public interface IBlockhashProvider { - Hash256? GetBlockhash(BlockHeader currentBlock, in long number, IReleaseSpec spec, IWorldState stateProvider); + Hash256? GetBlockhash(BlockHeader currentBlock, in long number); } } diff --git a/src/Nethermind/Nethermind.Evm/Nethermind.Evm.csproj b/src/Nethermind/Nethermind.Evm/Nethermind.Evm.csproj index 8f6c31d198f..3c46f405757 100644 --- a/src/Nethermind/Nethermind.Evm/Nethermind.Evm.csproj +++ b/src/Nethermind/Nethermind.Evm/Nethermind.Evm.csproj @@ -27,4 +27,7 @@ true + + + diff --git a/src/Nethermind/Nethermind.Evm/VirtualMachine.cs b/src/Nethermind/Nethermind.Evm/VirtualMachine.cs index 098e310df35..9bf922a3e16 100644 --- a/src/Nethermind/Nethermind.Evm/VirtualMachine.cs +++ b/src/Nethermind/Nethermind.Evm/VirtualMachine.cs @@ -1480,7 +1480,7 @@ private CallResult ExecuteCall(EvmState vmState, ReadOnlyM if (!stack.PopUInt256(out a)) goto StackUnderflow; long number = a > long.MaxValue ? long.MaxValue : (long)a; - Hash256? blockHash = _blockhashProvider.GetBlockhash(blkCtx.Header, number, spec, _worldState); + Hash256? blockHash = _blockhashProvider.GetBlockhash(blkCtx.Header, number); stack.PushBytes(blockHash is not null ? blockHash.Bytes : BytesZero32); diff --git a/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs b/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs index cc8b8ad085c..4b79fd2c09e 100644 --- a/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs +++ b/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs @@ -175,10 +175,11 @@ protected virtual VirtualMachine CreateVirtualMachine() { if (_api.BlockTree is null) throw new StepDependencyException(nameof(_api.BlockTree)); if (_api.SpecProvider is null) throw new StepDependencyException(nameof(_api.SpecProvider)); + if (_api.WorldState is null) throw new StepDependencyException(nameof(_api.WorldState)); // blockchain processing BlockhashProvider blockhashProvider = new( - _api.BlockTree, _api.LogManager); + _api.BlockTree, _api.SpecProvider, _api.WorldState, _api.LogManager); return new VirtualMachine( blockhashProvider, diff --git a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Trace/ParityStyleTracerTests.cs b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Trace/ParityStyleTracerTests.cs index f20f7dfe448..7fa0e6d8a19 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Trace/ParityStyleTracerTests.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Trace/ParityStyleTracerTests.cs @@ -61,7 +61,7 @@ public void Setup() WorldState stateProvider = new(trieStore, codeDb, LimboLogs.Instance); _stateReader = new StateReader(trieStore, codeDb, LimboLogs.Instance); - BlockhashProvider blockhashProvider = new(_blockTree, LimboLogs.Instance); + BlockhashProvider blockhashProvider = new(_blockTree, specProvider, stateProvider, LimboLogs.Instance); VirtualMachine virtualMachine = new(blockhashProvider, specProvider, LimboLogs.Instance); TransactionProcessor transactionProcessor = new(specProvider, stateProvider, virtualMachine, LimboLogs.Instance); diff --git a/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs b/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs index 0dcecb0b67d..8c5548d7c56 100644 --- a/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs +++ b/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs @@ -20,7 +20,6 @@ using Nethermind.Specs.Forks; using Nethermind.State; using Nethermind.Consensus.BeaconBlockRoot; -using Nethermind.Evm.BlockHashInState; namespace Nethermind.Merge.Plugin.Test { @@ -112,7 +111,8 @@ private ExecutionPayload CreateParentBlockRequestOnHead(IBlockTree blockTree) Snapshot before = chain.State.TakeSnapshot(); _beaconBlockRootHandler.ApplyContractStateChanges(block!, chain.SpecProvider.GenesisSpec, chain.State); - BlockHashInStateHandler.AddParentBlockHashToState(block!.Header, chain.SpecProvider.GenesisSpec, chain.State); + var blockHashStore = new BlockhashStore(chain.BlockTree, chain.SpecProvider, chain.State); + blockHashStore.AddParentBlockHashToState(block!.Header); chain.WithdrawalProcessor?.ProcessWithdrawals(block!, chain.SpecProvider.GenesisSpec); chain.State.Commit(chain.SpecProvider.GenesisSpec); diff --git a/src/Nethermind/Nethermind.Synchronization.Test/SyncThreadTests.cs b/src/Nethermind/Nethermind.Synchronization.Test/SyncThreadTests.cs index d43acede2a0..5976010b040 100644 --- a/src/Nethermind/Nethermind.Synchronization.Test/SyncThreadTests.cs +++ b/src/Nethermind/Nethermind.Synchronization.Test/SyncThreadTests.cs @@ -273,7 +273,7 @@ private SyncTestContext CreateSyncManager(int index) new TxValidator(specProvider.ChainId), logManager, transactionComparerProvider.GetDefaultComparer()); - BlockhashProvider blockhashProvider = new(tree, LimboLogs.Instance); + BlockhashProvider blockhashProvider = new(tree, specProvider, stateProvider, LimboLogs.Instance); VirtualMachine virtualMachine = new(blockhashProvider, specProvider, logManager); Always sealValidator = Always.Valid; From 5eafc8d40d3b4348f378ca3307c98fec77920189 Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Thu, 25 Apr 2024 13:38:53 +0530 Subject: [PATCH 28/44] refactor --- .../BlockhashProviderTests.cs | 1 + .../BlockHashInStateExtension.cs | 16 ---------- .../BlockhashProvider.cs | 4 ++- .../{ => Blocks}/BlockhashStore.cs | 32 ++++++------------- .../Blocks/IBlockhashStore.cs | 14 ++++++++ .../Processing/BlockProcessor.cs | 1 + .../EngineModuleTests.HelperFunctions.cs | 1 + 7 files changed, 29 insertions(+), 40 deletions(-) delete mode 100644 src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs rename src/Nethermind/Nethermind.Blockchain/{ => Blocks}/BlockhashStore.cs (64%) create mode 100644 src/Nethermind/Nethermind.Blockchain/Blocks/IBlockhashStore.cs diff --git a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs index 3fb97facc30..6c8e5f1410c 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs @@ -1,6 +1,7 @@ // SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited // SPDX-License-Identifier: LGPL-3.0-only +using Nethermind.Blockchain.Blocks; using Nethermind.Core; using Nethermind.Core.Crypto; using Nethermind.Core.Test.Builders; diff --git a/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs b/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs deleted file mode 100644 index f1a23bee016..00000000000 --- a/src/Nethermind/Nethermind.Blockchain/BlockHashInStateExtension.cs +++ /dev/null @@ -1,16 +0,0 @@ -// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using System; -using System.IO; -using Nethermind.Blockchain.Find; -using Nethermind.Core; -using Nethermind.Core.Specs; -using Nethermind.State; - -namespace Nethermind.Blockchain; - -public static class BlockHashInStateExtension -{ - -} diff --git a/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs b/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs index 6171144a0fb..500af4b0c23 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs +++ b/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs @@ -3,6 +3,8 @@ using System; using System.IO; +using Nethermind.Blockchain; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Find; using Nethermind.Core; using Nethermind.Core.Crypto; @@ -27,7 +29,7 @@ public BlockhashProvider(IBlockTree blockTree, ISpecProvider specProvider, IWorl _blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree)); _specProvider = specProvider; _worldState = worldState; - _blockhashStore = new BlockhashStore(blockTree, specProvider, worldState); + _blockhashStore = new Blocks.BlockhashStore(blockTree, specProvider, worldState); _logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager)); } diff --git a/src/Nethermind/Nethermind.Blockchain/BlockhashStore.cs b/src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs similarity index 64% rename from src/Nethermind/Nethermind.Blockchain/BlockhashStore.cs rename to src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs index 1846d6136e6..28222c41273 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockhashStore.cs +++ b/src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs @@ -11,25 +11,11 @@ using Nethermind.Int256; using Nethermind.State; -namespace Nethermind.Blockchain; +namespace Nethermind.Blockchain.Blocks; -public interface IBlockhashStore +public class BlockhashStore(IBlockFinder blockFinder, ISpecProvider specProvider, IWorldState worldState) + : IBlockhashStore { - public void InitHistoryOnForkBlock(BlockHeader currentBlock); - public void AddParentBlockHashToState(BlockHeader blockHeader); - public Hash256? GetBlockHashFromState(BlockHeader currentBlockHeader, long requiredBlockNumber); -} -public class BlockhashStore: IBlockhashStore -{ - public BlockhashStore(IBlockFinder blockFinder, ISpecProvider specProvider, IWorldState worldState) - { - _blockFinder = blockFinder; - _specProvider = specProvider; - _worldState = worldState; - } - private readonly IBlockFinder _blockFinder; - private readonly ISpecProvider _specProvider; - private readonly IWorldState _worldState; public void InitHistoryOnForkBlock(BlockHeader currentBlock) { long current = currentBlock.Number; @@ -39,7 +25,7 @@ public void InitHistoryOnForkBlock(BlockHeader currentBlock) // an extra check - don't think it is needed if (header.IsGenesis) break; AddParentBlockHashToState(header); - header = _blockFinder.FindParentHeader(header, BlockTreeLookupOptions.TotalDifficultyNotNeeded); + header = blockFinder.FindParentHeader(header, BlockTreeLookupOptions.TotalDifficultyNotNeeded); if (header is null) { throw new InvalidDataException( @@ -49,22 +35,22 @@ public void InitHistoryOnForkBlock(BlockHeader currentBlock) } public void AddParentBlockHashToState(BlockHeader blockHeader) { - var spec = _specProvider.GetSpec(blockHeader); + var spec = specProvider.GetSpec(blockHeader); if (!spec.IsEip2935Enabled || blockHeader.IsGenesis || blockHeader.ParentHash is null) return; Address? eip2935Account = spec.Eip2935ContractAddress ?? Eip2935Constants.BlockHashHistoryAddress; - if (!_worldState.AccountExists(eip2935Account)) return; + if (!worldState.AccountExists(eip2935Account)) return; Hash256 parentBlockHash = blockHeader.ParentHash; var blockIndex = new UInt256((ulong)((blockHeader.Number - 1) % Eip2935Constants.RingBufferSize)); StorageCell blockHashStoreCell = new(eip2935Account, blockIndex); - _worldState.Set(blockHashStoreCell, parentBlockHash.Bytes.WithoutLeadingZeros().ToArray()); + worldState.Set(blockHashStoreCell, parentBlockHash.Bytes.WithoutLeadingZeros().ToArray()); } public Hash256? GetBlockHashFromState(BlockHeader currentHeader, long requiredBlockNumber) { - var spec = _specProvider.GetSpec(currentHeader); + var spec = specProvider.GetSpec(currentHeader); if (requiredBlockNumber >= currentHeader.Number || requiredBlockNumber + Eip2935Constants.RingBufferSize < currentHeader.Number) { @@ -73,7 +59,7 @@ public void AddParentBlockHashToState(BlockHeader blockHeader) var blockIndex = new UInt256((ulong)(requiredBlockNumber % Eip2935Constants.RingBufferSize)); Address? eip2935Account = spec.Eip2935ContractAddress ?? Eip2935Constants.BlockHashHistoryAddress; StorageCell blockHashStoreCell = new(eip2935Account, blockIndex); - ReadOnlySpan data = _worldState.Get(blockHashStoreCell); + ReadOnlySpan data = worldState.Get(blockHashStoreCell); return data.Length < 32 ? null : new Hash256(data); } } diff --git a/src/Nethermind/Nethermind.Blockchain/Blocks/IBlockhashStore.cs b/src/Nethermind/Nethermind.Blockchain/Blocks/IBlockhashStore.cs new file mode 100644 index 00000000000..356dec198dd --- /dev/null +++ b/src/Nethermind/Nethermind.Blockchain/Blocks/IBlockhashStore.cs @@ -0,0 +1,14 @@ +// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using Nethermind.Core; +using Nethermind.Core.Crypto; + +namespace Nethermind.Blockchain.Blocks; + +public interface IBlockhashStore +{ + public void InitHistoryOnForkBlock(BlockHeader currentBlock); + public void AddParentBlockHashToState(BlockHeader blockHeader); + public Hash256? GetBlockHashFromState(BlockHeader currentBlockHeader, long requiredBlockNumber); +} diff --git a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs index 154aea5103a..3bec70ce688 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs @@ -7,6 +7,7 @@ using System.Runtime.InteropServices; using System.Threading; using Nethermind.Blockchain; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Find; using Nethermind.Blockchain.Receipts; using Nethermind.Consensus.BeaconBlockRoot; diff --git a/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs b/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs index 8c5548d7c56..7d19b45fb7c 100644 --- a/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs +++ b/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs @@ -6,6 +6,7 @@ using System.Linq.Expressions; using System.Threading.Tasks; using Nethermind.Blockchain; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Find; using Nethermind.Core; using Nethermind.Core.Crypto; From 83134c44513de7400272b6509344e3a27ce552cb Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Thu, 25 Apr 2024 13:49:36 +0530 Subject: [PATCH 29/44] Refac --- src/Nethermind/Nethermind.Core/Eip2935Constants.cs | 5 ++++- .../Nethermind.Evm.Test/TestBlockhashProvider.cs | 8 ++++---- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/src/Nethermind/Nethermind.Core/Eip2935Constants.cs b/src/Nethermind/Nethermind.Core/Eip2935Constants.cs index 8df633f7954..9ca60fc3cbf 100644 --- a/src/Nethermind/Nethermind.Core/Eip2935Constants.cs +++ b/src/Nethermind/Nethermind.Core/Eip2935Constants.cs @@ -11,9 +11,12 @@ namespace Nethermind.Core; public static class Eip2935Constants { /// - /// Gets the HISTORY_STORAGE_ADDRESS parameter. + /// The HISTORY_STORAGE_ADDRESS parameter. /// public static readonly Address BlockHashHistoryAddress = new("0x25a219378dad9b3503c8268c9ca836a52427a4fb"); + /// + /// The HISTORY_SERVE_WINDOW parameter. + /// public static readonly long RingBufferSize = 8192; } diff --git a/src/Nethermind/Nethermind.Evm.Test/TestBlockhashProvider.cs b/src/Nethermind/Nethermind.Evm.Test/TestBlockhashProvider.cs index d3dc562cc21..8f90fee3cdc 100644 --- a/src/Nethermind/Nethermind.Evm.Test/TestBlockhashProvider.cs +++ b/src/Nethermind/Nethermind.Evm.Test/TestBlockhashProvider.cs @@ -18,10 +18,10 @@ public TestBlockhashProvider(ISpecProvider specProvider) public Hash256 GetBlockhash(BlockHeader currentBlock, in long number) { - var spec = _specProvider.GetSpec(currentBlock); - if (spec.IsBlockHashInStateAvailable) - return Keccak.Compute((Eip2935Constants.RingBufferSize + number).ToString()); - return Keccak.Compute((number).ToString()); + IReleaseSpec? spec = _specProvider.GetSpec(currentBlock); + return Keccak.Compute(spec.IsBlockHashInStateAvailable + ? (Eip2935Constants.RingBufferSize + number).ToString() + : (number).ToString()); } } } From 40ebcfc50c6afcded799804ea0be4eec9393e8a7 Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Thu, 25 Apr 2024 13:50:01 +0530 Subject: [PATCH 30/44] fix benchmarks and ethereum tests --- .../Ethereum.Test.Base/BlockchainTestBase.cs | 2 +- .../Ethereum.Test.Base/GeneralTestBase.cs | 2 +- .../Ethereum.Test.Base/TestBlockhashProvider.cs | 15 +++++++++++---- .../Nethermind.Evm.Benchmark/EvmBenchmarks.cs | 2 +- .../MultipleUnsignedOperations.cs | 2 +- .../StaticCallBenchmarks.cs | 2 +- .../TestBlockhashProvider.cs | 13 +++++++++++-- .../EthModuleBenchmarks.cs | 2 +- 8 files changed, 28 insertions(+), 12 deletions(-) diff --git a/src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs b/src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs index 98dd868d8ba..e5022707afe 100644 --- a/src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs +++ b/src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs @@ -142,7 +142,7 @@ protected async Task RunTest(BlockchainTest test, Stopwatch? IStateReader stateReader = new StateReader(trieStore, codeDb, _logManager); IReceiptStorage receiptStorage = NullReceiptStorage.Instance; - IBlockhashProvider blockhashProvider = new BlockhashProvider(blockTree, _logManager); + IBlockhashProvider blockhashProvider = new BlockhashProvider(blockTree, specProvider, stateProvider, _logManager); ITxValidator txValidator = new TxValidator(TestBlockchainIds.ChainId); IHeaderValidator headerValidator = new HeaderValidator(blockTree, Sealer, specProvider, _logManager); IUnclesValidator unclesValidator = new UnclesValidator(blockTree, headerValidator, _logManager); diff --git a/src/Nethermind/Ethereum.Test.Base/GeneralTestBase.cs b/src/Nethermind/Ethereum.Test.Base/GeneralTestBase.cs index 9a88c5273bd..b83d6e86790 100644 --- a/src/Nethermind/Ethereum.Test.Base/GeneralTestBase.cs +++ b/src/Nethermind/Ethereum.Test.Base/GeneralTestBase.cs @@ -66,7 +66,7 @@ protected EthereumTestResult RunTest(GeneralStateTest test, ITxTracer txTracer) TrieStore trieStore = new(stateDb, _logManager); WorldState stateProvider = new(trieStore, codeDb, _logManager); - IBlockhashProvider blockhashProvider = new TestBlockhashProvider(); + IBlockhashProvider blockhashProvider = new TestBlockhashProvider(specProvider); IVirtualMachine virtualMachine = new VirtualMachine( blockhashProvider, specProvider, diff --git a/src/Nethermind/Ethereum.Test.Base/TestBlockhashProvider.cs b/src/Nethermind/Ethereum.Test.Base/TestBlockhashProvider.cs index 9ad97dfcc80..55afe5cc0d1 100644 --- a/src/Nethermind/Ethereum.Test.Base/TestBlockhashProvider.cs +++ b/src/Nethermind/Ethereum.Test.Base/TestBlockhashProvider.cs @@ -11,11 +11,18 @@ namespace Ethereum.Test.Base { public class TestBlockhashProvider : IBlockhashProvider { - public Hash256 GetBlockhash(BlockHeader currentBlock, in long number, IReleaseSpec spec, IWorldState stateProvider) + private readonly ISpecProvider _specProvider; + public TestBlockhashProvider(ISpecProvider specProvider) { - if (number != 0) - return Keccak.Zero; - return Keccak.Compute(number.ToString()); + _specProvider = specProvider; + } + + public Hash256 GetBlockhash(BlockHeader currentBlock, in long number) + { + IReleaseSpec? spec = _specProvider.GetSpec(currentBlock); + return Keccak.Compute(spec.IsBlockHashInStateAvailable + ? (Eip2935Constants.RingBufferSize + number).ToString() + : (number).ToString()); } } } diff --git a/src/Nethermind/Nethermind.Evm.Benchmark/EvmBenchmarks.cs b/src/Nethermind/Nethermind.Evm.Benchmark/EvmBenchmarks.cs index 5e490186992..8d01214bfaa 100644 --- a/src/Nethermind/Nethermind.Evm.Benchmark/EvmBenchmarks.cs +++ b/src/Nethermind/Nethermind.Evm.Benchmark/EvmBenchmarks.cs @@ -28,7 +28,7 @@ public class EvmBenchmarks private ExecutionEnvironment _environment; private IVirtualMachine _virtualMachine; private BlockHeader _header = new BlockHeader(Keccak.Zero, Keccak.Zero, Address.Zero, UInt256.One, MainnetSpecProvider.IstanbulBlockNumber, Int64.MaxValue, 1UL, Bytes.Empty); - private IBlockhashProvider _blockhashProvider = new TestBlockhashProvider(); + private IBlockhashProvider _blockhashProvider = new TestBlockhashProvider(MainnetSpecProvider.Instance); private EvmState _evmState; private WorldState _stateProvider; diff --git a/src/Nethermind/Nethermind.Evm.Benchmark/MultipleUnsignedOperations.cs b/src/Nethermind/Nethermind.Evm.Benchmark/MultipleUnsignedOperations.cs index d3d8889bcc7..749ae715bd8 100644 --- a/src/Nethermind/Nethermind.Evm.Benchmark/MultipleUnsignedOperations.cs +++ b/src/Nethermind/Nethermind.Evm.Benchmark/MultipleUnsignedOperations.cs @@ -27,7 +27,7 @@ public class MultipleUnsignedOperations private ExecutionEnvironment _environment; private IVirtualMachine _virtualMachine; private readonly BlockHeader _header = new(Keccak.Zero, Keccak.Zero, Address.Zero, UInt256.One, MainnetSpecProvider.MuirGlacierBlockNumber, Int64.MaxValue, 1UL, Bytes.Empty); - private readonly IBlockhashProvider _blockhashProvider = new TestBlockhashProvider(); + private readonly IBlockhashProvider _blockhashProvider = new TestBlockhashProvider(MainnetSpecProvider.Instance); private EvmState _evmState; private WorldState _stateProvider; diff --git a/src/Nethermind/Nethermind.Evm.Benchmark/StaticCallBenchmarks.cs b/src/Nethermind/Nethermind.Evm.Benchmark/StaticCallBenchmarks.cs index 93e158881a7..ebedead21a1 100644 --- a/src/Nethermind/Nethermind.Evm.Benchmark/StaticCallBenchmarks.cs +++ b/src/Nethermind/Nethermind.Evm.Benchmark/StaticCallBenchmarks.cs @@ -28,7 +28,7 @@ public class StaticCallBenchmarks private ExecutionEnvironment _environment; private IVirtualMachine _virtualMachine; private BlockHeader _header = new BlockHeader(Keccak.Zero, Keccak.Zero, Address.Zero, UInt256.One, MainnetSpecProvider.MuirGlacierBlockNumber, Int64.MaxValue, 1UL, Bytes.Empty); - private IBlockhashProvider _blockhashProvider = new TestBlockhashProvider(); + private IBlockhashProvider _blockhashProvider = new TestBlockhashProvider(MainnetSpecProvider.Instance); private EvmState _evmState; private WorldState _stateProvider; diff --git a/src/Nethermind/Nethermind.Evm.Benchmark/TestBlockhashProvider.cs b/src/Nethermind/Nethermind.Evm.Benchmark/TestBlockhashProvider.cs index f6b8454dfe1..a42d0d0be9a 100644 --- a/src/Nethermind/Nethermind.Evm.Benchmark/TestBlockhashProvider.cs +++ b/src/Nethermind/Nethermind.Evm.Benchmark/TestBlockhashProvider.cs @@ -10,9 +10,18 @@ namespace Nethermind.Evm.Benchmark { public class TestBlockhashProvider : IBlockhashProvider { - public Hash256 GetBlockhash(BlockHeader currentBlock, in long number, IReleaseSpec spec, IWorldState stateProvider) + private readonly ISpecProvider _specProvider; + public TestBlockhashProvider(ISpecProvider specProvider) { - return Keccak.Compute(number.ToString()); + _specProvider = specProvider; + } + + public Hash256 GetBlockhash(BlockHeader currentBlock, in long number) + { + IReleaseSpec spec = _specProvider.GetSpec(currentBlock); + return Keccak.Compute(spec.IsBlockHashInStateAvailable + ? (Eip2935Constants.RingBufferSize + number).ToString() + : (number).ToString()); } } } diff --git a/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs b/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs index ea072ebdc34..e412b703967 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs @@ -79,7 +79,7 @@ public void GlobalSetup() NullBloomStorage.Instance, new SyncConfig(), LimboLogs.Instance); - _blockhashProvider = new BlockhashProvider(blockTree, LimboLogs.Instance); + _blockhashProvider = new BlockhashProvider(blockTree, specProvider, stateProvider, LimboLogs.Instance); _virtualMachine = new VirtualMachine(_blockhashProvider, specProvider, LimboLogs.Instance); Block genesisBlock = Build.A.Block.Genesis.TestObject; From f044dfeea4c52760ea0fdce7704ca594fd7278ef Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Thu, 25 Apr 2024 13:53:08 +0530 Subject: [PATCH 31/44] fix ethereum tests --- .../Ethereum.Test.Base/GeneralTestBase.cs | 2 +- .../Ethereum.Test.Base/TestBlockhashProvider.cs | 15 +++------------ 2 files changed, 4 insertions(+), 13 deletions(-) diff --git a/src/Nethermind/Ethereum.Test.Base/GeneralTestBase.cs b/src/Nethermind/Ethereum.Test.Base/GeneralTestBase.cs index b83d6e86790..9a88c5273bd 100644 --- a/src/Nethermind/Ethereum.Test.Base/GeneralTestBase.cs +++ b/src/Nethermind/Ethereum.Test.Base/GeneralTestBase.cs @@ -66,7 +66,7 @@ protected EthereumTestResult RunTest(GeneralStateTest test, ITxTracer txTracer) TrieStore trieStore = new(stateDb, _logManager); WorldState stateProvider = new(trieStore, codeDb, _logManager); - IBlockhashProvider blockhashProvider = new TestBlockhashProvider(specProvider); + IBlockhashProvider blockhashProvider = new TestBlockhashProvider(); IVirtualMachine virtualMachine = new VirtualMachine( blockhashProvider, specProvider, diff --git a/src/Nethermind/Ethereum.Test.Base/TestBlockhashProvider.cs b/src/Nethermind/Ethereum.Test.Base/TestBlockhashProvider.cs index 55afe5cc0d1..786ddde0b16 100644 --- a/src/Nethermind/Ethereum.Test.Base/TestBlockhashProvider.cs +++ b/src/Nethermind/Ethereum.Test.Base/TestBlockhashProvider.cs @@ -3,26 +3,17 @@ using Nethermind.Core; using Nethermind.Core.Crypto; -using Nethermind.Core.Specs; using Nethermind.Evm; -using Nethermind.State; namespace Ethereum.Test.Base { public class TestBlockhashProvider : IBlockhashProvider { - private readonly ISpecProvider _specProvider; - public TestBlockhashProvider(ISpecProvider specProvider) - { - _specProvider = specProvider; - } - public Hash256 GetBlockhash(BlockHeader currentBlock, in long number) { - IReleaseSpec? spec = _specProvider.GetSpec(currentBlock); - return Keccak.Compute(spec.IsBlockHashInStateAvailable - ? (Eip2935Constants.RingBufferSize + number).ToString() - : (number).ToString()); + if (number != 0) + return Keccak.Zero; + return Keccak.Compute(number.ToString()); } } } From 69f21946f2a8ae80c5a88432930ddf52cf7f1d0d Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Thu, 25 Apr 2024 13:57:42 +0530 Subject: [PATCH 32/44] cleanup --- .../BlockhashProviderTests.cs | 26 +++++++++---------- .../Nethermind.Evm/Nethermind.Evm.csproj | 3 --- 2 files changed, 13 insertions(+), 16 deletions(-) diff --git a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs index 6c8e5f1410c..ca18b7ed95f 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs @@ -36,7 +36,7 @@ public void Can_get_parent_only_headers() BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); BlockHeader? head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None); Block current = Build.A.Block.WithParent(head!).TestObject; Hash256? result = provider.GetBlockhash(current.Header, chainLength - 1); @@ -51,7 +51,7 @@ public void Can_lookup_up_to_256_before_with_headers_only() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; Hash256? result = provider.GetBlockhash(current.Header, chainLength - 256); @@ -66,7 +66,7 @@ public void Can_lookup_up_to_256_before_with_headers_only_and_competing_branches Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(out Block headBlock, chainLength).OfChainLength(out Block _, chainLength, 1).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); Block current = Build.A.Block.WithParent(headBlock).TestObject; long lookupNumber = chainLength - 256; Hash256? result = provider.GetBlockhash(current.Header, lookupNumber); @@ -81,7 +81,7 @@ public void Can_lookup_up_to_256_before_soon_after_fast_sync() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(out Block headBlock, chainLength).OfChainLength(out Block _, chainLength, 1).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); Block current = Build.A.Block.WithParent(headBlock).TestObject; tree.SuggestBlock(current); tree.UpdateMainChain(current); @@ -98,7 +98,7 @@ public void Can_lookup_up_to_256_before_some_blocks_after_fast_sync() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(out Block headBlock, chainLength).OfChainLength(out Block _, chainLength, 1).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); Block current = Build.A.Block.WithParent(headBlock).TestObject; for (int i = 0; i < 6; i++) @@ -128,7 +128,7 @@ public void Can_handle_non_main_chain_in_fast_sync() current = Build.A.Block.WithParent(current).TestObject; } - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); Hash256? result = provider.GetBlockhash(current.Header, 509); Assert.NotNull(result); @@ -143,7 +143,7 @@ public void Can_get_parent_hash() BlockTree tree = Build.A.BlockTree(genesis).OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; Hash256? result = provider.GetBlockhash(current.Header, chainLength - 1); @@ -158,7 +158,7 @@ public void Cannot_ask_for_self() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; Hash256? result = provider.GetBlockhash(current.Header, chainLength); @@ -173,7 +173,7 @@ public void Cannot_ask_about_future() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; Hash256? result = provider.GetBlockhash(current.Header, chainLength + 1); @@ -188,7 +188,7 @@ public void Can_lookup_up_to_256_before() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; Hash256? result = provider.GetBlockhash(current.Header, chainLength - 256); @@ -203,7 +203,7 @@ public void No_lookup_more_than_256_before() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; Hash256? result = provider.GetBlockhash(current.Header, chainLength - 257); @@ -218,7 +218,7 @@ public void UInt_256_overflow() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; Hash256? result = provider.GetBlockhash(current.Header, 127); @@ -233,7 +233,7 @@ public void Eip2935_init_block_history_and_then_get_hash() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Prague.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = new(tree, new TestSpecProvider(Prague.Instance), _worldState, LimboLogs.Instance); BlockhashStore store = new BlockhashStore(tree, new TestSpecProvider(Prague.Instance), _worldState); BlockHeader? head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None); diff --git a/src/Nethermind/Nethermind.Evm/Nethermind.Evm.csproj b/src/Nethermind/Nethermind.Evm/Nethermind.Evm.csproj index 3c46f405757..8f6c31d198f 100644 --- a/src/Nethermind/Nethermind.Evm/Nethermind.Evm.csproj +++ b/src/Nethermind/Nethermind.Evm/Nethermind.Evm.csproj @@ -27,7 +27,4 @@ true - - - From 60b0b11580b17660c6e400032e720b323a2ffd52 Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Thu, 25 Apr 2024 14:10:30 +0530 Subject: [PATCH 33/44] fix empty check --- .../Nethermind.Blockchain/Blocks/BlockhashStore.cs | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs b/src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs index 28222c41273..7111a742d98 100644 --- a/src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs +++ b/src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs @@ -16,6 +16,8 @@ namespace Nethermind.Blockchain.Blocks; public class BlockhashStore(IBlockFinder blockFinder, ISpecProvider specProvider, IWorldState worldState) : IBlockhashStore { + private static readonly byte[] _emptyBytes = [0]; + public void InitHistoryOnForkBlock(BlockHeader currentBlock) { long current = currentBlock.Number; @@ -35,7 +37,7 @@ public void InitHistoryOnForkBlock(BlockHeader currentBlock) } public void AddParentBlockHashToState(BlockHeader blockHeader) { - var spec = specProvider.GetSpec(blockHeader); + IReleaseSpec? spec = specProvider.GetSpec(blockHeader); if (!spec.IsEip2935Enabled || blockHeader.IsGenesis || blockHeader.ParentHash is null) return; Address? eip2935Account = spec.Eip2935ContractAddress ?? Eip2935Constants.BlockHashHistoryAddress; @@ -45,12 +47,12 @@ public void AddParentBlockHashToState(BlockHeader blockHeader) var blockIndex = new UInt256((ulong)((blockHeader.Number - 1) % Eip2935Constants.RingBufferSize)); StorageCell blockHashStoreCell = new(eip2935Account, blockIndex); - worldState.Set(blockHashStoreCell, parentBlockHash.Bytes.WithoutLeadingZeros().ToArray()); + worldState.Set(blockHashStoreCell, parentBlockHash.BytesToArray()); } public Hash256? GetBlockHashFromState(BlockHeader currentHeader, long requiredBlockNumber) { - var spec = specProvider.GetSpec(currentHeader); + IReleaseSpec? spec = specProvider.GetSpec(currentHeader); if (requiredBlockNumber >= currentHeader.Number || requiredBlockNumber + Eip2935Constants.RingBufferSize < currentHeader.Number) { @@ -60,6 +62,6 @@ public void AddParentBlockHashToState(BlockHeader blockHeader) Address? eip2935Account = spec.Eip2935ContractAddress ?? Eip2935Constants.BlockHashHistoryAddress; StorageCell blockHashStoreCell = new(eip2935Account, blockIndex); ReadOnlySpan data = worldState.Get(blockHashStoreCell); - return data.Length < 32 ? null : new Hash256(data); + return data.SequenceEqual(_emptyBytes) ? null : new Hash256(data); } } From 6ff6046eec0e14809704cf6dcd35dc9fd7a9234f Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Wed, 1 May 2024 16:27:17 +0530 Subject: [PATCH 34/44] use block finder instead --- src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs | 4 ++-- .../Nethermind.Consensus.AuRa/AuRaBlockProcessor.cs | 4 ++-- .../Nethermind.Consensus/Processing/BlockProcessor.cs | 4 ++-- src/Nethermind/Nethermind.Optimism/OptimismBlockProcessor.cs | 3 ++- 4 files changed, 8 insertions(+), 7 deletions(-) diff --git a/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs b/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs index 500af4b0c23..aa867e1da3b 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs +++ b/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs @@ -18,13 +18,13 @@ namespace Nethermind.Blockchain public class BlockhashProvider : IBlockhashProvider { private static readonly int _maxDepth = 256; - private readonly IBlockTree _blockTree; + private readonly IBlockFinder _blockTree; private readonly ISpecProvider _specProvider; private readonly IWorldState _worldState; private readonly IBlockhashStore _blockhashStore; private readonly ILogger _logger; - public BlockhashProvider(IBlockTree blockTree, ISpecProvider specProvider, IWorldState worldState, ILogManager? logManager) + public BlockhashProvider(IBlockFinder blockTree, ISpecProvider specProvider, IWorldState worldState, ILogManager? logManager) { _blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree)); _specProvider = specProvider; diff --git a/src/Nethermind/Nethermind.Consensus.AuRa/AuRaBlockProcessor.cs b/src/Nethermind/Nethermind.Consensus.AuRa/AuRaBlockProcessor.cs index dab1eeeb9b6..bddd4c53895 100644 --- a/src/Nethermind/Nethermind.Consensus.AuRa/AuRaBlockProcessor.cs +++ b/src/Nethermind/Nethermind.Consensus.AuRa/AuRaBlockProcessor.cs @@ -24,7 +24,7 @@ namespace Nethermind.Consensus.AuRa public class AuRaBlockProcessor : BlockProcessor { private readonly ISpecProvider _specProvider; - private readonly IBlockTree _blockTree; + private readonly IBlockFinder _blockTree; private readonly AuRaContractGasLimitOverride? _gasLimitOverride; private readonly ContractRewriter? _contractRewriter; private readonly ITxFilter _txFilter; @@ -38,7 +38,7 @@ public class AuRaBlockProcessor : BlockProcessor IWorldState stateProvider, IReceiptStorage receiptStorage, ILogManager logManager, - IBlockTree blockTree, + IBlockFinder blockTree, IWithdrawalProcessor withdrawalProcessor, IAuRaValidator? auRaValidator, ITxFilter? txFilter = null, diff --git a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs index 3bec70ce688..f0ae02175de 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs @@ -41,7 +41,7 @@ public partial class BlockProcessor : IBlockProcessor private readonly IBlockValidator _blockValidator; private readonly IRewardCalculator _rewardCalculator; private readonly IBlockProcessor.IBlockTransactionsExecutor _blockTransactionsExecutor; - private readonly IBlockTree _blockTree; + private readonly IBlockFinder _blockTree; private readonly IBlockhashStore _blockhashStore; private const int MaxUncommittedBlocks = 64; @@ -59,7 +59,7 @@ public partial class BlockProcessor : IBlockProcessor IWorldState? stateProvider, IReceiptStorage? receiptStorage, IWitnessCollector? witnessCollector, - IBlockTree? blockTree, + IBlockFinder? blockTree, ILogManager? logManager, IWithdrawalProcessor? withdrawalProcessor = null, IReceiptsRootCalculator? receiptsRootCalculator = null) diff --git a/src/Nethermind/Nethermind.Optimism/OptimismBlockProcessor.cs b/src/Nethermind/Nethermind.Optimism/OptimismBlockProcessor.cs index c5117b4a937..eebb1a4c7da 100644 --- a/src/Nethermind/Nethermind.Optimism/OptimismBlockProcessor.cs +++ b/src/Nethermind/Nethermind.Optimism/OptimismBlockProcessor.cs @@ -3,6 +3,7 @@ using System; using Nethermind.Blockchain; +using Nethermind.Blockchain.Find; using Nethermind.Blockchain.Receipts; using Nethermind.Consensus.Processing; using Nethermind.Consensus.Rewards; @@ -29,7 +30,7 @@ public class OptimismBlockProcessor : BlockProcessor IWorldState? stateProvider, IReceiptStorage? receiptStorage, IWitnessCollector? witnessCollector, - IBlockTree? blockTree, + IBlockFinder? blockTree, ILogManager? logManager, IOPConfigHelper opConfigHelper, Create2DeployerContractRewriter contractRewriter, From e51a39d0dcd3d5b9d86165e29a670194b0aff0d9 Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Wed, 1 May 2024 16:41:15 +0530 Subject: [PATCH 35/44] move everything to blockHashStore --- .../Blocks/BlockhashStore.cs | 53 ++++++++++++------- .../Blocks/IBlockhashStore.cs | 4 +- .../Processing/BlockProcessor.cs | 14 +---- 3 files changed, 38 insertions(+), 33 deletions(-) diff --git a/src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs b/src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs index 7111a742d98..8e962243943 100644 --- a/src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs +++ b/src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs @@ -3,6 +3,7 @@ using System; using System.IO; +using System.Runtime.CompilerServices; using Nethermind.Blockchain.Find; using Nethermind.Core; using Nethermind.Core.Crypto; @@ -11,14 +12,44 @@ using Nethermind.Int256; using Nethermind.State; +[assembly: InternalsVisibleTo("Nethermind.Blockchain.Test")] +[assembly: InternalsVisibleTo("Nethermind.Merge.Plugin.Test")] namespace Nethermind.Blockchain.Blocks; public class BlockhashStore(IBlockFinder blockFinder, ISpecProvider specProvider, IWorldState worldState) : IBlockhashStore { - private static readonly byte[] _emptyBytes = [0]; + private static readonly byte[] EmptyBytes = [0]; - public void InitHistoryOnForkBlock(BlockHeader currentBlock) + public void ApplyHistoryBlockHashes(BlockHeader blockHeader, IReleaseSpec spec) + { + if (!spec.IsEip2935Enabled) return; + + // TODO: find a better way to handle this - no need to have this check everytime + // this would just be true on the fork block + BlockHeader parentHeader = blockFinder.FindParentHeader(blockHeader, BlockTreeLookupOptions.None); + if (parentHeader is not null && parentHeader!.Timestamp < spec.Eip2935TransitionTimestamp) + InitHistoryOnForkBlock(blockHeader); + else + AddParentBlockHashToState(blockHeader); + } + + public Hash256? GetBlockHashFromState(BlockHeader currentHeader, long requiredBlockNumber) + { + IReleaseSpec? spec = specProvider.GetSpec(currentHeader); + if (requiredBlockNumber >= currentHeader.Number || + requiredBlockNumber + Eip2935Constants.RingBufferSize < currentHeader.Number) + { + return null; + } + var blockIndex = new UInt256((ulong)(requiredBlockNumber % Eip2935Constants.RingBufferSize)); + Address? eip2935Account = spec.Eip2935ContractAddress ?? Eip2935Constants.BlockHashHistoryAddress; + StorageCell blockHashStoreCell = new(eip2935Account, blockIndex); + ReadOnlySpan data = worldState.Get(blockHashStoreCell); + return data.SequenceEqual(EmptyBytes) ? null : new Hash256(data); + } + + internal void InitHistoryOnForkBlock(BlockHeader currentBlock) { long current = currentBlock.Number; BlockHeader header = currentBlock; @@ -35,7 +66,8 @@ public void InitHistoryOnForkBlock(BlockHeader currentBlock) } } } - public void AddParentBlockHashToState(BlockHeader blockHeader) + + internal void AddParentBlockHashToState(BlockHeader blockHeader) { IReleaseSpec? spec = specProvider.GetSpec(blockHeader); if (!spec.IsEip2935Enabled || blockHeader.IsGenesis || blockHeader.ParentHash is null) return; @@ -49,19 +81,4 @@ public void AddParentBlockHashToState(BlockHeader blockHeader) StorageCell blockHashStoreCell = new(eip2935Account, blockIndex); worldState.Set(blockHashStoreCell, parentBlockHash.BytesToArray()); } - - public Hash256? GetBlockHashFromState(BlockHeader currentHeader, long requiredBlockNumber) - { - IReleaseSpec? spec = specProvider.GetSpec(currentHeader); - if (requiredBlockNumber >= currentHeader.Number || - requiredBlockNumber + Eip2935Constants.RingBufferSize < currentHeader.Number) - { - return null; - } - var blockIndex = new UInt256((ulong)(requiredBlockNumber % Eip2935Constants.RingBufferSize)); - Address? eip2935Account = spec.Eip2935ContractAddress ?? Eip2935Constants.BlockHashHistoryAddress; - StorageCell blockHashStoreCell = new(eip2935Account, blockIndex); - ReadOnlySpan data = worldState.Get(blockHashStoreCell); - return data.SequenceEqual(_emptyBytes) ? null : new Hash256(data); - } } diff --git a/src/Nethermind/Nethermind.Blockchain/Blocks/IBlockhashStore.cs b/src/Nethermind/Nethermind.Blockchain/Blocks/IBlockhashStore.cs index 356dec198dd..88fd36a6c3f 100644 --- a/src/Nethermind/Nethermind.Blockchain/Blocks/IBlockhashStore.cs +++ b/src/Nethermind/Nethermind.Blockchain/Blocks/IBlockhashStore.cs @@ -3,12 +3,12 @@ using Nethermind.Core; using Nethermind.Core.Crypto; +using Nethermind.Core.Specs; namespace Nethermind.Blockchain.Blocks; public interface IBlockhashStore { - public void InitHistoryOnForkBlock(BlockHeader currentBlock); - public void AddParentBlockHashToState(BlockHeader blockHeader); + public void ApplyHistoryBlockHashes(BlockHeader blockHeader, IReleaseSpec spec); public Hash256? GetBlockHashFromState(BlockHeader currentBlockHeader, long requiredBlockNumber); } diff --git a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs index f0ae02175de..262829813a6 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs @@ -241,19 +241,7 @@ private void ValidateProcessedBlock(Block suggestedBlock, ProcessingOptions opti ReceiptsTracer.StartNewBlockTrace(block); _beaconBlockRootHandler.ApplyContractStateChanges(block, spec, _stateProvider); - - if (spec.IsEip2935Enabled) - { - // TODO: find a better way to handle this - no need to have this check everytime - // this would just be true on the fork block - BlockHeader parentHeader = _blockTree.FindParentHeader(block.Header, BlockTreeLookupOptions.None); - if (parentHeader is not null && parentHeader!.Timestamp < spec.Eip2935TransitionTimestamp) - _blockhashStore.InitHistoryOnForkBlock(block.Header); - else - _blockhashStore.AddParentBlockHashToState(block.Header); - - } - + _blockhashStore.ApplyHistoryBlockHashes(block.Header, spec); _stateProvider.Commit(spec); From efbe0a8c680b7158cde367f8b0b973be7eae2499 Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Wed, 1 May 2024 17:20:46 +0530 Subject: [PATCH 36/44] refactor the blockHashStore --- .../BlockhashProviderTests.cs | 69 ++++++++++++------- .../Blocks/BlockhashStore.cs | 27 ++++---- .../Blocks/IBlockhashStore.cs | 2 +- .../Processing/BlockProcessor.cs | 2 +- .../EngineModuleTests.HelperFunctions.cs | 2 +- 5 files changed, 60 insertions(+), 42 deletions(-) diff --git a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs index ca18b7ed95f..b9eaf6380a4 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs @@ -2,13 +2,16 @@ // SPDX-License-Identifier: LGPL-3.0-only using Nethermind.Blockchain.Blocks; +using Nethermind.Blockchain.Find; using Nethermind.Core; using Nethermind.Core.Crypto; +using Nethermind.Core.Specs; using Nethermind.Core.Test.Builders; using Nethermind.Db; using Nethermind.Logging; using Nethermind.Specs; using Nethermind.Specs.Forks; +using Nethermind.Specs.Test; using Nethermind.State; using Nethermind.Trie.Pruning; using NUnit.Framework; @@ -18,15 +21,22 @@ namespace Nethermind.Blockchain.Test [TestFixture] public class BlockhashProviderTests { - private IWorldState _worldState; - [SetUp] - public void Setup() + + private static IWorldState CreateWorldState() { var trieStore = new TrieStore(new MemDb(), LimboLogs.Instance); - _worldState = new WorldState(trieStore, new MemDb(), LimboLogs.Instance); - _worldState.CreateAccount(Eip2935Constants.BlockHashHistoryAddress, 0, 1); - _worldState.Commit(Frontier.Instance); + var worldState = new WorldState(trieStore, new MemDb(), LimboLogs.Instance); + worldState.CreateAccount(Eip2935Constants.BlockHashHistoryAddress, 0, 1); + worldState.Commit(Frontier.Instance); + return worldState; + } + private static BlockhashProvider CreateBlockHashProvider(IBlockFinder tree, IReleaseSpec spec) + { + IWorldState worldState = CreateWorldState(); + BlockhashProvider provider = new(tree, new TestSpecProvider(spec), worldState, LimboLogs.Instance); + return provider; } + [Test, Timeout(Timeout.MaxTestTime)] public void Can_get_parent_only_headers() { @@ -36,7 +46,7 @@ public void Can_get_parent_only_headers() BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = CreateBlockHashProvider(tree, Frontier.Instance); BlockHeader? head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None); Block current = Build.A.Block.WithParent(head!).TestObject; Hash256? result = provider.GetBlockhash(current.Header, chainLength - 1); @@ -51,7 +61,7 @@ public void Can_lookup_up_to_256_before_with_headers_only() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = CreateBlockHashProvider(tree, Frontier.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; Hash256? result = provider.GetBlockhash(current.Header, chainLength - 256); @@ -66,7 +76,7 @@ public void Can_lookup_up_to_256_before_with_headers_only_and_competing_branches Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(out Block headBlock, chainLength).OfChainLength(out Block _, chainLength, 1).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = CreateBlockHashProvider(tree, Frontier.Instance); Block current = Build.A.Block.WithParent(headBlock).TestObject; long lookupNumber = chainLength - 256; Hash256? result = provider.GetBlockhash(current.Header, lookupNumber); @@ -81,7 +91,7 @@ public void Can_lookup_up_to_256_before_soon_after_fast_sync() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(out Block headBlock, chainLength).OfChainLength(out Block _, chainLength, 1).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = CreateBlockHashProvider(tree, Frontier.Instance); Block current = Build.A.Block.WithParent(headBlock).TestObject; tree.SuggestBlock(current); tree.UpdateMainChain(current); @@ -98,7 +108,7 @@ public void Can_lookup_up_to_256_before_some_blocks_after_fast_sync() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(out Block headBlock, chainLength).OfChainLength(out Block _, chainLength, 1).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = CreateBlockHashProvider(tree, Frontier.Instance); Block current = Build.A.Block.WithParent(headBlock).TestObject; for (int i = 0; i < 6; i++) @@ -128,7 +138,7 @@ public void Can_handle_non_main_chain_in_fast_sync() current = Build.A.Block.WithParent(current).TestObject; } - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = CreateBlockHashProvider(tree, Frontier.Instance); Hash256? result = provider.GetBlockhash(current.Header, 509); Assert.NotNull(result); @@ -143,7 +153,7 @@ public void Can_get_parent_hash() BlockTree tree = Build.A.BlockTree(genesis).OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = CreateBlockHashProvider(tree, Frontier.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; Hash256? result = provider.GetBlockhash(current.Header, chainLength - 1); @@ -158,7 +168,7 @@ public void Cannot_ask_for_self() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = CreateBlockHashProvider(tree, Frontier.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; Hash256? result = provider.GetBlockhash(current.Header, chainLength); @@ -173,7 +183,7 @@ public void Cannot_ask_about_future() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = CreateBlockHashProvider(tree, Frontier.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; Hash256? result = provider.GetBlockhash(current.Header, chainLength + 1); @@ -188,7 +198,7 @@ public void Can_lookup_up_to_256_before() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = CreateBlockHashProvider(tree, Frontier.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; Hash256? result = provider.GetBlockhash(current.Header, chainLength - 256); @@ -203,7 +213,7 @@ public void No_lookup_more_than_256_before() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = CreateBlockHashProvider(tree, Frontier.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; Hash256? result = provider.GetBlockhash(current.Header, chainLength - 257); @@ -218,7 +228,7 @@ public void UInt_256_overflow() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Frontier.Instance), _worldState, LimboLogs.Instance); + BlockhashProvider provider = CreateBlockHashProvider(tree, Frontier.Instance); BlockHeader head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None)!; Block current = Build.A.Block.WithParent(head).TestObject; Hash256? result = provider.GetBlockhash(current.Header, 127); @@ -233,14 +243,22 @@ public void Eip2935_init_block_history_and_then_get_hash() Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(chainLength).TestObject; - BlockhashProvider provider = new(tree, new TestSpecProvider(Prague.Instance), _worldState, LimboLogs.Instance); - BlockhashStore store = new BlockhashStore(tree, new TestSpecProvider(Prague.Instance), _worldState); - BlockHeader? head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None); Block current = Build.A.Block.WithParent(head!).TestObject; - store.InitHistoryOnForkBlock(current.Header); - _worldState.Commit(Prague.Instance); + IWorldState worldState = CreateWorldState(); + var specToUse = new OverridableReleaseSpec(Prague.Instance) + { + Eip2935TransitionTimestamp = current.Timestamp + }; + var specProvider = new CustomSpecProvider( + (new ForkActivation(0, genesis.Timestamp), Frontier.Instance), + (new ForkActivation(0, current.Timestamp), specToUse)); + BlockhashProvider provider = new(tree, specProvider, worldState, LimboLogs.Instance); + BlockhashStore store = new (tree, specProvider, worldState); + + store.ApplyHistoryBlockHashes(current.Header); + worldState.Commit(specToUse); Hash256? result = provider.GetBlockhash(current.Header, chainLength - 1); Assert.That(result, Is.EqualTo(head?.Hash)); @@ -248,9 +266,12 @@ public void Eip2935_init_block_history_and_then_get_hash() tree.SuggestHeader(current.Header); head = current.Header; current = Build.A.Block.WithParent(head!).TestObject; - store.AddParentBlockHashToState(current.Header); + store.ApplyHistoryBlockHashes(current.Header); result = provider.GetBlockhash(current.Header, chainLength); Assert.That(result, Is.EqualTo(head?.Hash)); + + result = provider.GetBlockhash(current.Header, 0); + Assert.That(result, Is.EqualTo(genesis.Hash)); } } } diff --git a/src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs b/src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs index 8e962243943..6ec4094aa11 100644 --- a/src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs +++ b/src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs @@ -21,17 +21,21 @@ public class BlockhashStore(IBlockFinder blockFinder, ISpecProvider specProvider { private static readonly byte[] EmptyBytes = [0]; - public void ApplyHistoryBlockHashes(BlockHeader blockHeader, IReleaseSpec spec) + public void ApplyHistoryBlockHashes(BlockHeader blockHeader) { - if (!spec.IsEip2935Enabled) return; + IReleaseSpec spec = specProvider.GetSpec(blockHeader); + if (!spec.IsEip2935Enabled || blockHeader.IsGenesis || blockHeader.ParentHash is null) return; + + Address? eip2935Account = spec.Eip2935ContractAddress ?? Eip2935Constants.BlockHashHistoryAddress; + if (!worldState.AccountExists(eip2935Account)) return; // TODO: find a better way to handle this - no need to have this check everytime // this would just be true on the fork block BlockHeader parentHeader = blockFinder.FindParentHeader(blockHeader, BlockTreeLookupOptions.None); if (parentHeader is not null && parentHeader!.Timestamp < spec.Eip2935TransitionTimestamp) - InitHistoryOnForkBlock(blockHeader); + InitHistoryOnForkBlock(blockHeader, eip2935Account); else - AddParentBlockHashToState(blockHeader); + AddParentBlockHashToState(blockHeader, eip2935Account); } public Hash256? GetBlockHashFromState(BlockHeader currentHeader, long requiredBlockNumber) @@ -49,7 +53,7 @@ public void ApplyHistoryBlockHashes(BlockHeader blockHeader, IReleaseSpec spec) return data.SequenceEqual(EmptyBytes) ? null : new Hash256(data); } - internal void InitHistoryOnForkBlock(BlockHeader currentBlock) + private void InitHistoryOnForkBlock(BlockHeader currentBlock, Address eip2935Account) { long current = currentBlock.Number; BlockHeader header = currentBlock; @@ -57,7 +61,7 @@ internal void InitHistoryOnForkBlock(BlockHeader currentBlock) { // an extra check - don't think it is needed if (header.IsGenesis) break; - AddParentBlockHashToState(header); + AddParentBlockHashToState(header, eip2935Account); header = blockFinder.FindParentHeader(header, BlockTreeLookupOptions.TotalDifficultyNotNeeded); if (header is null) { @@ -67,18 +71,11 @@ internal void InitHistoryOnForkBlock(BlockHeader currentBlock) } } - internal void AddParentBlockHashToState(BlockHeader blockHeader) + private void AddParentBlockHashToState(BlockHeader blockHeader, Address eip2935Account) { - IReleaseSpec? spec = specProvider.GetSpec(blockHeader); - if (!spec.IsEip2935Enabled || blockHeader.IsGenesis || blockHeader.ParentHash is null) return; - Address? eip2935Account = spec.Eip2935ContractAddress ?? Eip2935Constants.BlockHashHistoryAddress; - - if (!worldState.AccountExists(eip2935Account)) return; - Hash256 parentBlockHash = blockHeader.ParentHash; var blockIndex = new UInt256((ulong)((blockHeader.Number - 1) % Eip2935Constants.RingBufferSize)); - StorageCell blockHashStoreCell = new(eip2935Account, blockIndex); - worldState.Set(blockHashStoreCell, parentBlockHash.BytesToArray()); + worldState.Set(blockHashStoreCell, parentBlockHash!.BytesToArray()); } } diff --git a/src/Nethermind/Nethermind.Blockchain/Blocks/IBlockhashStore.cs b/src/Nethermind/Nethermind.Blockchain/Blocks/IBlockhashStore.cs index 88fd36a6c3f..457a5115780 100644 --- a/src/Nethermind/Nethermind.Blockchain/Blocks/IBlockhashStore.cs +++ b/src/Nethermind/Nethermind.Blockchain/Blocks/IBlockhashStore.cs @@ -9,6 +9,6 @@ namespace Nethermind.Blockchain.Blocks; public interface IBlockhashStore { - public void ApplyHistoryBlockHashes(BlockHeader blockHeader, IReleaseSpec spec); + public void ApplyHistoryBlockHashes(BlockHeader blockHeader); public Hash256? GetBlockHashFromState(BlockHeader currentBlockHeader, long requiredBlockNumber); } diff --git a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs index 262829813a6..04bf0c73751 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs @@ -241,7 +241,7 @@ private void ValidateProcessedBlock(Block suggestedBlock, ProcessingOptions opti ReceiptsTracer.StartNewBlockTrace(block); _beaconBlockRootHandler.ApplyContractStateChanges(block, spec, _stateProvider); - _blockhashStore.ApplyHistoryBlockHashes(block.Header, spec); + _blockhashStore.ApplyHistoryBlockHashes(block.Header); _stateProvider.Commit(spec); diff --git a/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs b/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs index 7d19b45fb7c..3d57378ffc5 100644 --- a/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs +++ b/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.HelperFunctions.cs @@ -113,7 +113,7 @@ private ExecutionPayload CreateParentBlockRequestOnHead(IBlockTree blockTree) Snapshot before = chain.State.TakeSnapshot(); _beaconBlockRootHandler.ApplyContractStateChanges(block!, chain.SpecProvider.GenesisSpec, chain.State); var blockHashStore = new BlockhashStore(chain.BlockTree, chain.SpecProvider, chain.State); - blockHashStore.AddParentBlockHashToState(block!.Header); + blockHashStore.ApplyHistoryBlockHashes(block!.Header); chain.WithdrawalProcessor?.ProcessWithdrawals(block!, chain.SpecProvider.GenesisSpec); chain.State.Commit(chain.SpecProvider.GenesisSpec); From d0d1dbb7d5e6a7cee9ff3c421dcd7b25793425a7 Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Wed, 1 May 2024 17:26:38 +0530 Subject: [PATCH 37/44] Parallelize the tests --- .../Nethermind.Blockchain.Test/BlockhashProviderTests.cs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs index b9eaf6380a4..5f51c9fe5ae 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs @@ -18,10 +18,9 @@ namespace Nethermind.Blockchain.Test { - [TestFixture] + [TestFixture, Parallelizable(ParallelScope.All)] public class BlockhashProviderTests { - private static IWorldState CreateWorldState() { var trieStore = new TrieStore(new MemDb(), LimboLogs.Instance); From fc311450b4aa95e2b31aefd395f05c06a85b913b Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Wed, 1 May 2024 17:55:49 +0530 Subject: [PATCH 38/44] refactor the interface --- ...onRpcModuleTests.TestAccountAbstractionRpcBlockchain.cs | 3 ++- .../Nethermind.Blockchain.Test/BlockProcessorTests.cs | 7 ++++--- .../Producers/DevBlockproducerTests.cs | 3 ++- src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs | 3 ++- .../Nethermind.Clique.Test/CliqueBlockProducerTests.cs | 5 +++-- .../Nethermind.Consensus.AuRa/AuRaBlockProcessor.cs | 4 +++- src/Nethermind/Nethermind.Consensus.Clique/CliquePlugin.cs | 3 ++- .../Nethermind.Consensus.Ethash/NethDevPlugin.cs | 3 ++- .../Nethermind.Consensus/Processing/BlockProcessor.cs | 6 ++---- .../Processing/ReadOnlyChainProcessingEnv.cs | 3 ++- .../Producers/BlockProducerEnvFactory.cs | 3 ++- .../Nethermind.Core.Test/Blockchain/TestBlockchain.cs | 3 ++- .../Nethermind.Init/Steps/InitializeBlockchain.cs | 3 ++- .../Modules/Trace/ParityStyleTracerTests.cs | 3 ++- .../AuRaMergeEngineModuleTests.cs | 3 ++- .../EngineModuleTests.Setup.cs | 3 ++- .../MevRpcModuleTests.TestMevRpcBlockchain.cs | 3 ++- .../Nethermind.Optimism/InitializeBlockchainOptimism.cs | 3 ++- .../Nethermind.Optimism/OptimismBlockProcessor.cs | 6 ++++-- .../Nethermind.Optimism/OptimismBlockProducerEnvFactory.cs | 3 ++- .../Nethermind.Synchronization.Test/SyncThreadTests.cs | 5 +++-- 21 files changed, 49 insertions(+), 29 deletions(-) diff --git a/src/Nethermind/Nethermind.AccountAbstraction.Test/AccountAbstractionRpcModuleTests.TestAccountAbstractionRpcBlockchain.cs b/src/Nethermind/Nethermind.AccountAbstraction.Test/AccountAbstractionRpcModuleTests.TestAccountAbstractionRpcBlockchain.cs index f594f974315..5200ddeaa66 100644 --- a/src/Nethermind/Nethermind.AccountAbstraction.Test/AccountAbstractionRpcModuleTests.TestAccountAbstractionRpcBlockchain.cs +++ b/src/Nethermind/Nethermind.AccountAbstraction.Test/AccountAbstractionRpcModuleTests.TestAccountAbstractionRpcBlockchain.cs @@ -12,6 +12,7 @@ using Nethermind.AccountAbstraction.Executor; using Nethermind.AccountAbstraction.Source; using Nethermind.Blockchain; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Contracts.Json; using Nethermind.Consensus; using Nethermind.Consensus.Comparers; @@ -190,7 +191,7 @@ protected override BlockProcessor CreateBlockProcessor() State, ReceiptStorage, NullWitnessCollector.Instance, - BlockTree, + new BlockhashStore(BlockTree, SpecProvider, State), LogManager); AbiParameterConverter.RegisterFactory(new AbiTypeFactory(new AbiTuple())); diff --git a/src/Nethermind/Nethermind.Blockchain.Test/BlockProcessorTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/BlockProcessorTests.cs index 422b29d59d0..097883c8720 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/BlockProcessorTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/BlockProcessorTests.cs @@ -23,6 +23,7 @@ using System.Threading.Tasks; using System.Threading; using FluentAssertions; +using Nethermind.Blockchain.Blocks; using Nethermind.Consensus.Processing; using Nethermind.Consensus.Rewards; using Nethermind.Core.Test.Blockchain; @@ -49,7 +50,7 @@ public void Prepared_block_contains_author_field() stateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, - Substitute.For(), + Substitute.For(), LimboLogs.Instance); BlockHeader header = Build.A.BlockHeader.WithAuthor(TestItem.AddressD).TestObject; @@ -81,7 +82,7 @@ public void Can_store_a_witness() stateProvider, NullReceiptStorage.Instance, witnessCollector, - Substitute.For(), + Substitute.For(), LimboLogs.Instance); BlockHeader header = Build.A.BlockHeader.WithAuthor(TestItem.AddressD).TestObject; @@ -111,7 +112,7 @@ public void Recovers_state_on_cancel() stateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, - Substitute.For(), + Substitute.For(), LimboLogs.Instance); BlockHeader header = Build.A.BlockHeader.WithNumber(1).WithAuthor(TestItem.AddressD).TestObject; diff --git a/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs index 9f65fe8e99f..9360f8af091 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs @@ -3,6 +3,7 @@ using System.Threading; using FluentAssertions; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Receipts; using Nethermind.Config; using Nethermind.Consensus.Processing; @@ -73,7 +74,7 @@ public void Test() stateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, - blockTree, + new BlockhashStore(blockTree, specProvider, stateProvider), LimboLogs.Instance); BlockchainProcessor blockchainProcessor = new( blockTree, diff --git a/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs index d207b36595d..55354baf565 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using FluentAssertions; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Receipts; using Nethermind.Consensus.Comparers; using Nethermind.Consensus.Processing; @@ -75,7 +76,7 @@ public void Setup() stateProvider, NullReceiptStorage.Instance, new WitnessCollector(memDbProvider.StateDb, LimboLogs.Instance), - _blockTree, + new BlockhashStore(_blockTree, MainnetSpecProvider.Instance, stateProvider), LimboLogs.Instance); _blockchainProcessor = new BlockchainProcessor( _blockTree, diff --git a/src/Nethermind/Nethermind.Clique.Test/CliqueBlockProducerTests.cs b/src/Nethermind/Nethermind.Clique.Test/CliqueBlockProducerTests.cs index 2e5366b3552..ce0e1996581 100644 --- a/src/Nethermind/Nethermind.Clique.Test/CliqueBlockProducerTests.cs +++ b/src/Nethermind/Nethermind.Clique.Test/CliqueBlockProducerTests.cs @@ -8,6 +8,7 @@ using System.Threading; using System.Threading.Tasks; using Nethermind.Blockchain; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Receipts; using Nethermind.Consensus; using Nethermind.Consensus.Clique; @@ -137,7 +138,7 @@ public On CreateNode(PrivateKey privateKey, bool withGenesisAlreadyProcessed = f stateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, - blockTree, + new BlockhashStore(blockTree, goerliSpecProvider, stateProvider), nodeLogManager); BlockchainProcessor processor = new(blockTree, blockProcessor, new AuthorRecoveryStep(snapshotManager), stateReader, nodeLogManager, BlockchainProcessor.Options.NoReceipts); @@ -157,7 +158,7 @@ public On CreateNode(PrivateKey privateKey, bool withGenesisAlreadyProcessed = f minerStateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, - blockTree, + new BlockhashStore(blockTree, goerliSpecProvider, minerStateProvider), nodeLogManager); BlockchainProcessor minerProcessor = new(blockTree, minerBlockProcessor, new AuthorRecoveryStep(snapshotManager), stateReader, nodeLogManager, BlockchainProcessor.Options.NoReceipts); diff --git a/src/Nethermind/Nethermind.Consensus.AuRa/AuRaBlockProcessor.cs b/src/Nethermind/Nethermind.Consensus.AuRa/AuRaBlockProcessor.cs index bddd4c53895..53a6836ff8f 100644 --- a/src/Nethermind/Nethermind.Consensus.AuRa/AuRaBlockProcessor.cs +++ b/src/Nethermind/Nethermind.Consensus.AuRa/AuRaBlockProcessor.cs @@ -3,6 +3,7 @@ using System; using Nethermind.Blockchain; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Find; using Nethermind.Blockchain.Receipts; using Nethermind.Consensus.AuRa.Validators; @@ -14,6 +15,7 @@ using Nethermind.Core; using Nethermind.Core.Specs; using Nethermind.Crypto; +using Nethermind.Evm; using Nethermind.Evm.Tracing; using Nethermind.Logging; using Nethermind.State; @@ -52,7 +54,7 @@ public class AuRaBlockProcessor : BlockProcessor stateProvider, receiptStorage, NullWitnessCollector.Instance, - blockTree, + new BlockhashStore(blockTree, specProvider, stateProvider), logManager, withdrawalProcessor) { diff --git a/src/Nethermind/Nethermind.Consensus.Clique/CliquePlugin.cs b/src/Nethermind/Nethermind.Consensus.Clique/CliquePlugin.cs index 851a35c3e14..9d0690a118b 100644 --- a/src/Nethermind/Nethermind.Consensus.Clique/CliquePlugin.cs +++ b/src/Nethermind/Nethermind.Consensus.Clique/CliquePlugin.cs @@ -6,6 +6,7 @@ using Nethermind.Api; using Nethermind.Api.Extensions; using Nethermind.Blockchain; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Receipts; using Nethermind.Config; using Nethermind.Consensus.Comparers; @@ -107,7 +108,7 @@ public Task InitBlockProducer(IBlockProductionTrigger? blockProd producerEnv.StateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, - getFromApi.BlockTree, + new BlockhashStore(getFromApi.BlockTree, getFromApi.SpecProvider, producerEnv.StateProvider), getFromApi.LogManager, new BlockProductionWithdrawalProcessor(new WithdrawalProcessor(producerEnv.StateProvider, getFromApi.LogManager))); diff --git a/src/Nethermind/Nethermind.Consensus.Ethash/NethDevPlugin.cs b/src/Nethermind/Nethermind.Consensus.Ethash/NethDevPlugin.cs index 70c3b8fdffb..98875c1f159 100644 --- a/src/Nethermind/Nethermind.Consensus.Ethash/NethDevPlugin.cs +++ b/src/Nethermind/Nethermind.Consensus.Ethash/NethDevPlugin.cs @@ -6,6 +6,7 @@ using Nethermind.Api; using Nethermind.Api.Extensions; using Nethermind.Blockchain; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Receipts; using Nethermind.Config; using Nethermind.Consensus.Processing; @@ -77,7 +78,7 @@ public Task InitBlockProducer(IBlockProductionTrigger? blockProd producerEnv.StateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, - getFromApi.BlockTree, + new BlockhashStore(getFromApi.BlockTree, getFromApi.SpecProvider, producerEnv.StateProvider), getFromApi.LogManager); IBlockchainProcessor producerChainProcessor = new BlockchainProcessor( diff --git a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs index 04bf0c73751..953d570cfe6 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/BlockProcessor.cs @@ -41,7 +41,6 @@ public partial class BlockProcessor : IBlockProcessor private readonly IBlockValidator _blockValidator; private readonly IRewardCalculator _rewardCalculator; private readonly IBlockProcessor.IBlockTransactionsExecutor _blockTransactionsExecutor; - private readonly IBlockFinder _blockTree; private readonly IBlockhashStore _blockhashStore; private const int MaxUncommittedBlocks = 64; @@ -59,7 +58,7 @@ public partial class BlockProcessor : IBlockProcessor IWorldState? stateProvider, IReceiptStorage? receiptStorage, IWitnessCollector? witnessCollector, - IBlockFinder? blockTree, + IBlockhashStore? blockHashStore, ILogManager? logManager, IWithdrawalProcessor? withdrawalProcessor = null, IReceiptsRootCalculator? receiptsRootCalculator = null) @@ -74,9 +73,8 @@ public partial class BlockProcessor : IBlockProcessor _rewardCalculator = rewardCalculator ?? throw new ArgumentNullException(nameof(rewardCalculator)); _blockTransactionsExecutor = blockTransactionsExecutor ?? throw new ArgumentNullException(nameof(blockTransactionsExecutor)); _receiptsRootCalculator = receiptsRootCalculator ?? ReceiptsRootCalculator.Instance; - _blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree)); + _blockhashStore = blockHashStore ?? throw new ArgumentNullException(nameof(blockHashStore)); _beaconBlockRootHandler = new BeaconBlockRootHandler(); - _blockhashStore = new BlockhashStore(_blockTree, _specProvider, _stateProvider); ReceiptsTracer = new BlockReceiptsTracer(); } diff --git a/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyChainProcessingEnv.cs b/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyChainProcessingEnv.cs index d2bdeb765e8..f448f7ee1e9 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyChainProcessingEnv.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyChainProcessingEnv.cs @@ -2,6 +2,7 @@ // SPDX-License-Identifier: LGPL-3.0-only using System; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Receipts; using Nethermind.Consensus.Rewards; using Nethermind.Consensus.Validators; @@ -48,7 +49,7 @@ public class ReadOnlyChainProcessingEnv : IDisposable StateProvider, receiptStorage, NullWitnessCollector.Instance, - _txEnv.BlockTree, + new BlockhashStore(txEnv.BlockTree, specProvider, StateProvider), logManager); _blockProcessingQueue = new BlockchainProcessor(_txEnv.BlockTree, BlockProcessor, recoveryStep, _txEnv.StateReader, logManager, BlockchainProcessor.Options.NoReceipts); diff --git a/src/Nethermind/Nethermind.Consensus/Producers/BlockProducerEnvFactory.cs b/src/Nethermind/Nethermind.Consensus/Producers/BlockProducerEnvFactory.cs index ea2fd4f4ae5..8bc9472b3e1 100644 --- a/src/Nethermind/Nethermind.Consensus/Producers/BlockProducerEnvFactory.cs +++ b/src/Nethermind/Nethermind.Consensus/Producers/BlockProducerEnvFactory.cs @@ -2,6 +2,7 @@ // SPDX-License-Identifier: LGPL-3.0-only using Nethermind.Blockchain; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Receipts; using Nethermind.Config; using Nethermind.Consensus.Comparers; @@ -142,7 +143,7 @@ public virtual BlockProducerEnv Create(ITxSource? additionalTxSource = null) readOnlyTxProcessingEnv.StateProvider, receiptStorage, NullWitnessCollector.Instance, - _blockTree, + new BlockhashStore(_blockTree, _specProvider, readOnlyTxProcessingEnv.StateProvider), logManager, new BlockProductionWithdrawalProcessor(new WithdrawalProcessor(readOnlyTxProcessingEnv.StateProvider, logManager))); diff --git a/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs b/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs index 24e47467107..f252f9bbfca 100644 --- a/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs +++ b/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs @@ -6,6 +6,7 @@ using System.Threading; using System.Threading.Tasks; using Nethermind.Blockchain; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Find; using Nethermind.Blockchain.Receipts; using Nethermind.Config; @@ -356,7 +357,7 @@ protected virtual async Task AddBlocksOnStart() State, ReceiptStorage, NullWitnessCollector.Instance, - BlockTree, + new BlockhashStore(BlockTree, SpecProvider, State), LogManager); public async Task WaitForNewHead() diff --git a/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs b/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs index 4b79fd2c09e..3816b0a5840 100644 --- a/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs +++ b/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs @@ -9,6 +9,7 @@ using System.Threading.Tasks; using Nethermind.Api; using Nethermind.Blockchain; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Filters; using Nethermind.Blockchain.FullPruning; using Nethermind.Blockchain.Receipts; @@ -230,7 +231,7 @@ protected virtual BlockProcessor CreateBlockProcessor() worldState, _api.ReceiptStorage, _api.WitnessCollector, - _api.BlockTree, + new BlockhashStore(_api.BlockTree, _api.SpecProvider!, worldState), _api.LogManager); } diff --git a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Trace/ParityStyleTracerTests.cs b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Trace/ParityStyleTracerTests.cs index 7fa0e6d8a19..2c6722f3e19 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Trace/ParityStyleTracerTests.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Trace/ParityStyleTracerTests.cs @@ -4,6 +4,7 @@ using System.Linq; using FluentAssertions; using Nethermind.Blockchain; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Find; using Nethermind.Blockchain.Receipts; using Nethermind.Blockchain.Synchronization; @@ -74,7 +75,7 @@ public void Setup() stateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, - _blockTree, + new BlockhashStore(_blockTree, specProvider, stateProvider), LimboLogs.Instance); RecoverSignatures txRecovery = new(new EthereumEcdsa(TestBlockchainIds.ChainId, LimboLogs.Instance), NullTxPool.Instance, specProvider, LimboLogs.Instance); diff --git a/src/Nethermind/Nethermind.Merge.AuRa.Test/AuRaMergeEngineModuleTests.cs b/src/Nethermind/Nethermind.Merge.AuRa.Test/AuRaMergeEngineModuleTests.cs index 1f932373024..ae7a2c03109 100644 --- a/src/Nethermind/Nethermind.Merge.AuRa.Test/AuRaMergeEngineModuleTests.cs +++ b/src/Nethermind/Nethermind.Merge.AuRa.Test/AuRaMergeEngineModuleTests.cs @@ -3,6 +3,7 @@ using System; using System.Threading.Tasks; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Synchronization; using Nethermind.Config; using Nethermind.Consensus; @@ -131,7 +132,7 @@ protected override IBlockProcessor CreateBlockProcessor() State, ReceiptStorage, NullWitnessCollector.Instance, - BlockTree, + new BlockhashStore(BlockTree, SpecProvider, State), LogManager, WithdrawalProcessor); diff --git a/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.Setup.cs b/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.Setup.cs index 61989e766a7..a758393594e 100644 --- a/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.Setup.cs +++ b/src/Nethermind/Nethermind.Merge.Plugin.Test/EngineModuleTests.Setup.cs @@ -7,6 +7,7 @@ using System.Threading.Tasks; using Nethermind.Api; using Nethermind.Blockchain; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Synchronization; using Nethermind.Config; using Nethermind.Consensus; @@ -235,7 +236,7 @@ protected override IBlockProcessor CreateBlockProcessor() State, ReceiptStorage, NullWitnessCollector.Instance, - BlockTree, + new BlockhashStore(BlockTree, SpecProvider, State), LogManager, WithdrawalProcessor); diff --git a/src/Nethermind/Nethermind.Mev.Test/MevRpcModuleTests.TestMevRpcBlockchain.cs b/src/Nethermind/Nethermind.Mev.Test/MevRpcModuleTests.TestMevRpcBlockchain.cs index bfaa34fba1d..e370ca4ba36 100644 --- a/src/Nethermind/Nethermind.Mev.Test/MevRpcModuleTests.TestMevRpcBlockchain.cs +++ b/src/Nethermind/Nethermind.Mev.Test/MevRpcModuleTests.TestMevRpcBlockchain.cs @@ -7,6 +7,7 @@ using System.Threading.Tasks; using FluentAssertions; using Nethermind.Blockchain; +using Nethermind.Blockchain.Blocks; using Nethermind.Config; using Nethermind.Consensus; using Nethermind.Consensus.Comparers; @@ -201,7 +202,7 @@ protected override BlockProcessor CreateBlockProcessor() State, ReceiptStorage, NullWitnessCollector.Instance, - BlockTree, + new BlockhashStore(BlockTree, SpecProvider, State), LogManager); _tracerFactory = new TracerFactory( diff --git a/src/Nethermind/Nethermind.Optimism/InitializeBlockchainOptimism.cs b/src/Nethermind/Nethermind.Optimism/InitializeBlockchainOptimism.cs index f756ab72986..fa99bec8bf7 100644 --- a/src/Nethermind/Nethermind.Optimism/InitializeBlockchainOptimism.cs +++ b/src/Nethermind/Nethermind.Optimism/InitializeBlockchainOptimism.cs @@ -3,6 +3,7 @@ using System.Threading.Tasks; using Nethermind.Api; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Services; using Nethermind.Config; using Nethermind.Consensus.Processing; @@ -102,7 +103,7 @@ protected override BlockProcessor CreateBlockProcessor() _api.WorldState, _api.ReceiptStorage, _api.WitnessCollector, - _api.BlockTree, + new BlockhashStore(_api.BlockTree, _api.SpecProvider, _api.WorldState), _api.LogManager, _api.SpecHelper, contractRewriter); diff --git a/src/Nethermind/Nethermind.Optimism/OptimismBlockProcessor.cs b/src/Nethermind/Nethermind.Optimism/OptimismBlockProcessor.cs index eebb1a4c7da..289ab3d3ab6 100644 --- a/src/Nethermind/Nethermind.Optimism/OptimismBlockProcessor.cs +++ b/src/Nethermind/Nethermind.Optimism/OptimismBlockProcessor.cs @@ -3,6 +3,7 @@ using System; using Nethermind.Blockchain; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Find; using Nethermind.Blockchain.Receipts; using Nethermind.Consensus.Processing; @@ -12,6 +13,7 @@ using Nethermind.Core; using Nethermind.Core.Crypto; using Nethermind.Core.Specs; +using Nethermind.Evm; using Nethermind.Evm.Tracing; using Nethermind.Logging; using Nethermind.State; @@ -30,13 +32,13 @@ public class OptimismBlockProcessor : BlockProcessor IWorldState? stateProvider, IReceiptStorage? receiptStorage, IWitnessCollector? witnessCollector, - IBlockFinder? blockTree, + IBlockhashStore? blockhashStore, ILogManager? logManager, IOPConfigHelper opConfigHelper, Create2DeployerContractRewriter contractRewriter, IWithdrawalProcessor? withdrawalProcessor = null) : base(specProvider, blockValidator, rewardCalculator, blockTransactionsExecutor, - stateProvider, receiptStorage, witnessCollector, blockTree, logManager, withdrawalProcessor, OptimismReceiptsRootCalculator.Instance) + stateProvider, receiptStorage, witnessCollector, blockhashStore, logManager, withdrawalProcessor, OptimismReceiptsRootCalculator.Instance) { ArgumentNullException.ThrowIfNull(stateProvider); _contractRewriter = contractRewriter; diff --git a/src/Nethermind/Nethermind.Optimism/OptimismBlockProducerEnvFactory.cs b/src/Nethermind/Nethermind.Optimism/OptimismBlockProducerEnvFactory.cs index cbccf1f919b..b0d8d0620a1 100644 --- a/src/Nethermind/Nethermind.Optimism/OptimismBlockProducerEnvFactory.cs +++ b/src/Nethermind/Nethermind.Optimism/OptimismBlockProducerEnvFactory.cs @@ -2,6 +2,7 @@ // SPDX-License-Identifier: LGPL-3.0-only using Nethermind.Blockchain; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Receipts; using Nethermind.Config; using Nethermind.Consensus.Comparers; @@ -88,7 +89,7 @@ public class OptimismBlockProducerEnvFactory : BlockProducerEnvFactory readOnlyTxProcessingEnv.StateProvider, receiptStorage, NullWitnessCollector.Instance, - _blockTree, + new BlockhashStore(_blockTree, specProvider, readOnlyTxProcessingEnv.StateProvider), logManager, _specHelper, new Create2DeployerContractRewriter(_specHelper, _specProvider, _blockTree), diff --git a/src/Nethermind/Nethermind.Synchronization.Test/SyncThreadTests.cs b/src/Nethermind/Nethermind.Synchronization.Test/SyncThreadTests.cs index 5976010b040..b2ae132370c 100644 --- a/src/Nethermind/Nethermind.Synchronization.Test/SyncThreadTests.cs +++ b/src/Nethermind/Nethermind.Synchronization.Test/SyncThreadTests.cs @@ -6,6 +6,7 @@ using System.Threading; using System.Threading.Tasks; using Nethermind.Blockchain; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Receipts; using Nethermind.Blockchain.Synchronization; using Nethermind.Consensus; @@ -299,7 +300,7 @@ private SyncTestContext CreateSyncManager(int index) stateProvider, receiptStorage, NullWitnessCollector.Instance, - tree, + new BlockhashStore(tree, specProvider, stateProvider), logManager); RecoverSignatures step = new(ecdsa, txPool, specProvider, logManager); @@ -322,7 +323,7 @@ private SyncTestContext CreateSyncManager(int index) devState, receiptStorage, NullWitnessCollector.Instance, - tree, + new BlockhashStore(tree, specProvider, devState), logManager); BlockchainProcessor devChainProcessor = new(tree, devBlockProcessor, step, stateReader, logManager, From 715dbdc6a162de6187ea7530e785378410124df7 Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Wed, 1 May 2024 17:58:59 +0530 Subject: [PATCH 39/44] whitespace --- .../Nethermind.Blockchain.Test/BlockhashProviderTests.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs index 5f51c9fe5ae..dacc0e1e25c 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs @@ -254,7 +254,7 @@ public void Eip2935_init_block_history_and_then_get_hash() (new ForkActivation(0, genesis.Timestamp), Frontier.Instance), (new ForkActivation(0, current.Timestamp), specToUse)); BlockhashProvider provider = new(tree, specProvider, worldState, LimboLogs.Instance); - BlockhashStore store = new (tree, specProvider, worldState); + BlockhashStore store = new(tree, specProvider, worldState); store.ApplyHistoryBlockHashes(current.Header); worldState.Commit(specToUse); From 6122e25cb9c2829431fd135e57f3e2252b3b4f17 Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Wed, 1 May 2024 18:04:23 +0530 Subject: [PATCH 40/44] fix other tests --- src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs | 3 ++- .../Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs b/src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs index e5022707afe..863eeeb3c44 100644 --- a/src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs +++ b/src/Nethermind/Ethereum.Test.Base/BlockchainTestBase.cs @@ -9,6 +9,7 @@ using System.Threading; using System.Threading.Tasks; using Nethermind.Blockchain; +using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Find; using Nethermind.Blockchain.Receipts; using Nethermind.Consensus; @@ -166,7 +167,7 @@ protected async Task RunTest(BlockchainTest test, Stopwatch? stateProvider, receiptStorage, NullWitnessCollector.Instance, - blockTree, + new BlockhashStore(blockTree, specProvider, stateProvider), _logManager); IBlockchainProcessor blockchainProcessor = new BlockchainProcessor( diff --git a/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs b/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs index e412b703967..2c53024e98e 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs @@ -93,7 +93,7 @@ TransactionProcessor transactionProcessor IBlockProcessor.IBlockTransactionsExecutor transactionsExecutor = new BlockProcessor.BlockValidationTransactionsExecutor(transactionProcessor, stateProvider); BlockProcessor blockProcessor = new(specProvider, Always.Valid, new RewardCalculator(specProvider), transactionsExecutor, - stateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, blockTree, LimboLogs.Instance); + stateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, new BlockhashStore(blockTree, specProvider,stateProvider), LimboLogs.Instance); EthereumEcdsa ecdsa = new(specProvider.ChainId, LimboLogs.Instance); BlockchainProcessor blockchainProcessor = new( From 831cc60bb6e0dd7f7a844db58797716278caa521 Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Wed, 1 May 2024 18:14:35 +0530 Subject: [PATCH 41/44] whitespace --- .../Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs b/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs index 2c53024e98e..07b96b59c2a 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs @@ -93,7 +93,7 @@ TransactionProcessor transactionProcessor IBlockProcessor.IBlockTransactionsExecutor transactionsExecutor = new BlockProcessor.BlockValidationTransactionsExecutor(transactionProcessor, stateProvider); BlockProcessor blockProcessor = new(specProvider, Always.Valid, new RewardCalculator(specProvider), transactionsExecutor, - stateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, new BlockhashStore(blockTree, specProvider,stateProvider), LimboLogs.Instance); + stateProvider, NullReceiptStorage.Instance, NullWitnessCollector.Instance, new BlockhashStore(blockTree, specProvider, stateProvider), LimboLogs.Instance); EthereumEcdsa ecdsa = new(specProvider.ChainId, LimboLogs.Instance); BlockchainProcessor blockchainProcessor = new( From 911b07f1e0770996efa21546a3e4fe5f323a860b Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Fri, 3 May 2024 10:24:07 +0530 Subject: [PATCH 42/44] update test --- .../BlockhashProviderTests.cs | 29 ++++++++++++++----- 1 file changed, 22 insertions(+), 7 deletions(-) diff --git a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs index dacc0e1e25c..763d0f43d30 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/BlockhashProviderTests.cs @@ -234,16 +234,20 @@ public void UInt_256_overflow() Assert.That(result, Is.EqualTo(head.Hash)); } - [Test, Timeout(Timeout.MaxTestTime)] - public void Eip2935_init_block_history_and_then_get_hash() + [Timeout(Timeout.MaxTestTime)] + [TestCase(1)] + [TestCase(512)] + [TestCase(8192)] + [TestCase(8193)] + public void Eip2935_init_block_history_and_then_get_hash(int chainLength) { - const int chainLength = 512; - Block genesis = Build.A.Block.Genesis.TestObject; BlockTree tree = Build.A.BlockTree(genesis).OfHeadersOnly.OfChainLength(chainLength).TestObject; BlockHeader? head = tree.FindHeader(chainLength - 1, BlockTreeLookupOptions.None); + // number = chainLength Block current = Build.A.Block.WithParent(head!).TestObject; + tree.SuggestHeader(current.Header); IWorldState worldState = CreateWorldState(); var specToUse = new OverridableReleaseSpec(Prague.Instance) @@ -261,16 +265,27 @@ public void Eip2935_init_block_history_and_then_get_hash() Hash256? result = provider.GetBlockhash(current.Header, chainLength - 1); Assert.That(result, Is.EqualTo(head?.Hash)); + AssertGenesisHash(provider, current.Header, genesis.Hash!); - tree.SuggestHeader(current.Header); head = current.Header; + // number = chainLength + 1 current = Build.A.Block.WithParent(head!).TestObject; + tree.SuggestHeader(current.Header); + store.ApplyHistoryBlockHashes(current.Header); result = provider.GetBlockhash(current.Header, chainLength); Assert.That(result, Is.EqualTo(head?.Hash)); - result = provider.GetBlockhash(current.Header, 0); - Assert.That(result, Is.EqualTo(genesis.Hash)); + AssertGenesisHash(provider, current.Header, genesis.Hash!); + } + + private static void AssertGenesisHash(BlockhashProvider provider, BlockHeader currentHeader, Hash256 genesisHash) + { + Hash256? result = provider.GetBlockhash(currentHeader, 0); + if (currentHeader.Number > Eip2935Constants.RingBufferSize) + Assert.That(result, Is.Null); + else + Assert.That(result, Is.EqualTo(genesisHash)); } } } From 7ccf3f2f3b144011d0f3fed086ecd681214a030d Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Fri, 3 May 2024 10:27:05 +0530 Subject: [PATCH 43/44] remove redundant check --- src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs b/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs index aa867e1da3b..663d44bc62d 100644 --- a/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs +++ b/src/Nethermind/Nethermind.Blockchain/BlockhashProvider.cs @@ -20,7 +20,6 @@ public class BlockhashProvider : IBlockhashProvider private static readonly int _maxDepth = 256; private readonly IBlockFinder _blockTree; private readonly ISpecProvider _specProvider; - private readonly IWorldState _worldState; private readonly IBlockhashStore _blockhashStore; private readonly ILogger _logger; @@ -28,8 +27,7 @@ public BlockhashProvider(IBlockFinder blockTree, ISpecProvider specProvider, IWo { _blockTree = blockTree ?? throw new ArgumentNullException(nameof(blockTree)); _specProvider = specProvider; - _worldState = worldState; - _blockhashStore = new Blocks.BlockhashStore(blockTree, specProvider, worldState); + _blockhashStore = new BlockhashStore(blockTree, specProvider, worldState); _logger = logManager?.GetClassLogger() ?? throw new ArgumentNullException(nameof(logManager)); } From d7ceca4e4fbaab98815a1cdc4599012b984afe8d Mon Sep 17 00:00:00 2001 From: Tanishq Jasoria Date: Fri, 3 May 2024 10:27:20 +0530 Subject: [PATCH 44/44] update --- src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs b/src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs index 6ec4094aa11..c3697f828d1 100644 --- a/src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs +++ b/src/Nethermind/Nethermind.Blockchain/Blocks/BlockhashStore.cs @@ -59,8 +59,6 @@ private void InitHistoryOnForkBlock(BlockHeader currentBlock, Address eip2935Acc BlockHeader header = currentBlock; for (var i = 0; i < Math.Min(Eip2935Constants.RingBufferSize, current); i++) { - // an extra check - don't think it is needed - if (header.IsGenesis) break; AddParentBlockHashToState(header, eip2935Account); header = blockFinder.FindParentHeader(header, BlockTreeLookupOptions.TotalDifficultyNotNeeded); if (header is null)