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

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

@@ -1,8 +1,9 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
+import { allToCompletion } from '@aztec/foundation/promise';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { computeNoteHashNonce, computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
 
-import type { NoteData } from './oracle/interfaces.js';
+import type { NoteData } from './noir-structs/note_data.js';
 
 interface PendingNote {
   note: NoteData;
@@ -43,12 +44,6 @@ export class ExecutionNoteCache {
 
   private inRevertiblePhase = false;
 
-  /**
-   * 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: boolean | undefined;
-
   constructor(private readonly protocolNullifier: Fr) {}
 
   /**
@@ -64,18 +59,15 @@ export class ExecutionNoteCache {
     this.inRevertiblePhase = true;
     this.minRevertibleSideEffectCounter = minRevertibleSideEffectCounter;
 
-    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 protocol nullifier is always the tx's first nullifier (injected by the kernel init), so it is the
+    // nonce generator for every note hash.
+    const nonceGenerator = this.protocolNullifier;
 
     // 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 "unique" note hashes.
-    const updatedNotes = await Promise.all(
+    const updatedNotes = await allToCompletion(
       this.notes.map(async ({ note, counter }, i) => {
         const noteNonce = await computeNoteHashNonce(nonceGenerator, i);
         const uniqueNoteHash = await computeUniqueNoteHash(
@@ -102,14 +94,6 @@ export class ExecutionNoteCache {
     return sideEffectCounter >= this.minRevertibleSideEffectCounter;
   }
 
-  public finish() {
-    // 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.getEmittedNullifiers().length === 0;
-    }
-  }
-
   /**
    * Add a new note to cache.
    * @param note - New note created during execution.
@@ -223,19 +207,15 @@ export class ExecutionNoteCache {
   }
 
   /**
-   * @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.
+   * @returns All nullifiers of the transaction: the protocol nullifier (the kernel-injected first nullifier),
+   * followed by those emitted by private calls.
    */
   getAllNullifiers(): Fr[] {
-    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];
+    return [this.protocolNullifier, ...this.getEmittedNullifiers()];
   }
 
   getNonceGenerator(): Fr {
-    return this.getAllNullifiers()[0];
+    return this.protocolNullifier;
   }
 
   #recordNullifier(contractAddress: AztecAddress, siloedNullifier: bigint) {

package/src/contract_function_simulator/execution_tagging_index_cache.ts

@@ -1,32 +1,33 @@
-import { ExtendedDirectionalAppTaggingSecret, type PreTag } from '@aztec/stdlib/logs';
+import { AppTaggingSecret, type TaggingIndexRange } from '@aztec/stdlib/logs';
 
-/**
- * A map that stores the tagging index for a given extended 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: ExtendedDirectionalAppTaggingSecret): number | undefined {
-    return this.taggingIndexMap.get(secret.toString());
+  public getLastUsedIndex(secret: AppTaggingSecret): number | undefined {
+    return this.taggingIndexMap.get(secret.toString())?.highestIndex;
   }
 
-  public setLastUsedIndex(secret: ExtendedDirectionalAppTaggingSecret, 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]) => ({
-      extendedSecret: ExtendedDirectionalAppTaggingSecret.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

@@ -1,13 +1,98 @@
+export {
+  ORACLE_REGISTRY,
+  makeEntry,
+  type NamedValue,
+  type OracleRegistryEntry,
+  type ParamTypes,
+} from './oracle/oracle_registry.js';
+export {
+  ALIAS,
+  ARRAY,
+  AZTEC_ADDRESS,
+  BIGINT,
+  BLOCK_HASH,
+  BLOCK_NUMBER,
+  BOOL,
+  BOUNDED_VEC,
+  U8,
+  CONTRACT_INSTANCE,
+  DELIVERY_MODE,
+  EPHEMERAL_ARRAY,
+  ETH_ADDRESS,
+  EVENT_VALIDATION_REQUEST,
+  FIELD,
+  FIXED_ARRAY,
+  FUNCTION_SELECTOR,
+  LEAF,
+  LEAF_INDEX,
+  LOG_RETRIEVAL_REQUEST,
+  LOG_RETRIEVAL_RESPONSE,
+  MEMBERSHIP_WITNESS,
+  NOTE_SELECTOR,
+  NOTE_VALIDATION_REQUEST,
+  OPTION,
+  PENDING_TAGGED_LOG,
+  POINT,
+  PROVIDED_SECRET,
+  SCALAR,
+  SLOT_NUMBER,
+  STR,
+  STRUCT,
+  U32,
+  U64,
+  U128,
+  tryFieldWidth,
+  isArrayMapping,
+  isBoundedVecMapping,
+  isEphemeralArrayMapping,
+  isFixedArrayMapping,
+  isFixedBoundedVecMapping,
+  isOptionMapping,
+  isStructMapping,
+  type ArrayMapping,
+  type BoundedVecMapping,
+  type CompositeMapping,
+  type EphemeralArrayMapping,
+  type FixedArrayMapping,
+  type FixedBoundedVecMapping,
+  type InputSlot,
+  type MaybePromise,
+  type OptionMapping,
+  type OutputSlot,
+  type SlotShape,
+  type StructField,
+  type StructMapping,
+  type TypeMapping,
+} from './oracle/oracle_type_mappings.js';
 export { ExecutionNoteCache } from './execution_note_cache.js';
 export { ExecutionTaggingIndexCache } from './execution_tagging_index_cache.js';
 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 type { IMiscOracle, IUtilityExecutionOracle, IPrivateExecutionOracle } from './oracle/interfaces.js';
+export type { FactCollection } from './noir-structs/fact_collection.js';
+export type { NoteData } from './noir-structs/note_data.js';
+export type { ResolvedTaggingStrategy } from './noir-structs/resolved_tagging_strategy.js';
+export type { MessageLoadOracleInputs } from './oracle/message_load_oracle_inputs.js';
+export { TxResolverService } from '../messages/tx_resolver_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 { buildACIRCallback, UnavailableOracleError } from './oracle/acir_callback.js';
+export { LEGACY_ORACLE_REGISTRY } from './oracle/legacy_oracle_registry.js';
 export { executePrivateFunction, extractPrivateCircuitPublicInputs } from './oracle/private_execution.js';
 export { generateSimulatedProvingResult } from './contract_function_simulator.js';
 export { packAsHintedNote } from './oracle/note_packing_utils.js';
-export { UtilityContext } from './noir-structs/utility_context.js';
+export { BoundedVec } from './noir-structs/bounded_vec.js';
+export type { ContractClassLogData } from './noir-structs/contract_class_log_data.js';
+export type { EmbeddedCurvePoint } from './noir-structs/embedded_curve_point.js';
+export { EphemeralArray } from './noir-structs/ephemeral_array.js';
+export { Option } from './noir-structs/option.js';
+export type { UtilityContext } from './noir-structs/utility_context.js';
+export { EventValidationRequest } from './noir-structs/event_validation_request.js';
+export type { LogRetrievalRequest } from './noir-structs/log_retrieval_request.js';
+export type { LogRetrievalResponse } from './noir-structs/log_retrieval_response.js';
+export { NoteValidationRequest } from './noir-structs/note_validation_request.js';
+export type { PendingTaggedLog } from './noir-structs/pending_tagged_log.js';
+export type { TxEffectData } from './noir-structs/tx_effect_data.js';
+export type { ProvidedSecret } from './noir-structs/provided_secret.js';
+export type { ResolvedTx } from './noir-structs/resolved_tx.js';
+export { TransientArrayService } from './transient_array_service.js';

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

@@ -0,0 +1,43 @@
+/** TypeScript counterpart of Noir's `BoundedVec<T, MaxLen>`. */
+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. Only consulted for
+   *   variable-width elements whose width isn't statically known from their shape (e.g. a packed note spanning
+   *   `packedHintedNoteLength` fields); fixed-width elements derive it from the shape, so it can be omitted.
+   *
+   * @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);
+  }
+
+  equals(other: BoundedVec<T>, innerEquals: (a: T, b: T) => boolean): boolean {
+    return (
+      this.maxLength === other.maxLength &&
+      this.data.length === other.data.length &&
+      this.data.every((value, i) => innerEquals(value, other.data[i]))
+    );
+  }
+}

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

