devnet-5: Add EIP-7623: Increase calldata cost (#3015)

* devnet5: Add EIP-7623: Increase calldata cost

* Fix copyright year

Author: jangko

nimbus/core/validate.nim

@@ -231,8 +231,12 @@ proc validateTxBasic*(
   if tx.maxFeePerGasNorm < tx.maxPriorityFeePerGasNorm:
     return err(&"invalid tx: maxFee is smaller than maxPriorityFee. maxFee={tx.maxFeePerGas}, maxPriorityFee={tx.maxPriorityFeePerGasNorm}")
 
-  if tx.gasLimit < tx.intrinsicGas(fork):
-    return err(&"invalid tx: not enough gas to perform calculation. avail={tx.gasLimit}, require={tx.intrinsicGas(fork)}")
+  let
+    (intrinsicGas, floorDataGas) = tx.intrinsicGas(fork)
+    minGasLimit = max(intrinsicGas, floorDataGas)
+
+  if tx.gasLimit < minGasLimit:
+    return err(&"invalid tx: not enough gas to perform calculation. avail={tx.gasLimit}, require={minGasLimit}")
 
   if fork >= FkCancun:
     if tx.payload.len > MAX_CALLDATA_SIZE:

nimbus/transaction/call_common.nim

@@ -1,6 +1,6 @@
 # Nimbus - Common entry point to the EVM from all different callers
 #
-# Copyright (c) 2018-2024 Status Research & Development GmbH
+# Copyright (c) 2018-2025 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
@@ -143,8 +143,8 @@ proc setupHost(call: CallParams, keepStack: bool): TransactionHost =
   vmState.gasRefunded = 0
 
   let
-    intrinsicGas = if call.noIntrinsic: 0.GasInt
-                   else: intrinsicGas(call, vmState.fork)
+    (intrinsicGas, floorDataGas) = if call.noIntrinsic: (0.GasInt, 0.GasInt)
+                                   else: intrinsicGas(call, vmState.fork)
     host = TransactionHost(
       vmState: vmState,
       sysCall: call.sysCall,
@@ -157,7 +157,8 @@ proc setupHost(call: CallParams, keepStack: bool): TransactionHost =
         code_address: call.to.toEvmc,
         sender:       call.sender.toEvmc,
         value:        call.value.toEvmc,
-      )
+      ),
+      floorDataGas: floorDataGas,
       # All other defaults in `TransactionHost` are fine.
     )
     gasRefund = if call.sysCall: 0
@@ -235,38 +236,50 @@ proc prepareToRunComputation(host: TransactionHost, call: CallParams) =
         db.subBalance(call.sender, blobFee)
 
 proc calculateAndPossiblyRefundGas(host: TransactionHost, call: CallParams): GasInt =
-  let c = host.computation
+  let
+    c = host.computation
+    fork = host.vmState.fork
 
   # EIP-3529: Reduction in refunds
-  let MaxRefundQuotient = if host.vmState.fork >= FkLondon:
+  let MaxRefundQuotient = if fork >= FkLondon:
                             5.GasInt
                           else:
                             2.GasInt
 
+  var gasRemaining = 0.GasInt
+
   # Calculated gas used, taking into account refund rules.
   if call.noRefund:
-    result = c.gasMeter.gasRemaining
+    gasRemaining = c.gasMeter.gasRemaining
   else:
     if c.shouldBurnGas:
       c.gasMeter.gasRemaining = 0
     let maxRefund = (call.gasLimit - c.gasMeter.gasRemaining) div MaxRefundQuotient
     let refund = min(c.getGasRefund(), maxRefund)
     c.gasMeter.returnGas(refund)
-    result = c.gasMeter.gasRemaining
+    gasRemaining = c.gasMeter.gasRemaining
+
+  let gasUsed = call.gasLimit - gasRemaining
+  if fork >= FkPrague:
+    if host.floorDataGas > gasUsed:
+      gasRemaining = call.gasLimit - host.floorDataGas
+      c.gasMeter.gasRemaining = gasRemaining
 
   # Refund for unused gas.
-  if result > 0 and not call.noGasCharge:
+  if gasRemaining > 0 and not call.noGasCharge:
     host.vmState.mutateLedger:
-      db.addBalance(call.sender, result.u256 * call.gasPrice.u256)
+      db.addBalance(call.sender, gasRemaining.u256 * call.gasPrice.u256)
+
+  gasRemaining
 
 proc finishRunningComputation(
     host: TransactionHost, call: CallParams, T: type): T =
   let c = host.computation
 
   let gasRemaining = calculateAndPossiblyRefundGas(host, call)
   # evm gas used without intrinsic gas
