@aztec/simulator 0.0.1-commit.2ed92850 → 0.0.1-commit.3100065

package/src/private/acvm_native.ts

@@ -1,5 +1,5 @@
 import { runInDirectory } from '@aztec/foundation/fs';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, resolveLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import type { ForeignCallHandler, WitnessMap } from '@aztec/noir-acvm_js';
 import type { FunctionArtifactWithContractName } from '@aztec/stdlib/abi';
@@ -12,8 +12,6 @@ import type { ACIRCallback, ACIRExecutionResult } from './acvm/acvm.js';
 import type { ACVMWitness } from './acvm/acvm_types.js';
 import type { CircuitSimulator } from './circuit_simulator.js';
 
-const logger = createLogger('simulator:acvm-native');
-
 export enum ACVM_RESULT {
   SUCCESS,
   FAILURE,
@@ -64,7 +62,9 @@ export async function executeNativeCircuit(
   workingDirectory: string,
   pathToAcvm: string,
   outputFilename?: string,
+  loggerOrBindings?: Logger | LoggerBindings,
 ): Promise<ACVMResult> {
+  const logger = resolveLogger('simulator:acvm-native', loggerOrBindings);
   const bytecodeFilename = 'bytecode';
   const witnessFilename = 'input_witness.toml';
 
@@ -145,11 +145,16 @@ export async function executeNativeCircuit(
 }
 
 export class NativeACVMSimulator implements CircuitSimulator {
+  private logger: Logger;
+
   constructor(
     private workingDirectory: string,
     private pathToAcvm: string,
     private witnessFilename?: string,
-  ) {}
+    loggerOrBindings?: Logger | LoggerBindings,
+  ) {
+    this.logger = resolveLogger('simulator:acvm-native', loggerOrBindings);
+  }
 
   async executeProtocolCircuit(
     input: ACVMWitness,
@@ -172,6 +177,7 @@ export class NativeACVMSimulator implements CircuitSimulator {
         directory,
         this.pathToAcvm,
         this.witnessFilename,
+        this.logger,
       );
 
       if (result.status == ACVM_RESULT.FAILURE) {
@@ -181,7 +187,7 @@ export class NativeACVMSimulator implements CircuitSimulator {
       return result;
     };
 
-    return await runInDirectory(this.workingDirectory, operation, false, logger);
+    return await runInDirectory(this.workingDirectory, operation, false, this.logger);
   }
 
   executeUserCircuit(

package/src/private/acvm_wasm.ts

@@ -1,4 +1,4 @@
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, resolveLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import initACVM, { type ExecutionError, type ForeignCallHandler, executeCircuit } from '@aztec/noir-acvm_js';
 import initAbi from '@aztec/noir-noirc_abi';
@@ -10,8 +10,14 @@ import type { ACVMWitness } from './acvm/acvm_types.js';
 import type { ACVMSuccess } from './acvm_native.js';
 import { type CircuitSimulator, enrichNoirError } from './circuit_simulator.js';
 
+let wasmInitPromise: Promise<unknown> | undefined;
+
 export class WASMSimulator implements CircuitSimulator {
-  constructor(protected log = createLogger('wasm-simulator')) {}
+  protected log: Logger;
+
+  constructor(loggerOrBindings?: Logger | LoggerBindings) {
+    this.log = resolveLogger('wasm-simulator', loggerOrBindings);
+  }
 
   async init(): Promise<void> {
     // If these are available, then we are in the
@@ -19,7 +25,8 @@ export class WASMSimulator implements CircuitSimulator {
     // is a no-op.
     if (typeof initAbi === 'function') {
       /** @ts-expect-error The node bundle doesn't include these default imports, so TS complains */
-      await Promise.all([initAbi(), initACVM()]);
+      wasmInitPromise ??= Promise.all([initAbi(), initACVM()]);
+      await wasmInitPromise;
     }
   }
 
@@ -67,6 +74,6 @@ export class WASMSimulator implements CircuitSimulator {
     callback: ACIRCallback,
   ): Promise<ACIRExecutionResult> {
     await this.init();
-    return acvm(artifact.bytecode, input, callback);
+    return acvm(artifact.bytecode, input, callback, this.log.createChild('acvm'));
   }
 }

package/src/private/circuit_recording/circuit_recorder.ts

@@ -1,8 +1,10 @@
 import { sha512 } from '@aztec/foundation/crypto/sha512';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, resolveLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
 import type { ForeignCallHandler, ForeignCallInput, ForeignCallOutput } from '@aztec/noir-acvm_js';
 
+import { AsyncLocalStorage } from 'node:async_hooks';
+
 import type { ACIRCallback } from '../acvm/acvm.js';
 import type { ACVMWitness } from '../acvm/acvm_types.js';
 
@@ -43,10 +45,23 @@ export class CircuitRecording {
   }
 }
 
+/** Inputs needed to open a recording for a single circuit execution. */
+export type RecordingMetadata = {
+  input: ACVMWitness;
+  bytecode: Buffer;
+  circuitName: string;
+  functionName: string;
+};
+
 /**
  * Class responsible for recording circuit inputs necessary to replay the circuit. These inputs are the initial witness
  * map and the oracle calls made during the circuit execution/witness generation.
  *
+ * The active recording for an execution lives in `AsyncLocalStorage`, so each (possibly nested) circuit execution owns
+ * its own recording and concurrent or re-entrant executions cannot corrupt one another's state. Nested executions
+ * (`aztec_prv_callPrivateFunction`, utility calls) re-enter {@link record}, which links the child to the recording
+ * active in the enclosing async context and lets ALS restore the parent automatically when the child completes.
+ *
  * Example recording object:
  * ```json
  * {
@@ -89,37 +104,46 @@ export class CircuitRecording {
  * ```
  */
 export class CircuitRecorder {
-  protected readonly logger = createLogger('simulator:acvm:recording');
+  protected readonly logger: Logger;
 
-  protected recording?: CircuitRecording;
+  readonly #recordings = new AsyncLocalStorage<CircuitRecording>();
 
-  private stackDepth: number = 0;
-  private newCircuit: boolean = true;
-
-  protected constructor() {}
+  protected constructor(loggerOrBindings?: Logger | LoggerBindings) {
+    this.logger = resolveLogger('simulator:acvm:recording', loggerOrBindings);
+  }
 
   /**
-   * Initializes a new circuit recording session.
-   * @param recordDir - Directory to store the recording
-   * @param input - Circuit input witness
-   * @param circuitBytecode - Compiled circuit bytecode
-   * @param circuitName - Name of the circuit
-   * @param functionName - Name of the circuit function (defaults to 'main'). This is meaningful only for
-   * contracts as protocol circuits artifacts always contain a single entrypoint function called 'main'.
+   * Records a single circuit execution. Opens a recording for the circuit (linked as a child of the recording active
+   * in the current async context, if any), runs `fn` within that recording's context, and finalizes it. The recording
+   * is returned alongside the result so callers can derive per-circuit stats (e.g. oracle timings).
+   *
+   * Recorder bookkeeping never alters execution: if `fn` throws, the error is attached to the recording and re-thrown
+   * unchanged.
+   * @param metadata - Identifies the circuit and its initial witness.
+   * @param fn - Runs the circuit execution; its oracle calls are recorded into this recording.
    */
-  start(input: ACVMWitness, circuitBytecode: Buffer, circuitName: string, functionName: string): Promise<void> {
-    if (this.newCircuit) {
-      const parentRef = this.recording;
-      this.recording = new CircuitRecording(
-        circuitName,
-        functionName,
-        sha512(circuitBytecode).toString('hex'),
-        Object.fromEntries(input),
-      );
-      this.recording.setParent(parentRef);
-    }
+  record<T>(metadata: RecordingMetadata, fn: () => Promise<T>): Promise<{ result: T; recording: CircuitRecording }> {
+    const parent = this.#recordings.getStore();
+    const recording = new CircuitRecording(
+      metadata.circuitName,
+      metadata.functionName,
+      sha512(metadata.bytecode).toString('hex'),
+      Object.fromEntries(metadata.input),
+    );
+    recording.setParent(parent);
 
-    return Promise.resolve();
+    return this.#recordings.run(recording, async () => {
+      await this.onStart(recording);
+      try {
+        const result = await fn();
+        await this.onFinish(recording);
+        return { result, recording };
+      } catch (error) {
+        recording.error = JSON.stringify(error);
+        await this.onError(recording, error);
+        throw error;
+      }
+    });
   }
 
   /**
@@ -145,7 +169,9 @@ export class CircuitRecorder {
   }
 
   /**
-   * Wraps a user circuit callback to record all oracle calls.
+   * Wraps a user circuit callback to record all oracle calls. A nested circuit entered via an oracle (e.g.
+   * `aztec_prv_callPrivateFunction`) re-enters {@link record}, so its own oracle calls land on the child recording and
+   * this circuit's calls (including the entering oracle call itself) land on this recording once the child completes.
    * @param callback - The original circuit callback.
    * @returns A wrapped callback that records all oracle interactions which is to be provided to the ACVM.
    */
@@ -159,38 +185,16 @@ export class CircuitRecorder {
         throw new Error(`Oracle method ${name} not found when setting up recording callback`);
       }
 
-      const isExternalCall = (name as keyof ACIRCallback) === 'privateCallPrivateFunction';
-
       recordingCallback[name as keyof ACIRCallback] = (...args: ForeignCallInput[]): ReturnType<typeof fn> => {
         const timer = new Timer();
-        // If we're entering another circuit via `privateCallPrivateFunction`, we increase the stack depth and set the
-        // newCircuit variable to ensure we are creating a new recording object.
-        if (isExternalCall) {
-          this.stackDepth++;
-          this.newCircuit = true;
-        }
         const result = fn.call(callback, ...args);
         if (result instanceof Promise) {
           return result.then(async r => {
-            // Once we leave the nested circuit, we decrease the stack depth and set newCircuit to false
-            // so that the parent circuit continues with its existing recording
-            // Note: recording restoration is handled by finish()
-            if (isExternalCall) {
-              this.stackDepth--;
-              this.newCircuit = false;
-            }
-            await this.recordCall(name, args, r, timer.ms(), this.stackDepth);
+            await this.recordCall(name, args, r, timer.ms());
             return r;
           }) as ReturnType<typeof fn>;
         }
-        // Once we leave the nested circuit, we decrease the stack depth and set newCircuit to false
-        // so that the parent circuit continues with its existing recording
-        // Note: recording restoration is handled by finish()
-        if (isExternalCall) {
-          this.stackDepth--;
-          this.newCircuit = false;
-        }
-        void this.recordCall(name, args, result, timer.ms(), this.stackDepth);
+        void this.recordCall(name, args, result, timer.ms());
         return result;
       };
     }
@@ -207,55 +211,59 @@ export class CircuitRecorder {
     return async (name: string, inputs: ForeignCallInput[]): Promise<ForeignCallOutput[]> => {
       const timer = new Timer();
       const result = await callback(name, inputs);
-      await this.recordCall(name, inputs, result, timer.ms(), 0);
+      await this.recordCall(name, inputs, result, timer.ms());
       return result;
     };
   }
 
   /**
-   * Records a single oracle/foreign call with its inputs and outputs.
+   * Records a single oracle/foreign call with its inputs and outputs against the recording active in the current
+   * async context.
    * @param name - Name of the call
    * @param inputs - Input arguments
    * @param outputs - Output results
    */
-  recordCall(name: string, inputs: unknown[], outputs: unknown, time: number, stackDepth: number): Promise<OracleCall> {
+  recordCall(name: string, inputs: unknown[], outputs: unknown, time: number): Promise<OracleCall> {
+    const recording = this.#recordings.getStore();
     const entry = {
       name,
       inputs,
       outputs,
       time,
-      stackDepth,
+      stackDepth: depthOf(recording),
     };
-    this.recording!.oracleCalls.push(entry);
+    // Outside any active recording context (e.g. a stray call after the scope closed, or a direct unit-test call)
+    // there is nowhere to record; return the entry without throwing into the execution path.
+    recording?.oracleCalls.push(entry);
     return Promise.resolve(entry);
   }
 
-  /**
-   * Finalizes the recording by resetting the state and returning the recording object.
-   */
-  finish(): Promise<CircuitRecording> {
-    const result = this.recording;
-    // If this is the top-level circuit recording, we reset the state for the next simulator call
-    if (!result!.parent) {
-      this.newCircuit = true;
-      this.recording = undefined;
-    } else {
-      // For nested circuits (utility calls, nested contract calls), restore to parent recording
-      // Note: we don't set newCircuit=false here because:
-      // - For privateCallPrivateFunction, the callback wrapper will set it to false
-      // - For utility calls, we want newCircuit to remain true so the next circuit creates its own recording
-      this.recording = result!.parent;
-    }
-    return Promise.resolve(result!);
+  /** The recording active in the current async context, if any. */
+  protected currentRecording(): CircuitRecording | undefined {
+    return this.#recordings.getStore();
   }
 
-  /**
-   * Finalizes the recording by resetting the state and returning the recording object with an attached error.
-   * @param error - The error that occurred during circuit execution
-   */
-  async finishWithError(error: unknown): Promise<CircuitRecording> {
-    const result = await this.finish();
-    result.error = JSON.stringify(error);
-    return result;
+  /** Hook invoked when a recording opens, within the recording's context. Overridden to persist recordings. */
+  protected onStart(_recording: CircuitRecording): Promise<void> {
+    return Promise.resolve();
+  }
+
+  /** Hook invoked when a recording completes successfully, within the recording's context. */
+  protected onFinish(_recording: CircuitRecording): Promise<void> {
+    return Promise.resolve();
+  }
+
+  /** Hook invoked when a recording's execution throws, within the recording's context. */
+  protected onError(_recording: CircuitRecording, _error: unknown): Promise<void> {
+    return Promise.resolve();
+  }
+}
+
+/** Depth of a recording in the call tree: 0 for a top-level circuit, incremented per nested circuit. */
+function depthOf(recording: CircuitRecording | undefined): number {
+  let depth = 0;
+  for (let ancestor = recording?.parent; ancestor; ancestor = ancestor.parent) {
+    depth++;
   }
+  return depth;
 }

package/src/private/circuit_recording/file_circuit_recorder.ts

@@ -1,26 +1,26 @@
+import type { Logger } from '@aztec/foundation/log';
+
 import fs from 'fs/promises';
 import path from 'path';
 
-import type { ACVMWitness } from '../acvm/acvm_types.js';
 import { CircuitRecorder, type CircuitRecording } from './circuit_recorder.js';
 
-export class FileCircuitRecorder extends CircuitRecorder {
-  declare recording?: CircuitRecording & { filePath: string; isFirstCall: boolean };
+/** Per-recording file state, keyed by recording so concurrent/nested executions don't share it. */
+type RecordingFileState = { filePath: string; isFirstCall: boolean };
 
-  constructor(private readonly recordDir: string) {
-    super();
-  }
+export class FileCircuitRecorder extends CircuitRecorder {
+  readonly #fileState = new WeakMap<CircuitRecording, RecordingFileState>();
 
-  override async start(
-    input: ACVMWitness,
-    circuitBytecode: Buffer,
-    circuitName: string,
-    functionName: string = 'main',
+  constructor(
+    private readonly recordDir: string,
+    logger?: Logger,
   ) {
-    await super.start(input, circuitBytecode, circuitName, functionName);
+    super(logger);
+  }
 
+  protected override async onStart(recording: CircuitRecording): Promise<void> {
     const recordingStringWithoutClosingBracket = JSON.stringify(
-      { ...this.recording, isFirstCall: undefined, parent: undefined, oracleCalls: undefined, filePath: undefined },
+      { ...recording, parent: undefined, oracleCalls: undefined },
       null,
       2,
     ).slice(0, -2);
@@ -40,13 +40,13 @@ export class FileCircuitRecorder extends CircuitRecorder {
       }
     }
 
-    this.recording!.isFirstCall = true;
-    this.recording!.filePath = await FileCircuitRecorder.#computeFilePathAndStoreInitialRecording(
+    const filePath = await FileCircuitRecorder.#computeFilePathAndStoreInitialRecording(
       this.recordDir,
-      this.recording!.circuitName,
-      this.recording!.functionName,
+      recording.circuitName,
+      recording.functionName,
       recordingStringWithoutClosingBracket,
     );
+    this.#fileState.set(recording, { filePath, isFirstCall: true });
   }
 
   /**
@@ -90,53 +90,48 @@ export class FileCircuitRecorder extends CircuitRecorder {
    * @param inputs - Input arguments
    * @param outputs - Output results
    */
-  override async recordCall(name: string, inputs: unknown[], outputs: unknown, time: number, stackDepth: number) {
-    const entry = await super.recordCall(name, inputs, outputs, time, stackDepth);
-    try {
-      const prefix = this.recording!.isFirstCall ? '    ' : '    ,';
-      this.recording!.isFirstCall = false;
-      await fs.appendFile(this.recording!.filePath, prefix + JSON.stringify(entry) + '\n');
-    } catch (err) {
-      this.logger.error('Failed to log circuit call', { error: err });
+  override async recordCall(name: string, inputs: unknown[], outputs: unknown, time: number) {
+    const entry = await super.recordCall(name, inputs, outputs, time);
+    const recording = this.currentRecording();
+    const state = recording && this.#fileState.get(recording);
+    if (state) {
+      try {
+        const prefix = state.isFirstCall ? '    ' : '    ,';
+        state.isFirstCall = false;
+        await fs.appendFile(state.filePath, prefix + JSON.stringify(entry) + '\n');
+      } catch (err) {
+        this.logger.error('Failed to log circuit call', { error: err });
+      }
     }
     return entry;
   }
 
-  /**
-   * Finalizes the recording file by adding closing brackets. Without calling this method, the recording file is
-   * incomplete and it fails to parse.
-   */
-  override async finish(): Promise<CircuitRecording> {
-    // Finish sets the recording to undefined if we are at the topmost circuit,
-    // so we save the current file path before that
-    const filePath = this.recording!.filePath;
-    const result = await super.finish();
+  /** Closes the recording file with the trailing brackets so the JSON parses. */
+  protected override async onFinish(recording: CircuitRecording): Promise<void> {
+    const state = this.#fileState.get(recording);
+    if (!state) {
+      return;
+    }
     try {
-      await fs.appendFile(filePath, '  ]\n}\n');
+      await fs.appendFile(state.filePath, '  ]\n}\n');
     } catch (err) {
       this.logger.error('Failed to finalize recording file', { error: err });
     }
-    return result!;
   }
 
-  /**
-   * Finalizes the recording file by adding the error and closing brackets. Without calling this method or `finish`,
-   * the recording file is incomplete and it fails to parse.
-   * @param error - The error that occurred during circuit execution
-   */
-  override async finishWithError(error: unknown): Promise<CircuitRecording> {
-    // Finish sets the recording to undefined if we are at the topmost circuit,
-    // so we save the current file path before that
-    const filePath = this.recording!.filePath;
-    const result = await super.finishWithError(error);
+  /** Closes the recording file with the execution error and trailing brackets so the JSON parses. */
+  protected override async onError(recording: CircuitRecording, error: unknown): Promise<void> {
+    const state = this.#fileState.get(recording);
+    if (!state) {
+      return;
+    }
     try {
-      await fs.appendFile(filePath, '  ],\n');
-      await fs.appendFile(filePath, `  "error": ${JSON.stringify(error)}\n`);
-      await fs.appendFile(filePath, '}\n');
+      await fs.appendFile(state.filePath, '  ],\n');
+      await fs.appendFile(state.filePath, `  "error": ${JSON.stringify(error)}\n`);
+      await fs.appendFile(state.filePath, '}\n');
     } catch (err) {
       this.logger.error('Failed to finalize recording file with error', { error: err });
     }
-    return result!;
   }
 }
 

package/src/private/circuit_recording/memory_circuit_recorder.ts

@@ -1,11 +1,13 @@
+import type { Logger } from '@aztec/foundation/log';
+
 import { CircuitRecorder } from './circuit_recorder.js';
 
-/*
+/**
  * In memory circuit recorder uses the default implementation. This is kept
- * while we decide the fate of the FileCircuitRecorder
+ * while we decide the fate of the FileCircuitRecorder.
  */
 export class MemoryCircuitRecorder extends CircuitRecorder {
-  constructor() {
-    super();
+  constructor(logger?: Logger) {
+    super(logger);
   }
 }

package/src/private/circuit_recording/simulator_recorder_wrapper.ts

@@ -58,24 +58,18 @@ export class SimulatorRecorderWrapper implements CircuitSimulator {
     functionName: string,
     callback: C,
   ): Promise<T> {
-    // Start recording circuit execution
-    await this.recorder.start(input, bytecode, contractName, functionName);
-
-    // If callback was provided, we wrap it in a circuit recorder callback wrapper
+    // If a callback was provided, we wrap it so that its oracle calls are recorded. The wrapped callback reads the
+    // active recording lazily, so it picks up the recording opened by record() below.
     const wrappedCallback = this.recorder.wrapCallback(callback);
-    let result: T;
-    try {
-      result = await simulateFn(wrappedCallback as C);
-    } catch (error) {
-      // If an error occurs, we finalize the recording file with the error
-      await this.recorder.finishWithError(error);
-      throw error;
-    }
 
-    // Witness generation is complete so we finish the circuit recorder
-    const recording = await this.recorder.finish();
+    // record() opens a recording for this circuit, runs the simulation within it, and finalizes it. A simulation
+    // failure is re-thrown unchanged, so recorder bookkeeping never masks the underlying error.
+    const { result, recording } = await this.recorder.record(
+      { input, bytecode, circuitName: contractName, functionName },
+      () => simulateFn(wrappedCallback as C),
+    );
 
-    (result as ACIRExecutionResult).oracles = recording.oracleCalls?.reduce(
+    (result as ACIRExecutionResult).oracles = recording.oracleCalls.reduce(
       (acc, { time, name }) => {
         if (!acc[name]) {
           acc[name] = { times: [] };

package/src/private/factory.ts

@@ -1,4 +1,4 @@
-import { type Logger, createLogger } from '@aztec/foundation/log';
+import { type Logger, type LoggerBindings, resolveLogger } from '@aztec/foundation/log';
 
 import { promises as fs } from 'fs';
 
@@ -21,18 +21,21 @@ export function getSimulatorConfigFromEnv() {
 
 export async function createSimulator(
   config: SimulatorConfig,
-  logger: Logger = createLogger('simulator'),
+  loggerOrBindings?: Logger | LoggerBindings,
 ): Promise<CircuitSimulator> {
+  const logger = resolveLogger('simulator', loggerOrBindings);
   if (config.acvmBinaryPath && config.acvmWorkingDirectory) {
     try {
       await fs.access(config.acvmBinaryPath, fs.constants.R_OK);
       await fs.mkdir(config.acvmWorkingDirectory, { recursive: true });
       logger.info(`Using native ACVM at ${config.acvmBinaryPath} and working directory ${config.acvmWorkingDirectory}`);
-      return new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath);
+      const acvmLogger = logger.createChild('acvm-native');
+      return new NativeACVMSimulator(config.acvmWorkingDirectory, config.acvmBinaryPath, undefined, acvmLogger);
     } catch {
       logger.warn(`Failed to access ACVM at ${config.acvmBinaryPath}, falling back to WASM`);
     }
   }
   logger.info('Using WASM ACVM simulation');
-  return new WASMSimulator();
+  const wasmLogger = logger.createChild('wasm');
+  return new WASMSimulator(wasmLogger);
 }

package/src/public/avm/avm_gas.ts

@@ -110,7 +110,7 @@ const BASE_GAS_COSTS: Record<Opcode, Gas> = {
   [Opcode.NULLIFIEREXISTS]: makeCost(c.AVM_NULLIFIEREXISTS_BASE_L2_GAS, 0),
   [Opcode.EMITNULLIFIER]: makeCost(c.AVM_EMITNULLIFIER_BASE_L2_GAS, c.AVM_EMITNULLIFIER_BASE_DA_GAS),
   [Opcode.L1TOL2MSGEXISTS]: makeCost(c.AVM_L1TOL2MSGEXISTS_BASE_L2_GAS, 0),
-  [Opcode.EMITUNENCRYPTEDLOG]: makeCost(c.AVM_EMITUNENCRYPTEDLOG_BASE_L2_GAS, c.AVM_EMITUNENCRYPTEDLOG_BASE_DA_GAS),
+  [Opcode.EMITPUBLICLOG]: makeCost(c.AVM_EMITPUBLICLOG_BASE_L2_GAS, c.AVM_EMITPUBLICLOG_BASE_DA_GAS),
   [Opcode.SENDL2TOL1MSG]: makeCost(c.AVM_SENDL2TOL1MSG_BASE_L2_GAS, c.AVM_SENDL2TOL1MSG_BASE_DA_GAS),
   [Opcode.GETCONTRACTINSTANCE]: makeCost(c.AVM_GETCONTRACTINSTANCE_BASE_L2_GAS, 0),
   [Opcode.CALL]: makeCost(c.AVM_CALL_BASE_L2_GAS, 0),
@@ -130,7 +130,7 @@ const DYNAMIC_GAS_COSTS = new Map<Opcode, Gas>([
   [Opcode.CALLDATACOPY, makeCost(c.AVM_CALLDATACOPY_DYN_L2_GAS, 0)],
   [Opcode.RETURNDATACOPY, makeCost(c.AVM_RETURNDATACOPY_DYN_L2_GAS, 0)],
   // TODO: Call and static call based on bytecode length
-  [Opcode.EMITUNENCRYPTEDLOG, makeCost(c.AVM_EMITUNENCRYPTEDLOG_DYN_L2_GAS, c.AVM_EMITUNENCRYPTEDLOG_DYN_DA_GAS)],
+  [Opcode.EMITPUBLICLOG, makeCost(c.AVM_EMITPUBLICLOG_DYN_L2_GAS, c.AVM_EMITPUBLICLOG_DYN_DA_GAS)],
   [Opcode.TORADIXBE, makeCost(c.AVM_TORADIXBE_DYN_L2_GAS, 0)],
   [Opcode.AND_8, makeCost(c.AVM_BITWISE_DYN_L2_GAS, 0)],
   [Opcode.AND_16, makeCost(c.AVM_BITWISE_DYN_L2_GAS, 0)],

package/src/public/avm/avm_simulator.ts

@@ -63,7 +63,7 @@ export class AvmSimulator implements AvmSimulatorInterface {
   public static async build(context: AvmContext): Promise<AvmSimulator> {
     const simulator = new AvmSimulator(context);
     const fnName = await context.persistableState.getPublicFunctionDebugName(context.environment);
-    simulator.log = createLogger(`simulator:avm(f:${fnName})`);
+    simulator.log = createLogger(`simulator:avm(f:${fnName.slice(0, 128)})`);
 
     return simulator;
   }

package/src/public/avm/calldata.ts

@@ -33,13 +33,14 @@ export class LazyReaderMemory implements LazyReader {
   }
 
   public slice(start: number, end: number): Fr[] {
-    const clampedEnd = Math.min(end, this.size);
+    const clampedEnd = Math.min(end, this.size, TaggedMemory.MAX_MEMORY_SIZE - this.offset);
     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());
+    const size = Math.min(this.size, TaggedMemory.MAX_MEMORY_SIZE - this.offset);
+    return this.memory.getSlice(this.offset, size).map(word => word.toFr());
   }
 
   public length(): number {