@aztec/simulator 0.44.0 → 0.45.0

package/src/avm/journal/journal.ts

@@ -5,8 +5,8 @@ import { SerializableContractInstance } from '@aztec/types/contracts';
 
 import { type TracedContractInstance } from '../../public/side_effect_trace.js';
 import { type PublicSideEffectTraceInterface } from '../../public/side_effect_trace_interface.js';
+import { type AvmContractCallResult } from '../avm_contract_call_result.js';
 import { type AvmExecutionEnvironment } from '../avm_execution_environment.js';
-import { type AvmContractCallResults } from '../avm_message_call_result.js';
 import { type HostStorage } from './host_storage.js';
 import { NullifierManager } from './nullifiers.js';
 import { PublicStorage } from './public_storage.js';
@@ -25,10 +25,11 @@ export class AvmPersistableStateManager {
 
   constructor(
     /** Reference to node storage */
-    private hostStorage: HostStorage,
+    private readonly hostStorage: HostStorage,
     /** Side effect trace */
-    private trace: PublicSideEffectTraceInterface,
+    private readonly trace: PublicSideEffectTraceInterface,
     /** Public storage, including cached writes */
+    // TODO(5818): make private once no longer accessed in executor
     public readonly publicStorage: PublicStorage,
     /** Nullifier set, including cached/recently-emitted nullifiers */
     private readonly nullifiers: NullifierManager,
@@ -197,9 +198,9 @@ export class AvmPersistableStateManager {
    * @param event - log event selector
    * @param log - log contents
    */
-  public writeUnencryptedLog(contractAddress: Fr, event: Fr, log: Fr[]) {
-    this.log.debug(`UnencryptedL2Log(${contractAddress}) += event ${event} with ${log.length} fields.`);
-    this.trace.traceUnencryptedLog(contractAddress, event, log);
+  public writeUnencryptedLog(contractAddress: Fr, log: Fr[]) {
+    this.log.debug(`UnencryptedL2Log(${contractAddress}) += event with ${log.length} fields.`);
+    this.trace.traceUnencryptedLog(contractAddress, log);
   }
 
   /**
@@ -243,21 +244,23 @@ export class AvmPersistableStateManager {
    */
   public async processNestedCall(
     nestedState: AvmPersistableStateManager,
-    success: boolean,
     nestedEnvironment: AvmExecutionEnvironment,
     startGasLeft: Gas,
     endGasLeft: Gas,
     bytecode: Buffer,
-    avmCallResults: AvmContractCallResults,
+    avmCallResults: AvmContractCallResult,
   ) {
-    if (success) {
+    if (!avmCallResults.reverted) {
       this.acceptNestedCallState(nestedState);
     }
     const functionName =
       (await nestedState.hostStorage.contractsDb.getDebugFunctionName(
         nestedEnvironment.address,
-        nestedEnvironment.temporaryFunctionSelector,
-      )) ?? `${nestedEnvironment.address}:${nestedEnvironment.temporaryFunctionSelector}`;
+        nestedEnvironment.functionSelector,
+      )) ?? `${nestedEnvironment.address}:${nestedEnvironment.functionSelector}`;
+
+    this.log.verbose(`[AVM] Calling nested function ${functionName}`);
+
     this.trace.traceNestedCall(
       nestedState.trace,
       nestedEnvironment,

package/src/avm/journal/public_storage.ts

@@ -16,7 +16,7 @@ type PublicStorageReadResult = {
  */
 export class PublicStorage {
   /** Cached storage writes. */
-  private cache: PublicStorageCache;
+  private readonly cache: PublicStorageCache;
 
   constructor(
     /** Reference to node storage. Checked on parent cache-miss. */
@@ -134,7 +134,7 @@ class PublicStorageCache {
    * mapping storage slot to latest staged write value.
    */
   public cachePerContract: Map<bigint, Map<bigint, Fr>> = new Map();
-  // FIXME: storage ^ should be private, but its value is used in tests for "currentStorageValue"
+  // FIXME: storage ^ should be private, but its value is used in commitToDB
 
   /**
    * Read a staged value from storage, if it has been previously written to.

package/src/avm/opcodes/accrued_substate.ts

@@ -217,20 +217,9 @@ export class EmitUnencryptedLog extends Instruction {
   static type: string = 'EMITUNENCRYPTEDLOG';
   static readonly opcode: Opcode = Opcode.EMITUNENCRYPTEDLOG;
   // Informs (de)serialization. See Instruction.deserialize.
-  static readonly wireFormat = [
-    OperandType.UINT8,
-    OperandType.UINT8,
-    OperandType.UINT32,
-    OperandType.UINT32,
-    OperandType.UINT32,
-  ];
+  static readonly wireFormat = [OperandType.UINT8, OperandType.UINT8, OperandType.UINT32, OperandType.UINT32];
 
-  constructor(
-    private indirect: number,
-    private eventSelectorOffset: number,
-    private logOffset: number,
-    private logSizeOffset: number,
-  ) {
+  constructor(private indirect: number, private logOffset: number, private logSizeOffset: number) {
     super();
   }
 
@@ -241,22 +230,20 @@ export class EmitUnencryptedLog extends Instruction {
 
     const memory = context.machineState.memory.track(this.type);
 
-    const [eventSelectorOffset, logOffset, logSizeOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.eventSelectorOffset, this.logOffset, this.logSizeOffset],
+    const [logOffset, logSizeOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.logOffset, this.logSizeOffset],
       memory,
     );
-    memory.checkTag(TypeTag.FIELD, eventSelectorOffset);
     memory.checkTag(TypeTag.UINT32, logSizeOffset);
     const logSize = memory.get(logSizeOffset).toNumber();
     memory.checkTagsRange(TypeTag.FIELD, logOffset, logSize);
 
     const contractAddress = context.environment.address;
-    const event = memory.get(eventSelectorOffset).toFr();
 
-    const memoryOperations = { reads: 2 + logSize, indirect: this.indirect };
+    const memoryOperations = { reads: 1 + logSize, indirect: this.indirect };
     context.machineState.consumeGas(this.gasCost(memoryOperations));
     const log = memory.getSlice(logOffset, logSize).map(f => f.toFr());
-    context.persistableState.writeUnencryptedLog(contractAddress, event, log);
+    context.persistableState.writeUnencryptedLog(contractAddress, log);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();

package/src/avm/opcodes/environment_getters.ts

@@ -1,6 +1,6 @@
 import type { AvmContext } from '../avm_context.js';
 import type { AvmExecutionEnvironment } from '../avm_execution_environment.js';
-import { Field, type MemoryValue, Uint64 } from '../avm_memory_types.js';
+import { Field, type MemoryValue, Uint32, Uint64 } from '../avm_memory_types.js';
 import { Opcode } from '../serialization/instruction_serialization.js';
 import { GetterInstruction } from './instruction_impl.js';
 
@@ -39,21 +39,12 @@ export class Sender extends EnvironmentGetterInstruction {
   }
 }
 
-export class FeePerL2Gas extends EnvironmentGetterInstruction {
-  static type: string = 'FEEPERL2GAS';
-  static readonly opcode: Opcode = Opcode.FEEPERL2GAS;
-
-  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return new Field(env.feePerL2Gas);
-  }
-}
-
-export class FeePerDAGas extends EnvironmentGetterInstruction {
-  static type: string = 'FEEPERDAGAS';
-  static readonly opcode: Opcode = Opcode.FEEPERDAGAS;
+export class FunctionSelector extends EnvironmentGetterInstruction {
+  static type: string = 'FUNCTIONSELECTOR';
+  static readonly opcode: Opcode = Opcode.FUNCTIONSELECTOR;
 
   protected getEnvironmentValue(env: AvmExecutionEnvironment) {
-    return new Field(env.feePerDaGas);
+    return new Uint32(env.functionSelector.value);
   }
 }
 
@@ -101,3 +92,21 @@ export class Timestamp extends EnvironmentGetterInstruction {
     return new Uint64(env.globals.timestamp.toBigInt());
   }
 }
+
+export class FeePerL2Gas extends EnvironmentGetterInstruction {
+  static type: string = 'FEEPERL2GAS';
+  static readonly opcode: Opcode = Opcode.FEEPERL2GAS;
+
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
+    return new Field(env.globals.gasFees.feePerL2Gas);
+  }
+}
+
+export class FeePerDAGas extends EnvironmentGetterInstruction {
+  static type: string = 'FEEPERDAGAS';
+  static readonly opcode: Opcode = Opcode.FEEPERDAGAS;
+
+  protected getEnvironmentValue(env: AvmExecutionEnvironment) {
+    return new Field(env.globals.gasFees.feePerDaGas);
+  }
+}

package/src/avm/opcodes/external_calls.ts

@@ -2,9 +2,9 @@ import { FunctionSelector, Gas } from '@aztec/circuits.js';
 import { padArrayEnd } from '@aztec/foundation/collection';
 
 import type { AvmContext } from '../avm_context.js';
+import { type AvmContractCallResult } from '../avm_contract_call_result.js';
 import { gasLeftToGas } from '../avm_gas.js';
 import { Field, TypeTag, Uint8 } from '../avm_memory_types.js';
-import { type AvmContractCallResults } from '../avm_message_call_result.js';
 import { AvmSimulator } from '../avm_simulator.js';
 import { RethrownError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
@@ -88,7 +88,7 @@ abstract class ExternalCall extends Instruction {
     );
 
     const simulator = new AvmSimulator(nestedContext);
-    const nestedCallResults: AvmContractCallResults = await simulator.execute();
+    const nestedCallResults: AvmContractCallResult = await simulator.execute();
     const success = !nestedCallResults.reverted;
 
     // TRANSITIONAL: We rethrow here so that the MESSAGE gets propagated.
@@ -120,7 +120,6 @@ abstract class ExternalCall extends Instruction {
     // Accept the nested call's state and trace the nested call
     await context.persistableState.processNestedCall(
       /*nestedState=*/ nestedContext.persistableState,
-      /*success=*/ success,
       /*nestedEnvironment=*/ nestedContext.environment,
       /*startGasLeft=*/ Gas.from(allocatedGas),
       /*endGasLeft=*/ Gas.from(nestedContext.machineState.gasLeft),

package/src/avm/serialization/bytecode_serialization.ts

@@ -21,6 +21,7 @@ import {
   FeePerDAGas,
   FeePerL2Gas,
   FieldDiv,
+  FunctionSelector,
   GetContractInstance,
   InternalCall,
   InternalReturn,
@@ -85,16 +86,16 @@ const INSTRUCTION_SET = () =>
     [Address.opcode, Address],
     [StorageAddress.opcode, StorageAddress],
     [Sender.opcode, Sender],
-    [FeePerL2Gas.opcode, FeePerL2Gas],
-    [FeePerDAGas.opcode, FeePerDAGas],
+    [FunctionSelector.opcode, FunctionSelector],
     [TransactionFee.opcode, TransactionFee],
-    //[Contractcalldepth.opcode, Contractcalldepth],
     // Execution Environment - Globals
     [ChainId.opcode, ChainId],
     [Version.opcode, Version],
     [BlockNumber.opcode, BlockNumber],
     [Timestamp.opcode, Timestamp],
     //[Coinbase.opcode, Coinbase],
+    [FeePerL2Gas.opcode, FeePerL2Gas],
+    [FeePerDAGas.opcode, FeePerDAGas],
     //[Blockl2gaslimit.opcode, Blockl2gaslimit],
     //[Blockdagaslimit.opcode, Blockdagaslimit],
     // Execution Environment - Calldata

package/src/avm/serialization/instruction_serialization.ts

@@ -27,15 +27,15 @@ export enum Opcode {
   ADDRESS,
   STORAGEADDRESS,
   SENDER,
-  FEEPERL2GAS,
-  FEEPERDAGAS,
+  FUNCTIONSELECTOR,
   TRANSACTIONFEE,
-  CONTRACTCALLDEPTH,
   CHAINID,
   VERSION,
   BLOCKNUMBER,
   TIMESTAMP,
   COINBASE,
+  FEEPERL2GAS,
+  FEEPERDAGAS,
   BLOCKL2GASLIMIT,
   BLOCKDAGASLIMIT,
   CALLDATACOPY,

package/src/client/client_execution_context.ts

@@ -678,16 +678,25 @@ export class ClientExecutionContext extends ViewDataOracle {
 
   /**
    * Read the public storage data.
+   * @param contractAddress - The address to read storage from.
    * @param startStorageSlot - The starting storage slot.
+   * @param blockNumber - The block number to read storage at.
    * @param numberOfElements - Number of elements to read from the starting storage slot.
    */
-  public override async storageRead(startStorageSlot: Fr, numberOfElements: number): Promise<Fr[]> {
+  public override async storageRead(
+    contractAddress: Fr,
+    startStorageSlot: Fr,
+    blockNumber: number,
+    numberOfElements: number,
+  ): Promise<Fr[]> {
     const values = [];
     for (let i = 0n; i < numberOfElements; i++) {
       const storageSlot = new Fr(startStorageSlot.value + i);
 
-      const value = await this.aztecNode.getPublicStorageAt(this.callContext.storageContractAddress, storageSlot);
-      this.log.debug(`Oracle storage read: slot=${storageSlot.toString()} value=${value}`);
+      const value = await this.aztecNode.getPublicStorageAt(contractAddress, storageSlot, blockNumber);
+      this.log.debug(
+        `Oracle storage read: slot=${storageSlot.toString()} address-${contractAddress.toString()} value=${value}`,
+      );
 
       values.push(value);
     }

package/src/client/view_data_oracle.ts

@@ -260,16 +260,25 @@ export class ViewDataOracle extends TypedOracle {
 
   /**
    * Read the public storage data.
+   * @param contractAddress - The address to read storage from.
    * @param startStorageSlot - The starting storage slot.
+   * @param blockNumber - The block number to read storage at.
    * @param numberOfElements - Number of elements to read from the starting storage slot.
    */
-  public override async storageRead(startStorageSlot: Fr, numberOfElements: number) {
+  public override async storageRead(
+    contractAddress: Fr,
+    startStorageSlot: Fr,
+    blockNumber: number,
+    numberOfElements: number,
+  ) {
     const values = [];
     for (let i = 0n; i < numberOfElements; i++) {
       const storageSlot = new Fr(startStorageSlot.value + i);
-      const value = await this.aztecNode.getPublicStorageAt(this.contractAddress, storageSlot);
+      const value = await this.aztecNode.getPublicStorageAt(contractAddress, storageSlot, blockNumber);
 
-      this.log.debug(`Oracle storage read: slot=${storageSlot.toString()} value=${value}`);
+      this.log.debug(
+        `Oracle storage read: slot=${storageSlot.toString()} address-${contractAddress.toString()} value=${value}`,
+      );
       values.push(value);
     }
     return values;

package/src/mocks/fixtures.ts

@@ -14,10 +14,10 @@ import { makeAztecAddress, makeSelector } from '@aztec/circuits.js/testing';
 import { FunctionType } from '@aztec/foundation/abi';
 import { padArrayEnd } from '@aztec/foundation/collection';
 
-import { type PublicExecution, type PublicExecutionResult } from '../public/execution.js';
+import { type PublicExecutionRequest, type PublicExecutionResult } from '../public/execution.js';
 
 export class PublicExecutionResultBuilder {
-  private _execution: PublicExecution;
+  private _executionRequest: PublicExecutionRequest;
   private _nestedExecutions: PublicExecutionResult[] = [];
   private _contractStorageUpdateRequests: ContractStorageUpdateRequest[] = [];
   private _contractStorageReads: ContractStorageRead[] = [];
@@ -25,8 +25,8 @@ export class PublicExecutionResultBuilder {
   private _reverted = false;
   private _revertReason: SimulationError | undefined = undefined;
 
-  constructor(execution: PublicExecution) {
-    this._execution = execution;
+  constructor(executionRequest: PublicExecutionRequest) {
+    this._executionRequest = executionRequest;
   }
 
   static fromPublicCallRequest({
@@ -120,7 +120,7 @@ export class PublicExecutionResultBuilder {
 
   build(overrides: Partial<PublicExecutionResult> = {}): PublicExecutionResult {
     return {
-      execution: this._execution,
+      executionRequest: this._executionRequest,
       nestedExecutions: this._nestedExecutions,
       noteHashReadRequests: [],
       nullifierReadRequests: [],

package/src/public/abstract_phase_manager.ts

@@ -57,7 +57,7 @@ import { computeVarArgsHash } from '@aztec/circuits.js/hash';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import {
-  type PublicExecution,
+  type PublicExecutionRequest,
   type PublicExecutionResult,
   type PublicExecutor,
   accumulateReturnValues,
@@ -176,12 +176,14 @@ export abstract class AbstractPhaseManager {
         call => revertibleCallStack.find(p => p.equals(call)) || nonRevertibleCallStack.find(p => p.equals(call)),
       );
 
+    const teardownCallStack = tx.publicTeardownFunctionCall.isEmpty() ? [] : [tx.publicTeardownFunctionCall];
+
     if (callRequestsStack.length === 0) {
       return {
         [PublicKernelType.NON_PUBLIC]: [],
         [PublicKernelType.SETUP]: [],
         [PublicKernelType.APP_LOGIC]: [],
-        [PublicKernelType.TEARDOWN]: [],
+        [PublicKernelType.TEARDOWN]: teardownCallStack,
         [PublicKernelType.TAIL]: [],
       };
     }
@@ -191,8 +193,6 @@ export abstract class AbstractPhaseManager {
       c => revertibleCallStack.findIndex(p => p.equals(c)) !== -1,
     );
 
-    const teardownCallStack = tx.publicTeardownFunctionCall.isEmpty() ? [] : [tx.publicTeardownFunctionCall];
-
     if (firstRevertibleCallIndex === 0) {
       return {
         [PublicKernelType.NON_PUBLIC]: [],
@@ -256,7 +256,7 @@ export abstract class AbstractPhaseManager {
     const enqueuedCallResults = [];
 
     for (const enqueuedCall of enqueuedCalls) {
-      const executionStack: (PublicExecution | PublicExecutionResult)[] = [enqueuedCall];
+      const executionStack: (PublicExecutionRequest | PublicExecutionResult)[] = [enqueuedCall];
 
       // Keep track of which result is for the top/enqueued call
       let enqueuedExecutionResult: PublicExecutionResult | undefined;
@@ -283,10 +283,10 @@ export abstract class AbstractPhaseManager {
 
         // Sanity check for a current upstream assumption.
         // Consumers of the result seem to expect "reverted <=> revertReason !== undefined".
-        const functionSelector = result.execution.functionSelector.toString();
+        const functionSelector = result.executionRequest.functionSelector.toString();
         if (result.reverted && !result.revertReason) {
           throw new Error(
-            `Simulation of ${result.execution.contractAddress.toString()}:${functionSelector}(${
+            `Simulation of ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
               result.functionName
             }) reverted with no reason.`,
           );
@@ -294,7 +294,7 @@ export abstract class AbstractPhaseManager {
 
         if (result.reverted && !PhaseIsRevertible[this.phase]) {
           this.log.debug(
-            `Simulation error on ${result.execution.contractAddress.toString()}:${functionSelector}(${
+            `Simulation error on ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
               result.functionName
             }) with reason: ${result.revertReason}`,
           );
@@ -308,7 +308,7 @@ export abstract class AbstractPhaseManager {
 
         // Simulate the public kernel circuit.
         this.log.debug(
-          `Running public kernel circuit for ${result.execution.contractAddress.toString()}:${functionSelector}(${
+          `Running public kernel circuit for ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
             result.functionName
           })`,
         );
@@ -331,7 +331,7 @@ export abstract class AbstractPhaseManager {
         // but the kernel carries the reverted flag forward. But if the simulator reverts, so should the kernel.
         if (result.reverted && kernelPublicOutput.revertCode.isOK()) {
           throw new Error(
-            `Public kernel circuit did not revert on ${result.execution.contractAddress.toString()}:${functionSelector}(${
+            `Public kernel circuit did not revert on ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
               result.functionName
             }), but simulator did.`,
           );
@@ -341,7 +341,7 @@ export abstract class AbstractPhaseManager {
         // So safely return the revert reason and the kernel output (which has had its revertible side effects dropped)
         if (result.reverted) {
           this.log.debug(
-            `Reverting on ${result.execution.contractAddress.toString()}:${functionSelector}(${
+            `Reverting on ${result.executionRequest.contractAddress.toString()}:${functionSelector}(${
               result.functionName
             }) with reason: ${result.revertReason}`,
           );
@@ -430,9 +430,9 @@ export abstract class AbstractPhaseManager {
     );
 
     const publicCircuitPublicInputs = PublicCircuitPublicInputs.from({
-      callContext: result.execution.callContext,
+      callContext: result.executionRequest.callContext,
       proverAddress: AztecAddress.ZERO,
-      argsHash: computeVarArgsHash(result.execution.args),
+      argsHash: computeVarArgsHash(result.executionRequest.args),
       newNoteHashes: padArrayEnd(result.newNoteHashes, NoteHash.empty(), MAX_NEW_NOTE_HASHES_PER_CALL),
       newNullifiers: padArrayEnd(result.newNullifiers, Nullifier.empty(), MAX_NEW_NULLIFIERS_PER_CALL),
       newL2ToL1Msgs: padArrayEnd(result.newL2ToL1Messages, L2ToL1Message.empty(), MAX_NEW_L2_TO_L1_MSGS_PER_CALL),
@@ -481,8 +481,8 @@ export abstract class AbstractPhaseManager {
     });
 
     return new PublicCallStackItem(
-      result.execution.contractAddress,
-      new FunctionData(result.execution.functionSelector, false),
+      result.executionRequest.contractAddress,
+      new FunctionData(result.executionRequest.functionSelector, false),
       publicCircuitPublicInputs,
       isExecutionRequest,
     );

package/src/public/execution.ts

@@ -18,8 +18,8 @@ import { type Gas } from '../avm/avm_gas.js';
  * The public function execution result.
  */
 export interface PublicExecutionResult {
-  /** The execution that triggered this result. */
-  execution: PublicExecution;
+  /** The execution request that triggered this result. */
+  executionRequest: PublicExecutionRequest;
 
   /** The side effect counter at the start of the function call. */
   startSideEffectCounter: Fr;
@@ -90,9 +90,13 @@ export interface PublicExecutionResult {
 }
 
 /**
- * The execution of a public function.
+ * The execution request of a public function.
+ * A subset of PublicCallRequest
  */
-export type PublicExecution = Pick<PublicCallRequest, 'contractAddress' | 'functionSelector' | 'callContext' | 'args'>;
+export type PublicExecutionRequest = Pick<
+  PublicCallRequest,
+  'contractAddress' | 'functionSelector' | 'callContext' | 'args'
+>;
 
 /**
  * Returns if the input is a public execution result and not just a public execution.
@@ -100,9 +104,9 @@ export type PublicExecution = Pick<PublicCallRequest, 'contractAddress' | 'funct
  * @returns Whether the input is a public execution result and not just a public execution.
  */
 export function isPublicExecutionResult(
-  input: PublicExecution | PublicExecutionResult,
+  input: PublicExecutionRequest | PublicExecutionResult,
 ): input is PublicExecutionResult {
-  return 'execution' in input && input.execution !== undefined;
+  return 'executionRequest' in input && input.executionRequest !== undefined;
 }
 
 /**

package/src/public/executor.ts

@@ -4,21 +4,21 @@ import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 
 import { AvmContext } from '../avm/avm_context.js';
+import { AvmExecutionEnvironment } from '../avm/avm_execution_environment.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 { type CommitmentsDB, type PublicContractsDB, type PublicStateDB } from './db_interfaces.js';
-import { type PublicExecution, type PublicExecutionResult, checkValidStaticCall } from './execution.js';
+import { type PublicExecutionRequest, type PublicExecutionResult } from './execution.js';
 import { PublicSideEffectTrace } from './side_effect_trace.js';
-import { createAvmExecutionEnvironment } from './transitional_adaptors.js';
 
 /**
  * Handles execution of public functions.
  */
 export class PublicExecutor {
   constructor(
-    private readonly stateDb: PublicStateDB,
+    private readonly publicStorageDB: PublicStateDB,
     private readonly contractsDb: PublicContractsDB,
     private readonly commitmentsDb: CommitmentsDB,
     private readonly header: Header,
@@ -38,10 +38,10 @@ export class PublicExecutor {
    * @returns The result of execution, including the results of all nested calls.
    */
   public async simulate(
-    executionRequest: PublicExecution,
+    executionRequest: PublicExecutionRequest,
     globalVariables: GlobalVariables,
     availableGas: Gas,
-    txContext: TxContext,
+    _txContext: TxContext,
     pendingSiloedNullifiers: Nullifier[],
     transactionFee: Fr = Fr.ZERO,
     startSideEffectCounter: number = 0,
@@ -53,7 +53,7 @@ export class PublicExecutor {
     PublicExecutor.log.verbose(`[AVM] Executing public external function ${fnName}.`);
     const timer = new Timer();
 
-    const hostStorage = new HostStorage(this.stateDb, this.contractsDb, this.commitmentsDb);
+    const hostStorage = new HostStorage(this.publicStorageDB, this.contractsDb, this.commitmentsDb);
     const trace = new PublicSideEffectTrace(startSideEffectCounter);
     const avmPersistableState = AvmPersistableStateManager.newWithPendingSiloedNullifiers(
       hostStorage,
@@ -65,7 +65,6 @@ export class PublicExecutor {
       executionRequest,
       this.header,
       globalVariables,
-      txContext.gasSettings,
       transactionFee,
     );
 
@@ -75,7 +74,7 @@ export class PublicExecutor {
     const avmResult = await simulator.execute();
     const bytecode = simulator.getBytecode()!;
 
-    // Commit the journals state to the DBs since this is a top-level execution.
+    // Commit the public storage state to the DBs since this is a top-level execution.
     // Observe that this will write all the state changes to the DBs, not only the latest for each slot.
     // However, the underlying DB keep a cache and will only write the latest state to disk.
     // TODO(dbanks12): this should be unnecessary here or should be exposed by state manager
@@ -105,18 +104,34 @@ export class PublicExecutor {
       // (which counts the request itself)
     );
 
-    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/5818): is this really needed?
-    // should already be handled in simulation.
-    if (executionRequest.callContext.isStaticCall) {
-      checkValidStaticCall(
-        publicExecutionResult.newNoteHashes,
-        publicExecutionResult.newNullifiers,
-        publicExecutionResult.contractStorageUpdateRequests,
-        publicExecutionResult.newL2ToL1Messages,
-        publicExecutionResult.unencryptedLogs,
-      );
-    }
-
     return publicExecutionResult;
   }
 }
+
+/**
+ * Convert a PublicExecutionRequest object to an AvmExecutionEnvironment
+ *
+ * @param executionRequest
+ * @param globalVariables
+ * @returns
+ */
+function createAvmExecutionEnvironment(
+  executionRequest: PublicExecutionRequest,
+  header: Header,
+  globalVariables: GlobalVariables,
+  transactionFee: Fr,
+): AvmExecutionEnvironment {
+  return new AvmExecutionEnvironment(
+    executionRequest.contractAddress,
+    executionRequest.callContext.storageContractAddress,
+    executionRequest.callContext.msgSender,
+    executionRequest.functionSelector,
+    /*contractCallDepth=*/ Fr.zero(),
+    transactionFee,
+    header,
+    globalVariables,
+    executionRequest.callContext.isStaticCall,
+    executionRequest.callContext.isDelegateCall,
+    executionRequest.args,
+  );
+}

package/src/public/index.ts

@@ -1,6 +1,6 @@
 export * from './abstract_phase_manager.js';
 export * from './db_interfaces.js';
-export { isPublicExecutionResult, type PublicExecution, type PublicExecutionResult } from './execution.js';
+export { isPublicExecutionResult, type PublicExecutionRequest, type PublicExecutionResult } from './execution.js';
 export { PublicExecutor } from './executor.js';
 export * from './fee_payment.js';
 export { HintsBuilder } from './hints_builder.js';

package/src/public/public_kernel.ts

@@ -21,8 +21,9 @@ import {
   convertSimulatedPublicTeardownInputsToWitnessMap,
   convertSimulatedPublicTeardownOutputFromWitnessMap,
 } from '@aztec/noir-protocol-circuits-types';
-import { type SimulationProvider, WASMSimulator } from '@aztec/simulator';
 
+import { WASMSimulator } from '../providers/acvm_wasm.js';
+import { type SimulationProvider } from '../providers/simulation_provider.js';
 import { type PublicKernelCircuitSimulator } from './public_kernel_circuit_simulator.js';
 
 /**