@aztec/simulator 0.71.0 → 0.73.0

package/src/client/client_execution_context.ts

@@ -95,7 +95,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     const args = this.executionCache.getPreimage(this.argsHash);
 
     if (args.length !== argumentsSize) {
-      throw new Error('Invalid arguments size');
+      throw new Error(`Invalid arguments size: expected ${argumentsSize}, got ${args.length}`);
     }
 
     const privateContextInputs = new PrivateContextInputs(
@@ -160,21 +160,13 @@ export class ClientExecutionContext extends ViewDataOracle {
     return this.publicTeardownFunctionCall;
   }
 
-  /**
-   * Store values in the execution cache.
-   * @param values - Values to store.
-   */
-  public override storeArrayInExecutionCache(args: Fr[]): Promise<Fr> {
-    return Promise.resolve(this.executionCache.store(args));
-  }
-
   /**
    * Store values in the execution cache.
    * @param values - Values to store.
    * @returns The hash of the values.
    */
   public override storeInExecutionCache(values: Fr[]): Promise<Fr> {
-    return Promise.resolve(this.executionCache.store(values));
+    return this.executionCache.store(values);
   }
 
   /**
@@ -249,14 +241,22 @@ export class ClientExecutionContext extends ViewDataOracle {
         .join(', ')}`,
     );
 
-    notes.forEach(n => {
-      if (n.index !== undefined) {
-        const siloedNoteHash = siloNoteHash(n.contractAddress, n.noteHash);
-        const uniqueNoteHash = computeUniqueNoteHash(n.nonce, siloedNoteHash);
+    const noteHashesAndIndexes = await Promise.all(
+      notes.map(async n => {
+        if (n.index !== undefined) {
+          const siloedNoteHash = await siloNoteHash(n.contractAddress, n.noteHash);
+          const uniqueNoteHash = await computeUniqueNoteHash(n.nonce, siloedNoteHash);
 
-        this.noteHashLeafIndexMap.set(uniqueNoteHash.toBigInt(), n.index);
-      }
-    });
+          return { hash: uniqueNoteHash, index: n.index };
+        }
+      }),
+    );
+
+    noteHashesAndIndexes
+      .filter(n => n !== undefined)
+      .forEach(n => {
+        this.noteHashLeafIndexMap.set(n!.hash.toBigInt(), n!.index);
+      });
 
     return notes;
   }
@@ -299,8 +299,8 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param innerNullifier - The pending nullifier to add in the list (not yet siloed by contract address).
    * @param noteHash - A hash of the new note.
    */
-  public override notifyNullifiedNote(innerNullifier: Fr, noteHash: Fr, counter: number) {
-    const nullifiedNoteHashCounter = this.noteCache.nullifyNote(
+  public override async notifyNullifiedNote(innerNullifier: Fr, noteHash: Fr, counter: number) {
+    const nullifiedNoteHashCounter = await this.noteCache.nullifyNote(
       this.callContext.contractAddress,
       innerNullifier,
       noteHash,
@@ -308,7 +308,6 @@ export class ClientExecutionContext extends ViewDataOracle {
     if (nullifiedNoteHashCounter !== undefined) {
       this.noteHashNullifierCounterMap.set(nullifiedNoteHashCounter, counter);
     }
-    return Promise.resolve();
   }
 
   /**
@@ -318,8 +317,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param noteHash - A hash of the new note.
    */
   public override notifyCreatedNullifier(innerNullifier: Fr) {
-    this.noteCache.nullifierCreated(this.callContext.contractAddress, innerNullifier);
-    return Promise.resolve();
+    return this.noteCache.nullifierCreated(this.callContext.contractAddress, innerNullifier);
   }
 
   /**
@@ -327,6 +325,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    * This fn exists because sha hashing the preimage
    * is too large to compile (16,200 fields, 518,400 bytes) => the oracle hashes it.
    * See private_context.nr
+   * TODO(#8945): Contract class logs are currently sha hashes. When these are fields, delete this.
    * @param log - The unencrypted log to be emitted.
    */
   public override emitContractClassLog(log: UnencryptedL2Log, counter: number) {
@@ -376,7 +375,7 @@ export class ClientExecutionContext extends ViewDataOracle {
 
     const derivedTxContext = this.txContext.clone();
 
-    const derivedCallContext = this.deriveCallContext(targetContractAddress, targetArtifact, isStaticCall);
+    const derivedCallContext = await this.deriveCallContext(targetContractAddress, targetArtifact, isStaticCall);
 
     const context = new ClientExecutionContext(
       argsHash,
@@ -433,7 +432,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     isStaticCall: boolean,
   ) {
     const targetArtifact = await this.db.getFunctionArtifact(targetContractAddress, functionSelector);
-    const derivedCallContext = this.deriveCallContext(targetContractAddress, targetArtifact, isStaticCall);
+    const derivedCallContext = await this.deriveCallContext(targetContractAddress, targetArtifact, isStaticCall);
     const args = this.executionCache.getPreimage(argsHash);
 
     this.log.verbose(
@@ -483,7 +482,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.
     // We don't validate or compute it in the circuit because a) it's harder to do with slices, and
     // b) this is only temporary.
-    const newArgsHash = this.executionCache.store([
+    const newArgsHash = await this.executionCache.store([
       functionSelector.toField(),
       ...this.executionCache.getPreimage(argsHash),
     ]);
@@ -522,7 +521,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.
     // We don't validate or compute it in the circuit because a) it's harder to do with slices, and
     // b) this is only temporary.
-    const newArgsHash = this.executionCache.store([
+    const newArgsHash = await this.executionCache.store([
       functionSelector.toField(),
       ...this.executionCache.getPreimage(argsHash),
     ]);
@@ -537,8 +536,8 @@ export class ClientExecutionContext extends ViewDataOracle {
     return newArgsHash;
   }
 
-  public override notifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number): void {
-    this.noteCache.setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter);
+  public override notifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number): Promise<void> {
+    return this.noteCache.setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter);
   }
 
   /**
@@ -548,7 +547,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param isStaticCall - Whether the call is a static call.
    * @returns The derived call context.
    */
-  private deriveCallContext(
+  private async deriveCallContext(
     targetContractAddress: AztecAddress,
     targetArtifact: FunctionArtifact,
     isStaticCall = false,
@@ -556,7 +555,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     return new CallContext(
       this.contractAddress,
       targetContractAddress,
-      FunctionSelector.fromNameAndParameters(targetArtifact.name, targetArtifact.parameters),
+      await FunctionSelector.fromNameAndParameters(targetArtifact.name, targetArtifact.parameters),
       isStaticCall,
     );
   }

package/src/client/execution_note_cache.ts

@@ -52,7 +52,7 @@ export class ExecutionNoteCache {
    * Enters the revertible phase of the transaction.
    * @param minRevertibleSideEffectCounter - The counter at which the transaction enters the revertible phase.
    */
-  public setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number) {
+  public async setMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number) {
     if (this.inRevertiblePhase) {
       throw new Error(
         `Cannot enter the revertible phase twice. Current counter: ${minRevertibleSideEffectCounter}. Previous enter counter: ${this.minRevertibleSideEffectCounter}`,
@@ -72,15 +72,20 @@ export class ExecutionNoteCache {
     // They cannot be squashed by nullifiers emitted after minRevertibleSideEffectCounter is set.
     // Their indexes in the tx are known at this point and won't change. So we can assign a nonce to each one of them.
     // The nonces will be used to create the "complete" nullifier.
-    const updatedNotes = this.notes.map(({ note, counter }, i) => {
-      const nonce = computeNoteHashNonce(nonceGenerator, i);
-      const uniqueNoteHash = computeUniqueNoteHash(nonce, siloNoteHash(note.contractAddress, note.noteHash));
-      return {
-        counter,
-        note: { ...note, nonce },
-        noteHashForConsumption: uniqueNoteHash,
-      };
-    });
+    const updatedNotes = await Promise.all(
+      this.notes.map(async ({ note, counter }, i) => {
+        const nonce = await computeNoteHashNonce(nonceGenerator, i);
+        const uniqueNoteHash = await computeUniqueNoteHash(
+          nonce,
+          await siloNoteHash(note.contractAddress, note.noteHash),
+        );
+        return {
+          counter,
+          note: { ...note, nonce },
+          noteHashForConsumption: uniqueNoteHash,
+        };
+      }),
+    );
     // Rebuild the data.
     this.notes = [];
     this.noteMap = new Map();
@@ -120,8 +125,8 @@ export class ExecutionNoteCache {
    * @param noteHash - A hash of the note. If this value equals 0, it means the note being nullified is from a previous
    * transaction (and thus not a new note).
    */
-  public nullifyNote(contractAddress: AztecAddress, innerNullifier: Fr, noteHash: Fr) {
-    const siloedNullifier = siloNullifier(contractAddress, innerNullifier);
+  public async nullifyNote(contractAddress: AztecAddress, innerNullifier: Fr, noteHash: Fr) {
+    const siloedNullifier = await siloNullifier(contractAddress, innerNullifier);
     let nullifiedNoteHashCounter: number | undefined = undefined;
     // Find and remove the matching new note and log(s) if the emitted noteHash is not empty.
     if (!noteHash.isEmpty()) {
@@ -152,8 +157,8 @@ export class ExecutionNoteCache {
    * @param contractAddress - Contract address that emitted the nullifier.
    * @param innerNullifier
    */
-  public nullifierCreated(contractAddress: AztecAddress, innerNullifier: Fr) {
-    const siloedNullifier = siloNullifier(contractAddress, innerNullifier);
+  public async nullifierCreated(contractAddress: AztecAddress, innerNullifier: Fr) {
+    const siloedNullifier = await siloNullifier(contractAddress, innerNullifier);
     this.recordNullifier(contractAddress, siloedNullifier);
   }
 

package/src/client/pick_notes.ts

@@ -84,7 +84,7 @@ interface ContainsNote {
   note: Note;
 }
 
-const selectPropertyFromSerializedNote = (noteData: Fr[], selector: PropertySelector): Fr => {
+const selectPropertyFromPackedNoteContent = (noteData: Fr[], selector: PropertySelector): Fr => {
   const noteValueBuffer = noteData[selector.index].toBuffer();
   const noteValue = noteValueBuffer.subarray(selector.offset, selector.offset + selector.length);
   return Fr.fromBuffer(noteValue);
@@ -93,7 +93,7 @@ const selectPropertyFromSerializedNote = (noteData: Fr[], selector: PropertySele
 const selectNotes = <T extends ContainsNote>(noteDatas: T[], selects: Select[]): T[] =>
   noteDatas.filter(noteData =>
     selects.every(({ selector, value, comparator }) => {
-      const noteValueFr = selectPropertyFromSerializedNote(noteData.note.items, selector);
+      const noteValueFr = selectPropertyFromPackedNoteContent(noteData.note.items, selector);
       const comparatorSelector = {
         [Comparator.EQ]: () => noteValueFr.equals(value),
         [Comparator.NEQ]: () => !noteValueFr.equals(value),
@@ -117,8 +117,8 @@ const sortNotes = (a: Fr[], b: Fr[], sorts: Sort[], level = 0): number => {
     return 0;
   }
 
-  const aValue = selectPropertyFromSerializedNote(a, selector);
-  const bValue = selectPropertyFromSerializedNote(b, selector);
+  const aValue = selectPropertyFromPackedNoteContent(a, selector);
+  const bValue = selectPropertyFromPackedNoteContent(b, selector);
 
   const dir = order === 1 ? [-1, 1] : [1, -1];
   return aValue.toBigInt() === bValue.toBigInt()

package/src/client/simulator.ts

@@ -72,11 +72,11 @@ export class AcirSimulator {
     const callContext = new CallContext(
       msgSender,
       contractAddress,
-      FunctionSelector.fromNameAndParameters(entryPointArtifact.name, entryPointArtifact.parameters),
+      await FunctionSelector.fromNameAndParameters(entryPointArtifact.name, entryPointArtifact.parameters),
       entryPointArtifact.isStatic,
     );
 
-    const txRequestHash = request.toTxRequest().hash();
+    const txRequestHash = await request.toTxRequest().hash();
     const noteCache = new ExecutionNoteCache(txRequestHash);
 
     const context = new ClientExecutionContext(
@@ -192,7 +192,7 @@ export class AcirSimulator {
     const execRequest: FunctionCall = {
       name: artifact.name,
       to: contractAddress,
-      selector: FunctionSelector.fromNameAndParameters(artifact),
+      selector: await FunctionSelector.fromNameAndParameters(artifact),
       type: FunctionType.UNCONSTRAINED,
       isStatic: artifact.isStatic,
       args: encodeArguments(artifact, [

package/src/client/view_data_oracle.ts

@@ -230,7 +230,7 @@ export class ViewDataOracle extends TypedOracle {
    * @returns A boolean indicating whether the nullifier exists in the tree or not.
    */
   public override async checkNullifierExists(innerNullifier: Fr) {
-    const nullifier = siloNullifier(this.contractAddress, innerNullifier!);
+    const nullifier = await siloNullifier(this.contractAddress, innerNullifier!);
     const index = await this.db.getNullifierIndex(nullifier);
     return index !== undefined;
   }

package/src/common/hashed_values_cache.ts

@@ -32,7 +32,7 @@ export class HashedValuesCache {
     if (hash.equals(Fr.ZERO)) {
       return [];
     }
-    const hashedValues = this.cache.get(hash.value);
+    const hashedValues = this.cache.get(hash.toBigInt());
     if (!hashedValues) {
       throw new Error(`Preimage for hash ${hash.toString()} not found in cache`);
     }
@@ -44,12 +44,12 @@ export class HashedValuesCache {
    * @param values - The values to store.
    * @returns The hash of the values.
    */
-  public store(values: Fr[]) {
+  public async store(values: Fr[]) {
     if (values.length === 0) {
       return Fr.ZERO;
     }
-    const hashedValues = HashedValues.fromValues(values);
-    this.cache.set(hashedValues.hash.value, hashedValues.values);
+    const hashedValues = await HashedValues.fromValues(values);
+    this.cache.set(hashedValues.hash.toBigInt(), hashedValues.values);
     return hashedValues.hash;
   }
 }

package/src/providers/acvm_wasm.ts

@@ -1,3 +1,4 @@
+import { createLogger } from '@aztec/foundation/log';
 import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types/client';
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
@@ -10,6 +11,8 @@ import { type ACVMWitness } from '../acvm/acvm_types.js';
 import { type SimulationProvider, parseErrorPayload } from '../common/simulation_provider.js';
 
 export class WASMSimulator implements SimulationProvider {
+  constructor(protected log = createLogger('wasm-simulator')) {}
+
   async init(): Promise<void> {
     // If these are available, then we are in the
     // web environment. For the node environment, this
@@ -21,6 +24,7 @@ export class WASMSimulator implements SimulationProvider {
   }
 
   async executeProtocolCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
+    this.log.debug('init', { hash: compiledCircuit.hash });
     await this.init();
     // Execute the circuit on those initial witness values
     //
@@ -34,13 +38,20 @@ export class WASMSimulator implements SimulationProvider {
         input,
         foreignCallHandler, // handle calls to debug_log
       );
-
+      this.log.debug('execution successful', { hash: compiledCircuit.hash });
       return _witnessMap;
     } catch (err) {
       // Typescript types catched errors as unknown or any, so we need to narrow its type to check if it has raw assertion payload.
       if (typeof err === 'object' && err !== null && 'rawAssertionPayload' in err) {
-        throw parseErrorPayload(compiledCircuit.abi, err as ExecutionError);
+        const parsed = parseErrorPayload(compiledCircuit.abi, err as ExecutionError);
+        this.log.debug('execution failed', {
+          hash: compiledCircuit.hash,
+          error: parsed,
+          message: parsed.message,
+        });
+        throw parsed;
       }
+      this.log.debug('execution failed', { hash: compiledCircuit.hash, error: err });
       throw new Error(`Circuit execution failed: ${err}`);
     }
   }

package/src/public/execution.ts

@@ -1,8 +1,4 @@
-import {
-  type PublicExecutionRequest,
-  type SimulationError,
-  type UnencryptedFunctionL2Logs,
-} from '@aztec/circuit-types';
+import { type PublicExecutionRequest, type SimulationError } from '@aztec/circuit-types';
 import {
   type AvmExecutionHints,
   type ContractStorageRead,
@@ -10,16 +6,15 @@ import {
   type Fr,
   Gas,
   type L2ToL1Message,
-  type LogHash,
   type NoteHash,
   type Nullifier,
   PublicCallStackItemCompressed,
   type PublicDataUpdateRequest,
   PublicInnerCallRequest,
+  type PublicLog,
   type ReadRequest,
   RevertCode,
   type ScopedL2ToL1Message,
-  type ScopedLogHash,
   type TreeLeafReadRequest,
 } from '@aztec/circuits.js';
 import { computeVarArgsHash } from '@aztec/circuits.js/hash';
@@ -33,16 +28,8 @@ export interface PublicSideEffects {
   nullifiers: Nullifier[];
   /** The new l2 to l1 messages generated to be inserted into the messages tree. */
   l2ToL1Messages: ScopedL2ToL1Message[];
-  /**
-   * The hashed logs with side effect counter.
-   * Note: required as we don't track the counter anywhere else.
-   */
-  unencryptedLogsHashes: ScopedLogHash[];
-  /**
-   * Unencrypted logs emitted during execution.
-   * Note: These are preimages to `unencryptedLogsHashes`.
-   */
-  unencryptedLogs: UnencryptedFunctionL2Logs;
+  /** Public logs emitted during execution. */
+  publicLogs: PublicLog[];
 }
 
 export interface EnqueuedPublicCallExecutionResult {
@@ -124,21 +111,10 @@ export interface PublicFunctionCallResult {
   /** L1 to L2 message read requests emitted in this call. */
   l1ToL2MsgReadRequests: TreeLeafReadRequest[];
   /**
-   * The hashed logs with side effect counter.
-   * Note: required as we don't track the counter anywhere else.
+   * The public logs emitted in this call.
+   * Note: PublicLog has no counter - unsure if this is needed bc this struct is unused
    */
-  unencryptedLogsHashes: LogHash[];
-  /**
-   * Unencrypted logs emitted during execution of this function call.
-   * Note: These are preimages to `unencryptedLogsHashes`.
-   */
-  unencryptedLogs: UnencryptedFunctionL2Logs;
-  /**
-   * Unencrypted logs emitted during this call AND any nested calls.
-   * Useful for maintaining correct ordering in ts.
-   */
-  allUnencryptedLogs: UnencryptedFunctionL2Logs;
-
+  publicLogs: PublicLog[];
   /** The requests to call public functions made by this call. */
   publicCallRequests: PublicInnerCallRequest[];
   /** The results of nested calls. */
@@ -151,13 +127,13 @@ export interface PublicFunctionCallResult {
   functionName: string;
 }
 
-export function resultToPublicCallRequest(result: PublicFunctionCallResult) {
+export async function resultToPublicCallRequest(result: PublicFunctionCallResult) {
   const request = result.executionRequest;
   const item = new PublicCallStackItemCompressed(
     request.callContext.contractAddress,
     request.callContext,
-    computeVarArgsHash(request.args),
-    computeVarArgsHash(result.returnValues),
+    await computeVarArgsHash(request.args),
+    await computeVarArgsHash(result.returnValues),
     // TODO(@just-mitch): need better mapping from simulator to revert code.
     result.reverted ? RevertCode.APP_LOGIC_REVERTED : RevertCode.OK,
     Gas.from(result.startGasLeft),

package/src/public/fee_payment.ts

@@ -14,10 +14,10 @@ export function computeFeePayerBalanceStorageSlot(feePayer: AztecAddress) {
 /**
  * Computes the leaf slot in the public data tree for the balance of the fee payer in the Fee Juice.
  */
-export function computeFeePayerBalanceLeafSlot(feePayer: AztecAddress): Fr {
+export async function computeFeePayerBalanceLeafSlot(feePayer: AztecAddress): Promise<Fr> {
   if (feePayer.isZero()) {
     return Fr.ZERO;
   }
-  const balanceSlot = computeFeePayerBalanceStorageSlot(feePayer);
+  const balanceSlot = await computeFeePayerBalanceStorageSlot(feePayer);
   return computePublicDataTreeLeafSlot(ProtocolContractAddress.FeeJuice, balanceSlot);
 }