@aztec/simulator 0.0.1-fake-ceab37513c → 0.0.6-commit.a2d1860fe9

package/src/public/side_effect_errors.ts

@@ -1,6 +1,96 @@
-export class SideEffectLimitReachedError extends Error {
+import {
+  L1_TO_L2_MSG_TREE_LEAF_COUNT,
+  MAX_L2_TO_L1_MSGS_PER_TX,
+  MAX_NOTE_HASHES_PER_TX,
+  MAX_NULLIFIERS_PER_TX,
+  MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS,
+  NOTE_HASH_TREE_LEAF_COUNT,
+} from '@aztec/constants';
+
+import { CheckedPublicExecutionError } from './public_errors.js';
+
+/**
+ * Any error that can be thrown during side effect insertion in public.
+ * Includes SideEffectLimitReachedError and NullifierCollisionError.
+ */
+export abstract class SideEffectError extends CheckedPublicExecutionError {
+  constructor(message: string) {
+    super(message);
+    this.name = 'SideEffectInsertionError';
+  }
+}
+
+export class SideEffectLimitReachedError extends SideEffectError {
   constructor(sideEffectType: string, limit: number) {
     super(`Reached the limit (${limit}) on number of '${sideEffectType}' per tx`);
     this.name = 'SideEffectLimitReachedError';
   }
 }
+
+export class MaxCallsToUniqueContractClassIdsError extends SideEffectLimitReachedError {
+  constructor() {
+    super('contract calls to unique class IDs', MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS);
+    this.name = 'MaxCallsToUniqueContractClassIdsError';
+  }
+}
+
+export class NullifierLimitReachedError extends SideEffectLimitReachedError {
+  constructor() {
+    super('nullifier', MAX_NULLIFIERS_PER_TX);
+    this.name = 'NullifierLimitReachedError';
+  }
+}
+
+export class NoteHashLimitReachedError extends SideEffectLimitReachedError {
+  constructor() {
+    super('note hash', MAX_NOTE_HASHES_PER_TX);
+    this.name = 'NoteHashLimitReachedError';
+  }
+}
+
+export class L2ToL1MessageLimitReachedError extends SideEffectLimitReachedError {
+  constructor() {
+    super('l2 to l1 message', MAX_L2_TO_L1_MSGS_PER_TX);
+    this.name = 'L2ToL1MessageLimitReachedError';
+  }
+}
+
+export class NullifierCollisionError extends SideEffectError {
+  constructor(message: string) {
+    super(`Nullifier collision: ${message}`);
+    this.name = 'NullifierCollisionError';
+  }
+}
+
+/**
+ * Any error that can be thrown during side effect reads in public.
+ * Note: Thrown at state manager level and unknown by simulation, hence NOT considered
+ * CheckedPublicExecutionErrors. Currently only includes append-only tree reads.
+ */
+export abstract class SideEffectReadError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'SideEffectReadError';
+  }
+}
+
+export class IndexOutOfRangeError extends SideEffectReadError {
+  constructor(tree: string, index: number, limit: number) {
+    super(`Attempting to read index ${index} of ${tree} tree with maximum ${limit} leaves`);
+    this.name = 'IndexOutOfRangeError';
+  }
+}
+
+export class NoteHashIndexOutOfRangeError extends IndexOutOfRangeError {
+  constructor(index: number) {
+    super('note hash', index, NOTE_HASH_TREE_LEAF_COUNT);
+    this.name = 'NoteHashIndexOutOfRangeError';
+  }
+}
+
+export class L1ToL2MessageIndexOutOfRangeError extends IndexOutOfRangeError {
+  constructor(index: number) {
+    super('l1 to l2 message', index, L1_TO_L2_MSG_TREE_LEAF_COUNT);
+    this.name = 'L1ToL2MessageIndexOutOfRangeError';
+  }
+}

package/src/public/side_effect_trace.ts

@@ -1,27 +1,31 @@
 import {
+  FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH,
   MAX_L2_TO_L1_MSGS_PER_TX,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
   MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS,
   MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  MAX_PUBLIC_LOGS_PER_TX,
   PROTOCOL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
-  PUBLIC_LOG_SIZE_IN_FIELDS,
 } from '@aztec/constants';
