Implement EIP 2935

packages/common/src/common.ts

@@ -243,7 +243,8 @@ export class Common {
     // Assign hardfork changes in the sequence of the applied hardforks
     this.HARDFORK_CHANGES = this.hardforks().map((hf) => [
       hf.name as HardforkSpecKeys,
-      HARDFORK_SPECS[hf.name as HardforkSpecKeys],
+      HARDFORK_SPECS[hf.name] ??
+        (this._chainParams.customHardforks && this._chainParams.customHardforks[hf.name]),
     ])
     this._hardfork = this.DEFAULT_HARDFORK
     if (opts.hardfork !== undefined) {
@@ -779,6 +780,24 @@ export class Common {
     return null
   }
 
+  /**
+   * Returns the scheduled timestamp of the EIP (if scheduled and scheduled by timestamp)
+   * @param eip EIP number
+   * @returns Scheduled timestamp. If this EIP is unscheduled, or the EIP is scheduled by block number or ttd, then it returns `null`.
+   */
+  eipTimestamp(eip: number): bigint | null {
+    for (const hfChanges of this.HARDFORK_CHANGES) {
+      const hf = hfChanges[1]
+      if ('eips' in hf) {
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        if ((hf['eips'] as any).includes(eip)) {
+          return this.hardforkTimestamp(hfChanges[0])
+        }
+      }
+    }
+    return null
+  }
+
   /**
    * Returns the hardfork change total difficulty (Merge HF) for hardfork provided or set
    * @param hardfork Hardfork name, optional if HF set
@@ -946,7 +965,11 @@ export class Common {
    * @returns {Array} Array with arrays of hardforks
    */
   hardforks(): HardforkTransitionConfig[] {
-    return this._chainParams.hardforks
+    const hfs = this._chainParams.hardforks
+    if (this._chainParams.customHardforks !== undefined) {
+      this._chainParams.customHardforks
+    }
+    return hfs
   }
 
   /**

packages/common/src/eips.ts

@@ -7,6 +7,7 @@ type EIPsDict = {
 }
 
 enum Status {
+  Stagnant = 'stagnant',
   Draft = 'draft',
   Review = 'review',
   Final = 'final',
@@ -190,6 +191,23 @@ export const EIPs: EIPsDict = {
       },
     },
   },
+  2935: {
+    comment: 'Save historical block hashes in state',
+    url: 'https://github.com/ethereum/EIPs/pull/8166/commits/941d3beb084d638be258b8fded6171cf0705a5db',
+    status: Status.Draft,
+    minimumHardfork: Hardfork.Chainstart,
+    requiredEIPs: [],
+    vm: {
+      historyStorageAddress: {
+        v: BigInt('0xfffffffffffffffffffffffffffffffffffffffe'),
+        d: 'The address where the historical blockhashes are stored',
+      },
+      minHistoryServeWindow: {
+        v: BigInt(256),
+        d: 'The minimum amount of blocks to be served by the historical blockhash contract',
+      },
+    },
+  },
   3074: {
     comment: 'AUTH and AUTHCALL opcodes',
     url: 'https://eips.ethereum.org/EIPS/eip-3074',

packages/common/src/hardforks.ts

@@ -1,10 +1,6 @@
-import type { HardforkConfig } from './types.js'
+import type { HardforksDict } from './types.js'
 
-type HardforksDict = {
-  [key: string]: HardforkConfig
-}
-
-enum Status {
+export enum Status {
   Draft = 'draft',
   Review = 'review',
   Final = 'final',

packages/common/src/types.ts

@@ -34,6 +34,7 @@ export interface ChainConfig {
   url?: string
   genesis: GenesisBlockConfig
   hardforks: HardforkTransitionConfig[]
+  customHardforks?: HardforksDict
   bootstrapNodes: BootstrapNodeConfig[]
   dnsNetworks?: string[]
   consensus: ConsensusConfig
@@ -194,3 +195,7 @@ export type HardforkConfig = {
   eips?: number[]
   consensus?: ConsensusConfig
 } & EIPOrHFConfig
+
+export type HardforksDict = {
+  [key: string]: HardforkConfig
+}

packages/common/test/customChains.spec.ts

@@ -1,5 +1,6 @@
 import { assert, describe, it } from 'vitest'
 
+import { Status } from '../src/hardforks.js'
 import { Chain, Common, ConsensusType, CustomChain, Hardfork } from '../src/index.js'
 
 import * as testnet from './data/testnet.json'
@@ -151,6 +152,58 @@ describe('[Common]: Custom chains', () => {
       'customChains, should allow to switch custom chain'
     )
   })
+
+  it('customHardforks parameter: initialization and transition tests', () => {
+    const c = Common.custom({
+      customHardforks: {
+        testEIP2935Hardfork: {
+          name: 'testEIP2935Hardfork',
+          comment: 'Hardfork to test EIP 2935',
+          url: '',
+          status: Status.Final,
+          eips: [2935],
+        },
+      },
+      hardforks: [
+        {
+          name: 'chainstart',
+          block: 0,
+        },
+        {
+          name: 'berlin',
+          block: null,
+          timestamp: 999,
+        },
+        {
+          // Note: this custom hardfork name MUST be in customHardforks as field
+          // If this is not the case, Common will throw with a random error
+          // Should we throw early with a descriptive error? TODO
+          name: 'testEIP2935Hardfork',
+          block: null,
+          timestamp: 1000,
+        },
+      ],
+    })
+    // Note: default HF of Common is currently Shanghai
+    // Did not pass any "hardfork" param
+    assert.equal(c.hardfork(), Hardfork.Shanghai)
+    c.setHardforkBy({
+      blockNumber: 0,
+    })
+    assert.equal(c.hardfork(), Hardfork.Chainstart)
+    c.setHardforkBy({
+      blockNumber: 1,
+      timestamp: 999,
+    })
+    assert.equal(c.hardfork(), Hardfork.Berlin)
+    assert.notOk(c.isActivatedEIP(2935))
+    c.setHardforkBy({
+      blockNumber: 1,
+      timestamp: 1000,
+    })
+    assert.equal(c.hardfork(), 'testEIP2935Hardfork')
+    assert.ok(c.isActivatedEIP(2935))
+  })
 })
 
 describe('custom chain setup with hardforks with undefined/null block numbers', () => {

packages/common/test/eips.spec.ts

@@ -62,4 +62,17 @@ describe('[Common/EIPs]: Initialization / Chain params', () => {
     msg = 'should return null for unscheduled eip'
     assert.equal(c.eipBlock(0), null, msg)
   })
+
+  it('eipTimestamp', () => {
+    const c = new Common({ chain: Chain.Mainnet })
+
+    let msg = 'should return null for unscheduled eip by timestamp'
+    assert.ok(c.eipTimestamp(1559) === null, msg)
+
+    msg = 'should return null for unscheduled eip'
+    assert.equal(c.eipTimestamp(0), null, msg)
+
+    msg = 'should return correct value'
+    assert.equal(c.eipTimestamp(3651), BigInt(1681338455), msg)
+  })
 })

packages/evm/src/evm.ts

@@ -164,8 +164,8 @@ export class EVM implements EVMInterface {
 
     // Supported EIPs
     const supportedEIPs = [
-      1153, 1559, 2315, 2565, 2718, 2929, 2930, 3074, 3198, 3529, 3540, 3541, 3607, 3651, 3670,
-      3855, 3860, 4399, 4895, 4788, 4844, 5133, 5656, 6780, 6800, 7516,
+      1153, 1559, 2315, 2565, 2718, 2929, 2930, 2935, 3074, 3198, 3529, 3540, 3541, 3607, 3651,
+      3670, 3855, 3860, 4399, 4895, 4788, 4844, 5133, 5656, 6780, 6800, 7516,
     ]
 
     for (const eip of this.common.eips()) {

packages/evm/src/journal.ts

@@ -2,6 +2,7 @@
 import {
   Address,
   RIPEMD160_ADDRESS_STRING,
+  bigIntToHex,
   bytesToHex,
   bytesToUnprefixedHex,
   stripHexPrefix,
@@ -198,6 +199,13 @@
         const address = new Address(toBytes('0x' + addressHex))
         const account = await this.stateManager.getAccount(address)
         if (account === undefined || account.isEmpty()) {
+          if (this.common.isActivatedEIP(2935)) {
+            // The history storage address is exempt of state clearing by EIP-158 if the EIP is activated
+            const addr = bigIntToHex(this.common.param('vm', 'historyStorageAddress')).slice(2)
+            if (addressHex === addr) {
+              continue
+            }
+          }
           await this.deleteAccount(address)
           if (this.DEBUG) {
             this._debug(`Cleanup touched account address=${address} (>= SpuriousDragon)`)

packages/evm/src/opcodes/functions.ts

@@ -21,6 +21,7 @@
   SECP256K1_ORDER_DIV_2,
   TWO_POW256,
   bigIntToBytes,
+  bigIntToHex,
   bytesToBigInt,
   bytesToHex,
   concatBytes,
@@ -593,19 +594,35 @@
   // 0x40: BLOCKHASH
   [
     0x40,
-    async function (runState) {
+    async function (runState, common) {
       const number = runState.stack.pop()
 
-      const diff = runState.interpreter.getBlockNumber() - number
-      // block lookups must be within the past 256 blocks
-      if (diff > BIGINT_256 || diff <= BIGINT_0) {
-        runState.stack.push(BIGINT_0)
-        return
-      }
+      if (common.isActivatedEIP(2935)) {
+        if (number >= runState.interpreter.getBlockNumber()) {
+          runState.stack.push(BIGINT_0)
+          return
+        }
 
-      const block = await runState.blockchain.getBlock(Number(number))
+        const historyAddress = Address.fromString(
+          bigIntToHex(common.param('vm', 'historyStorageAddress'))
+        )
+        const key = setLengthLeft(bigIntToBytes(number), 32)
 
-      runState.stack.push(bytesToBigInt(block.hash()))
+        const storage = await runState.stateManager.getContractStorage(historyAddress, key)
+
+        runState.stack.push(bytesToBigInt(storage))
+      } else {
+        const diff = runState.interpreter.getBlockNumber() - number
+        // block lookups must be within the past 256 blocks
+        if (diff > BIGINT_256 || diff <= BIGINT_0) {
+          runState.stack.push(BIGINT_0)
+          return
+        }
+
+        const block = await runState.blockchain.getBlock(Number(number))
+
+        runState.stack.push(bytesToBigInt(block.hash()))
+      }
     },
   ],
   // 0x41: COINBASE

packages/vm/src/runBlock.ts

@@ -8,10 +8,12 @@
   Account,
   Address,
   BIGINT_0,
+  BIGINT_1,
   BIGINT_8,
   GWEI_TO_WEI,
   KECCAK256_RLP,
   bigIntToBytes,
+  bigIntToHex,
   bytesToHex,
   concatBytes,
   equalsBytes,
@@ -350,6 +352,13 @@
       block.header.timestamp
     )
   }
+  if (this.common.isActivatedEIP(2935)) {
+    if (this.DEBUG) {
+      debug(`accumulate parentBlockHash `)
+    }
+
+    await accumulateParentBlockHash.bind(this)(block)
+  }
 
   if (enableProfiler) {
     // eslint-disable-next-line no-console
@@ -407,6 +416,51 @@
   return blockResults
 }
 
+/**
+ * This method runs the logic of EIP 2935 (save blockhashes to state)
+ * It will put the `parentHash` of the block to the storage slot of `block.number - 1` of the history storage contract.
+ * This contract is used to retrieve BLOCKHASHes in EVM if EIP 2935 is activated.
+ * In case that the previous block of `block` is pre-EIP-2935 (so we are on the EIP 2935 fork block), additionally
+ * also add the currently available past blockhashes which are available by BLOCKHASH (so, the past 256 block hashes)
+ * @param this The VM to run on
+ * @param block The current block to save the parent block hash of
+ */
+export async function accumulateParentBlockHash(this: VM, block: Block) {
+  const historyAddress = Address.fromString(
+    bigIntToHex(this.common.param('vm', 'historyStorageAddress'))
+  )
+
+  if ((await this.stateManager.getAccount(historyAddress)) === undefined) {
+    await this.evm.journal.putAccount(historyAddress, new Account())
+  }
+
+  async function putBlockHash(vm: VM, hash: Uint8Array, number: bigint) {
+    const key = setLengthLeft(bigIntToBytes(number), 32)
+    await vm.stateManager.putContractStorage(historyAddress, key, hash)
+  }
+  await putBlockHash(this, block.header.parentHash, block.header.number - BIGINT_1)
+
+  // Check if we are on the fork block
+  const forkTime = this.common.eipTimestamp(2935)
+  if (forkTime === null) {
+    throw new Error('EIP 2935 should be activated by timestamp')
+  }
+  const parentBlock = await this.blockchain.getBlock(block.header.parentHash)
+
+  if (parentBlock.header.timestamp < forkTime) {
+    let ancestor = parentBlock
+    const range = this.common.param('vm', 'minHistoryServeWindow')
+    for (let i = 0; i < Number(range) - 1; i++) {
+      if (ancestor.header.number === BIGINT_0) {
+        break
+      }
+
+      ancestor = await this.blockchain.getBlock(ancestor.header.parentHash)
+      await putBlockHash(this, ancestor.hash(), ancestor.header.number)
+    }
+  }
+}
+
 export async function accumulateParentBeaconBlockRoot(
   this: VM,
   root: Uint8Array,