@aztec/pxe 4.0.0-nightly.20250907 → 4.0.0-nightly.20260107

package/src/contract_function_simulator/hashed_values_cache.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { HashedValues } from '@aztec/stdlib/tx';
 
 /**

package/src/contract_function_simulator/index.ts

@@ -1,7 +1,8 @@
 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, TypedOracle } from './oracle/typed_oracle.js';
+export type { NoteData, IMiscOracle, IUtilityExecutionOracle, IPrivateExecutionOracle } from './oracle/interfaces.js';
 export { MessageLoadOracleInputs } from './oracle/message_load_oracle_inputs.js';
 export { UtilityExecutionOracle } from './oracle/utility_execution_oracle.js';
 export { PrivateExecutionOracle } from './oracle/private_execution_oracle.js';
@@ -9,3 +10,4 @@ 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 { UtilityContext } from './noir-structs/utility_context.js';

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

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { FieldReader } from '@aztec/foundation/serialize';
 import { EventSelector } from '@aztec/stdlib/abi';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';

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

@@ -1,6 +1,7 @@
-import { Fr } from '@aztec/foundation/fields';
+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';
 
 /**
  * Intermediate struct used to perform batch log retrieval by PXE. The `utilityBulkRetrieveLogs` oracle expects values of this
@@ -9,19 +10,19 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
 export class LogRetrievalRequest {
   constructor(
     public contractAddress: AztecAddress,
-    public unsiloedTag: Fr,
+    public tag: Tag,
   ) {}
 
   toFields(): Fr[] {
-    return [this.contractAddress.toField(), this.unsiloedTag];
+    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 unsiloedTag = reader.readField();
+    const tag = new Tag(reader.readField());
 
-    return new LogRetrievalRequest(contractAddress, unsiloedTag);
+    return new LogRetrievalRequest(contractAddress, tag);
   }
 }

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

@@ -1,9 +1,12 @@
-import { MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_CIPHERTEXT_LEN, PUBLIC_LOG_PLAINTEXT_LEN } from '@aztec/constants';
+import { MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_CIPHERTEXT_LEN } from '@aztec/constants';
 import { range } from '@aztec/foundation/array';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { TxHash } from '@aztec/stdlib/tx';
 
-const MAX_LOG_CONTENT_LEN = Math.max(PUBLIC_LOG_PLAINTEXT_LEN, PRIVATE_LOG_CIPHERTEXT_LEN);
+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);
 
 /**
  * Intermediate struct used to perform batch log retrieval by PXE. The `utilityBulkRetrieveLogs` oracle stores values of this
@@ -19,7 +22,9 @@ export class LogRetrievalResponse {
 
   toFields(): Fr[] {
     return [
-      ...serializeBoundedVec(this.logPayload, MAX_LOG_CONTENT_LEN),
+      // 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,
@@ -37,7 +42,7 @@ export class LogRetrievalResponse {
     return range(serializationLen).map(_ => Fr.zero());
   }
 
-  static toSerializedOption(response?: LogRetrievalResponse): Fr[] {
+  static toSerializedOption(response: LogRetrievalResponse | null): Fr[] {
     if (response) {
       return [new Fr(1), ...response.toFields()];
     } else {

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

@@ -1,10 +1,10 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 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.
-const MAX_NOTE_PACKED_LEN = 12;
+export const MAX_NOTE_PACKED_LEN = 10;
 
 /**
  * Intermediate struct used to perform batch note validation by PXE. The `utilityValidateEnqueuedNotesAndEvents` oracle
@@ -13,7 +13,9 @@ const MAX_NOTE_PACKED_LEN = 12;
 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,
@@ -26,7 +28,9 @@ export class NoteValidationRequest {
     const reader = FieldReader.asReader(fields);
 
     const contractAddress = AztecAddress.fromField(reader.readField());
+    const owner = AztecAddress.fromField(reader.readField());
     const storageSlot = reader.readField();
+    const randomness = reader.readField();
     const noteNonce = reader.readField();
 
     const contentStorage = reader.readFieldArray(MAX_NOTE_PACKED_LEN);
@@ -38,9 +42,17 @@ export class NoteValidationRequest {
     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.`,
+      );
+    }
+
     return new NoteValidationRequest(
       contractAddress,
+      owner,
       storageSlot,
+      randomness,
       noteNonce,
       content,
       noteHash,

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

@@ -0,0 +1,42 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { FieldsOf } from '@aztec/foundation/types';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { UInt64 } from '@aztec/stdlib/types';
+
+/**
+ * TypeScript counterpart of utility_context.nr. Used only as a return value for the utilityGetUtilityContext oracle.
+ */
+export class UtilityContext {
+  private constructor(
+    public readonly blockNumber: number,
+    public readonly timestamp: UInt64,
+    public readonly contractAddress: AztecAddress,
+    public readonly version: Fr,
+    public readonly chainId: Fr,
+  ) {}
+
+  static from(fields: FieldsOf<UtilityContext>) {
+    return new UtilityContext(
+      fields.blockNumber,
+      fields.timestamp,
+      fields.contractAddress,
+      fields.version,
+      fields.chainId,
+    );
+  }
+
+  /**
+   * Returns a representation of the utility context as expected by intrinsic Noir deserialization.
+   * The order of the fields has to be the same as the order of the fields in the utility_context.nr.
+   */
+  public toNoirRepresentation(): (string | string[])[] {
+    // TODO(#12874): remove the stupid as string conversion by modifying ForeignCallOutput type in acvm.js
+    return [
+      new Fr(this.blockNumber).toString() as string,
+      new Fr(this.timestamp).toString() as string,
+      this.contractAddress.toString() as string,
+      this.version.toString() as string,
+      this.chainId.toString() as string,
+    ];
+  }
+}

