AddressExtensions.IsPrecompiles - Extensibility

src/Nethermind/Nethermind.Api/IBasicApi.cs

@@ -53,6 +53,7 @@ public interface IBasicApi
 
         [SkipServiceCollection]
         ILifetimeScope Context { get; }
+        IPrecompileChecker PrecompileChecker { get; }
 
         public IConsensusPlugin? GetConsensusPlugin() =>
             Plugins

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<IMiningConfig>();
@@ -205,7 +207,7 @@ public virtual IBlockchainBridge CreateBlockchainBridge()
 
         public ISubscriptionFactory? SubscriptionFactory { get; set; }
         public IProtectedPrivateKey? NodeKey { get; set; }
-
+        public IPrecompileChecker PrecompileChecker => Context.Resolve<IPrecompileChecker>();
         /// <summary>
         /// Key used for signing blocks. Original as its loaded on startup. This can later be changed via RPC in <see cref="Signer"/>.
         /// </summary>

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);

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<TxPriorityContract.Destination>(
                     new TxPriorityContract.DestinationSortedListContractDataStoreCollection(),

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,

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<ValueHash256, UInt256>(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);

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
                 };

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,

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,

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(

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)

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,

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);
     }
 

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,17 +43,19 @@ 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)
         {
         }
 
         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);