ethereumjs · am1r021 · May 6, 2025 · May 6, 2025 · May 6, 2025 · May 6, 2025
diff --git a/packages/common/src/eips.ts b/packages/common/src/eips.ts
@@ -479,6 +479,14 @@ export const eipsDict: EIPsDict = {
    minimumHardfork: Hardfork.Chainstart,
    requiredEIPs: [2935],
  },
+  /**
+   * Description : Set upper bounds for MODEXP
+   * URL         : https://eips.ethereum.org/EIPS/eip-7823
+   * Status      : Review
+   */
+  7823: {
+    minimumHardfork: Hardfork.Chainstart,
+  },
  /**
   * Description : Ethereum state using a unified binary tree (experimental)
   * URL         : hhttps://eips.ethereum.org/EIPS/eip-7864

diff --git a/packages/common/src/hardforks.ts b/packages/common/src/hardforks.ts
@@ -166,7 +166,7 @@ export const hardforksDict: HardforksDict = {
   * Status     : Final
   */
  osaka: {
-    eips: [663, 3540, 3670, 4200, 4750, 5450, 6206, 7069, 7480, 7594, 7620, 7692, 7698, 7883],
+    eips: [663, 3540, 3670, 4200, 4750, 5450, 6206, 7069, 7480, 7594, 7620, 7692, 7698, 7823, 7883],
  },
  /**
   * Description: Next feature hardfork after osaka, internally used for verkle testing/implementation (incomplete/experimental)

diff --git a/packages/evm/src/evm.ts b/packages/evm/src/evm.ts
@@ -256,7 +256,7 @@ export class EVM implements EVMInterface {
    const supportedEIPs = [
      663, 1153, 1559, 2537, 2565, 2718, 2929, 2930, 2935, 3198, 3529, 3540, 3541, 3607, 3651, 3670,
      3855, 3860, 4200, 4399, 4750, 4788, 4844, 4895, 5133, 5450, 5656, 6110, 6206, 6780, 6800,
-      7002, 7069, 7251, 7480, 7516, 7594, 7620, 7685, 7691, 7692, 7698, 7702, 7709,
+      7002, 7069, 7251, 7480, 7516, 7594, 7620, 7685, 7691, 7692, 7698, 7702, 7709, 7823,
    ]

    for (const eip of this.common.eips()) {

diff --git a/packages/evm/src/precompiles/05-modexp.ts b/packages/evm/src/precompiles/05-modexp.ts
@@ -32,9 +32,8 @@ const BIGINT_3072 = BigInt(3072)
 const BIGINT_199680 = BigInt(199680)

 const maxInt = BigInt(Number.MAX_SAFE_INTEGER)
-const maxSize = BigInt(2147483647) // @ethereumjs/util setLengthRight limitation

-function multiplicationComplexity(x: bigint): bigint {
+export function multiplicationComplexity(x: bigint): bigint {
  let fac1
  let fac2
  if (x <= BIGINT_64) {
@@ -52,12 +51,12 @@ function multiplicationComplexity(x: bigint): bigint {
  }
 }

-function multiplicationComplexityEIP2565(x: bigint): bigint {
+export function multiplicationComplexityEIP2565(x: bigint): bigint {
  const words = (x + BIGINT_7) / BIGINT_8
  return words * words
 }

-function getAdjustedExponentLength(data: Uint8Array, opts: PrecompileInput): bigint {
+export function getAdjustedExponentLength(data: Uint8Array, opts: PrecompileInput): bigint {
  let expBytesStart
  try {
    const baseLen = bytesToBigInt(data.subarray(0, 32))
@@ -157,6 +156,7 @@ export function precompile05(opts: PrecompileInput): ExecResult {
    }
  }

+  const maxSize = opts.common.isActivatedEIP(7823) ? BigInt(1024) : BigInt(2147483647) // @ethereumjs/util setLengthRight limitation
  if (bLen > maxSize || eLen > maxSize || mLen > maxSize) {
    if (opts._debug !== undefined) {
      opts._debug(`${pName} failed: OOG`)

diff --git a/packages/evm/test/precompiles/05-modexp.spec.ts b/packages/evm/test/precompiles/05-modexp.spec.ts
@@ -1,14 +1,34 @@
 import { Common, Mainnet } from '@ethereumjs/common'
-import { bytesToHex, hexToBytes } from '@ethereumjs/util'
+import {
+  BIGINT_1,
+  bytesToBigInt,
+  bytesToHex,
+  concatBytes,
+  hexToBytes,
+  randomBytes,
+  setLengthLeft,
+  setLengthRight,
+  toBytes,
+} from '@ethereumjs/util'
 import { assert, beforeAll, describe, it } from 'vitest'

-import { createEVM, getActivePrecompiles } from '../../src/index.ts'
+import { gasLimitCheck } from '../../src/precompiles/util.ts'

+import { createEVM, getActivePrecompiles } from '../../src/index.ts'
+import {
+  expMod,
+  getAdjustedExponentLength,
+  multiplicationComplexity,
+  multiplicationComplexityEIP2565,
+} from '../../src/precompiles/05-modexp.ts'
+import { getPrecompileName } from '../../src/precompiles/index.ts'
 import { testData } from './modexp-testdata.ts'

 import type { PrefixedHexString } from '@ethereumjs/util'
 import type { EVM } from '../../src/index.ts'
-import type { PrecompileFunc } from '../../src/precompiles/types.ts'
+import type { PrecompileFunc, PrecompileInput } from '../../src/precompiles/types.ts'
+
+const BIGINT_200 = BigInt(200)

 const fuzzerTests = testData.data as PrefixedHexString[][]
 describe('Precompiles: MODEXP', () => {
@@ -51,3 +71,81 @@ describe('Precompiles: MODEXP', () => {
    assert.strictEqual(result.executionGasUsed, gas)
  })
 })
+
+function enoughGas(opts: PrecompileInput): boolean {
+  const pName = getPrecompileName('05')
+  const data = opts.data.length < 96 ? setLengthRight(opts.data, 96) : opts.data
+
+  let adjustedELen = getAdjustedExponentLength(data, opts)
+  if (adjustedELen < BIGINT_1) {
+    adjustedELen = BIGINT_1
+  }
+
+  const bLen = bytesToBigInt(data.subarray(0, 32))
+  const mLen = bytesToBigInt(data.subarray(64, 96))
+
+  let maxLen = bLen
+  if (maxLen < mLen) {
+    maxLen = mLen
+  }
+  const Gquaddivisor = opts.common.param('modexpGquaddivisorGas')
+  let gasUsed
+
+  if (!(opts.common.isActivatedEIP(2565) === true)) {
+    gasUsed = (adjustedELen * multiplicationComplexity(maxLen)) / Gquaddivisor
+  } else {
+    gasUsed = (adjustedELen * multiplicationComplexityEIP2565(maxLen)) / Gquaddivisor
+    if (gasUsed < BIGINT_200) {
+      gasUsed = BIGINT_200
+    }
+  }
+  if (!(gasLimitCheck(opts, gasUsed, pName) === true)) {
+    return false
+  }
+  return true
+}
+
+describe('Precompiles: MODEXP with EIP-7823', async () => {
+  const common = new Common({ chain: Mainnet, eips: [7823] })
+  const evm = await createEVM({
+    common,
+  })
+  const addressStr = '0000000000000000000000000000000000000005'
+  const MODEXP = getActivePrecompiles(common).get(addressStr)!
+
+  for (let i = 1020; i < 1028; i++) {
+    const bLen = i
+    const eLen = i
+    const mLen = i
+    const maxInputLen = Math.max(bLen, eLen, mLen)
+    const base = randomBytes(bLen)
+    const exponent = randomBytes(eLen)
+    const modulo = randomBytes(mLen)
+    const expected = expMod(bytesToBigInt(base), bytesToBigInt(exponent), bytesToBigInt(modulo))
+    const input = concatBytes(
+      setLengthLeft(toBytes(bLen), 32),
+      setLengthLeft(toBytes(eLen), 32),
+      setLengthLeft(toBytes(mLen), 32),
+      concatBytes(base, exponent, modulo),
+    )
+
+    it(`MODEXP should reject and consume all gas for inputs over 8192 bits in length - case ${maxInputLen} bytes`, async () => {
+      const opts = {
+        data: input,
+        gasLimit: BigInt(0xffffffff),
+        common,
+        _EVM: evm,
+      }
+
+      // sanity check to make sure there is enough gas in order to isolate error to cases causing OOG due to size limit of inputs
+      while (!enoughGas(opts)) opts.gasLimit *= BigInt(256)
+
+      const result = await MODEXP(opts)
+      if (maxInputLen > 1024) {
+        assert.strictEqual(result.exceptionError?.error, 'out of gas')
+      } else {
+        assert.deepEqual(bytesToBigInt(result.returnValue), expected)
+      }
+    })
+  }
+})