Precompiles Extensibility through IReleaseSpec

src/Nethermind/Nethermind.Core.Test/AddressTests.cs

@@ -12,7 +12,6 @@
 using Nethermind.Core.Test.Builders;
 using Nethermind.Int256;
 using Nethermind.Evm;
-using Nethermind.Evm.Precompiles;
 using NUnit.Framework;
 
 namespace Nethermind.Core.Test;
@@ -120,7 +119,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(Frontier.Instance.IsPrecompile(address), Is.True);
     }
 
     [Test]
@@ -129,7 +128,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(Frontier.Instance.IsPrecompile(address), Is.True);
     }
 
     [Test]
@@ -138,7 +137,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(Frontier.Instance.IsPrecompile(address), Is.False);
     }
 
     [Test]
@@ -147,7 +146,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(Byzantium.Instance.IsPrecompile(address), Is.True);
     }
 
     [Test]
@@ -156,7 +155,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(Byzantium.Instance.IsPrecompile(address), Is.False);
     }
 
     [TestCase(0, false)]
@@ -165,7 +164,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(Byzantium.Instance.IsPrecompile(address), Is.EqualTo(isPrecompile));
     }
 
     [TestCase(0, "0x24cd2edba056b7c654a50e8201b619d4f624fdda")]
@@ -178,7 +177,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);
+        spec.IsPrecompile(Address.FromNumber(0x0a));
 
     [TestCase(Address.SystemUserHex, false)]
     [TestCase("2" + Address.SystemUserHex, false)]

src/Nethermind/Nethermind.Core/Precompiles/PrecompiledAddresses.cs

@@ -0,0 +1,29 @@
+// SPDX-FileCopyrightText: 2025 Demerzel Solutions Limited
+// SPDX-License-Identifier: LGPL-3.0-only
+
+namespace Nethermind.Core.Precompiles;
+
+/// <summary>
+/// Contains static references to all known Ethereum precompile addresses.
+/// </summary>
+public static class PrecompiledAddresses
+{
+    public static readonly AddressAsKey EcRecover = Address.FromNumber(0x01);
+    public static readonly AddressAsKey Sha256 = Address.FromNumber(0x02);
+    public static readonly AddressAsKey Ripemd160 = Address.FromNumber(0x03);
+    public static readonly AddressAsKey Identity = Address.FromNumber(0x04);
+    public static readonly AddressAsKey ModExp = Address.FromNumber(0x05);
+    public static readonly AddressAsKey Bn128Add = Address.FromNumber(0x06);
+    public static readonly AddressAsKey Bn128Mul = Address.FromNumber(0x07);
+    public static readonly AddressAsKey Bn128Pairing = Address.FromNumber(0x08);
+    public static readonly AddressAsKey Blake2F = Address.FromNumber(0x09);
+    public static readonly AddressAsKey PointEvaluation = Address.FromNumber(0x0a);
+    public static readonly AddressAsKey Bls12G1Add = Address.FromNumber(0x0b);
+    public static readonly AddressAsKey Bls12G1Mul = Address.FromNumber(0x0c);
+    public static readonly AddressAsKey Bls12G1MultiExp = Address.FromNumber(0x0d);
+    public static readonly AddressAsKey Bls12G2Add = Address.FromNumber(0x0e);
+    public static readonly AddressAsKey Bls12G2Mul = Address.FromNumber(0x0f);
+    public static readonly AddressAsKey Bls12G2MultiExp = Address.FromNumber(0x10);
+    public static readonly AddressAsKey Bls12Pairing = Address.FromNumber(0x11);
+    public static readonly AddressAsKey P256Verify = Address.FromNumber(0x0100);
+}

src/Nethermind/Nethermind.Core/Specs/IReleaseSpec.cs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
 using System;
+using System.Collections.Generic;
 using Nethermind.Int256;
 
 namespace Nethermind.Core.Specs
@@ -363,6 +364,19 @@ public interface IReleaseSpec : IEip1559Spec, IReceiptSpec
         /// </summary>
         bool IsEip7883Enabled { get; }
 
+        /// <summary>
+        /// Determines whether the specified address is a precompiled contract for this release specification.
+        /// </summary>
+        /// <param name="address">The address to check for precompile status.</param>
+        /// <returns>True if the address is a precompiled contract; otherwise, false.</returns>
+        bool IsPrecompile(Address address) => Precompiles.Contains(address);
+
+        /// <summary>
+        /// Gets a cached set of all precompiled contract addresses for this release specification.
+        /// Chain-specific implementations can override this to include their own precompiled contracts.
+        /// </summary>
+        HashSet<AddressAsKey> Precompiles { get; }
+
         /// <summary>
         /// Should transactions be validated against chainId.
         /// </summary>

src/Nethermind/Nethermind.Core/Specs/ReleaseSpecDecorator.cs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: LGPL-3.0-only
 
 using System;
+using System.Collections.Generic;
 using Nethermind.Int256;
 
 namespace Nethermind.Core.Specs;
@@ -147,4 +148,5 @@ public class ReleaseSpecDecorator(IReleaseSpec spec) : IReleaseSpec
     Array? IReleaseSpec.EvmInstructionsNoTrace { get => spec.EvmInstructionsNoTrace; set => spec.EvmInstructionsNoTrace = value; }
     Array? IReleaseSpec.EvmInstructionsTraced { get => spec.EvmInstructionsTraced; set => spec.EvmInstructionsTraced = value; }
     public bool IsEip7939Enabled => spec.IsEip7939Enabled;
