@aztec/simulator 0.33.0 → 0.35.0

package/src/public/executor.ts

@@ -1,58 +1,110 @@
 import { UnencryptedFunctionL2Logs } from '@aztec/circuit-types';
-import { Fr, type GlobalVariables, type Header, PublicCircuitPublicInputs } from '@aztec/circuits.js';
+import { Fr, Gas, type GlobalVariables, type Header, PublicCircuitPublicInputs } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 
 import { spawn } from 'child_process';
 import fs from 'fs/promises';
 import path from 'path';
 
-import { Oracle, acvm, extractCallStack, extractReturnWitness } from '../acvm/index.js';
+import { Oracle, acvm, extractCallStack, witnessMapToFields } from '../acvm/index.js';
 import { AvmContext } from '../avm/avm_context.js';
 import { AvmMachineState } from '../avm/avm_machine_state.js';
 import { AvmSimulator } from '../avm/avm_simulator.js';
 import { HostStorage } from '../avm/journal/host_storage.js';
 import { AvmPersistableStateManager } from '../avm/journal/index.js';
-import {
-  isAvmBytecode,
-  temporaryConvertAvmResults,
-  temporaryCreateAvmExecutionEnvironment,
-} from '../avm/temporary_executor_migration.js';
 import { AcirSimulator } from '../client/simulator.js';
 import { ExecutionError, createSimulationError } from '../common/errors.js';
 import { SideEffectCounter } from '../common/index.js';
-import { PackedArgsCache } from '../common/packed_args_cache.js';
+import { PackedValuesCache } from '../common/packed_values_cache.js';
 import { type CommitmentsDB, type PublicContractsDB, type PublicStateDB } from './db.js';
 import { type PublicExecution, type PublicExecutionResult, checkValidStaticCall } from './execution.js';
 import { PublicExecutionContext } from './public_execution_context.js';
