@aztec/pxe 0.0.1-commit.9ef841308 → 0.0.1-commit.a5db02d

package/src/contract_function_simulator/execution_note_cache.ts

@@ -2,7 +2,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 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 +43,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,12 +58,9 @@ 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.
@@ -102,14 +93,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 +206,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,18 +1,14 @@
-import { ExtendedDirectionalAppTaggingSecret, type TaggingIndexRange } from '@aztec/stdlib/logs';
+import { AppTaggingSecret, type TaggingIndexRange } from '@aztec/stdlib/logs';
 
-/**
- * A map that stores the tagging index range 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, { lowestIndex: number; highestIndex: number }> = new Map();
 
-  public getLastUsedIndex(secret: ExtendedDirectionalAppTaggingSecret): number | undefined {
+  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.highestIndex !== index - 1) {
       throw new Error(`Invalid tagging index update. Current value: ${currentValue.highestIndex}, new value: ${index}`);
@@ -29,7 +25,7 @@ export class ExecutionTaggingIndexCache {
    */
   public getUsedTaggingIndexRanges(): TaggingIndexRange[] {
     return Array.from(this.taggingIndexMap.entries()).map(([secret, { lowestIndex, highestIndex }]) => ({
-      extendedSecret: ExtendedDirectionalAppTaggingSecret.fromString(secret),
+      extendedSecret: AppTaggingSecret.fromString(secret),
       lowestIndex,
       highestIndex,
     }));

package/src/contract_function_simulator/index.ts

@@ -1,14 +1,78 @@
+export {
+  ORACLE_REGISTRY,
+  makeEntry,
+  type NamedValue,
+  type OracleRegistryEntry,
+  type ParamTypes,
+} from './oracle/oracle_registry.js';
+export {
+  ARRAY,
+  AZTEC_ADDRESS,
+  BIGINT,
+  BLOCK_HASH,
+  BLOCK_NUMBER,
+  BOOL,
+  BOUNDED_VEC,
+  BUFFER,
+  BYTE,
+  CONTRACT_INSTANCE,
+  DELIVERY_MODE,
+  EPHEMERAL_ARRAY,
+  ETH_ADDRESS,
+  EVENT_VALIDATION_REQUEST,
+  FIELD,
+  FIXED_ARRAY,
+  FUNCTION_SELECTOR,
+  LOG_RETRIEVAL_REQUEST,
+  LOG_RETRIEVAL_RESPONSE,
+  MEMBERSHIP_WITNESS,
+  NOTE_SELECTOR,
+  NOTE_VALIDATION_REQUEST,
+  OPTION,
+  PENDING_TAGGED_LOG,
+  POINT,
+  PROVIDED_SECRET,
+  SLOT_NUMBER,
+  STR,
+  STRUCT,
+  U32,
+  tryFieldWidth,
+  type InputSlot,
+  type MaybePromise,
+  type OutputSlot,
+  type SlotShape,
+  type StructField,
+  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 { MessageContextService } from '../messages/message_context_service.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 { 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

@@ -6,7 +6,7 @@ import { TxHash } from '@aztec/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 `CapsuleArray`.
+ * expects for values of this type to be stored in a `EphemeralArray`.
  */
 export class EventValidationRequest {
   constructor(
@@ -18,14 +18,15 @@ export class EventValidationRequest {
     public txHash: TxHash,
   ) {}
 
-  static fromFields(fields: Fr[], maxEventSerializedLen: number): EventValidationRequest {
+  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 maxEventSerializedLen = reader.readField().toNumber();
     const eventStorage = reader.readFieldArray(maxEventSerializedLen);
     const eventLen = reader.readField().toNumber();
     const serializedEvent = eventStorage.slice(0, eventLen);
@@ -35,7 +36,7 @@ export class EventValidationRequest {
 
     if (reader.remainingFields() !== 0) {
       throw new Error(
-        `Error converting array of fields to EventValidationRequest: expected ${reader.cursor} fields but received ${fields.length} (maxEventSerializedLen=${maxEventSerializedLen}).`,
+        `Error converting array of fields to EventValidationRequest: expected ${reader.cursor} fields but received ${reader.cursor + reader.remainingFields()} (maxEventSerializedLen=${maxEventSerializedLen}).`,
       );
     }
 

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;
 }

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

@@ -1,66 +1,19 @@
-import { MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_CIPHERTEXT_LEN } from '@aztec/constants';
-import { range } from '@aztec/foundation/array';
-import { Fr } from '@aztec/foundation/curves/bn254';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { BlockHash } from '@aztec/stdlib/block';
 import type { TxHash } from '@aztec/stdlib/tx';
-
-const MAX_LOG_CONTENT_LEN = PRIVATE_LOG_CIPHERTEXT_LEN;
+import type { UInt64 } from '@aztec/stdlib/types';
 
 /**
  * Intermediate struct used to perform batch log retrieval by PXE. The `utilityBulkRetrieveLogs` oracle stores values of this
- * type in a `CapsuleArray`.
- */
-export class LogRetrievalResponse {
-  constructor(
-    public logPayload: Fr[],
-    public txHash: TxHash,
-    public uniqueNoteHashesInTx: Fr[],
-    public firstNullifierInTx: Fr,
-  ) {}
-
-  toFields(): Fr[] {
-    return [
-      // We need to trim the payload since public logs can be larger than MAX_LOG_CONTENT_LEN.
-      // This is currently not a problem since this class is only used with public logs for note completion.
-      ...serializeBoundedVec(this.logPayload.slice(0, MAX_LOG_CONTENT_LEN), MAX_LOG_CONTENT_LEN),
-      this.txHash.hash,
-      ...serializeBoundedVec(this.uniqueNoteHashesInTx, MAX_NOTE_HASHES_PER_TX),
-      this.firstNullifierInTx,
-    ];
-  }
-
-  static toEmptyFields(): Fr[] {
-    const serializationLen =
-      MAX_LOG_CONTENT_LEN +
-      1 /* logPayload BVec */ +
-      1 /* txHash */ +
-      MAX_NOTE_HASHES_PER_TX +
-      1 /* uniqueNoteHashesInTx BVec */ +
-      1; /* firstNullifierInTx */
-    return range(serializationLen).map(_ => Fr.zero());
-  }
-
-  static toSerializedOption(response: LogRetrievalResponse | null): Fr[] {
-    if (response) {
-      return [new Fr(1), ...response.toFields()];
-    } else {
-      return [new Fr(0), ...LogRetrievalResponse.toEmptyFields()];
-    }
-  }
-}
-
-/**
- * Helper function to serialize a bounded vector according to Noir's BoundedVec format
- * @param values - The values to serialize
- * @param maxLength - The maximum length of the bounded vector
- * @returns The serialized bounded vector as Fr[]
+ * type in a `EphemeralArray`.
  */
-function serializeBoundedVec(values: Fr[], maxLength: number): Fr[] {
-  if (values.length > maxLength) {
-    throw new Error(`Attempted to serialize ${values} values into a BoundedVec with max length ${maxLength}`);
-  }
-
-  const lengthDiff = maxLength - values.length;
-  const zeroPaddingArray = Array(lengthDiff).fill(Fr.ZERO);
-  const storage = values.concat(zeroPaddingArray);
-  return [...storage, new Fr(values.length)];
-}
+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/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { Note } from '@aztec/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

@@ -5,7 +5,7 @@ import { TxHash } from '@aztec/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 `CapsuleArray`.
+ * expects for values of this type to be stored in a `EphemeralArray`.
  */
 export class NoteValidationRequest {
   constructor(
@@ -20,15 +20,16 @@ export class NoteValidationRequest {
     public txHash: TxHash,
   ) {}
 
-  static fromFields(fields: Fr[], maxNotePackedLen: number): NoteValidationRequest {
+  static fromFields(fields: Fr[] | FieldReader): NoteValidationRequest {
     const reader = FieldReader.asReader(fields);
 
-    const contractAddress = AztecAddress.fromField(reader.readField());
-    const owner = AztecAddress.fromField(reader.readField());
+    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);
@@ -39,7 +40,7 @@ export class NoteValidationRequest {
 
     if (reader.remainingFields() !== 0) {
       throw new Error(
-        `Error converting array of fields to NoteValidationRequest: expected ${reader.cursor} fields but received ${fields.length} (maxNotePackedLen=${maxNotePackedLen}).`,
+        `Error converting array of fields to NoteValidationRequest: expected ${reader.cursor} fields but received ${reader.cursor + reader.remainingFields()} (maxNotePackedLen=${maxNotePackedLen}).`,
       );
     }