@aztec/simulator 0.67.1 → 0.68.1

package/src/avm/journal/journal.ts

@@ -1,4 +1,4 @@
-import { MerkleTreeId } from '@aztec/circuit-types';
+import { MerkleTreeId, type TxHash } from '@aztec/circuit-types';
 import {
   AztecAddress,
   CANONICAL_AUTH_REGISTRY_ADDRESS,
@@ -12,7 +12,13 @@ import {
   ROUTER_ADDRESS,
   SerializableContractInstance,
 } from '@aztec/circuits.js';
-import { computePublicDataTreeLeafSlot, siloNoteHash, siloNullifier } from '@aztec/circuits.js/hash';
+import {
+  computeNoteHashNonce,
+  computePublicDataTreeLeafSlot,
+  computeUniqueNoteHash,
+  siloNoteHash,
+  siloNullifier,
+} from '@aztec/circuits.js/hash';
 import { Fr } from '@aztec/foundation/fields';
 import { jsonStringify } from '@aztec/foundation/json-rpc';
 import { createLogger } from '@aztec/foundation/log';
@@ -55,29 +61,9 @@ export class AvmPersistableStateManager {
     private readonly doMerkleOperations: boolean = false,
     /** Ephmeral forest for merkle tree operations */
     public merkleTrees: AvmEphemeralForest,
+    public readonly txHash: TxHash,
   ) {}
 
-  /**
-   * Create a new state manager with some preloaded pending siloed nullifiers
-   */
-  public static async newWithPendingSiloedNullifiers(
-    worldStateDB: WorldStateDB,
-    trace: PublicSideEffectTraceInterface,
-    pendingSiloedNullifiers: Fr[],
-    doMerkleOperations: boolean = false,
-  ) {
-    const parentNullifiers = NullifierManager.newWithPendingSiloedNullifiers(worldStateDB, pendingSiloedNullifiers);
-    const ephemeralForest = await AvmEphemeralForest.create(worldStateDB.getMerkleInterface());
-    return new AvmPersistableStateManager(
-      worldStateDB,
-      trace,
-      /*publicStorage=*/ new PublicStorage(worldStateDB),
-      /*nullifiers=*/ parentNullifiers.fork(),
-      doMerkleOperations,
-      ephemeralForest,
-    );
-  }
-
   /**
    * Create a new state manager
    */
@@ -85,6 +71,7 @@ export class AvmPersistableStateManager {
     worldStateDB: WorldStateDB,
     trace: PublicSideEffectTraceInterface,
     doMerkleOperations: boolean = false,
+    txHash: TxHash,
   ) {
     const ephemeralForest = await AvmEphemeralForest.create(worldStateDB.getMerkleInterface());
     return new AvmPersistableStateManager(
@@ -94,6 +81,7 @@ export class AvmPersistableStateManager {
       /*nullifiers=*/ new NullifierManager(worldStateDB),
       /*doMerkleOperations=*/ doMerkleOperations,
       ephemeralForest,
+      txHash,
     );
   }
 
@@ -108,6 +96,7 @@ export class AvmPersistableStateManager {
       this.nullifiers.fork(),
       this.doMerkleOperations,
       this.merkleTrees.fork(),
+      this.txHash,
     );
   }
 
@@ -290,20 +279,41 @@ export class AvmPersistableStateManager {
   }
 
   /**
-   * Write a note hash, trace the write.
+   * 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 {
-    this.log.debug(`noteHashes(${contractAddress}) += @${noteHash}.`);
+    const siloedNoteHash = siloNoteHash(contractAddress, noteHash);
+
+    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 txHash = Fr.fromBuffer(this.txHash.toBuffer());
+    const nonce = computeNoteHashNonce(txHash, this.trace.getNoteHashCount());
+    const uniqueNoteHash = computeUniqueNoteHash(nonce, noteHash);
+
+    this.writeUniqueNoteHash(uniqueNoteHash);
+  }
+
+  /**
+   * Write a note hash, trace the write.
+   * @param noteHash - the siloed unique hash to write
+   */
+  public writeUniqueNoteHash(noteHash: Fr): 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 siloedNoteHash = siloNoteHash(contractAddress, noteHash);
-      const insertionPath = this.merkleTrees.appendNoteHash(siloedNoteHash);
-      this.trace.traceNewNoteHash(contractAddress, noteHash, leafIndex, insertionPath);
+      const insertionPath = this.merkleTrees.appendNoteHash(noteHash);
+      this.trace.traceNewNoteHash(noteHash, leafIndex, insertionPath);
     } else {
-      this.trace.traceNewNoteHash(contractAddress, noteHash);
+      this.trace.traceNewNoteHash(noteHash);
     }
   }
 

