Split EVM executor from EvmSpec (#8825)

This PR splits up the EVM executor used in the testing infrastructure into an EvmSpec part which is useful for looking up the precompile contracts belonging to a certain fork. It's also able to get the entire configuration for the EVM at a certain fork by just passing the fork name, which is useful in e.g. BenchmarkSubCommand.

I looked around and couldn't find a way to do this elsewhere. In production we only seem to get the protocol schedule through timestamps or block numbers given a pre-populated set of milestones.
Even in production, at some stage as the number of forks grow, this whole set of milestones might be wasteful at startup since the list of configured hardforks doesn't change after the initial setup and until process restart.

Author: lu-pinto

ethereum/evmtool/src/main/java/org/hyperledger/besu/evmtool/benchmarks/AltBN128Benchmark.java

@@ -14,12 +14,11 @@
  */
 package org.hyperledger.besu.evmtool.benchmarks;
 
+import org.hyperledger.besu.datatypes.Address;
 import org.hyperledger.besu.evm.EvmSpecVersion;
-import org.hyperledger.besu.evm.gascalculator.GasCalculator;
+import org.hyperledger.besu.evm.fluent.EvmSpec;
 import org.hyperledger.besu.evm.precompile.AbstractAltBnPrecompiledContract;
-import org.hyperledger.besu.evm.precompile.AltBN128AddPrecompiledContract;
-import org.hyperledger.besu.evm.precompile.AltBN128MulPrecompiledContract;
-import org.hyperledger.besu.evm.precompile.AltBN128PairingPrecompiledContract;
+import org.hyperledger.besu.evm.precompile.PrecompiledContract;
 
 import java.io.PrintStream;
 import java.util.LinkedHashMap;
@@ -51,17 +50,13 @@ public void runBenchmark(final Boolean attemptNative, final String fork) {
     }
     output.println(
         AbstractAltBnPrecompiledContract.isNative() ? "Native AltBN128" : "Java AltBN128");
-    GasCalculator gasCalculator = gasCalculatorForFork(fork);
 
-    benchmarkAdd(output, gasCalculator, forkVersion);
-    benchmarkMul(output, gasCalculator, forkVersion);
-    benchmarkPairings(output, gasCalculator, forkVersion);
+    benchmarkAdd(output, forkVersion);
+    benchmarkMul(output, forkVersion);
+    benchmarkPairings(output, forkVersion);
   }
 