-import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
+import { type LogLevel, type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { PublicDataUpdateRequest } from '@aztec/stdlib/avm';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { computePublicDataTreeLeafSlot } from '@aztec/stdlib/hash';
 import { NoteHash, Nullifier } from '@aztec/stdlib/kernel';
-import { PublicLog } from '@aztec/stdlib/logs';
+import { DebugLog, PublicLog } from '@aztec/stdlib/logs';
 import { L2ToL1Message, ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
 
 import { strict as assert } from 'assert';
 
-import { SideEffectLimitReachedError } from './side_effect_errors.js';
+import {
+  L2ToL1MessageLimitReachedError,
+  MaxCallsToUniqueContractClassIdsError,
+  NoteHashLimitReachedError,
+  NullifierLimitReachedError,
+  SideEffectLimitReachedError,
+} from './side_effect_errors.js';
 import type { PublicSideEffectTraceInterface } from './side_effect_trace_interface.js';
 import { UniqueClassIds } from './unique_class_ids.js';
 
@@ -45,7 +49,7 @@ export class SideEffectArrayLengths {
     public readonly noteHashes: number,
     public readonly nullifiers: number,
     public readonly l2ToL1Msgs: number,
-    public readonly publicLogs: number,
+    public readonly publicLogFields: number,
   ) {}
 
   static empty() {
@@ -57,7 +61,7 @@ export class SideEffectArrayLengths {
  * Trace side effects for an enqueued public call's execution.
  */
 export class SideEffectTrace implements PublicSideEffectTraceInterface {
-  public log = createLogger('simulator:side_effect_trace');
+  public log: Logger;
 
   /** The side effect counter increments with every call to the trace. */
   private sideEffectCounter: number;
@@ -69,13 +73,13 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
   private nullifiers: Nullifier[] = [];
   private l2ToL1Messages: ScopedL2ToL1Message[] = [];
   private publicLogs: PublicLog[] = [];
-
   /** Make sure a forked trace is never merged twice. */
   private alreadyMergedIntoParent = false;
 
   constructor(
     /** The counter of this trace's first side effect. */
     public readonly startSideEffectCounter: number = 0,
+    bindings?: LoggerBindings,
     /** Track parent's (or previous kernel's) lengths so the AVM can properly enforce TX-wide limits,
      *  otherwise the public kernel can fail to prove because TX limits are breached.
      */
@@ -83,23 +87,30 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
     /** We need to track the set of class IDs used, to enforce limits. */
     private uniqueClassIds: UniqueClassIds = new UniqueClassIds(),
     private writtenPublicDataSlots: Set<string> = new Set(),
+    private debugLogs: DebugLog[] = [],
+    private debugLogMemoryReads: number = 0,
   ) {
     this.sideEffectCounter = startSideEffectCounter;
+    this.log = createLogger('simulator:side_effect_trace', bindings);
   }
 
   public fork() {
     return new SideEffectTrace(
       this.sideEffectCounter,
+      this.log.getBindings(),
       new SideEffectArrayLengths(
         this.previousSideEffectArrayLengths.publicDataWrites + this.userPublicDataWritesLength,
         this.previousSideEffectArrayLengths.protocolPublicDataWrites + this.protocolPublicDataWritesLength,
         this.previousSideEffectArrayLengths.noteHashes + this.noteHashes.length,
         this.previousSideEffectArrayLengths.nullifiers + this.nullifiers.length,
         this.previousSideEffectArrayLengths.l2ToL1Msgs + this.l2ToL1Messages.length,
-        this.previousSideEffectArrayLengths.publicLogs + this.publicLogs.length,
+        this.previousSideEffectArrayLengths.publicLogFields +
+          this.publicLogs.reduce((acc, log) => acc + log.sizeInFields(), 0),
       ),
       this.uniqueClassIds.fork(),
       new Set(this.writtenPublicDataSlots),
+      this.debugLogs.slice(),
+      this.debugLogMemoryReads,
     );
   }
 
@@ -113,6 +124,8 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
 
     this.sideEffectCounter = forkedTrace.sideEffectCounter;
     this.uniqueClassIds.acceptAndMerge(forkedTrace.uniqueClassIds);
+    this.debugLogs = forkedTrace.debugLogs;
+    this.debugLogMemoryReads = forkedTrace.debugLogMemoryReads;
 
     if (!reverted) {
       this.publicDataWrites.push(...forkedTrace.publicDataWrites);
@@ -193,7 +206,7 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
 
   public traceNewNoteHash(noteHash: Fr) {
     if (this.noteHashes.length + this.previousSideEffectArrayLengths.noteHashes >= MAX_NOTE_HASHES_PER_TX) {
-      throw new SideEffectLimitReachedError('note hash', MAX_NOTE_HASHES_PER_TX);
+      throw new NoteHashLimitReachedError();
     }
 
     this.noteHashes.push(new NoteHash(noteHash, this.sideEffectCounter));
@@ -203,10 +216,10 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
 
   public traceNewNullifier(siloedNullifier: Fr) {
     if (this.nullifiers.length + this.previousSideEffectArrayLengths.nullifiers >= MAX_NULLIFIERS_PER_TX) {
-      throw new SideEffectLimitReachedError('nullifier', MAX_NULLIFIERS_PER_TX);
+      throw new NullifierLimitReachedError();
     }
 
-    this.nullifiers.push(new Nullifier(siloedNullifier, this.sideEffectCounter, /*noteHash=*/ Fr.ZERO));
+    this.nullifiers.push(new Nullifier(siloedNullifier, /*noteHash=*/ Fr.ZERO, this.sideEffectCounter));
 
     this.log.trace(`Tracing new nullifier (counter=${this.sideEffectCounter})`);
     this.incrementSideEffectCounter();
@@ -214,7 +227,7 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
 
   public traceNewL2ToL1Message(contractAddress: AztecAddress, recipient: Fr, content: Fr) {
     if (this.l2ToL1Messages.length + this.previousSideEffectArrayLengths.l2ToL1Msgs >= MAX_L2_TO_L1_MSGS_PER_TX) {
-      throw new SideEffectLimitReachedError('l2 to l1 message', MAX_L2_TO_L1_MSGS_PER_TX);
+      throw new L2ToL1MessageLimitReachedError();
     }
 
     const recipientAddress = EthAddress.fromField(recipient);
@@ -224,28 +237,43 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
   }
 
   public tracePublicLog(contractAddress: AztecAddress, log: Fr[]) {
-    if (this.publicLogs.length + this.previousSideEffectArrayLengths.publicLogs >= MAX_PUBLIC_LOGS_PER_TX) {
-      throw new SideEffectLimitReachedError('public log', MAX_PUBLIC_LOGS_PER_TX);
-    }
+    const previouslyEmittedPublicLogFieldsCount =
+      this.previousSideEffectArrayLengths.publicLogFields +
+      this.publicLogs.reduce((acc, log) => acc + log.sizeInFields(), 0);
+
+    const publicLog = new PublicLog(contractAddress, log);
 
-    if (log.length > PUBLIC_LOG_SIZE_IN_FIELDS) {
-      throw new Error(`Emitted public log is too large, max: ${PUBLIC_LOG_SIZE_IN_FIELDS}, passed: ${log.length}`);
+    if (previouslyEmittedPublicLogFieldsCount + publicLog.sizeInFields() > FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH) {
+      throw new SideEffectLimitReachedError('public log fields', FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH);
     }
-    const publicLog = new PublicLog(contractAddress, padArrayEnd(log, Fr.ZERO, PUBLIC_LOG_SIZE_IN_FIELDS), log.length);
+
     this.publicLogs.push(publicLog);
     this.log.trace(`Tracing new public log (counter=${this.sideEffectCounter})`);
     this.incrementSideEffectCounter();
   }
 
+  public traceDebugLog(contractAddress: AztecAddress, level: LogLevel, message: string, fields: Fr[]) {
+    this.debugLogs.push(new DebugLog(contractAddress, level, message, fields));
+  }
+
+  public getDebugLogs() {
+    return this.debugLogs;
+  }
+
+  public getDebugLogMemoryReads() {
+    return this.debugLogMemoryReads;
+  }
+
+  public traceDebugLogMemoryReads(memoryReads: number) {
+    this.debugLogMemoryReads += memoryReads;
+  }
+
   public traceGetContractClass(contractClassId: Fr, exists: boolean) {
     // We limit the number of unique contract class IDs due to hashing and the trace length limit.
     if (exists && !this.uniqueClassIds.has(contractClassId.toString())) {
       if (this.uniqueClassIds.size() >= MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS) {
         this.log.debug(`Bytecode retrieval failure for contract class ID ${contractClassId} (limit reached)`);
-        throw new SideEffectLimitReachedError(
-          'contract calls to unique class IDs',
-          MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS,
-        );
+        throw new MaxCallsToUniqueContractClassIdsError();
       }
       this.log.trace(`Adding contract class ID ${contractClassId} (counter=${this.sideEffectCounter})`);
       this.uniqueClassIds.add(contractClassId.toString());

package/src/public/side_effect_trace_interface.ts

@@ -1,5 +1,7 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { LogLevel } from '@aztec/foundation/log';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { DebugLog } from '@aztec/stdlib/logs';
 
 export interface PublicSideEffectTraceInterface {
   fork(): PublicSideEffectTraceInterface;
@@ -18,5 +20,9 @@ export interface PublicSideEffectTraceInterface {
   traceNewNullifier(siloedNullifier: Fr): void;
   traceNewL2ToL1Message(contractAddress: AztecAddress, recipient: Fr, content: Fr): void;
   tracePublicLog(contractAddress: AztecAddress, log: Fr[]): void;
+  traceDebugLog(contractAddress: AztecAddress, level: LogLevel, message: string, fields: Fr[]): void;
+  getDebugLogs(): DebugLog[];
+  getDebugLogMemoryReads(): number;
+  traceDebugLogMemoryReads(memoryReads: number): void;
   traceGetContractClass(contractClassId: Fr, exists: boolean): void;
 }

package/src/public/state_manager/nullifiers.ts

@@ -1,6 +1,7 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { PublicTreesDB } from '../public_db_sources.js';
+import { NullifierCollisionError } from '../side_effect_errors.js';
 
 /**
  * A class to manage new nullifier staging and existence checks during a contract call's AVM simulation.
@@ -100,10 +101,3 @@ export class NullifierManager {
     this.cache = new Set([...this.cache, ...incomingNullifiers.cache]);
   }
 }
-
-export class NullifierCollisionError extends Error {
-  constructor(message: string, ...rest: any[]) {
-    super(message, ...rest);
-    this.name = 'NullifierCollisionError';
-  }
-}

package/src/public/state_manager/public_storage.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 
 import type { PublicStateDBInterface } from '../db_interfaces.js';

package/src/public/state_manager/state_manager.ts

@@ -1,21 +1,16 @@
-import {
-  CANONICAL_AUTH_REGISTRY_ADDRESS,
-  CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,
-  CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS,
-  FEE_JUICE_ADDRESS,
-  MULTI_CALL_ENTRYPOINT_ADDRESS,
-  ROUTER_ADDRESS,
-} from '@aztec/constants';
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS, MAX_PROTOCOL_CONTRACTS } from '@aztec/constants';
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
-import { createLogger } from '@aztec/foundation/log';
+import { type LogLevel, type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { FunctionSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { ContractClassPublicWithCommitment, ContractInstanceWithAddress } from '@aztec/stdlib/contract';
 import { SerializableContractInstance } from '@aztec/stdlib/contract';
 import { DelayedPublicMutableValues, DelayedPublicMutableValuesWithHash } from '@aztec/stdlib/delayed-public-mutable';
 import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
+import type { DebugLog } from '@aztec/stdlib/logs';
 import { ScopedL2ToL1Message } from '@aztec/stdlib/messaging';
 import { MerkleTreeId } from '@aztec/stdlib/trees';
 import type { TreeSnapshots } from '@aztec/stdlib/tx';
@@ -25,10 +20,16 @@ import { strict as assert } from 'assert';
 
 import type { AvmExecutionEnvironment } from '../avm/avm_execution_environment.js';
 import type { PublicContractsDBInterface } from '../db_interfaces.js';
-import { getPublicFunctionDebugName } from '../debug_fn_name.js';
+import { getPublicFunctionDebugName, getPublicFunctionSelectorAndName } from '../debug_fn_name.js';
 import type { PublicTreesDB } from '../public_db_sources.js';
+import {
+  L1ToL2MessageIndexOutOfRangeError,
+  MaxCallsToUniqueContractClassIdsError,
+  NoteHashIndexOutOfRangeError,
+  NullifierCollisionError,
+} from '../side_effect_errors.js';
 import type { PublicSideEffectTraceInterface } from '../side_effect_trace_interface.js';
-import { NullifierCollisionError, NullifierManager } from './nullifiers.js';
+import { NullifierManager } from './nullifiers.js';
 import { PublicStorage } from './public_storage.js';
 
 /**
@@ -41,7 +42,7 @@ import { PublicStorage } from './public_storage.js';
  * Manages merging of successful/reverted child state into current state.
  */
 export class PublicPersistableStateManager {
-  private readonly log = createLogger('simulator:state_manager');
+  private readonly log: Logger;
 
   /** Make sure a forked state is never merged twice. */
   private alreadyMergedIntoParent = false;
@@ -52,10 +53,13 @@ export class PublicPersistableStateManager {
     private readonly trace: PublicSideEffectTraceInterface,
     private readonly firstNullifier: Fr, // Needed for note hashes.
     private readonly timestamp: UInt64, // Needed for contract updates.
-    private readonly doMerkleOperations: boolean = false,
+    private readonly doMerkleOperations: boolean = true,
     private readonly publicStorage: PublicStorage = new PublicStorage(treesDB),
     private readonly nullifiers: NullifierManager = new NullifierManager(treesDB),
-  ) {}
+    bindings?: LoggerBindings,
+  ) {
+    this.log = createLogger('simulator:state_manager', bindings);
+  }
 
   /**
    * Create a new state manager
@@ -64,9 +68,9 @@ export class PublicPersistableStateManager {
     treesDB: PublicTreesDB,
     contractsDB: PublicContractsDBInterface,
     trace: PublicSideEffectTraceInterface,
-    doMerkleOperations: boolean = false,
     firstNullifier: Fr,
     timestamp: UInt64,
+    bindings?: LoggerBindings,
   ): PublicPersistableStateManager {
     return new PublicPersistableStateManager(
       treesDB,
@@ -74,7 +78,10 @@ export class PublicPersistableStateManager {
       trace,
       firstNullifier,
       timestamp,
-      doMerkleOperations,
+      undefined,
+      undefined,
+      undefined,
+      bindings,
     );
   }
 
@@ -92,6 +99,7 @@ export class PublicPersistableStateManager {
       this.doMerkleOperations,
       this.publicStorage.fork(),
       this.nullifiers.fork(),
+      this.log.getBindings(),
     );
   }
 
@@ -164,7 +172,6 @@ export class PublicPersistableStateManager {
     if (this.doMerkleOperations) {
       return await this.treesDB.storageRead(contractAddress, slot);
     } else {
-      // TODO(fcarreiro): I don't get this. PublicStorage CAN end up reading the tree. Why is it in the "dont do merkle operations" branch?
       const read = await this.publicStorage.read(contractAddress, slot);
       this.log.trace(
         `Storage read results (address=${contractAddress}, slot=${slot}): value=${read.value}, cached=${read.cached}`,
@@ -183,12 +190,21 @@ export class PublicPersistableStateManager {
    * @returns true if the note hash exists at the given leaf index, false otherwise
    */
   public async checkNoteHashExists(contractAddress: AztecAddress, noteHash: Fr, leafIndex: bigint): Promise<boolean> {
-    const gotLeafValue = await this.treesDB.getNoteHash(leafIndex);
-    const exists = gotLeafValue !== undefined && gotLeafValue.equals(noteHash);
-    this.log.trace(
-      `noteHashes(${contractAddress})@${noteHash} ?? leafIndex: ${leafIndex} | gotLeafValue: ${gotLeafValue}, exists: ${exists}.`,
-    );
-    return Promise.resolve(exists);
+    try {
+      const gotLeafValue = await this.treesDB.getNoteHash(leafIndex);
+      const exists = gotLeafValue.equals(noteHash);
+      this.log.trace(
+        `noteHashes(${contractAddress})@${noteHash} ?? leafIndex: ${leafIndex} | gotLeafValue: ${gotLeafValue}, exists: ${exists}.`,
+      );
+      return Promise.resolve(exists);
+    } catch (error) {
+      // If the index is out of range, note_hash_leaf_in_range = 0 and the circuit returns false:
+      if (error instanceof NoteHashIndexOutOfRangeError) {
+        return Promise.resolve(false);
+      }
+      // Otherwise, unknown error. This is a bug.
+      throw error;
+    }
   }
 
   /**
@@ -232,7 +248,15 @@ export class PublicPersistableStateManager {
   public async checkNullifierExists(contractAddress: AztecAddress, nullifier: Fr): Promise<boolean> {
     this.log.trace(`Checking existence of nullifier (address=${contractAddress}, nullifier=${nullifier})`);
     const siloedNullifier = await siloNullifier(contractAddress, nullifier);
+    return this.checkSiloedNullifierExists(siloedNullifier);
+  }
 
+  /**
+   * Check if a siloed nullifier exists.
+   * @param siloedNullifier - the siloed nullifier to check
+   * @returns exists - whether the nullifier exists in the nullifier set
+   */
+  public async checkSiloedNullifierExists(siloedNullifier: Fr): Promise<boolean> {
     if (this.doMerkleOperations) {
       const exists = await this.treesDB.checkNullifierExists(siloedNullifier);
       this.log.trace(`Checked siloed nullifier ${siloedNullifier} (exists=${exists})`);
@@ -288,12 +312,21 @@ export class PublicPersistableStateManager {
    * @returns exists - whether the message exists in the L1 to L2 Messages tree
    */
   public async checkL1ToL2MessageExists(msgHash: Fr, msgLeafIndex: Fr): Promise<boolean> {
-    const valueAtIndex = await this.treesDB.getL1ToL2LeafValue(msgLeafIndex.toBigInt());
-    const exists = valueAtIndex !== undefined && valueAtIndex.equals(msgHash);
-    this.log.trace(
-      `l1ToL2Messages(@${msgLeafIndex}) ?? exists: ${exists}, expected: ${msgHash}, found: ${valueAtIndex}.`,
-    );
-    return Promise.resolve(exists);
+    try {
+      const valueAtIndex = await this.treesDB.getL1ToL2LeafValue(msgLeafIndex.toBigInt());
+      const exists = valueAtIndex.equals(msgHash);
+      this.log.trace(
+        `l1ToL2Messages(@${msgLeafIndex}) ?? exists: ${exists}, expected: ${msgHash}, found: ${valueAtIndex}.`,
+      );
+      return Promise.resolve(exists);
+    } catch (error) {
+      // If the index is out of range, l1_to_l2_msg_leaf_in_range = 0 and the circuit returns false:
+      if (error instanceof L1ToL2MessageIndexOutOfRangeError) {
+        return Promise.resolve(false);
+      }
+      // Otherwise, unknown error. This is a bug.
+      throw error;
+    }
   }
 
   /**
@@ -319,6 +352,22 @@ export class PublicPersistableStateManager {
     );
   }
 
+  public writeDebugLog(contractAddress: AztecAddress, level: LogLevel, message: string, fields: Fr[]) {
+    this.trace.traceDebugLog(contractAddress, level, message, fields);
+  }
+
+  public writeDebugLogMemoryReads(memoryReads: number) {
+    this.trace.traceDebugLogMemoryReads(memoryReads);
+  }
+
+  public getDebugLogMemoryReads() {
+    return this.trace.getDebugLogMemoryReads();
+  }
+
+  public getLogs(): DebugLog[] {
+    return this.trace.getDebugLogs();
+  }
+
   /**
    * Write a public log
    * @param contractAddress - address of the contract that emitted the log
@@ -368,7 +417,7 @@ export class PublicPersistableStateManager {
 
     this.log.trace(`Got contract instance (address=${contractAddress}): instance=${jsonStringify(instance!)}`);
 
-    // All that is left is tocheck that the contract updatability information is correct.
+    // All that is left is to check that the contract updatability information is correct.
     // That is, that the current and original contract class ids are correct.
     await this.checkContractUpdateInformation(instanceWithAddress);
 
@@ -389,13 +438,15 @@ export class PublicPersistableStateManager {
       //
       // However, we will also be checking the hash of the delayed public mutable values.
       // This is a bit of a leak of information, since the circuit will use it to prove
-      // one public read insted of N of the delayed public mutable values.
+      // one public read instead of N of the delayed public mutable values.
       const { delayedPublicMutableSlot, delayedPublicMutableHashSlot } =
         await DelayedPublicMutableValuesWithHash.getContractUpdateSlots(instance.address);
       const readDeployerStorage = async (storageSlot: Fr) =>
         await this.readStorage(ProtocolContractAddress.ContractInstanceRegistry, storageSlot);
 
       const hash = await readDeployerStorage(delayedPublicMutableHashSlot);
+      // NOTE: The below reads are either not performed (if hash.isZero()) or only performed in unconstrained in c++ simulation.
+      // See UpdateCheck::check_current_class_id documentation - this means if we generate hints from the merkle db, they are unused:
       const delayedPublicMutableValues = await DelayedPublicMutableValues.readFromTree(
         delayedPublicMutableSlot,
         readDeployerStorage,
@@ -438,7 +489,7 @@ export class PublicPersistableStateManager {
    * @param classId - class id to retrieve.
    * @returns the contract class or undefined if it does not exist.
    */
-  public async getContractClass(classId: Fr): Promise<ContractClassPublicWithCommitment | undefined> {
+  private async getContractClass(classId: Fr): Promise<ContractClassPublicWithCommitment | undefined> {
     this.log.trace(`Getting contract class for id ${classId}`);
     const contractClass = await this.contractsDB.getContractClass(classId);
     const exists = contractClass !== undefined;
@@ -459,7 +510,7 @@ export class PublicPersistableStateManager {
         publicBytecodeCommitment: bytecodeCommitment,
       };
     } else {
-      this.log.debug(`Contract instance NOT FOUND (id=${classId})`);
+      this.log.debug(`Contract class NOT FOUND (id=${classId})`);
     }
 
     // TODO(dbanks12): does this need to be moved to before the DB accesses as was done with writeNullifier?
@@ -478,19 +529,32 @@ export class PublicPersistableStateManager {
       return undefined;
     }
 
-    const contractClass = await this.getContractClass(contractInstance.currentContractClassId);
-    assert(
-      contractClass,
-      `Contract class not found in DB, but a contract instance was found with this class ID (${contractInstance.currentContractClassId}). This should not happen!`,
-    );
-
-    return contractClass.packedBytecode;
+    try {
+      const contractClass = await this.getContractClass(contractInstance.currentContractClassId);
+      assert(
+        contractClass,
+        `Contract class not found in DB, but a contract instance was found with this class ID (${contractInstance.currentContractClassId}). This should not happen!`,
+      );
+      return contractClass.packedBytecode;
+    } catch (error) {
+      if (error instanceof MaxCallsToUniqueContractClassIdsError) {
+        return undefined;
+      }
+      // Otherwise, unknown error. This is a bug.
+      throw error;
+    }
   }
 
   public async getPublicFunctionDebugName(avmEnvironment: AvmExecutionEnvironment): Promise<string> {
     return await getPublicFunctionDebugName(this.contractsDB, avmEnvironment.address, avmEnvironment.calldata);
   }
 
+  public async getPublicFunctionSelectorAndName(
+    avmEnvironment: AvmExecutionEnvironment,
+  ): Promise<{ functionSelector?: FunctionSelector; functionName?: string }> {
+    return await getPublicFunctionSelectorAndName(this.contractsDB, avmEnvironment.address, avmEnvironment.calldata);
+  }
+
   public async padTree(treeId: MerkleTreeId, leavesToInsert: number): Promise<void> {
     await this.treesDB.padTree(treeId, leavesToInsert);
   }
@@ -501,12 +565,5 @@ export class PublicPersistableStateManager {
 }
 
 function contractAddressIsCanonical(contractAddress: AztecAddress): boolean {
-  return (
-    contractAddress.equals(AztecAddress.fromNumber(CANONICAL_AUTH_REGISTRY_ADDRESS)) ||
-    contractAddress.equals(AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS)) ||
-    contractAddress.equals(AztecAddress.fromNumber(CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS)) ||
-    contractAddress.equals(AztecAddress.fromNumber(MULTI_CALL_ENTRYPOINT_ADDRESS)) ||
-    contractAddress.equals(AztecAddress.fromNumber(FEE_JUICE_ADDRESS)) ||
-    contractAddress.equals(AztecAddress.fromNumber(ROUTER_ADDRESS))
-  );
+  return contractAddress.toBigInt() >= 1 && contractAddress.toBigInt() <= MAX_PROTOCOL_CONTRACTS;
 }