@aztec/simulator 0.56.0 → 0.58.0

package/src/acvm/oracle/oracle.ts

@@ -1,8 +1,7 @@
 import { MerkleTreeId, UnencryptedL2Log } from '@aztec/circuit-types';
-import { KeyValidationRequest } from '@aztec/circuits.js';
 import { FunctionSelector, NoteSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
-import { Fr, Point } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/fields';
 
 import { type ACVMField } from '../acvm_types.js';
 import { frToBoolean, frToNumber, fromACVMField } from '../deserialize.js';
@@ -71,7 +70,7 @@ export class Oracle {
       instance.deployer,
       instance.contractClassId,
       instance.initializationHash,
-      instance.publicKeysHash,
+      ...instance.publicKeys.toFields(),
     ].map(toACVMField);
   }
 
@@ -329,72 +328,6 @@ export class Oracle {
     this.typedOracle.emitEncryptedNoteLog(+noteHashCounter, processedInput, +counter);
   }
 
-  computeEncryptedEventLog(
-    [contractAddress]: ACVMField[],
-    [randomness]: ACVMField[],
-    [eventTypeId]: ACVMField[],
-    [ovskApp]: ACVMField[],
-    [ovpkMX]: ACVMField[],
-    [ovpkMY]: ACVMField[],
-    [ovpkMIsInfinite]: ACVMField[],
-    [ivpkMX]: ACVMField[],
-    [ivpkMY]: ACVMField[],
-    [ivpkMIsInfinite]: ACVMField[],
-    [recipient]: ACVMField[],
-    preimage: ACVMField[],
-  ): ACVMField[] {
-    const ovpkM = new Point(fromACVMField(ovpkMX), fromACVMField(ovpkMY), !fromACVMField(ovpkMIsInfinite).isZero());
-    const ovKeys = new KeyValidationRequest(ovpkM, Fr.fromString(ovskApp));
-    const ivpkM = new Point(fromACVMField(ivpkMX), fromACVMField(ivpkMY), !fromACVMField(ivpkMIsInfinite).isZero());
-    const encLog = this.typedOracle.computeEncryptedEventLog(
-      AztecAddress.fromString(contractAddress),
-      Fr.fromString(randomness),
-      Fr.fromString(eventTypeId),
-      ovKeys,
-      ivpkM,
-      AztecAddress.fromString(recipient),
-      preimage.map(fromACVMField),
-    );
-    const bytes: ACVMField[] = [];
-    encLog.forEach(v => {
-      bytes.push(toACVMField(v));
-    });
-    return bytes;
-  }
-
-  computeEncryptedNoteLog(
-    [contractAddress]: ACVMField[],
-    [storageSlot]: ACVMField[],
-    [noteTypeId]: ACVMField[],
-    [ovskApp]: ACVMField[],
-    [ovpkMX]: ACVMField[],
-    [ovpkMY]: ACVMField[],
-    [ovpkMIsInfinite]: ACVMField[],
-    [ivpkMX]: ACVMField[],
-    [ivpkMY]: ACVMField[],
-    [ivpkMIsInfinite]: ACVMField[],
-    [recipient]: ACVMField[],
-    preimage: ACVMField[],
-  ): ACVMField[] {
-    const ovpkM = new Point(fromACVMField(ovpkMX), fromACVMField(ovpkMY), !fromACVMField(ovpkMIsInfinite).isZero());
-    const ovKeys = new KeyValidationRequest(ovpkM, Fr.fromString(ovskApp));
-    const ivpkM = new Point(fromACVMField(ivpkMX), fromACVMField(ivpkMY), !fromACVMField(ivpkMIsInfinite).isZero());
-    const encLog = this.typedOracle.computeEncryptedNoteLog(
-      AztecAddress.fromString(contractAddress),
-      Fr.fromString(storageSlot),
-      NoteSelector.fromField(Fr.fromString(noteTypeId)),
-      ovKeys,
-      ivpkM,
-      AztecAddress.fromString(recipient),
-      preimage.map(fromACVMField),
-    );
-    const bytes: ACVMField[] = [];
-    encLog.forEach(v => {
-      bytes.push(toACVMField(v));
-    });
-    return bytes;
-  }
-
   emitUnencryptedLog([contractAddress]: ACVMField[], message: ACVMField[], [counter]: ACVMField[]): ACVMField {
     const logPayload = Buffer.concat(message.map(fromACVMField).map(f => f.toBuffer()));
     const log = new UnencryptedL2Log(AztecAddress.fromString(contractAddress), logPayload);
@@ -447,8 +380,8 @@ export class Oracle {
     [sideEffectCounter]: ACVMField[],
     [isStaticCall]: ACVMField[],
     [isDelegateCall]: ACVMField[],
-  ) {
-    await this.typedOracle.enqueuePublicFunctionCall(
+  ): Promise<ACVMField> {
+    const newArgsHash = await this.typedOracle.enqueuePublicFunctionCall(
       AztecAddress.fromString(contractAddress),
       FunctionSelector.fromField(fromACVMField(functionSelector)),
       fromACVMField(argsHash),
@@ -456,6 +389,7 @@ export class Oracle {
       frToBoolean(fromACVMField(isStaticCall)),
       frToBoolean(fromACVMField(isDelegateCall)),
     );
+    return toACVMField(newArgsHash);
   }
 
   async setPublicTeardownFunctionCall(
@@ -465,8 +399,8 @@ export class Oracle {
     [sideEffectCounter]: ACVMField[],
     [isStaticCall]: ACVMField[],
     [isDelegateCall]: ACVMField[],
-  ) {
-    await this.typedOracle.setPublicTeardownFunctionCall(
+  ): Promise<ACVMField> {
+    const newArgsHash = await this.typedOracle.setPublicTeardownFunctionCall(
       AztecAddress.fromString(contractAddress),
       FunctionSelector.fromField(fromACVMField(functionSelector)),
       fromACVMField(argsHash),
@@ -474,22 +408,10 @@ export class Oracle {
       frToBoolean(fromACVMField(isStaticCall)),
       frToBoolean(fromACVMField(isDelegateCall)),
     );
+    return toACVMField(newArgsHash);
   }
 
   notifySetMinRevertibleSideEffectCounter([minRevertibleSideEffectCounter]: ACVMField[]) {
     this.typedOracle.notifySetMinRevertibleSideEffectCounter(frToNumber(fromACVMField(minRevertibleSideEffectCounter)));
   }
-
-  aes128Encrypt(input: ACVMField[], initializationVector: ACVMField[], key: ACVMField[]): ACVMField[] {
-    // Convert each field to a number and then to a buffer (1 byte is stored in 1 field)
-    const processedInput = Buffer.from(input.map(fromACVMField).map(f => f.toNumber()));
-    const processedIV = Buffer.from(initializationVector.map(fromACVMField).map(f => f.toNumber()));
-    const processedKey = Buffer.from(key.map(fromACVMField).map(f => f.toNumber()));
-
-    // Encrypt the input
-    const ciphertext = this.typedOracle.aes128Encrypt(processedInput, processedIV, processedKey);
-
-    // Convert each byte of ciphertext to a field and return it
-    return Array.from(ciphertext).map(byte => toACVMField(byte));
-  }
 }

package/src/acvm/oracle/typed_oracle.ts

@@ -5,15 +5,18 @@ import {
   type NoteStatus,
   type NullifierMembershipWitness,
   type PublicDataWitness,
-  type PublicKey,
   type SiblingPath,
   type UnencryptedL2Log,
 } from '@aztec/circuit-types';
-import { type Header, type KeyValidationRequest, type L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/circuits.js';
+import {
+  type ContractInstance,
+  type Header,
+  type KeyValidationRequest,
+  type L1_TO_L2_MSG_TREE_HEIGHT,
+} from '@aztec/circuits.js';
 import { type FunctionSelector, type NoteSelector } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
-import { type ContractInstance } from '@aztec/types/contracts';
 
 /**
  * Information about a note needed during execution.
@@ -204,30 +207,6 @@ export abstract class TypedOracle {
     throw new OracleMethodNotAvailableError('emitEncryptedNoteLog');
   }
 
-  computeEncryptedEventLog(
-    _contractAddress: AztecAddress,
-    _randomness: Fr,
-    _eventTypeId: Fr,
-    _ovKeys: KeyValidationRequest,
-    _ivpkM: PublicKey,
-    _recipient: AztecAddress,
-    _preimage: Fr[],
-  ): Buffer {
-    throw new OracleMethodNotAvailableError('computeEncryptedEventLog');
-  }
-
-  computeEncryptedNoteLog(
-    _contractAddress: AztecAddress,
-    _storageSlot: Fr,
-    _noteTypeId: NoteSelector,
-    _ovKeys: KeyValidationRequest,
-    _ivpkM: PublicKey,
-    _recipient: AztecAddress,
-    _preimage: Fr[],
-  ): Buffer {
-    throw new OracleMethodNotAvailableError('computeEncryptedNoteLog');
-  }
-
   emitUnencryptedLog(_log: UnencryptedL2Log, _counter: number): void {
     throw new OracleMethodNotAvailableError('emitUnencryptedLog');
   }
@@ -254,7 +233,7 @@ export abstract class TypedOracle {
     _sideEffectCounter: number,
     _isStaticCall: boolean,
     _isDelegateCall: boolean,
-  ): Promise<void> {
+  ): Promise<Fr> {
     throw new OracleMethodNotAvailableError('enqueuePublicFunctionCall');
   }
 
@@ -265,7 +244,7 @@ export abstract class TypedOracle {
     _sideEffectCounter: number,
     _isStaticCall: boolean,
     _isDelegateCall: boolean,
-  ): Promise<void> {
+  ): Promise<Fr> {
     throw new OracleMethodNotAvailableError('setPublicTeardownFunctionCall');
   }
 
@@ -273,10 +252,6 @@ export abstract class TypedOracle {
     throw new OracleMethodNotAvailableError('notifySetMinRevertibleSideEffectCounter');
   }
 
-  aes128Encrypt(_input: Buffer, _initializationVector: Buffer, _key: Buffer): Buffer {
-    throw new OracleMethodNotAvailableError('encrypt');
-  }
-
   debugLog(_message: string, _fields: Fr[]): void {
     throw new OracleMethodNotAvailableError('debugLog');
   }

package/src/avm/avm_execution_environment.ts

@@ -1,4 +1,4 @@
-import { FunctionSelector, type GlobalVariables, type Header } from '@aztec/circuits.js';
+import { FunctionSelector, type GlobalVariables } from '@aztec/circuits.js';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
 import { Fr } from '@aztec/foundation/fields';
 
@@ -14,7 +14,6 @@ export class AvmExecutionEnvironment {
     public readonly functionSelector: FunctionSelector, // may be temporary (#7224)
     public readonly contractCallDepth: Fr,
     public readonly transactionFee: Fr,
-    public readonly header: Header,
     public readonly globals: GlobalVariables,
     public readonly isStaticCall: boolean,
     public readonly isDelegateCall: boolean,
@@ -35,7 +34,6 @@ export class AvmExecutionEnvironment {
       functionSelector,
       this.contractCallDepth.add(Fr.ONE),
       this.transactionFee,
-      this.header,
       this.globals,
       isStaticCall,
       isDelegateCall,

package/src/avm/avm_gas.ts

@@ -101,7 +101,6 @@ const BASE_GAS_COSTS: Record<Opcode, Gas> = {
   [Opcode.SET_FF]: makeCost(c.AVM_SET_BASE_L2_GAS, 0),
   [Opcode.MOV_8]: makeCost(c.AVM_MOV_BASE_L2_GAS, 0),
   [Opcode.MOV_16]: makeCost(c.AVM_MOV_BASE_L2_GAS, 0),
-  [Opcode.CMOV]: makeCost(c.AVM_CMOV_BASE_L2_GAS, 0),
   [Opcode.SLOAD]: makeCost(c.AVM_SLOAD_BASE_L2_GAS, 0),
   [Opcode.SSTORE]: makeCost(c.AVM_SSTORE_BASE_L2_GAS, c.AVM_SSTORE_BASE_DA_GAS),
   [Opcode.NOTEHASHEXISTS]: makeCost(c.AVM_NOTEHASHEXISTS_BASE_L2_GAS, 0),
@@ -181,6 +180,7 @@ export function getGasCostForTypeTag(tag: TypeTag, baseCost: Gas) {
 function getGasCostMultiplierFromTypeTag(tag: TypeTag) {
   switch (tag) {
     case TypeTag.UINT1: // same as u8
+      return 1;
     case TypeTag.UINT8:
       return 1;
     case TypeTag.UINT16:
@@ -194,7 +194,6 @@ function getGasCostMultiplierFromTypeTag(tag: TypeTag) {
     case TypeTag.FIELD:
       return 32;
     case TypeTag.INVALID:
-    case TypeTag.UNINITIALIZED:
       throw new InstructionExecutionError(`Invalid tag type for gas cost multiplier: ${TypeTag[tag]}`);
   }
 }

package/src/avm/avm_memory_types.ts

@@ -208,21 +208,19 @@ export class Field extends MemoryValue {
 }
 
 export enum TypeTag {
-  UNINITIALIZED,
+  FIELD = MEM_TAG_FF,
   UINT1 = MEM_TAG_U1,
   UINT8 = MEM_TAG_U8,
   UINT16 = MEM_TAG_U16,
   UINT32 = MEM_TAG_U32,
   UINT64 = MEM_TAG_U64,
   UINT128 = MEM_TAG_U128,
-  FIELD = MEM_TAG_FF,
   INVALID,
 }
 
 // Lazy interface definition for tagged memory
 export type TaggedMemoryInterface = FunctionsOf<TaggedMemory>;
 
-// TODO: Consider automatic conversion when getting undefined values.
 export class TaggedMemory implements TaggedMemoryInterface {
   static readonly log: DebugLogger = createDebugLogger('aztec:avm_simulator:memory');
 
@@ -255,6 +253,7 @@ export class TaggedMemory implements TaggedMemoryInterface {
     TaggedMemory.log.debug(`get(${offset}) = ${word}`);
     if (word === undefined) {
       TaggedMemory.log.debug(`WARNING: Memory at offset ${offset} is undefined!`);
+      return new Field(0) as T;
     }
     return word as T;
   }
@@ -264,7 +263,11 @@ export class TaggedMemory implements TaggedMemoryInterface {
     assert(offset + size < TaggedMemory.MAX_MEMORY_SIZE);
     const value = this._mem.slice(offset, offset + size);
     TaggedMemory.log.debug(`getSlice(${offset}, ${size}) = ${value}`);
-    assert(!value.some(e => e === undefined), 'Memory slice contains undefined values.');
+    for (let i = 0; i < value.length; i++) {
+      if (value[i] === undefined) {
+        value[i] = new Field(0);
+      }
+    }
     assert(value.length === size, `Expected slice of size ${size}, got ${value.length}.`);
     return value;
   }
@@ -332,6 +335,16 @@ export class TaggedMemory implements TaggedMemoryInterface {
     }
   }
 
+  /**
+   * Check that all tags at the given offsets are the same.
+   */
+  public checkTagsAreSame(...offsets: number[]) {
+    const tag = this.getTag(offsets[0]);
+    for (let i = 1; i < offsets.length; i++) {
+      this.checkTag(tag, offsets[i]);
+    }
+  }
+
   /**
    * Check tags for all memory in the specified range.
    */
@@ -347,7 +360,9 @@ export class TaggedMemory implements TaggedMemoryInterface {
     let tag = TypeTag.INVALID;
 
     if (v === undefined) {
-      tag = TypeTag.UNINITIALIZED;
+      tag = TypeTag.FIELD; // uninitialized memory is Field(0)
+    } else if (v instanceof Field) {
+      tag = TypeTag.FIELD;
     } else if (v instanceof Uint1) {
       tag = TypeTag.UINT1;
     } else if (v instanceof Uint8) {
@@ -360,8 +375,6 @@ export class TaggedMemory implements TaggedMemoryInterface {
       tag = TypeTag.UINT64;
     } else if (v instanceof Uint128) {
       tag = TypeTag.UINT128;
-    } else if (v instanceof Field) {
-      tag = TypeTag.FIELD;
     }
 
     return tag;
@@ -371,6 +384,8 @@ export class TaggedMemory implements TaggedMemoryInterface {
   public static buildFromTagTruncating(v: bigint | number, tag: TypeTag): MemoryValue {
     v = BigInt(v);
     switch (tag) {
+      case TypeTag.FIELD:
+        return new Field(v);
       case TypeTag.UINT1:
         return new Uint1(v & 1n);
       case TypeTag.UINT8:
@@ -383,8 +398,6 @@ export class TaggedMemory implements TaggedMemoryInterface {
         return new Uint64(v & ((1n << 64n) - 1n));
       case TypeTag.UINT128:
         return new Uint128(v & ((1n << 128n) - 1n));
-      case TypeTag.FIELD:
-        return new Field(v);
       default:
         throw new Error(`${TypeTag[tag]} is not a valid tag.`);
     }
@@ -393,6 +406,8 @@ export class TaggedMemory implements TaggedMemoryInterface {
   // Does not truncate. Type constructor will check that it fits.
   public static buildFromTagOrDie(v: bigint | number, tag: TypeTag): MemoryValue {
     switch (tag) {
+      case TypeTag.FIELD:
+        return new Field(v);
       case TypeTag.UINT1:
         return new Uint1(v);
       case TypeTag.UINT8:
@@ -405,15 +420,13 @@ export class TaggedMemory implements TaggedMemoryInterface {
         return new Uint64(v);
       case TypeTag.UINT128:
         return new Uint128(v);
-      case TypeTag.FIELD:
-        return new Field(v);
       default:
         throw new Error(`${TypeTag[tag]} is not a valid integral type.`);
     }
   }
 
   /** No-op. Implemented here for compatibility with the MeteredTaggedMemory. */
-  public assert(_operations: Partial<MemoryOperations & { indirect: number }>) {}
+  public assert(_operations: Partial<MemoryOperations & { addressing: Addressing }>) {}
 }
 
 /** Tagged memory wrapper with metering for each memory read and write operation. */
@@ -435,10 +448,15 @@ export class MeteredTaggedMemory implements TaggedMemoryInterface {
    * Asserts that the exact number of memory operations have been performed.
    * Indirect represents the flags for indirect accesses: each bit set to one counts as an extra read.
    */
-  public assert(operations: Partial<MemoryOperations & { indirect: number }>) {
-    const { reads: expectedReads, writes: expectedWrites, indirect } = { reads: 0, writes: 0, ...operations };
-
-    const totalExpectedReads = expectedReads + Addressing.fromWire(indirect ?? 0).count(AddressingMode.INDIRECT);
+  public assert(operations: Partial<MemoryOperations & { addressing: Addressing }>) {
+    const {
+      reads: expectedReads,
+      writes: expectedWrites,
+      addressing,
+    } = { reads: 0, writes: 0, addressing: new Addressing([]), ...operations };
+
+    const totalExpectedReads =
+      expectedReads + addressing.count(AddressingMode.INDIRECT) + addressing.count(AddressingMode.RELATIVE);
     const { reads: actualReads, writes: actualWrites } = this.reset();
     if (actualReads !== totalExpectedReads) {
       throw new InstructionExecutionError(
@@ -506,6 +524,10 @@ export class MeteredTaggedMemory implements TaggedMemoryInterface {
     this.wrapped.checkTags(tag, ...offsets);
   }
 
+  public checkTagsAreSame(...offsets: number[]): void {
+    this.wrapped.checkTagsAreSame(...offsets);
+  }
+
   public checkTagsRange(tag: TypeTag, startOffset: number, size: number): void {
     this.wrapped.checkTagsRange(tag, startOffset, size);
   }

package/src/avm/avm_simulator.ts

@@ -1,7 +1,9 @@
+import { MAX_L2_GAS_PER_ENQUEUED_CALL } from '@aztec/circuits.js';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 
 import { strict as assert } from 'assert';
 
+import { SideEffectLimitReachedError } from '../public/side_effect_errors.js';
 import type { AvmContext } from './avm_context.js';
 import { AvmContractCallResult } from './avm_contract_call_result.js';
 import { isAvmBytecode } from './bytecode_utils.js';
@@ -20,6 +22,10 @@ export class AvmSimulator {
   private bytecode: Buffer | undefined;
 
   constructor(private context: AvmContext) {
+    assert(
+      context.machineState.gasLeft.l2Gas <= MAX_L2_GAS_PER_ENQUEUED_CALL,
+      `Cannot allocate more than ${MAX_L2_GAS_PER_ENQUEUED_CALL} to the AVM for execution of an enqueued call`,
+    );
     this.log = createDebugLogger(`aztec:avm_simulator:core(f:${context.environment.functionSelector.toString()})`);
   }
 
@@ -98,7 +104,7 @@ export class AvmSimulator {
       return results;
     } catch (err: any) {
       this.log.verbose('Exceptional halt (revert by something other than REVERT opcode)');
-      if (!(err instanceof AvmExecutionError)) {
+      if (!(err instanceof AvmExecutionError || err instanceof SideEffectLimitReachedError)) {
         this.log.verbose(`Unknown error thrown by AVM: ${err}`);
         throw err;
       }

package/src/avm/errors.ts

@@ -1,5 +1,5 @@
 import { type FailingFunction, type NoirCallStack } from '@aztec/circuit-types';
-import { type AztecAddress, type Fr } from '@aztec/circuits.js';
+import { type AztecAddress, Fr, FunctionSelector, PUBLIC_DISPATCH_SELECTOR } from '@aztec/circuits.js';
 
 import { ExecutionError } from '../common/errors.js';
 import { type AvmContext } from './avm_context.js';
@@ -109,13 +109,21 @@ export class AvmRevertReason extends ExecutionError {
  * @param nestedError - the error that caused this one (if this is not the root-cause itself)
  */
 function createRevertReason(message: string, context: AvmContext, nestedError?: AvmRevertReason): AvmRevertReason {
+  // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Properly fix this.
+  // If the function selector is the public dispatch selector, we need to extract the actual function selector from the calldata.
+  // We should remove this because the AVM (or public protocol) shouldn't be aware of the public dispatch calling convention.
+  let functionSelector = context.environment.functionSelector;
+  const internalCallStack = context.machineState.internalCallStack;
+  if (functionSelector.toField().equals(new Fr(PUBLIC_DISPATCH_SELECTOR)) && context.environment.calldata.length > 0) {
+    functionSelector = FunctionSelector.fromField(context.environment.calldata[0]);
+  }
   return new AvmRevertReason(
     message,
     /*failingFunction=*/ {
       contractAddress: context.environment.address,
-      functionSelector: context.environment.functionSelector,
+      functionSelector: functionSelector,
     },
-    /*noirCallStack=*/ [...context.machineState.internalCallStack, context.machineState.pc].map(pc => `0.${pc}`),
+    /*noirCallStack=*/ [...internalCallStack, context.machineState.pc].map(pc => `0.${pc}`),
     /*options=*/ { cause: nestedError },
   );
 }

package/src/avm/fixtures/index.ts

@@ -1,5 +1,5 @@
 import { isNoirCallStackUnresolved } from '@aztec/circuit-types';
-import { GasFees, GlobalVariables, Header } from '@aztec/circuits.js';
+import { GasFees, GlobalVariables, MAX_L2_GAS_PER_ENQUEUED_CALL } from '@aztec/circuits.js';
 import { FunctionSelector, getFunctionDebugMetadata } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
@@ -63,7 +63,6 @@ export function initExecutionEnvironment(overrides?: Partial<AvmExecutionEnviron
     overrides?.functionSelector ?? FunctionSelector.empty(),
     overrides?.contractCallDepth ?? Fr.zero(),
     overrides?.transactionFee ?? Fr.zero(),
-    overrides?.header ?? Header.empty(),
     overrides?.globals ?? GlobalVariables.empty(),
     overrides?.isStaticCall ?? false,
     overrides?.isDelegateCall ?? false,
@@ -92,7 +91,7 @@ export function initGlobalVariables(overrides?: Partial<GlobalVariables>): Globa
  */
 export function initMachineState(overrides?: Partial<AvmMachineState>): AvmMachineState {
   return AvmMachineState.fromState({
-    l2GasLeft: overrides?.l2GasLeft ?? 1e8,
+    l2GasLeft: overrides?.l2GasLeft ?? MAX_L2_GAS_PER_ENQUEUED_CALL,
     daGasLeft: overrides?.daGasLeft ?? 1e8,
   });
 }

package/src/avm/journal/journal.ts

@@ -1,8 +1,8 @@
-import { AztecAddress, type FunctionSelector, type Gas } from '@aztec/circuits.js';
+import { AztecAddress, type FunctionSelector, type Gas, SerializableContractInstance } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
-import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
-import { SerializableContractInstance } from '@aztec/types/contracts';
+import { createDebugLogger } from '@aztec/foundation/log';
 
+import { getPublicFunctionDebugName } from '../../common/debug_fn_name.js';
 import { type WorldStateDB } from '../../public/public_db_sources.js';
 import { type TracedContractInstance } from '../../public/side_effect_trace.js';
 import { type PublicSideEffectTraceInterface } from '../../public/side_effect_trace_interface.js';
@@ -21,7 +21,7 @@ import { PublicStorage } from './public_storage.js';
  * Manages merging of successful/reverted child state into current state.
  */
 export class AvmPersistableStateManager {
-  private readonly log: DebugLogger = createDebugLogger('aztec:avm_simulator:state_manager');
+  private readonly log = createDebugLogger('aztec:avm_simulator:state_manager');
 
   constructor(
     /** Reference to node storage */
@@ -187,12 +187,13 @@ export class AvmPersistableStateManager {
 
   /**
    * Write an L2 to L1 message.
+   * @param contractAddress - L2 contract address that created this message
    * @param recipient - L1 contract address to send the message to.
    * @param content - Message content.
    */
-  public writeL2ToL1Message(recipient: Fr, content: Fr) {
-    this.log.debug(`L1Messages(${recipient}) += ${content}.`);
-    this.trace.traceNewL2ToL1Message(recipient, content);
+  public writeL2ToL1Message(contractAddress: Fr, recipient: Fr, content: Fr) {
+    this.log.debug(`L2ToL1Messages(${contractAddress}) += (recipient: ${recipient}, content: ${content}).`);
+    this.trace.traceNewL2ToL1Message(contractAddress, recipient, content);
   }
 
   /**
@@ -256,9 +257,12 @@ export class AvmPersistableStateManager {
     if (!avmCallResults.reverted) {
       this.acceptNestedCallState(nestedState);
     }
-    const functionName =
-      (await this.worldStateDB.getDebugFunctionName(nestedEnvironment.address, nestedEnvironment.functionSelector)) ??
-      `${nestedEnvironment.address}:${nestedEnvironment.functionSelector}`;
+    const functionName = await getPublicFunctionDebugName(
+      this.worldStateDB,
+      nestedEnvironment.address,
+      nestedEnvironment.functionSelector,
+      nestedEnvironment.calldata,
+    );
 
     this.log.verbose(`[AVM] Calling nested function ${functionName}`);