Implement storex gas function and base evmmax cas cost model

Author: am1r021

packages/evm/src/opcodes/gas.ts

@@ -7,7 +7,9 @@ import {
   BIGINT_32,
   BIGINT_64,
   bigIntToBytes,
+  bytesToBigInt,
   equalsBytes,
+  hexToBigInt,
   setLengthLeft,
 } from '@ethereumjs/util'
 
@@ -21,6 +23,8 @@ import { accessAddressEIP2929, accessStorageEIP2929 } from './EIP2929.ts'
 import {
   createAddressFromStackBigInt,
   divCeil,
+  evmmaxMemoryGasCost,
+  isPowerOfTwo,
   maxCallGas,
   setLengthLeftStorage,
   subMemUsage,
@@ -30,6 +34,11 @@ import {
 
 import type { Common } from '@ethereumjs/common'
 import type { Address } from '@ethereumjs/util'
+import {
+  MAX_ALLOC_SIZE,
+  SETMODX_ODD_MODULUS_COST,
+  setmodxOddModulusCost,
+} from '../evmmax/constants.js'
 import type { RunState } from '../interpreter.ts'
 
 const EXTCALL_TARGET_MAX = BigInt(2) ** BigInt(8 * 20) - BigInt(1)
@@ -47,6 +56,11 @@ async function eip7702GasCost(
   return BIGINT_0
 }
 
+const MAX_UINT64 = 2n ** 64n - 1n
+function isUint64(value: bigint): boolean {
+  return value >= 0n && value <= MAX_UINT64
+}
+
 /**
  * This file returns the dynamic parts of opcodes which have dynamic gas
  * These are not pure functions: some edit the size of the memory
@@ -772,7 +786,37 @@ export const dynamicGasHandlers: Map<number, AsyncDynamicGasHandler | SyncDynami
       /* SETMODX */
       0xc0,
       async function (runState, gas, common): Promise<bigint> {
-        return 0n
+        const [modId, modOffset, modSize, allocCount] = runState.stack.peek(4)
+
+        if (!isUint64(modId) || !isUint64(modSize) || !isUint64(allocCount)) {
+          trap('one or more parameters overflows 64 bits')
+        }
+        if (runState.evmmaxState.getAlloced().get(Number(modId)) !== undefined) {
+          return 0n
+        }
+        if (modSize > 96n) {
+          trap('modulus cannot exceed 768 bits in width')
+        }
+        if (!isUint64(modOffset + modSize)) {
+          trap('modulus offset + size overflows uint64')
+        }
+        if (allocCount > 256) {
+          trap('cannot allocate more than 256 field elements per modulus id')
+        }
+        const paddedModSize = (modSize + 7n) / 8n
+        const precompCost = SETMODX_ODD_MODULUS_COST[Number(paddedModSize)]
+
+        const allocSize = paddedModSize * allocCount
+        if (runState.evmmaxState.allocSize() + allocSize > MAX_ALLOC_SIZE) {
+          trap('call context evmmax allocation threshold exceeded')
+        }
+
+        const memCost = evmmaxMemoryGasCost(runState, common, allocSize, 0n, 0n) // TODO should I be setting length and offset to 0?
+        const modBytes = runState.memory.read(Number(modOffset), Number(modSize))
+        if (!isPowerOfTwo(bytesToBigInt(modBytes))) {
+          return BigInt(precompCost) + memCost
+        }
+        return memCost
       },
     ],
     [

packages/evm/src/opcodes/util.ts

@@ -10,6 +10,7 @@ import {
   bytesToHex,
   createAddressFromBigInt,
   equalsBytes,
+  hexToBigInt,
   setLengthLeft,
   setLengthRight,
 } from '@ethereumjs/util'
@@ -197,31 +198,74 @@ export function maxCallGas(
   }
 }
 
-/**
- * Subtracts the amount needed for memory usage from `runState.gasLeft`
- */
-export function subMemUsage(runState: RunState, offset: bigint, length: bigint, common: Common) {
+export function isPowerOfTwo(val: bigint): boolean {
+  if (val <= 0n) return false
+
+  const bin = val.toString(2)
+  const topBitIndex = bin.length - 1
+  const cleared = val - (1n << BigInt(topBitIndex))
+
+  return cleared === 0n
+}
+
+export function evmmaxMemoryGasCost(
+  runState: RunState,
+  common: Common,
+  newEVMMAXMemSize: bigint,
+  offset: bigint,
+  length: bigint,
+) {
+  if (runState.memoryWordCount === 0n && newEVMMAXMemSize === 0n) {
+    return 0n
+  }
+
   // YP (225): access with zero length will not extend the memory
   if (length === BIGINT_0) return BIGINT_0
 
   const newMemoryWordCount = divCeil(offset + length, BIGINT_32)
   if (newMemoryWordCount <= runState.memoryWordCount) return BIGINT_0
 
-  const words = newMemoryWordCount
-  const fee = common.param('memoryGas')
-  const quadCoefficient = common.param('quadCoefficientDivGas')
-  // words * 3 + words ^2 / 512
-  let cost = words * fee + (words * words) / quadCoefficient
+  let newMemSize = newMemoryWordCount
 
-  if (cost > runState.highestMemCost) {
-    const currentHighestMemCost = runState.highestMemCost
-    runState.highestMemCost = cost
-    cost -= currentHighestMemCost
+  if (newMemSize > hexToBigInt('0x1FFFFFFFE0')) {
+    trap('gas uint64 overflow') // TODO is there an error code for gas overflow?
   }
+  const newMemSizePadded = newMemSize * 32n
 
-  runState.memoryWordCount = newMemoryWordCount
+  const curEVMMAXMemSizePadded = runState.evmmaxState.getActive().getAllocatedSize() * 32
+  const newEVMMAXMemSizePadded = Number(newEVMMAXMemSize) * 32
 
-  return cost
+  if (
+    newMemSizePadded > BigInt(runState.memory._store.length) ||
+    newEVMMAXMemSizePadded > curEVMMAXMemSizePadded
+  ) {
+    if (newMemSize <= BigInt(runState.memory._store.length)) {
+      newMemSize = BigInt(runState.memory._store.length)
+    }
+    const newEffectiveMemSizeWords = newEVMMAXMemSize + newMemSize // toWordSize?
+    const words = newEffectiveMemSizeWords
+    const fee = common.param('memoryGas')
+    const quadCoefficient = common.param('quadCoefficientDivGas')
+    // words * 3 + words ^2 / 512
+    let cost = words * fee + (words * words) / quadCoefficient
+    if (cost > runState.highestMemCost) {
+      const currentHighestMemCost = runState.highestMemCost
+      runState.highestMemCost = cost
+      cost -= currentHighestMemCost
+    }
+    runState.memoryWordCount = newMemoryWordCount
+
+    return cost
+  }
+
+  return 0n
+}
+
+/**
+ * Subtracts the amount needed for memory usage from `runState.gasLeft`
+ */
+export function subMemUsage(runState: RunState, offset: bigint, length: bigint, common: Common) {
+  return evmmaxMemoryGasCost(runState, common, runState.evmmaxState.allocSize(), offset, length)
 }
 
 /**