Merge pull request #1026 from ethereumjs/eip-2565

Add EIP 2565, ModExp precompile gas cost

Author: holgerd77

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,11 @@ function multComplexity(x: BN): BN {
   }
 }
 
+function multComplexityEIP2565(x: BN): BN {
+  const words = x.addn(7).divn(8)
+  return words.mul(words)
+}
+
 function getAdjustedExponentLength(data: Buffer): BN {
   let expBytesStart
   try {
@@ -86,7 +91,23 @@ 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)
+
+  if (!opts._common.eips().includes(2565)) {
+    gasUsed = adjustedELen.mul(multComplexity(maxLen)).divn(Gquaddivisor)
+  } else {
+    gasUsed = adjustedELen.mul(multComplexityEIP2565(maxLen)).divn(Gquaddivisor)
+    if (gasUsed.ltn(200)) {
+      gasUsed = new BN(200)
+    }
+  }
 
   if (opts.gasLimit.lt(gasUsed)) {
     return OOGResult(opts.gasLimit)
@@ -95,7 +116,7 @@ export default function (opts: PrecompileInput): ExecResult {
   if (bLen.isZero()) {
     return {
       gasUsed,
-      returnValue: new BN(0).toArrayLike(Buffer, 'be', 1),
+      returnValue: new BN(0).toArrayLike(Buffer, 'be', mLen.toNumber()),
     }
   }
 
@@ -113,21 +134,14 @@ export default function (opts: PrecompileInput): ExecResult {
     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)
+  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 (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,50 @@
+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'))) {
+        console.log(result.execResult.returnValue.toString('hex'))
+        st.fail(`[${testName}]: Return value not the expected value`)
+        continue
+      }
+
+      st.pass(`[${testName}]: Call produced the expected results`)
+    }
+
+    st.end()
+  })
+})