+    HashSet<AddressAsKey> IReleaseSpec.Precompiles => spec.Precompiles;
 }

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(Spec.IsPrecompile(precompileAddress), 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(Spec.IsPrecompile(precompileAddress), Is.True);
 
         TestState.CreateAccount(precompileAddress, 1.Wei());
 

src/Nethermind/Nethermind.Evm.Test/Eip152Tests.cs

@@ -28,7 +28,7 @@ public void before_istanbul()
     {
         _blockNumberAdjustment = -1;
         Address precompileAddress = Blake2FPrecompile.Address;
-        Assert.That(precompileAddress.IsPrecompile(Spec), Is.False);
+        Assert.That(Spec.IsPrecompile(precompileAddress), Is.False);
     }
 
     [Test]

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(Spec.IsPrecompile(G1AddPrecompile.Address), Is.False);
     }
 
     [Test]
     public void Test_g1_add_after_prague()
     {
-        Assert.That(G1AddPrecompile.Address.IsPrecompile(Spec), Is.True);
+        Assert.That(Spec.IsPrecompile(G1AddPrecompile.Address), 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(Spec.IsPrecompile(G2AddPrecompile.Address), Is.False);
     }
 
     [Test]
     public void Test_g2_add_after_prague()
     {
-        Assert.That(G2AddPrecompile.Address.IsPrecompile(Spec), Is.True);
+        Assert.That(Spec.IsPrecompile(G2AddPrecompile.Address), 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(Spec.IsPrecompile(G1MSMPrecompile.Address), Is.False);
     }
 
     [Test]
     public void Test_g1_msm_after_prague()
     {
-        Assert.That(G1MSMPrecompile.Address.IsPrecompile(Spec), Is.True);
+        Assert.That(Spec.IsPrecompile(G1MSMPrecompile.Address), 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(Spec.IsPrecompile(G2MSMPrecompile.Address), Is.False);
     }
 
     [Test]
     public void Test_g2_msm_after_prague()
     {
-        Assert.That(G2MSMPrecompile.Address.IsPrecompile(Spec), Is.True);
+        Assert.That(Spec.IsPrecompile(G2MSMPrecompile.Address), 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(Spec.IsPrecompile(PairingCheckPrecompile.Address), Is.False);
     }
 
     [Test]
     public void Test_pairing_check_after_prague()
     {
-        Assert.That(PairingCheckPrecompile.Address.IsPrecompile(Spec), Is.True);
+        Assert.That(Spec.IsPrecompile(PairingCheckPrecompile.Address), 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(Spec.IsPrecompile(MapFpToG1Precompile.Address), Is.False);
     }
 
     [Test]
     public void Test_map_fp_to_g1_after_prague()
     {
-        Assert.That(MapFpToG1Precompile.Address.IsPrecompile(Spec), Is.True);
+        Assert.That(Spec.IsPrecompile(MapFpToG1Precompile.Address), 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(Spec.IsPrecompile(MapFp2ToG2Precompile.Address), Is.False);
     }
 
     [Test]
     public void Test_map_fp2_to_g2_after_prague()
     {
-        Assert.That(MapFp2ToG2Precompile.Address.IsPrecompile(Spec), Is.True);
+        Assert.That(Spec.IsPrecompile(MapFp2ToG2Precompile.Address), Is.True);
 
         byte[] code = Prepare.EvmCode
             .CallWithInput(MapFp2ToG2Precompile.Address, 100000L, new byte[128])

src/Nethermind/Nethermind.Evm.Test/VirtualMachineTestsBase.cs

@@ -18,7 +18,6 @@
 using Nethermind.Evm.TransactionProcessing;
 using Nethermind.Logging;
 using Nethermind.State;
-using Nethermind.Trie.Pruning;
 using NUnit.Framework;
 
 namespace Nethermind.Evm.Test;

src/Nethermind/Nethermind.Evm/CodeInfoRepository.cs

@@ -67,7 +67,7 @@ public CodeInfoRepository(ConcurrentDictionary<PreBlockCaches.PrecompileCacheKey
     public ICodeInfo GetCachedCodeInfo(IWorldState worldState, Address codeSource, bool followDelegation, IReleaseSpec vmSpec, out Address? delegationAddress)
     {
         delegationAddress = null;
-        if (codeSource.IsPrecompile(vmSpec))
+        if (vmSpec.IsPrecompile(codeSource))
         {
             return _localPrecompiles[codeSource];
         }
@@ -271,4 +271,3 @@ public bool TryGet(in ValueHash256 codeHash, [NotNullWhen(true)] out ICodeInfo?
         }
     }
 }
-

src/Nethermind/Nethermind.Evm/Instructions/EvmInstructions.cs

@@ -8,7 +8,6 @@
 namespace Nethermind.Evm;
 using unsafe OpCode = delegate*<VirtualMachineBase, ref EvmStack, ref long, ref int, EvmExceptionType>;
 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) && !spec.IsPrecompile(address))
             {
                 result = UpdateGas(GasCostOf.ColdAccountAccess, ref gasAvailable);
                 vmState.AccessTracker.WarmUp(address);

src/Nethermind/Nethermind.Evm/Tracing/GethStyle/Custom/JavaScript/Engine.cs

@@ -13,7 +13,6 @@
 using Nethermind.Core.Caching;
 using Nethermind.Core.Extensions;
 using Nethermind.Core.Specs;
-using Nethermind.Evm.Precompiles;
 using Nethermind.Logging;
 #pragma warning disable CS0162 // Unreachable code detected
 
@@ -126,7 +125,7 @@ public Engine(IReleaseSpec spec)
     /// <summary>
     /// Checks if contract at given address is a precompile
     /// </summary>
-    private bool IsPrecompiled(object address) => address.ToAddress().IsPrecompile(_spec);
+    private bool IsPrecompiled(object address) => _spec.IsPrecompile(address.ToAddress());
 
     /// <summary>
     /// Returns a slice of input