@aztec-labs/pxe 6.0.0-nightly.20260829

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

@@ -0,0 +1,52 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { FieldReader } from '@aztec-labs/foundation/serialize';
+import { EventSelector } from '@aztec-labs/stdlib/abi';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { TxHash } from '@aztec-labs/stdlib/tx';
+
+/**
+ * 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(
+    public contractAddress: AztecAddress,
+    public eventTypeId: EventSelector,
+    public randomness: Fr,
+    public serializedEvent: Fr[],
+    public eventCommitment: Fr,
+    public txHash: TxHash,
+  ) {}
+
+  static fromFields(fields: Fr[] | FieldReader): EventValidationRequest {
+    const reader = FieldReader.asReader(fields);
+
+    const contractAddress = AztecAddress.fromFieldUnsafe(reader.readField());
+    const eventTypeId = EventSelector.fromField(reader.readField());
+
+    const randomness = reader.readField();
+
+    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());
+
+    if (reader.remainingFields() !== 0) {
+      throw new Error(
+        `Error converting array of fields to EventValidationRequest: expected ${reader.cursor} fields but received ${reader.cursor + reader.remainingFields()} (maxEventSerializedLen=${maxEventSerializedLen}).`,
+      );
+    }
+
+    return new EventValidationRequest(
+      contractAddress,
+      eventTypeId,
+      randomness,
+      serializedEvent,
+      eventCommitment,
+      txHash,
+    );
+  }
+}

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

@@ -0,0 +1,13 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+
+import type { RetractableFactOrigin } from '../../storage/fact_store/index.js';
+import type { EphemeralArray } from './ephemeral_array.js';
+import type { Option } from './option.js';
+
+/**
+ * A single fact returned within a fact collection by the fact store oracles.
+ *
+ * A TS version of the `Fact` struct in `facts/mod.nr`. `originBlock` is `Some` for a retractable fact (carrying its
+ * origin block's current chain state) and `None` for a non-retractable one.
+ */
+export type Fact = { factTypeId: Fr; payload: EphemeralArray<Fr>; originBlock: Option<RetractableFactOrigin> };

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

@@ -0,0 +1,64 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+
+import type { FactWithOriginState, RetractableFactOrigin } from '../../storage/fact_store/index.js';
+import { OriginBlockState } from '../../storage/fact_store/index.js';
+import type { EphemeralArrayService } from '../ephemeral_array_service.js';
+import { EphemeralArray } from './ephemeral_array.js';
+import type { Fact } from './fact.js';
+import { Option } from './option.js';
+
+/**
+ * A fact collection.
+ */
+export type FactCollection = {
+  contractAddress: AztecAddress;
+  scope: AztecAddress;
+  factCollectionTypeId: Fr;
+  factCollectionId: Fr;
+  facts: EphemeralArray<Fact>;
+};
+
+/**
+ * Builds the Noir-facing `FactCollection` from stored facts.
+ */
+export function toNoirFactCollection(
+  service: EphemeralArrayService,
+  contractAddress: AztecAddress,
+  scope: AztecAddress,
+  factCollectionTypeId: Fr,
+  factCollectionId: Fr,
+  facts: FactWithOriginState[],
+): FactCollection {
+  return {
+    contractAddress,
+    scope,
+    factCollectionTypeId,
+    factCollectionId,
+    facts: EphemeralArray.fromValues(
+      service,
+      facts.map(
+        (fact: FactWithOriginState): Fact => ({
+          factTypeId: fact.factTypeId,
+          payload: EphemeralArray.fromValues(service, fact.payload),
+          originBlock: fact.originBlock
+            ? Option.some(fact.originBlock)
+            : Option.none<RetractableFactOrigin>({
+                blockNumber: 0,
+                blockHash: Fr.ZERO,
+                blockState: OriginBlockState.Pending,
+              }),
+        }),
+      ),
+    ),
+  };
+}
+
+/**
+ * A zeroed `FactCollection` used only as a serialization shape template for the `None` case of
+ * `Option<FactCollection>`. Noir's `Option<T>` is fixed-width on the wire, so `None` must emit the same number of
+ * (zeroed) field slots as `Some`.
+ **/
+export function emptyFactCollection(service: EphemeralArrayService): FactCollection {
+  return toNoirFactCollection(service, AztecAddress.ZERO, AztecAddress.ZERO, Fr.ZERO, Fr.ZERO, []);
+}

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

