diff --git a/src/Nethermind/Nethermind.Api/IBasicApi.cs b/src/Nethermind/Nethermind.Api/IBasicApi.cs index f548c5ca577..ed31d7880f0 100644 --- a/src/Nethermind/Nethermind.Api/IBasicApi.cs +++ b/src/Nethermind/Nethermind.Api/IBasicApi.cs @@ -53,6 +53,7 @@ public interface IBasicApi [SkipServiceCollection] ILifetimeScope Context { get; } + IPrecompileChecker PrecompileChecker { get; } public IConsensusPlugin? GetConsensusPlugin() => Plugins diff --git a/src/Nethermind/Nethermind.Api/NethermindApi.cs b/src/Nethermind/Nethermind.Api/NethermindApi.cs index 353ebe5947f..f9701dd6d68 100644 --- a/src/Nethermind/Nethermind.Api/NethermindApi.cs +++ b/src/Nethermind/Nethermind.Api/NethermindApi.cs @@ -84,7 +84,8 @@ public virtual IBlockchainBridge CreateBlockchainBridge() WorldStateManager!.CreateOverridableWorldScope(), readOnlyTree, SpecProvider!, - LogManager); + LogManager, + PrecompileChecker); SimulateReadOnlyBlocksProcessingEnvFactory simulateReadOnlyBlocksProcessingEnvFactory = new SimulateReadOnlyBlocksProcessingEnvFactory( @@ -93,6 +94,7 @@ public virtual IBlockchainBridge CreateBlockchainBridge() DbProvider!, SpecProvider!, SimulateTransactionProcessorFactory, + PrecompileChecker, LogManager); IMiningConfig miningConfig = ConfigProvider.GetConfig(); @@ -205,7 +207,7 @@ public virtual IBlockchainBridge CreateBlockchainBridge() public ISubscriptionFactory? SubscriptionFactory { get; set; } public IProtectedPrivateKey? NodeKey { get; set; } - + public IPrecompileChecker PrecompileChecker => Context.Resolve(); /// /// Key used for signing blocks. Original as its loaded on startup. This can later be changed via RPC in . /// diff --git a/src/Nethermind/Nethermind.AuRa.Test/Contract/AuRaContractGasLimitOverrideTests.cs b/src/Nethermind/Nethermind.AuRa.Test/Contract/AuRaContractGasLimitOverrideTests.cs index a3a3f1ca51d..cf0d4ddf8e1 100644 --- a/src/Nethermind/Nethermind.AuRa.Test/Contract/AuRaContractGasLimitOverrideTests.cs +++ b/src/Nethermind/Nethermind.AuRa.Test/Contract/AuRaContractGasLimitOverrideTests.cs @@ -19,7 +19,6 @@ using Nethermind.Consensus.Withdrawals; using Nethermind.Core; using Nethermind.Logging; -using Nethermind.Specs.ChainSpecStyle; using Nethermind.State; using NUnit.Framework; @@ -92,7 +91,7 @@ protected override BlockProcessor CreateBlockProcessor(IWorldState worldState) blockGasLimitContractTransition.Key, new ReadOnlyTxProcessingEnv( WorldStateManager, - BlockTree.AsReadOnly(), SpecProvider, LimboLogs.Instance)); + BlockTree.AsReadOnly(), SpecProvider, LimboLogs.Instance, PrecompileChecker)); GasLimitOverrideCache = new AuRaContractGasLimitOverride.Cache(); GasLimitCalculator = new AuRaContractGasLimitOverride(new[] { gasLimitContract }, GasLimitOverrideCache, false, new FollowOtherMiners(SpecProvider), LimboLogs.Instance); diff --git a/src/Nethermind/Nethermind.AuRa.Test/Contract/TxPriorityContractTests.cs b/src/Nethermind/Nethermind.AuRa.Test/Contract/TxPriorityContractTests.cs index 4a066de37f0..290d9433913 100644 --- a/src/Nethermind/Nethermind.AuRa.Test/Contract/TxPriorityContractTests.cs +++ b/src/Nethermind/Nethermind.AuRa.Test/Contract/TxPriorityContractTests.cs @@ -16,9 +16,7 @@ using Nethermind.Consensus.AuRa.Contracts; using Nethermind.Consensus.AuRa.Contracts.DataStore; using Nethermind.Consensus.Processing; -using Nethermind.Consensus.Producers; using Nethermind.Core; -using Nethermind.Core.Specs; using Nethermind.Core.Test.Blockchain; using Nethermind.Core.Test.Builders; using Nethermind.Core.Test.IO; @@ -253,7 +251,7 @@ public class TxPermissionContractBlockchain : TestContractBlockchain protected override IBlockProcessor CreateBlockProcessor(IWorldState state) { TxPriorityContract = new TxPriorityContract(AbiEncoder.Instance, TestItem.AddressA, - new ReadOnlyTxProcessingEnv(WorldStateManager, BlockTree.AsReadOnly(), SpecProvider, LimboLogs.Instance)); + new ReadOnlyTxProcessingEnv(WorldStateManager, BlockTree.AsReadOnly(), SpecProvider, LimboLogs.Instance, PrecompileChecker)); Priorities = new DictionaryContractDataStore( new TxPriorityContract.DestinationSortedListContractDataStoreCollection(), diff --git a/src/Nethermind/Nethermind.AuRa.Test/Transactions/TxCertifierFilterTests.cs b/src/Nethermind/Nethermind.AuRa.Test/Transactions/TxCertifierFilterTests.cs index d439d98f1b8..7da2fbbc256 100644 --- a/src/Nethermind/Nethermind.AuRa.Test/Transactions/TxCertifierFilterTests.cs +++ b/src/Nethermind/Nethermind.AuRa.Test/Transactions/TxCertifierFilterTests.cs @@ -143,7 +143,7 @@ protected override BlockProcessor CreateBlockProcessor(IWorldState worldState) ReadOnlyTransactionProcessorSource = new ReadOnlyTxProcessingEnv( WorldStateManager, BlockTree.AsReadOnly(), SpecProvider, - LimboLogs.Instance); + LimboLogs.Instance, PrecompileChecker); RegisterContract = new RegisterContract(abiEncoder, ChainSpec.Parameters.Registrar, ReadOnlyTransactionProcessorSource); CertifierContract = new CertifierContract( abiEncoder, diff --git a/src/Nethermind/Nethermind.AuRa.Test/Transactions/TxPermissionFilterTest.cs b/src/Nethermind/Nethermind.AuRa.Test/Transactions/TxPermissionFilterTest.cs index 82c7555c8b8..8acfdcd927e 100644 --- a/src/Nethermind/Nethermind.AuRa.Test/Transactions/TxPermissionFilterTest.cs +++ b/src/Nethermind/Nethermind.AuRa.Test/Transactions/TxPermissionFilterTest.cs @@ -29,7 +29,6 @@ using Nethermind.Evm.TransactionProcessing; using Nethermind.Logging; using Nethermind.State; -using Nethermind.Trie.Pruning; using Nethermind.TxPool; using NSubstitute; using NUnit.Framework; @@ -272,7 +271,7 @@ protected override BlockProcessor CreateBlockProcessor(IWorldState worldState) new LruCache(PermissionBasedTxFilter.Cache.MaxCacheSize, nameof(TransactionPermissionContract)); VersionedTransactionPermissionContract transactionPermissionContract = new(AbiEncoder.Instance, _contractAddress, 1, - new ReadOnlyTxProcessingEnv(WorldStateManager, BlockTree.AsReadOnly(), SpecProvider, LimboLogs.Instance), TransactionPermissionContractVersions, LimboLogs.Instance, SpecProvider); + new ReadOnlyTxProcessingEnv(WorldStateManager, BlockTree.AsReadOnly(), SpecProvider, LimboLogs.Instance, PrecompileChecker), TransactionPermissionContractVersions, LimboLogs.Instance, SpecProvider); TxPermissionFilterCache = new PermissionBasedTxFilter.Cache(); PermissionBasedTxFilter = new PermissionBasedTxFilter(transactionPermissionContract, TxPermissionFilterCache, LimboLogs.Instance); diff --git a/src/Nethermind/Nethermind.Blockchain.Test/BlockchainProcessorTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/BlockchainProcessorTests.cs index 84bd747ccce..1fa50e173cf 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/BlockchainProcessorTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/BlockchainProcessorTests.cs @@ -19,6 +19,7 @@ using Nethermind.Core.Test.Blockchain; using Nethermind.Core.Test.Builders; using Nethermind.Evm; +using Nethermind.Evm.Precompiles; using Nethermind.Evm.Tracing; using Nethermind.Logging; using Nethermind.State; @@ -522,7 +523,7 @@ public async Task Can_process_fast_sync() new FixedForkActivationChainHeadSpecProvider(specProvider, fixedBlock: 10_000_000), blockTree, readOnlyState, - new CodeInfoRepository()) + new CodeInfoRepository(TestPrecompiles.Ethereum)) { HasSynced = true }; diff --git a/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs index ffa60c5b471..f1210614194 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/Producers/DevBlockproducerTests.cs @@ -21,6 +21,7 @@ using Nethermind.Core.Test.Builders; using Nethermind.Db; using Nethermind.Evm; +using Nethermind.Evm.Precompiles; using Nethermind.Evm.TransactionProcessing; using Nethermind.Logging; using Nethermind.Specs; @@ -52,11 +53,13 @@ public void Test() IWorldState stateProvider = worldStateManager.GlobalWorldState; IStateReader stateReader = worldStateManager.GlobalStateReader; BlockhashProvider blockhashProvider = new(blockTree, specProvider, stateProvider, LimboLogs.Instance); - CodeInfoRepository codeInfoRepository = new(); + IPrecompileChecker precompileChecker = TestPrecompiles.Ethereum; + CodeInfoRepository codeInfoRepository = new(precompileChecker); VirtualMachine virtualMachine = new( blockhashProvider, specProvider, - LimboLogs.Instance); + LimboLogs.Instance, + precompileChecker); TransactionProcessor txProcessor = new( specProvider, stateProvider, diff --git a/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs b/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs index 5e9bb54e8da..e4468f4e208 100644 --- a/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs +++ b/src/Nethermind/Nethermind.Blockchain.Test/ReorgTests.cs @@ -20,11 +20,11 @@ using Nethermind.Crypto; using Nethermind.Db; using Nethermind.Evm; +using Nethermind.Evm.Precompiles; using Nethermind.Evm.TransactionProcessing; using Nethermind.Logging; using Nethermind.Specs; using Nethermind.State; -using Nethermind.Trie.Pruning; using Nethermind.TxPool; using NUnit.Framework; @@ -44,7 +44,7 @@ public void Setup() IDbProvider memDbProvider = TestMemDbProvider.Init(); IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(memDbProvider, LimboLogs.Instance); IWorldState stateProvider = worldStateManager.GlobalWorldState; - + IPrecompileChecker precompileChecker = TestPrecompiles.Ethereum; IReleaseSpec finalSpec = specProvider.GetFinalSpec(); if (finalSpec.WithdrawalsEnabled) @@ -72,7 +72,7 @@ public void Setup() .WithSpecProvider(specProvider) .TestObject; - CodeInfoRepository codeInfoRepository = new(); + CodeInfoRepository codeInfoRepository = new(precompileChecker); TxPool.TxPool txPool = new( ecdsa, new BlobTxStorage(), @@ -85,7 +85,8 @@ public void Setup() VirtualMachine virtualMachine = new( blockhashProvider, specProvider, - LimboLogs.Instance); + LimboLogs.Instance, + precompileChecker); TransactionProcessor transactionProcessor = new( specProvider, stateProvider, diff --git a/src/Nethermind/Nethermind.Clique.Test/CliqueBlockProducerTests.cs b/src/Nethermind/Nethermind.Clique.Test/CliqueBlockProducerTests.cs index 22057b7028d..237c6f9c9f0 100644 --- a/src/Nethermind/Nethermind.Clique.Test/CliqueBlockProducerTests.cs +++ b/src/Nethermind/Nethermind.Clique.Test/CliqueBlockProducerTests.cs @@ -28,7 +28,6 @@ using Nethermind.Logging; using Nethermind.Specs; using Nethermind.State; -using Nethermind.Trie.Pruning; using Nethermind.TxPool; using NUnit.Framework; using System; @@ -39,6 +38,7 @@ using System.Threading.Tasks; using Nethermind.Consensus.ExecutionRequests; using Nethermind.Consensus.Withdrawals; +using Nethermind.Evm.Precompiles; namespace Nethermind.Clique.Test; @@ -88,7 +88,7 @@ public On CreateNode(PrivateKey privateKey, bool withGenesisAlreadyProcessed = f MemDb blocksDb = new(); ISpecProvider specProvider = SepoliaSpecProvider.Instance; - + IPrecompileChecker precompileChecker = TestPrecompiles.Ethereum; IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); IStateReader stateReader = worldStateManager.GlobalStateReader; IWorldState stateProvider = worldStateManager.GlobalWorldState; @@ -122,7 +122,7 @@ public On CreateNode(PrivateKey privateKey, bool withGenesisAlreadyProcessed = f ITransactionComparerProvider transactionComparerProvider = new TransactionComparerProvider(specProvider, blockTree); - CodeInfoRepository codeInfoRepository = new(); + CodeInfoRepository codeInfoRepository = new(precompileChecker); TxPool.TxPool txPool = new(_ethereumEcdsa, new BlobTxStorage(), new ChainHeadInfoProvider(new FixedForkActivationChainHeadSpecProvider(SepoliaSpecProvider.Instance), blockTree, stateProvider, codeInfoRepository), @@ -144,7 +144,7 @@ public On CreateNode(PrivateKey privateKey, bool withGenesisAlreadyProcessed = f _genesis3Validators.Header.Hash = _genesis3Validators.Header.CalculateHash(); TransactionProcessor transactionProcessor = new(testnetSpecProvider, stateProvider, - new VirtualMachine(blockhashProvider, specProvider, nodeLogManager), + new VirtualMachine(blockhashProvider, specProvider, nodeLogManager, precompileChecker), codeInfoRepository, nodeLogManager); BlockProcessor blockProcessor = new BlockProcessor( @@ -180,7 +180,7 @@ public On CreateNode(PrivateKey privateKey, bool withGenesisAlreadyProcessed = f minerStateProvider.Commit(testnetSpecProvider.GenesisSpec); minerStateProvider.CommitTree(0); - VirtualMachine minerVirtualMachine = new(blockhashProvider, specProvider, nodeLogManager); + VirtualMachine minerVirtualMachine = new(blockhashProvider, specProvider, nodeLogManager, precompileChecker); TransactionProcessor minerTransactionProcessor = new(testnetSpecProvider, minerStateProvider, minerVirtualMachine, codeInfoRepository, nodeLogManager); BlockProcessor minerBlockProcessor = new BlockProcessor( diff --git a/src/Nethermind/Nethermind.Consensus.AuRa/InitializationSteps/RegisterAuRaRpcModules.cs b/src/Nethermind/Nethermind.Consensus.AuRa/InitializationSteps/RegisterAuRaRpcModules.cs index 81ab5baf115..a73244e95d3 100644 --- a/src/Nethermind/Nethermind.Consensus.AuRa/InitializationSteps/RegisterAuRaRpcModules.cs +++ b/src/Nethermind/Nethermind.Consensus.AuRa/InitializationSteps/RegisterAuRaRpcModules.cs @@ -4,7 +4,6 @@ using System.Collections.Generic; using System.IO.Abstractions; using System.Linq; -using Autofac; using Nethermind.Api; using Nethermind.Blockchain; using Nethermind.Blockchain.BeaconBlockRoot; @@ -80,7 +79,8 @@ protected override void RegisterTraceRpcModule(IRpcModuleProvider rpcModuleProvi _api.SpecProvider, _poSSwitcher, _api.LogManager, - _factory); + _factory, + _api.PrecompileChecker); rpcModuleProvider.RegisterBoundedByCpuCount(traceModuleFactory, JsonRpcConfig.Timeout); } @@ -97,9 +97,10 @@ protected class AuRaTraceModuleFactory( ISpecProvider specProvider, IPoSSwitcher poSSwitcher, ILogManager logManager, - IAuRaBlockProcessorFactory factory) + IAuRaBlockProcessorFactory factory, + IPrecompileChecker precompileChecker) : TraceModuleFactory(worldStateManager, blockTree, jsonRpcConfig, blockchainBridge, secondsPerSlot, recoveryStep, rewardCalculatorSource, - receiptFinder, specProvider, poSSwitcher, logManager) + receiptFinder, specProvider, poSSwitcher, logManager, precompileChecker) { protected override ReadOnlyChainProcessingEnv CreateChainProcessingEnv(IOverridableWorldScope worldStateManager, IBlockProcessor.IBlockTransactionsExecutor transactionsExecutor, IReadOnlyTxProcessingScope scope, @@ -226,7 +227,8 @@ protected override void RegisterDebugRpcModule(IRpcModuleProvider rpcModuleProvi _api.BadBlocksStore, _api.FileSystem, _api.LogManager, - _factory); + _factory, + _api.PrecompileChecker); rpcModuleProvider.RegisterBoundedByCpuCount(debugModuleFactory, JsonRpcConfig.Timeout); } @@ -249,10 +251,11 @@ protected class AuRaDebugModuleFactory( IBadBlockStore badBlockStore, IFileSystem fileSystem, ILogManager logManager, - IAuRaBlockProcessorFactory factory) + IAuRaBlockProcessorFactory factory, + IPrecompileChecker precompileChecker) : DebugModuleFactory(worldStateManager, dbProvider, blockTree, jsonRpcConfig, blockchainBridge, secondsPerSlot, blockValidator, recoveryStep, rewardCalculator, receiptStorage, receiptsMigration, configProvider, specProvider, syncModeSelector, - badBlockStore, fileSystem, logManager) + badBlockStore, fileSystem, logManager, precompileChecker) { protected override ReadOnlyChainProcessingEnv CreateReadOnlyChainProcessingEnv(IReadOnlyTxProcessingScope scope, IOverridableWorldScope worldStateManager, IBlockProcessor.IBlockTransactionsExecutor transactionsExecutor) diff --git a/src/Nethermind/Nethermind.Consensus.Test/CensorshipDetectorTests.cs b/src/Nethermind/Nethermind.Consensus.Test/CensorshipDetectorTests.cs index 7dc2306ee22..84437e3b451 100644 --- a/src/Nethermind/Nethermind.Consensus.Test/CensorshipDetectorTests.cs +++ b/src/Nethermind/Nethermind.Consensus.Test/CensorshipDetectorTests.cs @@ -19,6 +19,7 @@ using Nethermind.Crypto; using Nethermind.Db; using Nethermind.Evm; +using Nethermind.Evm.Precompiles; using Nethermind.Logging; using Nethermind.Specs; using Nethermind.State; @@ -258,7 +259,7 @@ private TxPool.TxPool CreatePool(bool eip1559Enabled = true) return new( _ethereumEcdsa, new BlobTxStorage(), - new ChainHeadInfoProvider(_specProvider, _blockTree, _stateProvider, new CodeInfoRepository()), + new ChainHeadInfoProvider(_specProvider, _blockTree, _stateProvider, new CodeInfoRepository(TestPrecompiles.Ethereum)), new TxPoolConfig(), new TxValidator(_specProvider.ChainId), _logManager, diff --git a/src/Nethermind/Nethermind.Consensus/Processing/OverridableTxProcessingEnv.cs b/src/Nethermind/Nethermind.Consensus/Processing/OverridableTxProcessingEnv.cs index e7c437a12ea..398607fe76d 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/OverridableTxProcessingEnv.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/OverridableTxProcessingEnv.cs @@ -26,12 +26,14 @@ public class OverridableTxProcessingEnv : IOverridableTxProcessorSource protected OverridableCodeInfoRepository CodeInfoRepository { get; } protected IVirtualMachine Machine { get; } protected ITransactionProcessor TransactionProcessor => _transactionProcessorLazy.Value; + protected IPrecompileChecker PrecompileChecker { get; } public OverridableTxProcessingEnv( IOverridableWorldScope overridableScope, IReadOnlyBlockTree readOnlyBlockTree, ISpecProvider specProvider, - ILogManager? logManager + ILogManager? logManager, + IPrecompileChecker precompileChecker ) { SpecProvider = specProvider; @@ -40,9 +42,10 @@ public OverridableTxProcessingEnv( IBlockhashProvider blockhashProvider = new BlockhashProvider(BlockTree, specProvider, StateProvider, logManager); LogManager = logManager; StateProvider = overridableScope.WorldState; + PrecompileChecker = precompileChecker; - CodeInfoRepository = new(new CodeInfoRepository()); - Machine = new VirtualMachine(blockhashProvider, specProvider, logManager); + CodeInfoRepository = new(new CodeInfoRepository(precompileChecker)); + Machine = new VirtualMachine(blockhashProvider, specProvider, logManager, precompileChecker); _transactionProcessorLazy = new(CreateTransactionProcessor); } diff --git a/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyTxProcessingEnv.cs b/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyTxProcessingEnv.cs index 0374563891e..80e3be453f7 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyTxProcessingEnv.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyTxProcessingEnv.cs @@ -3,6 +3,7 @@ using System; using Nethermind.Blockchain; +using Nethermind.Core; using Nethermind.Core.Crypto; using Nethermind.Core.Specs; using Nethermind.Evm; @@ -42,8 +43,9 @@ public ReadOnlyTxProcessingEnv( IReadOnlyBlockTree readOnlyBlockTree, ISpecProvider specProvider, ILogManager logManager, - IWorldState worldStateToWarmUp - ) : this(worldStateManager.GlobalStateReader, worldStateManager.CreateWorldStateForWarmingUp(worldStateToWarmUp), new CodeInfoRepository((worldStateToWarmUp as IPreBlockCaches)?.Caches.PrecompileCache), readOnlyBlockTree, specProvider, logManager) + IWorldState worldStateToWarmUp, + IPrecompileChecker precompileChecker + ) : this(worldStateManager.GlobalStateReader, worldStateManager.CreateWorldStateForWarmingUp(worldStateToWarmUp), new CodeInfoRepository(precompileChecker, (worldStateToWarmUp as IPreBlockCaches)?.Caches.PrecompileCache), readOnlyBlockTree, specProvider, logManager, precompileChecker) { } @@ -51,8 +53,9 @@ public ReadOnlyTxProcessingEnv( IWorldStateManager worldStateManager, IReadOnlyBlockTree readOnlyBlockTree, ISpecProvider specProvider, - ILogManager logManager - ) : this(worldStateManager.GlobalStateReader, worldStateManager.CreateResettableWorldState(), new CodeInfoRepository(), readOnlyBlockTree, specProvider, logManager) + ILogManager logManager, + IPrecompileChecker precompileChecker + ) : this(worldStateManager.GlobalStateReader, worldStateManager.CreateResettableWorldState(), new CodeInfoRepository(precompileChecker), readOnlyBlockTree, specProvider, logManager, precompileChecker) { } @@ -62,7 +65,8 @@ private ReadOnlyTxProcessingEnv( ICodeInfoRepository codeInfoRepository, IReadOnlyBlockTree readOnlyBlockTree, ISpecProvider specProvider, - ILogManager logManager + ILogManager logManager, + IPrecompileChecker precompileChecker ) { SpecProvider = specProvider; @@ -72,7 +76,7 @@ ILogManager logManager BlockhashProvider = new BlockhashProvider(BlockTree, specProvider, StateProvider, logManager); CodeInfoRepository = codeInfoRepository; - Machine = new VirtualMachine(BlockhashProvider, specProvider, logManager); + Machine = new VirtualMachine(BlockhashProvider, specProvider, logManager, precompileChecker); BlockTree = readOnlyBlockTree ?? throw new ArgumentNullException(nameof(readOnlyBlockTree)); BlockhashProvider = new BlockhashProvider(BlockTree, specProvider, StateProvider, logManager); diff --git a/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyTxProcessingEnvFactory.cs b/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyTxProcessingEnvFactory.cs index e4b8a71fc14..16cc5e4b8d8 100644 --- a/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyTxProcessingEnvFactory.cs +++ b/src/Nethermind/Nethermind.Consensus/Processing/ReadOnlyTxProcessingEnvFactory.cs @@ -2,6 +2,7 @@ // SPDX-License-Identifier: LGPL-3.0-only using Nethermind.Blockchain; +using Nethermind.Core; using Nethermind.Core.Specs; using Nethermind.Evm.TransactionProcessing; using Nethermind.Logging; @@ -13,14 +14,16 @@ public class ReadOnlyTxProcessingEnvFactory( IWorldStateManager worldStateManager, IReadOnlyBlockTree readOnlyBlockTree, ISpecProvider specProvider, - ILogManager logManager) : IReadOnlyTxProcessingEnvFactory + ILogManager logManager, + IPrecompileChecker precompileChecker) : IReadOnlyTxProcessingEnvFactory { public ReadOnlyTxProcessingEnvFactory( IWorldStateManager worldStateManager, IBlockTree blockTree, ISpecProvider specProvider, - ILogManager logManager) - : this(worldStateManager, blockTree.AsReadOnly(), specProvider, logManager) + ILogManager logManager, + IPrecompileChecker precompileChecker) + : this(worldStateManager, blockTree.AsReadOnly(), specProvider, logManager, precompileChecker) { } @@ -30,7 +33,8 @@ public IReadOnlyTxProcessorSource Create() worldStateManager, readOnlyBlockTree, specProvider, - logManager); + logManager, + precompileChecker); } public IReadOnlyTxProcessorSource CreateForWarmingUp(IWorldState worldStateToWarmUp) @@ -40,6 +44,7 @@ public IReadOnlyTxProcessorSource CreateForWarmingUp(IWorldState worldStateToWar readOnlyBlockTree, specProvider, logManager, - worldStateToWarmUp); + worldStateToWarmUp, + precompileChecker); } } diff --git a/src/Nethermind/Nethermind.Core.Test/AddressTests.cs b/src/Nethermind/Nethermind.Core.Test/AddressTests.cs index bd6cba869b2..10190e919c4 100644 --- a/src/Nethermind/Nethermind.Core.Test/AddressTests.cs +++ b/src/Nethermind/Nethermind.Core.Test/AddressTests.cs @@ -19,6 +19,8 @@ namespace Nethermind.Core.Test; public class AddressTests { + private readonly EthereumPrecompileChecker _precompileChecker = new(); + [TestCase("0x5A4EAB120fB44eb6684E5e32785702FF45ea344D", "0x5a4eab120fb44eb6684e5e32785702ff45ea344d")] [TestCase("0x5a4eab120fb44eb6684e5e32785702ff45ea344d", "0x5a4eab120fb44eb6684e5e32785702ff45ea344d")] public void String_representation_is_correct(string init, string expected) @@ -120,7 +122,7 @@ public void Is_precompiled_1() byte[] addressBytes = new byte[20]; addressBytes[19] = 1; Address address = new(addressBytes); - Assert.That(address.IsPrecompile(Frontier.Instance), Is.True); + Assert.That(_precompileChecker.IsPrecompile(address, Frontier.Instance), Is.True); } [Test] @@ -129,7 +131,7 @@ public void Is_precompiled_4_regression() byte[] addressBytes = new byte[20]; addressBytes[19] = 4; Address address = new(addressBytes); - Assert.That(address.IsPrecompile(Frontier.Instance), Is.True); + Assert.That(_precompileChecker.IsPrecompile(address, Frontier.Instance), Is.True); } [Test] @@ -138,7 +140,7 @@ public void Is_precompiled_5_frontier() byte[] addressBytes = new byte[20]; addressBytes[19] = 5; Address address = new(addressBytes); - Assert.That(address.IsPrecompile(Frontier.Instance), Is.False); + Assert.That(_precompileChecker.IsPrecompile(address, Frontier.Instance), Is.False); } [Test] @@ -147,7 +149,7 @@ public void Is_precompiled_5_byzantium() byte[] addressBytes = new byte[20]; addressBytes[19] = 5; Address address = new(addressBytes); - Assert.That(address.IsPrecompile(Byzantium.Instance), Is.True); + Assert.That(_precompileChecker.IsPrecompile(address, Byzantium.Instance), Is.True); } [Test] @@ -156,7 +158,7 @@ public void Is_precompiled_9_byzantium() byte[] addressBytes = new byte[20]; addressBytes[19] = 9; Address address = new(addressBytes); - Assert.That(address.IsPrecompile(Byzantium.Instance), Is.False); + Assert.That(_precompileChecker.IsPrecompile(address, Byzantium.Instance), Is.False); } [TestCase(0, false)] @@ -165,7 +167,7 @@ public void Is_precompiled_9_byzantium() public void From_number_for_precompile(int number, bool isPrecompile) { Address address = Address.FromNumber((UInt256)number); - Assert.That(address.IsPrecompile(Byzantium.Instance), Is.EqualTo(isPrecompile)); + Assert.That(_precompileChecker.IsPrecompile(address, Byzantium.Instance), Is.EqualTo(isPrecompile)); } [TestCase(0, "0x24cd2edba056b7c654a50e8201b619d4f624fdda")] @@ -178,7 +180,7 @@ public void Of_contract(long nonce, string expectedAddress) [TestCaseSource(nameof(PointEvaluationPrecompileTestCases))] public bool Is_PointEvaluationPrecompile_properly_activated(IReleaseSpec spec) => - Address.FromNumber(0x0a).IsPrecompile(spec); + _precompileChecker.IsPrecompile(Address.FromNumber(0x0a), spec); [TestCase(Address.SystemUserHex, false)] [TestCase("2" + Address.SystemUserHex, false)] diff --git a/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs b/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs index 53a3ba4b5ed..6c4b09f02d7 100644 --- a/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs +++ b/src/Nethermind/Nethermind.Core.Test/Blockchain/TestBlockchain.cs @@ -20,7 +20,6 @@ using Nethermind.Consensus.Processing; using Nethermind.Consensus.Producers; using Nethermind.Consensus.Rewards; -using Nethermind.Consensus.Transactions; using Nethermind.Consensus.Validators; using Nethermind.Consensus.Withdrawals; using Nethermind.Core.Crypto; @@ -81,6 +80,7 @@ public class TestBlockchain : IDisposable public IBlockProducerRunner BlockProducerRunner { get; protected set; } = null!; public IDbProvider DbProvider => _fromContainer.DbProvider; public ISpecProvider SpecProvider => _fromContainer.SpecProvider; + public IPrecompileChecker PrecompileChecker => _fromContainer.PrecompileChecker; public ISealEngine SealEngine => _fromContainer.SealEngine; @@ -144,6 +144,7 @@ private record FromContainer( IReadOnlyStateProvider ReadOnlyState, IDbProvider DbProvider, ISpecProvider SpecProvider, + IPrecompileChecker PrecompileChecker, ISealEngine SealEngine, ITransactionComparerProvider TransactionComparerProvider, IPoSSwitcher PoSSwitcher, diff --git a/src/Nethermind/Nethermind.Core.Test/Modules/TestBlockProcessingModule.cs b/src/Nethermind/Nethermind.Core.Test/Modules/TestBlockProcessingModule.cs index ddf49605d35..95acaecf192 100644 --- a/src/Nethermind/Nethermind.Core.Test/Modules/TestBlockProcessingModule.cs +++ b/src/Nethermind/Nethermind.Core.Test/Modules/TestBlockProcessingModule.cs @@ -43,7 +43,8 @@ protected override void Load(ContainerBuilder builder) { IWorldState worldState = ctx.Resolve().GlobalWorldState; PreBlockCaches? preBlockCaches = (worldState as IPreBlockCaches)?.Caches; - return new CodeInfoRepository(preBlockCaches?.PrecompileCache); + IPrecompileChecker precompileChecker = ctx.Resolve(); + return new CodeInfoRepository(precompileChecker, preBlockCaches?.PrecompileCache); }) .AddSingleton((ctx) => { diff --git a/src/Nethermind/Nethermind.Core.Test/TestPrecompiles.cs b/src/Nethermind/Nethermind.Core.Test/TestPrecompiles.cs new file mode 100644 index 00000000000..43baefc1c42 --- /dev/null +++ b/src/Nethermind/Nethermind.Core.Test/TestPrecompiles.cs @@ -0,0 +1,19 @@ +// SPDX-FileCopyrightText: 2024 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using Nethermind.Evm.Precompiles; + +namespace Nethermind.Core.Test; + +/// +/// Test utilities for precompile checkers. +/// Provides shared instances to avoid unnecessary object creation in tests. +/// +public static class TestPrecompiles +{ + /// + /// Shared EthereumPrecompileChecker instance for use in tests. + /// Safe to share since EthereumPrecompileChecker is stateless. + /// + public static readonly IPrecompileChecker Ethereum = new EthereumPrecompileChecker(); +} diff --git a/src/Nethermind/Nethermind.Core/CompositePrecompileChecker.cs b/src/Nethermind/Nethermind.Core/CompositePrecompileChecker.cs new file mode 100644 index 00000000000..51f73902158 --- /dev/null +++ b/src/Nethermind/Nethermind.Core/CompositePrecompileChecker.cs @@ -0,0 +1,31 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using Nethermind.Core.Specs; + +namespace Nethermind.Core; + +public class CompositePrecompileChecker : IPrecompileChecker +{ + private readonly IPrecompileChecker[] _checkers; + + public CompositePrecompileChecker(params IPrecompileChecker[] checkers) + { + if (checkers is null || checkers.Length == 0) + throw new ArgumentException("At least one precompile checker must be provided", nameof(checkers)); + + _checkers = checkers; + } + + public bool IsPrecompile(Address address, IReleaseSpec spec) + { + foreach (var pc in _checkers) + { + if (pc.IsPrecompile(address, spec)) + return true; + } + + return false; + } +} diff --git a/src/Nethermind/Nethermind.Core/IPrecompileChecker.cs b/src/Nethermind/Nethermind.Core/IPrecompileChecker.cs new file mode 100644 index 00000000000..b5d9b3e6439 --- /dev/null +++ b/src/Nethermind/Nethermind.Core/IPrecompileChecker.cs @@ -0,0 +1,11 @@ +// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using Nethermind.Core.Specs; + +namespace Nethermind.Core; + +public interface IPrecompileChecker +{ + bool IsPrecompile(Address address, IReleaseSpec spec); +} diff --git a/src/Nethermind/Nethermind.Evm.Benchmark/EvmBenchmarks.cs b/src/Nethermind/Nethermind.Evm.Benchmark/EvmBenchmarks.cs index 7bc6c562dd6..8e692bd7c35 100644 --- a/src/Nethermind/Nethermind.Evm.Benchmark/EvmBenchmarks.cs +++ b/src/Nethermind/Nethermind.Evm.Benchmark/EvmBenchmarks.cs @@ -16,6 +16,7 @@ using Nethermind.Logging; using Nethermind.State; using Nethermind.Trie.Pruning; +using Nethermind.Evm.Precompiles; namespace Nethermind.Evm.Benchmark { @@ -43,8 +44,9 @@ public void GlobalSetup() _stateProvider = worldStateManager.GlobalWorldState; _stateProvider.CreateAccount(Address.Zero, 1000.Ether()); _stateProvider.Commit(_spec); - CodeInfoRepository codeInfoRepository = new(); - _virtualMachine = new VirtualMachine(_blockhashProvider, MainnetSpecProvider.Instance, LimboLogs.Instance); + IPrecompileChecker precompileChecker = new EthereumPrecompileChecker(); + CodeInfoRepository codeInfoRepository = new(precompileChecker); + _virtualMachine = new VirtualMachine(_blockhashProvider, MainnetSpecProvider.Instance, LimboLogs.Instance, precompileChecker); _virtualMachine.SetBlockExecutionContext(new BlockExecutionContext(_header, _spec)); _virtualMachine.SetTxExecutionContext(new TxExecutionContext(Address.Zero, codeInfoRepository, null, 0)); diff --git a/src/Nethermind/Nethermind.Evm.Benchmark/MultipleUnsignedOperations.cs b/src/Nethermind/Nethermind.Evm.Benchmark/MultipleUnsignedOperations.cs index 2e9dffbc950..8c311747f4f 100644 --- a/src/Nethermind/Nethermind.Evm.Benchmark/MultipleUnsignedOperations.cs +++ b/src/Nethermind/Nethermind.Evm.Benchmark/MultipleUnsignedOperations.cs @@ -18,6 +18,7 @@ using Nethermind.Specs.Forks; using Nethermind.State; using Nethermind.Trie.Pruning; +using Nethermind.Evm.Precompiles; namespace Nethermind.Evm.Benchmark; @@ -75,8 +76,9 @@ public void GlobalSetup() _stateProvider.Commit(_spec); Console.WriteLine(MuirGlacier.Instance); - CodeInfoRepository codeInfoRepository = new(); - _virtualMachine = new VirtualMachine(_blockhashProvider, MainnetSpecProvider.Instance, new OneLoggerLogManager(NullLogger.Instance)); + IPrecompileChecker precompileChecker = new EthereumPrecompileChecker(); + CodeInfoRepository codeInfoRepository = new(precompileChecker); + _virtualMachine = new VirtualMachine(_blockhashProvider, MainnetSpecProvider.Instance, new OneLoggerLogManager(NullLogger.Instance), precompileChecker); _virtualMachine.SetBlockExecutionContext(new BlockExecutionContext(_header, _spec)); _virtualMachine.SetTxExecutionContext(new TxExecutionContext(Address.Zero, codeInfoRepository, null, 0)); diff --git a/src/Nethermind/Nethermind.Evm.Benchmark/StaticCallBenchmarks.cs b/src/Nethermind/Nethermind.Evm.Benchmark/StaticCallBenchmarks.cs index e92c54a8935..44f4e1c7b79 100644 --- a/src/Nethermind/Nethermind.Evm.Benchmark/StaticCallBenchmarks.cs +++ b/src/Nethermind/Nethermind.Evm.Benchmark/StaticCallBenchmarks.cs @@ -18,6 +18,7 @@ using Nethermind.Specs.Forks; using Nethermind.State; using Nethermind.Trie.Pruning; +using Nethermind.Evm.Precompiles; namespace Nethermind.Evm.Benchmark { @@ -86,8 +87,9 @@ public void GlobalSetup() _stateProvider.Commit(_spec); Console.WriteLine(MuirGlacier.Instance); - CodeInfoRepository codeInfoRepository = new(); - _virtualMachine = new VirtualMachine(_blockhashProvider, MainnetSpecProvider.Instance, new OneLoggerLogManager(NullLogger.Instance)); + IPrecompileChecker precompileChecker = new EthereumPrecompileChecker(); + CodeInfoRepository codeInfoRepository = new CodeInfoRepository(precompileChecker); + _virtualMachine = new VirtualMachine(_blockhashProvider, MainnetSpecProvider.Instance, new OneLoggerLogManager(NullLogger.Instance), precompileChecker); _virtualMachine.SetBlockExecutionContext(new BlockExecutionContext(_header, _spec)); _virtualMachine.SetTxExecutionContext(new TxExecutionContext(Address.Zero, codeInfoRepository, null, 0)); _environment = new ExecutionEnvironment diff --git a/src/Nethermind/Nethermind.Evm.Test/CodeInfoRepositoryTests.cs b/src/Nethermind/Nethermind.Evm.Test/CodeInfoRepositoryTests.cs index e310c8da9dc..a75d31d3d03 100644 --- a/src/Nethermind/Nethermind.Evm.Test/CodeInfoRepositoryTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/CodeInfoRepositoryTests.cs @@ -19,6 +19,7 @@ using Nethermind.Core.Test; using Nethermind.Db; using Nethermind.Trie.Pruning; +using Nethermind.Evm.Precompiles; namespace Nethermind.Evm.Test; @@ -69,7 +70,8 @@ public void TryGetDelegation_CodeIsNotDelegation_ReturnsFalse(byte[] code) IWorldState stateProvider = worldStateManager.GlobalWorldState; stateProvider.CreateAccount(TestItem.AddressA, 0); stateProvider.InsertCode(TestItem.AddressA, code, Substitute.For()); - CodeInfoRepository sut = new(); + IPrecompileChecker precompileChecker = TestPrecompiles.Ethereum; + CodeInfoRepository sut = new(precompileChecker); sut.TryGetDelegation(stateProvider, TestItem.AddressA, Substitute.For(), out _).Should().Be(false); } @@ -98,7 +100,8 @@ public void TryGetDelegation_CodeTryGetDelegation_ReturnsTrue(byte[] code) IWorldState stateProvider = worldStateManager.GlobalWorldState; stateProvider.CreateAccount(TestItem.AddressA, 0); stateProvider.InsertCode(TestItem.AddressA, code, Substitute.For()); - CodeInfoRepository sut = new(); + IPrecompileChecker precompileChecker = TestPrecompiles.Ethereum; + CodeInfoRepository sut = new(precompileChecker); sut.TryGetDelegation(stateProvider, TestItem.AddressA, Substitute.For(), out _).Should().Be(true); } @@ -111,7 +114,8 @@ public void TryGetDelegation_CodeTryGetDelegation_CorrectDelegationAddressIsSet( IWorldState stateProvider = worldStateManager.GlobalWorldState; stateProvider.CreateAccount(TestItem.AddressA, 0); stateProvider.InsertCode(TestItem.AddressA, code, Substitute.For()); - CodeInfoRepository sut = new(); + IPrecompileChecker precompileChecker = TestPrecompiles.Ethereum; + CodeInfoRepository sut = new(precompileChecker); Address result; sut.TryGetDelegation(stateProvider, TestItem.AddressA, Substitute.For(), out result); @@ -132,7 +136,8 @@ public void GetExecutableCodeHash_CodeTryGetDelegation_ReturnsHashOfDelegated(by stateProvider.CreateAccount(delegationAddress, 0); stateProvider.InsertCode(delegationAddress, delegationCode, Substitute.For()); - CodeInfoRepository sut = new(); + IPrecompileChecker precompileChecker = TestPrecompiles.Ethereum; + CodeInfoRepository sut = new(precompileChecker); sut.GetExecutableCodeHash(stateProvider, TestItem.AddressA, Substitute.For()).Should().Be(Keccak.Compute(code).ValueHash256); } @@ -146,7 +151,8 @@ public void GetExecutableCodeHash_CodeIsNotDelegation_ReturnsCodeHashOfAddress(b stateProvider.CreateAccount(TestItem.AddressA, 0); stateProvider.InsertCode(TestItem.AddressA, code, Substitute.For()); - CodeInfoRepository sut = new(); + IPrecompileChecker precompileChecker = TestPrecompiles.Ethereum; + CodeInfoRepository sut = new(precompileChecker); sut.GetExecutableCodeHash(stateProvider, TestItem.AddressA, Substitute.For()).Should().Be(Keccak.Compute(code).ValueHash256); } @@ -163,7 +169,8 @@ public void GetCachedCodeInfo_CodeTryGetDelegation_ReturnsCodeOfDelegation(byte[ stateProvider.CreateAccount(delegationAddress, 0); byte[] delegationCode = new byte[32]; stateProvider.InsertCode(delegationAddress, delegationCode, Substitute.For()); - CodeInfoRepository sut = new(); + IPrecompileChecker precompileChecker = TestPrecompiles.Ethereum; + CodeInfoRepository sut = new(precompileChecker); ICodeInfo result = sut.GetCachedCodeInfo(stateProvider, TestItem.AddressA, Substitute.For()); result.MachineCode.ToArray().Should().BeEquivalentTo(delegationCode); @@ -178,7 +185,8 @@ public void GetCachedCodeInfo_CodeIsNotDelegation_ReturnsCodeOfAddress(byte[] co stateProvider.CreateAccount(TestItem.AddressA, 0); stateProvider.InsertCode(TestItem.AddressA, code, Substitute.For()); - CodeInfoRepository sut = new(); + IPrecompileChecker precompileChecker = TestPrecompiles.Ethereum; + CodeInfoRepository sut = new(precompileChecker); sut.GetCachedCodeInfo(stateProvider, TestItem.AddressA, Substitute.For()).Should().BeEquivalentTo(new CodeInfo(code)); } diff --git a/src/Nethermind/Nethermind.Evm.Test/Eip1052Tests.cs b/src/Nethermind/Nethermind.Evm.Test/Eip1052Tests.cs index fd4246c7770..76738fd71a4 100644 --- a/src/Nethermind/Nethermind.Evm.Test/Eip1052Tests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/Eip1052Tests.cs @@ -59,7 +59,7 @@ public void Non_existing_account_returns_0() public void Non_existing_precompile_returns_0() { Address precompileAddress = Sha256Precompile.Address; - Assert.That(precompileAddress.IsPrecompile(Spec), Is.True); + Assert.That(_precompileChecker.IsPrecompile(precompileAddress, Spec), Is.True); byte[] code = Prepare.EvmCode .PushData(precompileAddress) @@ -76,7 +76,7 @@ public void Non_existing_precompile_returns_0() public void Existing_precompile_returns_empty_data_hash() { Address precompileAddress = Sha256Precompile.Address; - Assert.That(precompileAddress.IsPrecompile(Spec), Is.True); + Assert.That(_precompileChecker.IsPrecompile(precompileAddress, Spec), Is.True); TestState.CreateAccount(precompileAddress, 1.Wei()); diff --git a/src/Nethermind/Nethermind.Evm.Test/Eip152Tests.cs b/src/Nethermind/Nethermind.Evm.Test/Eip152Tests.cs index b93be39bd7f..c53cf08d990 100644 --- a/src/Nethermind/Nethermind.Evm.Test/Eip152Tests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/Eip152Tests.cs @@ -2,8 +2,8 @@ // SPDX-License-Identifier: LGPL-3.0-only using Nethermind.Core; -using Nethermind.Specs; using Nethermind.Evm.Precompiles; +using Nethermind.Specs; using NUnit.Framework; namespace Nethermind.Evm.Test; @@ -28,7 +28,7 @@ public void before_istanbul() { _blockNumberAdjustment = -1; Address precompileAddress = Blake2FPrecompile.Address; - Assert.That(precompileAddress.IsPrecompile(Spec), Is.False); + Assert.That(_precompileChecker.IsPrecompile(precompileAddress, Spec), Is.False); } [Test] diff --git a/src/Nethermind/Nethermind.Evm.Test/Eip2537Tests.cs b/src/Nethermind/Nethermind.Evm.Test/Eip2537Tests.cs index 90936510c1a..0c46efb96bc 100644 --- a/src/Nethermind/Nethermind.Evm.Test/Eip2537Tests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/Eip2537Tests.cs @@ -2,7 +2,6 @@ // SPDX-License-Identifier: LGPL-3.0-only using NUnit.Framework; -using Nethermind.Evm.Precompiles; using Nethermind.Evm.Precompiles.Bls; using Nethermind.Specs; @@ -27,13 +26,13 @@ public override void TearDown() public void Test_g1_add_before_prague() { _timestampAdjustment = -12; - Assert.That(G1AddPrecompile.Address.IsPrecompile(Spec), Is.False); + Assert.That(_precompileChecker.IsPrecompile(G1AddPrecompile.Address, Spec), Is.False); } [Test] public void Test_g1_add_after_prague() { - Assert.That(G1AddPrecompile.Address.IsPrecompile(Spec), Is.True); + Assert.That(_precompileChecker.IsPrecompile(G1AddPrecompile.Address, Spec), Is.True); byte[] code = Prepare.EvmCode .CallWithInput(G1AddPrecompile.Address, 1000L, new byte[256]) @@ -55,13 +54,13 @@ public void Test_g1_add_after_prague() public void Test_g2_add_before_prague() { _timestampAdjustment = -12; - Assert.That(G2AddPrecompile.Address.IsPrecompile(Spec), Is.False); + Assert.That(_precompileChecker.IsPrecompile(G2AddPrecompile.Address, Spec), Is.False); } [Test] public void Test_g2_add_after_prague() { - Assert.That(G2AddPrecompile.Address.IsPrecompile(Spec), Is.True); + Assert.That(_precompileChecker.IsPrecompile(G2AddPrecompile.Address, Spec), Is.True); byte[] code = Prepare.EvmCode .CallWithInput(G2AddPrecompile.Address, 1000L, new byte[512]) @@ -83,13 +82,13 @@ public void Test_g2_add_after_prague() public void Test_g1_msm_before_prague() { _timestampAdjustment = -12; - Assert.That(G1MSMPrecompile.Address.IsPrecompile(Spec), Is.False); + Assert.That(_precompileChecker.IsPrecompile(G1MSMPrecompile.Address, Spec), Is.False); } [Test] public void Test_g1_msm_after_prague() { - Assert.That(G1MSMPrecompile.Address.IsPrecompile(Spec), Is.True); + Assert.That(_precompileChecker.IsPrecompile(G1MSMPrecompile.Address, Spec), Is.True); byte[] code = Prepare.EvmCode .CallWithInput(G1MSMPrecompile.Address, 100000L, new byte[160]) @@ -111,13 +110,13 @@ public void Test_g1_msm_after_prague() public void Test_g2_msm_before_prague() { _timestampAdjustment = -12; - Assert.That(G2MSMPrecompile.Address.IsPrecompile(Spec), Is.False); + Assert.That(_precompileChecker.IsPrecompile(G2MSMPrecompile.Address, Spec), Is.False); } [Test] public void Test_g2_msm_after_prague() { - Assert.That(G2MSMPrecompile.Address.IsPrecompile(Spec), Is.True); + Assert.That(_precompileChecker.IsPrecompile(G2MSMPrecompile.Address, Spec), Is.True); byte[] code = Prepare.EvmCode .CallWithInput(G2MSMPrecompile.Address, 100000L, new byte[288]) @@ -139,13 +138,13 @@ public void Test_g2_msm_after_prague() public void Test_pairing_before_prague() { _timestampAdjustment = -12; - Assert.That(PairingCheckPrecompile.Address.IsPrecompile(Spec), Is.False); + Assert.That(_precompileChecker.IsPrecompile(PairingCheckPrecompile.Address, Spec), Is.False); } [Test] public void Test_pairing_check_after_prague() { - Assert.That(PairingCheckPrecompile.Address.IsPrecompile(Spec), Is.True); + Assert.That(_precompileChecker.IsPrecompile(PairingCheckPrecompile.Address, Spec), Is.True); byte[] code = Prepare.EvmCode .CallWithInput(PairingCheckPrecompile.Address, 100000L, new byte[384]) @@ -167,13 +166,13 @@ public void Test_pairing_check_after_prague() public void Test_map_fp_to_g1_before_prague() { _timestampAdjustment = -12; - Assert.That(MapFpToG1Precompile.Address.IsPrecompile(Spec), Is.False); + Assert.That(_precompileChecker.IsPrecompile(MapFpToG1Precompile.Address, Spec), Is.False); } [Test] public void Test_map_fp_to_g1_after_prague() { - Assert.That(MapFpToG1Precompile.Address.IsPrecompile(Spec), Is.True); + Assert.That(_precompileChecker.IsPrecompile(MapFpToG1Precompile.Address, Spec), Is.True); byte[] code = Prepare.EvmCode .CallWithInput(MapFpToG1Precompile.Address, 10000L, new byte[64]) @@ -195,13 +194,13 @@ public void Test_map_fp_to_g1_after_prague() public void Test_map_fp2_to_g2_before_prague() { _timestampAdjustment = -12; - Assert.That(MapFp2ToG2Precompile.Address.IsPrecompile(Spec), Is.False); + Assert.That(_precompileChecker.IsPrecompile(MapFp2ToG2Precompile.Address, Spec), Is.False); } [Test] public void Test_map_fp2_to_g2_after_prague() { - Assert.That(MapFp2ToG2Precompile.Address.IsPrecompile(Spec), Is.True); + Assert.That(_precompileChecker.IsPrecompile(MapFp2ToG2Precompile.Address, Spec), Is.True); byte[] code = Prepare.EvmCode .CallWithInput(MapFp2ToG2Precompile.Address, 100000L, new byte[128]) diff --git a/src/Nethermind/Nethermind.Evm.Test/EvmPooledMemoryTests.cs b/src/Nethermind/Nethermind.Evm.Test/EvmPooledMemoryTests.cs index bfdafe9e874..4db1aae118f 100644 --- a/src/Nethermind/Nethermind.Evm.Test/EvmPooledMemoryTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/EvmPooledMemoryTests.cs @@ -9,7 +9,6 @@ using Nethermind.Core.Specs; using Nethermind.Core.Test.Builders; using Nethermind.Crypto; -using Nethermind.Db; using Nethermind.Evm.Tracing; using Nethermind.Evm.TransactionProcessing; using Nethermind.Int256; @@ -17,9 +16,9 @@ using Nethermind.Specs; using Nethermind.Specs.Forks; using Nethermind.State; -using Nethermind.Trie.Pruning; using FluentAssertions; using Nethermind.Core.Test; +using Nethermind.Evm.Precompiles; using NUnit.Framework; namespace Nethermind.Evm.Test; @@ -151,11 +150,13 @@ private static string Run(byte[] input) IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); IWorldState stateProvider = worldStateManager.GlobalWorldState; ISpecProvider specProvider = new TestSpecProvider(London.Instance); - CodeInfoRepository codeInfoRepository = new(); + IPrecompileChecker precompileChecker = TestPrecompiles.Ethereum; + CodeInfoRepository codeInfoRepository = new(precompileChecker); VirtualMachine virtualMachine = new( new TestBlockhashProvider(specProvider), specProvider, - LimboLogs.Instance); + LimboLogs.Instance, + precompileChecker); ITransactionProcessor transactionProcessor = new TransactionProcessor( specProvider, stateProvider, diff --git a/src/Nethermind/Nethermind.Evm.Test/Tracing/GasEstimationTests.cs b/src/Nethermind/Nethermind.Evm.Test/Tracing/GasEstimationTests.cs index e8fff9b4cbe..f75b3f04fd5 100644 --- a/src/Nethermind/Nethermind.Evm.Test/Tracing/GasEstimationTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/Tracing/GasEstimationTests.cs @@ -10,14 +10,13 @@ using Nethermind.Core.Test; using Nethermind.Core.Test.Builders; using Nethermind.Crypto; -using Nethermind.Db; +using Nethermind.Evm.Precompiles; using Nethermind.Evm.Tracing; using Nethermind.Evm.TransactionProcessing; using Nethermind.Int256; using Nethermind.Logging; using Nethermind.Specs; using Nethermind.State; -using Nethermind.Trie.Pruning; using NSubstitute; using NUnit.Framework; @@ -383,6 +382,7 @@ private class TestEnvironment public IWorldState _stateProvider; public EstimateGasTracer tracer; public GasEstimator estimator; + public IPrecompileChecker precompileChecker; public TestEnvironment() { @@ -392,9 +392,10 @@ public TestEnvironment() _stateProvider.CreateAccount(TestItem.AddressA, 1.Ether()); _stateProvider.Commit(_specProvider.GenesisSpec); _stateProvider.CommitTree(0); + precompileChecker = TestPrecompiles.Ethereum; - CodeInfoRepository codeInfoRepository = new(); - VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance); + CodeInfoRepository codeInfoRepository = new(precompileChecker); + VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance, precompileChecker); _transactionProcessor = new TransactionProcessor(_specProvider, _stateProvider, virtualMachine, codeInfoRepository, LimboLogs.Instance); _ethereumEcdsa = new EthereumEcdsa(_specProvider.ChainId); diff --git a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip4844Tests.cs b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip4844Tests.cs index 997355cebcc..03779252656 100644 --- a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip4844Tests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip4844Tests.cs @@ -7,17 +7,16 @@ using Nethermind.Specs; using Nethermind.Core.Test.Builders; using Nethermind.Crypto; -using Nethermind.Db; using Nethermind.Int256; using Nethermind.Evm.Tracing; using Nethermind.Evm.TransactionProcessing; using Nethermind.Logging; using Nethermind.Specs.Forks; using Nethermind.State; -using Nethermind.Trie.Pruning; using NUnit.Framework; using System.Collections.Generic; using Nethermind.Core.Test; +using Nethermind.Evm.Precompiles; namespace Nethermind.Evm.Test; @@ -28,6 +27,7 @@ internal class TransactionProcessorEip4844Tests private IEthereumEcdsa _ethereumEcdsa = null!; private ITransactionProcessor _transactionProcessor = null!; private IWorldState _stateProvider = null!; + private IPrecompileChecker _precompileChecker = null!; [SetUp] public void Setup() @@ -35,8 +35,9 @@ public void Setup() _specProvider = new TestSpecProvider(Cancun.Instance); IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); _stateProvider = worldStateManager.GlobalWorldState; - CodeInfoRepository codeInfoRepository = new(); - VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance); + _precompileChecker = TestPrecompiles.Ethereum; + CodeInfoRepository codeInfoRepository = new(_precompileChecker); + VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance, _precompileChecker); _transactionProcessor = new TransactionProcessor(_specProvider, _stateProvider, virtualMachine, codeInfoRepository, LimboLogs.Instance); _ethereumEcdsa = new EthereumEcdsa(_specProvider.ChainId); } diff --git a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip7623Tests.cs b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip7623Tests.cs index 451444bcf3d..3df0c2bfda6 100644 --- a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip7623Tests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip7623Tests.cs @@ -8,16 +8,14 @@ using Nethermind.Core.Test; using Nethermind.Core.Test.Builders; using Nethermind.Crypto; -using Nethermind.Db; +using Nethermind.Evm.Precompiles; using Nethermind.Evm.Tracing; using Nethermind.Evm.TransactionProcessing; -using Nethermind.Facade; using Nethermind.Int256; using Nethermind.Logging; using Nethermind.Specs; using Nethermind.Specs.Forks; using Nethermind.State; -using Nethermind.Trie.Pruning; using NUnit.Framework; namespace Nethermind.Evm.Test; @@ -28,6 +26,7 @@ public class TransactionProcessorEip7623Tests private IEthereumEcdsa _ethereumEcdsa; private ITransactionProcessor _transactionProcessor; private IWorldState _stateProvider; + private IPrecompileChecker _precompileChecker; [SetUp] public void Setup() @@ -35,8 +34,9 @@ public void Setup() _specProvider = new TestSpecProvider(Prague.Instance); IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); _stateProvider = worldStateManager.GlobalWorldState; - CodeInfoRepository codeInfoRepository = new(); - VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance); + _precompileChecker = TestPrecompiles.Ethereum; + CodeInfoRepository codeInfoRepository = new(_precompileChecker); + VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance, _precompileChecker); _transactionProcessor = new TransactionProcessor(_specProvider, _stateProvider, virtualMachine, codeInfoRepository, LimboLogs.Instance); _ethereumEcdsa = new EthereumEcdsa(_specProvider.ChainId); } diff --git a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip7702Tests.cs b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip7702Tests.cs index 8e6cbd4ac2b..4258798bc57 100644 --- a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip7702Tests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorEip7702Tests.cs @@ -7,19 +7,18 @@ using Nethermind.Specs; using Nethermind.Core.Test.Builders; using Nethermind.Crypto; -using Nethermind.Db; using Nethermind.Evm.Tracing; using Nethermind.Evm.TransactionProcessing; using Nethermind.Logging; using Nethermind.Specs.Forks; using Nethermind.State; -using Nethermind.Trie.Pruning; using NUnit.Framework; using System.Collections.Generic; using Nethermind.Core.Crypto; using System; using System.Linq; using Nethermind.Core.Test; +using Nethermind.Evm.Precompiles; using Nethermind.Int256; namespace Nethermind.Evm.Test; @@ -31,6 +30,7 @@ internal class TransactionProcessorEip7702Tests private IEthereumEcdsa _ethereumEcdsa; private ITransactionProcessor _transactionProcessor; private IWorldState _stateProvider; + private IPrecompileChecker _precompileChecker; [SetUp] public void Setup() @@ -38,8 +38,9 @@ public void Setup() _specProvider = new TestSpecProvider(Prague.Instance); IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); _stateProvider = worldStateManager.GlobalWorldState; - CodeInfoRepository codeInfoRepository = new(); - VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance); + _precompileChecker = TestPrecompiles.Ethereum; + CodeInfoRepository codeInfoRepository = new(_precompileChecker); + VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance, _precompileChecker); _transactionProcessor = new TransactionProcessor(_specProvider, _stateProvider, virtualMachine, codeInfoRepository, LimboLogs.Instance); _ethereumEcdsa = new EthereumEcdsa(_specProvider.ChainId); } diff --git a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorFeeTests.cs b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorFeeTests.cs index 7c8d471570d..0058ba1e138 100644 --- a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorFeeTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorFeeTests.cs @@ -9,14 +9,13 @@ using Nethermind.Core.Test; using Nethermind.Core.Test.Builders; using Nethermind.Crypto; -using Nethermind.Db; +using Nethermind.Evm.Precompiles; using Nethermind.Evm.Tracing; using Nethermind.Evm.TransactionProcessing; using Nethermind.Logging; using Nethermind.Specs; using Nethermind.Specs.Test; using Nethermind.State; -using Nethermind.Trie.Pruning; using Nethermind.Int256; using NUnit.Framework; using Nethermind.Specs.GnosisForks; @@ -30,6 +29,7 @@ public class TransactionProcessorFeeTests private ITransactionProcessor _transactionProcessor; private IWorldState _stateProvider; private OverridableReleaseSpec _spec; + private IPrecompileChecker _precompileChecker; [SetUp] public void Setup() @@ -42,9 +42,10 @@ public void Setup() _stateProvider.CreateAccount(TestItem.AddressA, 1.Ether()); _stateProvider.Commit(_specProvider.GenesisSpec); _stateProvider.CommitTree(0); + _precompileChecker = TestPrecompiles.Ethereum; - CodeInfoRepository codeInfoRepository = new(); - VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance); + CodeInfoRepository codeInfoRepository = new(_precompileChecker); + VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance, _precompileChecker); _transactionProcessor = new TransactionProcessor(_specProvider, _stateProvider, virtualMachine, codeInfoRepository, LimboLogs.Instance); _ethereumEcdsa = new EthereumEcdsa(_specProvider.ChainId); } diff --git a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorTests.cs b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorTests.cs index 5dca3a53efd..283957a1a74 100644 --- a/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorTests.cs +++ b/src/Nethermind/Nethermind.Evm.Test/TransactionProcessorTests.cs @@ -11,7 +11,6 @@ using Nethermind.Specs; using Nethermind.Core.Test.Builders; using Nethermind.Crypto; -using Nethermind.Db; using Nethermind.Int256; using Nethermind.Evm.Tracing; using Nethermind.Evm.Tracing.GethStyle; @@ -21,11 +20,11 @@ using Nethermind.Serialization.Json; using Nethermind.Specs.Forks; using Nethermind.State; -using Nethermind.Trie.Pruning; using NUnit.Framework; using Nethermind.Config; using System.Collections.Generic; using Nethermind.Core.Test; +using Nethermind.Evm.Precompiles; namespace Nethermind.Evm.Test; @@ -40,6 +39,7 @@ public class TransactionProcessorTests private IEthereumEcdsa _ethereumEcdsa; private ITransactionProcessor _transactionProcessor; private IWorldState _stateProvider; + private IPrecompileChecker _precompileChecker; public TransactionProcessorTests(bool eip155Enabled) { @@ -57,9 +57,10 @@ public void Setup() _stateProvider.CreateAccount(TestItem.AddressA, AccountBalance); _stateProvider.Commit(_specProvider.GenesisSpec); _stateProvider.CommitTree(0); + _precompileChecker = TestPrecompiles.Ethereum; - CodeInfoRepository codeInfoRepository = new(); - VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance); + CodeInfoRepository codeInfoRepository = new(_precompileChecker); + VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance, _precompileChecker); _transactionProcessor = new TransactionProcessor(_specProvider, _stateProvider, virtualMachine, codeInfoRepository, LimboLogs.Instance); _ethereumEcdsa = new EthereumEcdsa(_specProvider.ChainId); } diff --git a/src/Nethermind/Nethermind.Evm.Test/VirtualMachineTestsBase.cs b/src/Nethermind/Nethermind.Evm.Test/VirtualMachineTestsBase.cs index 249a5be5b2f..7e6fa075971 100644 --- a/src/Nethermind/Nethermind.Evm.Test/VirtualMachineTestsBase.cs +++ b/src/Nethermind/Nethermind.Evm.Test/VirtualMachineTestsBase.cs @@ -12,13 +12,13 @@ using Nethermind.Core.Test.Builders; using Nethermind.Crypto; using Nethermind.Db; +using Nethermind.Evm.Precompiles; using Nethermind.Int256; using Nethermind.Evm.Tracing; using Nethermind.Evm.Tracing.GethStyle; using Nethermind.Evm.TransactionProcessing; using Nethermind.Logging; using Nethermind.State; -using Nethermind.Trie.Pruning; using NUnit.Framework; namespace Nethermind.Evm.Test; @@ -50,6 +50,7 @@ public abstract class VirtualMachineTestsBase protected virtual long BlockNumber { get; } = MainnetSpecProvider.ByzantiumBlockNumber; protected virtual ulong Timestamp => 0UL; protected virtual ISpecProvider SpecProvider => MainnetSpecProvider.Instance; + protected IPrecompileChecker _precompileChecker => TestPrecompiles.Ethereum; protected IReleaseSpec Spec => SpecProvider.GetSpec(Activation); protected virtual ILogManager GetLogManager() @@ -68,8 +69,8 @@ public virtual void Setup() TestState = worldStateManager.GlobalWorldState; _ethereumEcdsa = new EthereumEcdsa(SpecProvider.ChainId); IBlockhashProvider blockhashProvider = new TestBlockhashProvider(SpecProvider); - CodeInfoRepository = new CodeInfoRepository(); - Machine = new VirtualMachine(blockhashProvider, SpecProvider, logManager); + CodeInfoRepository = new CodeInfoRepository(_precompileChecker); + Machine = new VirtualMachine(blockhashProvider, SpecProvider, logManager, _precompileChecker); _processor = new TransactionProcessor(SpecProvider, TestState, Machine, CodeInfoRepository, logManager); } @@ -227,7 +228,6 @@ protected TestAllTracerWithOutput Execute(ForkActivation activation, long gasLim TestState.CreateAccount(senderRecipientAndMiner.Recipient, 100.Ether()); else TestState.AddToBalance(senderRecipientAndMiner.Recipient, 100.Ether(), SpecProvider.GenesisSpec); - if (code is not null) { TestState.InsertCode(senderRecipientAndMiner.Recipient, code, SpecProvider.GenesisSpec); diff --git a/src/Nethermind/Nethermind.Evm/CodeInfoRepository.cs b/src/Nethermind/Nethermind.Evm/CodeInfoRepository.cs index b429e5611db..04386d4f75e 100644 --- a/src/Nethermind/Nethermind.Evm/CodeInfoRepository.cs +++ b/src/Nethermind/Nethermind.Evm/CodeInfoRepository.cs @@ -26,6 +26,7 @@ public class CodeInfoRepository : ICodeInfoRepository private static readonly FrozenDictionary _precompiles = InitializePrecompiledContracts(); private static readonly CodeLruCache _codeCache = new(); private readonly FrozenDictionary _localPrecompiles; + private readonly IPrecompileChecker _precompileChecker; private static FrozenDictionary InitializePrecompiledContracts() { @@ -57,8 +58,11 @@ private static FrozenDictionary InitializePrecompi }.ToFrozenDictionary(); } - public CodeInfoRepository(ConcurrentDictionary? precompileCache = null) + public CodeInfoRepository( + IPrecompileChecker precompileChecker, + ConcurrentDictionary? precompileCache = null) { + _precompileChecker = precompileChecker; _localPrecompiles = precompileCache is null ? _precompiles : _precompiles.ToFrozenDictionary(kvp => kvp.Key, kvp => CreateCachedPrecompile(kvp, precompileCache)); @@ -67,7 +71,7 @@ public CodeInfoRepository(ConcurrentDictionary; using Int256; -using Nethermind.Evm.Precompiles; internal static unsafe partial class EvmInstructions { @@ -359,7 +358,7 @@ private static bool ChargeAccountAccessGas(ref long gasAvailable, VirtualMachine } // If the account is cold (and not a precompile), charge the cold access cost. - if (vmState.AccessTracker.IsCold(address) && !address.IsPrecompile(spec)) + if (vmState.AccessTracker.IsCold(address) && !vm.PrecompileChecker.IsPrecompile(address, spec)) { result = UpdateGas(GasCostOf.ColdAccountAccess, ref gasAvailable); vmState.AccessTracker.WarmUp(address); diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/AddressExtensions.cs b/src/Nethermind/Nethermind.Evm/Precompiles/AddressExtensions.cs deleted file mode 100644 index 0071beb79ef..00000000000 --- a/src/Nethermind/Nethermind.Evm/Precompiles/AddressExtensions.cs +++ /dev/null @@ -1,49 +0,0 @@ -// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited -// SPDX-License-Identifier: LGPL-3.0-only - -using System; -using System.Runtime.InteropServices; -using Nethermind.Core; -using Nethermind.Core.Specs; - -namespace Nethermind.Evm.Precompiles; - -public static class AddressExtensions -{ - public static bool IsPrecompile(this Address address, IReleaseSpec releaseSpec) - { - Span data = MemoryMarshal.Cast(address.Bytes.AsSpan()); - return (data[4] & 0x0000ffff) == 0 - && data[3] == 0 && data[2] == 0 && data[1] == 0 && data[0] == 0 - && ((data[4] >>> 16) & 0xff) switch - { - 0x00 => (data[4] >>> 24) switch - { - 0x01 => true, - 0x02 => true, - 0x03 => true, - 0x04 => true, - 0x05 => releaseSpec.ModExpEnabled, - 0x06 => releaseSpec.Bn128Enabled, - 0x07 => releaseSpec.Bn128Enabled, - 0x08 => releaseSpec.Bn128Enabled, - 0x09 => releaseSpec.BlakeEnabled, - 0x0a => releaseSpec.IsEip4844Enabled, - 0x0b => releaseSpec.Bls381Enabled, - 0x0c => releaseSpec.Bls381Enabled, - 0x0d => releaseSpec.Bls381Enabled, - 0x0e => releaseSpec.Bls381Enabled, - 0x0f => releaseSpec.Bls381Enabled, - 0x10 => releaseSpec.Bls381Enabled, - 0x11 => releaseSpec.Bls381Enabled, - _ => false - }, - 0x01 => (data[4] >>> 24) switch - { - 0x00 => releaseSpec.IsRip7212Enabled, - _ => false - }, - _ => false - }; - } -} diff --git a/src/Nethermind/Nethermind.Evm/Precompiles/EthereumPrecompileChecker.cs b/src/Nethermind/Nethermind.Evm/Precompiles/EthereumPrecompileChecker.cs new file mode 100644 index 00000000000..8dd75794865 --- /dev/null +++ b/src/Nethermind/Nethermind.Evm/Precompiles/EthereumPrecompileChecker.cs @@ -0,0 +1,49 @@ +// SPDX-FileCopyrightText: 2022 Demerzel Solutions Limited +// SPDX-License-Identifier: LGPL-3.0-only + +using System; +using System.Runtime.InteropServices; +using Nethermind.Core; +using Nethermind.Core.Specs; + +namespace Nethermind.Evm.Precompiles; + +public class EthereumPrecompileChecker : IPrecompileChecker +{ + public bool IsPrecompile(Address address, IReleaseSpec spec) + { + Span data = MemoryMarshal.Cast(address.Bytes.AsSpan()); + return (data[4] & 0x0000ffff) == 0 + && data[3] == 0 && data[2] == 0 && data[1] == 0 && data[0] == 0 + && ((data[4] >>> 16) & 0xff) switch + { + 0x00 => (data[4] >>> 24) switch + { + 0x01 => true, + 0x02 => true, + 0x03 => true, + 0x04 => true, + 0x05 => spec.ModExpEnabled, + 0x06 => spec.Bn128Enabled, + 0x07 => spec.Bn128Enabled, + 0x08 => spec.Bn128Enabled, + 0x09 => spec.BlakeEnabled, + 0x0a => spec.IsEip4844Enabled, + 0x0b => spec.Bls381Enabled, + 0x0c => spec.Bls381Enabled, + 0x0d => spec.Bls381Enabled, + 0x0e => spec.Bls381Enabled, + 0x0f => spec.Bls381Enabled, + 0x10 => spec.Bls381Enabled, + 0x11 => spec.Bls381Enabled, + _ => false + }, + 0x01 => (data[4] >>> 24) switch + { + 0x00 => spec.IsRip7212Enabled, + _ => false + }, + _ => false + }; + } +} diff --git a/src/Nethermind/Nethermind.Evm/Tracing/GethStyle/Custom/JavaScript/Engine.cs b/src/Nethermind/Nethermind.Evm/Tracing/GethStyle/Custom/JavaScript/Engine.cs index 04b64fab64a..74b7781ae71 100644 --- a/src/Nethermind/Nethermind.Evm/Tracing/GethStyle/Custom/JavaScript/Engine.cs +++ b/src/Nethermind/Nethermind.Evm/Tracing/GethStyle/Custom/JavaScript/Engine.cs @@ -10,6 +10,7 @@ using System.Threading.Tasks; using Microsoft.ClearScript.JavaScript; using Microsoft.ClearScript.V8; +using Nethermind.Core; using Nethermind.Core.Caching; using Nethermind.Core.Extensions; using Nethermind.Core.Specs; @@ -31,6 +32,7 @@ public class Engine : IDisposable private const string Extension = "js"; private readonly IReleaseSpec _spec; + private readonly IPrecompileChecker _precompileChecker; private dynamic _bigInteger; private dynamic _createUint8Array; @@ -75,9 +77,10 @@ private static void CompileStandardScripts() private static V8Script LoadBuiltIn(string name, string code) => _builtInScripts.AddOrUpdate(name, c => _runtime.Compile(code), static (_, script) => script); - public Engine(IReleaseSpec spec) + public Engine(IReleaseSpec spec, IPrecompileChecker? precompileChecker = null) { _spec = spec; + _precompileChecker = precompileChecker ?? new EthereumPrecompileChecker(); V8Engine = _runtime.CreateScriptEngine(IsDebugging ? V8ScriptEngineFlags.AwaitDebuggerAndPauseOnStart | V8ScriptEngineFlags.EnableDebugging @@ -126,8 +129,7 @@ public Engine(IReleaseSpec spec) /// /// Checks if contract at given address is a precompile /// - private bool IsPrecompiled(object address) => address.ToAddress().IsPrecompile(_spec); - + private bool IsPrecompiled(object address) => _precompileChecker.IsPrecompile(address.ToAddress(), _spec); /// /// Returns a slice of input /// diff --git a/src/Nethermind/Nethermind.Evm/VirtualMachine.Warmup.cs b/src/Nethermind/Nethermind.Evm/VirtualMachine.Warmup.cs index 35ebc81e210..2c0f9cc00c1 100644 --- a/src/Nethermind/Nethermind.Evm/VirtualMachine.Warmup.cs +++ b/src/Nethermind/Nethermind.Evm/VirtualMachine.Warmup.cs @@ -8,6 +8,7 @@ using Nethermind.Core.Specs; using Nethermind.Db; using Nethermind.Evm.CodeAnalysis; +using Nethermind.Evm.Precompiles; using Nethermind.Evm.Tracing; using Nethermind.Int256; using Nethermind.Logging; @@ -27,7 +28,8 @@ public static void WarmUpEvmInstructions() { IReleaseSpec spec = Fork.GetLatest(); IBlockhashProvider hashProvider = new WarmupBlockhashProvider(MainnetSpecProvider.Instance); - VirtualMachineBase vm = new(hashProvider, MainnetSpecProvider.Instance, LimboLogs.Instance); + IPrecompileChecker precompileChecker = new EthereumPrecompileChecker(); + VirtualMachineBase vm = new(hashProvider, MainnetSpecProvider.Instance, LimboLogs.Instance, precompileChecker); ILogManager lm = new OneLoggerLogManager(NullLogger.Instance); IKeyValueStoreWithBatching db = new MemDb(); @@ -42,7 +44,7 @@ public static void WarmUpEvmInstructions() WorldState state = new(trieStore, db, lm); state.CreateAccount(addressOne, 1000.Ether()); state.Commit(spec); - CodeInfoRepository codeInfoRepository = new(); + CodeInfoRepository codeInfoRepository = new CodeInfoRepository(precompileChecker); BlockHeader _header = new(Keccak.Zero, Keccak.Zero, addressOne, UInt256.One, MainnetSpecProvider.PragueActivation.BlockNumber, Int64.MaxValue, 1UL, Bytes.Empty, 0, 0); vm.SetBlockExecutionContext(new BlockExecutionContext(_header, spec)); diff --git a/src/Nethermind/Nethermind.Evm/VirtualMachine.cs b/src/Nethermind/Nethermind.Evm/VirtualMachine.cs index 3b7058fd9b3..a57ea25e6b6 100644 --- a/src/Nethermind/Nethermind.Evm/VirtualMachine.cs +++ b/src/Nethermind/Nethermind.Evm/VirtualMachine.cs @@ -36,15 +36,17 @@ namespace Nethermind.Evm; public sealed unsafe class VirtualMachine( IBlockhashProvider? blockHashProvider, ISpecProvider? specProvider, - ILogManager? logManager -) : VirtualMachineBase(blockHashProvider, specProvider, logManager) + ILogManager? logManager, + IPrecompileChecker precompileChecker +) : VirtualMachineBase(blockHashProvider, specProvider, logManager, precompileChecker) { } public unsafe partial class VirtualMachineBase( IBlockhashProvider? blockHashProvider, ISpecProvider? specProvider, - ILogManager? logManager) : IVirtualMachine + ILogManager? logManager, + IPrecompileChecker precompileChecker) : IVirtualMachine { public const int MaxCallDepth = Eof1.RETURN_STACK_MAX_HEIGHT; private readonly static UInt256 P255Int = (UInt256)System.Numerics.BigInteger.Pow(2, 255); @@ -104,6 +106,7 @@ public unsafe partial class VirtualMachineBase( public ReadOnlyMemory ReturnDataBuffer { get; set; } = Array.Empty(); public object ReturnData { get; set; } public IBlockhashProvider BlockHashProvider => _blockHashProvider; + public IPrecompileChecker PrecompileChecker { get; } = precompileChecker; protected Stack StateStack => _stateStack; private BlockExecutionContext _blockExecutionContext; diff --git a/src/Nethermind/Nethermind.Facade.Test/BlockchainBridgeTests.cs b/src/Nethermind/Nethermind.Facade.Test/BlockchainBridgeTests.cs index 365704ad645..0bdb2b2049d 100644 --- a/src/Nethermind/Nethermind.Facade.Test/BlockchainBridgeTests.cs +++ b/src/Nethermind/Nethermind.Facade.Test/BlockchainBridgeTests.cs @@ -21,7 +21,6 @@ using Nethermind.Int256; using Nethermind.Logging; using Nethermind.Specs; -using Nethermind.Trie.Pruning; using Nethermind.TxPool; using NSubstitute; using NUnit.Framework; @@ -47,14 +46,16 @@ public class BlockchainBridgeTests private ManualTimestamper _timestamper; private ISpecProvider _specProvider; private IDbProvider _dbProvider; + private IPrecompileChecker _precompileChecker; private class TestReadOnlyTxProcessingEnv( IOverridableWorldScope worldStateManager, IReadOnlyBlockTree blockTree, ISpecProvider specProvider, ILogManager logManager, - ITransactionProcessor transactionProcessor) - : OverridableTxProcessingEnv(worldStateManager, blockTree, specProvider, logManager) + ITransactionProcessor transactionProcessor, + IPrecompileChecker precompileChecker) + : OverridableTxProcessingEnv(worldStateManager, blockTree, specProvider, logManager, precompileChecker) { protected override ITransactionProcessor CreateTransactionProcessor() => transactionProcessor; } @@ -72,6 +73,7 @@ public async Task SetUp() _transactionProcessor = Substitute.For(); _ethereumEcdsa = Substitute.For(); _specProvider = MainnetSpecProvider.Instance; + _precompileChecker = Substitute.For(); WorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(_dbProvider, LimboLogs.Instance); IOverridableWorldScope overridableWorldScope = worldStateManager.CreateOverridableWorldScope(); @@ -82,7 +84,8 @@ public async Task SetUp() readOnlyBlockTree, _specProvider, LimboLogs.Instance, - _transactionProcessor); + _transactionProcessor, + _precompileChecker); SimulateReadOnlyBlocksProcessingEnvFactory simulateProcessingEnvFactory = new SimulateReadOnlyBlocksProcessingEnvFactory( worldStateManager, @@ -90,6 +93,7 @@ public async Task SetUp() new ReadOnlyDbProvider(_dbProvider, true), _specProvider, SimulateTransactionProcessorFactory.Instance, + _precompileChecker, LimboLogs.Instance); _blockchainBridge = new BlockchainBridge( @@ -220,7 +224,8 @@ public void Bridge_head_is_correct(long headNumber) worldStateManager.CreateOverridableWorldScope(), roBlockTree, _specProvider, - LimboLogs.Instance); + LimboLogs.Instance, + _precompileChecker); SimulateReadOnlyBlocksProcessingEnvFactory simulateProcessingEnv = new SimulateReadOnlyBlocksProcessingEnvFactory( worldStateManager, @@ -228,6 +233,7 @@ public void Bridge_head_is_correct(long headNumber) new ReadOnlyDbProvider(_dbProvider, true), _specProvider, SimulateTransactionProcessorFactory.Instance, + _precompileChecker, LimboLogs.Instance); Block head = Build.A.Block.WithNumber(headNumber).TestObject; diff --git a/src/Nethermind/Nethermind.Facade/Simulate/SimulateReadOnlyBlocksProcessingEnv.cs b/src/Nethermind/Nethermind.Facade/Simulate/SimulateReadOnlyBlocksProcessingEnv.cs index 434a8f5a283..263bdd1aca7 100644 --- a/src/Nethermind/Nethermind.Facade/Simulate/SimulateReadOnlyBlocksProcessingEnv.cs +++ b/src/Nethermind/Nethermind.Facade/Simulate/SimulateReadOnlyBlocksProcessingEnv.cs @@ -68,6 +68,7 @@ public SimulateReadOnlyBlocksProcessingEnv( IBlockTree blockTree, ISpecProvider specProvider, ISimulateTransactionProcessorFactory transactionProcessorFactory, + IPrecompileChecker precompileChecker, ILogManager? logManager = null, bool validate = false) { @@ -78,8 +79,8 @@ public SimulateReadOnlyBlocksProcessingEnv( BlockTree = new BlockTreeOverlay(baseBlockTree, blockTree); StateProvider = worldState; SimulateBlockhashProvider blockhashProvider = new SimulateBlockhashProvider(new BlockhashProvider(BlockTree, specProvider, StateProvider, logManager), BlockTree); - CodeInfoRepository = new OverridableCodeInfoRepository(new CodeInfoRepository()); - SimulateVirtualMachine virtualMachine = new SimulateVirtualMachine(new VirtualMachine(blockhashProvider, specProvider, logManager)); + CodeInfoRepository = new OverridableCodeInfoRepository(new CodeInfoRepository(precompileChecker)); + SimulateVirtualMachine virtualMachine = new SimulateVirtualMachine(new VirtualMachine(blockhashProvider, specProvider, logManager, precompileChecker)); _transactionProcessor = transactionProcessorFactory.CreateTransactionProcessor(SpecProvider, StateProvider, virtualMachine, CodeInfoRepository, _logManager, validate); _blockValidator = CreateValidator(); BlockTransactionPicker = new BlockProductionTransactionPicker(specProvider, ignoreEip3607: true); diff --git a/src/Nethermind/Nethermind.Facade/Simulate/SimulateReadOnlyBlocksProcessingEnvFactory.cs b/src/Nethermind/Nethermind.Facade/Simulate/SimulateReadOnlyBlocksProcessingEnvFactory.cs index 75b2be07831..6b28bd182b9 100644 --- a/src/Nethermind/Nethermind.Facade/Simulate/SimulateReadOnlyBlocksProcessingEnvFactory.cs +++ b/src/Nethermind/Nethermind.Facade/Simulate/SimulateReadOnlyBlocksProcessingEnvFactory.cs @@ -5,6 +5,7 @@ using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Headers; using Nethermind.Blockchain.Synchronization; +using Nethermind.Core; using Nethermind.Core.Specs; using Nethermind.Db; using Nethermind.Db.Blooms; @@ -20,6 +21,7 @@ public class SimulateReadOnlyBlocksProcessingEnvFactory( IDbProvider dbProvider, ISpecProvider specProvider, ISimulateTransactionProcessorFactory transactionProcessorFactory, + IPrecompileChecker precompileChecker, ILogManager? logManager = null) { public SimulateReadOnlyBlocksProcessingEnv Create(bool validate) @@ -35,6 +37,7 @@ public SimulateReadOnlyBlocksProcessingEnv Create(bool validate) tempBlockTree, specProvider, transactionProcessorFactory, + precompileChecker, logManager, validate); } diff --git a/src/Nethermind/Nethermind.Init/Modules/BlockProcessingModule.cs b/src/Nethermind/Nethermind.Init/Modules/BlockProcessingModule.cs index 437b3083f7c..e0b69b1f822 100644 --- a/src/Nethermind/Nethermind.Init/Modules/BlockProcessingModule.cs +++ b/src/Nethermind/Nethermind.Init/Modules/BlockProcessingModule.cs @@ -2,7 +2,6 @@ // SPDX-License-Identifier: LGPL-3.0-only using Autofac; -using Nethermind.Api; using Nethermind.Blockchain; using Nethermind.Blockchain.Find; using Nethermind.Config; diff --git a/src/Nethermind/Nethermind.Init/Modules/NethermindModule.cs b/src/Nethermind/Nethermind.Init/Modules/NethermindModule.cs index 214295b11b2..7e94892d2d6 100644 --- a/src/Nethermind/Nethermind.Init/Modules/NethermindModule.cs +++ b/src/Nethermind/Nethermind.Init/Modules/NethermindModule.cs @@ -13,6 +13,7 @@ using Nethermind.Crypto; using Nethermind.Db; using Nethermind.Era1; +using Nethermind.Evm.Precompiles; using Nethermind.Logging; using Nethermind.Network.Config; using Nethermind.Runner.Ethereum.Modules; @@ -43,6 +44,7 @@ protected override void Load(ContainerBuilder builder) .AddModule(new DbModule()) .AddModule(new BlockProcessingModule()) .AddSingleton() + .AddSingleton() .Bind() diff --git a/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs b/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs index b1350698e6e..7e6a6c16a74 100644 --- a/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs +++ b/src/Nethermind/Nethermind.Init/Steps/InitializeBlockchain.cs @@ -14,7 +14,6 @@ using Nethermind.Blockchain.Blocks; using Nethermind.Blockchain.Filters; using Nethermind.Blockchain.Receipts; -using Nethermind.Blockchain.Services; using Nethermind.Config; using Nethermind.Consensus; using Nethermind.Consensus.Comparers; @@ -72,7 +71,7 @@ protected virtual Task InitBlockchain() IStateReader stateReader = setApi.StateReader!; IWorldState mainWorldState = _api.WorldStateManager!.GlobalWorldState; PreBlockCaches? preBlockCaches = (mainWorldState as IPreBlockCaches)?.Caches; - ICodeInfoRepository codeInfoRepository = CreateCodeInfoRepository(preBlockCaches?.PrecompileCache); + ICodeInfoRepository codeInfoRepository = CreateCodeInfoRepository(_api.PrecompileChecker, preBlockCaches?.PrecompileCache); IChainHeadInfoProvider chainHeadInfoProvider = new ChainHeadInfoProvider(getApi.SpecProvider!, getApi.BlockTree!, stateReader, codeInfoRepository); @@ -85,7 +84,7 @@ protected virtual Task InitBlockchain() _api.ReceiptMonitor = receiptCanonicalityMonitor; _api.BlockPreprocessor.AddFirst( - new RecoverSignatures(getApi.EthereumEcdsa, getApi.SpecProvider, getApi.LogManager)); + new RecoverSignatures(getApi.EthereumEcdsa, getApi.SpecProvider, _api.LogManager)); VirtualMachine.WarmUpEvmInstructions(); IVirtualMachine virtualMachine = CreateVirtualMachine(mainWorldState); @@ -172,9 +171,10 @@ protected virtual Task InitBlockchain() } protected virtual ICodeInfoRepository CreateCodeInfoRepository( + IPrecompileChecker precompileChecker, ConcurrentDictionary? precompileCache ) - => new CodeInfoRepository(precompileCache); + => new CodeInfoRepository(precompileChecker, precompileCache); protected virtual ITransactionProcessor CreateTransactionProcessor(ICodeInfoRepository codeInfoRepository, IVirtualMachine virtualMachine, IWorldState worldState) { @@ -201,7 +201,8 @@ protected virtual IVirtualMachine CreateVirtualMachine(IWorldState worldState) VirtualMachine virtualMachine = new( blockhashProvider, _api.SpecProvider, - _api.LogManager); + _api.LogManager, + _api.PrecompileChecker); return virtualMachine; } diff --git a/src/Nethermind/Nethermind.Init/Steps/RegisterRpcModules.cs b/src/Nethermind/Nethermind.Init/Steps/RegisterRpcModules.cs index 4fcd2c3df0f..a3b40cf89c1 100644 --- a/src/Nethermind/Nethermind.Init/Steps/RegisterRpcModules.cs +++ b/src/Nethermind/Nethermind.Init/Steps/RegisterRpcModules.cs @@ -177,7 +177,8 @@ protected virtual void RegisterDebugRpcModule(IRpcModuleProvider rpcModuleProvid _api.SyncModeSelector, _api.BadBlocksStore, _api.FileSystem, - _api.LogManager); + _api.LogManager, + _api.PrecompileChecker); rpcModuleProvider.RegisterBoundedByCpuCount(debugModuleFactory, JsonRpcConfig.Timeout); } @@ -246,7 +247,8 @@ protected ModuleFactoryBase CreateTraceModuleFactory() _api.ReceiptStorage, _api.SpecProvider, _poSSwitcher, - _api.LogManager); + _api.LogManager, + _api.PrecompileChecker); } protected virtual void RegisterTraceRpcModule(IRpcModuleProvider rpcModuleProvider) diff --git a/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs b/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs index 4967c7a0474..f7b8d8387d0 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Benchmark/EthModuleBenchmarks.cs @@ -54,6 +54,7 @@ using Nethermind.Synchronization.ParallelSync; using Nethermind.Synchronization.Peers; using NSubstitute; +using Nethermind.Evm.Precompiles; namespace Nethermind.JsonRpc.Benchmark { @@ -98,8 +99,9 @@ public void GlobalSetup() new SyncConfig(), LimboLogs.Instance); _blockhashProvider = new BlockhashProvider(blockTree, specProvider, stateProvider, LimboLogs.Instance); - CodeInfoRepository codeInfoRepository = new(); - _virtualMachine = new VirtualMachine(_blockhashProvider, specProvider, LimboLogs.Instance); + IPrecompileChecker precompileChecker = new EthereumPrecompileChecker(); + CodeInfoRepository codeInfoRepository = new(precompileChecker); + _virtualMachine = new VirtualMachine(_blockhashProvider, specProvider, LimboLogs.Instance, precompileChecker); Block genesisBlock = Build.A.Block.Genesis.TestObject; blockTree.SuggestBlock(genesisBlock); diff --git a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/DebugRpcModuleTests.cs b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/DebugRpcModuleTests.cs index 9672761700f..41613db0711 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/DebugRpcModuleTests.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/DebugRpcModuleTests.cs @@ -15,7 +15,6 @@ using Nethermind.Core; using Nethermind.Core.Crypto; using Nethermind.Core.Extensions; -using Nethermind.Core.Specs; using Nethermind.Core.Test.Builders; using Nethermind.Evm.Tracing.GethStyle; using Nethermind.Facade; @@ -70,7 +69,8 @@ public static async Task Create(bool isAura = false) syncModeSelector, new BadBlockStore(blockchain.BlocksDb, 100), new FileSystem(), - blockchain.LogManager + blockchain.LogManager, + blockchain.PrecompileChecker ); IDebugRpcModule debugRpcModule = factory.Create(); diff --git a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/ParityRpcModuleTests.cs b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/ParityRpcModuleTests.cs index 00d521a7ccf..69b179776b9 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/ParityRpcModuleTests.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/ParityRpcModuleTests.cs @@ -36,6 +36,7 @@ using NUnit.Framework; using System; using Nethermind.Evm; +using Nethermind.Evm.Precompiles; namespace Nethermind.JsonRpc.Test.Modules { @@ -78,7 +79,7 @@ public void Initialize() _txPool = new TxPool.TxPool(_ethereumEcdsa, new BlobTxStorage(), - new ChainHeadInfoProvider(new FixedForkActivationChainHeadSpecProvider(specProvider), _blockTree, stateProvider, new CodeInfoRepository()) { HasSynced = true }, + new ChainHeadInfoProvider(new FixedForkActivationChainHeadSpecProvider(specProvider), _blockTree, stateProvider, new CodeInfoRepository(TestPrecompiles.Ethereum)) { HasSynced = true }, new TxPoolConfig(), new TxValidator(specProvider.ChainId), LimboLogs.Instance, diff --git a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Proof/ProofRpcModuleTests.cs b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Proof/ProofRpcModuleTests.cs index ee53516bc63..d70081a68dc 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Proof/ProofRpcModuleTests.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Proof/ProofRpcModuleTests.cs @@ -27,6 +27,7 @@ using Nethermind.Consensus.Processing; using Nethermind.Core.Buffers; using Nethermind.Core.Test; +using Nethermind.Evm.Precompiles; using Nethermind.Facade.Eth.RpcTransaction; using Nethermind.State.Tracing; using NSubstitute; @@ -47,6 +48,7 @@ public class ProofRpcModuleTests private TestSpecProvider _specProvider = null!; private WorldStateManager _worldStateManager = null!; private IReadOnlyTxProcessingEnvFactory _readOnlyTxProcessingEnvFactory = null!; + private IPrecompileChecker _precompileChecker = null!; public ProofRpcModuleTests(bool createSystemAccount, bool useNonZeroGasPrice) { @@ -71,8 +73,9 @@ public async Task Setup() .WithTransactions(receiptStorage) .OfChainLength(10) .TestObject; + _precompileChecker = TestPrecompiles.Ethereum; - _readOnlyTxProcessingEnvFactory = new ReadOnlyTxProcessingEnvFactory(_worldStateManager, _blockTree, _specProvider, LimboLogs.Instance); + _readOnlyTxProcessingEnvFactory = new ReadOnlyTxProcessingEnvFactory(_worldStateManager, _blockTree, _specProvider, LimboLogs.Instance, _precompileChecker); ProofModuleFactory moduleFactory = new( _worldStateManager, diff --git a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/TestRpcBlockchain.cs b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/TestRpcBlockchain.cs index 10a91766ef7..8dee02b7f4c 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/TestRpcBlockchain.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/TestRpcBlockchain.cs @@ -41,11 +41,9 @@ using Nethermind.Consensus; using Nethermind.Consensus.Scheduler; using Nethermind.Core; -using Nethermind.Core.Crypto; using Nethermind.Core.Timers; using Nethermind.JsonRpc.Modules.Trace; using Nethermind.Network; -using Nethermind.Network.Config; using Nethermind.Network.P2P.Subprotocols.Eth; using Nethermind.Network.Rlpx; using Nethermind.Stats; @@ -212,7 +210,8 @@ public async Task Build(Action configurer) Substitute.For(), new BadBlockStore(@this.BlocksDb, 100), new FileSystem(), - @this.LogManager).Create(); + @this.LogManager, + @this.PrecompileChecker).Create(); private readonly Func _traceRpcModuleBuilder = static @this => new TraceModuleFactory( @@ -226,7 +225,8 @@ public async Task Build(Action configurer) @this.ReceiptStorage, @this.SpecProvider, @this.PoSSwitcher, - @this.LogManager + @this.LogManager, + @this.PrecompileChecker ).Create(); protected override async Task Build(Action? configurer = null) @@ -246,13 +246,15 @@ await base.Build(builder => WorldStateManager.CreateOverridableWorldScope(), roBlockTree, SpecProvider, - LimboLogs.Instance); + LimboLogs.Instance, + PrecompileChecker); SimulateReadOnlyBlocksProcessingEnvFactory simulateProcessingEnvFactory = new SimulateReadOnlyBlocksProcessingEnvFactory( WorldStateManager, roBlockTree, new ReadOnlyDbProvider(dbProvider, true), SpecProvider, SimulateTransactionProcessorFactory.Instance, + PrecompileChecker, LimboLogs.Instance); Bridge ??= new BlockchainBridge(processingEnv, simulateProcessingEnvFactory, TxPool, ReceiptFinder, filterStore, filterManager, EthereumEcdsa, Timestamper, LogFinder, SpecProvider, BlocksConfig, false); diff --git a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Trace/ParityStyleTracerTests.cs b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Trace/ParityStyleTracerTests.cs index 6d2286f4432..240c37997c7 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Trace/ParityStyleTracerTests.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/Trace/ParityStyleTracerTests.cs @@ -26,16 +26,15 @@ using Nethermind.Logging; using Nethermind.Specs; using Nethermind.State; -using Nethermind.TxPool; using NUnit.Framework; using Nethermind.Evm.TransactionProcessing; -using Nethermind.Trie.Pruning; using NSubstitute; using Nethermind.Facade; using Nethermind.Config; using Nethermind.Consensus.ExecutionRequests; using Nethermind.Consensus.Withdrawals; using Nethermind.Core.Test; +using Nethermind.Evm.Precompiles; namespace Nethermind.JsonRpc.Test.Modules.Trace; @@ -51,6 +50,7 @@ public class ParityStyleTracerTests private IStateReader _stateReader; private TraceRpcModule _traceRpcModule; private readonly IJsonRpcConfig _jsonRpcConfig = new JsonRpcConfig(); + private IPrecompileChecker _precompileChecker; [SetUp] public void Setup() @@ -68,8 +68,9 @@ public void Setup() _stateReader = worldStateManager.GlobalStateReader; BlockhashProvider blockhashProvider = new(_blockTree, specProvider, stateProvider, LimboLogs.Instance); - CodeInfoRepository codeInfoRepository = new(); - VirtualMachine virtualMachine = new(blockhashProvider, specProvider, LimboLogs.Instance); + CodeInfoRepository codeInfoRepository = new(_precompileChecker); + _precompileChecker = TestPrecompiles.Ethereum; + VirtualMachine virtualMachine = new(blockhashProvider, specProvider, LimboLogs.Instance, _precompileChecker); TransactionProcessor transactionProcessor = new(specProvider, stateProvider, virtualMachine, codeInfoRepository, LimboLogs.Instance); _poSSwitcher = Substitute.For(); diff --git a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/TraceRpcModuleTests.cs b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/TraceRpcModuleTests.cs index 18117de8a8e..19fa8ef5fea 100644 --- a/src/Nethermind/Nethermind.JsonRpc.Test/Modules/TraceRpcModuleTests.cs +++ b/src/Nethermind/Nethermind.JsonRpc.Test/Modules/TraceRpcModuleTests.cs @@ -76,7 +76,8 @@ public async Task Build(ISpecProvider? specProvider = null, bool isAura = false) Blockchain.ReceiptStorage, Blockchain.SpecProvider, Blockchain.PoSSwitcher, - Blockchain.LogManager + Blockchain.LogManager, + Blockchain.PrecompileChecker ); TraceRpcModule = Factory.Create(); diff --git a/src/Nethermind/Nethermind.JsonRpc/Modules/DebugModule/DebugModuleFactory.cs b/src/Nethermind/Nethermind.JsonRpc/Modules/DebugModule/DebugModuleFactory.cs index 7eba760483c..9f9a6ead39b 100644 --- a/src/Nethermind/Nethermind.JsonRpc/Modules/DebugModule/DebugModuleFactory.cs +++ b/src/Nethermind/Nethermind.JsonRpc/Modules/DebugModule/DebugModuleFactory.cs @@ -11,6 +11,7 @@ using Nethermind.Consensus.Rewards; using Nethermind.Consensus.Tracing; using Nethermind.Consensus.Validators; +using Nethermind.Core; using Nethermind.Core.Crypto; using Nethermind.Core.Specs; using Nethermind.Db; @@ -18,7 +19,6 @@ using Nethermind.Logging; using Nethermind.State; using Nethermind.Synchronization.ParallelSync; -using Nethermind.Trie.Pruning; using Nethermind.Facade; namespace Nethermind.JsonRpc.Modules.DebugModule; @@ -42,6 +42,7 @@ public class DebugModuleFactory : ModuleFactoryBase private readonly IBadBlockStore _badBlockStore; private readonly IFileSystem _fileSystem; private readonly IWorldStateManager _worldStateManager; + private readonly IPrecompileChecker _precompileChecker; public DebugModuleFactory( IWorldStateManager worldStateManager, @@ -60,7 +61,8 @@ public DebugModuleFactory( ISyncModeSelector syncModeSelector, IBadBlockStore badBlockStore, IFileSystem fileSystem, - ILogManager logManager) + ILogManager logManager, + IPrecompileChecker precompileChecker) { _worldStateManager = worldStateManager; _dbProvider = dbProvider.AsReadOnly(false); @@ -79,12 +81,13 @@ public DebugModuleFactory( _syncModeSelector = syncModeSelector ?? throw new ArgumentNullException(nameof(syncModeSelector)); _badBlockStore = badBlockStore; _fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem)); + _precompileChecker = precompileChecker; } public override IDebugRpcModule Create() { IOverridableWorldScope worldStateManager = _worldStateManager.CreateOverridableWorldScope(); - OverridableTxProcessingEnv txEnv = new(worldStateManager, _blockTree, _specProvider, _logManager); + OverridableTxProcessingEnv txEnv = new(worldStateManager, _blockTree, _specProvider, _logManager, _precompileChecker); IReadOnlyTxProcessingScope scope = txEnv.Build(Keccak.EmptyTreeHash); diff --git a/src/Nethermind/Nethermind.JsonRpc/Modules/Trace/TraceModuleFactory.cs b/src/Nethermind/Nethermind.JsonRpc/Modules/Trace/TraceModuleFactory.cs index 75428e27b7d..d1e7cec9c06 100644 --- a/src/Nethermind/Nethermind.JsonRpc/Modules/Trace/TraceModuleFactory.cs +++ b/src/Nethermind/Nethermind.JsonRpc/Modules/Trace/TraceModuleFactory.cs @@ -9,6 +9,7 @@ using Nethermind.Consensus.Rewards; using Nethermind.Consensus.Tracing; using Nethermind.Consensus.Validators; +using Nethermind.Core; using Nethermind.Core.Crypto; using Nethermind.Core.Specs; using Nethermind.Evm.TransactionProcessing; @@ -29,7 +30,8 @@ public class TraceModuleFactory( IReceiptStorage receiptFinder, ISpecProvider specProvider, IPoSSwitcher poSSwitcher, - ILogManager logManager) : ModuleFactoryBase + ILogManager logManager, + IPrecompileChecker precompileChecker) : ModuleFactoryBase { protected readonly IReadOnlyBlockTree _blockTree = blockTree.AsReadOnly(); protected readonly IJsonRpcConfig _jsonRpcConfig = jsonRpcConfig ?? throw new ArgumentNullException(nameof(jsonRpcConfig)); @@ -41,8 +43,9 @@ public class TraceModuleFactory( protected readonly IBlockPreprocessorStep _recoveryStep = recoveryStep ?? throw new ArgumentNullException(nameof(recoveryStep)); protected readonly IRewardCalculatorSource _rewardCalculatorSource = rewardCalculatorSource ?? throw new ArgumentNullException(nameof(rewardCalculatorSource)); protected readonly IPoSSwitcher _poSSwitcher = poSSwitcher ?? throw new ArgumentNullException(nameof(poSSwitcher)); + protected readonly IPrecompileChecker _precompileChecker = precompileChecker ?? throw new ArgumentNullException(nameof(precompileChecker)); - protected virtual OverridableTxProcessingEnv CreateTxProcessingEnv(IOverridableWorldScope worldScope) => new(worldScope, _blockTree, _specProvider, _logManager); + protected virtual OverridableTxProcessingEnv CreateTxProcessingEnv(IOverridableWorldScope worldScope) => new(worldScope, _blockTree, _specProvider, _logManager, _precompileChecker); protected virtual ReadOnlyChainProcessingEnv CreateChainProcessingEnv(IOverridableWorldScope worldScope, IBlockProcessor.IBlockTransactionsExecutor transactionsExecutor, IReadOnlyTxProcessingScope scope, IRewardCalculator rewardCalculator) => new( scope, diff --git a/src/Nethermind/Nethermind.Network.Benchmark/Eth62ProtocolHandlerBenchmarks.cs b/src/Nethermind/Nethermind.Network.Benchmark/Eth62ProtocolHandlerBenchmarks.cs index 4d3657c3216..64884f52373 100644 --- a/src/Nethermind/Nethermind.Network.Benchmark/Eth62ProtocolHandlerBenchmarks.cs +++ b/src/Nethermind/Nethermind.Network.Benchmark/Eth62ProtocolHandlerBenchmarks.cs @@ -61,7 +61,7 @@ public void SetUp() TxPool.TxPool txPool = new TxPool.TxPool( ecdsa, new BlobTxStorage(), - new ChainHeadInfoProvider(new FixedForkActivationChainHeadSpecProvider(MainnetSpecProvider.Instance), tree, stateProvider, new CodeInfoRepository()), + new ChainHeadInfoProvider(new FixedForkActivationChainHeadSpecProvider(MainnetSpecProvider.Instance), tree, stateProvider, new CodeInfoRepository(new EthereumPrecompileChecker())), new TxPoolConfig(), new TxValidator(TestBlockchainIds.ChainId), LimboLogs.Instance, diff --git a/src/Nethermind/Nethermind.Optimism/OptimismOverridableTxProcessingEnv.cs b/src/Nethermind/Nethermind.Optimism/OptimismOverridableTxProcessingEnv.cs index f40c0795c7f..dba95152ef8 100644 --- a/src/Nethermind/Nethermind.Optimism/OptimismOverridableTxProcessingEnv.cs +++ b/src/Nethermind/Nethermind.Optimism/OptimismOverridableTxProcessingEnv.cs @@ -4,6 +4,7 @@ using System; using Nethermind.Blockchain; using Nethermind.Consensus.Processing; +using Nethermind.Core; using Nethermind.Core.Specs; using Nethermind.Evm; using Nethermind.Evm.TransactionProcessing; @@ -18,15 +19,16 @@ public class OptimismOverridableTxProcessingEnv( ISpecProvider specProvider, ILogManager logManager, ICostHelper costHelper, - IOptimismSpecHelper opSpecHelper) - : OverridableTxProcessingEnv(worldStateManager, readOnlyBlockTree, specProvider, logManager) + IOptimismSpecHelper opSpecHelper, + IPrecompileChecker precompileChecker) + : OverridableTxProcessingEnv(worldStateManager, readOnlyBlockTree, specProvider, logManager, precompileChecker) { protected override ITransactionProcessor CreateTransactionProcessor() { ArgumentNullException.ThrowIfNull(LogManager); BlockhashProvider blockhashProvider = new(BlockTree, SpecProvider, StateProvider, LogManager); - VirtualMachine virtualMachine = new(blockhashProvider, SpecProvider, LogManager); + VirtualMachine virtualMachine = new(blockhashProvider, SpecProvider, LogManager, PrecompileChecker); return new OptimismTransactionProcessor(SpecProvider, StateProvider, virtualMachine, LogManager, costHelper, opSpecHelper, CodeInfoRepository); } } diff --git a/src/Nethermind/Nethermind.Optimism/Rpc/OptimismTraceModuleFactory.cs b/src/Nethermind/Nethermind.Optimism/Rpc/OptimismTraceModuleFactory.cs index 56c0c6b56bf..886de130779 100644 --- a/src/Nethermind/Nethermind.Optimism/Rpc/OptimismTraceModuleFactory.cs +++ b/src/Nethermind/Nethermind.Optimism/Rpc/OptimismTraceModuleFactory.cs @@ -8,6 +8,7 @@ using Nethermind.Consensus.Rewards; using Nethermind.Consensus.Validators; using Nethermind.Consensus.Withdrawals; +using Nethermind.Core; using Nethermind.Core.Specs; using Nethermind.Evm.TransactionProcessing; using Nethermind.JsonRpc; @@ -33,7 +34,8 @@ public class OptimismTraceModuleFactory( ICostHelper costHelper, IOptimismSpecHelper opSpecHelper, Create2DeployerContractRewriter contractRewriter, - IWithdrawalProcessor withdrawalProcessor) : TraceModuleFactory( + IWithdrawalProcessor withdrawalProcessor, + IPrecompileChecker precompileChecker) : TraceModuleFactory( worldStateManager, blockTree, jsonRpcConfig, @@ -44,10 +46,11 @@ public class OptimismTraceModuleFactory( receiptFinder, specProvider, poSSwitcher, - logManager) + logManager, + precompileChecker) { protected override OverridableTxProcessingEnv CreateTxProcessingEnv(IOverridableWorldScope worldStateManager) => - new OptimismOverridableTxProcessingEnv(worldStateManager, _blockTree, _specProvider, _logManager, costHelper, opSpecHelper); + new OptimismOverridableTxProcessingEnv(worldStateManager, _blockTree, _specProvider, _logManager, costHelper, opSpecHelper, _precompileChecker); protected override ReadOnlyChainProcessingEnv CreateChainProcessingEnv(IOverridableWorldScope worldStateManager, IBlockProcessor.IBlockTransactionsExecutor transactionsExecutor, IReadOnlyTxProcessingScope scope, IRewardCalculator rewardCalculator) => new OptimismReadOnlyChainProcessingEnv( scope, diff --git a/src/Nethermind/Nethermind.Optimism/Rpc/RegisterOptimismRpcModules.cs b/src/Nethermind/Nethermind.Optimism/Rpc/RegisterOptimismRpcModules.cs index ee686145a5d..fb3f38b613a 100644 --- a/src/Nethermind/Nethermind.Optimism/Rpc/RegisterOptimismRpcModules.cs +++ b/src/Nethermind/Nethermind.Optimism/Rpc/RegisterOptimismRpcModules.cs @@ -8,7 +8,6 @@ using Nethermind.Consensus; using Nethermind.Consensus.Withdrawals; using Nethermind.Init.Steps; -using Nethermind.JsonRpc; using Nethermind.JsonRpc.Client; using Nethermind.JsonRpc.Modules; using Nethermind.JsonRpc.Modules.Eth.FeeHistory; @@ -121,7 +120,8 @@ protected override void RegisterTraceRpcModule(IRpcModuleProvider rpcModuleProvi _api.L1CostHelper, _api.SpecHelper, new Create2DeployerContractRewriter(_api.SpecHelper, _api.SpecProvider, _api.BlockTree), - new BlockProductionWithdrawalProcessor(new NullWithdrawalProcessor())); + new BlockProductionWithdrawalProcessor(new NullWithdrawalProcessor()), + _api.PrecompileChecker); rpcModuleProvider.RegisterBoundedByCpuCount(traceModuleFactory, JsonRpcConfig.Timeout); } diff --git a/src/Nethermind/Nethermind.Shutter.Test/ShutterApiSimulator.cs b/src/Nethermind/Nethermind.Shutter.Test/ShutterApiSimulator.cs index d541d337603..950acafa966 100644 --- a/src/Nethermind/Nethermind.Shutter.Test/ShutterApiSimulator.cs +++ b/src/Nethermind/Nethermind.Shutter.Test/ShutterApiSimulator.cs @@ -40,9 +40,10 @@ public class ShutterApiSimulator( IKeyStoreConfig keyStoreConfig, IShutterConfig cfg, ShutterValidatorsInfo validatorsInfo, - Random rnd + Random rnd, + IPrecompileChecker precompileChecker ) : ShutterApi(abiEncoder, blockTree, ecdsa, logFinder, receiptStorage, - logManager, specProvider, timestamper, new ReadOnlyTxProcessingEnvFactory(worldStateManager, blockTree, specProvider, logManager), fileSystem, + logManager, specProvider, timestamper, new ReadOnlyTxProcessingEnvFactory(worldStateManager, blockTree, specProvider, logManager, precompileChecker), fileSystem, keyStoreConfig, cfg, validatorsInfo, ShutterTestsCommon.SlotLength, IPAddress.None) { public int EonUpdateCalled = 0; diff --git a/src/Nethermind/Nethermind.Shutter.Test/ShutterTestsCommon.cs b/src/Nethermind/Nethermind.Shutter.Test/ShutterTestsCommon.cs index db3599238e9..8c55665d989 100644 --- a/src/Nethermind/Nethermind.Shutter.Test/ShutterTestsCommon.cs +++ b/src/Nethermind/Nethermind.Shutter.Test/ShutterTestsCommon.cs @@ -57,7 +57,7 @@ public static ShutterApiSimulator InitApi(Random rnd, ITimestamper? timestamper AbiEncoder, blockTree, Ecdsa, logFinder, receiptStorage, LogManager, SpecProvider, timestamper ?? Substitute.For(), worldStateManager, Substitute.For(), - Substitute.For(), Cfg, new(), rnd + Substitute.For(), Cfg, new(), rnd, Substitute.For() ); } @@ -66,7 +66,7 @@ public static ShutterApiSimulator InitApi(Random rnd, BaseEngineModuleTests.Merg eventSimulator ?? InitEventSimulator(rnd), AbiEncoder, chain.BlockTree.AsReadOnly(), chain.EthereumEcdsa, chain.LogFinder, chain.ReceiptStorage, chain.LogManager, chain.SpecProvider, timestamper ?? chain.Timestamper, chain.WorldStateManager, - Substitute.For(), Substitute.For(), Cfg, new(), rnd + Substitute.For(), Substitute.For(), Cfg, new(), rnd, Substitute.For() ); public static ShutterEventSimulator InitEventSimulator(Random rnd) diff --git a/src/Nethermind/Nethermind.Taiko.Test/TransactionProcessorTests.cs b/src/Nethermind/Nethermind.Taiko.Test/TransactionProcessorTests.cs index 8c51dd0c9ed..239de4af9b0 100644 --- a/src/Nethermind/Nethermind.Taiko.Test/TransactionProcessorTests.cs +++ b/src/Nethermind/Nethermind.Taiko.Test/TransactionProcessorTests.cs @@ -7,16 +7,15 @@ using Nethermind.Specs; using Nethermind.Core.Test.Builders; using Nethermind.Crypto; -using Nethermind.Db; using Nethermind.Int256; using Nethermind.Evm.Tracing; using Nethermind.Logging; using Nethermind.State; -using Nethermind.Trie.Pruning; using NUnit.Framework; using System.Collections; using Nethermind.Core.Test; using Nethermind.Evm; +using Nethermind.Evm.Precompiles; using Nethermind.Evm.Test; using Nethermind.Taiko.TaikoSpec; @@ -29,6 +28,7 @@ public class TransactionProcessorTests private readonly IEthereumEcdsa _ethereumEcdsa; private TaikoTransactionProcessor? _transactionProcessor; private IWorldState? _stateProvider; + private IPrecompileChecker? _precompileChecker; public TransactionProcessorTests() { @@ -49,9 +49,10 @@ public void Setup() _stateProvider.CreateAccount(TestItem.AddressA, AccountBalance); _stateProvider.Commit(_specProvider.GenesisSpec); _stateProvider.CommitTree(0); + _precompileChecker = TestPrecompiles.Ethereum; - CodeInfoRepository codeInfoRepository = new(); - VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance); + CodeInfoRepository codeInfoRepository = new(_precompileChecker); + VirtualMachine virtualMachine = new(new TestBlockhashProvider(_specProvider), _specProvider, LimboLogs.Instance, _precompileChecker); _transactionProcessor = new TaikoTransactionProcessor(_specProvider, _stateProvider, virtualMachine, codeInfoRepository, LimboLogs.Instance); } diff --git a/src/Nethermind/Nethermind.Taiko/Rpc/RegisterTaikoRpcModules.cs b/src/Nethermind/Nethermind.Taiko/Rpc/RegisterTaikoRpcModules.cs index 5162bdcb1a0..b5dd2ec57c0 100644 --- a/src/Nethermind/Nethermind.Taiko/Rpc/RegisterTaikoRpcModules.cs +++ b/src/Nethermind/Nethermind.Taiko/Rpc/RegisterTaikoRpcModules.cs @@ -113,7 +113,8 @@ protected override void RegisterTraceRpcModule(IRpcModuleProvider rpcModuleProvi _api.ReceiptStorage, _api.SpecProvider, _poSSwitcher, - _api.LogManager); + _api.LogManager, + _api.PrecompileChecker); rpcModuleProvider.RegisterBoundedByCpuCount(traceModuleFactory, JsonRpcConfig.Timeout); } @@ -148,7 +149,8 @@ protected override void RegisterDebugRpcModule(IRpcModuleProvider rpcModuleProvi _api.SyncModeSelector, _api.BadBlocksStore, _api.FileSystem, - _api.LogManager); + _api.LogManager, + _api.PrecompileChecker); rpcModuleProvider.RegisterBoundedByCpuCount(debugModuleFactory, JsonRpcConfig.Timeout); } diff --git a/src/Nethermind/Nethermind.Taiko/Rpc/TaikoDebugModuleFactory.cs b/src/Nethermind/Nethermind.Taiko/Rpc/TaikoDebugModuleFactory.cs index 88ccff47c42..9896ae9c9ef 100644 --- a/src/Nethermind/Nethermind.Taiko/Rpc/TaikoDebugModuleFactory.cs +++ b/src/Nethermind/Nethermind.Taiko/Rpc/TaikoDebugModuleFactory.cs @@ -17,6 +17,7 @@ using Nethermind.State; using Nethermind.Synchronization.ParallelSync; using System.IO.Abstractions; +using Nethermind.Core; using Nethermind.Taiko.BlockTransactionExecutors; using Nethermind.Facade; @@ -42,7 +43,8 @@ public TaikoDebugModuleFactory( ISyncModeSelector syncModeSelector, IBadBlockStore badBlockStore, IFileSystem fileSystem, - ILogManager logManager) : base(worldStateManager, dbProvider, blockTree, jsonRpcConfig, blockchainBridge, secondsPerSlot, blockValidator, recoveryStep, rewardCalculator, receiptStorage, receiptsMigration, configProvider, specProvider, syncModeSelector, badBlockStore, fileSystem, logManager) + ILogManager logManager, + IPrecompileChecker precompileChecker) : base(worldStateManager, dbProvider, blockTree, jsonRpcConfig, blockchainBridge, secondsPerSlot, blockValidator, recoveryStep, rewardCalculator, receiptStorage, receiptsMigration, configProvider, specProvider, syncModeSelector, badBlockStore, fileSystem, logManager, precompileChecker) { } diff --git a/src/Nethermind/Nethermind.Taiko/Rpc/TaikoTraceModuleFactory.cs b/src/Nethermind/Nethermind.Taiko/Rpc/TaikoTraceModuleFactory.cs index 0abf778c619..1631496ca7e 100644 --- a/src/Nethermind/Nethermind.Taiko/Rpc/TaikoTraceModuleFactory.cs +++ b/src/Nethermind/Nethermind.Taiko/Rpc/TaikoTraceModuleFactory.cs @@ -6,6 +6,7 @@ using Nethermind.Consensus; using Nethermind.Consensus.Processing; using Nethermind.Consensus.Rewards; +using Nethermind.Core; using Nethermind.Core.Specs; using Nethermind.Evm.TransactionProcessing; using Nethermind.JsonRpc; @@ -21,11 +22,11 @@ class TaikoTraceModuleFactory( IWorldStateManager worldStateManager, IBlockTree blockTree, IJsonRpcConfig jsonRpcConfig, IBlockchainBridge blockchainBridge, ulong secondsPerSlot, IBlockPreprocessorStep recoveryStep, IRewardCalculatorSource rewardCalculatorSource, IReceiptStorage receiptFinder, - ISpecProvider specProvider, IPoSSwitcher poSSwitcher, ILogManager logManager) : - TraceModuleFactory(worldStateManager, blockTree, jsonRpcConfig, blockchainBridge, secondsPerSlot, recoveryStep, rewardCalculatorSource, receiptFinder, specProvider, poSSwitcher, logManager) + ISpecProvider specProvider, IPoSSwitcher poSSwitcher, ILogManager logManager, IPrecompileChecker precompileChecker) : + TraceModuleFactory(worldStateManager, blockTree, jsonRpcConfig, blockchainBridge, secondsPerSlot, recoveryStep, rewardCalculatorSource, receiptFinder, specProvider, poSSwitcher, logManager, precompileChecker) { protected override OverridableTxProcessingEnv CreateTxProcessingEnv(IOverridableWorldScope worldStateManager) - => new TaikoOverridableTxProcessingEnv(worldStateManager, _blockTree, _specProvider, _logManager); + => new TaikoOverridableTxProcessingEnv(worldStateManager, _blockTree, _specProvider, _logManager, _precompileChecker); protected override IBlockProcessor.IBlockTransactionsExecutor CreateBlockTransactionsExecutor(IReadOnlyTxProcessingScope scope) => new TaikoBlockValidationTransactionExecutor(scope.TransactionProcessor, scope.WorldState); diff --git a/src/Nethermind/Nethermind.Taiko/TaikoOverridableTxProcessingEnv.cs b/src/Nethermind/Nethermind.Taiko/TaikoOverridableTxProcessingEnv.cs index 0a24d772c65..a0b5bc41048 100644 --- a/src/Nethermind/Nethermind.Taiko/TaikoOverridableTxProcessingEnv.cs +++ b/src/Nethermind/Nethermind.Taiko/TaikoOverridableTxProcessingEnv.cs @@ -3,6 +3,7 @@ using Nethermind.Blockchain; using Nethermind.Consensus.Processing; +using Nethermind.Core; using Nethermind.Core.Specs; using Nethermind.Evm.TransactionProcessing; using Nethermind.Logging; @@ -14,11 +15,13 @@ public class TaikoOverridableTxProcessingEnv( IOverridableWorldScope worldScope, IReadOnlyBlockTree readOnlyBlockTree, ISpecProvider specProvider, - ILogManager logManager) : OverridableTxProcessingEnv( + ILogManager logManager, + IPrecompileChecker precompileChecker) : OverridableTxProcessingEnv( worldScope, readOnlyBlockTree, specProvider, - logManager + logManager, + precompileChecker ) { protected override ITransactionProcessor CreateTransactionProcessor() => diff --git a/src/Nethermind/Nethermind.TxPool.Test/DelegatedAccountFilterTest.cs b/src/Nethermind/Nethermind.TxPool.Test/DelegatedAccountFilterTest.cs index 5d19ef79357..87b43d23311 100644 --- a/src/Nethermind/Nethermind.TxPool.Test/DelegatedAccountFilterTest.cs +++ b/src/Nethermind/Nethermind.TxPool.Test/DelegatedAccountFilterTest.cs @@ -19,6 +19,7 @@ using NUnit.Framework; using System.Collections.Generic; using Nethermind.Core.Test; +using Nethermind.Evm.Precompiles; namespace Nethermind.TxPool.Test; internal class DelegatedAccountFilterTest @@ -30,7 +31,7 @@ public void Accept_SenderIsNotDelegated_ReturnsAccepted() headInfoProvider.GetCurrentHeadSpec().Returns(Prague.Instance); TxDistinctSortedPool standardPool = new TxDistinctSortedPool(MemoryAllowance.MemPoolSize, Substitute.For>(), NullLogManager.Instance); TxDistinctSortedPool blobPool = new BlobTxDistinctSortedPool(10, Substitute.For>(), NullLogManager.Instance); - DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, Substitute.For(), new CodeInfoRepository(), new DelegationCache()); + DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, Substitute.For(), new CodeInfoRepository(TestPrecompiles.Ethereum), new DelegationCache()); Transaction transaction = Build.A.Transaction.SignedAndResolved(new EthereumEcdsa(0), TestItem.PrivateKeyA).TestObject; TxFilteringState state = new(transaction, Substitute.For()); @@ -45,7 +46,7 @@ public void Accept_SenderIsDelegatedWithNoTransactionsInPool_ReturnsAccepted() IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); IWorldState stateProvider = worldStateManager.GlobalWorldState; stateProvider.CreateAccount(TestItem.AddressA, 0); - CodeInfoRepository codeInfoRepository = new(); + CodeInfoRepository codeInfoRepository = new CodeInfoRepository(TestPrecompiles.Ethereum); byte[] code = [.. Eip7702Constants.DelegationHeader, .. TestItem.PrivateKeyA.Address.Bytes]; codeInfoRepository.InsertCode(stateProvider, code, TestItem.AddressA, Prague.Instance); IChainHeadSpecProvider headInfoProvider = Substitute.For(); @@ -73,7 +74,7 @@ public void Accept_SenderIsDelegatedWithOneTransactionInPoolWithSameNonce_Return IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); IWorldState stateProvider = worldStateManager.GlobalWorldState; stateProvider.CreateAccount(TestItem.AddressA, 0); - CodeInfoRepository codeInfoRepository = new(); + CodeInfoRepository codeInfoRepository = new CodeInfoRepository(TestPrecompiles.Ethereum); byte[] code = [.. Eip7702Constants.DelegationHeader, .. TestItem.PrivateKeyA.Address.Bytes]; codeInfoRepository.InsertCode(stateProvider, code, TestItem.AddressA, Prague.Instance); DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, stateProvider, codeInfoRepository, new DelegationCache()); @@ -97,7 +98,7 @@ public void Accept_SenderIsDelegatedWithOneTransactionInPoolWithDifferentNonce_R IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); IWorldState stateProvider = worldStateManager.GlobalWorldState; stateProvider.CreateAccount(TestItem.AddressA, 0); - CodeInfoRepository codeInfoRepository = new(); + CodeInfoRepository codeInfoRepository = new CodeInfoRepository(TestPrecompiles.Ethereum); byte[] code = [.. Eip7702Constants.DelegationHeader, .. TestItem.PrivateKeyA.Address.Bytes]; codeInfoRepository.InsertCode(stateProvider, code, TestItem.AddressA, Prague.Instance); DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, stateProvider, codeInfoRepository, new DelegationCache()); @@ -126,7 +127,7 @@ public void Accept_Eip7702IsNotActivated_ReturnsExpected(bool isActive, AcceptTx IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); IWorldState stateProvider = worldStateManager.GlobalWorldState; stateProvider.CreateAccount(TestItem.AddressA, 0); - CodeInfoRepository codeInfoRepository = new(); + CodeInfoRepository codeInfoRepository = new CodeInfoRepository(TestPrecompiles.Ethereum); byte[] code = [.. Eip7702Constants.DelegationHeader, .. TestItem.PrivateKeyA.Address.Bytes]; codeInfoRepository.InsertCode(stateProvider, code, TestItem.AddressA, Prague.Instance); DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, stateProvider, codeInfoRepository, new DelegationCache()); @@ -154,7 +155,7 @@ public void Accept_SenderHasPendingDelegation_OnlyAcceptsIfNonceIsExactMatch(int TxDistinctSortedPool blobPool = new BlobTxDistinctSortedPool(10, Substitute.For>(), NullLogManager.Instance); DelegationCache pendingDelegations = new(); pendingDelegations.IncrementDelegationCount(TestItem.AddressA); - DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, Substitute.For(), new CodeInfoRepository(), pendingDelegations); + DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, Substitute.For(), new CodeInfoRepository(TestPrecompiles.Ethereum), pendingDelegations); Transaction transaction = Build.A.Transaction.WithNonce((UInt256)nonce).SignedAndResolved(new EthereumEcdsa(0), TestItem.PrivateKeyA).TestObject; IWorldStateManager worldStateManager = TestWorldStateFactory.CreateForTest(); IWorldState stateProvider = worldStateManager.GlobalWorldState; @@ -174,7 +175,7 @@ public void Accept_AuthorityHasPendingTransaction_ReturnsDelegatorHasPendingTx(b headInfoProvider.GetCurrentHeadSpec().Returns(Prague.Instance); TxDistinctSortedPool standardPool = new TxDistinctSortedPool(MemoryAllowance.MemPoolSize, Substitute.For>(), NullLogManager.Instance); TxDistinctSortedPool blobPool = new BlobTxDistinctSortedPool(10, Substitute.For>(), NullLogManager.Instance); - DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, Substitute.For(), new CodeInfoRepository(), new()); + DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, Substitute.For(), new CodeInfoRepository(TestPrecompiles.Ethereum), new()); Transaction transaction; if (useBlobPool) { @@ -215,7 +216,7 @@ public void Accept_SetCodeTxHasAuthorityWithPendingTx_ReturnsDelegatorHasPending TxDistinctSortedPool blobPool = new BlobTxDistinctSortedPool(10, Substitute.For>(), NullLogManager.Instance); DelegationCache pendingDelegations = new(); pendingDelegations.IncrementDelegationCount(TestItem.AddressA); - DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, Substitute.For(), new CodeInfoRepository(), pendingDelegations); + DelegatedAccountFilter filter = new(headInfoProvider, standardPool, blobPool, Substitute.For(), new CodeInfoRepository(TestPrecompiles.Ethereum), pendingDelegations); Transaction transaction = Build.A.Transaction .WithNonce(1) .SignedAndResolved(new EthereumEcdsa(0), TestItem.PrivateKeyA).TestObject; diff --git a/src/Nethermind/Nethermind.TxPool.Test/NonceManagerTests.cs b/src/Nethermind/Nethermind.TxPool.Test/NonceManagerTests.cs index af6b329e956..f81b752c829 100644 --- a/src/Nethermind/Nethermind.TxPool.Test/NonceManagerTests.cs +++ b/src/Nethermind/Nethermind.TxPool.Test/NonceManagerTests.cs @@ -13,6 +13,7 @@ using Nethermind.Core.Test.Builders; using Nethermind.Db; using Nethermind.Evm; +using Nethermind.Evm.Precompiles; using Nethermind.Int256; using Nethermind.Logging; using Nethermind.Specs; @@ -42,7 +43,7 @@ public void Setup() _blockTree.Head.Returns(block); _blockTree.FindBestSuggestedHeader().Returns(Build.A.BlockHeader.WithNumber(10000000).TestObject); - _headInfo = new ChainHeadInfoProvider(_specProvider, _blockTree, _stateProvider, new CodeInfoRepository()); + _headInfo = new ChainHeadInfoProvider(_specProvider, _blockTree, _stateProvider, new CodeInfoRepository(TestPrecompiles.Ethereum)); _nonceManager = new NonceManager(_headInfo.ReadOnlyStateProvider); } diff --git a/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.Blobs.cs b/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.Blobs.cs index 2ee239c31bf..03bf44cdc94 100644 --- a/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.Blobs.cs +++ b/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.Blobs.cs @@ -26,6 +26,7 @@ using System.Collections; using System.Collections.Generic; using System.Threading.Tasks; +using Nethermind.Evm.Precompiles; namespace Nethermind.TxPool.Test { @@ -465,7 +466,7 @@ public void should_allow_to_replace_blob_tx_by_the_one_with_network_wrapper_in_h IChainHeadSpecProvider specProvider = Substitute.For(); specProvider.GetCurrentHeadSpec().Returns(releaseSpec); - ChainHeadInfoProvider chainHeadInfoProvider = new(specProvider, _blockTree, _stateProvider, new CodeInfoRepository()); + ChainHeadInfoProvider chainHeadInfoProvider = new(specProvider, _blockTree, _stateProvider, new CodeInfoRepository(new EthereumPrecompileChecker())); _txPool = CreatePool(new TxPoolConfig() { BlobsSupport = BlobsSupportMode.InMemory, Size = 128 }, specProvider: specProvider, chainHeadInfoProvider: chainHeadInfoProvider); diff --git a/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.cs b/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.cs index c951e5aa530..03c992a331d 100644 --- a/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.cs +++ b/src/Nethermind/Nethermind.TxPool.Test/TxPoolTests.cs @@ -23,6 +23,7 @@ using Nethermind.Crypto; using Nethermind.Db; using Nethermind.Evm; +using Nethermind.Evm.Precompiles; using Nethermind.Int256; using Nethermind.Logging; using Nethermind.Specs; @@ -2195,7 +2196,7 @@ private TxPool CreatePool( txStorage ??= new BlobTxStorage(); _headInfo = chainHeadInfoProvider; - _headInfo ??= new ChainHeadInfoProvider(specProvider, _blockTree, _stateProvider, new CodeInfoRepository()); + _headInfo ??= new ChainHeadInfoProvider(specProvider, _blockTree, _stateProvider, new CodeInfoRepository(TestPrecompiles.Ethereum)); return new TxPool( _ethereumEcdsa,