@aztec/pxe 0.0.1-commit.96bb3f7 → 0.0.1-commit.993d240

package/src/contract_function_simulator/ephemeral_array_service.ts

@@ -0,0 +1,110 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+
+/** In-memory store for ephemeral arrays scoped to a single contract call frame. */
+export class EphemeralArrayService {
+  /**
+   * Maps a slot to the elements of the array stored at that slot. Each element is a serialized representation of
+   * the original type.
+   */
+  #arrays: Map<string, Fr[][]> = new Map();
+
+  /** Returns all elements in the array, or an empty array if uninitialized. */
+  readArrayAt(slot: Fr): Fr[][] {
+    return this.#arrays.get(slot.toString()) ?? [];
+  }
+
+  #setArray(slot: Fr, array: Fr[][]): void {
+    this.#arrays.set(slot.toString(), array);
+  }
+
+  /** Returns the number of elements in the array at the given slot. */
+  len(slot: Fr): number {
+    return this.readArrayAt(slot).length;
+  }
+
+  /** Appends an element to the array and returns the new length. */
+  push(slot: Fr, elements: Fr[]): number {
+    const array = this.readArrayAt(slot);
+    array.push(elements);
+    this.#setArray(slot, array);
+    return array.length;
+  }
+
+  /** Removes and returns the last element. Throws if empty. */
+  pop(slot: Fr): Fr[] {
+    const array = this.readArrayAt(slot);
+    if (array.length === 0) {
+      throw new Error(`Ephemeral array at slot ${slot} is empty`);
+    }
+    const element = array.pop()!;
+    this.#setArray(slot, array);
+    return element;
+  }
+
+  /** Returns the element at the given index. Throws if out of bounds. */
+  get(slot: Fr, index: number): Fr[] {
+    const array = this.readArrayAt(slot);
+    if (index < 0 || index >= array.length) {
+      throw new Error(
+        `Ephemeral array index ${index} out of bounds for array of length ${array.length} at slot ${slot}`,
+      );
+    }
+    return array[index];
+  }
+
+  /** Overwrites the element at the given index. Throws if out of bounds. */
+  set(slot: Fr, index: number, value: Fr[]): void {
+    const array = this.readArrayAt(slot);
+    if (index < 0 || index >= array.length) {
+      throw new Error(
+        `Ephemeral array index ${index} out of bounds for array of length ${array.length} at slot ${slot}`,
+      );
+    }
+    array[index] = value;
+  }
+
+  /** Removes the element at the given index, shifting subsequent elements backward. Throws if out of bounds. */
+  remove(slot: Fr, index: number): void {
+    const array = this.readArrayAt(slot);
+    if (index < 0 || index >= array.length) {
+      throw new Error(
+        `Ephemeral array index ${index} out of bounds for array of length ${array.length} at slot ${slot}`,
+      );
+    }
+    array.splice(index, 1);
+  }
+
+  /** Removes all elements from the array. */
+  clear(slot: Fr): void {
+    this.#arrays.delete(slot.toString());
+  }
+
+  /** Allocates a fresh, unused slot for a new ephemeral array. */
+  allocateSlot(): Fr {
+    let slot: Fr;
+    do {
+      slot = Fr.random();
+    } while (this.#arrays.has(slot.toString()));
+    return slot;
+  }
+
+  /** Creates a new ephemeral array pre-populated with the given elements and returns its slot. */
+  newArray(elements: Fr[][]): Fr {
+    const slot = this.allocateSlot();
+    this.#setArray(slot, elements);
+    return slot;
+  }
+
+  /** Copies `count` elements from the source array to the destination array (overwrites destination). */
+  copy(srcSlot: Fr, dstSlot: Fr, count: number): void {
+    const srcArray = this.readArrayAt(srcSlot);
+    if (count > srcArray.length) {
+      throw new Error(
+        `Cannot copy ${count} elements from ephemeral array of length ${srcArray.length} at slot ${srcSlot}`,
+      );
+    }
+    // Deep copy the elements to avoid aliasing
+    const copied = srcArray.slice(0, count).map(el => [...el]);
+    this.#setArray(dstSlot, copied);
+  }
+}