+import { convertAvmResults, createAvmExecutionEnvironment, isAvmBytecode } from './transitional_adaptors.js';
 
 /**
  * Execute a public function and return the execution result.
  */
 export async function executePublicFunction(
+  context: PublicExecutionContext,
+  nested: boolean,
+): Promise<PublicExecutionResult> {
+  const bytecode = await context.contractsDb.getBytecode(
+    context.execution.contractAddress,
+    context.execution.functionData.selector,
+  );
+  if (!bytecode) {
+    throw new Error(
+      `Bytecode not found for ${context.execution.contractAddress}:${context.execution.functionData.selector}`,
+    );
+  }
+
+  if (isAvmBytecode(bytecode)) {
+    return await executePublicFunctionAvm(context);
+  } else {
+    return await executePublicFunctionAcvm(context, bytecode, nested);
+  }
+}
+
+async function executePublicFunctionAvm(executionContext: PublicExecutionContext): Promise<PublicExecutionResult> {
+  const address = executionContext.execution.contractAddress;
+  const selector = executionContext.execution.functionData.selector;
+  const log = createDebugLogger('aztec:simulator:public_execution');
+  log.verbose(`[AVM] Executing public external function ${address.toString()}:${selector}.`);
+
+  // Temporary code to construct the AVM context
+  // These data structures will permeate across the simulator when the public executor is phased out
+  const hostStorage = new HostStorage(
+    executionContext.stateDb,
+    executionContext.contractsDb,
+    executionContext.commitmentsDb,
+  );
+  const worldStateJournal = new AvmPersistableStateManager(hostStorage);
+
+  const executionEnv = createAvmExecutionEnvironment(
+    executionContext.execution,
+    executionContext.header,
+    executionContext.globalVariables,
+  );
+
+  const machineState = new AvmMachineState(executionContext.execution.callContext.gasLeft);
+  const context = new AvmContext(worldStateJournal, executionEnv, machineState);
+  const simulator = new AvmSimulator(context);
+
+  const result = await simulator.execute();
+  const newWorldState = context.persistableState.flush();
+
+  log.verbose(
+    `[AVM] ${address.toString()}:${selector} returned, reverted: ${result.reverted}, reason: ${result.revertReason}.`,
+  );
+
+  return await convertAvmResults(executionContext, newWorldState, result, machineState);
+}
+
+async function executePublicFunctionAcvm(
   context: PublicExecutionContext,
   acir: Buffer,
   nested: boolean,
-  log = createDebugLogger('aztec:simulator:public_execution'),
 ): Promise<PublicExecutionResult> {
   const execution = context.execution;
   const { contractAddress, functionData } = execution;
   const selector = functionData.selector;
-  log(`Executing public external function ${contractAddress.toString()}:${selector}`);
+  const log = createDebugLogger('aztec:simulator:public_execution');
+  log.verbose(`[ACVM] Executing public external function ${contractAddress.toString()}:${selector}.`);
 
   const initialWitness = context.getInitialWitness();
   const acvmCallback = new Oracle(context);
-  const { partialWitness, reverted, revertReason } = await acvm(
-    await AcirSimulator.getSolver(),
-    acir,
-    initialWitness,
-    acvmCallback,
-  )
-    .then(result => ({
-      partialWitness: result.partialWitness,
-      reverted: false,
-      revertReason: undefined,
-    }))
-    .catch((err: Error) => {
+
+  const { partialWitness, returnWitnessMap, reverted, revertReason } = await (async () => {
+    try {
+      const result = await acvm(await AcirSimulator.getSolver(), acir, initialWitness, acvmCallback);
+      return {
+        partialWitness: result.partialWitness,
+        returnWitnessMap: result.returnWitness,
+        reverted: false,
+        revertReason: undefined,
+      };
+    } catch (err_) {
+      const err = err_ as Error;
       const ee = new ExecutionError(
         err.message,
         {
@@ -69,11 +121,14 @@ export async function executePublicFunction(
       } else {
         return {
           partialWitness: undefined,
+          returnWitnessMap: undefined,
           reverted: true,
           revertReason: createSimulationError(ee),
         };
       }
-    });
+    }
+  })();
+
   if (reverted) {
     if (!revertReason) {
       throw new Error('Reverted but no revert reason');
@@ -96,6 +151,7 @@ export async function executePublicFunction(
       unencryptedLogs: UnencryptedFunctionL2Logs.empty(),
       reverted,
       revertReason,
+      gasLeft: Gas.empty(),
     };
   }
 
@@ -103,9 +159,9 @@ export async function executePublicFunction(
     throw new Error('No partial witness returned from ACVM');
   }
 
-  const returnWitness = extractReturnWitness(acir, partialWitness);
+  const returnWitness = witnessMapToFields(returnWitnessMap);
   const {
-    returnValues,
+    returnsHash,
     nullifierReadRequests: nullifierReadRequestsPadded,
     nullifierNonExistentReadRequests: nullifierNonExistentReadRequestsPadded,
     newL2ToL1Msgs,
@@ -114,6 +170,7 @@ export async function executePublicFunction(
     startSideEffectCounter,
     endSideEffectCounter,
   } = PublicCircuitPublicInputs.fromFields(returnWitness);
+  const returnValues = await context.unpackReturns(returnsHash);
 
   const nullifierReadRequests = nullifierReadRequestsPadded.filter(v => !v.isEmpty());
   const nullifierNonExistentReadRequests = nullifierNonExistentReadRequestsPadded.filter(v => !v.isEmpty());
@@ -123,12 +180,12 @@ export async function executePublicFunction(
 
   const { contractStorageReads, contractStorageUpdateRequests } = context.getStorageActionData();
 
-  log(
+  log.debug(
     `Contract storage reads: ${contractStorageReads
       .map(r => r.toFriendlyJSON() + ` - sec: ${r.sideEffectCounter}`)
       .join(', ')}`,
   );
-  log(
+  log.debug(
     `Contract storage update requests: ${contractStorageUpdateRequests
       .map(r => r.toFriendlyJSON() + ` - sec: ${r.sideEffectCounter}`)
       .join(', ')}`,
@@ -136,6 +193,7 @@ export async function executePublicFunction(
 
   const nestedExecutions = context.getNestedExecutions();
   const unencryptedLogs = context.getUnencryptedLogs();
+  const gasLeft = context.execution.callContext.gasLeft; // No gas metering for ACVM
 
   return {
     execution,
@@ -153,6 +211,7 @@ export async function executePublicFunction(
     unencryptedLogs,
     reverted: false,
     revertReason: undefined,
+    gasLeft,
   };
 }
 
@@ -179,39 +238,9 @@ export class PublicExecutor {
     globalVariables: GlobalVariables,
     sideEffectCounter: number = 0,
   ): Promise<PublicExecutionResult> {
-    const selector = execution.functionData.selector;
-    const bytecode = await this.contractsDb.getBytecode(execution.contractAddress, selector);
-    if (!bytecode) {
-      throw new Error(`Bytecode not found for ${execution.contractAddress}:${selector}`);
-    }
-
-    if (isAvmBytecode(bytecode)) {
-      return await this.simulateAvm(execution, globalVariables, sideEffectCounter);
-    } else {
-      return await this.simulateAcvm(execution, globalVariables, sideEffectCounter);
-    }
-  }
-
-  /**
-   * Executes a public execution request with the ACVM.
-   * @param execution - The execution to run.
-   * @param globalVariables - The global variables to use.
-   * @returns The result of the run plus all nested runs.
-   */
-  private async simulateAcvm(
-    execution: PublicExecution,
-    globalVariables: GlobalVariables,
-    sideEffectCounter: number = 0,
-  ): Promise<PublicExecutionResult> {
-    const selector = execution.functionData.selector;
-    const acir = await this.contractsDb.getBytecode(execution.contractAddress, selector);
-    if (!acir) {
-      throw new Error(`Bytecode not found for ${execution.contractAddress}:${selector}`);
-    }
-
     // Functions can request to pack arguments before calling other functions.
     // We use this cache to hold the packed arguments.
-    const packedArgs = PackedArgsCache.create([]);
+    const packedArgs = PackedValuesCache.create([]);
 
     const context = new PublicExecutionContext(
       execution,
@@ -224,7 +253,7 @@ export class PublicExecutor {
       this.commitmentsDb,
     );
 
-    const executionResult = await executePublicFunction(context, acir, false /** nested */);
+    const executionResult = await executePublicFunction(context, /*nested=*/ false);
 
     if (executionResult.execution.callContext.isStaticCall) {
       checkValidStaticCall(
@@ -239,35 +268,6 @@ export class PublicExecutor {
     return executionResult;
   }
 
-  /**
-   * Executes a public execution request in the AVM.
-   * @param execution - The execution to run.
-   * @param globalVariables - The global variables to use.
-   * @returns The result of the run plus all nested runs.
-   */
-  private async simulateAvm(
-    execution: PublicExecution,
-    globalVariables: GlobalVariables,
-    _sideEffectCounter = 0,
-  ): Promise<PublicExecutionResult> {
-    // Temporary code to construct the AVM context
-    // These data structures will permeate across the simulator when the public executor is phased out
-    const hostStorage = new HostStorage(this.stateDb, this.contractsDb, this.commitmentsDb);
-    const worldStateJournal = new AvmPersistableStateManager(hostStorage);
-    const executionEnv = temporaryCreateAvmExecutionEnvironment(execution, globalVariables);
-    // TODO(@spalladino) Load initial gas from the public execution request
-    const machineState = new AvmMachineState(1e10, 1e10, 1e10);
-
-    const context = new AvmContext(worldStateJournal, executionEnv, machineState);
-    const simulator = new AvmSimulator(context);
-
-    const result = await simulator.execute();
-    const newWorldState = context.persistableState.flush();
-
-    // TODO(@spalladino) Read gas left from machineState and return it
-    return temporaryConvertAvmResults(execution, newWorldState, result);
-  }
-
   /**
    * These functions are currently housed in the temporary executor as it relies on access to
    * oracles like the contractsDB and this is the least intrusive way to achieve this.
@@ -305,7 +305,7 @@ export class PublicExecutor {
 
     const bbExec = path.join(bbPath, 'build', 'bin', 'bb');
     const bbArgs = ['avm_prove', '-b', bytecodePath, '-d', calldataPath, '-o', proofPath];
-    this.log(`calling '${bbExec} ${bbArgs.join(' ')}'`);
+    this.log.debug(`calling '${bbExec} ${bbArgs.join(' ')}'`);
     const bbBinary = spawn(bbExec, bbArgs);
 
     // The binary writes the proof and the verification key to the write path.
@@ -314,7 +314,7 @@ export class PublicExecutor {
       let stderr: string = '';
 
       bbBinary.on('close', () => {
-        this.log(`Proof generation complete. Reading proof and vk from ${proofPath}.`);
+        this.log.verbose(`Proof generation complete. Reading proof and vk from ${proofPath}.`);
         return resolve(Promise.all([fs.readFile(proofPath), fs.readFile(path.join(artifactsPath, 'vk'))]));
       });
 
@@ -324,7 +324,7 @@ export class PublicExecutor {
       });
       bbBinary.stdout.on('end', () => {
         if (stdout.length > 0) {
-          this.log(`stdout: ${stdout}`);
+          this.log.debug(`stdout: ${stdout}`);
         }
       });
 
@@ -334,7 +334,7 @@ export class PublicExecutor {
       });
       bbBinary.stderr.on('end', () => {
         if (stderr.length > 0) {
-          this.log(`stderr: ${stderr}`);
+          this.log.warn(`stderr: ${stderr}`);
         }
       });
 
@@ -366,7 +366,7 @@ export class PublicExecutor {
 
     const bbExec = path.join(bbPath, 'build', 'bin', 'bb');
     const bbArgs = ['avm_verify', '-p', proofPath];
-    this.log(`calling '${bbPath} ${bbArgs.join(' ')}'`);
+    this.log.debug(`calling '${bbPath} ${bbArgs.join(' ')}'`);
     const bbBinary = spawn(bbExec, bbArgs);
 
     // The binary prints to stdout 1 if the proof is valid and 0 if it is not.

package/src/public/hints_builder.ts

@@ -0,0 +1,119 @@
+import { MerkleTreeId } from '@aztec/circuit-types';
+import {
+  type Fr,
+  MAX_NEW_NULLIFIERS_PER_TX,
+  type MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX,
+  type MAX_NULLIFIER_READ_REQUESTS_PER_TX,
+  MAX_PUBLIC_DATA_READS_PER_TX,
+  MembershipWitness,
+  NULLIFIER_TREE_HEIGHT,
+  PUBLIC_DATA_TREE_HEIGHT,
+  type PublicDataRead,
+  PublicDataTreeLeafPreimage,
+  type ReadRequestContext,
+  type SideEffectLinkedToNoteHash,
+  buildNullifierNonExistentReadRequestHints,
+  buildNullifierReadRequestHints,
+  mergeAccumulatedData,
+} from '@aztec/circuits.js';
+import { makeTuple } from '@aztec/foundation/array';
+import { type Tuple } from '@aztec/foundation/serialize';
+import { type MerkleTreeOperations } from '@aztec/world-state';
+
+export class HintsBuilder {
+  constructor(private db: MerkleTreeOperations) {}
+
+  getNullifierReadRequestHints(
+    nullifierReadRequests: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
+    nullifiersNonRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NEW_NULLIFIERS_PER_TX>,
+    nullifiersRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NEW_NULLIFIERS_PER_TX>,
+  ) {
+    return buildNullifierReadRequestHints(
+      this,
+      nullifierReadRequests,
+      mergeAccumulatedData(MAX_NEW_NULLIFIERS_PER_TX, nullifiersNonRevertible, nullifiersRevertible),
+    );
+  }
+
+  getNullifierNonExistentReadRequestHints(
+    nullifierNonExistentReadRequests: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_NON_EXISTENT_READ_REQUESTS_PER_TX>,
+    nullifiersNonRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NEW_NULLIFIERS_PER_TX>,
+    nullifiersRevertible: Tuple<SideEffectLinkedToNoteHash, typeof MAX_NEW_NULLIFIERS_PER_TX>,
+  ) {
+    const pendingNullifiers = mergeAccumulatedData(
+      MAX_NEW_NULLIFIERS_PER_TX,
+      nullifiersNonRevertible,
+      nullifiersRevertible,
+    );
+    return buildNullifierNonExistentReadRequestHints(this, nullifierNonExistentReadRequests, pendingNullifiers);
+  }
+
+  async getNullifierMembershipWitness(nullifier: Fr) {
+    const index = await this.db.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBuffer());
+    if (index === undefined) {
+      return;
+    }
+
+    return this.getNullifierMembershipWitnessWithPreimage(index);
+  }
+
+  async getLowNullifierMembershipWitness(nullifier: Fr) {
+    const res = await this.db.getPreviousValueIndex(MerkleTreeId.NULLIFIER_TREE, nullifier.toBigInt());
+    if (res === undefined) {
+      throw new Error(`Cannot find the low leaf for nullifier ${nullifier.toBigInt()}.`);
+    }
+
+    const { index, alreadyPresent } = res;
+    if (alreadyPresent) {
+      throw new Error(`Nullifier ${nullifier.toBigInt()} already exists in the tree.`);
+    }
+
+    return this.getNullifierMembershipWitnessWithPreimage(index);
+  }
+
+  private async getNullifierMembershipWitnessWithPreimage(index: bigint) {
+    const siblingPath = await this.db.getSiblingPath<typeof NULLIFIER_TREE_HEIGHT>(MerkleTreeId.NULLIFIER_TREE, index);
+    const membershipWitness = new MembershipWitness(
+      NULLIFIER_TREE_HEIGHT,
+      index,
+      siblingPath.toTuple<typeof NULLIFIER_TREE_HEIGHT>(),
+    );
+
+    const leafPreimage = await this.db.getLeafPreimage(MerkleTreeId.NULLIFIER_TREE, index);
+    if (!leafPreimage) {
+      throw new Error(`Cannot find the leaf preimage at index ${index}.`);
+    }
+
+    return { membershipWitness, leafPreimage };
+  }
+
+  async getPublicDataReadsInfo(publicDataReads: PublicDataRead[]) {
+    const newPublicDataReadsWitnesses: Tuple<
+      MembershipWitness<typeof PUBLIC_DATA_TREE_HEIGHT>,
+      typeof MAX_PUBLIC_DATA_READS_PER_TX
+    > = makeTuple(MAX_PUBLIC_DATA_READS_PER_TX, () => MembershipWitness.empty(PUBLIC_DATA_TREE_HEIGHT, 0n));
+
+    const newPublicDataReadsPreimages: Tuple<PublicDataTreeLeafPreimage, typeof MAX_PUBLIC_DATA_READS_PER_TX> =
+      makeTuple(MAX_PUBLIC_DATA_READS_PER_TX, () => PublicDataTreeLeafPreimage.empty());
+
+    for (const i in publicDataReads) {
+      const leafSlot = publicDataReads[i].leafSlot.value;
+      const lowLeafResult = await this.db.getPreviousValueIndex(MerkleTreeId.PUBLIC_DATA_TREE, leafSlot);
+      if (!lowLeafResult) {
+        throw new Error(`Public data tree should have one initial leaf`);
+      }
+      const preimage = await this.db.getLeafPreimage(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
+      const path = await this.db.getSiblingPath(MerkleTreeId.PUBLIC_DATA_TREE, lowLeafResult.index);
+      newPublicDataReadsWitnesses[i] = new MembershipWitness(
+        PUBLIC_DATA_TREE_HEIGHT,
+        BigInt(lowLeafResult.index),
+        path.toTuple<typeof PUBLIC_DATA_TREE_HEIGHT>(),
+      );
+      newPublicDataReadsPreimages[i] = preimage! as PublicDataTreeLeafPreimage;
+    }
+    return {
+      newPublicDataReadsWitnesses,
+      newPublicDataReadsPreimages,
+    };
+  }
+}

package/src/public/index.ts

@@ -7,3 +7,8 @@ export {
   collectPublicDataUpdateRequests,
 } from './execution.js';
 export { PublicExecutor } from './executor.js';
+export { PublicProcessor, PublicProcessorFactory } from './public_processor.js';
+export * from './public_executor.js';
+export * from './abstract_phase_manager.js';
+export * from './public_kernel_circuit_simulator.js';
+export * from './public_kernel.js';

package/src/public/phase_manager_factory.ts

@@ -0,0 +1,126 @@
+import { type Tx } from '@aztec/circuit-types';
+import { type GlobalVariables, type Header, type PublicKernelCircuitPublicInputs } from '@aztec/circuits.js';
+import { type PublicExecutor, type PublicStateDB } from '@aztec/simulator';
+import { type MerkleTreeOperations } from '@aztec/world-state';
+
+import { type AbstractPhaseManager, PublicKernelPhase } from './abstract_phase_manager.js';
+import { AppLogicPhaseManager } from './app_logic_phase_manager.js';
+import { type ContractsDataSourcePublicDB } from './public_executor.js';
+import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
+import { SetupPhaseManager } from './setup_phase_manager.js';
+import { TailPhaseManager } from './tail_phase_manager.js';
+import { TeardownPhaseManager } from './teardown_phase_manager.js';
+
+export class PhaseDidNotChangeError extends Error {
+  constructor(phase: PublicKernelPhase) {
+    super(`Tried to advance the phase from [${phase}] when the circuit still needs [${phase}]`);
+  }
+}
+
+export class CannotTransitionToSetupError extends Error {
+  constructor() {
+    super('Cannot transition to setup phase');
+  }
+}
+
+export class PhaseManagerFactory {
+  public static phaseFromTx(
+    tx: Tx,
+    db: MerkleTreeOperations,
+    publicExecutor: PublicExecutor,
+    publicKernel: PublicKernelCircuitSimulator,
+    globalVariables: GlobalVariables,
+    historicalHeader: Header,
+    publicContractsDB: ContractsDataSourcePublicDB,
+    publicStateDB: PublicStateDB,
+  ): AbstractPhaseManager | undefined {
+    const data = tx.data.forPublic!;
+    if (data.needsSetup) {
+      return new SetupPhaseManager(
+        db,
+        publicExecutor,
+        publicKernel,
+        globalVariables,
+        historicalHeader,
+        publicContractsDB,
+        publicStateDB,
+      );
+    } else if (data.needsAppLogic) {
+      return new AppLogicPhaseManager(
+        db,
+        publicExecutor,
+        publicKernel,
+        globalVariables,
+        historicalHeader,
+        publicContractsDB,
+        publicStateDB,
+      );
+    } else if (data.needsTeardown) {
+      return new TeardownPhaseManager(
+        db,
+        publicExecutor,
+        publicKernel,
+        globalVariables,
+        historicalHeader,
+        publicContractsDB,
+        publicStateDB,
+      );
+    } else {
+      return undefined;
+    }
+  }
+
+  public static phaseFromOutput(
+    output: PublicKernelCircuitPublicInputs,
+    currentPhaseManager: AbstractPhaseManager,
+    db: MerkleTreeOperations,
+    publicExecutor: PublicExecutor,
+    publicKernel: PublicKernelCircuitSimulator,
+    globalVariables: GlobalVariables,
+    historicalHeader: Header,
+    publicContractsDB: ContractsDataSourcePublicDB,
+    publicStateDB: PublicStateDB,
+  ): AbstractPhaseManager | undefined {
+    if (output.needsSetup) {
+      throw new CannotTransitionToSetupError();
+    } else if (output.needsAppLogic) {
+      if (currentPhaseManager.phase === PublicKernelPhase.APP_LOGIC) {
+        throw new PhaseDidNotChangeError(currentPhaseManager.phase);
+      }
+      return new AppLogicPhaseManager(
+        db,
+        publicExecutor,
+        publicKernel,
+        globalVariables,
+        historicalHeader,
+        publicContractsDB,
+        publicStateDB,
+      );
+    } else if (output.needsTeardown) {
+      if (currentPhaseManager.phase === PublicKernelPhase.TEARDOWN) {
+        throw new PhaseDidNotChangeError(currentPhaseManager.phase);
+      }
+      return new TeardownPhaseManager(
+        db,
+        publicExecutor,
+        publicKernel,
+        globalVariables,
+        historicalHeader,
+        publicContractsDB,
+        publicStateDB,
+      );
+    } else if (currentPhaseManager.phase !== PublicKernelPhase.TAIL) {
+      return new TailPhaseManager(
+        db,
+        publicExecutor,
+        publicKernel,
+        globalVariables,
+        historicalHeader,
+        publicContractsDB,
+        publicStateDB,
+      );
+    } else {
+      return undefined;
+    }
+  }
+}