vm: adjust test runner with verkle state management

packages/client/src/util/rpc.ts

@@ -175,7 +175,7 @@ function checkHeaderAuth(req: any, jwtSecret: Uint8Array): void {
   const token = header.trim().split(' ')[1]
   if (!token) throw Error(`Missing jwt token`)
   const claims = decode(token.trim(), jwtSecret as never as string, false, algorithm)
-  const drift = Math.abs(new Date().getTime() - claims.iat * 1000 ?? 0)
+  const drift = Math.abs(new Date().getTime() - claims.iat * 1000)
   if (drift > ALLOWED_DRIFT) {
     throw Error(`Stale jwt token drift=${drift}, allowed=${ALLOWED_DRIFT}`)
   }

packages/client/test/cli/cli.spec.ts

@@ -57,7 +57,7 @@ describe('[CLI]', () => {
       }
     }
     await clientRunHelper(cliArgs, onData)
-  }, 5000)
+  }, 15000)
   it('should successfully start client with custom inputs for PoA network', async () => {
     const cliArgs = [
       '--rpc',
@@ -117,7 +117,7 @@ describe('[CLI]', () => {
       resolve(undefined)
     }
     await clientRunHelper(cliArgs, onData, true)
-  }, 5000)
+  }, 15000)
   it('should throw error if the same port is assigned to multiple RPC servers', async () => {
     const cliArgs = ['--ws', '--rpc', '--rpcPort=8546']
     const onData = async (
@@ -792,7 +792,7 @@ describe('[CLI]', () => {
       resolve(undefined)
     }
     await clientRunHelper(cliArgs, onData, true)
-  }, 5000)
+  }, 15000)
   it('should not start client with conflicting parameters', async () => {
     const cliArgs = ['--chainId', '--gethGenesis']
     const onData = async (
@@ -807,7 +807,7 @@ describe('[CLI]', () => {
       resolve(undefined)
     }
     await clientRunHelper(cliArgs, onData, true)
-  }, 5000)
+  }, 15000)
   it('should not start client with conflicting parameters', async () => {
     const cliArgs = ['--chainId', '--gethGenesis']
     const onData = async (
@@ -822,7 +822,7 @@ describe('[CLI]', () => {
       resolve(undefined)
     }
     await clientRunHelper(cliArgs, onData, true)
-  }, 5000)
+  }, 15000)
 }, 180000)
 
 describe('verkle execution', () => {

packages/common/src/chains.ts

@@ -121,6 +121,10 @@ export const Mainnet: ChainConfig = {
       name: 'osaka',
       block: null,
     },
+    {
+      name: 'verkle',
+      block: null,
+    },
   ],
   bootstrapNodes: [
     {

packages/vm/package.json

@@ -72,6 +72,7 @@
   "devDependencies": {
     "@ethereumjs/blockchain": "^8.0.0-alpha.1",
     "@ethereumjs/ethash": "^4.0.0-alpha.1",
+    "@ethereumjs/verkle": "^0.2.0-alpha.1",
     "@paulmillr/trusted-setups": "^0.1.2",
     "@types/benchmark": "^1.0.33",
     "@types/core-js": "^2.5.0",

packages/vm/test/tester/config.ts

@@ -1,8 +1,9 @@
 import { Common, Hardfork, Mainnet, createCustomCommon } from '@ethereumjs/common'
-import { type KZG } from '@ethereumjs/util'
+import * as verkle from 'micro-eth-signer/verkle'
 import * as path from 'path'
 
 import type { HardforkTransitionConfig } from '@ethereumjs/common'
+import type { KZG } from '@ethereumjs/util'
 
 /**
  * Default tests path (git submodule: ethereum-tests)
@@ -109,6 +110,7 @@ const normalHardforks = [
   'cancun',
   'prague',
   'osaka',
+  'verkle',
 ]
 
 const transitionNetworks = {
@@ -278,6 +280,69 @@ function setupCommonWithNetworks(network: string, ttd?: number, timestamp?: numb
   return common
 }
 
+/**
+ * Returns a common instance configured for verkle
+ * @param network Network target (this can include EIPs, such as Byzantium+2537+2929)
+ * @param ttd If set: total terminal difficulty to switch to merge
+ * @returns
+ */
+function setupCommonForVerkle(network: string, timestamp?: number, kzg?: KZG) {
+  let ttd
+  // hard fork that verkle tests are filled on
+  const hfName = 'shanghai'
+  const mainnetCommon = new Common({ chain: Mainnet, hardfork: hfName })
+  const hardforks = mainnetCommon.hardforks().slice(0, 17) // skip hardforks after Shanghai
+  const testHardforks: HardforkTransitionConfig[] = []
+  for (const hf of hardforks) {
+    // check if we enable this hf
+    // disable dao hf by default (if enabled at block 0 forces the first 10 blocks to have dao-hard-fork in extraData of block header)
+    if (mainnetCommon.gteHardfork(hf.name) && hf.name !== Hardfork.Dao) {
+      // this hardfork should be activated at block 0
+      testHardforks.push({
+        name: hf.name,
+        // Current type definition Partial<Chain> in Common is currently not allowing to pass in forkHash
+        // forkHash: hf.forkHash,
+        block: 0,
+      })
+    } else {
+      // disable hardforks newer than the test hardfork (but do add "support" for it, it just never gets activated)
+      if (
+        (ttd === undefined && timestamp === undefined) ||
+        (hf.name === 'paris' && ttd !== undefined)
+      ) {
+        testHardforks.push({
+          name: hf.name,
+          block: null,
+        })
+      }
+      if (timestamp !== undefined && hf.name !== Hardfork.Dao) {
+        testHardforks.push({
+          name: hf.name,
+          block: null,
+          timestamp,
+        })
+      }
+    }
+  }
+
+  testHardforks.push({ name: 'verkle', block: 1 })
+  const common = createCustomCommon(
+    {
+      hardforks: testHardforks,
+      defaultHardfork: 'verkle',
+    },
+    Mainnet,
+    { eips: [2935, 3607], customCrypto: { kzg, verkle } },
+  )
+
+  // Activate EIPs
+  const eips = network.match(/(?<=\+)(.\d+)/g)
+  if (eips) {
+    common.setEIPs(eips.map((e: string) => parseInt(e)))
+  }
+  return common
+}
+
 /**
  * Returns a Common for the given network (a test parameter)
  * @param network - the network field of a test.
@@ -292,6 +357,10 @@ export function getCommon(network: string, kzg?: KZG): Common {
     network = retestethAlias[network as keyof typeof retestethAlias]
   }
   let networkLowercase = network.toLowerCase()
+  // Special handler for verkle tests
+  if (networkLowercase.includes('verkle')) {
+    return setupCommonForVerkle(network, undefined, kzg)
+  }
   if (network.includes('+')) {
     const index = network.indexOf('+')
     networkLowercase = network.slice(0, index).toLowerCase()

packages/vm/test/tester/index.ts

@@ -142,6 +142,7 @@ async function runTests() {
     profile: boolean
     bls: EVMBLSInterface
     bn254: EVMBN254Interface
+    stateManager: string
   } = {
     forkConfigVM: FORK_CONFIG_VM,
     forkConfigTestSuite: FORK_CONFIG_TEST_SUITE,
@@ -156,6 +157,7 @@ async function runTests() {
     bls,
     profile: RUN_PROFILER,
     bn254,
+    stateManager: argv.stateManager,
   }
 
   /**

packages/vm/test/tester/runners/BlockchainTestsRunner.ts

@@ -3,26 +3,26 @@ import { EthashConsensus, createBlockchain } from '@ethereumjs/blockchain'
 import { ConsensusAlgorithm } from '@ethereumjs/common'
 import { Ethash } from '@ethereumjs/ethash'
 import { MerklePatriciaTrie } from '@ethereumjs/mpt'
-import { RLP } from '@ethereumjs/rlp'
-import { Caches, MerkleStateManager } from '@ethereumjs/statemanager'
+import { Caches, MerkleStateManager, StatefulVerkleStateManager } from '@ethereumjs/statemanager'
 import { createTxFromRLP } from '@ethereumjs/tx'
 import {
   MapDB,
-  bytesToBigInt,
   bytesToHex,
   hexToBytes,
   isHexString,
   stripHexPrefix,
   toBytes,
 } from '@ethereumjs/util'
+import { createVerkleTree } from '@ethereumjs/verkle'
 
 import { buildBlock, createVM, runBlock } from '../../../src/index.js'
 import { setupPreConditions, verifyPostConditions } from '../../util.js'
 
 import type { Block } from '@ethereumjs/block'
 import type { Blockchain, ConsensusDict } from '@ethereumjs/blockchain'
-import type { Common } from '@ethereumjs/common'
+import type { Common, StateManagerInterface } from '@ethereumjs/common'
 import type { PrefixedHexString } from '@ethereumjs/util'
+import type { VerkleTree } from '@ethereumjs/verkle'
 import type * as tape from 'tape'
 
 function formatBlockHeader(data: any) {
@@ -46,13 +46,25 @@ export async function runBlockchainTest(options: any, testData: any, t: tape.Tes
   let common = options.common.copy() as Common
   common.setHardforkBy({ blockNumber: 0 })
 
+  let stateTree: MerklePatriciaTrie | VerkleTree
+  let stateManager: StateManagerInterface
+
+  if (options.stateManager === 'verkle') {
+    stateTree = await createVerkleTree()
+    stateManager = new StatefulVerkleStateManager({
+      trie: stateTree,
+      common: options.common,
+    })
+  } else {
+    stateTree = new MerklePatriciaTrie({ useKeyHashing: true, common })
+    stateManager = new MerkleStateManager({
+      caches: new Caches(),
+      trie: stateTree,
+      common,
+    })
+  }
+
   let cacheDB = new MapDB()
-  let state = new MerklePatriciaTrie({ useKeyHashing: true, common })
-  let stateManager = new MerkleStateManager({
-    caches: new Caches(),
-    trie: state,
-    common,
-  })
 
   let validatePow = false
   // Only run with block validation when sealEngine present in test file
@@ -86,7 +98,7 @@ export async function runBlockchainTest(options: any, testData: any, t: tape.Tes
   })
 
   if (validatePow) {
-    ;(blockchain.consensus as EthashConsensus)._ethash!.cacheDB = cacheDB as any
+    ;(blockchain.consensus as EthashConsensus)._ethash!.cacheDB = cacheDB
   }
 
   const begin = Date.now()
@@ -134,29 +146,13 @@ export async function runBlockchainTest(options: any, testData: any, t: tape.Tes
       raw[paramAll1] ??
       raw[paramAll2] ??
       raw.blockHeader === undefined) as PrefixedHexString | boolean
-
-    // Here we decode the rlp to extract the block number
-    // The block library cannot be used, as this throws on certain EIP1559 blocks when trying to convert
     try {
-      const blockRlp = hexToBytes(raw.rlp as PrefixedHexString)
-      const decodedRLP: any = RLP.decode(Uint8Array.from(blockRlp))
-      currentBlock = bytesToBigInt(decodedRLP[0][8])
-    } catch (e: any) {
-      await handleError(e, expectException)
-      continue
-    }
-
-    try {
-      const blockRlp = hexToBytes(raw.rlp as PrefixedHexString)
-      // Update common HF
-      let timestamp: bigint | undefined = undefined
-      try {
-        const decoded: any = RLP.decode(blockRlp)
-        timestamp = bytesToBigInt(decoded[0][11])
-        // eslint-disable-next-line no-empty
-      } catch (e) {}
-
-      common.setHardforkBy({ blockNumber: currentBlock, timestamp })
+      // The block library cannot be used, as this throws on certain EIP1559 blocks when trying to convert
+      currentBlock = BigInt(raw.blockHeader.number)
+      common.setHardforkBy({
+        blockNumber: currentBlock,
+        timestamp: BigInt(raw.blockHeader.timestamp),
+      })
 
       // transactionSequence is provided when txs are expected to be rejected.
       // To run this field we try to import them on the current state.
@@ -190,7 +186,27 @@ export async function runBlockchainTest(options: any, testData: any, t: tape.Tes
         await blockBuilder.revert() // will only revert if checkpointed
       }
 
-      const block = createBlockFromRLP(blockRlp, { common, setHardfork: true })
+      let block: Block
+      if (options.stateManager === 'verkle') {
+        // Create the block from the JSON block data since the RLP doesn't include the execution witness
+        block = createBlock(
+          {
+            header: raw.blockHeader,
+            transactions: raw.transactions,
+            uncleHeaders: raw.uncleHeaders,
+            withdrawals: raw.withdrawals,
+            executionWitness: raw.witness,
+          },
+          {
+            common,
+            setHardfork: true,
+          },
+        )
+      } else {
+        const blockRLP = hexToBytes(raw.rlp as PrefixedHexString)
+        block = createBlockFromRLP(blockRLP, { common, setHardfork: true })
+      }
+
       await blockchain.putBlock(block)
 
       // This is a trick to avoid generating the canonical genesis
@@ -224,7 +240,7 @@ export async function runBlockchainTest(options: any, testData: any, t: tape.Tes
           const headBlock = await (vm.blockchain as Blockchain).getIteratorHead()
           await vm.stateManager.setStateRoot(headBlock.header.stateRoot)
         } else {
-          await verifyPostConditions(state, testData.postState, t)
+          await verifyPostConditions(stateTree, testData.postState, t)
         }
 
         throw e
@@ -242,7 +258,7 @@ export async function runBlockchainTest(options: any, testData: any, t: tape.Tes
   }
 
   t.equal(
-    bytesToHex((blockchain as any)._headHeaderHash),
+    bytesToHex(blockchain['_headHeaderHash']),
     '0x' + testData.lastblockhash,
     'correct last header block',
   )
@@ -251,6 +267,5 @@ export async function runBlockchainTest(options: any, testData: any, t: tape.Tes
   const timeSpent = `${(end - begin) / 1000} secs`
   t.comment(`Time: ${timeSpent}`)
 
-  // @ts-ignore Explicitly delete objects for memory optimization (early GC)
-  common = blockchain = state = stateManager = vm = cacheDB = null // eslint-disable-line
+  common = blockchain = stateTree = stateManager = vm = cacheDB = null as any
 }