package/src/contract_function_simulator/execution_note_cache.ts

@@ -32,19 +32,22 @@ export class ExecutionNoteCache {
   private nullifierMap: Map<bigint, Set<bigint>> = new Map();
 
   /**
-   * All nullifiers emitted in this transaction.
+   * Nullifiers emitted by private calls in this transaction.
    */
-  private allNullifiers: Set<bigint> = new Set();
+  private emittedNullifiers: Set<bigint> = new Set();
 
+  /**
+   * The counter that separates non-revertible side effects (which persist even if the tx reverts) from revertible ones.
+   */
   private minRevertibleSideEffectCounter = 0;
 
   private inRevertiblePhase = false;
 
   /**
-   * We don't need to use the tx request hash for nonces if another non revertible nullifier is emitted.
-   * In that case we disable injecting the tx request hash as a nullifier.
+   * Whether the protocol nullifier was used for nonce generation.
+   * We don't need to use the protocol nullifier if a non-revertible nullifier is emitted.
    */
-  private usedProtocolNullifierForNonces = true;
+  private usedProtocolNullifierForNonces: boolean | undefined;
 
   constructor(private readonly protocolNullifier: Fr) {}
 
@@ -60,17 +63,18 @@ export class ExecutionNoteCache {
     }
     this.inRevertiblePhase = true;
     this.minRevertibleSideEffectCounter = minRevertibleSideEffectCounter;
-    let nonceGenerator = this.protocolNullifier;
-    const nullifiers = this.getAllNullifiers();
-    if (nullifiers.length > 0) {
-      nonceGenerator = new Fr(nullifiers[0]);
-      this.usedProtocolNullifierForNonces = false;
-    }
+
+    const nullifiers = this.getEmittedNullifiers();
+    // If there are no nullifiers emitted by private calls so far, we use the protocol nullifier as the nonce generator.
+    // Note: There could still be nullifiers emitted after the counter is set, but those nullifiers are revertible, so
+    // we don't want to use them as the nonce generator.
+    this.usedProtocolNullifierForNonces = nullifiers.length === 0;
+    const nonceGenerator = this.usedProtocolNullifierForNonces ? this.protocolNullifier : new Fr(nullifiers[0]);
 
     // The existing pending notes are all non-revertible.
     // They cannot be squashed by nullifiers emitted after minRevertibleSideEffectCounter is set.
     // Their indexes in the tx are known at this point and won't change. So we can assign a nonce to each one of them.
-    // The nonces will be used to create the "complete" nullifier.
+    // The nonces will be used to create the "unique" note hashes.
     const updatedNotes = await Promise.all(
       this.notes.map(async ({ note, counter }, i) => {
         const noteNonce = await computeNoteHashNonce(nonceGenerator, i);
@@ -99,15 +103,11 @@ export class ExecutionNoteCache {
   }
 
   public finish() {
-    // If we never entered the revertible phase, we need to use the protocol nullifier to compute the nonces for the
-    // notes if no nullifiers have been emitted.
+    // If we never entered the revertible phase, and there are no nullifiers emitted, we need to use the protocol
+    // nullifier as the nonce generator.
     if (!this.inRevertiblePhase) {
-      this.usedProtocolNullifierForNonces = this.getAllNullifiers().length === 0;
+      this.usedProtocolNullifierForNonces = this.getEmittedNullifiers().length === 0;
     }
-    // If we entered the revertible phase, the nonce generator was decided based on wether or not a nullifier was emitted before entering.
-    return {
-      usedProtocolNullifierForNonces: this.usedProtocolNullifierForNonces,
-    };
   }
 
   /**
@@ -150,11 +150,11 @@ export class ExecutionNoteCache {
 
       // If the note is non revertible and the nullifier was emitted in the revertible phase, both the note hash and the nullifier will be emitted
       if (this.inRevertiblePhase && note.counter < this.minRevertibleSideEffectCounter) {
-        this.recordNullifier(contractAddress, siloedNullifier);
+        this.#recordNullifier(contractAddress, siloedNullifier);
       }
     } else {
       // If the note being nullified comes from a previous tx the nullifier will be emitted.
-      this.recordNullifier(contractAddress, siloedNullifier);
+      this.#recordNullifier(contractAddress, siloedNullifier);
     }
     return nullifiedNoteHashCounter;
   }
@@ -166,7 +166,7 @@ export class ExecutionNoteCache {
    */
   public async nullifierCreated(contractAddress: AztecAddress, innerNullifier: Fr) {
     const siloedNullifier = (await siloNullifier(contractAddress, innerNullifier)).toBigInt();
-    this.recordNullifier(contractAddress, siloedNullifier);
+    this.#recordNullifier(contractAddress, siloedNullifier);
   }
 
   /**
@@ -215,11 +215,30 @@ export class ExecutionNoteCache {
     return this.notes;
   }
 
+  /**
+   * @returns All nullifiers emitted by private calls in this transaction.
+   */
+  getEmittedNullifiers(): Fr[] {
+    return [...this.emittedNullifiers].map(n => new Fr(n));
+  }
+
+  /**
+   * @returns All nullifiers emitted by private calls in this transaction. If the protocol nullifier was used as the
+   * nonce generator, it is injected as the first nullifier.
+   */
   getAllNullifiers(): Fr[] {
-    return [...this.allNullifiers].map(n => new Fr(n));
+    if (this.usedProtocolNullifierForNonces === undefined) {
+      throw new Error('usedProtocolNullifierForNonces is not set yet. Call finish() to complete the transaction.');
+    }
+    const allNullifiers = this.getEmittedNullifiers();
+    return [...(this.usedProtocolNullifierForNonces ? [this.protocolNullifier] : []), ...allNullifiers];
+  }
+
+  getNonceGenerator(): Fr {
+    return this.getAllNullifiers()[0];
   }
 
-  recordNullifier(contractAddress: AztecAddress, siloedNullifier: bigint) {
+  #recordNullifier(contractAddress: AztecAddress, siloedNullifier: bigint) {
     const nullifiers = this.getNullifiers(contractAddress);
 
     if (nullifiers.has(siloedNullifier)) {
@@ -228,6 +247,6 @@ export class ExecutionNoteCache {
 
     nullifiers.add(siloedNullifier);
     this.nullifierMap.set(contractAddress.toBigInt(), nullifiers);
-    this.allNullifiers.add(siloedNullifier);
+    this.emittedNullifiers.add(siloedNullifier);
   }
 }

package/src/contract_function_simulator/execution_tagging_index_cache.ts

@@ -1,32 +1,33 @@
-import { DirectionalAppTaggingSecret, type PreTag } from '@aztec/stdlib/logs';
+import { AppTaggingSecret, type TaggingIndexRange } from '@aztec/stdlib/logs';
 
-/**
- * A map that stores the tagging index for a given directional app tagging secret.
- * Note: The directional app tagging secret is unique for a (sender, recipient, contract) tuple while the direction
- * of sender -> recipient matters.
- */
+/** A map that stores the tagging index range for a given app tagging secret. */
 export class ExecutionTaggingIndexCache {
-  private taggingIndexMap: Map<string, number> = new Map();
+  private taggingIndexMap: Map<string, { lowestIndex: number; highestIndex: number }> = new Map();
 
-  public getLastUsedIndex(secret: DirectionalAppTaggingSecret): number | undefined {
-    return this.taggingIndexMap.get(secret.toString());
+  public getLastUsedIndex(secret: AppTaggingSecret): number | undefined {
+    return this.taggingIndexMap.get(secret.toString())?.highestIndex;
   }
 
-  public setLastUsedIndex(secret: DirectionalAppTaggingSecret, index: number) {
+  public setLastUsedIndex(secret: AppTaggingSecret, index: number) {
     const currentValue = this.taggingIndexMap.get(secret.toString());
-    if (currentValue !== undefined && currentValue !== index - 1) {
-      throw new Error(`Invalid tagging index update. Current value: ${currentValue}, new value: ${index}`);
+    if (currentValue !== undefined && currentValue.highestIndex !== index - 1) {
+      throw new Error(`Invalid tagging index update. Current value: ${currentValue.highestIndex}, new value: ${index}`);
+    }
+    if (currentValue !== undefined) {
+      currentValue.highestIndex = index;
+    } else {
+      this.taggingIndexMap.set(secret.toString(), { lowestIndex: index, highestIndex: index });
     }
-    this.taggingIndexMap.set(secret.toString(), index);
   }
 
   /**
-   * Returns the pre-tags that were used in this execution (and that need to be stored in the db).
+   * Returns the tagging index ranges that were used in this execution (and that need to be stored in the db).
    */
-  public getUsedPreTags(): PreTag[] {
-    return Array.from(this.taggingIndexMap.entries()).map(([secret, index]) => ({
-      secret: DirectionalAppTaggingSecret.fromString(secret),
-      index,
+  public getUsedTaggingIndexRanges(): TaggingIndexRange[] {
+    return Array.from(this.taggingIndexMap.entries()).map(([secret, { lowestIndex, highestIndex }]) => ({
+      extendedSecret: AppTaggingSecret.fromString(secret),
+      lowestIndex,
+      highestIndex,
     }));
   }
 }

package/src/contract_function_simulator/index.ts

@@ -4,10 +4,13 @@ export { HashedValuesCache } from './hashed_values_cache.js';
 export { pickNotes } from './pick_notes.js';
 export type { NoteData, IMiscOracle, IUtilityExecutionOracle, IPrivateExecutionOracle } from './oracle/interfaces.js';
 export { MessageLoadOracleInputs } from './oracle/message_load_oracle_inputs.js';
+export { MessageContextService } from '../messages/message_context_service.js';
 export { UtilityExecutionOracle } from './oracle/utility_execution_oracle.js';
 export { PrivateExecutionOracle } from './oracle/private_execution_oracle.js';
 export { Oracle } from './oracle/oracle.js';
 export { executePrivateFunction, extractPrivateCircuitPublicInputs } from './oracle/private_execution.js';
 export { generateSimulatedProvingResult } from './contract_function_simulator.js';
-export { packAsRetrievedNote } from './oracle/note_packing_utils.js';
+export { packAsHintedNote } from './oracle/note_packing_utils.js';
+export { BoundedVec } from './noir-structs/bounded_vec.js';
+export { Option } from './noir-structs/option.js';
 export { UtilityContext } from './noir-structs/utility_context.js';

package/src/contract_function_simulator/noir-structs/bounded_vec.ts

@@ -0,0 +1,55 @@
+/**
+ * TypeScript counterpart of Noir's `BoundedVec<T, MaxLen>`.
+ *
+ * Carries the actual `data` plus wire-format metadata (`maxLength`, `elementSize`) so the ACVM
+ * serializer can pad the storage slot to exactly `maxLength * elementSize` fields.
+ */
+export class BoundedVec<T> {
+  private constructor(
+    public readonly data: T[],
+    public readonly maxLength: number,
+    public readonly elementSize: number,
+  ) {}
+
+  /**
+   * Construct a BoundedVec with data.
+   *
+   * @param data - Actual elements. Length must be `<= maxLength`.
+   * @param maxLength - Maximum capacity declared at the Noir call site.
+   *   The storage slot is padded to this many elements.
+   * @param elementSize - Number of Fr fields each element contributes when serialized.
+   *   `1` for scalar elements (u8, Field) — this is the default.
+   *   `> 1` for compound elements (e.g. a packed note that spans multiple fields).
+   *
+   * @example A bounded vec of bytes (elementSize defaults to 1):
+   * ```ts
+   * BoundedVec.from({ data: plaintext, maxLength: ciphertext.maxLength })
+   * ```
+   *
+   * @example A bounded vec of packed notes, each spanning `packedHintedNoteLength` fields:
+   * ```ts
+   * BoundedVec.from({ data: notes, maxLength: maxNotes, elementSize: packedHintedNoteLength })
+   * ```
+   */
+  static from<T>({
+    data,
+    maxLength,
+    elementSize = 1,
+  }: {
+    data: T[];
+    maxLength: number;
+    elementSize?: number;
+  }): BoundedVec<T> {
+    return new BoundedVec<T>(data, maxLength, elementSize);
+  }
+
+  /**
+   * Construct an empty BoundedVec, typically used as a shape template for `Option.empty(...)`.
+   *
+   * @param maxLength - Maximum capacity declared at the Noir call site.
+   * @param elementSize - Number of Fr fields each element contributes when serialized (default 1).
+   */
+  static empty<T>({ maxLength, elementSize = 1 }: { maxLength: number; elementSize?: number }): BoundedVec<T> {
+    return new BoundedVec<T>([], maxLength, elementSize);
+  }
+}

package/src/contract_function_simulator/noir-structs/event_validation_request.ts

@@ -4,12 +4,9 @@ import { EventSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { TxHash } from '@aztec/stdlib/tx';
 
-// TODO(#14617): should we compute this from constants? This value is aztec-nr specific.
-const MAX_EVENT_SERIALIZED_LEN = 12;
-
 /**
- * Intermediate struct used to perform batch event validation by PXE. The `utilityValidateEnqueuedNotesAndEvents` oracle
- * expects for values of this type to be stored in a `CapsuleArray`.
+ * Intermediate struct used to perform batch event validation by PXE. The `utilityValidateAndStoreEnqueuedNotesAndEvents` oracle
+ * expects for values of this type to be stored in a `EphemeralArray`.
  */
 export class EventValidationRequest {
   constructor(
@@ -19,10 +16,9 @@ export class EventValidationRequest {
     public serializedEvent: Fr[],
     public eventCommitment: Fr,
     public txHash: TxHash,
-    public recipient: AztecAddress,
   ) {}
 
-  static fromFields(fields: Fr[] | FieldReader): EventValidationRequest {
+  static fromFields(fields: Fr[]): EventValidationRequest {
     const reader = FieldReader.asReader(fields);
 
     const contractAddress = AztecAddress.fromField(reader.readField());
@@ -30,13 +26,19 @@ export class EventValidationRequest {
 
     const randomness = reader.readField();
 
-    const eventStorage = reader.readFieldArray(MAX_EVENT_SERIALIZED_LEN);
+    const maxEventSerializedLen = reader.readField().toNumber();
+    const eventStorage = reader.readFieldArray(maxEventSerializedLen);
     const eventLen = reader.readField().toNumber();
     const serializedEvent = eventStorage.slice(0, eventLen);
 
     const eventCommitment = reader.readField();
     const txHash = TxHash.fromField(reader.readField());
-    const recipient = AztecAddress.fromField(reader.readField());
+
+    if (reader.remainingFields() !== 0) {
+      throw new Error(
+        `Error converting array of fields to EventValidationRequest: expected ${reader.cursor} fields but received ${fields.length} (maxEventSerializedLen=${maxEventSerializedLen}).`,
+      );
+    }
 
     return new EventValidationRequest(
       contractAddress,
@@ -45,7 +47,6 @@ export class EventValidationRequest {
       serializedEvent,
       eventCommitment,
       txHash,
-      recipient,
     );
   }
 }

package/src/contract_function_simulator/noir-structs/log_retrieval_request.ts

@@ -1,20 +1,39 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { FieldReader } from '@aztec/foundation/serialize';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { Tag } from '@aztec/stdlib/logs';
 
+/** Discriminant for which log source to query. */
+export enum LogSource {
+  PRIVATE = 0,
+  PUBLIC = 1,
+  PUBLIC_AND_PRIVATE = 2,
+}
+
 /**
  * Intermediate struct used to perform batch log retrieval by PXE. The `utilityBulkRetrieveLogs` oracle expects values of this
- * type to be stored in a `CapsuleArray`.
+ * type to be stored in a `EphemeralArray`.
  */
 export class LogRetrievalRequest {
   constructor(
     public contractAddress: AztecAddress,
     public tag: Tag,
+    public source: LogSource = LogSource.PUBLIC_AND_PRIVATE,
+    public fromBlock?: BlockNumber,
+    public toBlock?: BlockNumber,
   ) {}
 
   toFields(): Fr[] {
-    return [this.contractAddress.toField(), this.tag.value];
+    return [
+      this.contractAddress.toField(),
+      this.tag.value,
+      new Fr(this.source),
+      new Fr(this.fromBlock !== undefined ? 1 : 0),
+      new Fr(this.fromBlock ?? 0),
+      new Fr(this.toBlock !== undefined ? 1 : 0),
+      new Fr(this.toBlock ?? 0),
+    ];
   }
 
   static fromFields(fields: Fr[] | FieldReader): LogRetrievalRequest {
@@ -22,7 +41,21 @@ export class LogRetrievalRequest {
 
     const contractAddress = AztecAddress.fromField(reader.readField());
     const tag = new Tag(reader.readField());
+    const sourceNum = reader.readField().toNumber();
+    if (!(sourceNum in LogSource)) {
+      const validNames = Object.keys(LogSource).filter(k => isNaN(Number(k)));
+      throw new Error(`Invalid LogSource value ${sourceNum}, expected one of ${validNames.join(', ')}`);
+    }
+    const source = sourceNum as LogSource;
+
+    const fromBlockIsSome = reader.readBoolean();
+    const fromBlockValue = reader.readField();
+    const fromBlock = fromBlockIsSome ? BlockNumber(fromBlockValue.toNumber()) : undefined;
+
+    const toBlockIsSome = reader.readBoolean();
+    const toBlockValue = reader.readField();
+    const toBlock = toBlockIsSome ? BlockNumber(toBlockValue.toNumber()) : undefined;
 
-    return new LogRetrievalRequest(contractAddress, tag);
+    return new LogRetrievalRequest(contractAddress, tag, source, fromBlock, toBlock);
   }
 }

package/src/contract_function_simulator/noir-structs/log_retrieval_response.ts

@@ -3,14 +3,11 @@ import { range } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { TxHash } from '@aztec/stdlib/tx';
 
-import { MAX_NOTE_PACKED_LEN } from './note_validation_request.js';
-
-const MAX_PUBLIC_LOG_LEN_FOR_NOTE_COMPLETION = MAX_NOTE_PACKED_LEN;
-const MAX_LOG_CONTENT_LEN = Math.max(MAX_PUBLIC_LOG_LEN_FOR_NOTE_COMPLETION, PRIVATE_LOG_CIPHERTEXT_LEN);
+const MAX_LOG_CONTENT_LEN = PRIVATE_LOG_CIPHERTEXT_LEN;
 
 /**
  * Intermediate struct used to perform batch log retrieval by PXE. The `utilityBulkRetrieveLogs` oracle stores values of this
- * type in a `CapsuleArray`.
+ * type in a `EphemeralArray`.
  */
 export class LogRetrievalResponse {
   constructor(

package/src/contract_function_simulator/noir-structs/note_validation_request.ts

@@ -3,12 +3,9 @@ import { FieldReader } from '@aztec/foundation/serialize';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { TxHash } from '@aztec/stdlib/tx';
 
-// TODO(#14617): should we compute this from constants? This value is aztec-nr specific.
-export const MAX_NOTE_PACKED_LEN = 10;
-
 /**
- * Intermediate struct used to perform batch note validation by PXE. The `utilityValidateEnqueuedNotesAndEvents` oracle
- * expects for values of this type to be stored in a `CapsuleArray`.
+ * Intermediate struct used to perform batch note validation by PXE. The `utilityValidateAndStoreEnqueuedNotesAndEvents` oracle
+ * expects for values of this type to be stored in a `EphemeralArray`.
  */
 export class NoteValidationRequest {
   constructor(
@@ -21,10 +18,9 @@ export class NoteValidationRequest {
     public noteHash: Fr,
     public nullifier: Fr,
     public txHash: TxHash,
-    public recipient: AztecAddress,
   ) {}
 
-  static fromFields(fields: Fr[] | FieldReader): NoteValidationRequest {
+  static fromFields(fields: Fr[]): NoteValidationRequest {
     const reader = FieldReader.asReader(fields);
 
     const contractAddress = AztecAddress.fromField(reader.readField());
@@ -33,18 +29,18 @@ export class NoteValidationRequest {
     const randomness = reader.readField();
     const noteNonce = reader.readField();
 
-    const contentStorage = reader.readFieldArray(MAX_NOTE_PACKED_LEN);
+    const maxNotePackedLen = reader.readField().toNumber();
+    const contentStorage = reader.readFieldArray(maxNotePackedLen);
     const contentLen = reader.readField().toNumber();
     const content = contentStorage.slice(0, contentLen);
 
     const noteHash = reader.readField();
     const nullifier = reader.readField();
     const txHash = TxHash.fromField(reader.readField());
-    const recipient = AztecAddress.fromField(reader.readField());
 
     if (reader.remainingFields() !== 0) {
       throw new Error(
-        `Error converting array of fields to NoteValidationRequest. Hint: check that MAX_NOTE_PACKED_LEN is consistent with private_notes::MAX_NOTE_PACKED_LEN in Aztec-nr.`,
+        `Error converting array of fields to NoteValidationRequest: expected ${reader.cursor} fields but received ${fields.length} (maxNotePackedLen=${maxNotePackedLen}).`,
       );
     }
 
@@ -58,7 +54,6 @@ export class NoteValidationRequest {
       noteHash,
       nullifier,
       txHash,
-      recipient,
     );
   }
 }

package/src/contract_function_simulator/noir-structs/option.ts

@@ -0,0 +1,69 @@
+/**
+ * TypeScript counterpart of Noir's `Option<T>`.
+ *
+ * Wraps a value that may or may not be present. Use {@link Option.some} to wrap a present value and
+ * {@link Option.none} for an absent one. The type guards {@link isSome} and {@link isNone} narrow
+ * `value` in conditional branches.
+ */
+export class Option<T> {
+  private constructor(
+    public readonly value: T | undefined,
+    public readonly template: T | undefined,
+  ) {}
+
+  /**
+   * Wrap a present value.
+   *
+   * @example
+   * ```ts
+   * return Option.some(values);
+   * ```
+   */
+  static some<T>(value: T): Option<T> {
+    return new Option<T>(value, undefined);
+  }
+
+  /**
+   * Construct an absent Option.
+   *
+   * When serialized back to ACVM, the `None` case must produce the same number of fields as `Some`.
+   * For types whose wire size varies per call site (`BoundedVec`, `FixedArray`), pass a `template` so the
+   * serializer knows how many zero fields to emit. Omit the template when the Option will not be
+   * re-serialized (e.g. deserialized input params).
+   *
+   * @param template - A representative empty `T` whose serialization determines the zero-filled wire format.
+   *
+   * @example None for a fixed-size type:
+   * ```ts
+   * return Option.none(AztecAddress.ZERO);
+   * ```
+   *
+   * @example None for a dynamic-size type:
+   * ```ts
+   * return Option.none(BoundedVec.empty<number>({ maxLength: ciphertext.maxLength }));
+   * ```
+   */
+  static none<T>(template?: T): Option<T> {
+    return new Option<T>(undefined, template);
+  }
+
+  /**
+   * Type guard: narrows `value` to `T` in the truthy branch.
+   *
+   * @example
+   * ```ts
+   * const opt = await handler.getSenderForTags();
+   * if (opt.isSome()) {
+   *   console.log(opt.value); // narrowed to T
+   * }
+   * ```
+   */
+  isSome(): this is Option<T> & { value: T } {
+    return this.value !== undefined;
+  }
+
+  /** Type guard: narrows `value` to `undefined` in the truthy branch. */
+  isNone(): this is Option<T> & { value: undefined } {
+    return this.value === undefined;
+  }
+}