@aztec/simulator 0.0.1-commit.f504929 → 0.0.1-commit.f5a9928

package/src/private/circuit_recording/file_circuit_recorder.ts

@@ -3,11 +3,13 @@ import type { Logger } from '@aztec/foundation/log';
 import fs from 'fs/promises';
 import path from 'path';
 
-import type { ACVMWitness } from '../acvm/acvm_types.js';
 import { CircuitRecorder, type CircuitRecording } from './circuit_recorder.js';
 
+/** Per-recording file state, keyed by recording so concurrent/nested executions don't share it. */
+type RecordingFileState = { filePath: string; isFirstCall: boolean };
+
 export class FileCircuitRecorder extends CircuitRecorder {
-  declare recording?: CircuitRecording & { filePath: string; isFirstCall: boolean };
+  readonly #fileState = new WeakMap<CircuitRecording, RecordingFileState>();
 
   constructor(
     private readonly recordDir: string,
@@ -16,16 +18,9 @@ export class FileCircuitRecorder extends CircuitRecorder {
     super(logger);
   }
 
-  override async start(
-    input: ACVMWitness,
-    circuitBytecode: Buffer,
-    circuitName: string,
-    functionName: string = 'main',
-  ) {
-    await super.start(input, circuitBytecode, circuitName, functionName);
-
+  protected override async onStart(recording: CircuitRecording): Promise<void> {
     const recordingStringWithoutClosingBracket = JSON.stringify(
-      { ...this.recording, isFirstCall: undefined, parent: undefined, oracleCalls: undefined, filePath: undefined },
+      { ...recording, parent: undefined, oracleCalls: undefined },
       null,
       2,
     ).slice(0, -2);
@@ -45,13 +40,13 @@ export class FileCircuitRecorder extends CircuitRecorder {
       }
     }
 
-    this.recording!.isFirstCall = true;
-    this.recording!.filePath = await FileCircuitRecorder.#computeFilePathAndStoreInitialRecording(
+    const filePath = await FileCircuitRecorder.#computeFilePathAndStoreInitialRecording(
       this.recordDir,
-      this.recording!.circuitName,
-      this.recording!.functionName,
+      recording.circuitName,
+      recording.functionName,
       recordingStringWithoutClosingBracket,
     );
+    this.#fileState.set(recording, { filePath, isFirstCall: true });
   }
 
   /**
@@ -95,53 +90,48 @@ export class FileCircuitRecorder extends CircuitRecorder {
    * @param inputs - Input arguments
    * @param outputs - Output results
    */
-  override async recordCall(name: string, inputs: unknown[], outputs: unknown, time: number, stackDepth: number) {
-    const entry = await super.recordCall(name, inputs, outputs, time, stackDepth);
-    try {
-      const prefix = this.recording!.isFirstCall ? '    ' : '    ,';
-      this.recording!.isFirstCall = false;
-      await fs.appendFile(this.recording!.filePath, prefix + JSON.stringify(entry) + '\n');
-    } catch (err) {
-      this.logger.error('Failed to log circuit call', { error: err });
+  override async recordCall(name: string, inputs: unknown[], outputs: unknown, time: number) {
+    const entry = await super.recordCall(name, inputs, outputs, time);
+    const recording = this.currentRecording();
+    const state = recording && this.#fileState.get(recording);
+    if (state) {
+      try {
+        const prefix = state.isFirstCall ? '    ' : '    ,';
+        state.isFirstCall = false;
+        await fs.appendFile(state.filePath, prefix + JSON.stringify(entry) + '\n');
+      } catch (err) {
+        this.logger.error('Failed to log circuit call', { error: err });
+      }
     }
     return entry;
   }
 
-  /**
-   * Finalizes the recording file by adding closing brackets. Without calling this method, the recording file is
-   * incomplete and it fails to parse.
-   */
-  override async finish(): Promise<CircuitRecording> {
-    // Finish sets the recording to undefined if we are at the topmost circuit,
-    // so we save the current file path before that
-    const filePath = this.recording!.filePath;
-    const result = await super.finish();
+  /** Closes the recording file with the trailing brackets so the JSON parses. */
+  protected override async onFinish(recording: CircuitRecording): Promise<void> {
+    const state = this.#fileState.get(recording);
+    if (!state) {
+      return;
+    }
     try {
-      await fs.appendFile(filePath, '  ]\n}\n');
+      await fs.appendFile(state.filePath, '  ]\n}\n');
     } catch (err) {
       this.logger.error('Failed to finalize recording file', { error: err });
     }
-    return result!;
   }
 
-  /**
-   * Finalizes the recording file by adding the error and closing brackets. Without calling this method or `finish`,
-   * the recording file is incomplete and it fails to parse.
-   * @param error - The error that occurred during circuit execution
-   */
-  override async finishWithError(error: unknown): Promise<CircuitRecording> {
-    // Finish sets the recording to undefined if we are at the topmost circuit,
-    // so we save the current file path before that
-    const filePath = this.recording!.filePath;
-    const result = await super.finishWithError(error);
+  /** Closes the recording file with the execution error and trailing brackets so the JSON parses. */
+  protected override async onError(recording: CircuitRecording, error: unknown): Promise<void> {
+    const state = this.#fileState.get(recording);
+    if (!state) {
+      return;
+    }
     try {
-      await fs.appendFile(filePath, '  ],\n');
-      await fs.appendFile(filePath, `  "error": ${JSON.stringify(error)}\n`);
-      await fs.appendFile(filePath, '}\n');
+      await fs.appendFile(state.filePath, '  ],\n');
+      await fs.appendFile(state.filePath, `  "error": ${JSON.stringify(error)}\n`);
+      await fs.appendFile(state.filePath, '}\n');
     } catch (err) {
       this.logger.error('Failed to finalize recording file with error', { error: err });
     }
-    return result!;
   }
 }
 

package/src/private/circuit_recording/simulator_recorder_wrapper.ts

@@ -58,24 +58,18 @@ export class SimulatorRecorderWrapper implements CircuitSimulator {
     functionName: string,
     callback: C,
   ): Promise<T> {
-    // Start recording circuit execution
-    await this.recorder.start(input, bytecode, contractName, functionName);
-
-    // If callback was provided, we wrap it in a circuit recorder callback wrapper
+    // If a callback was provided, we wrap it so that its oracle calls are recorded. The wrapped callback reads the
+    // active recording lazily, so it picks up the recording opened by record() below.
     const wrappedCallback = this.recorder.wrapCallback(callback);
-    let result: T;
-    try {
-      result = await simulateFn(wrappedCallback as C);
-    } catch (error) {
-      // If an error occurs, we finalize the recording file with the error
-      await this.recorder.finishWithError(error);
-      throw error;
-    }
 
-    // Witness generation is complete so we finish the circuit recorder
-    const recording = await this.recorder.finish();
+    // record() opens a recording for this circuit, runs the simulation within it, and finalizes it. A simulation
+    // failure is re-thrown unchanged, so recorder bookkeeping never masks the underlying error.
+    const { result, recording } = await this.recorder.record(
+      { input, bytecode, circuitName: contractName, functionName },
+      () => simulateFn(wrappedCallback as C),
+    );
 
-    (result as ACIRExecutionResult).oracles = recording.oracleCalls?.reduce(
+    (result as ACIRExecutionResult).oracles = recording.oracleCalls.reduce(
       (acc, { time, name }) => {
         if (!acc[name]) {
           acc[name] = { times: [] };

package/src/public/avm/avm_simulator.ts

@@ -63,7 +63,7 @@ export class AvmSimulator implements AvmSimulatorInterface {
   public static async build(context: AvmContext): Promise<AvmSimulator> {
     const simulator = new AvmSimulator(context);
     const fnName = await context.persistableState.getPublicFunctionDebugName(context.environment);
-    simulator.log = createLogger(`simulator:avm(f:${fnName})`);
+    simulator.log = createLogger(`simulator:avm(f:${fnName.slice(0, 128)})`);
 
     return simulator;
   }

package/src/public/avm/calldata.ts

@@ -33,13 +33,14 @@ export class LazyReaderMemory implements LazyReader {
   }
 
   public slice(start: number, end: number): Fr[] {
-    const clampedEnd = Math.min(end, this.size);
+    const clampedEnd = Math.min(end, this.size, TaggedMemory.MAX_MEMORY_SIZE - this.offset);
     const length = Math.max(0, clampedEnd - start);
     return this.memory.getSlice(this.offset + start, length).map(word => word.toFr());
   }
 
   public readAll(): Fr[] {
-    return this.memory.getSlice(this.offset, this.size).map(word => word.toFr());
+    const size = Math.min(this.size, TaggedMemory.MAX_MEMORY_SIZE - this.offset);
+    return this.memory.getSlice(this.offset, size).map(word => word.toFr());
   }
 
   public length(): number {

package/src/public/avm/fixtures/base_avm_simulation_tester.ts

@@ -2,9 +2,10 @@ import { CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
-import { getCanonicalAuthRegistry } from '@aztec/protocol-contracts/auth-registry';
+import { getCanonicalClassRegistry } from '@aztec/protocol-contracts/class-registry';
 import { computeFeePayerBalanceStorageSlot, getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
 import { getCanonicalInstanceRegistry } from '@aztec/protocol-contracts/instance-registry';
+import { getStandardAuthRegistry } from '@aztec/standard-contracts/auth-registry';
 import type { ContractArtifact } from '@aztec/stdlib/abi';
 import { PublicDataWrite } from '@aztec/stdlib/avm';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -91,7 +92,7 @@ export abstract class BaseAvmSimulationTester {
   }
 
   async registerAuthContract(): Promise<ContractInstanceWithAddress> {
-    const authRegistry = await getCanonicalAuthRegistry();
+    const authRegistry = await getStandardAuthRegistry();
     const authRegistryContractClassPublic = {
       ...authRegistry.contractClass,
       privateFunctions: [],
@@ -102,9 +103,28 @@ export abstract class BaseAvmSimulationTester {
       authRegistryContractClassPublic,
       authRegistry.instance,
     );
+    // AuthRegistry is a standard contract (not a protocol contract), so the AVM enforces a
+    // deployment-nullifier check on every instance retrieval. Insert the nullifier here so
+    // calls to AuthRegistry don't EXCEPTIONAL_HALT during simulation.
+    await this.insertContractAddressNullifier(authRegistry.instance.address);
     return authRegistry.instance;
   }
 
+  async registerClassRegistryContract(): Promise<ContractInstanceWithAddress> {
+    const classRegistry = await getCanonicalClassRegistry();
+    const classRegistryContractClassPublic = {
+      ...classRegistry.contractClass,
+      privateFunctions: [],
+      utilityFunctions: [],
+    };
+    await this.contractDataSource.addNewContract(
+      classRegistry.artifact,
+      classRegistryContractClassPublic,
+      classRegistry.instance,
+    );
+    return classRegistry.instance;
+  }
+
   async registerInstanceRegistryContract(): Promise<ContractInstanceWithAddress> {
     const instanceRegistry = await getCanonicalInstanceRegistry();
     const instanceRegistryContractClassPublic = {
@@ -129,7 +149,7 @@ export abstract class BaseAvmSimulationTester {
 
   private async insertContractAddressNullifier(contractAddress: AztecAddress) {
     const contractAddressNullifier = await siloNullifier(
-      AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
+      AztecAddress.fromNumberUnsafe(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
       contractAddress.toField(),
     );
     await this.merkleTrees.sequentialInsert(MerkleTreeId.NULLIFIER_TREE, [contractAddressNullifier.toBuffer()]);

package/src/public/avm/fixtures/utils.ts

@@ -128,22 +128,25 @@ export async function createContractClassAndInstance(
   const constructorAbi = getContractFunctionAbi('constructor', contractArtifact);
   const { publicKeys } = await deriveKeys(new Fr(seed));
   const initializationHash = await computeInitializationHash(constructorAbi, constructorArgs);
+  const immutablesHash = new Fr(seed + 1);
   const contractInstance =
     originalContractClassId === undefined
       ? await makeContractInstanceFromClassId(contractClass.id, seed, {
           deployer,
           initializationHash,
+          immutablesHash,
           publicKeys,
         })
       : await makeContractInstanceFromClassId(originalContractClassId, seed, {
           deployer,
           initializationHash,
           currentClassId: contractClass.id,
+          immutablesHash,
           publicKeys,
         });
 
   const contractAddressNullifier = await siloNullifier(
-    AztecAddress.fromNumber(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
+    AztecAddress.fromNumberUnsafe(CONTRACT_INSTANCE_REGISTRY_CONTRACT_ADDRESS),
     contractInstance.address.toField(),
   );
 

package/src/public/avm/opcodes/contract.ts

@@ -9,6 +9,7 @@ export enum ContractInstanceMember {
   DEPLOYER,
   CLASS_ID,
   INIT_HASH,
+  IMMUTABLES_HASH,
 }
 
 export class GetContractInstance extends Instruction {
@@ -41,7 +42,7 @@ export class GetContractInstance extends Instruction {
     );
 
     if (!(this.memberEnum in ContractInstanceMember)) {
-      throw new InstructionExecutionError(`Invalid GETCONSTRACTINSTANCE member enum ${this.memberEnum}`);
+      throw new InstructionExecutionError(`Invalid GETCONTRACTINSTANCE member enum ${this.memberEnum}`);
     }
 
     const operands = [this.addressOffset, this.dstOffset];
@@ -64,6 +65,9 @@ export class GetContractInstance extends Instruction {
         case ContractInstanceMember.INIT_HASH:
           memberValue = new Field(instance.initializationHash);
           break;
+        case ContractInstanceMember.IMMUTABLES_HASH:
+          memberValue = new Field(instance.immutablesHash);
+          break;
       }
     }
 

package/src/public/avm/opcodes/ec_add.ts

@@ -2,7 +2,7 @@ import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
 import { Point } from '@aztec/foundation/curves/grumpkin';
 
 import type { AvmContext } from '../avm_context.js';
-import { Field, TypeTag, Uint1 } from '../avm_memory_types.js';
+import { Field, TypeTag } from '../avm_memory_types.js';
 import { EcAddPointNotOnCurveError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
@@ -18,10 +18,8 @@ export class EcAdd extends Instruction {
     OperandType.UINT16, // indirect
     OperandType.UINT16, // p1X
     OperandType.UINT16, // p1Y
-    OperandType.UINT16, // p1IsInfinite
     OperandType.UINT16, // p2X
     OperandType.UINT16, // p2Y
-    OperandType.UINT16, // p2IsInfinite
     OperandType.UINT16, // dst
   ];
 
@@ -29,10 +27,8 @@ export class EcAdd extends Instruction {
     private addressingMode: number,
     private p1XOffset: number,
     private p1YOffset: number,
-    private p1IsInfiniteOffset: number,
     private p2XOffset: number,
     private p2YOffset: number,
-    private p2IsInfiniteOffset: number,
     private dstOffset: number,
   ) {
     super();
@@ -46,51 +42,38 @@ export class EcAdd extends Instruction {
       this.baseGasCost(addressing.indirectOperandsCount(), addressing.relativeOperandsCount()),
     );
 
-    const operands = [
-      this.p1XOffset,
-      this.p1YOffset,
-      this.p1IsInfiniteOffset,
-      this.p2XOffset,
-      this.p2YOffset,
-      this.p2IsInfiniteOffset,
-      this.dstOffset,
-    ];
-    const [p1XOffset, p1YOffset, p1IsInfiniteOffset, p2XOffset, p2YOffset, p2IsInfiniteOffset, dstOffset] =
-      addressing.resolve(operands, memory);
+    const operands = [this.p1XOffset, this.p1YOffset, this.p2XOffset, this.p2YOffset, this.dstOffset];
+    const [p1XOffset, p1YOffset, p2XOffset, p2YOffset, dstOffset] = addressing.resolve(operands, memory);
 
     memory.checkTags(TypeTag.FIELD, p1XOffset, p1YOffset, p2XOffset, p2YOffset);
-    memory.checkTags(TypeTag.UINT1, p1IsInfiniteOffset, p2IsInfiniteOffset);
 
     const p1X = memory.get(p1XOffset);
     const p1Y = memory.get(p1YOffset);
-    const p1IsInfinite = memory.get(p1IsInfiniteOffset).toNumber() === 1;
-    const p1 = new Point(p1X.toFr(), p1Y.toFr(), p1IsInfinite);
-    if (!p1.isOnGrumpkin()) {
+    const p1 = new Point(p1X.toFr(), p1Y.toFr());
+    if (!p1.isOnCurve()) {
       throw new EcAddPointNotOnCurveError(/*pointIndex=*/ 1, p1);
     }
 
     const p2X = memory.get(p2XOffset);
     const p2Y = memory.get(p2YOffset);
-    // unused. Point doesn't store this information
-    const p2IsInfinite = memory.get(p2IsInfiniteOffset).toNumber() === 1;
-    const p2 = new Point(p2X.toFr(), p2Y.toFr(), p2IsInfinite);
-    if (!p2.isOnGrumpkin()) {
+    const p2 = new Point(p2X.toFr(), p2Y.toFr());
+    if (!p2.isOnCurve()) {
       throw new EcAddPointNotOnCurveError(/*pointIndex=*/ 2, p2);
     }
 
     let dest;
-    if (p1IsInfinite && p2IsInfinite) {
-      dest = Point.ZERO;
-    } else if (p1IsInfinite) {
+    if (p1.isInfinite && p2.isInfinite) {
+      dest = Point.INFINITY;
+    } else if (p1.isInfinite) {
       dest = p2;
-    } else if (p2IsInfinite) {
+    } else if (p2.isInfinite) {
       dest = p1;
     } else {
       // TS<>BB ecc add communication is broken for points that add up to infinity.
       // However, here we know that both points are on the curve, and that none is infinity
       // so we can check for the case where you add p + (-p) = infinity.
       if (p1.x.equals(p2.x) && !p1.y.equals(p2.y)) {
-        dest = Point.ZERO;
+        dest = Point.INFINITY;
       } else {
         dest = await Grumpkin.add(p1, p2);
       }
@@ -99,7 +82,5 @@ export class EcAdd extends Instruction {
     // 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.setSlice(dstOffset + 2, [new Uint1(dest.equals(Point.ZERO) ? 1 : 0)]);
   }
 }

package/src/public/avm/opcodes/external_calls.ts

@@ -14,8 +14,8 @@ abstract class ExternalCall extends Instruction {
     OperandType.UINT16, // L2 gas offset
     OperandType.UINT16, // DA gas offset
     OperandType.UINT16, // Address offset
-    OperandType.UINT16, // Args offset
     OperandType.UINT16, // Args size offset
+    OperandType.UINT16, // Args offset
   ];
 
   constructor(

package/src/public/contracts_db_checkpoint.ts

@@ -31,7 +31,7 @@ export class ContractsDbCheckpoint {
     return this.bytecodeCommitments.get(classId.toString());
   }
 
-  public deepCopy(): ContractsDbCheckpoint {
+  public fork(): ContractsDbCheckpoint {
     const copy = new ContractsDbCheckpoint();
     this.instances.forEach((value, key) => copy.instances.set(key, value));
     this.classes.forEach((value, key) => copy.classes.set(key, value));

package/src/public/fixtures/amm_test.ts

@@ -25,8 +25,8 @@ export async function ammTest(
 ) {
   const timer = new Timer();
 
-  const admin = AztecAddress.fromNumber(42);
-  const sender = AztecAddress.fromNumber(111);
+  const admin = AztecAddress.fromNumberUnsafe(42);
+  const sender = AztecAddress.fromNumberUnsafe(111);
 
   logger.debug(`Deploying tokens`);
   const token0 = await setUpToken(tester, tokenArtifact, admin, expectToBeTrue, /*seed=*/ 0);

package/src/public/fixtures/bulk_test.ts

@@ -13,7 +13,7 @@ export async function bulkTest(
 ) {
   const timer = new Timer();
 
-  const deployer = AztecAddress.fromNumber(42);
+  const deployer = AztecAddress.fromNumberUnsafe(42);
   const avmTestContract = await tester.registerAndDeployContract(
     /*constructorArgs=*/ [],
     deployer,
@@ -25,14 +25,26 @@ export async function bulkTest(
   // Register multiple different protocol contracts (to ensure we don't dedup bytecode hashing events):
   await tester.registerAuthContract();
   await tester.registerInstanceRegistryContract();
+  await tester.registerClassRegistryContract();
 
   // Get a deployed contract instance to pass to the contract
   // for it to use as "expected" values when testing contract instance retrieval.
   const expectContractInstance = avmTestContract;
   const argsField = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
-  const argsU8 = [1, 2, 3, 4, 5, 6, 7, 8].map(x => new Fr(x));
-  argsU8.push(new Fr(2n ** 128n + 9n)); // Trigger truncation from large (> 128 bits) value (canonical decomposition event)
-  argsU8.push(new Fr(2n ** 125n + 10n)); // Trigger truncation from small (< 128 bits) value (no canonical decomposition event)
+  const argsU8 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
+  // Pinned grumpkin-Poseidon2 Schnorr signature (mirrors the C++ `pinned_test_vector_large`
+  // and noir-lang/schnorr v0.4.0's `pinned_vector_large`). Passing these in as calldata
+  // (rather than baking them into Noir as constants) keeps MSM + Poseidon2 from being folded
+  // by the Noir compiler.
+  const schnorrInputs = [
+    Fr.fromHexString('0x065812e335a97c2108ea8cf4ccfe2f9dd6b117a0714f5e18461575be93f61da6'), // pubkey.x
+    Fr.fromHexString('0x1a915003e8ec534f9a15d926a7ded478e178468ccc4f28e236e67450a55ac622'), // pubkey.y
+    Fr.fromHexString('0xf3bc3b7147acb9c621fd9f72dbf15ffa'), // sig_s.lo
+    Fr.fromHexString('0x08599f379f0301dfefdbd0272554454d'), // sig_s.hi
+    Fr.fromHexString('0x97065383ebbbd76620398792bd259bc2'), // sig_e.lo
+    Fr.fromHexString('0x2ceaee87f45b7a417f0ffb05451a8c92'), // sig_e.hi
+    Fr.fromHexString('0x0123456789abcdef0fedcba9876543210123456789abcdef0fedcba987654321'), // message
+  ];
   const args = [
     argsField,
     argsU8,
@@ -40,6 +52,8 @@ export async function bulkTest(
     /*expectedDeployer=*/ expectContractInstance.deployer,
     /*expectedClassId=*/ expectContractInstance.currentContractClassId,
     /*expectedInitializationHash=*/ expectContractInstance.initializationHash,
+    /*expectedImmutablesHash=*/ expectContractInstance.immutablesHash,
+    /*schnorrInputs=*/ schnorrInputs,
     /*skip_strictly_limited_side_effects=*/ false,
   ];
 
@@ -62,7 +76,7 @@ export async function bulkTest(
       {
         address: avmTestContract.address,
         fnName: 'assert_calldata_copy',
-        args: [argsField.slice(3), /* with_selector: */ true],
+        args: [argsField.slice(0, 3), /* with_selector: */ true],
       },
       {
         address: avmTestContract.address,
@@ -100,7 +114,7 @@ export async function megaBulkTest(
 ) {
   const timer = new Timer();
 
-  const deployer = AztecAddress.fromNumber(42);
+  const deployer = AztecAddress.fromNumberUnsafe(42);
   const avmTestContract = await tester.registerAndDeployContract(
     /*constructorArgs=*/ [],
     deployer,
@@ -123,6 +137,15 @@ export async function megaBulkTest(
   //const argsField7 = [15, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
   //const argsField8 = [17, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
   const argsU8 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].map(x => new Fr(x));
+  const schnorrInputs = [
+    Fr.fromHexString('0x065812e335a97c2108ea8cf4ccfe2f9dd6b117a0714f5e18461575be93f61da6'), // pubkey.x
+    Fr.fromHexString('0x1a915003e8ec534f9a15d926a7ded478e178468ccc4f28e236e67450a55ac622'), // pubkey.y
+    Fr.fromHexString('0xf3bc3b7147acb9c621fd9f72dbf15ffa'), // sig_s.lo
+    Fr.fromHexString('0x08599f379f0301dfefdbd0272554454d'), // sig_s.hi
+    Fr.fromHexString('0x97065383ebbbd76620398792bd259bc2'), // sig_e.lo
+    Fr.fromHexString('0x2ceaee87f45b7a417f0ffb05451a8c92'), // sig_e.hi
+    Fr.fromHexString('0x0123456789abcdef0fedcba9876543210123456789abcdef0fedcba987654321'), // message
+  ];
   const genArgs = (argsField: Fr[]) => [
     argsField,
     argsU8,
@@ -130,6 +153,8 @@ export async function megaBulkTest(
     /*expectedDeployer=*/ expectContractInstance.deployer.toField(),
     /*expectedClassId=*/ expectContractInstance.currentContractClassId.toField(),
     /*expectedInitializationHash=*/ expectContractInstance.initializationHash.toField(),
+    /*expectedImmutablesHash=*/ expectContractInstance.immutablesHash.toField(),
+    /*schnorrInputs=*/ schnorrInputs,
     // Must skip strictly limited side effects (logs, messages) so we can spam the bulk test several times.
     /*skip_strictly_limited_side_effects=*/ true,
   ];

package/src/public/fixtures/custom_bytecode_tester.ts

@@ -17,7 +17,7 @@ export async function deployCustomBytecode(
   bytecode: Buffer,
   tester: PublicTxSimulationTester,
   contractName: string = 'CustomBytecodeContract',
-  deployer: AztecAddress = AztecAddress.fromNumber(42),
+  deployer: AztecAddress = AztecAddress.fromNumberUnsafe(42),
 ): Promise<ContractInstanceWithAddress> {
   const contractArtifact = emptyContractArtifact();
   contractArtifact.name = contractName;
@@ -75,7 +75,7 @@ export async function deployAndExecuteCustomBytecode(
   tester: PublicTxSimulationTester,
   txLabel: string = 'CustomBytecodeTest',
   contractName: string = 'CustomBytecodeContract',
-  deployer: AztecAddress = AztecAddress.fromNumber(42),
+  deployer: AztecAddress = AztecAddress.fromNumberUnsafe(42),
   calldata: any[] = [],
 ): Promise<PublicTxResult> {
   const testContract = await deployCustomBytecode(bytecode, tester, contractName, deployer);