@aztec/simulator 0.0.0-test.1 → 0.0.1-commit.023c3e5

package/src/public/avm/avm_simulator.ts

@@ -1,27 +1,24 @@
-import { MAX_L2_GAS_PER_TX_PUBLIC_PORTION } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type Logger, createLogger } from '@aztec/foundation/log';
+import { Timer } from '@aztec/foundation/timer';
+import type { PublicSimulatorConfig } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { GlobalVariables } from '@aztec/stdlib/tx';
 
 import { strict as assert } from 'assert';
 
-import { SideEffectLimitReachedError } from '../side_effect_errors.js';
+import { CheckedPublicExecutionError } from '../public_errors.js';
+import type { PublicPersistableStateManager } from '../state_manager/state_manager.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 { AvmMachineState } from './avm_machine_state.js';
-import { isAvmBytecode } from './bytecode_utils.js';
-import {
-  AvmExecutionError,
-  AvmRevertReason,
-  InvalidProgramCounterError,
-  revertReasonFromExceptionalHalt,
-  revertReasonFromExplicitRevert,
-} from './errors.js';
-import type { AvmPersistableStateManager } from './journal/journal.js';
+import type { AvmSimulatorInterface } from './avm_simulator_interface.js';
+import { type CallData, ReturnDataArray } from './calldata.js';
+import { AvmRevertReason, InvalidProgramCounterError } from './errors.js';
 import type { Instruction } from './opcodes/instruction.js';
