@aztec/simulator 0.64.0 → 0.65.1

package/src/avm/journal/nullifiers.ts

@@ -1,20 +1,18 @@
-import { type AztecAddress } from '@aztec/circuits.js';
-import { siloNullifier } from '@aztec/circuits.js/hash';
 import { Fr } from '@aztec/foundation/fields';
 
 import type { CommitmentsDB } from '../../index.js';
 
 /**
  * A class to manage new nullifier staging and existence checks during a contract call's AVM simulation.
- * Maintains a nullifier cache, and ensures that existence checks fall back to the correct source.
+ * Maintains a siloed nullifier cache, and ensures that existence checks fall back to the correct source.
  * When a contract call completes, its cached nullifier set can be merged into its parent's.
  */
 export class NullifierManager {
   constructor(
     /** Reference to node storage. Checked on parent cache-miss. */
     private readonly hostNullifiers: CommitmentsDB,
-    /** Cached nullifiers. */
-    private readonly cache: NullifierCache = new NullifierCache(),
+    /** Cache of siloed nullifiers. */
+    private cache: Set<bigint> = new Set(),
     /** Parent nullifier manager to fall back on */
     private readonly parent?: NullifierManager,
   ) {}
@@ -22,32 +20,34 @@ export class NullifierManager {
   /**
    * Create a new nullifiers manager with some preloaded pending siloed nullifiers
    */
-  public static newWithPendingSiloedNullifiers(hostNullifiers: CommitmentsDB, pendingSiloedNullifiers: Fr[]) {
-    const cache = new NullifierCache(pendingSiloedNullifiers);
-    return new NullifierManager(hostNullifiers, cache);
+  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
    */
   public fork() {
-    return new NullifierManager(this.hostNullifiers, new NullifierCache(), this);
+    return new NullifierManager(this.hostNullifiers, new Set(), this);
   }
 
   /**
    * Get a nullifier's existence in this' cache or parent's (recursively).
    * DOES NOT CHECK HOST STORAGE!
-   * @param contractAddress - the address of the contract whose storage is being read from
-   * @param nullifier - the nullifier to check for
+   * @param siloedNullifier - the nullifier to check for
    * @returns exists: whether the nullifier exists in cache here or in parent's
    */
-  private checkExistsHereOrParent(contractAddress: AztecAddress, nullifier: Fr): boolean {
+  private checkExistsHereOrParent(siloedNullifier: Fr): boolean {
     // First check this cache
-    let existsAsPending = this.cache.exists(contractAddress, nullifier);
+    let existsAsPending = this.cache.has(siloedNullifier.toBigInt());
     // Then try parent's nullifier cache
     if (!existsAsPending && this.parent) {
       // Note: this will recurse to grandparent/etc until a cache-hit is encountered.
-      existsAsPending = this.parent.checkExistsHereOrParent(contractAddress, nullifier);
+      existsAsPending = this.parent.checkExistsHereOrParent(siloedNullifier);
     }
     return existsAsPending;
   }
@@ -59,24 +59,22 @@ export class NullifierManager {
    * 3. Fall back to the host state.
    * 4. Not found! Nullifier does not exist.
    *
-   * @param contractAddress - the address of the contract whose storage is being read from
-   * @param nullifier - the nullifier to check for
+   * @param siloedNullifier - the nullifier to check for
    * @returns exists: whether the nullifier exists at all,
    *          isPending: whether the nullifier was found in a cache,
    *          leafIndex: the nullifier's leaf index if it exists and is not pending (comes from host state).
    */
   public async checkExists(
-    contractAddress: AztecAddress,
-    nullifier: Fr,
+    siloedNullifier: Fr,
   ): Promise<[/*exists=*/ boolean, /*isPending=*/ boolean, /*leafIndex=*/ Fr]> {
     // Check this cache and parent's (recursively)
-    const existsAsPending = this.checkExistsHereOrParent(contractAddress, nullifier);
+    const existsAsPending = this.checkExistsHereOrParent(siloedNullifier);
     // Finally try the host's Aztec state (a trip to the database)
     // If the value is found in the database, it will be associated with a leaf index!
     let leafIndex: bigint | undefined = undefined;
     if (!existsAsPending) {
       // silo the nullifier before checking for its existence in the host
-      leafIndex = await this.hostNullifiers.getNullifierIndex(siloNullifier(contractAddress, nullifier));
+      leafIndex = await this.hostNullifiers.getNullifierIndex(siloedNullifier);
     }
     const exists = existsAsPending || leafIndex !== undefined;
     leafIndex = leafIndex === undefined ? BigInt(0) : leafIndex;
@@ -86,17 +84,14 @@ export class NullifierManager {
   /**
    * Stage a new nullifier (append it to the cache).
    *
-   * @param contractAddress - the address of the contract that the nullifier is associated with
-   * @param nullifier - the nullifier to stage
+   * @param siloedNullifier - the nullifier to stage
    */
-  public async append(contractAddress: AztecAddress, nullifier: Fr) {
-    const [exists, ,] = await this.checkExists(contractAddress, nullifier);
+  public async append(siloedNullifier: Fr) {
+    const [exists, ,] = await this.checkExists(siloedNullifier);
     if (exists) {
-      throw new NullifierCollisionError(
-        `Nullifier ${nullifier} at contract ${contractAddress} already exists in parent cache or host.`,
-      );
+      throw new NullifierCollisionError(`Siloed nullifier ${siloedNullifier} already exists in parent cache or host.`);
     }
-    this.cache.append(contractAddress, nullifier);
+    this.cache.add(siloedNullifier.toBigInt());
   }
 
   /**
@@ -105,101 +100,14 @@ export class NullifierManager {
    * @param incomingNullifiers - the incoming cached nullifiers to merge into this instance's
    */
   public acceptAndMerge(incomingNullifiers: NullifierManager) {
-    this.cache.acceptAndMerge(incomingNullifiers.cache);
-  }
-}
-
-/**
- * A class to cache nullifiers created during a contract call's AVM simulation.
- * "append" updates a map, "exists" checks that map.
- * An instance of this class can merge another instance's cached nullifiers into its own.
- */
-export class NullifierCache {
-  /**
-   * Map for staging nullifiers.
-   * One inner-set per contract storage address,
-   * each entry being a nullifier.
-   */
-  private cachePerContract: Map<bigint, Set<bigint>> = new Map();
-  private siloedNullifiers: Set<bigint> = new Set();
-
-  /**
-   * @parem siloedNullifierFrs: optional list of pending siloed nullifiers to initialize this cache with
-   */
-  constructor(siloedNullifierFrs?: Fr[]) {
-    if (siloedNullifierFrs !== undefined) {
-      siloedNullifierFrs.forEach(nullifier => this.siloedNullifiers.add(nullifier.toBigInt()));
-    }
-  }
-
-  /**
-   * Check whether a nullifier exists in the cache.
-   *
-   * @param contractAddress - the address of the contract that the nullifier is associated with
-   * @param nullifier - the nullifier to check existence of
-   * @returns whether the nullifier is found in the cache
-   */
-  public exists(contractAddress: AztecAddress, nullifier: Fr): boolean {
-    const exists =
-      this.cachePerContract.get(contractAddress.toBigInt())?.has(nullifier.toBigInt()) ||
-      this.siloedNullifiers.has(siloNullifier(contractAddress, nullifier).toBigInt());
-    return !!exists;
-  }
-
-  /**
-   * Stage a new nullifier (append it to the cache).
-   *
-   * @param contractAddress - the address of the contract that the nullifier is associated with
-   * @param nullifier - the nullifier to stage
-   */
-  public append(contractAddress: AztecAddress, nullifier: Fr) {
-    if (this.exists(contractAddress, nullifier)) {
-      throw new NullifierCollisionError(
-        `Nullifier ${nullifier} at contract ${contractAddress} already exists in cache.`,
-      );
-    }
-
-    let nullifiersForContract = this.cachePerContract.get(contractAddress.toBigInt());
-    // If this contract's nullifier set has no cached nullifiers, create a new Set to store them
-    if (!nullifiersForContract) {
-      nullifiersForContract = new Set();
-      this.cachePerContract.set(contractAddress.toBigInt(), nullifiersForContract);
-    }
-    nullifiersForContract.add(nullifier.toBigInt());
-  }
-
-  /**
-   * Merge another cache's nullifiers into this instance's.
-   *
-   * Cached nullifiers in "incoming" must not collide with any present in "this".
-   *
-   * In practice, "this" is a parent call's pending nullifiers, and "incoming" is a nested call's.
-   *
-   * @param incomingNullifiers - the incoming cached nullifiers to merge into this instance's
-   */
-  public acceptAndMerge(incomingNullifiers: NullifierCache) {
-    // Merge siloed nullifiers.
-    this.siloedNullifiers = new Set([...this.siloedNullifiers, ...incomingNullifiers.siloedNullifiers]);
-    // Iterate over all contracts with staged writes in the child.
-    for (const [incomingAddress, incomingCacheAtContract] of incomingNullifiers.cachePerContract) {
-      const thisCacheAtContract = this.cachePerContract.get(incomingAddress);
-      if (!thisCacheAtContract) {
-        // This contract has no nullifiers cached here
-        // so just accept incoming cache as-is for this contract.
-        this.cachePerContract.set(incomingAddress, incomingCacheAtContract);
-      } else {
-        // "Incoming" and "this" both have cached nullifiers for this contract.
-        // Merge in incoming nullifiers, erroring if there are any duplicates.
-        for (const nullifier of incomingCacheAtContract) {
-          if (thisCacheAtContract.has(nullifier)) {
-            throw new NullifierCollisionError(
-              `Failed to accept child call's nullifiers. Nullifier ${nullifier} already exists at contract ${incomingAddress}.`,
-            );
-          }
-          thisCacheAtContract.add(nullifier);
-        }
+    for (const incomingNullifier of incomingNullifiers.cache) {
+      if (this.cache.has(incomingNullifier)) {
+        throw new NullifierCollisionError(
+          `Failed to merge in fork's cached nullifiers. Siloed nullifier ${incomingNullifier} already exists in parent cache.`,
+        );
       }
     }
+    this.cache = new Set([...this.cache, ...incomingNullifiers.cache]);
   }
 }
 

package/src/avm/opcodes/contract.ts

@@ -18,18 +18,18 @@ export class GetContractInstance extends Instruction {
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect bits
-    OperandType.UINT8, // member enum (immediate)
     OperandType.UINT16, // addressOffset
     OperandType.UINT16, // dstOffset
     OperandType.UINT16, // existsOfsset
+    OperandType.UINT8, // member enum (immediate)
   ];
 
   constructor(
     private indirect: number,
-    private memberEnum: number,
     private addressOffset: number,
     private dstOffset: number,
     private existsOffset: number,
+    private memberEnum: number,
   ) {
     super();
   }

package/src/avm/opcodes/control_flow.ts

@@ -36,11 +36,11 @@ export class JumpI extends Instruction {
   static readonly wireFormat: OperandType[] = [
     OperandType.UINT8,
     OperandType.UINT8,
-    OperandType.UINT32,
     OperandType.UINT16,
+    OperandType.UINT32,
   ];
 
-  constructor(private indirect: number, private loc: number, private condOffset: number) {
+  constructor(private indirect: number, private condOffset: number, private loc: number) {
     super();
   }
 

package/src/avm/opcodes/environment_getters.ts

@@ -60,11 +60,11 @@ export class GetEnvVar extends Instruction {
   static readonly wireFormat16: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect
-    OperandType.UINT8, // variable enum (immediate)
     OperandType.UINT16, // dstOffset
+    OperandType.UINT8, // variable enum (immediate)
   ];
 
-  constructor(private indirect: number, private varEnum: number, private dstOffset: number) {
+  constructor(private indirect: number, private dstOffset: number, private varEnum: number) {
     super();
   }
 

package/src/avm/opcodes/instruction.ts

@@ -94,7 +94,7 @@ export abstract class Instruction {
    * Computes gas cost for the instruction based on its base cost and memory operations.
    * @returns Gas cost.
    */
-  public gasCost(dynMultiplier: number = 0): Gas {
+  protected gasCost(dynMultiplier: number = 0): Gas {
     const baseGasCost = getBaseGasCost(this.opcode);
     const dynGasCost = mulGas(getDynamicGasCost(this.opcode), dynMultiplier);
     return sumGas(baseGasCost, dynGasCost);

package/src/avm/opcodes/memory.ts

@@ -12,63 +12,66 @@ export class Set extends Instruction {
   public static readonly wireFormat8: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect
+    OperandType.UINT8, // dstOffset
     OperandType.UINT8, // tag
     OperandType.UINT8, // const (value)
-    OperandType.UINT8, // dstOffset
   ];
   public static readonly wireFormat16: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect
+    OperandType.UINT16, // dstOffset
     OperandType.UINT8, // tag
     OperandType.UINT16, // const (value)
-    OperandType.UINT16, // dstOffset
   ];
   public static readonly wireFormat32: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect
+    OperandType.UINT16, // dstOffset
     OperandType.UINT8, // tag
     OperandType.UINT32, // const (value)
-    OperandType.UINT16, // dstOffset
   ];
   public static readonly wireFormat64: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect
+    OperandType.UINT16, // dstOffset
     OperandType.UINT8, // tag
     OperandType.UINT64, // const (value)
-    OperandType.UINT16, // dstOffset
   ];
   public static readonly wireFormat128: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect
+    OperandType.UINT16, // dstOffset
     OperandType.UINT8, // tag
     OperandType.UINT128, // const (value)
-    OperandType.UINT16, // dstOffset
   ];
   public static readonly wireFormatFF: OperandType[] = [
     OperandType.UINT8, // opcode
     OperandType.UINT8, // indirect
+    OperandType.UINT16, // dstOffset
     OperandType.UINT8, // tag
     OperandType.FF, // const (value)
-    OperandType.UINT16, // dstOffset
   ];
 
   constructor(
     private indirect: number,
+    private dstOffset: number,
     private inTag: number,
     private value: bigint | number,
-    private dstOffset: number,
   ) {
     super();
+    TaggedMemory.checkIsValidTag(inTag);
   }
 
   public async execute(context: AvmContext): Promise<void> {
+    // Constructor ensured that this.inTag is a valid tag
+    const res = TaggedMemory.buildFromTagTruncating(this.value, this.inTag);
+
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost());
 
     const operands = [this.dstOffset];
     const addressing = Addressing.fromWire(this.indirect, operands.length);
     const [dstOffset] = addressing.resolve(operands, memory);
-    const res = TaggedMemory.buildFromTagTruncating(this.value, this.inTag);
     memory.set(dstOffset, res);
 
     memory.assert({ writes: 1, addressing });
@@ -87,15 +90,16 @@ export class Cast extends Instruction {
     OperandType.UINT8,
   ];
   static readonly wireFormat16 = [
-    OperandType.UINT8,
     OperandType.UINT8,
     OperandType.UINT8,
     OperandType.UINT16,
     OperandType.UINT16,
+    OperandType.UINT8,
   ];
 
-  constructor(private indirect: number, private dstTag: number, private srcOffset: number, private dstOffset: number) {
+  constructor(private indirect: number, private srcOffset: number, private dstOffset: number, private dstTag: number) {
     super();
+    TaggedMemory.checkIsValidTag(dstTag);
   }
 
   public async execute(context: AvmContext): Promise<void> {
@@ -107,6 +111,7 @@ export class Cast extends Instruction {
     const [srcOffset, dstOffset] = addressing.resolve(operands, memory);
 
     const a = memory.get(srcOffset);
+    // Constructor ensured that this.dstTag is a valid tag
     const casted = TaggedMemory.buildFromTagTruncating(a.toBigInt(), this.dstTag);
 
     memory.set(dstOffset, casted);

package/src/avm/opcodes/misc.ts

@@ -16,17 +16,17 @@ export class DebugLog extends Instruction {
     OperandType.UINT8, // Opcode
     OperandType.UINT8, // Indirect
     OperandType.UINT16, // message memory address
-    OperandType.UINT16, // message size
     OperandType.UINT16, // fields memory address
     OperandType.UINT16, // fields size address
+    OperandType.UINT16, // message size
   ];
 
   constructor(
     private indirect: number,
     private messageOffset: number,
-    private messageSize: number,
     private fieldsOffset: number,
     private fieldsSizeOffset: number,
+    private messageSize: number,
   ) {
     super();
   }

package/src/avm/serialization/buffer_cursor.ts

@@ -1,5 +1,3 @@
-import { strict as assert } from 'assert';
-
 /*
  * A Buffer-like class that automatically advances the position.
  */
@@ -10,6 +8,10 @@ export class BufferCursor {
     return this._position;
   }
 
+  public buffer(): Buffer {
+    return this._buffer;
+  }
+
   public eof(): boolean {
     return this._position === this._buffer.length;
   }
@@ -20,7 +22,11 @@ export class BufferCursor {
 
   public advance(n: number): void {
     this._position += n;
-    assert(n < this._buffer.length);
+  }
+
+  public peekUint8(): number {
+    const ret = this._buffer.readUint8(this._position);
+    return ret;
   }
 
   public readUint8(): number {

package/src/avm/serialization/bytecode_serialization.ts

@@ -1,3 +1,4 @@
+import { AvmExecutionError, AvmParsingError, InvalidOpcodeError, InvalidProgramCounterError } from '../errors.js';
 import {
   Add,
   And,
@@ -48,7 +49,7 @@ import {
 } from '../opcodes/index.js';
 import { MultiScalarMul } from '../opcodes/multi_scalar_mul.js';
 import { BufferCursor } from './buffer_cursor.js';
-import { Opcode } from './instruction_serialization.js';
+import { MAX_OPCODE_VALUE, Opcode } from './instruction_serialization.js';
 
 export type InstructionDeserializer = (buf: BufferCursor | Buffer) => Instruction;
 
@@ -63,7 +64,7 @@ export interface Deserializable {
 export type InstructionSet = Map<Opcode, InstructionDeserializer>;
 // TODO(4359): This is a function so that Call and StaticCall can be lazily resolved.
 // This is a temporary solution until we solve the dependency cycle.
-const INSTRUCTION_SET = () =>
+export const INSTRUCTION_SET = () =>
   new Map<Opcode, InstructionDeserializer>([
     [Opcode.ADD_8, Add.as(Add.wireFormat8).deserialize],
     [Opcode.ADD_16, Add.as(Add.wireFormat16).deserialize],
@@ -179,18 +180,33 @@ export function decodeInstructionFromBytecode(
   instructionSet: InstructionSet = INSTRUCTION_SET(),
 ): [Instruction, number] {
   if (pc >= bytecode.length) {
-    throw new Error(`pc ${pc} is out of bounds for bytecode of length ${bytecode.length}`);
+    throw new InvalidProgramCounterError(pc, bytecode.length);
   }
-  const cursor = new BufferCursor(bytecode, pc);
-  const startingPosition = cursor.position();
-  const opcode: Opcode = cursor.bufferAtPosition().readUint8(); // peek.
 
-  const instructionDeserializerOrUndef = instructionSet.get(opcode);
-  if (instructionDeserializerOrUndef === undefined) {
-    throw new Error(`Opcode ${Opcode[opcode]} (0x${opcode.toString(16)}) not implemented`);
+  try {
+    const cursor = new BufferCursor(bytecode, pc);
+    const startingPosition = cursor.position();
+    const opcode: number = cursor.bufferAtPosition().readUint8(); // peek.
+
+    if (opcode > MAX_OPCODE_VALUE) {
+      throw new InvalidOpcodeError(
+        `Opcode ${opcode} (0x${opcode.toString(16)}) value is not in the range of valid opcodes.`,
+      );
+    }
+
+    const instructionDeserializerOrUndef = instructionSet.get(opcode);
+    if (instructionDeserializerOrUndef === undefined) {
+      throw new InvalidOpcodeError(`Opcode ${Opcode[opcode]} (0x${opcode.toString(16)}) is not implemented`);
+    }
+
+    const instructionDeserializer: InstructionDeserializer = instructionDeserializerOrUndef;
+    const instruction = instructionDeserializer(cursor);
+    return [instruction, cursor.position() - startingPosition];
+  } catch (error) {
+    if (error instanceof InvalidOpcodeError || error instanceof AvmExecutionError) {
+      throw error;
+    } else {
+      throw new AvmParsingError(`${error}`);
+    }
   }
-
-  const instructionDeserializer: InstructionDeserializer = instructionDeserializerOrUndef;
-  const instruction = instructionDeserializer(cursor);
-  return [instruction, cursor.position() - startingPosition];
 }

package/src/avm/serialization/instruction_serialization.ts

@@ -86,6 +86,12 @@ export enum Opcode {
   TORADIXBE,
 }
 
+export const MAX_OPCODE_VALUE = Math.max(
+  ...Object.values(Opcode)
+    .map(k => +k)
+    .filter(k => !isNaN(k)),
+);
+
 // Possible types for an instruction's operand in its wire format. (Keep in sync with CPP code.
 // See vm/avm_trace/deserialization.cpp)
 // Note that cpp code introduced an additional enum value TAG to express the instruction tag. In TS,
@@ -103,7 +109,7 @@ type OperandNativeType = number | bigint;
 type OperandWriter = (value: any) => void;
 
 // Specifies how to read and write each operand type.
-const OPERAND_SPEC = new Map<OperandType, [number, () => OperandNativeType, OperandWriter]>([
+const OPERAND_SPEC = new Map<OperandType, [number, (offset: number) => OperandNativeType, OperandWriter]>([
   [OperandType.UINT8, [1, Buffer.prototype.readUint8, Buffer.prototype.writeUint8]],
   [OperandType.UINT16, [2, Buffer.prototype.readUint16BE, Buffer.prototype.writeUint16BE]],
   [OperandType.UINT32, [4, Buffer.prototype.readUint32BE, Buffer.prototype.writeUint32BE]],
@@ -112,12 +118,12 @@ const OPERAND_SPEC = new Map<OperandType, [number, () => OperandNativeType, Oper
   [OperandType.FF, [32, readBigInt254BE, writeBigInt254BE]],
 ]);
 
-function readBigInt254BE(this: Buffer): bigint {
+function readBigInt254BE(this: Buffer, offset: number): bigint {
   const totalBytes = 32;
   let ret: bigint = 0n;
   for (let i = 0; i < totalBytes; ++i) {
     ret <<= 8n;
-    ret |= BigInt(this.readUint8(i));
+    ret |= BigInt(this.readUint8(i + offset));
   }
   return ret;
 }
@@ -130,12 +136,12 @@ function writeBigInt254BE(this: Buffer, value: bigint): void {
   }
 }
 
-function readBigInt128BE(this: Buffer): bigint {
+function readBigInt128BE(this: Buffer, offset: number): bigint {
   const totalBytes = 16;
   let ret: bigint = 0n;
   for (let i = 0; i < totalBytes; ++i) {
     ret <<= 8n;
-    ret |= BigInt(this.readUint8(i));
+    ret |= BigInt(this.readUint8(i + offset));
   }
   return ret;
 }
@@ -163,7 +169,7 @@ export function deserialize(cursor: BufferCursor | Buffer, operands: OperandType
   for (const op of operands) {
     const opType = op;
     const [sizeBytes, reader, _writer] = OPERAND_SPEC.get(opType)!;
-    argValues.push(reader.call(cursor.bufferAtPosition()));
+    argValues.push(reader.call(cursor.buffer(), cursor.position()));
     cursor.advance(sizeBytes);
   }
 

package/src/avm/test_utils.ts

@@ -1,4 +1,9 @@
-import { type ContractClassPublic, type ContractInstanceWithAddress, Fr } from '@aztec/circuits.js';
+import {
+  type ContractClassPublic,
+  type ContractInstanceWithAddress,
+  Fr,
+  computePublicBytecodeCommitment,
+} from '@aztec/circuits.js';
 
 import { type jest } from '@jest/globals';
 import { mock } from 'jest-mock-extended';
@@ -8,6 +13,9 @@ import { type PublicSideEffectTraceInterface } from '../public/side_effect_trace
 
 export function mockGetBytecode(worldStateDB: WorldStateDB, bytecode: Buffer) {
   (worldStateDB as jest.Mocked<WorldStateDB>).getBytecode.mockResolvedValue(bytecode);
+  (worldStateDB as jest.Mocked<WorldStateDB>).getBytecodeCommitment.mockResolvedValue(
+    computePublicBytecodeCommitment(bytecode),
+  );
 }
 
 export function mockTraceFork(trace: PublicSideEffectTraceInterface, nestedTrace?: PublicSideEffectTraceInterface) {

package/src/common/errors.ts

@@ -6,6 +6,7 @@ import {
 } from '@aztec/circuit-types';
 import { type Fr } from '@aztec/circuits.js';
 import type { BrilligFunctionId, FunctionAbi, FunctionDebugMetadata, OpcodeLocation } from '@aztec/foundation/abi';
+import { jsonStringify } from '@aztec/foundation/json-rpc';
 
 import { type RawAssertionPayload } from '@noir-lang/acvm_js';
 import { abiDecodeError } from '@noir-lang/noirc_abi';
@@ -153,7 +154,7 @@ export function resolveAssertionMessage(errorPayload: RawAssertionPayload, abi:
   if (typeof decoded === 'string') {
     return decoded;
   } else {
-    return JSON.stringify(decoded);
+    return jsonStringify(decoded);
   }
 }
 

package/src/public/dual_side_effect_trace.ts

@@ -94,50 +94,26 @@ export class DualSideEffectTrace implements PublicSideEffectTraceInterface {
   }
 
   public traceNullifierCheck(
-    contractAddress: AztecAddress,
-    nullifier: Fr,
+    siloedNullifier: Fr,
     exists: boolean,
     lowLeafPreimage: NullifierLeafPreimage,
     lowLeafIndex: Fr,
     lowLeafPath: Fr[],
   ) {
-    this.innerCallTrace.traceNullifierCheck(
-      contractAddress,
-      nullifier,
-      exists,
-      lowLeafPreimage,
-      lowLeafIndex,
-      lowLeafPath,
-    );
-    this.enqueuedCallTrace.traceNullifierCheck(
-      contractAddress,
-      nullifier,
-      exists,
-      lowLeafPreimage,
-      lowLeafIndex,
-      lowLeafPath,
-    );
+    this.innerCallTrace.traceNullifierCheck(siloedNullifier, exists, lowLeafPreimage, lowLeafIndex, lowLeafPath);
+    this.enqueuedCallTrace.traceNullifierCheck(siloedNullifier, exists, lowLeafPreimage, lowLeafIndex, lowLeafPath);
   }
 
   public traceNewNullifier(
-    contractAddress: AztecAddress,
-    nullifier: Fr,
+    siloedNullifier: Fr,
     lowLeafPreimage: NullifierLeafPreimage,
     lowLeafIndex: Fr,
     lowLeafPath: Fr[],
     insertionPath: Fr[],
   ) {
-    this.innerCallTrace.traceNewNullifier(
-      contractAddress,
-      nullifier,
-      lowLeafPreimage,
-      lowLeafIndex,
-      lowLeafPath,
-      insertionPath,
-    );
+    this.innerCallTrace.traceNewNullifier(siloedNullifier, lowLeafPreimage, lowLeafIndex, lowLeafPath, insertionPath);
     this.enqueuedCallTrace.traceNewNullifier(
-      contractAddress,
-      nullifier,
+      siloedNullifier,
       lowLeafPreimage,
       lowLeafIndex,
       lowLeafPath,