package/src/contract_function_simulator/oracle/index.ts

@@ -1,7 +1,7 @@
 import type { Oracle } from './oracle.js';
 
 export * from './oracle.js';
-export * from './typed_oracle.js';
+export * from './interfaces.js';
 
 /**
  * A conditional type that takes a type `T` and returns a union of its method names.

package/src/contract_function_simulator/oracle/interfaces.ts

@@ -0,0 +1,175 @@
+import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Point } from '@aztec/foundation/curves/grumpkin';
+import type { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
+import type { KeyValidationRequest } from '@aztec/stdlib/kernel';
+import type { ContractClassLog, Tag } from '@aztec/stdlib/logs';
+import type { Note, NoteStatus } from '@aztec/stdlib/note';
+import { type MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+
+import type { UtilityContext } from '../noir-structs/utility_context.js';
+import type { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
+
+/**
+ * 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;
+  /** The corresponding nullifier of the note. Undefined for pending notes. */
+  siloedNullifier?: Fr;
+  /** The note's leaf index in the note hash tree. Undefined for pending notes. */
+  index?: bigint;
+}
+
+// These interfaces contain the list of oracles required by aztec-nr in order to simulate and execute transactions, i.e.
+// in order to call #[external("utility")] and #[external("private")] contract functions.
+// The full list of aztec-nr oracles is larger and includes the oracles also required to run Noir tests - these reside
+// in the TXE package.
+
+/**
+ * Miscellaneous oracle methods, not very Aztec-specific and expected to be available all scenarios in which aztec-nr
+ * code runs, except #[external("public")] functions (since those are transpiled to AVM bytecode, where there are no oracles).
+ */
+export interface IMiscOracle {
+  isMisc: true;
+
+  utilityGetRandomField(): Fr;
+  utilityAssertCompatibleOracleVersion(version: number): void;
+  utilityDebugLog(level: number, message: string, fields: Fr[]): void;
+}
+
+/**
+ * Oracle methods associated with the execution of an Aztec #[external("utility")] function. Note that the IMiscOracles are also
+ * expected to be available in these contexts.
+ */
+export interface IUtilityExecutionOracle {
+  isUtility: true;
+
+  utilityGetUtilityContext(): UtilityContext;
+  utilityGetKeyValidationRequest(pkMHash: Fr): Promise<KeyValidationRequest>;
+  utilityGetContractInstance(address: AztecAddress): Promise<ContractInstance>;
+  utilityGetMembershipWitness(blockNumber: BlockNumber, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[] | undefined>;
+  utilityGetNullifierMembershipWitness(
+    blockNumber: BlockNumber,
+    nullifier: Fr,
+  ): Promise<NullifierMembershipWitness | undefined>;
+  utilityGetPublicDataWitness(blockNumber: BlockNumber, leafSlot: Fr): Promise<PublicDataWitness | undefined>;
+  utilityGetLowNullifierMembershipWitness(
+    blockNumber: BlockNumber,
+    nullifier: Fr,
+  ): Promise<NullifierMembershipWitness | undefined>;
+  utilityGetBlockHeader(blockNumber: BlockNumber): Promise<BlockHeader | undefined>;
+  utilityGetPublicKeysAndPartialAddress(account: AztecAddress): Promise<CompleteAddress>;
+  utilityGetAuthWitness(messageHash: Fr): Promise<Fr[] | undefined>;
+  utilityGetNotes(
+    owner: AztecAddress | undefined,
+    storageSlot: Fr,
+    numSelects: number,
+    selectByIndexes: number[],
+    selectByOffsets: number[],
+    selectByLengths: number[],
+    selectValues: Fr[],
+    selectComparators: number[],
+    sortByIndexes: number[],
+    sortByOffsets: number[],
+    sortByLengths: number[],
+    sortOrder: number[],
+    limit: number,
+    offset: number,
+    status: NoteStatus,
+  ): Promise<NoteData[]>;
+  utilityCheckNullifierExists(innerNullifier: Fr): Promise<boolean>;
+  utilityGetL1ToL2MembershipWitness(
+    contractAddress: AztecAddress,
+    messageHash: Fr,
+    secret: Fr,
+  ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>>;
+  utilityStorageRead(
+    contractAddress: AztecAddress,
+    startStorageSlot: Fr,
+    blockNumber: BlockNumber,
+    numberOfElements: number,
+  ): Promise<Fr[]>;
+  utilityFetchTaggedLogs(pendingTaggedLogArrayBaseSlot: Fr): Promise<void>;
+  utilityValidateEnqueuedNotesAndEvents(
+    contractAddress: AztecAddress,
+    noteValidationRequestsArrayBaseSlot: Fr,
+    eventValidationRequestsArrayBaseSlot: Fr,
+  ): Promise<void>;
+  utilityBulkRetrieveLogs(
+    contractAddress: AztecAddress,
+    logRetrievalRequestsArrayBaseSlot: Fr,
+    logRetrievalResponsesArrayBaseSlot: Fr,
+  ): Promise<void>;
+  utilityStoreCapsule(contractAddress: AztecAddress, key: Fr, capsule: Fr[]): Promise<void>;
+  utilityLoadCapsule(contractAddress: AztecAddress, key: Fr): Promise<Fr[] | null>;
+  utilityDeleteCapsule(contractAddress: AztecAddress, key: Fr): Promise<void>;
+  utilityCopyCapsule(contractAddress: AztecAddress, srcKey: Fr, dstKey: Fr, numEntries: number): Promise<void>;
+  utilityAes128Decrypt(ciphertext: Buffer, iv: Buffer, symKey: Buffer): Promise<Buffer>;
+  utilityGetSharedSecret(address: AztecAddress, ephPk: Point): Promise<Point>;
+}
+
+/**
+ * Oracle methods associated with the execution of an Aztec #[external("private")] function. Note that both the IMiscOracles and
+ * IUtilityExecutionOracle are also expected to be available in these contexts.
+ */
+export interface IPrivateExecutionOracle {
+  isPrivate: true;
+
+  privateStoreInExecutionCache(values: Fr[], hash: Fr): void;
+  privateLoadFromExecutionCache(hash: Fr): Promise<Fr[]>;
+  privateNotifyCreatedNote(
+    owner: AztecAddress,
+    storageSlot: Fr,
+    randomness: Fr,
+    noteTypeId: NoteSelector,
+    note: Fr[],
+    noteHash: Fr,
+    counter: number,
+  ): void;
+  privateNotifyNullifiedNote(innerNullifier: Fr, noteHash: Fr, counter: number): Promise<void>;
+  privateNotifyCreatedNullifier(innerNullifier: Fr): Promise<void>;
+  privateNotifyCreatedContractClassLog(log: ContractClassLog, counter: number): void;
+  privateCallPrivateFunction(
+    targetContractAddress: AztecAddress,
+    functionSelector: FunctionSelector,
+    argsHash: Fr,
+    sideEffectCounter: number,
+    isStaticCall: boolean,
+  ): Promise<{ endSideEffectCounter: Fr; returnsHash: Fr }>;
+  privateNotifyEnqueuedPublicFunctionCall(
+    targetContractAddress: AztecAddress,
+    calldataHash: Fr,
+    sideEffectCounter: number,
+    isStaticCall: boolean,
+  ): Promise<void>;
+  privateNotifySetPublicTeardownFunctionCall(
+    targetContractAddress: AztecAddress,
+    calldataHash: Fr,
+    sideEffectCounter: number,
+    isStaticCall: boolean,
+  ): Promise<void>;
+  privateNotifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number): Promise<void>;
+  privateIsSideEffectCounterRevertible(sideEffectCounter: number): Promise<boolean>;
+  privateGetSenderForTags(): Promise<AztecAddress | undefined>;
+  privateSetSenderForTags(senderForTags: AztecAddress): Promise<void>;
+  privateGetNextAppTagAsSender(sender: AztecAddress, recipient: AztecAddress): Promise<Tag>;
+  utilityEmitOffchainEffect(data: Fr[]): Promise<void>;
+}

package/src/contract_function_simulator/oracle/message_load_oracle_inputs.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { SiblingPath } from '@aztec/foundation/trees';
 
 export class MessageLoadOracleInputs<N extends number> {

package/src/contract_function_simulator/oracle/note_packing_utils.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { Note } from '@aztec/stdlib/note';
 
@@ -24,6 +24,9 @@ function fromRawData(nonzeroNoteHashCounter: boolean, maybeNoteNonce: Fr): { sta
  * and only after that it packs the retrieved note. Hence it doesn't map one to one with `RetrievedNote::pack()`.
  *
  * @param contractAddress - The address of the contract that owns the note
+ * @param owner - The owner of the note
+ * @param randomness - The randomness injected into the note to get the hiding property of commitments
+ * @param storageSlot - The storage slot of the note
  * @param noteNonce - The nonce injected into the note hash preimage by kernels.
  * @param index - Optional index in the note hash tree. If undefined, indicates a transient note
  * @param note - The note content containing the actual note data
@@ -31,22 +34,35 @@ function fromRawData(nonzeroNoteHashCounter: boolean, maybeNoteNonce: Fr): { sta
  */
 export function packAsRetrievedNote({
   contractAddress,
+  owner,
+  randomness,
+  storageSlot,
   noteNonce,
   index,
   note,
 }: {
   contractAddress: AztecAddress;
+  owner: AztecAddress;
+  randomness: Fr;
+  storageSlot: Fr;
   noteNonce: Fr;
   index?: bigint;
   note: Note;
 }) {
   // If index is undefined, the note is transient which implies that the nonzero_note_hash_counter has to be true
-  const noteIsTransient = index === undefined;
-  const nonzeroNoteHashCounter = noteIsTransient ? true : false;
+  const nonzeroNoteHashCounter = index === undefined;
 
   // To pack the note as retrieved note we first need to reconstruct the note metadata.
   const noteMetadata = fromRawData(nonzeroNoteHashCounter, noteNonce);
 
-  // Pack metadata first (stage and maybe_note_nonce), followed by the rest
-  return [...note.items, contractAddress, new Fr(noteMetadata.stage), noteMetadata.maybeNoteNonce];
+  // Pack in order: note, contract_address, owner, randomness, storage_slot, metadata (stage, maybe_note_nonce)
+  return [
+    ...note.items,
+    contractAddress,
+    owner,
+    randomness,
+    storageSlot,
+    new Fr(noteMetadata.stage),
+    noteMetadata.maybeNoteNonce,
+  ];
 }