@aztec/simulator 0.72.1 → 0.73.0

package/src/avm/fixtures/simple_contract_data_source.ts

@@ -0,0 +1,98 @@
+import {
+  type ContractClassPublic,
+  type ContractDataSource,
+  type ContractInstanceWithAddress,
+  type FunctionSelector,
+  type PublicFunction,
+  computePublicBytecodeCommitment,
+} from '@aztec/circuits.js';
+import { type ContractArtifact } from '@aztec/foundation/abi';
+import { type AztecAddress } from '@aztec/foundation/aztec-address';
+import { type Fr } from '@aztec/foundation/fields';
+import { createLogger } from '@aztec/foundation/log';
+
+import { PUBLIC_DISPATCH_FN_NAME } from './index.js';
+
+/**
+ * This class is used during public/avm testing to function as a database of
+ * contract contract classes and instances. Tests can populate it with classes
+ * and instances and then probe it via the ContractDataSource interface.
+ *
+ * This class does not include any real merkle trees & merkle operations.
+ */
+export class SimpleContractDataSource implements ContractDataSource {
+  public logger = createLogger('simple-contract-data-source');
+
+  // maps contract class ID to class
+  private contractClasses: Map<string, ContractClassPublic> = new Map();
+  // maps contract instance address to instance
+  private contractInstances: Map<string, ContractInstanceWithAddress> = new Map();
+  // maps contract instance address to address
+  private contractArtifacts: Map<string, ContractArtifact> = new Map();
+
+  /////////////////////////////////////////////////////////////
+  // Helper functions not in the contract data source interface
+  getFirstContractInstance(): ContractInstanceWithAddress {
+    return this.contractInstances.values().next().value;
+  }
+
+  addContractArtifact(classId: Fr, artifact: ContractArtifact): void {
+    this.contractArtifacts.set(classId.toString(), artifact);
+  }
+
+  /////////////////////////////////////////////////////////////
+  // ContractDataSource function impelementations
+  getPublicFunction(_address: AztecAddress, _selector: FunctionSelector): Promise<PublicFunction> {
+    throw new Error('Method not implemented.');
+  }
+
+  getBlockNumber(): Promise<number> {
+    throw new Error('Method not implemented.');
+  }
+
+  getContractClass(id: Fr): Promise<ContractClassPublic | undefined> {
+    return Promise.resolve(this.contractClasses.get(id.toString()));
+  }
+
+  async getBytecodeCommitment(id: Fr): Promise<Fr | undefined> {
+    const contractClass = await this.getContractClass(id);
+    return Promise.resolve(computePublicBytecodeCommitment(contractClass!.packedBytecode));
+  }
+
+  getContract(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
+    return Promise.resolve(this.contractInstances.get(address.toString()));
+  }
+
+  getContractClassIds(): Promise<Fr[]> {
+    throw new Error('Method not implemented.');
+  }
+
+  async getContractArtifact(address: AztecAddress): Promise<ContractArtifact | undefined> {
+    const contractInstance = await this.getContract(address);
+    if (!contractInstance) {
+      this.logger.warn(`Contract not found at address: ${address}`);
+      return undefined;
+    }
+    this.logger.debug(`Retrieved contract artifact for address: ${address}`);
+    this.logger.debug(`Contract class ID: ${contractInstance.contractClassId}`);
+    return Promise.resolve(this.contractArtifacts.get(contractInstance!.contractClassId.toString()));
+  }
+
+  getContractFunctionName(_address: AztecAddress, _selector: FunctionSelector): Promise<string> {
+    return Promise.resolve(PUBLIC_DISPATCH_FN_NAME);
+  }
+
+  registerContractFunctionSignatures(_address: AztecAddress, _signatures: string[]): Promise<void> {
+    return Promise.resolve();
+  }
+
+  addContractClass(contractClass: ContractClassPublic): Promise<void> {
+    this.contractClasses.set(contractClass.id.toString(), contractClass);
+    return Promise.resolve();
+  }
+
+  addContractInstance(contractInstance: ContractInstanceWithAddress): Promise<void> {
+    this.contractInstances.set(contractInstance.address.toString(), contractInstance);
+    return Promise.resolve();
+  }
+}

package/src/avm/journal/journal.ts