@@ -0,0 +1,9 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+/** Wire form of a contract class log. */
+export type ContractClassLogData = {
+  contractAddress: AztecAddress;
+  fields: Fr[];
+  emittedLength: number;
+};

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

@@ -0,0 +1,4 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+
+/** Wire form of a Grumpkin point crossing the oracle boundary: Noir's `EmbeddedCurvePoint` serializes to `[x, y]`. */
+export type EmbeddedCurvePoint = { x: Fr; y: Fr };

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

@@ -0,0 +1,66 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import { FieldReader } from '@aztec/foundation/serialize';
+
+import type { EphemeralArrayService } from '../ephemeral_array_service.js';
+import type { TypeMapping } from '../oracle/oracle_registry.js';
+
+/**
+ * TypeScript counterpart of Noir's `EphemeralArray<T>`.
+ *
+ * An ephemeral array looks very different depending on whether it's being produced (as an oracle return value) or
+ * consumed (as an oracle parameter), so we use a discriminated state to model both without leaking those details to
+ * callers:
+ *
+ * - As a return value (`output` mode), what we have are the typed values the oracle just computed. The slot is just
+ *   an implementation detail of how those values get handed back to ACVM, so we hold onto the values and the service
+ *   they will eventually live in, and only materialize a slot when something actually asks for it.
+ *
+ * - As a parameter (`input` mode), what we have is a slot pointing at fields ACVM already wrote into the service,
+ *   plus the TypeMapping that knows how to interpret those fields. We hold onto both so callers can later ask for
+ *   the typed values without having to think about deserialization.
+ *
+ * In both modes the idea is the same: store everything we already know at construction time, so the rest of the
+ * code can work with typed values and never touch slots, services, or TypeMappings directly.
+ */
+export class EphemeralArray<T> {
+  private constructor(private readonly state: EphemeralArrayState<T>) {}
+
+  /** Create an output-mode array carrying typed values. The service is only used if/when the slot is materialized. */
+  static fromValues<T>(service: EphemeralArrayService, values: T[]): EphemeralArray<T> {
+    return new EphemeralArray({ kind: 'output', service, values });
+  }
+
+  /** Wrap an existing slot. Intended for the EPHEMERAL_ARRAY combinator during ACVM deserialization. */
+  static fromSlot<T>(slot: Fr, mapping: TypeMapping<T>): EphemeralArray<T> {
+    return new EphemeralArray({ kind: 'input', slot, mapping });
+  }
+
+  /**
+   * Returns the slot, materializing values into the service on first call for output-mode arrays.
+   * Intended for the EPHEMERAL_ARRAY combinator during ACVM serialization.
+   */
+  materializeSlot(serializeItem: (v: T) => Fr[]): Fr {
+    if (this.state.kind === 'input') {
+      return this.state.slot;
+    }
+    if (this.state.cachedSlot === undefined) {
+      this.state.cachedSlot = this.state.service.newArray(this.state.values.map(serializeItem));
+    }
+    return this.state.cachedSlot;
+  }
+
+  /** Read all elements: returns stored values for output-mode arrays, deserializes from the service for input-mode. */
+  readAll(service: EphemeralArrayService): T[] {
+    if (this.state.kind === 'output') {
+      return this.state.values;
+    }
+    const mapping = this.state.mapping;
+    return service
+      .readArrayAt(this.state.slot)
+      .map(fields => mapping.deserialization!.fn([FieldReader.asReader(fields)]));
+  }
+}
+
+type EphemeralArrayState<T> =
+  | { kind: 'output'; service: EphemeralArrayService; values: T[]; cachedSlot?: Fr }
+  | { kind: 'input'; slot: Fr; mapping: TypeMapping<T> };

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 = 10;
-
 /**
  * Intermediate struct used to perform batch event validation by PXE. The `utilityValidateAndStoreEnqueuedNotesAndEvents` oracle
- * expects for values of this type to be stored in a `CapsuleArray`.
+ * expects for values of this type to be stored in a `EphemeralArray`.
  */
 export class EventValidationRequest {
   constructor(
@@ -19,24 +16,29 @@ export class EventValidationRequest {
     public serializedEvent: Fr[],
     public eventCommitment: Fr,
     public txHash: TxHash,
-    public recipient: AztecAddress,
   ) {}
 
   static fromFields(fields: Fr[] | FieldReader): EventValidationRequest {
     const reader = FieldReader.asReader(fields);
 
-    const contractAddress = AztecAddress.fromField(reader.readField());
+    const contractAddress = AztecAddress.fromFieldUnsafe(reader.readField());
     const eventTypeId = EventSelector.fromField(reader.readField());
 
     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 ${reader.cursor + reader.remainingFields()} (maxEventSerializedLen=${maxEventSerializedLen}).`,
+      );
+    }
 
     return new EventValidationRequest(
       contractAddress,
@@ -45,7 +47,6 @@ export class EventValidationRequest {
       serializedEvent,
       eventCommitment,
       txHash,
-      recipient,
     );
   }
 }

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

@@ -0,0 +1,13 @@
+import type { Fr } from '@aztec/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/foundation/curves/bn254';
+import { AztecAddress } from '@aztec/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

@@ -1,28 +1,35 @@
+import type { 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';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { Tag } from '@aztec/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 `CapsuleArray`.
+ * type to be stored in a `EphemeralArray`.
  */
-export class LogRetrievalRequest {
-  constructor(
-    public contractAddress: AztecAddress,
-    public tag: Tag,
-  ) {}
-
-  toFields(): Fr[] {
-    return [this.contractAddress.toField(), this.tag.value];
-  }
-
-  static fromFields(fields: Fr[] | FieldReader): LogRetrievalRequest {
-    const reader = FieldReader.asReader(fields);
-
-    const contractAddress = AztecAddress.fromField(reader.readField());
-    const tag = new Tag(reader.readField());
+export type LogRetrievalRequest = {
+  contractAddress: AztecAddress;
+  tag: Tag;
+  source: LogSource;
+  fromBlock: Option<BlockNumber>;
+  toBlock: Option<BlockNumber>;
+};
 
-    return new LogRetrievalRequest(contractAddress, tag);
+/** 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;
 }