vm: adjust test runner with verkle state management (#3848)

* vm: first commit general state test runner

* vm: undo lowercase

* add verkle common config

* common: add verkle chain

* vm: add statemanager option to tester

* vm: modularize stateTree and stateManager

* vm: minor adjustments

* tester: blockchain test runner

Author: gabrocheleau

packages/common/src/chains.ts

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

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

@@ -4,7 +4,7 @@ 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,
@@ -15,14 +15,16 @@ import {
   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) {
@@ -47,12 +49,23 @@ export async function runBlockchainTest(options: any, testData: any, t: tape.Tes
   common.setHardforkBy({ blockNumber: 0 })
 
   let cacheDB = new MapDB()
-  let state = new MerklePatriciaTrie({ useKeyHashing: true, common })
-  let stateManager = new MerkleStateManager({
-    caches: new Caches(),
-    trie: state,
-    common,
-  })
+  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 validatePow = false
   // Only run with block validation when sealEngine present in test file
@@ -86,7 +99,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()
@@ -190,7 +203,32 @@ 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') {
+        currentBlock = BigInt(raw.blockHeader.number)
+        common.setHardforkBy({
+          blockNumber: currentBlock,
+          timestamp: BigInt(raw.blockHeader.timestamp),
+        })
+        // 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 +262,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 +280,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 +289,6 @@ 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
+  // Explicitly delete objects for memory optimization (early GC)
+  common = blockchain = stateTree = stateManager = vm = cacheDB = null as any
 }

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

@@ -3,19 +3,25 @@ import { Block } from '@ethereumjs/block'
 import { createBlockchain } from '@ethereumjs/blockchain'
 import { type InterpreterStep } from '@ethereumjs/evm'
 import { MerklePatriciaTrie } from '@ethereumjs/mpt'
-import { Caches, MerkleStateManager } from '@ethereumjs/statemanager'
+import { Caches, MerkleStateManager, StatefulVerkleStateManager } from '@ethereumjs/statemanager'
 import {
   Account,
+  MapDB,
   bytesToHex,
   createAddressFromString,
   equalsBytes,
   toBytes,
 } from '@ethereumjs/util'
+import { createVerkleTree } from '@ethereumjs/verkle'
+import * as verkle from 'micro-eth-signer/verkle'
 
 import { createVM, runTx } from '../../../src/index.js'
 import { makeBlockFromEnv, makeTx, setupPreConditions } from '../../util.js'
 
+import type { StateManagerInterface } from '@ethereumjs/common'
+import type { VerkleTree } from '@ethereumjs/verkle'
 import type * as tape from 'tape'
+const loadVerkleCrypto = () => Promise.resolve(verkle)
 
 function parseTestCases(
   forkConfigTestSuite: string,
@@ -75,23 +81,34 @@ async function runTestCase(options: any, testData: any, t: tape.Test) {
   const begin = Date.now()
   // Copy the common object to not create long-lasting
   // references in memory which might prevent GC
-  const common = options.common.copy()
+  let common = options.common.copy()
   // Have to create a blockchain with empty block as genesisBlock for Merge
   // Otherwise mainnet genesis will throw since this has difficulty nonzero
   const genesisBlock = new Block(undefined, undefined, undefined, undefined, { common })
-  const blockchain = await createBlockchain({ genesisBlock, common })
-  const state = new MerklePatriciaTrie({ useKeyHashing: true, common })
-  const stateManager = new MerkleStateManager({
-    caches: new Caches(),
-    trie: state,
-    common,
-  })
+  let blockchain = await createBlockchain({ genesisBlock, common })
+  let stateTree: VerkleTree | MerklePatriciaTrie
+  let stateManager: StateManagerInterface
+  if (options.stateManager === 'verkle') {
+    const verkleCrypto = await loadVerkleCrypto()
+    stateTree = await createVerkleTree({ verkleCrypto, db: new MapDB() })
+    stateManager = new StatefulVerkleStateManager({
+      common,
+      trie: stateTree,
+    })
+  } else {
+    stateTree = new MerklePatriciaTrie({ useKeyHashing: true, common })
+    stateManager = new MerkleStateManager({
+      caches: new Caches(),
+      trie: stateTree,
+      common,
+    })
+  }
 
   const evmOpts = {
     bls: options.bls,
     bn254: options.bn254,
   }
-  const vm = await createVM({
+  let vm = await createVM({
     stateManager,
     common,
     blockchain,
@@ -107,8 +124,6 @@ async function runTestCase(options: any, testData: any, t: tape.Test) {
   try {
     tx = makeTx(testData.transaction, { common })
   } catch (e: any) {
-    console.log('error: ', e)
-    console.log('testData.transaction: ', testData.transaction)
     execInfo = 'tx instantiation exception'
   }
 
@@ -180,9 +195,7 @@ async function runTestCase(options: any, testData: any, t: tape.Test) {
   vm.evm.events!.removeListener('step', stepHandler)
   vm.events.removeListener('afterTx', afterTxHandler)
 
-  // @ts-ignore Explicitly delete objects for memory optimization (early GC)
-  // TODO FIXME
-  //common = blockchain = state = stateManager = evm = vm = null // eslint-disable-line
+  common = blockchain = stateTree = stateManager = vm = null as any
 
   return parseFloat(timeSpent)
 }