@aztec/simulator 0.76.4 → 0.77.0-testnet-ignition.21

package/src/{providers → private/providers}/acvm_wasm_with_blobs.ts

@@ -1,12 +1,12 @@
 import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types/server';
-import { type NoirCompiledCircuit } from '@aztec/types/noir';
+import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
 
 import { type ExecutionError, executeCircuit } from '@noir-lang/acvm_js';
-import { type WitnessMap } from '@noir-lang/types';
+import type { WitnessMap } from '@noir-lang/types';
 
-import { type ACIRCallback, type ACIRExecutionResult } from '../acvm/acvm.js';
-import { type ACVMWitness } from '../acvm/acvm_types.js';
-import { type SimulationProvider, parseErrorPayload } from '../common/simulation_provider.js';
+import type { ACIRCallback, ACIRExecutionResult } from '../acvm/acvm.js';
+import type { ACVMWitness } from '../acvm/acvm_types.js';
+import { type SimulationProvider, parseErrorPayload } from './simulation_provider.js';
 
 /**
  * A simulation provider that uses the WASM simulator with the ability to handle blobs via the foreign call handler.

package/src/{providers → private/providers}/factory.ts

@@ -2,9 +2,9 @@ import { type Logger, createLogger } from '@aztec/foundation/log';
 
 import { promises as fs } from 'fs';
 
-import { type SimulationProvider } from '../common/simulation_provider.js';
 import { NativeACVMSimulator } from './acvm_native.js';
 import { WASMSimulator } from './acvm_wasm.js';
+import type { SimulationProvider } from './simulation_provider.js';
 
 export type SimulationProviderConfig = {
   acvmBinaryPath?: string;

package/src/{common → private/providers}/simulation_provider.ts

@@ -1,11 +1,11 @@
-import { type NoirCompiledCircuit } from '@aztec/types/noir';
+import type { NoirCompiledCircuit } from '@aztec/stdlib/noir';
 
-import { type ExecutionError } from '@noir-lang/acvm_js';
+import type { ExecutionError } from '@noir-lang/acvm_js';
 import { abiDecodeError } from '@noir-lang/noirc_abi';
-import { type Abi, type WitnessMap } from '@noir-lang/types';
+import type { Abi, WitnessMap } from '@noir-lang/types';
 
-import { type ACIRCallback, type ACIRExecutionResult } from '../acvm/acvm.js';
-import { type ACVMWitness } from '../acvm/acvm_types.js';
+import type { ACIRCallback, ACIRExecutionResult } from '../acvm/acvm.js';
+import type { ACVMWitness } from '../acvm/acvm_types.js';
 
 /**
  * Low level simulation interface

package/src/{client → private}/simulator.ts

@@ -1,30 +1,18 @@
-import {
-  type AztecNode,
-  type FunctionCall,
-  type Note,
-  PrivateExecutionResult,
-  type TxExecutionRequest,
-} from '@aztec/circuit-types';
-import { CallContext } from '@aztec/circuits.js';
-import {
-  type ArrayType,
-  type FunctionArtifact,
-  FunctionSelector,
-  FunctionType,
-  type NoteSelector,
-  encodeArguments,
-} from '@aztec/foundation/abi';
-import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { FunctionCall } from '@aztec/stdlib/abi';
+import { FunctionSelector, FunctionType } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import { CallContext, PrivateExecutionResult, TxExecutionRequest } from '@aztec/stdlib/tx';
 
 import { createSimulationError } from '../common/errors.js';
-import { HashedValuesCache } from '../common/hashed_values_cache.js';
-import { type SimulationProvider } from '../common/simulation_provider.js';
 import { ClientExecutionContext } from './client_execution_context.js';
-import { type DBOracle } from './db_oracle.js';
+import type { DBOracle } from './db_oracle.js';
 import { ExecutionNoteCache } from './execution_note_cache.js';
-import { executePrivateFunction } from './private_execution.js';
+import { HashedValuesCache } from './hashed_values_cache.js';
+import { executePrivateFunction, verifyCurrentClassId } from './private_execution.js';
+import type { SimulationProvider } from './providers/simulation_provider.js';
 import { executeUnconstrainedFunction } from './unconstrained_execution.js';
 import { ViewDataOracle } from './view_data_oracle.js';
 
@@ -49,11 +37,21 @@ export class AcirSimulator {
    */
   public async run(
     request: TxExecutionRequest,
-    entryPointArtifact: FunctionArtifact,
     contractAddress: AztecAddress,
+    selector: FunctionSelector,
     msgSender = AztecAddress.fromField(Fr.MAX_FIELD_VALUE),
     scopes?: AztecAddress[],
   ): Promise<PrivateExecutionResult> {
+    const header = await this.db.getBlockHeader();
+
+    await verifyCurrentClassId(
+      contractAddress,
+      await this.db.getContractInstance(contractAddress),
+      this.node,
+      header.globalVariables.blockNumber.toNumber(),
+    );
+    const entryPointArtifact = await this.db.getFunctionArtifact(contractAddress, selector);
+
     if (entryPointArtifact.functionType !== FunctionType.PRIVATE) {
       throw new Error(`Cannot run ${entryPointArtifact.functionType} function as private`);
     }
@@ -64,8 +62,6 @@ export class AcirSimulator {
       );
     }
 
