From fac51693953d94f7ee96751441b3d4e3613ef068 Mon Sep 17 00:00:00 2001
From: Gabriel Rocheleau <contact@rockwaterweb.com>
Date: Tue, 29 Oct 2024 06:35:40 -0700
Subject: [PATCH] vm: verkle adjustments (#3775)

* initialize witness

* fix typo in postState verification check

* Reorganize verkle checks

* fix code chunking size calculation

* remove extraneous debug log

* clean up logging
---
 .../src/statefulVerkleStateManager.ts         |  5 +-
 packages/vm/src/runBlock.ts                   | 56 +++++++++----------
 2 files changed, 29 insertions(+), 32 deletions(-)

diff --git a/packages/statemanager/src/statefulVerkleStateManager.ts b/packages/statemanager/src/statefulVerkleStateManager.ts
index 42b610326d..30aec348f5 100644
--- a/packages/statemanager/src/statefulVerkleStateManager.ts
+++ b/packages/statemanager/src/statefulVerkleStateManager.ts
@@ -385,9 +385,9 @@ export class StatefulVerkleStateManager implements StateManagerInterface {
       // Determine code ending byte (if we're on the last chunk)
       let sliceEnd = 32
       if (x === chunks.length - 1) {
-        sliceEnd = (codeSize % VERKLE_CODE_CHUNK_SIZE) + 1
+        // On the last chunk, the end of the slice is either codeSize (if only one chunk) or codeSize % chunkSize
+        sliceEnd = (x === 0 ? codeSize : codeSize % VERKLE_CODE_CHUNK_SIZE) + 1
       }
-
       code.set(chunks[x]!.slice(1, sliceEnd), code.byteOffset + x * VERKLE_CODE_CHUNK_SIZE)
     }
     this._caches?.code?.put(address, code)
@@ -538,7 +538,6 @@ export class StatefulVerkleStateManager implements StateManagerInterface {
           return bytesToHex(basicDataBytes)
         } else {
           const encodedAccount = this._caches?.account?.get(address)?.accountRLP
-          this._debug(`we have encoded account ${encodedAccount}`)
           if (encodedAccount === undefined) {
             return null
           }
diff --git a/packages/vm/src/runBlock.ts b/packages/vm/src/runBlock.ts
index 0ec31d43d4..520960df2f 100644
--- a/packages/vm/src/runBlock.ts
+++ b/packages/vm/src/runBlock.ts
@@ -47,6 +47,7 @@ import type {
 import type { VM } from './vm.js'
 import type { Block } from '@ethereumjs/block'
 import type { Common } from '@ethereumjs/common'
+import type { StatefulVerkleStateManager } from '@ethereumjs/statemanager'
 import type { CLRequest, CLRequestType, PrefixedHexString } from '@ethereumjs/util'
 
 const debug = debugDefault('vm:block')
@@ -134,40 +135,37 @@ export async function runBlock(vm: VM, opts: RunBlockOpts): Promise<RunBlockResu
   }
 
   if (vm.common.isActivatedEIP(6800)) {
-    // We only do these checks if operating statelessly since the execution witness is
-    // constructed during stateful execution
-    if (stateManager instanceof StatelessVerkleStateManager) {
-      if (typeof stateManager.initVerkleExecutionWitness !== 'function') {
-        throw Error(`StatelessVerkleStateManager needed for execution of verkle blocks`)
-      }
+    // Initialize the access witness
+    if ((stateManager as any)['verkleCrypto'] === undefined)
+      throw Error('verkleCrypto required when EIP-6800 is active')
+    vm.evm.verkleAccessWitness = new VerkleAccessWitness({
+      verkleCrypto: (stateManager as StatefulVerkleStateManager).verkleCrypto,
+    })
 
-      if (vm.DEBUG) {
-        debug(`Initializing StatelessVerkleStateManager executionWitness`)
-      }
-      if (clearCache) {
-        stateManager.clearCaches()
-      }
+    if (typeof stateManager.initVerkleExecutionWitness !== 'function') {
+      throw Error(`VerkleStateManager needed for execution of verkle blocks`)
+    }
 
-      // Update the stateRoot cache
-      await stateManager.setStateRoot(block.header.stateRoot)
+    if (vm.DEBUG) {
+      debug(`Initializing executionWitness`)
+    }
+    if (clearCache) {
+      stateManager.clearCaches()
+    }
 
-      // Initialize the access witness
-      vm.evm.verkleAccessWitness = new VerkleAccessWitness({
-        verkleCrypto: stateManager.verkleCrypto,
-      })
-      // Populate the execution witness
-      stateManager.initVerkleExecutionWitness!(block.header.number, block.executionWitness)
+    // Populate the execution witness
+    stateManager.initVerkleExecutionWitness!(block.header.number, block.executionWitness)
 
-      if (
-        stateManager instanceof StatelessVerkleStateManager &&
-        verifyVerkleStateProof(stateManager) === false
-      ) {
+    if (stateManager instanceof StatelessVerkleStateManager) {
+      // Update the stateRoot cache
+      await stateManager.setStateRoot(block.header.stateRoot)
+      if (verifyVerkleStateProof(stateManager) === true) {
+        if (vm.DEBUG) {
+          debug(`Verkle proof verification succeeded`)
+        }
+      } else {
         throw Error(`Verkle proof verification failed`)
       }
-
-      if (vm.DEBUG) {
-        debug(`Verkle proof verification succeeded`)
-      }
     }
   } else {
     if (typeof stateManager.initVerkleExecutionWitness === 'function') {
@@ -327,7 +325,7 @@ export async function runBlock(vm: VM, opts: RunBlockOpts): Promise<RunBlockResu
       }
       // If verkle is activated and executing statelessly, only validate the post-state
       if (
-        !(await vm['_opts'].stateManager!.verifyPostState!(vm.evm.verkleAccessWitness)) === false
+        (await vm['_opts'].stateManager!.verifyPostState!(vm.evm.verkleAccessWitness)) === false
       ) {
         throw new Error(`Verkle post state verification failed on block ${block.header.number}`)
       }