@@ -72,7 +72,7 @@ export class AvmPersistableStateManager {
     trace: PublicSideEffectTraceInterface,
     doMerkleOperations: boolean = false,
     firstNullifier: Fr,
-  ) {
+  ): Promise<AvmPersistableStateManager> {
     const ephemeralForest = await AvmEphemeralForest.create(worldStateDB.getMerkleInterface());
     return new AvmPersistableStateManager(
       worldStateDB,
@@ -126,11 +126,12 @@ export class AvmPersistableStateManager {
     this.trace.merge(forkedState.trace, reverted);
     if (reverted) {
       if (this.doMerkleOperations) {
-        this.log.debug(
+        this.log.trace(
           `Rolled back nullifier tree to root ${this.merkleTrees.treeMap.get(MerkleTreeId.NULLIFIER_TREE)!.getRoot()}`,
         );
       }
     } else {
+      this.log.trace('Merging forked state into parent...');
       this.merkleTrees = forkedState.merkleTrees;
     }
   }
@@ -144,7 +145,7 @@ export class AvmPersistableStateManager {
    */
   public async writeStorage(contractAddress: AztecAddress, slot: Fr, value: Fr, protocolWrite = false): Promise<void> {
     this.log.debug(`Storage write (address=${contractAddress}, slot=${slot}): value=${value}`);
-    const leafSlot = computePublicDataTreeLeafSlot(contractAddress, slot);
+    const leafSlot = await computePublicDataTreeLeafSlot(contractAddress, slot);
     this.log.debug(`leafSlot=${leafSlot}`);
     // Cache storage writes for later reference/reads
     this.publicStorage.write(contractAddress, slot, value);
@@ -169,7 +170,7 @@ export class AvmPersistableStateManager {
         );
       }
 
-      this.trace.tracePublicStorageWrite(
+      await this.trace.tracePublicStorageWrite(
         contractAddress,
         slot,
         value,
@@ -181,7 +182,7 @@ export class AvmPersistableStateManager {
         insertionPath,
       );
     } else {
-      this.trace.tracePublicStorageWrite(contractAddress, slot, value, protocolWrite);
+      await this.trace.tracePublicStorageWrite(contractAddress, slot, value, protocolWrite);
     }
   }
 
@@ -195,7 +196,7 @@ export class AvmPersistableStateManager {
   public async readStorage(contractAddress: AztecAddress, slot: Fr): Promise<Fr> {
     const { value, cached } = await this.publicStorage.read(contractAddress, slot);
     this.log.debug(`Storage read  (address=${contractAddress}, slot=${slot}): value=${value}, cached=${cached}`);
-    const leafSlot = computePublicDataTreeLeafSlot(contractAddress, slot);
+    const leafSlot = await computePublicDataTreeLeafSlot(contractAddress, slot);
     this.log.debug(`leafSlot=${leafSlot}`);
 
     if (this.doMerkleOperations) {
@@ -283,34 +284,34 @@ export class AvmPersistableStateManager {
    * Write a raw note hash, silo it and make it unique, then trace the write.
    * @param noteHash - the unsiloed note hash to write
    */
-  public writeNoteHash(contractAddress: AztecAddress, noteHash: Fr): void {
-    const siloedNoteHash = siloNoteHash(contractAddress, noteHash);
+  public async writeNoteHash(contractAddress: AztecAddress, noteHash: Fr): Promise<void> {
+    const siloedNoteHash = await siloNoteHash(contractAddress, noteHash);
 
-    this.writeSiloedNoteHash(siloedNoteHash);
+    await this.writeSiloedNoteHash(siloedNoteHash);
   }
 
   /**
    * Write a note hash, make it unique, trace the write.
    * @param noteHash - the non unique note hash to write
    */
-  public writeSiloedNoteHash(noteHash: Fr): void {
-    const nonce = computeNoteHashNonce(this.firstNullifier, this.trace.getNoteHashCount());
-    const uniqueNoteHash = computeUniqueNoteHash(nonce, noteHash);
+  public async writeSiloedNoteHash(noteHash: Fr): Promise<void> {
+    const nonce = await computeNoteHashNonce(this.firstNullifier, this.trace.getNoteHashCount());
+    const uniqueNoteHash = await computeUniqueNoteHash(nonce, noteHash);
 
-    this.writeUniqueNoteHash(uniqueNoteHash);
+    await this.writeUniqueNoteHash(uniqueNoteHash);
   }
 
   /**
    * Write a note hash, trace the write.
    * @param noteHash - the siloed unique hash to write
    */
-  public writeUniqueNoteHash(noteHash: Fr): void {
+  public async writeUniqueNoteHash(noteHash: Fr): Promise<void> {
     this.log.debug(`noteHashes += @${noteHash}.`);
 
     if (this.doMerkleOperations) {
       // Should write a helper for this
       const leafIndex = new Fr(this.merkleTrees.treeMap.get(MerkleTreeId.NOTE_HASH_TREE)!.leafCount);
-      const insertionPath = this.merkleTrees.appendNoteHash(noteHash);
+      const insertionPath = await this.merkleTrees.appendNoteHash(noteHash);
       this.trace.traceNewNoteHash(noteHash, leafIndex, insertionPath);
     } else {
       this.trace.traceNewNoteHash(noteHash);
@@ -325,7 +326,7 @@ export class AvmPersistableStateManager {
    */
   public async checkNullifierExists(contractAddress: AztecAddress, nullifier: Fr): Promise<boolean> {
     this.log.debug(`Checking existence of nullifier (address=${contractAddress}, nullifier=${nullifier})`);
-    const siloedNullifier = siloNullifier(contractAddress, nullifier);
+    const siloedNullifier = await siloNullifier(contractAddress, nullifier);
     const [exists, leafOrLowLeafPreimage, leafOrLowLeafIndex, leafOrLowLeafPath] = await this.getNullifierMembership(
       siloedNullifier,
     );
@@ -407,7 +408,7 @@ export class AvmPersistableStateManager {
    */
   public async writeNullifier(contractAddress: AztecAddress, nullifier: Fr) {
     this.log.debug(`Inserting new nullifier (address=${nullifier}, nullifier=${contractAddress})`);
-    const siloedNullifier = siloNullifier(contractAddress, nullifier);
+    const siloedNullifier = await siloNullifier(contractAddress, nullifier);
     await this.writeSiloedNullifier(siloedNullifier);
   }
 
@@ -447,13 +448,15 @@ export class AvmPersistableStateManager {
         await this.nullifiers.append(siloedNullifier);
         // We append the new nullifier
         this.log.debug(
-          `Nullifier tree root before insertion ${this.merkleTrees.treeMap
+          `Nullifier tree root before insertion ${await this.merkleTrees.treeMap
             .get(MerkleTreeId.NULLIFIER_TREE)!
             .getRoot()}`,
         );
         const appendResult = await this.merkleTrees.appendNullifier(siloedNullifier);
         this.log.debug(
-          `Nullifier tree root after insertion ${this.merkleTrees.treeMap.get(MerkleTreeId.NULLIFIER_TREE)!.getRoot()}`,
+          `Nullifier tree root after insertion ${await this.merkleTrees.treeMap
+            .get(MerkleTreeId.NULLIFIER_TREE)!
+            .getRoot()}`,
         );
         const lowLeafPreimage = appendResult.lowWitness.preimage as NullifierLeafPreimage;
         const lowLeafIndex = appendResult.lowWitness.index;
@@ -550,7 +553,7 @@ export class AvmPersistableStateManager {
       new Array<Fr>(),
     ];
     if (!contractAddressIsCanonical(contractAddress)) {
-      const contractAddressNullifier = siloNullifier(
+      const contractAddressNullifier = await siloNullifier(
         AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
         contractAddress.toField(),
       );
@@ -615,7 +618,7 @@ export class AvmPersistableStateManager {
       new Array<Fr>(),
     ];
     if (!contractAddressIsCanonical(contractAddress)) {
-      const contractAddressNullifier = siloNullifier(
+      const contractAddressNullifier = await siloNullifier(
         AztecAddress.fromNumber(DEPLOYER_CONTRACT_ADDRESS),
         contractAddress.toField(),
       );

package/src/avm/opcodes/accrued_substate.ts

@@ -70,7 +70,7 @@ export class EmitNoteHash extends Instruction {
     }
 
     const noteHash = memory.get(noteHashOffset).toFr();
-    context.persistableState.writeNoteHash(context.environment.address, noteHash);
+    await context.persistableState.writeNoteHash(context.environment.address, noteHash);
 
     memory.assert({ reads: 1, addressing });
   }

package/src/avm/opcodes/hashing.ts

@@ -34,7 +34,7 @@ export class Poseidon2 extends Instruction {
     const inputState = memory.getSlice(inputOffset, Poseidon2.stateSize);
     memory.checkTagsRange(TypeTag.FIELD, inputOffset, Poseidon2.stateSize);
 
-    const outputState = poseidon2Permutation(inputState);
+    const outputState = await poseidon2Permutation(inputState);
     memory.setSlice(
       outputOffset,
       outputState.map(word => new Field(word)),

package/src/avm/test_utils.ts

@@ -11,11 +11,10 @@ import { mock } from 'jest-mock-extended';
 import { type WorldStateDB } from '../public/public_db_sources.js';
 import { type PublicSideEffectTraceInterface } from '../public/side_effect_trace_interface.js';
 
-export function mockGetBytecode(worldStateDB: WorldStateDB, bytecode: Buffer) {
+export async function mockGetBytecode(worldStateDB: WorldStateDB, bytecode: Buffer) {
+  const commitment = await computePublicBytecodeCommitment(bytecode);
   (worldStateDB as jest.Mocked<WorldStateDB>).getBytecode.mockResolvedValue(bytecode);
-  (worldStateDB as jest.Mocked<WorldStateDB>).getBytecodeCommitment.mockResolvedValue(
-    computePublicBytecodeCommitment(bytecode),
-  );
+  (worldStateDB as jest.Mocked<WorldStateDB>).getBytecodeCommitment.mockResolvedValue(commitment);
 }
 
 export function mockTraceFork(trace: PublicSideEffectTraceInterface, nestedTrace?: PublicSideEffectTraceInterface) {

package/src/client/client_execution_context.ts

@@ -166,7 +166,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @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);
   }
 
   /**
@@ -241,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;
   }
@@ -291,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,
@@ -300,7 +308,6 @@ export class ClientExecutionContext extends ViewDataOracle {
     if (nullifiedNoteHashCounter !== undefined) {
       this.noteHashNullifierCounterMap.set(nullifiedNoteHashCounter, counter);
     }
-    return Promise.resolve();
   }
 
   /**
@@ -310,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);
   }
 
   /**
@@ -369,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,
@@ -426,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(
@@ -476,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),
     ]);
@@ -515,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),
     ]);
@@ -530,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);
   }
 
   /**
@@ -541,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,
@@ -549,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

@@ -127,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);
 }