package/src/avm/journal/nullifiers.ts

@@ -17,17 +17,6 @@ export class NullifierManager {
     private readonly parent?: NullifierManager,
   ) {}
 
-  /**
-   * Create a new nullifiers manager with some preloaded pending siloed nullifiers
-   */
-  public static newWithPendingSiloedNullifiers(hostNullifiers: CommitmentsDB, pendingSiloedNullifiers?: Fr[]) {
-    const cachedSiloedNullifiers = new Set<bigint>();
-    if (pendingSiloedNullifiers !== undefined) {
-      pendingSiloedNullifiers.forEach(nullifier => cachedSiloedNullifiers.add(nullifier.toBigInt()));
-    }
-    return new NullifierManager(hostNullifiers, cachedSiloedNullifiers);
-  }
-
   /**
    * Create a new nullifiers manager forked from this one
    */

package/src/avm/journal/public_storage.ts

@@ -1,4 +1,4 @@
-import { AztecAddress } from '@aztec/circuits.js';
+import { type AztecAddress } from '@aztec/circuits.js';
 import { Fr } from '@aztec/foundation/fields';
 
 import type { PublicStateDB } from '../../index.js';
@@ -33,13 +33,6 @@ export class PublicStorage {
     return new PublicStorage(this.hostPublicStorage, this);
   }
 
-  /**
-   * Get the pending storage.
-   */
-  public getCache() {
-    return this.cache;
-  }
-
   /**
    * Read a storage value from this' cache or parent's (recursively).
    * DOES NOT CHECK HOST STORAGE!
@@ -108,17 +101,6 @@ export class PublicStorage {
   public acceptAndMerge(incomingPublicStorage: PublicStorage) {
     this.cache.acceptAndMerge(incomingPublicStorage.cache);
   }
-
-  /**
-   * Commits ALL staged writes to the host's state.
-   */
-  public async commitToDB() {
-    for (const [contractAddress, cacheAtContract] of this.cache.cachePerContract) {
-      for (const [slot, value] of cacheAtContract) {
-        await this.hostPublicStorage.storageWrite(AztecAddress.fromBigInt(contractAddress), new Fr(slot), value);
-      }
-    }
-  }
 }
 
 /**
@@ -132,8 +114,7 @@ class PublicStorageCache {
    * One inner-map per contract storage address,
    * mapping storage slot to latest staged write value.
    */