@@ -0,0 +1,35 @@
+import type { BlockNumber } from '@aztec-labs/foundation/branded-types';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { Tag } from '@aztec-labs/stdlib/logs';
+
+import type { Option } from './option.js';
+
+/** 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 `EphemeralArray`.
+ */
+export type LogRetrievalRequest = {
+  contractAddress: AztecAddress;
+  tag: Tag;
+  source: LogSource;
+  fromBlock: Option<BlockNumber>;
+  toBlock: Option<BlockNumber>;
+};
+
+/** Parses a `LogSource` from its wire field, throwing on an out-of-range value. */
+export function logSourceFromField(field: Fr): LogSource {
+  const sourceNum = field.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(', ')}`);
+  }
+  return sourceNum as LogSource;
+}

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

@@ -0,0 +1,19 @@
+import type { BlockNumber } from '@aztec-labs/foundation/branded-types';
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { BlockHash } from '@aztec-labs/stdlib/block';
+import type { TxHash } from '@aztec-labs/stdlib/tx';
+import type { UInt64 } from '@aztec-labs/stdlib/types';
+
+/**
+ * Intermediate struct used to perform batch log retrieval by PXE. The `utilityBulkRetrieveLogs` oracle stores values of this
+ * type in a `EphemeralArray`.
+ */
+export type LogRetrievalResponse = {
+  logPayload: Fr[];
+  txHash: TxHash;
+  uniqueNoteHashesInTx: Fr[];
+  firstNullifierInTx: Fr;
+  blockNumber: BlockNumber;
+  blockTimestamp: UInt64;
+  blockHash: BlockHash;
+};

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

@@ -0,0 +1,27 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { Note } from '@aztec-labs/stdlib/note';
+
+/**
+ * Information about a note needed during execution.
+ */
+export interface NoteData {
+  /** The actual note content (the fields of the Noir #[note] struct). */
+  note: Note;
+  /** The address of the contract that owns the note. */
+  contractAddress: AztecAddress;
+  /** The owner of the note. */
+  owner: AztecAddress;
+  /** The storage slot of the note. */
+  storageSlot: Fr;
+  /** The randomness injected to the note */
+  randomness: Fr;
+  /** The nonce injected into the note hash preimage by kernels. */
+  noteNonce: Fr;
+  /** A hash of the note as it gets stored in the note hash tree. */
+  noteHash: Fr;
+  /** True if the note is pending, false if settled. */
+  isPending: boolean;
+  /** The corresponding nullifier of the note. Undefined for pending notes. */
+  siloedNullifier?: Fr;
+}

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

@@ -0,0 +1,59 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { FieldReader } from '@aztec-labs/foundation/serialize';
+import { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import { TxHash } from '@aztec-labs/stdlib/tx';
+
+/**
+ * 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(
+    public contractAddress: AztecAddress,
+    public owner: AztecAddress,
+    public storageSlot: Fr,
+    public randomness: Fr,
+    public noteNonce: Fr,
+    public content: Fr[],
+    public noteHash: Fr,
+    public nullifier: Fr,
+    public txHash: TxHash,
+  ) {}
+
+  static fromFields(fields: Fr[] | FieldReader): NoteValidationRequest {
+    const reader = FieldReader.asReader(fields);
+
+    const contractAddress = AztecAddress.fromFieldUnsafe(reader.readField());
+    const owner = AztecAddress.fromFieldUnsafe(reader.readField());
+    const storageSlot = reader.readField();
+    const randomness = reader.readField();
+    const noteNonce = reader.readField();
+
+    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());
+
+    if (reader.remainingFields() !== 0) {
+      throw new Error(
+        `Error converting array of fields to NoteValidationRequest: expected ${reader.cursor} fields but received ${reader.cursor + reader.remainingFields()} (maxNotePackedLen=${maxNotePackedLen}).`,
+      );
+    }
+
+    return new NoteValidationRequest(
+      contractAddress,
+      owner,
+      storageSlot,
+      randomness,
+      noteNonce,
+      content,
+      noteHash,
+      nullifier,
+      txHash,
+    );
+  }
+}

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

@@ -0,0 +1,15 @@
+import type { NULLIFIER_TREE_HEIGHT } from '@aztec-labs/constants';
+import type { MembershipWitness } from '@aztec-labs/foundation/trees';
+import type { NullifierLeafPreimage, NullifierMembershipWitness } from '@aztec-labs/stdlib/trees';
+
+/**
+ * A nullifier leaf preimage and the witness proving its membership in the nullifier tree.
+ */
+export type NullifierMembershipWitnessData = {
+  leafPreimage: NullifierLeafPreimage;
+  witness: MembershipWitness<typeof NULLIFIER_TREE_HEIGHT>;
+};
+
+export function toNullifierMembershipWitnessData(witness: NullifierMembershipWitness): NullifierMembershipWitnessData {
+  return { leafPreimage: witness.leafPreimage, witness: witness.withoutPreimage() };
+}

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

@@ -0,0 +1,75 @@
+/**
+ * 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,
+    // `unknown` (not the descriptor shape) keeps this generic Option decoupled from the serialization layer's
+    // `{ length }`/`{ maxLength }` size descriptors; only the None-serialization path inspects it.
+    public readonly size: unknown,
+  ) {}
+
+  /**
+   * 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 an inner type whose
+   * wire size varies per call site (`BoundedVec`, an array), pass a `size` descriptor so the inner type's shape can
+   * resolve how many zero fields to emit; fixed-size inners take no argument.
+   *
+   * @example None for a fixed-size type:
+   * ```ts
+   * return Option.none();
+   * ```
+   *
+   * @example None for a dynamic-size type:
+   * ```ts
+   * return Option.none({ maxLength: ciphertext.maxLength });
+   * ```
+   */
+  static none<T>(size?: unknown): Option<T> {
+    return new Option<T>(undefined, size);
+  }
+
+  /**
+   * 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;
+  }
+
+  equals(other: Option<T>, innerEquals: (a: T, b: T) => boolean): boolean {
+    if (this.isSome() && other.isSome()) {
+      return innerEquals(this.value, other.value);
+    }
+    return this.isNone() && other.isNone();
+  }
+}

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

@@ -0,0 +1,8 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+
+/**
+ * The block a retractable fact originates from.
+ *
+ * A TS version of the `OriginBlock` struct in `facts/mod.nr`.
+ */
+export type OriginBlock = { blockNumber: number; blockHash: Fr };

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

@@ -0,0 +1,12 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+
+import type { ResolvedTx } from './resolved_tx.js';
+
+/**
+ * Represents a pending tagged log as it is stored in the pending tagged log array to which the fetchTaggedLogs oracle
+ * inserts found private logs. A TS version of `pending_tagged_log.nr`.
+ */
+export type PendingTaggedLog = {
+  log: Fr[];
+  context: ResolvedTx;
+};

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

@@ -0,0 +1,5 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { AppTaggingSecretKind } from '@aztec-labs/stdlib/logs';
+
+/** A tagging secret an app supplies explicitly to `getPendingTaggedLogsV2` when PXE cannot derive it internally. */
+export type ProvidedSecret = { secret: Fr; mode: AppTaggingSecretKind };

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

@@ -0,0 +1,13 @@
+import type { PUBLIC_DATA_TREE_HEIGHT } from '@aztec-labs/constants';
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { Tuple } from '@aztec-labs/foundation/serialize';
+import type { PublicDataTreeLeafPreimage } from '@aztec-labs/stdlib/trees';
+
+/**
+ * A public data leaf preimage and the witness proving its membership in the public data tree.
+ */
+export type PublicDataWitnessData = {
+  index: bigint;
+  leafPreimage: PublicDataTreeLeafPreimage;
+  siblingPath: Tuple<Fr, typeof PUBLIC_DATA_TREE_HEIGHT>;
+};

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

@@ -0,0 +1,66 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+
+// Keep in sync with aztec::messages::delivery::ResolvedTaggingStrategy
+const NON_INTERACTIVE_HANDSHAKE = 1;
+const UNCONSTRAINED_SECRET = 2;
+const INTERACTIVE_HANDSHAKE = 3;
+
+/**
+ * The tagging secret PXE hands to the contract after applying the wallet's {@link TaggingSecretStrategy} choice
+ * (and app-siloing). The contract uses it directly to derive the message tag, so it never sees raw key material.
+ */
+export type ResolvedTaggingStrategy =
+  | {
+      /** A non-interactive handshake: the recipient re-derives the secret from the onchain handshake registry. */
+      type: 'non-interactive-handshake';
+    }
+  | {
+      /**
+       * An interactive handshake: the registry obtains the recipient's signed authorization through the custom
+       * request oracle, and the recipient learns the secret while signing. Nothing announcing the handshake is
+       * published onchain.
+       */
+      type: 'interactive-handshake';
+    }
+  | {
+      /**
+       * An app-siloed, recipient-directional secret, ready to use. Only sound for unconstrained delivery.
+       */
+      type: 'unconstrained-secret';
+      /** The app-siloed directional tagging secret. */
+      secret: Fr;
+    };
+
+/** Serializes a {@link ResolvedTaggingStrategy} to its Noir `[kind, secret]` field layout, zero-filling absent fields. */
+export function resolvedTaggingStrategyToFields(resolved: ResolvedTaggingStrategy): Fr[] {
+  switch (resolved.type) {
+    case 'non-interactive-handshake':
+      return [new Fr(NON_INTERACTIVE_HANDSHAKE), Fr.ZERO];
+    case 'unconstrained-secret':
+      return [new Fr(UNCONSTRAINED_SECRET), resolved.secret];
+    case 'interactive-handshake':
+      return [new Fr(INTERACTIVE_HANDSHAKE), Fr.ZERO];
+  }
+}
+
+/** Deserializes a {@link ResolvedTaggingStrategy} from its `kind` discriminant and `secret` field. */
+export function resolvedTaggingStrategyFromFields(kind: number, secret: Fr): ResolvedTaggingStrategy {
+  switch (kind) {
+    case NON_INTERACTIVE_HANDSHAKE:
+      assertAbsentSecret(kind, secret);
+      return { type: 'non-interactive-handshake' };
+    case INTERACTIVE_HANDSHAKE:
+      assertAbsentSecret(kind, secret);
+      return { type: 'interactive-handshake' };
+    case UNCONSTRAINED_SECRET:
+      return { type: 'unconstrained-secret', secret };
+    default:
+      throw new Error(`Unrecognized resolved tagging strategy kind: ${kind}`);
+  }
+}
+
+function assertAbsentSecret(kind: number, secret: Fr): void {
+  if (!secret.isZero()) {
+    throw new Error(`Resolved tagging strategy ${kind} must not include a secret`);
+  }
+}

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

@@ -0,0 +1,19 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { TxHash } from '@aztec-labs/stdlib/tx';
+
+/**
+ * The resolved on-chain context of a transaction.
+ *
+ * Carries the note hashes and first nullifier needed to discover notes that originated from the transaction, plus the
+ * number and hash of the block in which it was mined.
+ *
+ * A TS version of the `ResolvedTx` struct in `oracle/tx_resolution.nr`; its wire layout lives in the `RESOLVED_TX`
+ * type mapping.
+ */
+export type ResolvedTx = {
+  txHash: TxHash;
+  uniqueNoteHashesInTx: Fr[];
+  firstNullifierInTx: Fr;
+  blockNumber: number;
+  blockHash: Fr;
+};

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

@@ -0,0 +1,16 @@
+import type { FieldsOf } from '@aztec-labs/foundation/types';
+import type { FlatPublicLogs } from '@aztec-labs/stdlib/logs';
+import type { TxEffect } from '@aztec-labs/stdlib/tx';
+
+import type { ContractClassLogData } from './contract_class_log_data.js';
+
+/**
+ * Wire form of a {@link TxEffect} as the `getTxEffect` oracle returns it: identical to the domain type except its logs
+ * are flattened to their Noir layout and its revert code is the plain `u8` Noir declares. Keeping the conversion in
+ * the handler lets the `TX_EFFECT` mapping stay purely structural.
+ */
+export type TxEffectData = Omit<FieldsOf<TxEffect>, 'revertCode' | 'publicLogs' | 'contractClassLogs'> & {
+  revertCode: number;
+  publicLogs: FlatPublicLogs;
+  contractClassLogs: ContractClassLogData[];
+};

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

@@ -0,0 +1,11 @@
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { BlockHeader } from '@aztec-labs/stdlib/tx';
+
+/**
+ * TypeScript counterpart of utility_context.nr. Used only as a return value for the utilityGetUtilityContext oracle.
+ */
+export type UtilityContext = {
+  blockHeader: BlockHeader;
+  contractAddress: AztecAddress;
+  msgSender: AztecAddress;
+};