dynamic blob gas calculation (#3354)

* dynamic blob gas calculation

* fix tests

* fix additional tests

* remove constants

Author: advaita-saha

execution_chain/common/common.nim

@@ -278,6 +278,16 @@ func toHardFork*(
     com: CommonRef, forkDeterminer: ForkDeterminationInfo): HardFork =
   toHardFork(com.forkTransitionTable, forkDeterminer)
 
+func toHardFork*(com: CommonRef, timestamp: EthTime): HardFork =
+  for fork in countdown(com.forkTransitionTable.timeThresholds.high, Shanghai):
+    if com.forkTransitionTable.timeThresholds[fork].isSome and timestamp >= com.forkTransitionTable.timeThresholds[fork].get:
+      return fork
+
+func toEVMFork*(com: CommonRef, timestamp: EthTime): EVMFork =
+  ## similar to toHardFork, but produce EVMFork
+  let fork = com.toHardFork(timestamp)
+  ToEVMFork[fork]
+
 func toEVMFork*(com: CommonRef, forkDeterminer: ForkDeterminationInfo): EVMFork =
   ## similar to toFork, but produce EVMFork
   let fork = com.toHardFork(forkDeterminer)

execution_chain/constants.nim

@@ -89,10 +89,6 @@ const
   MAX_BLOB_GAS_PER_BLOCK* = 786432
   MAX_BLOBS_PER_BLOCK* = int(MAX_BLOB_GAS_PER_BLOCK div GAS_PER_BLOB)
 
-  MAX_BLOB_GAS_PER_BLOCK_ELECTRA* = 1179648
-  TARGET_BLOB_GAS_PER_BLOCK_ELECTRA* = 786432
-  MAX_BLOBS_PER_BLOCK_ELECTRA* = int(MAX_BLOB_GAS_PER_BLOCK_ELECTRA div GAS_PER_BLOB)
-
   # EIP-4788 addresses
   # BEACON_ROOTS_ADDRESS is the address where historical beacon roots are stored as per EIP-4788
   BEACON_ROOTS_ADDRESS* = address"0x000F3df6D732807Ef1319fB7B8bB8522d0Beac02"

execution_chain/core/eip4844.nim

@@ -82,11 +82,11 @@ proc pointEvaluation*(input: openArray[byte]): Result[void, string] =
   ok()
 
 # calcExcessBlobGas implements calc_excess_data_gas from EIP-4844
-proc calcExcessBlobGas*(parent: Header, electra: bool): uint64 =
+proc calcExcessBlobGas*(com: CommonRef, parent: Header, fork: EVMFork): uint64 =
   let
     excessBlobGas = parent.excessBlobGas.get(0'u64)
     blobGasUsed = parent.blobGasUsed.get(0'u64)
-    targetBlobGasPerBlock = getTargetBlobGasPerBlock(electra)
+    targetBlobGasPerBlock = com.getTargetBlobsPerBlock(fork) * GAS_PER_BLOB
 
   if excessBlobGas + blobGasUsed < targetBlobGasPerBlock:
     0'u64
@@ -157,12 +157,12 @@ func validateEip4844Header*(
     return err("expect EIP-4844 excessBlobGas in block header")
 
   let
-    electra = com.isPragueOrLater(header.timestamp)
+    fork = com.toEVMFork(header)
     headerBlobGasUsed = header.blobGasUsed.get()
     blobGasUsed = blobGasUsed(txs)
     headerExcessBlobGas = header.excessBlobGas.get
-    excessBlobGas = calcExcessBlobGas(parentHeader, electra)
-    maxBlobGasPerBlock = getMaxBlobGasPerBlock(electra)
+    excessBlobGas = calcExcessBlobGas(com, parentHeader, fork)
+    maxBlobGasPerBlock = com.getMaxBlobGasPerBlock(fork)
 
   if blobGasUsed > maxBlobGasPerBlock:
     return err("blobGasUsed " & $blobGasUsed & " exceeds maximum allowance " & $maxBlobGasPerBlock)

execution_chain/core/eip7691.nim

@@ -16,14 +16,6 @@ import
   ../common/evmforks,
   ../common/common
 
-func getMaxBlobGasPerBlock*(electra: bool): uint64 =
-  if electra: MAX_BLOB_GAS_PER_BLOCK_ELECTRA.uint64
-  else: MAX_BLOB_GAS_PER_BLOCK.uint64
-
-func getTargetBlobGasPerBlock*(electra: bool): uint64 =
-  if electra: TARGET_BLOB_GAS_PER_BLOCK_ELECTRA.uint64
-  else: TARGET_BLOB_GAS_PER_BLOCK.uint64
-
 const
   EVMForkToFork: array[FkCancun..FkLatest, HardFork] = [
     Cancun,
@@ -32,9 +24,19 @@ const
   ]
 
 func getMaxBlobsPerBlock*(com: CommonRef, fork: EVMFork): uint64 =
-  doAssert(fork >= FkCancun)
+  if fork < FkCancun:
+    return 0
   com.maxBlobsPerBlock(EVMForkToFork[fork])
 
+func getTargetBlobsPerBlock*(com: CommonRef, fork: EVMFork): uint64 =
+  if fork < FkCancun:
+    return 0
+  com.targetBlobsPerBlock(EVMForkToFork[fork])
+
 func getBlobBaseFeeUpdateFraction*(com: CommonRef, fork: EVMFork): uint64 =
-  doAssert(fork >= FkCancun)
+  if fork < FkCancun:
+    return 0
   com.baseFeeUpdateFraction(EVMForkToFork[fork])
+
+func getMaxBlobGasPerBlock*(com: CommonRef, fork: EVMFork): uint64 =
+  com.getMaxBlobsPerBlock(fork) * GAS_PER_BLOB

execution_chain/core/executor/process_transaction.nim

@@ -94,7 +94,7 @@ proc processTransactionImpl(
   # blobGasUsed will be added to vmState.blobGasUsed if the tx is ok.
   let
     blobGasUsed = tx.getTotalBlobGas
-    maxBlobGasPerBlock = getMaxBlobGasPerBlock(vmState.fork >= FkPrague)
+    maxBlobGasPerBlock = getMaxBlobGasPerBlock(vmState.com, vmState.fork)
   if vmState.blobGasUsed + blobGasUsed > maxBlobGasPerBlock:
     return err("blobGasUsed " & $blobGasUsed &
       " exceeds maximum allowance " & $maxBlobGasPerBlock)

execution_chain/core/tx_pool/tx_desc.nim

@@ -87,7 +87,7 @@ proc setupVMState(com: CommonRef;
                   pos: PosPayloadAttr,
                   parentFrame: CoreDbTxRef): BaseVMState =
   let
-    electra = com.isPragueOrLater(pos.timestamp)
+    fork = com.toEVMFork(pos.timestamp)
 
   BaseVMState.new(
     parent   = parent,
@@ -98,7 +98,7 @@ proc setupVMState(com: CommonRef;
       prevRandao   : pos.prevRandao,
       difficulty   : UInt256.zero(),
       coinbase     : pos.feeRecipient,
-      excessBlobGas: calcExcessBlobGas(parent, electra),
+      excessBlobGas: com.calcExcessBlobGas(parent, fork),
       parentHash   : parentHash,
     ),
     txFrame = parentFrame.txFrameBegin(),

execution_chain/core/tx_pool/tx_packer.nim

@@ -71,7 +71,7 @@ proc classifyValidatePacked(vmState: BaseVMState; item: TxItemRef): bool =
     baseFee = vmState.blockCtx.baseFeePerGas.get(0.u256)
     fork = vmState.fork
     gasLimit = vmState.blockCtx.gasLimit
-    excessBlobGas = calcExcessBlobGas(vmState.parent, fork >= FkPrague)
+    excessBlobGas = calcExcessBlobGas(vmState.com, vmState.parent, fork)
 
   roDB.validateTransaction(
     item.tx, item.sender, gasLimit, baseFee, excessBlobGas, vmState.com, fork).isOk
@@ -159,7 +159,6 @@ proc vmExecGrabItem(pst: var TxPacker; item: TxItemRef, xp: TxPoolRef): bool =
   ## values are below the maximum block size.
   let
     vmState = pst.vmState
-    electra = vmState.fork >= FkPrague
 
   # EIP-4844
   if item.tx.txType == TxEip4844:
@@ -169,7 +168,7 @@ proc vmExecGrabItem(pst: var TxPacker; item: TxItemRef, xp: TxPoolRef): bool =
 
   let
     blobGasUsed = item.tx.getTotalBlobGas
-    maxBlobGasPerBlock = getMaxBlobGasPerBlock(electra)
+    maxBlobGasPerBlock = getMaxBlobGasPerBlock(vmState.com, vmState.fork)
   if vmState.blobGasUsed + blobGasUsed > maxBlobGasPerBlock:
     return ContinueWithNextAccount
 

hive_integration/nodocker/engine/cancun/step_newpayloads.nim

@@ -73,7 +73,7 @@ proc verifyPayload(step: NewPayloads,
       excessBlobGas: Opt.some(parentExcessBlobGas),
       blobGasUsed: Opt.some(parentBlobGasUsed)
     )
-    expectedExcessBlobGas = calcExcessBlobGas(parent, com.isPragueOrLater(payload.timestamp.EthTime))
+    expectedExcessBlobGas = com.calcExcessBlobGas(parent, com.toEVMFork(payload.timestamp.EthTime))
 
   if com.isCancunOrLater(payload.timestamp.EthTime):
     if payload.excessBlobGas.isNone:

tools/t8n/transition.nim

@@ -351,7 +351,7 @@ proc exec(ctx: TransContext,
   if ctx.env.currentExcessBlobGas.isSome:
     excessBlobGas = ctx.env.currentExcessBlobGas
   elif ctx.env.parentExcessBlobGas.isSome and ctx.env.parentBlobGasUsed.isSome:
-    excessBlobGas = Opt.some calcExcessBlobGas(vmState.parent, vmState.fork >= FkPrague)
+    excessBlobGas = Opt.some calcExcessBlobGas(vmState.com, vmState.parent, vmState.fork)
 
   if excessBlobGas.isSome:
     result.result.blobGasUsed = Opt.some vmState.blobGasUsed
@@ -535,7 +535,7 @@ proc transitionAction*(ctx: var TransContext, conf: T8NConf) =
       # If it is not explicitly defined, but we have the parent values, we try
       # to calculate it ourselves.
       if parent.excessBlobGas.isSome and parent.blobGasUsed.isSome:
-        ctx.env.currentExcessBlobGas = Opt.some calcExcessBlobGas(parent, com.isPragueOrLater(ctx.env.currentTimestamp))
+        ctx.env.currentExcessBlobGas = Opt.some com.calcExcessBlobGas(parent, com.toEVMFork(ctx.env.currentTimestamp))
 
     let header  = envToHeader(ctx.env)