-  public cachePerContract: Map<bigint, Map<bigint, Fr>> = new Map();
-  // FIXME: storage ^ should be private, but its value is used in commitToDB
+  private cachePerContract: Map<bigint, Map<bigint, Fr>> = new Map();
 
   /**
    * Read a staged value from storage, if it has been previously written to.

package/src/avm/opcodes/addressing_mode.ts

@@ -1,7 +1,7 @@
 import { strict as assert } from 'assert';
 
 import { TaggedMemory, type TaggedMemoryInterface } from '../avm_memory_types.js';
-import { AddressOutOfRangeError } from '../errors.js';
+import { RelativeAddressOutOfRangeError } from '../errors.js';
 
 export enum AddressingMode {
   DIRECT = 0,
@@ -67,7 +67,7 @@ export class Addressing {
         const baseAddr = Number(mem.get(0).toBigInt());
         resolved[i] += baseAddr;
         if (resolved[i] >= TaggedMemory.MAX_MEMORY_SIZE) {
-          throw new AddressOutOfRangeError(baseAddr, offset);
+          throw new RelativeAddressOutOfRangeError(baseAddr, offset);
         }
       }
       if (mode & AddressingMode.INDIRECT) {

package/src/avm/opcodes/conversion.ts

@@ -12,57 +12,62 @@ export class ToRadixBE extends Instruction {
   // Informs (de)serialization. See Instruction.deserialize.
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8, // Opcode
-    OperandType.UINT8, // Indirect
+    OperandType.UINT16, // Indirect
     OperandType.UINT16, // src memory address
-    OperandType.UINT16, // dst memory address
     OperandType.UINT16, // radix memory address
-    OperandType.UINT16, // number of limbs (Immediate)
-    OperandType.UINT8, // output is in "bits" mode (Immediate - Uint1 still takes up a whole byte)
+    OperandType.UINT16, // number of limbs address
+    OperandType.UINT16, // output is in "bits" mode memory address (boolean/Uint1 is stored)
+    OperandType.UINT16, // dst memory address
   ];
 
   constructor(
     private indirect: number,
     private srcOffset: number,
-    private dstOffset: number,
     private radixOffset: number,
-    private numLimbs: number,
-    private outputBits: number, // effectively a bool
+    private numLimbsOffset: number,
+    private outputBitsOffset: number,
+    private dstOffset: number,
   ) {
     super();
   }
 
   public async execute(context: AvmContext): Promise<void> {
     const memory = context.machineState.memory.track(this.type);
-    const operands = [this.srcOffset, this.dstOffset, this.radixOffset];
+    const operands = [this.srcOffset, this.radixOffset, this.numLimbsOffset, this.outputBitsOffset, this.dstOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
-    const [srcOffset, dstOffset, radixOffset] = addressing.resolve(operands, memory);
-    context.machineState.consumeGas(this.gasCost(this.numLimbs));
+    const [srcOffset, radixOffset, numLimbsOffset, outputBitsOffset, dstOffset] = addressing.resolve(operands, memory);
 
     // The radix gadget only takes in a Field
     memory.checkTag(TypeTag.FIELD, srcOffset);
     memory.checkTag(TypeTag.UINT32, radixOffset);
+    memory.checkTag(TypeTag.UINT32, numLimbsOffset);
+    memory.checkTag(TypeTag.UINT1, outputBitsOffset);
+
+    const numLimbs = memory.get(numLimbsOffset).toNumber();
+    context.machineState.consumeGas(this.gasCost(numLimbs));
+    const outputBits = memory.get(outputBitsOffset).toNumber();
 
     let value: bigint = memory.get(srcOffset).toBigInt();
     const radix: bigint = memory.get(radixOffset).toBigInt();
-    if (this.numLimbs < 1) {
-      throw new InstructionExecutionError(`ToRadixBE instruction's numLimbs should be > 0 (was ${this.numLimbs})`);
+    if (numLimbs < 1) {
+      throw new InstructionExecutionError(`ToRadixBE instruction's numLimbs should be > 0 (was ${numLimbs})`);
     }
     if (radix > 256) {
       throw new InstructionExecutionError(`ToRadixBE instruction's radix should be <= 256 (was ${radix})`);
     }
     const radixBN: bigint = BigInt(radix);
-    const limbArray = new Array(this.numLimbs);
+    const limbArray = new Array(numLimbs);
 
-    for (let i = this.numLimbs - 1; i >= 0; i--) {
+    for (let i = numLimbs - 1; i >= 0; i--) {
       const limb = value % radixBN;
       limbArray[i] = limb;
       value /= radixBN;
     }
 
-    const outputType = this.outputBits != 0 ? Uint1 : Uint8;
+    const outputType = outputBits != 0 ? Uint1 : Uint8;
     const res = limbArray.map(byte => new outputType(byte));
     memory.setSlice(dstOffset, res);
 
-    memory.assert({ reads: 2, writes: this.numLimbs, addressing });
+    memory.assert({ reads: 4, writes: numLimbs, addressing });
   }
 }

package/src/avm/opcodes/ec_add.ts

@@ -84,10 +84,11 @@ export class EcAdd extends Instruction {
       dest = grumpkin.add(p1, p2);
     }
 
-    memory.set(dstOffset, new Field(dest.x));
-    memory.set(dstOffset + 1, new Field(dest.y));
+    // Important to use setSlice() and not set() in the two following statements as
+    // this checks that the offsets lie within memory range.
+    memory.setSlice(dstOffset, [new Field(dest.x), new Field(dest.y)]);
     // Check representation of infinity for grumpkin
-    memory.set(dstOffset + 2, new Uint1(dest.equals(Point.ZERO) ? 1 : 0));
+    memory.setSlice(dstOffset + 2, [new Uint1(dest.equals(Point.ZERO) ? 1 : 0)]);
 
     memory.assert({ reads: 6, writes: 3, addressing });
   }

package/src/avm/opcodes/external_calls.ts

@@ -39,10 +39,10 @@ abstract class ExternalCall extends Instruction {
     memory.checkTag(TypeTag.UINT32, argsSizeOffset);
 
     const calldataSize = memory.get(argsSizeOffset).toNumber();
+    const calldata = memory.getSlice(argsOffset, calldataSize).map(f => f.toFr());
     memory.checkTagsRange(TypeTag.FIELD, argsOffset, calldataSize);
 
     const callAddress = memory.getAs<Field>(addrOffset);
-    const calldata = memory.getSlice(argsOffset, calldataSize).map(f => f.toFr());
     // If we are already in a static call, we propagate the environment.
     const callType = context.environment.isStaticCall ? 'STATICCALL' : this.type;
 

package/src/avm/opcodes/hashing.ts

@@ -30,9 +30,10 @@ export class Poseidon2 extends Instruction {
     const operands = [this.inputStateOffset, this.outputStateOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [inputOffset, outputOffset] = addressing.resolve(operands, memory);
-    memory.checkTagsRange(TypeTag.FIELD, inputOffset, Poseidon2.stateSize);
 
     const inputState = memory.getSlice(inputOffset, Poseidon2.stateSize);
+    memory.checkTagsRange(TypeTag.FIELD, inputOffset, Poseidon2.stateSize);
+
     const outputState = poseidon2Permutation(inputState);
     memory.setSlice(
       outputOffset,
@@ -68,9 +69,9 @@ export class KeccakF1600 extends Instruction {
     const [dstOffset, inputOffset] = addressing.resolve(operands, memory);
     context.machineState.consumeGas(this.gasCost());
 
+    const stateData = memory.getSlice(inputOffset, inputSize).map(word => word.toBigInt());
     memory.checkTagsRange(TypeTag.UINT64, inputOffset, inputSize);
 
-    const stateData = memory.getSlice(inputOffset, inputSize).map(word => word.toBigInt());
     const updatedState = keccakf1600(stateData);
 
     const res = updatedState.map(word => new Uint64(word));
@@ -113,11 +114,12 @@ export class Sha256Compression extends Instruction {
 
     // Note: size of output is same as size of state
     context.machineState.consumeGas(this.gasCost());
+    const inputs = Uint32Array.from(memory.getSlice(inputsOffset, INPUTS_SIZE).map(word => word.toNumber()));
+    const state = Uint32Array.from(memory.getSlice(stateOffset, STATE_SIZE).map(word => word.toNumber()));
+
     memory.checkTagsRange(TypeTag.UINT32, inputsOffset, INPUTS_SIZE);
     memory.checkTagsRange(TypeTag.UINT32, stateOffset, STATE_SIZE);
 
-    const state = Uint32Array.from(memory.getSlice(stateOffset, STATE_SIZE).map(word => word.toNumber()));
-    const inputs = Uint32Array.from(memory.getSlice(inputsOffset, INPUTS_SIZE).map(word => word.toNumber()));
     const output = sha256Compression(state, inputs);
 
     // Conversion required from Uint32Array to Uint32[] (can't map directly, need `...`)

package/src/avm/opcodes/misc.ts

@@ -39,14 +39,15 @@ export class DebugLog extends Instruction {
 
     memory.checkTag(TypeTag.UINT32, fieldsSizeOffset);
     const fieldsSize = memory.get(fieldsSizeOffset).toNumber();
+
+    const rawMessage = memory.getSlice(messageOffset, this.messageSize);
+    const fields = memory.getSlice(fieldsOffset, fieldsSize);
+
     memory.checkTagsRange(TypeTag.UINT8, messageOffset, this.messageSize);
     memory.checkTagsRange(TypeTag.FIELD, fieldsOffset, fieldsSize);
 
     context.machineState.consumeGas(this.gasCost(this.messageSize + fieldsSize));
 
-    const rawMessage = memory.getSlice(messageOffset, this.messageSize);
-    const fields = memory.getSlice(fieldsOffset, fieldsSize);
-
     // Interpret str<N> = [u8; N] to string.
     const messageAsStr = rawMessage.map(field => String.fromCharCode(field.toNumber())).join('');
     const formattedStr = applyStringFormatting(

package/src/avm/opcodes/multi_scalar_mul.ts

@@ -46,6 +46,12 @@ export class MultiScalarMul extends Instruction {
     if (pointsReadLength % 3 !== 0) {
       throw new InstructionExecutionError(`Points vector offset should be a multiple of 3, was ${pointsReadLength}`);
     }
+
+    // Get the unrolled (x, y, inf) representing the points
+    // Important to perform this before tag validation, as getSlice() first checks
+    // that the slice is not out of memory range. This needs to be aligned with circuit.
+    const pointsVector = memory.getSlice(pointsOffset, pointsReadLength);
+
     // Divide by 3 since each point is represented as a triplet to get the number of points
     const numPoints = pointsReadLength / 3;
     // The tag for each triplet will be (Field, Field, Uint8)
@@ -56,8 +62,6 @@ export class MultiScalarMul extends Instruction {
       // Check Uint1 (inf flag)
       memory.checkTag(TypeTag.UINT1, offset + 2);
     }
-    // Get the unrolled (x, y, inf) representing the points
-    const pointsVector = memory.getSlice(pointsOffset, pointsReadLength);
 
     // The size of the scalars vector is twice the NUMBER of points because of the scalar limb decomposition
     const scalarReadLength = numPoints * 2;
@@ -106,10 +110,11 @@ export class MultiScalarMul extends Instruction {
       }
     }, grumpkin.mul(firstBaseScalarPair[0], firstBaseScalarPair[1]));
 
-    memory.set(outputOffset, new Field(outputPoint.x));
-    memory.set(outputOffset + 1, new Field(outputPoint.y));
+    // Important to use setSlice() and not set() in the two following statements as
+    // this checks that the offsets lie within memory range.
+    memory.setSlice(outputOffset, [new Field(outputPoint.x), new Field(outputPoint.y)]);
     // Check representation of infinity for grumpkin
-    memory.set(outputOffset + 2, new Uint1(outputPoint.equals(Point.ZERO) ? 1 : 0));
+    memory.setSlice(outputOffset + 2, [new Uint1(outputPoint.equals(Point.ZERO) ? 1 : 0)]);
 
     memory.assert({
       reads: 1 + pointsReadLength + scalarReadLength /* points and scalars */,

