@aztec/simulator 0.67.1 → 0.68.1

package/src/public/public_tx_simulator.ts

@@ -56,6 +56,7 @@ export class PublicTxSimulator {
     telemetryClient: TelemetryClient,
     private globalVariables: GlobalVariables,
     private doMerkleOperations: boolean = false,
+    private enforceFeePayment: boolean = true,
   ) {
     this.log = createLogger(`simulator:public_tx_simulator`);
     this.metrics = new ExecutorMetrics(telemetryClient, 'PublicTxSimulator');
@@ -90,14 +91,20 @@ export class PublicTxSimulator {
     // FIXME: we shouldn't need to directly modify worldStateDb here!
     await this.worldStateDB.addNewContracts(tx);
 
+    const nonRevertStart = process.hrtime.bigint();
     await this.insertNonRevertiblesFromPrivate(context);
+    const nonRevertEnd = process.hrtime.bigint();
+    this.metrics.recordPrivateEffectsInsertion(Number(nonRevertEnd - nonRevertStart) / 1_000, 'non-revertible');
     const processedPhases: ProcessedPhase[] = [];
     if (context.hasPhase(TxExecutionPhase.SETUP)) {
       const setupResult: ProcessedPhase = await this.simulateSetupPhase(context);
       processedPhases.push(setupResult);
     }
 
+    const revertStart = process.hrtime.bigint();
     await this.insertRevertiblesFromPrivate(context);
+    const revertEnd = process.hrtime.bigint();
+    this.metrics.recordPrivateEffectsInsertion(Number(revertEnd - revertStart) / 1_000, 'revertible');
     if (context.hasPhase(TxExecutionPhase.APP_LOGIC)) {
       const appLogicResult: ProcessedPhase = await this.simulateAppLogicPhase(context);
       processedPhases.push(appLogicResult);
@@ -134,7 +141,11 @@ export class PublicTxSimulator {
 
     return {
       avmProvingRequest,
-      gasUsed: { totalGas: context.getActualGasUsed(), teardownGas: context.teardownGasUsed },
+      gasUsed: {
+        totalGas: context.getActualGasUsed(),
+        teardownGas: context.teardownGasUsed,
+        publicGas: context.getActualPublicGasUsed(),
+      },
       revertCode,
       revertReason: context.revertReason,
       processedPhases: processedPhases,
@@ -344,7 +355,7 @@ export class PublicTxSimulator {
     const avmCallResult = await simulator.execute();
     const result = avmCallResult.finalize();
 
-    this.log.debug(
+    this.log.verbose(
       result.reverted
         ? `Simulation of enqueued public call ${fnName} reverted with reason ${result.revertReason}.`
         : `Simulation of enqueued public call ${fnName} completed successfully.`,
@@ -378,6 +389,11 @@ export class PublicTxSimulator {
         );
       }
     }
+    for (const noteHash of context.nonRevertibleAccumulatedDataFromPrivate.noteHashes) {
+      if (!noteHash.isEmpty()) {
+        stateManager.writeUniqueNoteHash(noteHash);
+      }
+    }
   }
 
   /**
@@ -397,6 +413,12 @@ export class PublicTxSimulator {
         );
       }
     }
+    for (const noteHash of context.revertibleAccumulatedDataFromPrivate.noteHashes) {
+      if (!noteHash.isEmpty()) {
+        // Revertible note hashes from private are not hashed with nonce, since private can't know their final position, only we can.
+        stateManager.writeSiloedNoteHash(noteHash);
+      }
+    }
   }
 
   private async payFee(context: PublicTxContext) {
@@ -413,12 +435,18 @@ export class PublicTxSimulator {
     this.log.debug(`Deducting ${txFee.toBigInt()} balance in Fee Juice for ${context.feePayer}`);
     const stateManager = context.state.getActiveStateManager();
 
-    const currentBalance = await stateManager.readStorage(feeJuiceAddress, balanceSlot);
+    let currentBalance = await stateManager.readStorage(feeJuiceAddress, balanceSlot);
+    // We allow to fake the balance of the fee payer to allow fee estimation
+    // When mocking the balance of the fee payer, the circuit should not be able to prove the simulation
 
     if (currentBalance.lt(txFee)) {
-      throw new Error(
-        `Not enough balance for fee payer to pay for transaction (got ${currentBalance.toBigInt()} needs ${txFee.toBigInt()})`,
-      );
+      if (this.enforceFeePayment) {
+        throw new Error(
+          `Not enough balance for fee payer to pay for transaction (got ${currentBalance.toBigInt()} needs ${txFee.toBigInt()})`,
+        );
+      } else {
+        currentBalance = txFee;
+      }
     }
 
     const updatedBalance = currentBalance.sub(txFee);

package/src/public/side_effect_errors.ts

@@ -1,6 +1,6 @@
 export class SideEffectLimitReachedError extends Error {
   constructor(sideEffectType: string, limit: number) {
-    super(`Reached the limit on number of '${sideEffectType}' side effects: ${limit}`);
+    super(`Reached the limit (${limit}) on number of '${sideEffectType}' per tx`);
     this.name = 'SideEffectLimitReachedError';
   }
 }

package/src/public/side_effect_trace_interface.ts

@@ -39,7 +39,8 @@ export interface PublicSideEffectTraceInterface {
     insertionPath?: Fr[],
   ): void;
   traceNoteHashCheck(contractAddress: AztecAddress, noteHash: Fr, leafIndex: Fr, exists: boolean, path?: Fr[]): void;
-  traceNewNoteHash(contractAddress: AztecAddress, noteHash: Fr, leafIndex?: Fr, path?: Fr[]): void;
+  traceNewNoteHash(uniqueNoteHash: Fr, leafIndex?: Fr, path?: Fr[]): void;
+  getNoteHashCount(): number;
   traceNullifierCheck(
     siloedNullifier: Fr,
     exists: boolean,

package/src/public/transitional_adapters.ts

@@ -6,7 +6,6 @@ import {
   type GasSettings,
   type GlobalVariables,
   MAX_L2_TO_L1_MSGS_PER_TX,
-  MAX_NOTE_HASHES_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
   PrivateToAvmAccumulatedData,
   PrivateToAvmAccumulatedDataArrayLengths,
@@ -19,7 +18,6 @@ import {
   countAccumulatedItems,
   mergeAccumulatedData,
 } from '@aztec/circuits.js';
-import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash } from '@aztec/circuits.js/hash';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { assertLength } from '@aztec/foundation/serialize';
 
@@ -86,55 +84,6 @@ export function generateAvmCircuitPublicInputs(
     revertibleAccumulatedDataFromPrivate,
   );
 
-  const txHash = avmCircuitPublicInputs.previousNonRevertibleAccumulatedData.nullifiers[0];
-
-  // Add nonces to revertible note hashes from private. These don't have nonces since we don't know
-  // the final position in the tx until the AVM has executed.
-  // TODO: Use the final position in the tx
-  for (
-    let revertibleIndex = 0;
-    revertibleIndex < avmCircuitPublicInputs.previousRevertibleAccumulatedData.noteHashes.length;
-    revertibleIndex++
-  ) {
-    const noteHash = avmCircuitPublicInputs.previousRevertibleAccumulatedData.noteHashes[revertibleIndex];
-    if (noteHash.isZero()) {
-      continue;
-    }
-    const indexInTx =
-      revertibleIndex + avmCircuitPublicInputs.previousNonRevertibleAccumulatedDataArrayLengths.noteHashes;
-
-    const nonce = computeNoteHashNonce(txHash, indexInTx);
-    const uniqueNoteHash = computeUniqueNoteHash(nonce, noteHash);
-    avmCircuitPublicInputs.previousRevertibleAccumulatedData.noteHashes[revertibleIndex] = uniqueNoteHash;
-  }
-
-  // merge all revertible & non-revertible side effects into output accumulated data
-  const noteHashesFromPrivate = revertCode.isOK()
-    ? mergeAccumulatedData(
-        avmCircuitPublicInputs.previousNonRevertibleAccumulatedData.noteHashes,
-        avmCircuitPublicInputs.previousRevertibleAccumulatedData.noteHashes,
-      )
-    : avmCircuitPublicInputs.previousNonRevertibleAccumulatedData.noteHashes;
-  avmCircuitPublicInputs.accumulatedData.noteHashes = assertLength(
-    mergeAccumulatedData(noteHashesFromPrivate, avmCircuitPublicInputs.accumulatedData.noteHashes),
-    MAX_NOTE_HASHES_PER_TX,
-  );
-
-  // Silo and add nonces for note hashes emitted by the AVM
-  const scopedNoteHashesFromPublic = trace.getSideEffects().noteHashes;
-  for (let i = 0; i < scopedNoteHashesFromPublic.length; i++) {
-    const scopedNoteHash = scopedNoteHashesFromPublic[i];
-    const noteHash = scopedNoteHash.value;
-    if (!noteHash.isZero()) {
-      const noteHashIndexInTx = i + countAccumulatedItems(noteHashesFromPrivate);
-      const nonce = computeNoteHashNonce(txHash, noteHashIndexInTx);
-      const siloedNoteHash = siloNoteHash(scopedNoteHash.contractAddress, noteHash);
-      const uniqueNoteHash = computeUniqueNoteHash(nonce, siloedNoteHash);
-
-      avmCircuitPublicInputs.accumulatedData.noteHashes[noteHashIndexInTx] = uniqueNoteHash;
-    }
-  }
-
   const msgsFromPrivate = revertCode.isOK()
     ? mergeAccumulatedData(
         avmCircuitPublicInputs.previousNonRevertibleAccumulatedData.l2ToL1Msgs,

package/src/public/unique_class_ids.ts

@@ -0,0 +1,80 @@
+import { MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS } from '@aztec/circuits.js';
+
+import { strict as assert } from 'assert';
+
+/**
+ * A class manage a de-duplicated set of class IDs that errors if you try to add a duplicate.
+ * Useful for bytecode retrieval hints to avoid duplicates in parent trace & grandparent trace....
+ */
+export class UniqueClassIds {
+  private readonly classIds: Set<string> = new Set();
+
+  constructor(private readonly parent?: UniqueClassIds) {}
+
+  /**
+   * Create a fork that references this one as its parent
+   */
+  public fork() {
+    return new UniqueClassIds(/*parent=*/ this);
+  }
+
+  /**
+   * Check for a class ID here or in parent's (recursively).
+   *
+   * @param classId - the contract class ID (as a string) to check
+   * @returns boolean: whether the class ID is here
+   */
+  public has(classId: string): boolean {
+    // First try check this' classIds
+    let here = this.classIds.has(classId);
+    // Then try parent's
+    if (!here && this.parent) {
+      // Note: this will recurse to grandparent/etc until we reach top or find it
+      here = this.parent.has(classId);
+    }
+    return here;
+  }
+
+  /**
+   * Get the total number of classIds
+   */
+  public size(): number {
+    return this.classIds.size + (this.parent ? this.parent.size() : 0);
+  }
+
+  /**
+   * Add a class ID (if not already present) to the set.
+   *
+   * @param classId - the contract class ID (as a string)
+   */
+  public add(classId: string) {
+    assert(!this.has(classId), `Bug! Tried to add duplicate classId ${classId} to set of unique classIds.`);
+    if (!this.has(classId)) {
+      this.classIds.add(classId);
+      assert(
+        this.size() <= MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS,
+        `Bug! Surpassed limit (${MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS}) of unique contract class IDs used for bytecode retrievals.`,
+      );
+    }
+  }
+
+  /**
+   * Merge in another set of unique class IDs into this one, but fail on duplicates.
+   *
+   * @param incoming: other unique class IDs
+   */
+  public acceptAndMerge(incoming: UniqueClassIds) {
+    for (const classId of incoming.classIds.keys()) {
+      assert(
+        !this.has(classId),
+        `Bug! Cannot merge classId ${classId} into set of unique classIds as it already exists.`,
+      );
+      this.classIds.add(classId);
+    }
+    // since set() has an assertion, and size() always checks parent, this should be impossible
+    assert(
+      this.size() <= MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS,
+      `Bug! Merging unique class Ids should never exceed the limit of ${MAX_PUBLIC_CALLS_TO_UNIQUE_CONTRACT_CLASS_IDS}.`,
+    );
+  }
+}