vm/common: add EIP 2565, ModExp precompile gas cost

Author: jochem-brouwer

packages/common/src/eips/2565.json

@@ -0,0 +1,17 @@
+{
+    "name": "EIP-2565",
+    "number": 2565,
+    "comment": "ModExp gas cost",
+    "url": "https://eips.ethereum.org/EIPS/eip-2565",
+    "status": "Last call",
+    "minimumHardfork": "byzantium",
+    "gasConfig": {},
+    "gasPrices": {
+        "modexpGquaddivisor": {
+            "v": 3,
+            "d": "Gquaddivisor from modexp precompile for gas calculation"
+        }
+    },
+    "vm": {},
+    "pow": {}
+}

packages/common/src/eips/index.ts

@@ -3,5 +3,6 @@ import { eipsType } from './../types'
 export const EIPs: eipsType = {
   2315: require('./2315.json'),
   2537: require('./2537.json'),
+  2565: require('./2565.json'),
   2929: require('./2929.json'),
 }

packages/vm/lib/evm/precompiles/05-modexp.ts

@@ -22,6 +22,38 @@ function multComplexity(x: BN): BN {
   }
 }
 
+function calculateGasEIP2565(
+  baseLength: BN,
+  modulusLength: BN,
+  exponentLength: BN,
+  exponent: BN
+): BN {
+  console.log(
+    baseLength.toNumber(),
+    modulusLength.toNumber(),
+    exponentLength.toNumber(),
+    exponent.toNumber()
+  )
+  const maxLength = BN.max(baseLength, modulusLength)
+  const words = maxLength.divn(8)
+  // Ceil operation
+  if (maxLength.mod(new BN(8)).gtn(0)) {
+    words.iaddn(1)
+  }
+  const multiplicationComplexity = words.pow(new BN(2))
+  let iterationCount
+  if (exponentLength.lten(32) && exponent.eqn(0)) {
+    iterationCount = new BN(0)
+  } else if (exponentLength.lten(32)) {
+    iterationCount = new BN(exponent.bitLength() - 1)
+  } else {
+    const expMask = exponent.and(new BN(Buffer.alloc(32, 0xff)))
+    iterationCount = new BN(8).mul(exponentLength.subn(32)).addn(expMask.bitLength() - 1)
+  }
+  iterationCount = BN.max(new BN(1), iterationCount)
+  return BN.max(new BN(200), multiplicationComplexity.mul(iterationCount).divn(3))
+}
+
 function getAdjustedExponentLength(data: Buffer): BN {
   let expBytesStart
   try {
@@ -86,7 +118,35 @@ export default function (opts: PrecompileInput): ExecResult {
     maxLen = mLen
   }
   const Gquaddivisor = opts._common.param('gasPrices', 'modexpGquaddivisor')
-  const gasUsed = adjustedELen.mul(multComplexity(maxLen)).divn(Gquaddivisor)
+  let gasUsed
+
+  const bStart = new BN(96)
+  const bEnd = bStart.add(bLen)
+  const eStart = bEnd
+  const eEnd = eStart.add(eLen)
+  const mStart = eEnd
+  const mEnd = mStart.add(mLen)
+
+  const maxInt = new BN(Number.MAX_SAFE_INTEGER)
+  const maxSize = new BN(2147483647) // ethereumjs-util setLengthRight limitation
+
+  if (bLen.gt(maxSize) || eLen.gt(maxSize) || mLen.gt(maxSize)) {
+    return OOGResult(opts.gasLimit)
+  }
+
+  if (mEnd.gt(maxInt)) {
+    return OOGResult(opts.gasLimit)
+  }
+
+  const B = new BN(setLengthRight(data.slice(bStart.toNumber(), bEnd.toNumber()), bLen.toNumber()))
+  const E = new BN(setLengthRight(data.slice(eStart.toNumber(), eEnd.toNumber()), eLen.toNumber()))
+  const M = new BN(setLengthRight(data.slice(mStart.toNumber(), mEnd.toNumber()), mLen.toNumber()))
+
+  if (!opts._common.eips().includes(2565)) {
+    gasUsed = adjustedELen.mul(multComplexity(maxLen)).divn(Gquaddivisor)
+  } else {
+    gasUsed = calculateGasEIP2565(bLen, eLen, mLen, E)
+  }
 
   if (opts.gasLimit.lt(gasUsed)) {
     return OOGResult(opts.gasLimit)
@@ -106,28 +166,6 @@ export default function (opts: PrecompileInput): ExecResult {
     }
   }
 
-  const maxInt = new BN(Number.MAX_SAFE_INTEGER)
-  const maxSize = new BN(2147483647) // ethereumjs-util setLengthRight limitation
-
-  if (bLen.gt(maxSize) || eLen.gt(maxSize) || mLen.gt(maxSize)) {
-    return OOGResult(opts.gasLimit)
-  }
-
-  const bStart = new BN(96)
-  const bEnd = bStart.add(bLen)
-  const eStart = bEnd
-  const eEnd = eStart.add(eLen)
-  const mStart = eEnd
-  const mEnd = mStart.add(mLen)
-
-  if (mEnd.gt(maxInt)) {
-    return OOGResult(opts.gasLimit)
-  }
-
-  const B = new BN(setLengthRight(data.slice(bStart.toNumber(), bEnd.toNumber()), bLen.toNumber()))
-  const E = new BN(setLengthRight(data.slice(eStart.toNumber(), eEnd.toNumber()), eLen.toNumber()))
-  const M = new BN(setLengthRight(data.slice(mStart.toNumber(), mEnd.toNumber()), mLen.toNumber()))
-
   let R
   if (M.isZero()) {
     R = new BN(0)

packages/vm/lib/index.ts

@@ -163,7 +163,7 @@ export default class VM extends AsyncEventEmitter {
 
     if (opts.common) {
       //EIPs
-      const supportedEIPs = [2537, 2929]
+      const supportedEIPs = [2537, 2565, 2929]
       for (const eip of opts.common.eips()) {
         if (!supportedEIPs.includes(eip)) {
           throw new Error(`${eip} is not supported by the VM`)

packages/vm/tests/api/EIPs/eip-2565-modexp-gas-cost.spec.ts

@@ -0,0 +1,49 @@
+import tape from 'tape'
+import { Address, BN } from 'ethereumjs-util'
+import Common from '@ethereumjs/common'
+import VM from '../../../lib'
+
+// See https://github.com/holiman/go-ethereum/blob/2c99023b68c573ba24a5b01db13e000bd9b82417/core/vm/testdata/precompiles/modexp_eip2565.json
+const testData = require('./eip-2565-testdata.json')
+
+tape('EIP-2565 ModExp gas cost tests', (t) => {
+  t.test('Test return data, gas cost and execution status against testdata', async (st) => {
+    const common = new Common({ chain: 'mainnet', hardfork: 'byzantium', eips: [2565] })
+    const vm = new VM({ common: common })
+
+    for (const test of testData) {
+      const testName = test.Name
+      const to = new Address(Buffer.from('0000000000000000000000000000000000000005', 'hex'))
+      const result = await vm.runCall({
+        caller: Address.zero(),
+        gasLimit: new BN(0xffffffffff),
+        to,
+        value: new BN(0),
+        data: Buffer.from(test.Input, 'hex'),
+      })
+
+      if (!result.execResult.gasUsed.eq(new BN(test.Gas))) {
+        st.fail(
+          `[${testName}]: Gas usage incorrect, expected ${
+            test.Gas
+          }, got ${result.execResult.gasUsed.toNumber()}`
+        )
+        continue
+      }
+
+      if (result.execResult.exceptionError) {
+        st.fail(`[${testName}]: Call should not fail`)
+        continue
+      }
+
+      if (!result.execResult.returnValue.equals(Buffer.from(test.Expected, 'hex'))) {
+        st.fail(`[${testName}]: Return value not the expected value`)
+        continue
+      }
+
+      st.pass(`[${testName}]: Call produced the expected results`)
+    }
+
+    st.end()
+  })
+})