Combined EIP-7623 and spec test Spike

build.gradle

@@ -168,7 +168,7 @@ configure(allprojects - project(':platform')) {
     def ethExecSpecTestsRepo = ivy {
       url 'https://github.com'
       patternLayout {
-        artifact '/[organisation]/[module]/releases/download/v[revision]/[classifier].[ext]'
+        artifact '/[organisation]/[module]/releases/download/[revision]/[classifier].[ext]'
       }
       metadataSources {
         artifact()

ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/jsonrpc/internal/privacy/methods/eea/PluginEeaSendRawTransaction.java

@@ -84,6 +84,6 @@ protected long getGasLimit(final PrivateTransaction privateTransaction, final St
     // choose the highest of the two options
     return Math.max(
         privateTransaction.getGasLimit(),
-        gasCalculator.transactionIntrinsicGasCost(Bytes.fromBase64String(pmtPayload), false));
+        gasCalculator.transactionIntrinsicGasCost(Bytes.fromBase64String(pmtPayload), false, 0));
   }
 }

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/CodeDelegation.java

@@ -21,17 +21,22 @@
 import org.hyperledger.besu.datatypes.Address;
 import org.hyperledger.besu.datatypes.Hash;
 import org.hyperledger.besu.ethereum.core.encoding.CodeDelegationTransactionEncoder;
+import org.hyperledger.besu.ethereum.core.json.ChainIdDeserializer;
 import org.hyperledger.besu.ethereum.rlp.BytesValueRLPOutput;
 
 import java.math.BigInteger;
 import java.util.Optional;
 import java.util.function.Supplier;
 
 import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
 import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
 import com.google.common.base.Suppliers;
 import org.apache.tuweni.bytes.Bytes;
 
+// ignore `signer` field used in execution-spec-tests
+@JsonIgnoreProperties(ignoreUnknown = true)
 public class CodeDelegation implements org.hyperledger.besu.datatypes.CodeDelegation {
   private static final Supplier<SignatureAlgorithm> SIGNATURE_ALGORITHM =
       Suppliers.memoize(SignatureAlgorithmFactory::getInstance);
@@ -77,14 +82,23 @@ public CodeDelegation(
    */
   @JsonCreator
   public static org.hyperledger.besu.datatypes.CodeDelegation createCodeDelegation(
-      @JsonProperty("chainId") final BigInteger chainId,
+      @JsonProperty("chainId") @JsonDeserialize(using = ChainIdDeserializer.class)
+          final BigInteger chainId,
       @JsonProperty("address") final Address address,
-      @JsonProperty("nonce") final long nonce,
-      @JsonProperty("v") final byte v,
-      @JsonProperty("r") final BigInteger r,
-      @JsonProperty("s") final BigInteger s) {
+      @JsonProperty("nonce") final String nonce,
+      @JsonProperty("v") final String v,
+      @JsonProperty("r") final String r,
+      @JsonProperty("s") final String s) {
     return new CodeDelegation(
-        chainId, address, nonce, SIGNATURE_ALGORITHM.get().createSignature(r, s, v));
+        chainId,
+        address,
+        Bytes.fromHexStringLenient(nonce).toLong(),
+        SIGNATURE_ALGORITHM
+            .get()
+            .createSignature(
+                Bytes.fromHexStringLenient(r).toUnsignedBigInteger(),
+                Bytes.fromHexStringLenient(s).toUnsignedBigInteger(),
+                Bytes.fromHexStringLenient(v).get(0)));
   }
 
   @JsonProperty("chainId")

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/json/ChainIdDeserializer.java

@@ -35,12 +35,7 @@ public ChainIdDeserializer(final Class<?> vc) {
   @Override
   public BigInteger deserialize(final JsonParser jsonparser, final DeserializationContext context)
       throws IOException {
-    final var chainId =
-        UInt256.fromHexString(jsonparser.getCodec().readValue(jsonparser, String.class))
-            .toBigInteger();
-    if (chainId.signum() <= 0) {
-      throw new IllegalArgumentException("Non positive chain id: " + chainId);
-    }
-    return chainId;
+    return UInt256.fromHexString(jsonparser.getCodec().readValue(jsonparser, String.class))
+        .toBigInteger();
   }
 }

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/ClassicProtocolSpecs.java

@@ -171,12 +171,14 @@ public static ProtocolSpecBuilder atlantisDefinition(
                     evm, true, Collections.singletonList(MaxCodeSizeRule.from(evm)), 1))
         .transactionProcessorBuilder(
             (gasCalculator,
+                refundCalculator,
                 feeMarket,
                 transactionValidatorFactory,
                 contractCreationProcessor,
                 messageCallProcessor) ->
                 new MainnetTransactionProcessor(
                     gasCalculator,
+                    refundCalculator,
                     transactionValidatorFactory,
                     contractCreationProcessor,
                     messageCallProcessor,
@@ -353,12 +355,14 @@ public static ProtocolSpecBuilder spiralDefinition(
         // EIP-3651
         .transactionProcessorBuilder(
             (gasCalculator,
+                refundCalculator,
                 feeMarket,
                 transactionValidatorFactory,
                 contractCreationProcessor,
                 messageCallProcessor) ->
                 new MainnetTransactionProcessor(
                     gasCalculator,
+                    refundCalculator,
                     transactionValidatorFactory,
                     contractCreationProcessor,
                     messageCallProcessor,

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetProtocolSpecs.java

@@ -70,6 +70,8 @@
 import org.hyperledger.besu.evm.internal.EvmConfiguration;
 import org.hyperledger.besu.evm.processor.ContractCreationProcessor;
 import org.hyperledger.besu.evm.processor.MessageCallProcessor;
+import org.hyperledger.besu.evm.refundcalculator.FrontierRefundCalculator;
+import org.hyperledger.besu.evm.refundcalculator.PragueRefundCalculator;
 import org.hyperledger.besu.evm.worldstate.WorldState;
 import org.hyperledger.besu.evm.worldstate.WorldUpdater;
 import org.hyperledger.besu.plugin.services.MetricsSystem;
@@ -118,6 +120,7 @@ public static ProtocolSpecBuilder frontierDefinition(
       final MetricsSystem metricsSystem) {
     return new ProtocolSpecBuilder()
         .gasCalculator(FrontierGasCalculator::new)
+        .refundCalculator(FrontierRefundCalculator::new)
         .gasLimitCalculatorBuilder(feeMarket -> new FrontierTargetingGasLimitCalculator())
         .evmBuilder(MainnetEVMs::frontier)
         .precompileContractRegistryBuilder(MainnetPrecompiledContractRegistries::frontier)
@@ -132,12 +135,14 @@ public static ProtocolSpecBuilder frontierDefinition(
                     evm.getGasCalculator(), gasLimitCalculator, false, Optional.empty()))
         .transactionProcessorBuilder(
             (gasCalculator,
+                refundCalculator,
                 feeMarket,
                 transactionValidatorFactory,
                 contractCreationProcessor,
                 messageCallProcessor) ->
                 new MainnetTransactionProcessor(
                     gasCalculator,
+                    refundCalculator,
                     transactionValidatorFactory,
                     contractCreationProcessor,
                     messageCallProcessor,
@@ -293,12 +298,14 @@ public static ProtocolSpecBuilder spuriousDragonDefinition(
                     evm.getGasCalculator(), gasLimitCalculator, true, chainId))
         .transactionProcessorBuilder(
             (gasCalculator,
+                refundCalculator,
                 feeMarket,
                 transactionValidator,
                 contractCreationProcessor,
                 messageCallProcessor) ->
                 new MainnetTransactionProcessor(
                     gasCalculator,
+                    refundCalculator,
                     transactionValidator,
                     contractCreationProcessor,
                     messageCallProcessor,
@@ -499,12 +506,14 @@ static ProtocolSpecBuilder londonDefinition(
                     Integer.MAX_VALUE))
         .transactionProcessorBuilder(
             (gasCalculator,
+                refundCalculator,
                 feeMarket,
                 transactionValidatorFactory,
                 contractCreationProcessor,
                 messageCallProcessor) ->
                 new MainnetTransactionProcessor(
                     gasCalculator,
+                    refundCalculator,
                     transactionValidatorFactory,
                     contractCreationProcessor,
                     messageCallProcessor,
@@ -631,12 +640,14 @@ static ProtocolSpecBuilder shanghaiDefinition(
         // we need to flip the Warm Coinbase flag for EIP-3651 warm coinbase
         .transactionProcessorBuilder(
             (gasCalculator,
+                refundCalculator,
                 feeMarket,
                 transactionValidatorFactory,
                 contractCreationProcessor,
                 messageCallProcessor) ->
                 new MainnetTransactionProcessor(
                     gasCalculator,
+                    refundCalculator,
                     transactionValidatorFactory,
                     contractCreationProcessor,
                     messageCallProcessor,
@@ -718,12 +729,14 @@ static ProtocolSpecBuilder cancunDefinition(
         // use Cancun fee market
         .transactionProcessorBuilder(
             (gasCalculator,
+                refundCalculator,
                 feeMarket,
                 transactionValidator,
                 contractCreationProcessor,
                 messageCallProcessor) ->
                 new MainnetTransactionProcessor(
                     gasCalculator,
+                    refundCalculator,
                     transactionValidator,
                     contractCreationProcessor,
                     messageCallProcessor,
@@ -837,6 +850,7 @@ static ProtocolSpecBuilder pragueDefinition(
             metricsSystem)
         .feeMarket(pragueFeeMarket)
         .gasCalculator(pragueGasCalcSupplier)
+        .refundCalculator(PragueRefundCalculator::new)
         // EIP-7840 Blob schedule | EIP-7691 6/9 blob increase
         .gasLimitCalculatorBuilder(
             feeMarket ->

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionProcessor.java

@@ -18,6 +18,7 @@
 import static org.hyperledger.besu.ethereum.mainnet.PrivateStateUtils.KEY_PRIVATE_METADATA_UPDATER;
 import static org.hyperledger.besu.ethereum.mainnet.PrivateStateUtils.KEY_TRANSACTION;
 import static org.hyperledger.besu.ethereum.mainnet.PrivateStateUtils.KEY_TRANSACTION_HASH;
+import static org.hyperledger.besu.evm.internal.Words.clampedAdd;
 
 import org.hyperledger.besu.collections.trie.BytesTrieSet;
 import org.hyperledger.besu.datatypes.AccessListEntry;
@@ -41,6 +42,7 @@
 import org.hyperledger.besu.evm.frame.MessageFrame;
 import org.hyperledger.besu.evm.gascalculator.GasCalculator;
 import org.hyperledger.besu.evm.processor.AbstractMessageProcessor;
+import org.hyperledger.besu.evm.refundcalculator.RefundCalculator;
 import org.hyperledger.besu.evm.tracing.OperationTracer;
 import org.hyperledger.besu.evm.worldstate.EVMWorldUpdater;
 import org.hyperledger.besu.evm.worldstate.WorldUpdater;
@@ -66,6 +68,8 @@ public class MainnetTransactionProcessor {
 
   protected final GasCalculator gasCalculator;
 
+  private final RefundCalculator refundCalculator;
+
   protected final TransactionValidatorFactory transactionValidatorFactory;
 
   private final AbstractMessageProcessor contractCreationProcessor;
@@ -85,6 +89,7 @@ public class MainnetTransactionProcessor {
 
   public MainnetTransactionProcessor(
       final GasCalculator gasCalculator,
+      final RefundCalculator refundCalculator,
       final TransactionValidatorFactory transactionValidatorFactory,
       final AbstractMessageProcessor contractCreationProcessor,
       final AbstractMessageProcessor messageCallProcessor,
@@ -95,6 +100,7 @@ public MainnetTransactionProcessor(
       final CoinbaseFeePriceCalculator coinbaseFeePriceCalculator) {
     this(
         gasCalculator,
+        refundCalculator,
         transactionValidatorFactory,
         contractCreationProcessor,
         messageCallProcessor,
@@ -108,6 +114,7 @@ public MainnetTransactionProcessor(
 
   public MainnetTransactionProcessor(
       final GasCalculator gasCalculator,
+      final RefundCalculator refundCalculator,
       final TransactionValidatorFactory transactionValidatorFactory,
       final AbstractMessageProcessor contractCreationProcessor,
       final AbstractMessageProcessor messageCallProcessor,
@@ -118,6 +125,7 @@ public MainnetTransactionProcessor(
       final CoinbaseFeePriceCalculator coinbaseFeePriceCalculator,
       final CodeDelegationProcessor maybeCodeDelegationProcessor) {
     this.gasCalculator = gasCalculator;
+    this.refundCalculator = refundCalculator;
     this.transactionValidatorFactory = transactionValidatorFactory;
     this.contractCreationProcessor = contractCreationProcessor;
     this.messageCallProcessor = messageCallProcessor;
@@ -372,22 +380,22 @@ public TransactionProcessingResult processTransaction(
         warmAddressList.add(miningBeneficiary);
       }
 
-      final long intrinsicGas =
-          gasCalculator.transactionIntrinsicGasCost(
-              transaction.getPayload(), transaction.isContractCreation());
       final long accessListGas =
           gasCalculator.accessListGasCost(accessListEntries.size(), accessListStorageCount);
       final long codeDelegationGas =
           gasCalculator.delegateCodeGasCost(transaction.codeDelegationListSize());
-      final long gasAvailable =
-          transaction.getGasLimit() - intrinsicGas - accessListGas - codeDelegationGas;
+      final long intrinsicGas =
+          gasCalculator.transactionIntrinsicGasCost(
+              transaction.getPayload(),
+              transaction.isContractCreation(),
+              clampedAdd(accessListGas, codeDelegationGas));
+
+      final long gasAvailable = transaction.getGasLimit() - intrinsicGas;
       LOG.trace(
-          "Gas available for execution {} = {} - {} - {} - {} (limit - intrinsic - accessList - codeDelegation)",
+          "Gas available for execution {} = {} - {} (limit - intrinsic)",
           gasAvailable,
           transaction.getGasLimit(),
-          intrinsicGas,
-          accessListGas,
-          codeDelegationGas);
+          intrinsicGas);
 
       final WorldUpdater worldUpdater = evmWorldUpdater.updater();
       final ImmutableMap.Builder<String, Object> contextVariablesBuilder =
@@ -500,11 +508,9 @@ public TransactionProcessingResult processTransaction(
 
       // Refund the sender by what we should and pay the miner fee (note that we're doing them one
       // after the other so that if it is the same account somehow, we end up with the right result)
-      final long selfDestructRefund =
-          gasCalculator.getSelfDestructRefundAmount() * initialFrame.getSelfDestructs().size();
-      final long baseRefundGas =
-          initialFrame.getGasRefund() + selfDestructRefund + codeDelegationRefund;
-      final long refundedGas = refunded(transaction, initialFrame.getRemainingGas(), baseRefundGas);
+      final long refundedGas =
+          refundCalculator.calculateGasRefund(
+              gasCalculator, transaction, initialFrame, codeDelegationRefund);
       final Wei refundedWei = transactionGasPrice.multiply(refundedGas);
       final Wei balancePriorToRefund = sender.getBalance();
       sender.incrementBalance(refundedWei);
@@ -635,15 +641,6 @@ public AbstractMessageProcessor getMessageProcessor(final MessageFrame.Type type
     };
   }
 
-  protected long refunded(
-      final Transaction transaction, final long gasRemaining, final long gasRefund) {
-    // Integer truncation takes care of the floor calculation needed after the divide.
-    final long maxRefundAllowance =
-        (transaction.getGasLimit() - gasRemaining) / gasCalculator.getMaxRefundQuotient();
-    final long refundAllowance = Math.min(maxRefundAllowance, gasRefund);
-    return gasRemaining + refundAllowance;
-  }
-
   private String printableStackTraceFromThrowable(final RuntimeException re) {
     final StringBuilder builder = new StringBuilder();
 

ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionValidator.java

@@ -15,6 +15,7 @@
 package org.hyperledger.besu.ethereum.mainnet;
 
 import static org.hyperledger.besu.evm.account.Account.MAX_NONCE;
+import static org.hyperledger.besu.evm.internal.Words.clampedAdd;
 
 import org.hyperledger.besu.crypto.SECPSignature;
 import org.hyperledger.besu.crypto.SignatureAlgorithmFactory;
@@ -252,17 +253,22 @@ private ValidationResult<TransactionInvalidReason> validateCostAndFee(
       }
     }
 
-    final long intrinsicGasCost =
-        gasCalculator.transactionIntrinsicGasCost(
-                transaction.getPayload(), transaction.isContractCreation())
-            + (transaction.getAccessList().map(gasCalculator::accessListGasCost).orElse(0L))
-            + gasCalculator.delegateCodeGasCost(transaction.codeDelegationListSize());
-    if (Long.compareUnsigned(intrinsicGasCost, transaction.getGasLimit()) > 0) {
+    final long baselineGas =
+        clampedAdd(
+            transaction.getAccessList().map(gasCalculator::accessListGasCost).orElse(0L),
+            gasCalculator.delegateCodeGasCost(transaction.codeDelegationListSize()));
+    final long intrinsicGasCostOrFloor =
+        Math.max(
+            gasCalculator.transactionIntrinsicGasCost(
+                transaction.getPayload(), transaction.isContractCreation(), baselineGas),
+            gasCalculator.transactionFloorCost(transaction.getPayload()));
+
+    if (Long.compareUnsigned(intrinsicGasCostOrFloor, transaction.getGasLimit()) > 0) {
       return ValidationResult.invalid(
           TransactionInvalidReason.INTRINSIC_GAS_EXCEEDS_GAS_LIMIT,
           String.format(
               "intrinsic gas cost %s exceeds gas limit %s",
-              intrinsicGasCost, transaction.getGasLimit()));
+              intrinsicGasCostOrFloor, transaction.getGasLimit()));
     }
 
     if (transaction.calculateUpfrontGasCost(transaction.getMaxGasPrice(), Wei.ZERO, 0).bitLength()