@aztec/simulator 0.42.0 → 0.44.0

package/src/avm/opcodes/memory.ts

@@ -114,12 +114,17 @@ export class CMov extends Instruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const a = memory.get(this.aOffset);
-    const b = memory.get(this.bOffset);
-    const cond = memory.get(this.condOffset);
+    const [aOffset, bOffset, condOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.aOffset, this.bOffset, this.condOffset, this.dstOffset],
+      memory,
+    );
+
+    const a = memory.get(aOffset);
+    const b = memory.get(bOffset);
+    const cond = memory.get(condOffset);
 
     // TODO: reconsider toBigInt() here
-    memory.set(this.dstOffset, cond.toBigInt() > 0 ? a : b);
+    memory.set(dstOffset, cond.toBigInt() > 0 ? a : b);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
@@ -130,8 +135,8 @@ export class Cast extends TwoOperandInstruction {
   static readonly type: string = 'CAST';
   static readonly opcode = Opcode.CAST;
 
-  constructor(indirect: number, dstTag: number, aOffset: number, dstOffset: number) {
-    super(indirect, dstTag, aOffset, dstOffset);
+  constructor(indirect: number, dstTag: number, srcOffset: number, dstOffset: number) {
+    super(indirect, dstTag, srcOffset, dstOffset);
   }
 
   public async execute(context: AvmContext): Promise<void> {
@@ -139,13 +144,14 @@ export class Cast extends TwoOperandInstruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const a = memory.get(this.aOffset);
+    const [srcOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.aOffset, this.dstOffset], memory);
+
+    const a = memory.get(srcOffset);
 
-    // TODO: consider not using toBigInt()
     const casted =
       this.inTag == TypeTag.FIELD ? new Field(a.toBigInt()) : TaggedMemory.integralFromTag(a.toBigInt(), this.inTag);
 
-    memory.set(this.dstOffset, casted);
+    memory.set(dstOffset, casted);
 
     memory.assert(memoryOperations);
     context.machineState.incrementPc();
@@ -204,10 +210,11 @@ export class CalldataCopy extends Instruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const [dstOffset] = Addressing.fromWire(this.indirect).resolve([this.dstOffset], memory);
+    // We don't need to check tags here because: (1) the calldata is NOT in memory, and (2) we are the ones writing to destination.
+    const [cdOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.cdOffset, this.dstOffset], memory);
 
     const transformedData = context.environment.calldata
-      .slice(this.cdOffset, this.cdOffset + this.copySize)
+      .slice(cdOffset, cdOffset + this.copySize)
       .map(f => new Field(f));
 
     memory.setSlice(dstOffset, transformedData);

package/src/avm/opcodes/multi_scalar_mul.ts

@@ -0,0 +1,114 @@
+import { Fq, Point } from '@aztec/circuits.js';
+import { Grumpkin } from '@aztec/circuits.js/barretenberg';
+
+import { strict as assert } from 'assert';
+
+import { type AvmContext } from '../avm_context.js';
+import { Field, TypeTag } from '../avm_memory_types.js';
+import { InstructionExecutionError } from '../errors.js';
+import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
+import { Addressing } from './addressing_mode.js';
+import { Instruction } from './instruction.js';
+
+export class MultiScalarMul extends Instruction {
+  static type: string = 'MultiScalarMul';
+  static readonly opcode: Opcode = Opcode.MSM;
+
+  // Informs (de)serialization. See Instruction.deserialize.
+  static readonly wireFormat: OperandType[] = [
+    OperandType.UINT8 /* opcode */,
+    OperandType.UINT8 /* indirect */,
+    OperandType.UINT32 /* points vector offset */,
+    OperandType.UINT32 /* scalars vector offset */,
+    OperandType.UINT32 /* output offset (fixed triplet) */,
+    OperandType.UINT32 /* points length offset */,
+  ];
+
+  constructor(
+    private indirect: number,
+    private pointsOffset: number,
+    private scalarsOffset: number,
+    private outputOffset: number,
+    private pointsLengthOffset: number,
+  ) {
+    super();
+  }
+
+  public async execute(context: AvmContext): Promise<void> {
+    const memory = context.machineState.memory.track(this.type);
+    // Resolve indirects
+    const [pointsOffset, scalarsOffset, outputOffset] = Addressing.fromWire(this.indirect).resolve(
+      [this.pointsOffset, this.scalarsOffset, this.outputOffset],
+      memory,
+    );
+
+    // Length of the points vector should be U32
+    memory.checkTag(TypeTag.UINT32, this.pointsLengthOffset);
+    // Get the size of the unrolled (x, y , inf) points vector
+    const pointsReadLength = memory.get(this.pointsLengthOffset).toNumber();
+    assert(pointsReadLength % 3 === 0, 'Points vector offset should be a multiple of 3');
+    // 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)
+    for (let i = 0; i < numPoints; i++) {
+      const offset = pointsOffset + i * 3;
+      // Check (Field, Field)
+      memory.checkTagsRange(TypeTag.FIELD, offset, 2);
+      // Check Uint8 (inf flag)
+      memory.checkTag(TypeTag.UINT8, 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;
+    // Consume gas prior to performing work
+    const memoryOperations = {
+      reads: 1 + pointsReadLength + scalarReadLength /* points and scalars */,
+      writes: 3 /* output triplet */,
+      indirect: this.indirect,
+    };
+    context.machineState.consumeGas(this.gasCost(memoryOperations));
+    // Get the unrolled scalar (lo & hi) representing the scalars
+    const scalarsVector = memory.getSlice(scalarsOffset, scalarReadLength);
+    memory.checkTagsRange(TypeTag.FIELD, scalarsOffset, scalarReadLength);
+
+    // Now we need to reconstruct the points and scalars into something we can operate on.
+    const grumpkinPoints: Point[] = [];
+    for (let i = 0; i < numPoints; i++) {
+      const p: Point = new Point(pointsVector[3 * i].toFr(), pointsVector[3 * i + 1].toFr());
+      // Include this later when we have a standard for representing infinity
+      // const isInf = pointsVector[i + 2].toBoolean();
+
+      if (!p.isOnGrumpkin()) {
+        throw new InstructionExecutionError(`Point ${p.toString()} is not on the curve.`);
+      }
+      grumpkinPoints.push(p);
+    }
+    // The scalars are read from memory as Fr elements, which are limbs of Fq elements
+    // So we need to reconstruct them before performing the scalar multiplications
+    const scalarFqVector: Fq[] = [];
+    for (let i = 0; i < numPoints; i++) {
+      const scalarLo = scalarsVector[2 * i].toFr();
+      const scalarHi = scalarsVector[2 * i + 1].toFr();
+      const fqScalar = Fq.fromHighLow(scalarHi, scalarLo);
+      scalarFqVector.push(fqScalar);
+    }
+    // TODO: Is there an efficient MSM implementation in ts that we can replace this by?
+    const grumpkin = new Grumpkin();
+    // Zip the points and scalars into pairs
+    const [firstBaseScalarPair, ...rest]: Array<[Point, Fq]> = grumpkinPoints.map((p, idx) => [p, scalarFqVector[idx]]);
+    // Fold the points and scalars into a single point
+    // We have to ensure get the first point, since the identity element (point at infinity) isn't quite working in ts
+    const outputPoint = rest.reduce(
+      (acc, curr) => grumpkin.add(acc, grumpkin.mul(curr[0], curr[1])),
+      grumpkin.mul(firstBaseScalarPair[0], firstBaseScalarPair[1]),
+    );
+    const output = outputPoint.toFieldsWithInf().map(f => new Field(f));
+
+    memory.setSlice(outputOffset, output);
+
+    memory.assert(memoryOperations);
+    context.machineState.incrementPc();
+  }
+}

package/src/avm/opcodes/storage.ts

@@ -1,7 +1,7 @@
 import { Fr } from '@aztec/foundation/fields';
 
 import type { AvmContext } from '../avm_context.js';
-import { Field } from '../avm_memory_types.js';
+import { Field, TypeTag } from '../avm_memory_types.js';
 import { StaticCallAlterationError } from '../errors.js';
 import { Opcode, OperandType } from '../serialization/instruction_serialization.js';
 import { Addressing } from './addressing_mode.js';
@@ -31,8 +31,8 @@ export class SStore extends BaseStorageInstruction {
   static readonly type: string = 'SSTORE';
   static readonly opcode = Opcode.SSTORE;
 
-  constructor(indirect: number, srcOffset: number, /*temporary*/ srcSize: number, slotOffset: number) {
-    super(indirect, srcOffset, srcSize, slotOffset);
+  constructor(indirect: number, srcOffset: number, /*temporary*/ size: number, slotOffset: number) {
+    super(indirect, srcOffset, size, slotOffset);
   }
 
   public async execute(context: AvmContext): Promise<void> {
@@ -45,6 +45,8 @@ export class SStore extends BaseStorageInstruction {
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
     const [srcOffset, slotOffset] = Addressing.fromWire(this.indirect).resolve([this.aOffset, this.bOffset], memory);
+    memory.checkTag(TypeTag.FIELD, slotOffset);
+    memory.checkTagsRange(TypeTag.FIELD, srcOffset, this.size);
 
     const slot = memory.get(slotOffset).toFr();
     const data = memory.getSlice(srcOffset, this.size).map(field => field.toFr());
@@ -72,21 +74,19 @@ export class SLoad extends BaseStorageInstruction {
     const memory = context.machineState.memory.track(this.type);
     context.machineState.consumeGas(this.gasCost(memoryOperations));
 
-    const [aOffset, size, bOffset] = Addressing.fromWire(this.indirect).resolve(
-      [this.aOffset, this.size, this.bOffset],
-      memory,
-    );
+    const [slotOffset, dstOffset] = Addressing.fromWire(this.indirect).resolve([this.aOffset, this.bOffset], memory);
+    memory.checkTag(TypeTag.FIELD, slotOffset);
 
-    const slot = memory.get(aOffset);
+    const slot = memory.get(slotOffset);
 
     // Write each read value from storage into memory
-    for (let i = 0; i < size; i++) {
+    for (let i = 0; i < this.size; i++) {
       const data: Fr = await context.persistableState.readStorage(
         context.environment.storageAddress,
         new Fr(slot.toBigInt() + BigInt(i)),
       );
 
-      memory.set(bOffset + i, new Field(data));
+      memory.set(dstOffset + i, new Field(data));
     }
 
     context.machineState.incrementPc();

package/src/avm/serialization/bytecode_serialization.ts

@@ -1,4 +1,5 @@
 import { DAGasLeft, L2GasLeft } from '../opcodes/context_getters.js';
+import { EcAdd } from '../opcodes/ec_add.js';
 import { Keccak, Pedersen, Poseidon2, Sha256 } from '../opcodes/hashing.js';
 import type { Instruction } from '../opcodes/index.js';
 import {
@@ -52,6 +53,7 @@ import {
   Version,
   Xor,
 } from '../opcodes/index.js';
+import { MultiScalarMul } from '../opcodes/multi_scalar_mul.js';
 import { BufferCursor } from './buffer_cursor.js';
 import { Opcode } from './instruction_serialization.js';
 
@@ -137,10 +139,12 @@ const INSTRUCTION_SET = () =>
     [DebugLog.opcode, DebugLog],
 
     // Gadgets
+    [EcAdd.opcode, EcAdd],
     [Keccak.opcode, Keccak],
     [Poseidon2.opcode, Poseidon2],
     [Sha256.opcode, Sha256],
     [Pedersen.opcode, Pedersen],
+    [MultiScalarMul.opcode, MultiScalarMul],
     // Conversions
     [ToRadixLE.opcode, ToRadixLE],
   ]);

package/src/avm/serialization/instruction_serialization.ts

@@ -76,6 +76,8 @@ export enum Opcode {
   POSEIDON2,
   SHA256, // temp - may be removed, but alot of contracts rely on it
   PEDERSEN, // temp - may be removed, but alot of contracts rely on it
+  ECADD,
+  MSM,
   // Conversion
   TORADIXLE,
 }

package/src/avm/test_utils.ts

@@ -0,0 +1,53 @@
+import { Fr } from '@aztec/circuits.js';
+import { type ContractInstanceWithAddress } from '@aztec/types/contracts';
+
+import { type jest } from '@jest/globals';
+import { mock } from 'jest-mock-extended';
+
+import { type CommitmentsDB, type PublicContractsDB, type PublicStateDB } from '../public/db_interfaces.js';
+import { type PublicSideEffectTraceInterface } from '../public/side_effect_trace_interface.js';
+import { type HostStorage } from './journal/host_storage.js';
+
+export function mockGetBytecode(hs: HostStorage, bytecode: Buffer) {
+  (hs as jest.Mocked<HostStorage>).contractsDb.getBytecode.mockResolvedValue(bytecode);
+}
+
+export function mockTraceFork(trace: PublicSideEffectTraceInterface, nestedTrace?: PublicSideEffectTraceInterface) {
+  (trace as jest.Mocked<PublicSideEffectTraceInterface>).fork.mockReturnValue(
+    nestedTrace ?? mock<PublicSideEffectTraceInterface>(),
+  );
+}
+
+export function mockStorageRead(hs: HostStorage, value: Fr) {
+  (hs.publicStateDb as jest.Mocked<PublicStateDB>).storageRead.mockResolvedValue(value);
+}
+
+export function mockStorageReadWithMap(hs: HostStorage, mockedStorage: Map<bigint, Fr>) {
+  (hs.publicStateDb as jest.Mocked<PublicStateDB>).storageRead.mockImplementation((_address, slot) =>
+    Promise.resolve(mockedStorage.get(slot.toBigInt()) ?? Fr.ZERO),
+  );
+}
+
+export function mockNoteHashExists(hs: HostStorage, leafIndex: Fr, _value?: Fr) {
+  (hs.commitmentsDb as jest.Mocked<CommitmentsDB>).getCommitmentIndex.mockResolvedValue(leafIndex.toBigInt());
+}
+
+export function mockNullifierExists(hs: HostStorage, leafIndex: Fr, _value?: Fr) {
+  (hs.commitmentsDb as jest.Mocked<CommitmentsDB>).getNullifierIndex.mockResolvedValue(leafIndex.toBigInt());
+}
+
+export function mockL1ToL2MessageExists(hs: HostStorage, leafIndex: Fr, value: Fr, valueAtOtherIndices?: Fr) {
+  (hs.commitmentsDb as jest.Mocked<CommitmentsDB>).getL1ToL2LeafValue.mockImplementation((index: bigint) => {
+    if (index == leafIndex.toBigInt()) {
+      return Promise.resolve(value);
+    } else {
+      // any indices other than mockAtLeafIndex will return a different value
+      // (or undefined if no value is specified for other indices)
+      return Promise.resolve(valueAtOtherIndices!);
+    }
+  });
+}
+
+export function mockGetContractInstance(hs: HostStorage, contractInstance: ContractInstanceWithAddress) {
+  (hs.contractsDb as jest.Mocked<PublicContractsDB>).getContractInstance.mockResolvedValue(contractInstance);
+}

package/src/client/client_execution_context.ts

@@ -3,10 +3,12 @@ import {
   type AztecNode,
   EncryptedL2Log,
   EncryptedL2NoteLog,
+  Event,
+  L1EventPayload,
   L1NotePayload,
   Note,
   type NoteStatus,
-  TaggedNote,
+  TaggedLog,
   type UnencryptedL2Log,
 } from '@aztec/circuit-types';
 import {
@@ -19,8 +21,14 @@ import {
   type TxContext,
 } from '@aztec/circuits.js';
 import { Aes128 } from '@aztec/circuits.js/barretenberg';
-import { computePublicDataTreeLeafSlot, computeUniqueNoteHash, siloNoteHash } from '@aztec/circuits.js/hash';
-import { type FunctionAbi, type FunctionArtifact, countArgumentsSize } from '@aztec/foundation/abi';
+import { computeUniqueNoteHash, siloNoteHash } from '@aztec/circuits.js/hash';
+import {
+  EventSelector,
+  type FunctionAbi,
+  type FunctionArtifact,
+  type NoteSelector,
+  countArgumentsSize,
+} from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { pedersenHash } from '@aztec/foundation/crypto';
 import { Fr, GrumpkinScalar, type Point } from '@aztec/foundation/fields';
@@ -286,7 +294,7 @@ export class ClientExecutionContext extends ViewDataOracle {
    */
   public override notifyCreatedNote(
     storageSlot: Fr,
-    noteTypeId: Fr,
+    noteTypeId: NoteSelector,
     noteItems: Fr[],
     innerNoteHash: Fr,
     counter: number,
@@ -330,13 +338,15 @@ export class ClientExecutionContext extends ViewDataOracle {
 
   /**
    * Emit encrypted data
-   * @param encryptedNote - The encrypted data.
+   * @param contractAddress - The contract emitting the encrypted event.
+   * @param randomness - A value used to mask the contract address we are siloing with.
+   * @param encryptedEvent - The encrypted event data.
    * @param counter - The effects counter.
    */
-  public override emitEncryptedLog(
+  public override emitEncryptedEventLog(
     contractAddress: AztecAddress,
     randomness: Fr,
-    encryptedData: Buffer,
+    encryptedEvent: Buffer,
     counter: number,
   ) {
     // In some cases, we actually want to reveal the contract address we are siloing with:
@@ -345,7 +355,7 @@ export class ClientExecutionContext extends ViewDataOracle {
     const maskedContractAddress = randomness.isZero()
       ? contractAddress.toField()
       : pedersenHash([contractAddress, randomness], 0);
-    const encryptedLog = new CountedLog(new EncryptedL2Log(encryptedData, maskedContractAddress), counter);
+    const encryptedLog = new CountedLog(new EncryptedL2Log(encryptedEvent, maskedContractAddress), counter);
     this.encryptedLogs.push(encryptedLog);
   }
 
@@ -360,6 +370,34 @@ export class ClientExecutionContext extends ViewDataOracle {
     this.noteEncryptedLogs.push(encryptedLog);
   }
 
+  /**
+   * Encrypt an event
+   * @param contractAddress - The contract emitting the encrypted event.
+   * @param randomness - A value used to mask the contract address we are siloing with.
+   * @param eventTypeId - The type ID of the event (function selector).
+   * @param ovKeys - The outgoing viewing keys to use to encrypt.
+   * @param ivpkM - The master incoming viewing public key.
+   * @param preimage - The event preimage.
+   */
+  public override computeEncryptedEventLog(
+    contractAddress: AztecAddress,
+    randomness: Fr,
+    eventTypeId: Fr,
+    ovKeys: KeyValidationRequest,
+    ivpkM: Point,
+    preimage: Fr[],
+  ) {
+    const event = new Event(preimage);
+    const l1EventPayload = new L1EventPayload(event, contractAddress, randomness, EventSelector.fromField(eventTypeId));
+    const taggedEvent = new TaggedLog(l1EventPayload);
+
+    const ephSk = GrumpkinScalar.random();
+
+    const recipient = AztecAddress.random();
+
+    return taggedEvent.encrypt(ephSk, recipient, ivpkM, ovKeys);
+  }
+
   /**
    * Encrypt a note
    * @param contractAddress - The contract address of the note.
@@ -369,20 +407,23 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param ivpkM - The master incoming viewing public key.
    * @param preimage - The note preimage.
    */
-  public override computeEncryptedLog(
+  public override computeEncryptedNoteLog(
     contractAddress: AztecAddress,
     storageSlot: Fr,
-    noteTypeId: Fr,
+    noteTypeId: NoteSelector,
     ovKeys: KeyValidationRequest,
     ivpkM: Point,
     preimage: Fr[],
   ) {
     const note = new Note(preimage);
     const l1NotePayload = new L1NotePayload(note, contractAddress, storageSlot, noteTypeId);
-    const taggedNote = new TaggedNote(l1NotePayload);
+    const taggedNote = new TaggedLog(l1NotePayload);
 
     const ephSk = GrumpkinScalar.random();
 
+    // @todo This should be populated properly.
+    // Note that this encryption function SHOULD not be used, but is currently used
+    // as oracle for encrypted event logs.
     const recipient = AztecAddress.random();
 
     return taggedNote.encrypt(ephSk, recipient, ivpkM, ovKeys);
@@ -641,20 +682,13 @@ export class ClientExecutionContext extends ViewDataOracle {
    * @param numberOfElements - Number of elements to read from the starting storage slot.
    */
   public override async storageRead(startStorageSlot: Fr, numberOfElements: number): Promise<Fr[]> {
-    // TODO(#4320): This is a hack to work around not having directly access to the public data tree but
-    // still having access to the witnesses
-    const bn = await this.db.getBlockNumber();
-
     const values = [];
     for (let i = 0n; i < numberOfElements; i++) {
       const storageSlot = new Fr(startStorageSlot.value + i);
-      const leafSlot = computePublicDataTreeLeafSlot(this.callContext.storageContractAddress, storageSlot);
-      const witness = await this.db.getPublicDataTreeWitness(bn, leafSlot);
-      if (!witness) {
-        throw new Error(`No witness for slot ${storageSlot.toString()}`);
-      }
-      const value = witness.leafPreimage.value;
+
+      const value = await this.aztecNode.getPublicStorageAt(this.callContext.storageContractAddress, storageSlot);
       this.log.debug(`Oracle storage read: slot=${storageSlot.toString()} value=${value}`);
+
       values.push(value);
     }
     return values;

package/src/client/execution_note_cache.ts

@@ -63,7 +63,6 @@ export class ExecutionNoteCache {
       nullifiedNoteHashCounter = note.counter;
       this.newNotes.set(contractAddress.toBigInt(), notes);
     }
-
     return nullifiedNoteHashCounter;
   }
 

package/src/client/execution_result.ts

@@ -8,6 +8,7 @@ import {
   type UnencryptedL2Log,
 } from '@aztec/circuit-types';
 import { type IsEmpty, type PrivateCallStackItem, PublicCallRequest, sortByCounter } from '@aztec/circuits.js';
+import { type NoteSelector } from '@aztec/foundation/abi';
 import { type Fr } from '@aztec/foundation/fields';
 
 import { type ACVMField } from '../acvm/index.js';
@@ -21,7 +22,7 @@ export interface NoteAndSlot {
   /** The storage slot of the note. */
   storageSlot: Fr;
   /** The note type identifier. */
-  noteTypeId: Fr;
+  noteTypeId: NoteSelector;
 }
 
 export class CountedLog<TLog extends UnencryptedL2Log | EncryptedL2NoteLog | EncryptedL2Log> implements IsEmpty {

package/src/client/index.ts

@@ -1,3 +1,5 @@
 export * from './simulator.js';
 export * from './db_oracle.js';
 export * from './execution_result.js';
+export * from './pick_notes.js';
+export * from './execution_note_cache.js';

package/src/client/simulator.ts

@@ -5,6 +5,7 @@ import {
   type FunctionArtifact,
   FunctionSelector,
   FunctionType,
+  type NoteSelector,
   encodeArguments,
 } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
@@ -132,29 +133,31 @@ export class AcirSimulator {
    * @param nonce - The nonce of the note hash.
    * @param storageSlot - The storage slot.
    * @param noteTypeId - The note type identifier.
+   * @param computeNullifier - A flag indicating whether to compute the nullifier or just return 0.
    * @param note - The note.
    * @returns The nullifier.
    */
-  public async computeNoteHashAndNullifier(
+  public async computeNoteHashAndOptionallyANullifier(
     contractAddress: AztecAddress,
     nonce: Fr,
     storageSlot: Fr,
-    noteTypeId: Fr,
+    noteTypeId: NoteSelector,
+    computeNullifier: boolean,
     note: Note,
   ) {
     const artifact: FunctionArtifact | undefined = await this.db.getFunctionArtifactByName(
       contractAddress,
-      'compute_note_hash_and_nullifier',
+      'compute_note_hash_and_optionally_a_nullifier',
     );
     if (!artifact) {
       throw new Error(
-        `Mandatory implementation of "compute_note_hash_and_nullifier" missing in noir contract ${contractAddress.toString()}.`,
+        `Mandatory implementation of "compute_note_hash_and_optionally_a_nullifier" missing in noir contract ${contractAddress.toString()}.`,
       );
     }
 
-    if (artifact.parameters.length != 5) {
+    if (artifact.parameters.length != 6) {
       throw new Error(
-        `Expected 5 parameters in mandatory implementation of "compute_note_hash_and_nullifier", but found ${
+        `Expected 6 parameters in mandatory implementation of "compute_note_hash_and_optionally_a_nullifier", but found ${
           artifact.parameters.length
         } in noir contract ${contractAddress.toString()}.`,
       );
@@ -163,7 +166,7 @@ export class AcirSimulator {
     const maxNoteFields = (artifact.parameters[artifact.parameters.length - 1].type as ArrayType).length;
     if (maxNoteFields < note.items.length) {
       throw new Error(
-        `The note being processed has ${note.items.length} fields, while "compute_note_hash_and_nullifier" can only handle a maximum of ${maxNoteFields} fields. Please reduce the number of fields in your note.`,
+        `The note being processed has ${note.items.length} fields, while "compute_note_hash_and_optionally_a_nullifier" can only handle a maximum of ${maxNoteFields} fields. Please reduce the number of fields in your note.`,
       );
     }
 
@@ -175,7 +178,14 @@ export class AcirSimulator {
       selector: FunctionSelector.empty(),
       type: FunctionType.UNCONSTRAINED,
       isStatic: artifact.isStatic,
-      args: encodeArguments(artifact, [contractAddress, nonce, storageSlot, noteTypeId, extendedNoteItems]),
+      args: encodeArguments(artifact, [
+        contractAddress,
+        nonce,
+        storageSlot,
+        noteTypeId,
+        computeNullifier,
+        extendedNoteItems,
+      ]),
       returnTypes: artifact.returnTypes,
     };
 
@@ -201,12 +211,18 @@ export class AcirSimulator {
    * @param note - The note.
    * @returns The note hash.
    */
-  public async computeInnerNoteHash(contractAddress: AztecAddress, storageSlot: Fr, noteTypeId: Fr, note: Note) {
-    const { innerNoteHash } = await this.computeNoteHashAndNullifier(
+  public async computeInnerNoteHash(
+    contractAddress: AztecAddress,
+    storageSlot: Fr,
+    noteTypeId: NoteSelector,
+    note: Note,
+  ) {
+    const { innerNoteHash } = await this.computeNoteHashAndOptionallyANullifier(
       contractAddress,
       Fr.ZERO,
       storageSlot,
       noteTypeId,
+      false,
       note,
     );
     return innerNoteHash;

package/src/client/view_data_oracle.ts

@@ -42,6 +42,14 @@ export class ViewDataOracle extends TypedOracle {
     return Promise.resolve(this.contractAddress);
   }
 
+  public override getChainId(): Promise<Fr> {
+    return Promise.resolve(this.aztecNode.getChainId().then(id => new Fr(id)));
+  }
+
+  public override getVersion(): Promise<Fr> {
+    return Promise.resolve(this.aztecNode.getVersion().then(v => new Fr(v)));
+  }
+
   /**
    * Retrieve keys associated with a specific master public key and app address.
    * @param pkMHash - The master public key hash.

package/src/mocks/fixtures.ts

@@ -143,7 +143,8 @@ export class PublicExecutionResultBuilder {
       endGasLeft: Gas.test(),
       transactionFee: Fr.ZERO,
       calldata: [],
-      avmHints: AvmExecutionHints.empty(),
+      avmCircuitHints: AvmExecutionHints.empty(),
+      functionName: 'unknown',
       ...overrides,
     };
   }