-  private void benchmarkAdd(
-      final PrintStream output,
-      final GasCalculator gasCalculator,
-      final EvmSpecVersion forkVersion) {
+  private void benchmarkAdd(final PrintStream output, final EvmSpecVersion forkVersion) {
     final Map<String, Bytes> addTestCases = new LinkedHashMap<>();
     addTestCases.put(
         "Add",
@@ -71,10 +66,8 @@ private void benchmarkAdd(
                 + "17c139df0efee0f766bc0204762b774362e4ded88953a39ce849a8a7fa163fa9"
                 + "2e83f8d734803fc370eba25ed1f6b8768bd6d83887b87165fc2434fe11a830cb"));
 
-    AltBN128AddPrecompiledContract addContract =
-        EvmSpecVersion.ISTANBUL.compareTo(forkVersion) < 0
-            ? AltBN128AddPrecompiledContract.byzantium(gasCalculator)
-            : AltBN128AddPrecompiledContract.istanbul(gasCalculator);
+    PrecompiledContract addContract =
+        EvmSpec.evmSpec(forkVersion).getPrecompileContractRegistry().get(Address.ALTBN128_ADD);
     warmIterations = MATH_WARMUP / addTestCases.size();
     execIterations = MATH_ITERATIONS / addTestCases.size();
     double execTime = Double.MIN_VALUE; // a way to dodge divide by zero
@@ -90,10 +83,7 @@ private void benchmarkAdd(
         gasCost, execTime * 1_000_000, gasCost / execTime / 1_000_000);
   }
 
-  private void benchmarkMul(
-      final PrintStream output,
-      final GasCalculator gasCalculator,
-      final EvmSpecVersion forkVersion) {
+  private void benchmarkMul(final PrintStream output, final EvmSpecVersion forkVersion) {
     final Map<String, Bytes> mulTestCases = new LinkedHashMap<>();
     mulTestCases.put(
         "mul",
@@ -103,10 +93,8 @@ private void benchmarkMul(
                 + "17c139df0efee0f766bc0204762b774362e4ded88953a39ce849a8a7fa163fa9"
                 + "2e83f8d734803fc370eba25ed1f6b8768bd6d83887b87165fc2434fe11a830cb"));
 
-    AltBN128MulPrecompiledContract mulContract =
-        EvmSpecVersion.ISTANBUL.compareTo(forkVersion) < 0
-            ? AltBN128MulPrecompiledContract.byzantium(gasCalculator)
-            : AltBN128MulPrecompiledContract.istanbul(gasCalculator);
+    PrecompiledContract mulContract =
+        EvmSpec.evmSpec(forkVersion).getPrecompileContractRegistry().get(Address.ALTBN128_MUL);
     warmIterations = MATH_WARMUP / mulTestCases.size();
     execIterations = MATH_ITERATIONS / mulTestCases.size();
     double execTime = Double.MIN_VALUE; // a way to dodge divide by zero
@@ -122,10 +110,7 @@ private void benchmarkMul(
         gasCost, execTime * 1_000_000, gasCost / execTime / 1_000_000);
   }
 
-  private void benchmarkPairings(
-      final PrintStream output,
-      final GasCalculator gasCalculator,
-      final EvmSpecVersion forkVersion) {
+  private void benchmarkPairings(final PrintStream output, final EvmSpecVersion forkVersion) {
     final Bytes[] pairings = {
       Bytes.fromHexString(
           "0x0fc6ebd1758207e311a99674dc77d28128643c057fb9ca2c92b4205b6bf57ed2"
@@ -167,10 +152,8 @@ private void benchmarkPairings(
               + "1cacce8776f5ada6b35036f9343faab26c91b9aea83d3cb59cf5628ffe18ab1b"
               + "03b48ca7e6d84fca619aaf81745fbf9c30e5a78ed4766cc62b0f12aea5044f56")
     };
-    final AltBN128PairingPrecompiledContract contract =
-        EvmSpecVersion.ISTANBUL.compareTo(forkVersion) < 0
-            ? AltBN128PairingPrecompiledContract.byzantium(gasCalculator)
-            : AltBN128PairingPrecompiledContract.istanbul(gasCalculator);
+    final PrecompiledContract contract =
+        EvmSpec.evmSpec(forkVersion).getPrecompileContractRegistry().get(Address.ALTBN128_PAIRING);
 
     warmIterations = MATH_WARMUP / 20;
     execIterations = MATH_ITERATIONS / 20;

ethereum/evmtool/src/main/java/org/hyperledger/besu/evmtool/benchmarks/BLS12Benchmark.java

@@ -14,15 +14,11 @@
  */
 package org.hyperledger.besu.evmtool.benchmarks;
 
+import org.hyperledger.besu.datatypes.Address;
 import org.hyperledger.besu.evm.EvmSpecVersion;
+import org.hyperledger.besu.evm.fluent.EvmSpec;
 import org.hyperledger.besu.evm.precompile.AbstractBLS12PrecompiledContract;
-import org.hyperledger.besu.evm.precompile.BLS12G1AddPrecompiledContract;
-import org.hyperledger.besu.evm.precompile.BLS12G1MultiExpPrecompiledContract;
-import org.hyperledger.besu.evm.precompile.BLS12G2AddPrecompiledContract;
-import org.hyperledger.besu.evm.precompile.BLS12G2MultiExpPrecompiledContract;
-import org.hyperledger.besu.evm.precompile.BLS12MapFp2ToG2PrecompiledContract;
-import org.hyperledger.besu.evm.precompile.BLS12MapFpToG1PrecompiledContract;
-import org.hyperledger.besu.evm.precompile.BLS12PairingPrecompiledContract;
+import org.hyperledger.besu.evm.precompile.PrecompiledContract;
 
 import java.io.PrintStream;
 import java.util.LinkedHashMap;
@@ -167,22 +163,23 @@ public void runBenchmark(final Boolean attemptNative, final String fork) {
       return;
     }
 
-    benchmarkG1Add(output);
-    benchmarkG1MultiExp32Pairs(output);
-    benchmarkMapFpToG1(output);
-    benchmarkG2Add(output);
-    benchmarkG2MultiExp32Pairs(output);
-    benchmarkMapFp2ToG2(output);
-    benchmarkBlsPairing(output);
+    benchmarkG1Add(output, forkVersion);
+    benchmarkG1MultiExp32Pairs(output, forkVersion);
+    benchmarkMapFpToG1(output, forkVersion);
+    benchmarkG2Add(output, forkVersion);
+    benchmarkG2MultiExp32Pairs(output, forkVersion);
+    benchmarkMapFp2ToG2(output, forkVersion);
+    benchmarkBlsPairing(output, forkVersion);
   }
 
-  private void benchmarkG1Add(final PrintStream output) {
+  private void benchmarkG1Add(final PrintStream output, final EvmSpecVersion forkVersion) {
     final Map<String, Bytes> testCases = new LinkedHashMap<>();
     for (int i = 0; i < g1PointPairs.length - 1; i++) {
       testCases.put("G1 Add " + i, Bytes.fromHexString(g1PointPairs[i] + g1PointPairs[i + 1]));
     }
 
-    BLS12G1AddPrecompiledContract g1addContract = new BLS12G1AddPrecompiledContract();
+    PrecompiledContract g1addContract =
+        EvmSpec.evmSpec(forkVersion).getPrecompileContractRegistry().get(Address.BLS12_G1ADD);
     warmIterations = MATH_WARMUP / testCases.size();
     execIterations = MATH_ITERATIONS / testCases.size();
     double execTime = Double.MIN_VALUE; // a way to dodge divide by zero
@@ -198,7 +195,8 @@ private void benchmarkG1Add(final PrintStream output) {
         gasCost, execTime * 1_000_000, gasCost / execTime / 1_000_000);
   }
 
-  private void benchmarkG1MultiExp32Pairs(final PrintStream output) {
+  private void benchmarkG1MultiExp32Pairs(
+      final PrintStream output, final EvmSpecVersion forkVersion) {
     final Map<String, Bytes> testCases = new LinkedHashMap<>();
 
     // add test cases for 2, 4, 8, 16, and 32 point/scalar pairs
@@ -210,7 +208,8 @@ private void benchmarkG1MultiExp32Pairs(final PrintStream output) {
       testCases.put("G1 MSM " + (1 << i) + " pairs", Bytes.fromHexString(g1msmPairs.toString()));
     }
 
-    BLS12G1MultiExpPrecompiledContract g1msmContract = new BLS12G1MultiExpPrecompiledContract();
+    PrecompiledContract g1msmContract =
+        EvmSpec.evmSpec(forkVersion).getPrecompileContractRegistry().get(Address.BLS12_G1MULTIEXP);
     warmIterations = MATH_WARMUP / testCases.size();
     execIterations = MATH_ITERATIONS / testCases.size();
     double execTime = Double.MIN_VALUE; // a way to dodge divide by zero
@@ -224,13 +223,16 @@ private void benchmarkG1MultiExp32Pairs(final PrintStream output) {
         gasCost, execTime * 1_000_000, gasCost / execTime / 1_000_000);
   }
 
-  private void benchmarkMapFpToG1(final PrintStream output) {
+  private void benchmarkMapFpToG1(final PrintStream output, final EvmSpecVersion forkVersion) {
     final Map<String, Bytes> testCases = new LinkedHashMap<>();
     for (int i = 0; i < g1PointPairs.length; i++) {
       testCases.put("Map Fp to G1 " + i, Bytes.fromHexString(g1PointPairs[i].substring(0, 128)));
     }
 
-    BLS12MapFpToG1PrecompiledContract g1MapFpToG1Contract = new BLS12MapFpToG1PrecompiledContract();
+    PrecompiledContract g1MapFpToG1Contract =
+        EvmSpec.evmSpec(forkVersion)
+            .getPrecompileContractRegistry()
+            .get(Address.BLS12_MAP_FP_TO_G1);
     warmIterations = MATH_WARMUP / testCases.size();
     execIterations = MATH_ITERATIONS / testCases.size();
     double execTime = Double.MIN_VALUE; // a way to dodge divide by zero
@@ -247,13 +249,14 @@ private void benchmarkMapFpToG1(final PrintStream output) {
         gasCost, execTime * 1_000_000, gasCost / execTime / 1_000_000);
   }
 
-  private void benchmarkG2Add(final PrintStream output) {
+  private void benchmarkG2Add(final PrintStream output, final EvmSpecVersion forkVersion) {
     final Map<String, Bytes> testCases = new LinkedHashMap<>();
     for (int i = 0; i < g2PointPairs.length - 1; i++) {
       testCases.put("G2 Add " + i, Bytes.fromHexString(g2PointPairs[i] + g2PointPairs[i + 1]));
     }
 
-    BLS12G2AddPrecompiledContract g1addContract = new BLS12G2AddPrecompiledContract();
+    PrecompiledContract g1addContract =
+        EvmSpec.evmSpec(forkVersion).getPrecompileContractRegistry().get(Address.BLS12_G2ADD);
     warmIterations = MATH_WARMUP / testCases.size();
     execIterations = MATH_ITERATIONS / testCases.size();
     double execTime = Double.MIN_VALUE; // a way to dodge divide by zero
@@ -269,7 +272,8 @@ private void benchmarkG2Add(final PrintStream output) {
         gasCost, execTime * 1_000_000, gasCost / execTime / 1_000_000);
   }
 
-  private void benchmarkG2MultiExp32Pairs(final PrintStream output) {
+  private void benchmarkG2MultiExp32Pairs(
+      final PrintStream output, final EvmSpecVersion forkVersion) {
     final Map<String, Bytes> testCases = new LinkedHashMap<>();
 
     // add test cases for 2, 4, 8, 16, and 32 point/scalar pairs
@@ -281,7 +285,8 @@ private void benchmarkG2MultiExp32Pairs(final PrintStream output) {
       testCases.put("G2 MSM " + (1 << i) + " pairs", Bytes.fromHexString(g2msmPairs.toString()));
     }
 
-    BLS12G2MultiExpPrecompiledContract g2msmContract = new BLS12G2MultiExpPrecompiledContract();
+    PrecompiledContract g2msmContract =
+        EvmSpec.evmSpec(forkVersion).getPrecompileContractRegistry().get(Address.BLS12_G2MULTIEXP);
     warmIterations = MATH_WARMUP / testCases.size();
     execIterations = MATH_ITERATIONS / testCases.size();
     double execTime = Double.MIN_VALUE; // a way to dodge divide by zero
@@ -295,14 +300,16 @@ private void benchmarkG2MultiExp32Pairs(final PrintStream output) {
         gasCost, execTime * 1_000_000, gasCost / execTime / 1_000_000);
   }
 
-  private void benchmarkMapFp2ToG2(final PrintStream output) {
+  private void benchmarkMapFp2ToG2(final PrintStream output, final EvmSpecVersion forkVersion) {
     final Map<String, Bytes> testCases = new LinkedHashMap<>();
     for (int i = 0; i < g2PointPairs.length; i++) {
       testCases.put("Map Fp2 to G2 " + i, Bytes.fromHexString(g2PointPairs[i].substring(0, 256)));
     }
 
-    BLS12MapFp2ToG2PrecompiledContract g1MapFp2ToG2Contract =
-        new BLS12MapFp2ToG2PrecompiledContract();
+    PrecompiledContract g1MapFp2ToG2Contract =
+        EvmSpec.evmSpec(forkVersion)
+            .getPrecompileContractRegistry()
+            .get(Address.BLS12_MAP_FP2_TO_G2);
     warmIterations = MATH_WARMUP / testCases.size();
     execIterations = MATH_ITERATIONS / testCases.size();
     double execTime = Double.MIN_VALUE; // a way to dodge divide by zero
@@ -319,7 +326,7 @@ private void benchmarkMapFp2ToG2(final PrintStream output) {
         gasCost, execTime * 1_000_000, gasCost / execTime / 1_000_000);
   }
 
-  private void benchmarkBlsPairing(final PrintStream output) {
+  private void benchmarkBlsPairing(final PrintStream output, final EvmSpecVersion forkVersion) {
     final Map<String, Bytes> testCases = new LinkedHashMap<>();
 
     // add test cases for 2, 4, 8, 16, and 32 point/scalar pairs
@@ -331,7 +338,8 @@ private void benchmarkBlsPairing(final PrintStream output) {
       testCases.put("BLS Pairing " + (1 << i) + " pairs", Bytes.fromHexString(pairs.toString()));
     }
 
-    BLS12PairingPrecompiledContract blsPairingContract = new BLS12PairingPrecompiledContract();
+    PrecompiledContract blsPairingContract =
+        EvmSpec.evmSpec(forkVersion).getPrecompileContractRegistry().get(Address.BLS12_PAIRING);
     warmIterations = MATH_WARMUP / testCases.size();
     execIterations = MATH_ITERATIONS / testCases.size();
     double execTime = Double.MIN_VALUE; // a way to dodge divide by zero

ethereum/evmtool/src/main/java/org/hyperledger/besu/evmtool/benchmarks/ModExpBenchmark.java

@@ -14,7 +14,11 @@
  */
 package org.hyperledger.besu.evmtool.benchmarks;
 
+import org.hyperledger.besu.datatypes.Address;
+import org.hyperledger.besu.evm.EvmSpecVersion;
+import org.hyperledger.besu.evm.fluent.EvmSpec;
 import org.hyperledger.besu.evm.precompile.BigIntegerModularExponentiationPrecompiledContract;
+import org.hyperledger.besu.evm.precompile.PrecompiledContract;
 
 import java.io.PrintStream;
 import java.util.LinkedHashMap;
@@ -399,8 +403,10 @@ public void runBenchmark(final Boolean attemptNative, final String fork) {
                 + "ffffffffffffffffffffffff"
                 + "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));
 
-    final BigIntegerModularExponentiationPrecompiledContract contract =
-        BigIntegerModularExponentiationPrecompiledContract.osaka(gasCalculatorForFork(fork));
+    final PrecompiledContract contract =
+        EvmSpec.evmSpec(EvmSpecVersion.fromName(fork))
+            .getPrecompileContractRegistry()
+            .get(Address.MODEXP);
 
     if (attemptNative != null
         && (!attemptNative