package/src/avm/test_utils.ts

@@ -28,6 +28,10 @@ export function mockStorageRead(worldStateDB: WorldStateDB, value: Fr) {
   (worldStateDB as jest.Mocked<WorldStateDB>).storageRead.mockResolvedValue(value);
 }
 
+export function mockNoteHashCount(mockedTrace: PublicSideEffectTraceInterface, count: number) {
+  (mockedTrace as jest.Mocked<PublicSideEffectTraceInterface>).getNoteHashCount.mockReturnValue(count);
+}
+
 export function mockStorageReadWithMap(worldStateDB: WorldStateDB, mockedStorage: Map<bigint, Fr>) {
   (worldStateDB as jest.Mocked<WorldStateDB>).storageRead.mockImplementation((_address, slot) =>
     Promise.resolve(mockedStorage.get(slot.toBigInt()) ?? Fr.ZERO),

package/src/client/client_execution_context.ts

@@ -565,5 +565,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     for (const [recipient, taggedLogs] of taggedLogsByRecipient.entries()) {
       await this.db.processTaggedLogs(taggedLogs, AztecAddress.fromString(recipient));
     }
+
+    await this.db.removeNullifiedNotes(this.contractAddress);
   }
 }

package/src/client/db_oracle.ts

@@ -198,21 +198,21 @@ export interface DBOracle extends CommitmentsDB {
   getBlockNumber(): Promise<number>;
 
   /**
-   * Returns the tagging secret for a given sender and recipient pair. For this to work, the ivpsk_m of the sender must be known.
+   * Returns the tagging secret for a given sender and recipient pair. For this to work, the ivsk_m of the sender must be known.
    * Includes the next index to be used used for tagging with this secret.
    * @param contractAddress - The contract address to silo the secret for
    * @param sender - The address sending the note
    * @param recipient - The address receiving the note
    * @returns A tagging secret that can be used to tag notes.
    */
-  getAppTaggingSecretAsSender(
+  getIndexedTaggingSecretAsSender(
     contractAddress: AztecAddress,
     sender: AztecAddress,
     recipient: AztecAddress,
   ): Promise<IndexedTaggingSecret>;
 
   /**
-   * Increments the tagging secret for a given sender and recipient pair. For this to work, the ivpsk_m of the sender must be known.
+   * Increments the tagging secret for a given sender and recipient pair. For this to work, the ivsk_m of the sender must be known.
    * @param contractAddress - The contract address to silo the secret for
    * @param sender - The address sending the note
    * @param recipient - The address receiving the note
@@ -242,4 +242,9 @@ export interface DBOracle extends CommitmentsDB {
    * @param recipient - The recipient of the logs.
    */
   processTaggedLogs(logs: TxScopedL2Log[], recipient: AztecAddress): Promise<void>;
+
+  /**
+   * Removes all of a contract's notes that have been nullified from the note database.
+   */
+  removeNullifiedNotes(contractAddress: AztecAddress): Promise<void>;
 }

package/src/client/index.ts

@@ -3,3 +3,4 @@ export * from './db_oracle.js';
 export * from './pick_notes.js';
 export * from './execution_note_cache.js';
 export { extractPrivateCircuitPublicInputs } from './private_execution.js';
+export { WASMSimulator } from '../providers/acvm_wasm.js';

package/src/client/view_data_oracle.ts

@@ -296,16 +296,16 @@ export class ViewDataOracle extends TypedOracle {
   /**
    * Returns the tagging secret for a given sender and recipient pair, siloed to the current contract address.
    * Includes the next index to be used used for tagging with this secret.
-   * For this to work, the ivpsk_m of the sender must be known.
+   * For this to work, the ivsk_m of the sender must be known.
    * @param sender - The address sending the note
    * @param recipient - The address receiving the note
    * @returns A tagging secret that can be used to tag notes.
    */
-  public override async getAppTaggingSecretAsSender(
+  public override async getIndexedTaggingSecretAsSender(
     sender: AztecAddress,
     recipient: AztecAddress,
   ): Promise<IndexedTaggingSecret> {
-    return await this.db.getAppTaggingSecretAsSender(this.contractAddress, sender, recipient);
+    return await this.db.getIndexedTaggingSecretAsSender(this.contractAddress, sender, recipient);
   }
 
   public override async syncNotes() {
@@ -314,8 +314,11 @@ export class ViewDataOracle extends TypedOracle {
       await this.aztecNode.getBlockNumber(),
       this.scopes,
     );
+
     for (const [recipient, taggedLogs] of taggedLogsByRecipient.entries()) {
       await this.db.processTaggedLogs(taggedLogs, AztecAddress.fromString(recipient));
     }
+
+    await this.db.removeNullifiedNotes(this.contractAddress);
   }
 }

package/src/providers/acvm_wasm.ts

@@ -1,4 +1,4 @@
-import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types';
+import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types/client';
 import { type NoirCompiledCircuit } from '@aztec/types/noir';
 
 import { executeCircuit } from '@noir-lang/acvm_js';

package/src/providers/acvm_wasm_with_blobs.ts

@@ -0,0 +1,25 @@
+import { foreignCallHandler } from '@aztec/noir-protocol-circuits-types';
+import { type NoirCompiledCircuit } from '@aztec/types/noir';
+
+import { executeCircuit } from '@noir-lang/acvm_js';
+import { type WitnessMap } from '@noir-lang/types';
+
+import { type SimulationProvider } from './simulation_provider.js';
+
+export class WASMSimulatorWithBlobs implements SimulationProvider {
+  async simulateCircuit(input: WitnessMap, compiledCircuit: NoirCompiledCircuit): Promise<WitnessMap> {
+    // Execute the circuit on those initial witness values
+    //
+    // Decode the bytecode from base64 since the acvm does not know about base64 encoding
+    const decodedBytecode = Buffer.from(compiledCircuit.bytecode, 'base64');
+    //
+    // Execute the circuit
+    const _witnessMap = await executeCircuit(
+      decodedBytecode,
+      input,
+      foreignCallHandler, // handle calls to debug_log and evaluate_blobs mock
+    );
+
+    return _witnessMap;
+  }
+}

package/src/providers/index.ts

@@ -1,4 +1,4 @@
 export * from './acvm_native.js';
-export * from './acvm_wasm.js';
+export * from './acvm_wasm_with_blobs.js';
 export * from './simulation_provider.js';
 export * from './factory.js';

package/src/public/bytecode_errors.ts

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