+import { revertReasonFromExceptionalHalt, revertReasonFromExplicitRevert } from './revert_reason.js';
 import {
   INSTRUCTION_SET,
   type InstructionSet,
@@ -33,7 +30,7 @@ type OpcodeTally = {
   gas: Gas;
 };
 
-export class AvmSimulator {
+export class AvmSimulator implements AvmSimulatorInterface {
   private log: Logger;
   private bytecode: Buffer | undefined;
   private opcodeTallies: Map<string, OpcodeTally> = new Map();
@@ -53,11 +50,7 @@ export class AvmSimulator {
     // 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.`,
-    );
-    this.log = createLogger(`simulator:avm(calldata[0]: ${context.environment.calldata[0]})`);
+    this.log = createLogger(`simulator:avm(calldata[0]: ${context.environment.calldata.read(0)})`);
     // Turn on tallying if explicitly enabled or if trace logging
     if (enableTallying || this.log.isLevelEnabled('trace')) {
       this.tallyPrintFunction = this.printOpcodeTallies;
@@ -76,14 +69,15 @@ export class AvmSimulator {
   }
 
   public static async create(
-    stateManager: AvmPersistableStateManager,
+    stateManager: PublicPersistableStateManager,
     address: AztecAddress,
     sender: AztecAddress,
     transactionFee: Fr,
     globals: GlobalVariables,
     isStaticCall: boolean,
-    calldata: Fr[],
+    calldata: CallData,
     allocatedGas: Gas,
+    config: PublicSimulatorConfig,
   ) {
     const avmExecutionEnv = new AvmExecutionEnvironment(
       address,
@@ -93,6 +87,7 @@ export class AvmSimulator {
       globals,
       isStaticCall,
       calldata,
+      config,
     );
 
     const avmMachineState = new AvmMachineState(allocatedGas);
@@ -104,22 +99,13 @@ export class AvmSimulator {
    * Fetch the bytecode and execute it in the current context.
    */
   public async execute(): Promise<AvmContractCallResult> {
-    let bytecode: Buffer | undefined;
-    try {
-      bytecode = await this.context.persistableState.getBytecode(this.context.environment.address);
-    } catch (err: any) {
-      if (!(err instanceof AvmExecutionError || err instanceof SideEffectLimitReachedError)) {
-        this.log.error(`Unknown error thrown by AVM during bytecode retrieval: ${err}`);
-        throw err;
-      }
-      return await this.handleFailureToRetrieveBytecode(
-        `Bytecode retrieval for contract '${this.context.environment.address}' failed with ${err}. Reverting...`,
-      );
-    }
+    const bytecode = await this.context.persistableState.getBytecode(this.context.environment.address);
+    // getBytecode returns undefined if bytecode is not found or if the limit of contract calls to unique class IDs is reached.
+    // If it throws an error that reaches this point, it is a bug.
 
     if (!bytecode) {
       return await this.handleFailureToRetrieveBytecode(
-        `No bytecode found at: ${this.context.environment.address}. Reverting...`,
+        `No bytecode found. Contract is not deployed, or limit encountered for max calls to unique contract class IDs. Contract address: ${this.context.environment.address}. Reverting...`,
       );
     }
 
@@ -138,18 +124,17 @@ export class AvmSimulator {
    * This method is useful for testing and debugging.
    */
   public async executeBytecode(bytecode: Buffer): Promise<AvmContractCallResult> {
-    const startTotalTime = performance.now();
-    assert(isAvmBytecode(bytecode), "AVM simulator can't execute non-AVM bytecode");
+    const timer = new Timer();
     assert(bytecode.length > 0, "AVM simulator can't execute empty bytecode");
 
     this.bytecode = bytecode;
+    let instructionName = 'NONE'; // This is used for logging purposes
 
     const { machineState } = this.context;
     const callStartGas = machineState.gasLeft; // Save gas before executing instruction (for profiling)
     try {
       // Execute instruction pointed to by the current program counter
       // continuing until the machine state signifies a halt
-      let instrCounter = 0;
       while (!machineState.getHalted()) {
         // Get the instruction from cache, or deserialize for the first time
         let cachedInstruction = this.deserializedInstructionsCache.get(machineState.pc);
@@ -165,15 +150,14 @@ export class AvmSimulator {
         if (this.log.isLevelEnabled('trace')) {
           // Skip this entirely to avoid toStringing etc if trace is not enabled
           this.log.trace(
-            `[PC:${machineState.pc}] [IC:${instrCounter}] ${instruction.toString()} (gasLeft l2=${
+            `[PC:${machineState.pc}] [IC:${machineState.instrCounter}] ${instruction.toString()} (gasLeft l2=${
               machineState.l2GasLeft
             } da=${machineState.daGasLeft})`,
           );
         }
-        instrCounter++;
-
         machineState.nextPc = machineState.pc + bytesRead;
 
+        instructionName = instruction.constructor.name;
         // Execute the instruction.
         // Normal returns and reverts will return normally here.
         // "Exceptional halts" will throw.
@@ -183,6 +167,8 @@ export class AvmSimulator {
           machineState.pc += bytesRead;
         }
 
+        machineState.instrCounter++;
+
         // gas used by this instruction - used for profiling/tallying
         const gasUsed: Gas = {
           l2Gas: instrStartGas.l2Gas - machineState.l2GasLeft,
@@ -192,42 +178,42 @@ export class AvmSimulator {
 
         if (machineState.pc >= bytecode.length) {
           this.log.warn('Passed end of program');
-          throw new InvalidProgramCounterError(machineState.pc, /*max=*/ bytecode.length);
+          throw new InvalidProgramCounterError(machineState.pc, /*max=*/ bytecode.length - 1);
         }
       }
 
       const output = machineState.getOutput();
       const reverted = machineState.getReverted();
-      const revertReason = reverted ? await revertReasonFromExplicitRevert(output, this.context) : undefined;
-      const results = new AvmContractCallResult(reverted, output, machineState.gasLeft, revertReason);
+      const revertReason = reverted
+        ? await revertReasonFromExplicitRevert(output.bestEffortReadAll(), this.context)
+        : undefined;
+      const results = new AvmContractCallResult(
+        reverted,
+        output,
+        machineState.gasLeft,
+        revertReason,
+        machineState.instrCounter,
+      );
       this.log.debug(`Context execution results: ${results.toString()}`);
       const totalGasUsed: Gas = {
         l2Gas: callStartGas.l2Gas - machineState.l2GasLeft,
         daGas: callStartGas.daGas - machineState.daGasLeft,
       };
-      this.log.debug(`Executed ${instrCounter} instructions and consumed ${totalGasUsed.l2Gas} L2 Gas`);
+      this.log.debug(`Executed ${machineState.instrCounter} instructions and consumed ${totalGasUsed.l2Gas} L2 Gas`);
 
       this.tallyPrintFunction();
 
-      const endTotalTime = performance.now();
-      const totalTime = endTotalTime - startTotalTime;
-      this.log.debug(`Core AVM simulation took ${totalTime}ms`);
+      this.log.debug(`Core AVM simulation took ${timer.ms()}ms`);
 
       // Return results for processing by calling context
       return results;
     } catch (err: any) {
-      this.log.verbose('Exceptional halt (revert by something other than REVERT opcode)');
-      // FIXME: weird that we have to do this OutOfGasError check because:
-      // 1. OutOfGasError is an AvmExecutionError, so that check should cover both
-      // 2. We should at least be able to do instanceof OutOfGasError instead of checking the constructor name
-      if (
-        !(
-          err.constructor.name == 'OutOfGasError' ||
-          err instanceof AvmExecutionError ||
-          err instanceof SideEffectLimitReachedError
-        )
-      ) {
-        this.log.error(`Unknown error thrown by AVM: ${err}`);
+      this.log.info(
+        `Exceptional halt (revert by something other than REVERT opcode) for instruction
+         ${instructionName} at pc ${machineState.pc} and instruction counter ${machineState.instrCounter}`,
+      );
+      if (!(err instanceof CheckedPublicExecutionError)) {
+        this.log.error(`Unchecked/unknown error thrown by AVM. This is a bug. Error: ${err}`);
         throw err;
       }
 
@@ -235,7 +221,13 @@ export class AvmSimulator {
       // Exceptional halts consume all allocated gas
       const noGasLeft = { l2Gas: 0, daGas: 0 };
       // Note: "exceptional halts" cannot return data, hence [].
-      const results = new AvmContractCallResult(/*reverted=*/ true, /*output=*/ [], noGasLeft, revertReason);
+      const results = new AvmContractCallResult(
+        /*reverted=*/ true,
+        /*output=*/ new ReturnDataArray([]),
+        noGasLeft,
+        revertReason,
+        machineState.instrCounter,
+      );
       this.log.debug(`Context execution results: ${results.toString()}`);
 
       this.tallyPrintFunction();
@@ -246,19 +238,22 @@ export class AvmSimulator {
 
   private async handleFailureToRetrieveBytecode(message: string): Promise<AvmContractCallResult> {
     // revert, consuming all gas
-    const fnName = await this.context.persistableState.getPublicFunctionDebugName(this.context.environment);
+    const { functionSelector, functionName } = await this.context.persistableState.getPublicFunctionSelectorAndName(
+      this.context.environment,
+    );
     const revertReason = new AvmRevertReason(
       message,
       /*failingFunction=*/ {
         contractAddress: this.context.environment.address,
-        functionName: fnName,
+        functionSelector,
+        functionName,
       },
       /*noirCallStack=*/ [],
     );
     this.log.warn(message);
     return new AvmContractCallResult(
       /*reverted=*/ true,
-      /*output=*/ [],
+      /*output=*/ new ReturnDataArray([]),
       /*gasLeft=*/ { l2Gas: 0, daGas: 0 }, // consumes all allocated gas
       revertReason,
     );

package/src/public/avm/avm_simulator_interface.ts

@@ -0,0 +1,8 @@
+/**
+ * Interface for AvmSimulator to break the circular dependency between avm_context.ts and avm_simulator.ts
+ */
+export interface AvmSimulatorInterface {
+  execute(): Promise<any>; // Using any here to avoid importing AvmContractCallResult
+  executeBytecode(bytecode: Buffer): Promise<any>;
+  getBytecode(): Buffer | undefined;
+}

package/src/public/avm/calldata.ts

@@ -0,0 +1,100 @@
+import type { Fr } from '@aztec/foundation/schemas';
+
+import { TaggedMemory } from './avm_memory_types.js';
+
+// Allow reading up to 300 kB of return data when unspecified.
+const DEFAULT_BEST_EFFORT_READ_CAP = 10000;
+
+export interface LazyReader {
+  bestEffortReadAll(readCap?: number): Fr[];
+  readAll(): Fr[];
+  read(idx: number): Fr | undefined;
+  slice(start: number, end: number): Fr[];
+  length(): number;
+}
+
+export class LazyReaderMemory implements LazyReader {
+  constructor(
+    private memory: TaggedMemory,
+    private offset: number,
+    private size: number,
+  ) {}
+
+  public bestEffortReadAll(readCap = DEFAULT_BEST_EFFORT_READ_CAP): Fr[] {
+    const size = Math.min(this.size, readCap, TaggedMemory.MAX_MEMORY_SIZE - this.offset);
+    return this.memory.getSlice(this.offset, size).map(word => word.toFr());
+  }
+
+  public read(idx: number): Fr | undefined {
+    if (idx >= this.size) {
+      return undefined;
+    }
+    return this.memory.get(this.offset + idx).toFr();
+  }
+
+  public slice(start: number, end: number): Fr[] {
+    const clampedEnd = Math.min(end, this.size);
+    const length = Math.max(0, clampedEnd - start);
+    return this.memory.getSlice(this.offset + start, length).map(word => word.toFr());
+  }
+
+  public readAll(): Fr[] {
+    return this.memory.getSlice(this.offset, this.size).map(word => word.toFr());
+  }
+
+  public length(): number {
+    return this.size;
+  }
+}
+
+export class LazyReaderArray implements LazyReader {
+  constructor(private array: Fr[]) {}
+
+  public bestEffortReadAll(readCap = DEFAULT_BEST_EFFORT_READ_CAP): Fr[] {
+    return this.array.slice(0, readCap);
+  }
+
+  public read(idx: number): Fr | undefined {
+    return this.array[idx];
+  }
+
+  public slice(start: number, end: number): Fr[] {
+    return this.array.slice(start, end);
+  }
+
+  public readAll(): Fr[] {
+    return this.array;
+  }
+
+  public length(): number {
+    return this.array.length;
+  }
+}
+
+// Compile time branding to avoid swapping CallData and ReturnData by accident.
+declare const CallDataBrand: unique symbol;
+declare const ReturnDataBrand: unique symbol;
+
+export type CallData = LazyReader & {
+  readonly [CallDataBrand]: true;
+};
+
+export type ReturnData = LazyReader & {
+  readonly [ReturnDataBrand]: true;
+};
+
+export class CallDataArray extends LazyReaderArray implements CallData {
+  declare readonly [CallDataBrand]: true;
+}
+
+export class CallDataMemory extends LazyReaderMemory implements CallData {
+  declare readonly [CallDataBrand]: true;
+}
+
+export class ReturnDataArray extends LazyReaderArray implements ReturnData {
+  declare readonly [ReturnDataBrand]: true;
+}
+
+export class ReturnDataMemory extends LazyReaderMemory implements ReturnData {
+  declare readonly [ReturnDataBrand]: true;
+}

package/src/public/avm/errors.ts

@@ -1,27 +1,19 @@
-import type { Fr, Point } from '@aztec/foundation/fields';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { Point } from '@aztec/foundation/curves/grumpkin';
 import type { FailingFunction, NoirCallStack } from '@aztec/stdlib/errors';
 
 import { ExecutionError } from '../../common/errors.js';
-import type { AvmContext } from './avm_context.js';
+import { CheckedPublicExecutionError } from '../public_errors.js';
 
 /**
  * Avm-specific errors should derive from this
  */
-export abstract class AvmExecutionError extends Error {
+export abstract class AvmExecutionError extends CheckedPublicExecutionError {
   constructor(message: string) {
     super(message);
     this.name = 'AvmExecutionError';
   }
 }
 
-export class NoBytecodeForContractError extends AvmExecutionError {
-  constructor(contractAddress: AztecAddress) {
-    super(`No bytecode found at: ${contractAddress}`);
-    this.name = 'NoBytecodeFoundInterpreterError';
-  }
-}
-
 export class ArithmeticError extends AvmExecutionError {
   constructor(message: string) {
     super(message);
@@ -66,7 +58,7 @@ export class AvmParsingError extends AvmExecutionError {
  */
 export class InvalidTagValueError extends AvmExecutionError {
   constructor(tagValue: number) {
-    super(`Tag value ${tagValue} is invalid.`);
+    super(`Tag check failed: Tag value ${tagValue} is invalid.`);
     this.name = 'InvalidTagValueError';
   }
 }
@@ -85,6 +77,12 @@ export class InstructionExecutionError extends AvmExecutionError {
  * Error thrown on failed AVM memory tag check.
  */
 export class TagCheckError extends AvmExecutionError {
+  public static forBaseAddress(gotTag: string): TagCheckError {
+    return new TagCheckError(`Base address (mem[0]) is not a valid address (has tag ${gotTag})`);
+  }
+  public static forIndirectAddress(address: number, gotTag: string): TagCheckError {
+    return new TagCheckError(`Address after indirection is not a valid address (address ${address} has tag ${gotTag})`);
+  }
   public static forOffset(offset: number, gotTag: string, expectedTag: string): TagCheckError {
     return new TagCheckError(`Tag mismatch at offset ${offset}, got ${gotTag}, expected ${expectedTag}`);
   }
@@ -105,7 +103,7 @@ export class TagCheckError extends AvmExecutionError {
  */
 export class RelativeAddressOutOfRangeError extends AvmExecutionError {
   constructor(baseAddr: number, relOffset: number) {
-    super(`Address out of range. Base address ${baseAddr}, relative offset ${relOffset}`);
+    super(`Relative address out of range. Base address ${baseAddr}, relative offset ${relOffset}`);
     this.name = 'RelativeAddressOutOfRangeError';
   }
 }
@@ -130,22 +128,12 @@ export class OutOfGasError extends AvmExecutionError {
 }
 
 /**
- * Error is thrown when the supplied points length is not a multiple of 3. Specific for MSM opcode.
- */
-export class MSMPointsLengthError extends AvmExecutionError {
-  constructor(pointsReadLength: number) {
-    super(`Points vector length should be a multiple of 3, was ${pointsReadLength}`);
-    this.name = 'MSMPointsLengthError';
-  }
-}
-
-/**
- * Error is thrown when one of the supplied points does not lie on the Grumpkin curve. Specific for MSM opcode.
+ * Error is thrown when one of the supplied points does not lie on the Grumpkin curve. Specific for ECADD opcode.
  */
-export class MSMPointNotOnCurveError extends AvmExecutionError {
-  constructor(point: Point) {
-    super(`Point ${point.toString()} is not on the curve.`);
-    this.name = 'MSMPointNotOnCurveError';
+export class EcAddPointNotOnCurveError extends AvmExecutionError {
+  constructor(pointIndex: number, point: Point) {
+    super(`EcAdd point${pointIndex} (${point.toString()}) is not on the curve.`);
+    this.name = 'EcAddPointNotOnCurveError';
   }
 }
 
@@ -180,53 +168,10 @@ export class AvmRevertReason extends ExecutionError {
   }
 }
 
-async function createRevertReason(message: string, revertData: Fr[], context: AvmContext): Promise<AvmRevertReason> {
-  // We drop the returnPc information.
-  const internalCallStack = context.machineState.internalCallStack.map(entry => entry.callPc);
-
-  // If we are reverting due to the same error that we have been tracking, we use the nested error as the cause.
-  let nestedError = undefined;
-  const revertDataEquals = (a: Fr[], b: Fr[]) => a.length === b.length && a.every((v, i) => v.equals(b[i]));
-  if (
-    context.machineState.collectedRevertInfo &&
-    revertDataEquals(context.machineState.collectedRevertInfo.revertDataRepresentative, revertData)
-  ) {
-    nestedError = context.machineState.collectedRevertInfo.recursiveRevertReason;
-    message = context.machineState.collectedRevertInfo.recursiveRevertReason.message;
-  }
-
-  const fnName = await context.persistableState.getPublicFunctionDebugName(context.environment);
-
-  return new AvmRevertReason(
-    message,
-    /*failingFunction=*/ {
-      contractAddress: context.environment.address,
-      functionName: fnName,
-    },
-    /*noirCallStack=*/ [...internalCallStack, context.machineState.pc].map(pc => `0.${pc}`),
-    /*options=*/ { cause: nestedError },
-  );
-}
-
-/**
- * Create a "revert reason" error for an exceptional halt.
- *
- * @param haltingError - the lower-level error causing the exceptional halt
- * @param context - the context of the AVM execution used to extract the failingFunction and noirCallStack
- */
-export async function revertReasonFromExceptionalHalt(
-  haltingError: AvmExecutionError,
-  context: AvmContext,
-): Promise<AvmRevertReason> {
-  return await createRevertReason(haltingError.message, [], context);
-}
-
 /**
- * Create a "revert reason" error for an explicit revert (a root cause).
- *
- * @param revertData - output data of the explicit REVERT instruction
- * @param context - the context of the AVM execution used to extract the failingFunction and noirCallStack
+ * Helper to annotate errors occurring during instruction fetching.
  */
-export async function revertReasonFromExplicitRevert(revertData: Fr[], context: AvmContext): Promise<AvmRevertReason> {
-  return await createRevertReason('Assertion failed: ', revertData, context);
+export function duringInstrFetch(error: Error, pc: number) {
+  error.message = `Instruction fetching error at pc ${pc}: ${error.message}`;
+  return error;
 }

package/src/public/avm/fixtures/avm_simulation_tester.ts

@@ -1,5 +1,6 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { encodeArguments } from '@aztec/stdlib/abi';
+import { PublicSimulatorConfig } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { GasFees } from '@aztec/stdlib/gas';
 import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server';
@@ -8,20 +9,20 @@ import { NativeWorldStateService } from '@aztec/world-state';
 
 import { SideEffectTrace } from '../../../public/side_effect_trace.js';
 import type { AvmContractCallResult } from '../../avm/avm_contract_call_result.js';
+import { SimpleContractDataSource } from '../../fixtures/simple_contract_data_source.js';
+import { PublicContractsDB, PublicTreesDB } from '../../public_db_sources.js';
+import { PublicPersistableStateManager } from '../../state_manager/state_manager.js';
+import { AvmSimulator } from '../avm_simulator.js';
+import { CallDataArray } from '../calldata.js';
+import { BaseAvmSimulationTester } from './base_avm_simulation_tester.js';
+import { initContext, initExecutionEnvironment } from './initializers.js';
 import {
-  getContractFunctionArtifact,
+  DEFAULT_TIMESTAMP,
+  getContractFunctionAbi,
   getFunctionSelector,
-  initContext,
-  initExecutionEnvironment,
   resolveContractAssertionMessage,
-} from '../../avm/fixtures/index.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';
+} from './utils.js';
 
-const TIMESTAMP = new Fr(99833);
 const DEFAULT_GAS_FEES = new GasFees(2, 3);
 
 /**
@@ -33,24 +34,27 @@ export class AvmSimulationTester extends BaseAvmSimulationTester {
   constructor(
     contractDataSource: SimpleContractDataSource,
     merkleTrees: MerkleTreeWriteOperations,
-    private stateManager: AvmPersistableStateManager,
+    private stateManager: PublicPersistableStateManager,
   ) {
     super(contractDataSource, merkleTrees);
   }
 
-  static async create(): Promise<AvmSimulationTester> {
+  static async create(
+    worldStateService: NativeWorldStateService, // make sure to close this later
+  ): Promise<AvmSimulationTester> {
     const contractDataSource = new SimpleContractDataSource();
-    const merkleTrees = await (await NativeWorldStateService.tmp()).fork();
-    const worldStateDB = new WorldStateDB(merkleTrees, contractDataSource);
+    const merkleTrees = await worldStateService.fork();
+    const treesDB = new PublicTreesDB(merkleTrees);
+    const contractsDB = new PublicContractsDB(contractDataSource);
     const trace = new SideEffectTrace();
     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 = AvmPersistableStateManager.create(
-      worldStateDB,
+
+    const stateManager = PublicPersistableStateManager.create(
+      treesDB,
+      contractsDB,
       trace,
-      /*doMerkleOperations=*/ false,
       firstNullifier,
+      DEFAULT_TIMESTAMP,
     );
     return new AvmSimulationTester(contractDataSource, merkleTrees, stateManager);
   }
@@ -70,20 +74,28 @@ export class AvmSimulationTester extends BaseAvmSimulationTester {
       throw new Error(`Contract not found at address: ${address}`);
     }
     const fnSelector = await getFunctionSelector(fnName, contractArtifact);
-    const fnAbi = getContractFunctionArtifact(fnName, contractArtifact);
+    const fnAbi = getContractFunctionAbi(fnName, contractArtifact);
     const encodedArgs = encodeArguments(fnAbi!, args);
     const calldata = [fnSelector.toField(), ...encodedArgs];
 
     const globals = GlobalVariables.empty();
-    globals.timestamp = TIMESTAMP;
+    globals.timestamp = DEFAULT_TIMESTAMP;
     globals.gasFees = DEFAULT_GAS_FEES;
 
+    const config = PublicSimulatorConfig.from({
+      skipFeeEnforcement: false,
+      collectDebugLogs: true,
+      collectHints: false,
+      collectStatistics: false,
+      collectCallMetadata: true,
+    });
     const environment = initExecutionEnvironment({
-      calldata,
+      calldata: new CallDataArray(calldata),
       globals,
       address,
       sender,
       isStaticCall,
+      config,
     });
     const persistableState = await this.stateManager.fork();
     const context = initContext({ env: environment, persistableState });
@@ -94,7 +106,12 @@ export class AvmSimulationTester extends BaseAvmSimulationTester {
     if (result.reverted) {
       this.logger.error(`Error in ${fnName}:`);
       this.logger.error(
-        resolveContractAssertionMessage(fnName, result.revertReason!, result.output, contractArtifact)!,
+        resolveContractAssertionMessage(
+          fnName,
+          result.revertReason!,
+          result.output.bestEffortReadAll(),
+          contractArtifact,
+        )!,
       );
     } else {
       this.logger.info(`Simulation of function ${fnName} succeeded!`);