-  let gasUsed = host.msg.gas.GasInt - gasRemaining
-  host.vmState.captureEnd(c, c.output, gasUsed, c.errorOpt)
+  let evmGasUsed = host.msg.gas.GasInt - gasRemaining
+  host.vmState.captureEnd(c, c.output, evmGasUsed, c.errorOpt)
 
   when T is CallResult|DebugCallResult:
     # Collecting the result can be unnecessarily expensive when (re)-processing

nimbus/transaction/call_evm.nim

@@ -1,6 +1,6 @@
 # Nimbus - Various ways of calling the EVM
 #
-# Copyright (c) 2018-2024 Status Research & Development GmbH
+# Copyright (c) 2018-2025 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
@@ -118,11 +118,13 @@ proc rpcEstimateGas*(args: TransactionArgs,
     hi = gasCap
 
   cap = hi
-  let intrinsicGas = intrinsicGas(params, fork)
+  let
+    (intrinsicGas, floorDataGas) = intrinsicGas(params, fork)
+    minGasLimit = max(intrinsicGas, floorDataGas)
 
   # Create a helper to check if a gas allowance results in an executable transaction
   proc executable(gasLimit: GasInt): EvmResult[bool] =
-    if intrinsicGas > gasLimit:
+    if minGasLimit > gasLimit:
       # Special case, raise gas limit
       return ok(true)
 

nimbus/transaction/call_types.nim

@@ -1,5 +1,5 @@
 # Nimbus
-# Copyright (c) 2024 Status Research & Development GmbH
+# Copyright (c) 2024-2025 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT))
@@ -61,31 +61,44 @@ template input(tx: Transaction): auto =
 func isError*(cr: CallResult): bool =
   cr.error.len > 0
 
-func intrinsicGas*(call: CallParams | Transaction, fork: EVMFork): GasInt =
+const
+  TOTAL_COST_FLOOR_PER_TOKEN = 10
+
+func intrinsicGas*(call: CallParams | Transaction, fork: EVMFork): (GasInt, GasInt) =
   # Compute the baseline gas cost for this transaction.  This is the amount
   # of gas needed to send this transaction (but that is not actually used
   # for computation).
-  var gas = gasFees[fork][GasTransaction]
+  var
+    intrinsicGas = gasFees[fork][GasTransaction]
+    floorDataGas = intrinsicGas
+    tokens = 0
 
   # EIP-2 (Homestead) extra intrinsic gas for contract creations.
   if call.isCreate:
-    gas += gasFees[fork][GasTXCreate]
+    intrinsicGas += gasFees[fork][GasTXCreate]
     if fork >= FkShanghai:
-      gas += (gasFees[fork][GasInitcodeWord] * call.input.len.wordCount)
+      intrinsicGas += (gasFees[fork][GasInitcodeWord] * call.input.len.wordCount)
 
   # Input data cost, reduced in EIP-2028 (Istanbul).
   let gasZero    = gasFees[fork][GasTXDataZero]
   let gasNonZero = gasFees[fork][GasTXDataNonZero]
   for b in call.input:
-    gas += (if b == 0: gasZero else: gasNonZero)
+    if b == 0:
+      intrinsicGas += gasZero
+      tokens += 1
+    else:
+      intrinsicGas += gasNonZero
+      tokens += 4
+
 
   # EIP-2930 (Berlin) intrinsic gas for transaction access list.
   if fork >= FkBerlin:
     for account in call.accessList:
-      gas += ACCESS_LIST_ADDRESS_COST
-      gas += GasInt(account.storageKeys.len) * ACCESS_LIST_STORAGE_KEY_COST
+      intrinsicGas += ACCESS_LIST_ADDRESS_COST
+      intrinsicGas += GasInt(account.storageKeys.len) * ACCESS_LIST_STORAGE_KEY_COST
 
   if fork >= FkPrague:
-    gas += call.authorizationList.len * PER_EMPTY_ACCOUNT_COST
+    intrinsicGas += call.authorizationList.len * PER_EMPTY_ACCOUNT_COST
+    floorDataGas += tokens * TOTAL_COST_FLOOR_PER_TOKEN
 
-  return gas.GasInt
+  return (intrinsicGas.GasInt, floorDataGas.GasInt)

nimbus/transaction/host_types.nim

@@ -1,6 +1,6 @@
 # Nimbus - Types and helpers used at the boundary of transactions/RPC and EVMC/EVM
 #
-# Copyright (c) 2019-2024 Status Research & Development GmbH
+# Copyright (c) 2019-2025 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
@@ -66,6 +66,7 @@ type
     saveComputation*: seq[Computation]
     hostInterface*:   ptr evmc_host_interface
     sysCall*:         bool
+    floorDataGas*:    GasInt
 
 # These versions of `toEvmc` and `fromEvmc` don't flip big/little-endian like
 # the older functions in `evmc_helpers`.  New code only flips with _explicit_