@aztec/simulator 2.1.0-rc.9 → 3.0.0-devnet.2

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 { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
+import { type LogLevel, 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() {
@@ -69,7 +73,6 @@ 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;
 
@@ -83,6 +86,8 @@ 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;
   }
@@ -96,10 +101,13 @@ export class SideEffectTrace implements PublicSideEffectTraceInterface {
         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 +121,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 +203,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 +213,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 +224,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 +234,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 { 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 { 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/state_manager.ts

@@ -9,13 +9,14 @@ import {
 import { poseidon2Hash } from '@aztec/foundation/crypto';
 import { Fr } from '@aztec/foundation/fields';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
-import { createLogger } from '@aztec/foundation/log';
+import { type LogLevel, createLogger } from '@aztec/foundation/log';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 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';
@@ -27,8 +28,14 @@ import type { AvmExecutionEnvironment } from '../avm/avm_execution_environment.j
 import type { PublicContractsDBInterface } from '../db_interfaces.js';
 import { getPublicFunctionDebugName } 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';
 
 /**
@@ -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;
+    }
   }
 
   /**
@@ -288,12 +304,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 +344,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 +409,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,7 +430,7 @@ 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) =>
@@ -438,7 +479,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 +500,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,13 +519,20 @@ 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> {

package/dest/public/bytecode_errors.d.ts

@@ -1,4 +0,0 @@
-export declare class ContractClassBytecodeError extends Error {
-    constructor(contractAddress: string);
-}
-//# sourceMappingURL=bytecode_errors.d.ts.map

package/dest/public/bytecode_errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bytecode_errors.d.ts","sourceRoot":"","sources":["../../src/public/bytecode_errors.ts"],"names":[],"mappings":"AAAA,qBAAa,0BAA2B,SAAQ,KAAK;gBACvC,eAAe,EAAE,MAAM;CAIpC"}

package/dest/public/bytecode_errors.js

@@ -1,6 +0,0 @@
-export class ContractClassBytecodeError extends Error {
-    constructor(contractAddress){
-        super(`Failed to get bytecode for contract at address ${contractAddress}`);
-        this.name = 'ContractClassBytecodeError';
-    }
-}

package/src/public/bytecode_errors.ts

@@ -1,6 +0,0 @@
-export class ContractClassBytecodeError extends Error {
-  constructor(contractAddress: string) {
-    super(`Failed to get bytecode for contract at address ${contractAddress}`);
-    this.name = 'ContractClassBytecodeError';
-  }
-}