-    const header = await this.db.getBlockHeader();
-
     // reserve the first side effect for the tx hash (inserted by the private kernel)
     const startSideEffectCounter = 1;
 
@@ -85,6 +81,7 @@ export class AcirSimulator {
       callContext,
       header,
       request.authWitnesses,
+      request.capsules,
       HashedValuesCache.create(request.argsOfCalls),
       noteCache,
       this.db,
@@ -120,15 +117,23 @@ export class AcirSimulator {
    */
   public async runUnconstrained(
     request: FunctionCall,
-    entryPointArtifact: FunctionArtifact,
     contractAddress: AztecAddress,
+    selector: FunctionSelector,
     scopes?: AztecAddress[],
   ) {
+    await verifyCurrentClassId(
+      contractAddress,
+      await this.db.getContractInstance(contractAddress),
+      this.node,
+      await this.node.getBlockNumber(),
+    );
+    const entryPointArtifact = await this.db.getFunctionArtifact(contractAddress, selector);
+
     if (entryPointArtifact.functionType !== FunctionType.UNCONSTRAINED) {
       throw new Error(`Cannot run ${entryPointArtifact.functionType} function as unconstrained`);
     }
 
-    const context = new ViewDataOracle(contractAddress, [], this.db, this.node, undefined, scopes);
+    const context = new ViewDataOracle(contractAddress, [], [], this.db, this.node, undefined, scopes);
 
     try {
       return await executeUnconstrainedFunction(
@@ -143,101 +148,4 @@ export class AcirSimulator {
       throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
     }
   }
-
-  /**
-   * Computes the inner nullifier of a note.
-   * @param contractAddress - The address of the contract.
-   * @param nonce - The nonce of the note hash.
-   * @param storageSlot - The storage slot.
-   * @param noteTypeId - The note type identifier.
-   * @param computeNullifier - A flag indicating whether to compute the nullifier or just return 0.
-   * @param note - The note.
-   * @returns The nullifier.
-   */
-  public async computeNoteHashAndOptionallyANullifier(
-    contractAddress: AztecAddress,
-    nonce: Fr,
-    storageSlot: Fr,
-    noteTypeId: NoteSelector,
-    computeNullifier: boolean,
-    note: Note,
-  ) {
-    const artifact: FunctionArtifact | undefined = await this.db.getFunctionArtifactByName(
-      contractAddress,
-      'compute_note_hash_and_optionally_a_nullifier',
-    );
-    if (!artifact) {
-      throw new Error(
-        `Mandatory implementation of "compute_note_hash_and_optionally_a_nullifier" missing in noir contract ${contractAddress.toString()}.`,
-      );
-    }
-
-    if (artifact.parameters.length != 6) {
-      throw new Error(
-        `Expected 6 parameters in mandatory implementation of "compute_note_hash_and_optionally_a_nullifier", but found ${
-          artifact.parameters.length
-        } in noir contract ${contractAddress.toString()}.`,
-      );
-    }
-
-    const maxNoteFields = (artifact.parameters[artifact.parameters.length - 1].type as ArrayType).length;
-    if (maxNoteFields < note.items.length) {
-      throw new Error(
-        `The note being processed has ${note.items.length} fields, while "compute_note_hash_and_optionally_a_nullifier" can only handle a maximum of ${maxNoteFields} fields. Please reduce the number of fields in your note.`,
-      );
-    }
-
-    const extendedNoteItems = note.items.concat(Array(maxNoteFields - note.items.length).fill(Fr.ZERO));
-
-    const execRequest: FunctionCall = {
-      name: artifact.name,
-      to: contractAddress,
-      selector: await FunctionSelector.fromNameAndParameters(artifact),
-      type: FunctionType.UNCONSTRAINED,
-      isStatic: artifact.isStatic,
-      args: encodeArguments(artifact, [
-        contractAddress,
-        nonce,
-        storageSlot,
-        noteTypeId,
-        computeNullifier,
-        extendedNoteItems,
-      ]),
-      returnTypes: artifact.returnTypes,
-    };
-
-    const [noteHash, uniqueNoteHash, siloedNoteHash, innerNullifier] = (await this.runUnconstrained(
-      execRequest,
-      artifact,
-      contractAddress,
-      // We can omit scopes here, because "compute_note_hash_and_optionally_a_nullifier" does not need access to any notes.
-    )) as bigint[];
-
-    return {
-      noteHash: new Fr(noteHash),
-      uniqueNoteHash: new Fr(uniqueNoteHash),
-      siloedNoteHash: new Fr(siloedNoteHash),
-      innerNullifier: new Fr(innerNullifier),
-    };
-  }
-
-  /**
-   * Computes a hash of the note.
-   * @param contractAddress - The address of the contract.
-   * @param storageSlot - The storage slot.
-   * @param noteTypeId - The note type identifier.
-   * @param note - The note.
-   * @returns The note hash.
-   */
-  public async computeNoteHash(contractAddress: AztecAddress, storageSlot: Fr, noteTypeId: NoteSelector, note: Note) {
-    const { noteHash } = await this.computeNoteHashAndOptionallyANullifier(
-      contractAddress,
-      Fr.ZERO,
-      storageSlot,
-      noteTypeId,
-      false,
-      note,
-    );
-    return noteHash;
-  }
 }

package/src/{client → private}/unconstrained_execution.ts

@@ -1,13 +1,13 @@
-import { type AbiDecoded, type FunctionArtifact, type FunctionSelector, decodeFromAbi } from '@aztec/foundation/abi';
-import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { type Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
+import { type AbiDecoded, type FunctionArtifact, type FunctionSelector, decodeFromAbi } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
-import { witnessMapToFields } from '../acvm/deserialize.js';
-import { Oracle, extractCallStack, toACVMWitness } from '../acvm/index.js';
 import { ExecutionError, resolveAssertionMessageFromError } from '../common/errors.js';
-import { type SimulationProvider } from '../server.js';
-import { type ViewDataOracle } from './view_data_oracle.js';
+import { witnessMapToFields } from './acvm/deserialize.js';
+import { Oracle, extractCallStack, toACVMWitness } from './acvm/index.js';
+import type { SimulationProvider } from './providers/simulation_provider.js';
+import type { ViewDataOracle } from './view_data_oracle.js';
 
 // docs:start:execute_unconstrained_function
 /**

package/src/{client → private}/view_data_oracle.ts

@@ -1,26 +1,19 @@
-import {
-  type AuthWitness,
-  type AztecNode,
-  type CompleteAddress,
-  type MerkleTreeId,
-  type NoteStatus,
-  type NullifierMembershipWitness,
-  type PublicDataWitness,
-} from '@aztec/circuit-types';
-import {
-  type BlockHeader,
-  type ContractInstance,
-  type IndexedTaggingSecret,
-  type KeyValidationRequest,
-} from '@aztec/circuits.js';
-import { Aes128 } from '@aztec/circuits.js/barretenberg';
-import { siloNullifier } from '@aztec/circuits.js/hash';
-import { AztecAddress } from '@aztec/foundation/aztec-address';
+import { Aes128 } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { applyStringFormatting, createLogger } from '@aztec/foundation/log';
-
-import { type NoteData, TypedOracle } from '../acvm/index.js';
-import { type DBOracle } from './db_oracle.js';
+import type { AuthWitness } from '@aztec/stdlib/auth-witness';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
+import { siloNullifier } from '@aztec/stdlib/hash';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { KeyValidationRequest } from '@aztec/stdlib/kernel';
+import { IndexedTaggingSecret, LogWithTxData } from '@aztec/stdlib/logs';
+import type { NoteStatus } from '@aztec/stdlib/note';
+import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
+import type { BlockHeader, Capsule } from '@aztec/stdlib/tx';
+
+import { type NoteData, TypedOracle } from './acvm/index.js';
+import type { DBOracle } from './db_oracle.js';
 import { pickNotes } from './pick_notes.js';
 
 /**
@@ -32,6 +25,7 @@ export class ViewDataOracle extends TypedOracle {
     protected readonly contractAddress: AztecAddress,
     /** List of transient auth witnesses to be used during this simulation */
     protected readonly authWitnesses: AuthWitness[],
+    protected readonly capsules: Capsule[],
     protected readonly db: DBOracle,
     protected readonly aztecNode: AztecNode,
     protected log = createLogger('simulator:client_view_context'),
@@ -320,6 +314,10 @@ export class ViewDataOracle extends TypedOracle {
     await this.db.deliverNote(contractAddress, storageSlot, nonce, content, noteHash, nullifier, txHash, recipient);
   }
 
+  public override getLogByTag(tag: Fr): Promise<LogWithTxData | null> {
+    return this.db.getLogByTag(tag);
+  }
+
   public override storeCapsule(contractAddress: AztecAddress, slot: Fr, capsule: Fr[]): Promise<void> {
     if (!contractAddress.equals(this.contractAddress)) {
       // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
@@ -328,12 +326,15 @@ export class ViewDataOracle extends TypedOracle {
     return this.db.storeCapsule(this.contractAddress, slot, capsule);
   }
 
-  public override loadCapsule(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null> {
+  public override async loadCapsule(contractAddress: AztecAddress, slot: Fr): Promise<Fr[] | null> {
     if (!contractAddress.equals(this.contractAddress)) {
       // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
       throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
     }
-    return this.db.loadCapsule(this.contractAddress, slot);
+    return (
+      this.capsules.find(c => c.contractAddress.equals(contractAddress) && c.storageSlot.equals(slot))?.data ??
+      (await this.db.loadCapsule(this.contractAddress, slot))
+    );
   }
 
   public override deleteCapsule(contractAddress: AztecAddress, slot: Fr): Promise<void> {
@@ -359,11 +360,7 @@ export class ViewDataOracle extends TypedOracle {
 
   // TODO(#11849): consider replacing this oracle with a pure Noir implementation of aes decryption.
   public override aes128Decrypt(ciphertext: Buffer, iv: Buffer, symKey: Buffer): Promise<Buffer> {
-    // Noir can't predict the amount of padding that gets trimmed,
-    // but it needs to know the length of the returned value.
-    // So we tell Noir that the length is the (predictable) length
-    // of the padded plaintext, we return that padded plaintext, and have Noir interpret the padding to do the trimming.
     const aes128 = new Aes128();
-    return aes128.decryptBufferCBCKeepPadding(ciphertext, iv, symKey);
+    return aes128.decryptBufferCBC(ciphertext, iv, symKey);
   }
 }

package/src/{avm → public/avm}/avm_context.ts

@@ -1,10 +1,11 @@
-import { type AztecAddress } from '@aztec/circuits.js';
-import { type Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
-import { type AvmExecutionEnvironment } from './avm_execution_environment.js';
+import type { AvmExecutionEnvironment } from './avm_execution_environment.js';
 import { type Gas, gasToGasLeft } from './avm_gas.js';
 import { AvmMachineState } from './avm_machine_state.js';
-import { type AvmPersistableStateManager } from './journal/journal.js';
+import type { AvmSimulator } from './avm_simulator.js';
+import type { AvmPersistableStateManager } from './journal/journal.js';
 
 /**
  * An execution context includes the information necessary to initiate AVM
@@ -24,6 +25,10 @@ export class AvmContext {
     public machineState: AvmMachineState,
   ) {}
 
+  // This is needed to break a dependency cycle created by the CALL opcode,
+  // which needs to create a new simulator but cannot depend directly on AvmSimulator.
+  public provideSimulator?: (ctx: this) => Promise<AvmSimulator>;
+
   /**
    * Prepare a new AVM context that will be ready for an external/nested call
    * - Fork the world state journal
@@ -38,18 +43,18 @@ export class AvmContext {
    * @param callType - Type of call (CALL or STATICCALL)
    * @returns new AvmContext instance
    */
-  public createNestedContractCallContext(
+  public async createNestedContractCallContext(
     address: AztecAddress,
     calldata: Fr[],
     allocatedGas: Gas,
     callType: 'CALL' | 'STATICCALL',
-  ): AvmContext {
+  ): Promise<AvmContext> {
     const deriveFn =
       callType === 'CALL'
         ? this.environment.deriveEnvironmentForNestedCall
         : this.environment.deriveEnvironmentForNestedStaticCall;
     const newExecutionEnvironment = deriveFn.call(this.environment, address, calldata);
-    const forkedWorldState = this.persistableState.fork();
+    const forkedWorldState = await this.persistableState.fork();
     const machineState = AvmMachineState.fromState(gasToGasLeft(allocatedGas));
     return new AvmContext(forkedWorldState, newExecutionEnvironment, machineState);
   }

package/src/{avm → public/avm}/avm_contract_call_result.ts

@@ -1,12 +1,12 @@
-import { type SimulationError } from '@aztec/circuit-types';
-import { Gas } from '@aztec/circuits.js';
-import { type Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/fields';
+import type { SimulationError } from '@aztec/stdlib/errors';
+import { Gas } from '@aztec/stdlib/gas';
 
 import { inspect } from 'util';
 
-import { createSimulationError } from '../common/errors.js';
-import { type Gas as AvmGas } from './avm_gas.js';
-import { type AvmRevertReason } from './errors.js';
+import { createSimulationError } from '../../common/errors.js';
+import type { Gas as AvmGas } from './avm_gas.js';
+import type { AvmRevertReason } from './errors.js';
 
 /**
  * Results of an contract call's execution in the AVM.

package/src/{avm → public/avm}/avm_execution_environment.ts

@@ -1,6 +1,6 @@
-import { type GlobalVariables } from '@aztec/circuits.js';
-import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GlobalVariables } from '@aztec/stdlib/tx';
 
 /**
  * Contains variables that remain constant during AVM execution

package/src/{avm → public/avm}/avm_gas.ts

@@ -1,4 +1,4 @@
-import * as c from '@aztec/circuits.js/constants';
+import * as c from '@aztec/constants';
 
 import { TypeTag } from './avm_memory_types.js';
 import { InstructionExecutionError } from './errors.js';
@@ -123,7 +123,6 @@ const BASE_GAS_COSTS: Record<Opcode, Gas> = {
   [Opcode.SHA256COMPRESSION]: makeCost(c.AVM_SHA256COMPRESSION_BASE_L2_GAS, 0),
   [Opcode.KECCAKF1600]: makeCost(c.AVM_KECCAKF1600_BASE_L2_GAS, 0),
   [Opcode.ECADD]: makeCost(c.AVM_ECADD_BASE_L2_GAS, 0),
-  [Opcode.MSM]: makeCost(c.AVM_MSM_BASE_L2_GAS, 0),
   [Opcode.TORADIXBE]: makeCost(c.AVM_TORADIXBE_BASE_L2_GAS, 0),
 };
 
@@ -137,7 +136,6 @@ const DYNAMIC_GAS_COSTS = new Map<Opcode, Gas>([
   [Opcode.REVERT_8, makeCost(c.AVM_REVERT_DYN_L2_GAS, 0)],
   [Opcode.REVERT_16, makeCost(c.AVM_REVERT_DYN_L2_GAS, 0)],
   [Opcode.DEBUGLOG, makeCost(c.AVM_DEBUGLOG_DYN_L2_GAS, 0)],
-  [Opcode.MSM, makeCost(c.AVM_MSM_DYN_L2_GAS, 0)],
   [Opcode.TORADIXBE, makeCost(c.AVM_TORADIXBE_DYN_L2_GAS, 0)],
 ]);
 

package/src/{avm → public/avm}/avm_machine_state.ts

@@ -1,6 +1,6 @@
-import { type Fr } from '@aztec/circuits.js';
+import type { Fr } from '@aztec/foundation/fields';
 
-import { type Gas } from './avm_gas.js';
+import type { Gas } from './avm_gas.js';
 import { TaggedMemory } from './avm_memory_types.js';
 import { type AvmRevertReason, OutOfGasError } from './errors.js';
 

package/src/{avm → public/avm}/avm_memory_types.ts

@@ -6,12 +6,12 @@ import {
   MEM_TAG_U32,
   MEM_TAG_U64,
   MEM_TAG_U128,
-} from '@aztec/circuits.js';
-import { AztecAddress } from '@aztec/foundation/aztec-address';
+} from '@aztec/constants';
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
-import { type FunctionsOf } from '@aztec/foundation/types';
+import type { FunctionsOf } from '@aztec/foundation/types';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
 
 import { strict as assert } from 'assert';
 
@@ -219,7 +219,7 @@ export enum TypeTag {
   UINT32 = MEM_TAG_U32,
   UINT64 = MEM_TAG_U64,
   UINT128 = MEM_TAG_U128,
-  INVALID,
+  INVALID = MEM_TAG_U128 + 1,
 }
 
 // Lazy interface definition for tagged memory

package/src/{avm → public/avm}/avm_simulator.ts

@@ -1,13 +1,16 @@
-import { type AztecAddress, Fr, type GlobalVariables, MAX_L2_GAS_PER_TX_PUBLIC_PORTION } from '@aztec/circuits.js';
+import { MAX_L2_GAS_PER_TX_PUBLIC_PORTION } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GlobalVariables } from '@aztec/stdlib/tx';
 
 import { strict as assert } from 'assert';
 
-import { SideEffectLimitReachedError } from '../public/side_effect_errors.js';
+import { SideEffectLimitReachedError } from '../side_effect_errors.js';
 import { AvmContext } from './avm_context.js';
 import { AvmContractCallResult } from './avm_contract_call_result.js';
 import { AvmExecutionEnvironment } from './avm_execution_environment.js';
-import { type Gas } from './avm_gas.js';
+import type { Gas } from './avm_gas.js';
 import { AvmMachineState } from './avm_machine_state.js';
 import { isAvmBytecode } from './bytecode_utils.js';
 import {
@@ -17,8 +20,8 @@ import {
   revertReasonFromExceptionalHalt,
   revertReasonFromExplicitRevert,
 } from './errors.js';
-import { type AvmPersistableStateManager } from './journal/journal.js';
-import { type Instruction } from './opcodes/instruction.js';
+import type { AvmPersistableStateManager } from './journal/journal.js';
+import type { Instruction } from './opcodes/instruction.js';
 import {
   INSTRUCTION_SET,
   type InstructionSet,
@@ -44,9 +47,12 @@ export class AvmSimulator {
   // only. Otherwise, use build() below.
   constructor(
     private context: AvmContext,
-    private instructionSet: InstructionSet = INSTRUCTION_SET(),
+    private instructionSet: InstructionSet = INSTRUCTION_SET,
     enableTallying = false,
   ) {
+    // This will be used by the CALL opcode to create a new simulator. It is required to
+    // avoid a dependency cycle.
+    context.provideSimulator = AvmSimulator.build;
     assert(
       context.machineState.gasLeft.l2Gas <= MAX_L2_GAS_PER_TX_PUBLIC_PORTION,
       `Cannot allocate more than ${MAX_L2_GAS_PER_TX_PUBLIC_PORTION} to the AVM for execution.`,

package/src/{avm → public/avm}/errors.ts

@@ -1,8 +1,9 @@
-import { type FailingFunction, type NoirCallStack } from '@aztec/circuit-types';
-import { type AztecAddress, type Fr, type Point } from '@aztec/circuits.js';
+import type { Fr, Point } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { FailingFunction, NoirCallStack } from '@aztec/stdlib/errors';
 
-import { ExecutionError } from '../common/errors.js';
-import { type AvmContext } from './avm_context.js';
+import { ExecutionError } from '../../common/errors.js';
+import type { AvmContext } from './avm_context.js';
 
 /**
  * Avm-specific errors should derive from this

package/src/{avm → public/avm}/fixtures/avm_simulation_tester.ts

@@ -1,11 +1,13 @@
-import { type MerkleTreeWriteOperations } from '@aztec/circuit-types';
-import { GasFees, GlobalVariables } from '@aztec/circuits.js';
-import { encodeArguments } from '@aztec/foundation/abi';
-import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
+import { encodeArguments } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { GasFees } from '@aztec/stdlib/gas';
+import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
+import { GlobalVariables } from '@aztec/stdlib/tx';
 import { NativeWorldStateService } from '@aztec/world-state';
 
-import { type AvmContractCallResult } from '../../avm/avm_contract_call_result.js';
+import { SideEffectTrace } from '../../../public/side_effect_trace.js';
+import type { AvmContractCallResult } from '../../avm/avm_contract_call_result.js';
 import {
   getContractFunctionArtifact,
   getFunctionSelector,
@@ -13,9 +15,9 @@ import {
   initExecutionEnvironment,
   resolveContractAssertionMessage,
 } from '../../avm/fixtures/index.js';
-import { WorldStateDB } from '../../public/public_db_sources.js';
-import { SideEffectTrace } from '../../public/side_effect_trace.js';
-import { AvmPersistableStateManager, AvmSimulator } from '../../server.js';
+import { AvmPersistableStateManager } from '../../avm/journal/journal.js';
+import { WorldStateDB } from '../../public_db_sources.js';
+import { AvmSimulator } from '../avm_simulator.js';
 import { BaseAvmSimulationTester } from './base_avm_simulation_tester.js';
 import { SimpleContractDataSource } from './simple_contract_data_source.js';
 
@@ -31,13 +33,12 @@ export class AvmSimulationTester extends BaseAvmSimulationTester {
   constructor(
     contractDataSource: SimpleContractDataSource,
     merkleTrees: MerkleTreeWriteOperations,
-    skipContractDeployments = false,
     private stateManager: AvmPersistableStateManager,
   ) {
-    super(contractDataSource, merkleTrees, skipContractDeployments);
+    super(contractDataSource, merkleTrees);
   }
 
-  static async create(skipContractDeployments = false): Promise<AvmSimulationTester> {
+  static async create(): Promise<AvmSimulationTester> {
     const contractDataSource = new SimpleContractDataSource();
     const merkleTrees = await (await NativeWorldStateService.tmp()).fork();
     const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
@@ -45,13 +46,13 @@ export class AvmSimulationTester extends BaseAvmSimulationTester {
     const firstNullifier = new Fr(420000);
     // FIXME: merkle ops should work, but I'm seeing frequent (but inconsistent) bytecode retrieval
     // failures on 2nd call to simulateCall with merkle ops on
-    const stateManager = await AvmPersistableStateManager.create(
+    const stateManager = AvmPersistableStateManager.create(
       worldStateDB,
       trace,
       /*doMerkleOperations=*/ false,
       firstNullifier,
     );
-    return new AvmSimulationTester(contractDataSource, merkleTrees, skipContractDeployments, stateManager);
+    return new AvmSimulationTester(contractDataSource, merkleTrees, stateManager);
   }
 
   /**
@@ -84,7 +85,7 @@ export class AvmSimulationTester extends BaseAvmSimulationTester {
       sender,
       isStaticCall,
     });
-    const persistableState = this.stateManager.fork();
+    const persistableState = await this.stateManager.fork();
     const context = initContext({ env: environment, persistableState });
 
     // First we simulate (though it's not needed in this simple case).
@@ -97,7 +98,7 @@ export class AvmSimulationTester extends BaseAvmSimulationTester {
       );
     } else {
       this.logger.info(`Simulation of function ${fnName} succeeded!`);
-      this.stateManager.merge(persistableState);
+      await this.stateManager.merge(persistableState);
     }
     return result;
   }