@aztec/pxe 0.0.0-test.1 → 0.0.1-commit.001888fc

package/src/contract_function_simulator/oracle/interfaces.ts

@@ -0,0 +1,184 @@
+import type { ARCHIVE_HEIGHT, L1_TO_L2_MSG_TREE_HEIGHT, NOTE_HASH_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 { MembershipWitness } from '@aztec/foundation/trees';
+import type { FunctionSelector, NoteSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { BlockHash } from '@aztec/stdlib/block';
+import type { ContractInstance, PartialAddress } from '@aztec/stdlib/contract';
+import type { KeyValidationRequest } from '@aztec/stdlib/kernel';
+import type { PublicKeys } from '@aztec/stdlib/keys';
+import type { ContractClassLog, Tag } from '@aztec/stdlib/logs';
+import type { Note, NoteStatus } from '@aztec/stdlib/note';
+import { 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;
+  /** True if the note is pending, false if settled. */
+  isPending: boolean;
+  /** The corresponding nullifier of the note. Undefined for pending notes. */
+  siloedNullifier?: Fr;
+}
+
+// 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;
+
+  getRandomField(): Fr;
+  assertCompatibleOracleVersion(version: number): void;
+  log(level: number, message: string, fields: Fr[]): Promise<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;
+
+  getUtilityContext(): UtilityContext;
+  getKeyValidationRequest(pkMHash: Fr): Promise<KeyValidationRequest>;
+  getContractInstance(address: AztecAddress): Promise<ContractInstance>;
+  getNoteHashMembershipWitness(
+    anchorBlockHash: BlockHash,
+    noteHash: Fr,
+  ): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT> | undefined>;
+  getBlockHashMembershipWitness(
+    anchorBlockHash: BlockHash,
+    blockHash: BlockHash,
+  ): Promise<MembershipWitness<typeof ARCHIVE_HEIGHT> | undefined>;
+  getNullifierMembershipWitness(
+    anchorBlockHash: BlockHash,
+    nullifier: Fr,
+  ): Promise<NullifierMembershipWitness | undefined>;
+  getPublicDataWitness(anchorBlockHash: BlockHash, leafSlot: Fr): Promise<PublicDataWitness | undefined>;
+  getLowNullifierMembershipWitness(
+    anchorBlockHash: BlockHash,
+    nullifier: Fr,
+  ): Promise<NullifierMembershipWitness | undefined>;
+  getBlockHeader(blockNumber: BlockNumber): Promise<BlockHeader | undefined>;
+  tryGetPublicKeysAndPartialAddress(
+    account: AztecAddress,
+  ): Promise<{ publicKeys: PublicKeys; partialAddress: PartialAddress } | undefined>;
+  getAuthWitness(messageHash: Fr): Promise<Fr[] | undefined>;
+  getNotes(
+    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[]>;
+  checkNullifierExists(innerNullifier: Fr): Promise<boolean>;
+  getL1ToL2MembershipWitness(
+    contractAddress: AztecAddress,
+    messageHash: Fr,
+    secret: Fr,
+  ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>>;
+  storageRead(
+    anchorBlockHash: BlockHash,
+    contractAddress: AztecAddress,
+    startStorageSlot: Fr,
+    numberOfElements: number,
+  ): Promise<Fr[]>;
+  fetchTaggedLogs(pendingTaggedLogArrayBaseSlot: Fr): Promise<void>;
+  validateAndStoreEnqueuedNotesAndEvents(
+    contractAddress: AztecAddress,
+    noteValidationRequestsArrayBaseSlot: Fr,
+    eventValidationRequestsArrayBaseSlot: Fr,
+    maxNotePackedLen: number,
+    maxEventSerializedLen: number,
+  ): Promise<void>;
+  bulkRetrieveLogs(
+    contractAddress: AztecAddress,
+    logRetrievalRequestsArrayBaseSlot: Fr,
+    logRetrievalResponsesArrayBaseSlot: Fr,
+  ): Promise<void>;
+  utilityResolveMessageContexts(
+    contractAddress: AztecAddress,
+    messageContextRequestsArrayBaseSlot: Fr,
+    messageContextResponsesArrayBaseSlot: Fr,
+  ): Promise<void>;
+  storeCapsule(contractAddress: AztecAddress, key: Fr, capsule: Fr[]): Promise<void>;
+  loadCapsule(contractAddress: AztecAddress, key: Fr): Promise<Fr[] | null>;
+  deleteCapsule(contractAddress: AztecAddress, key: Fr): Promise<void>;
+  copyCapsule(contractAddress: AztecAddress, srcKey: Fr, dstKey: Fr, numEntries: number): Promise<void>;
+  aes128Decrypt(ciphertext: Buffer, iv: Buffer, symKey: Buffer): Promise<Buffer>;
+  getSharedSecret(address: AztecAddress, ephPk: Point): Promise<Point>;
+  emitOffchainEffect(data: Fr[]): Promise<void>;
+}
+
+/**
+ * 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;
+
+  storeInExecutionCache(values: Fr[], hash: Fr): void;
+  loadFromExecutionCache(hash: Fr): Promise<Fr[]>;
+  notifyCreatedNote(
+    owner: AztecAddress,
+    storageSlot: Fr,
+    randomness: Fr,
+    noteTypeId: NoteSelector,
+    note: Fr[],
+    noteHash: Fr,
+    counter: number,
+  ): void;
+  notifyNullifiedNote(innerNullifier: Fr, noteHash: Fr, counter: number): Promise<void>;
+  notifyCreatedNullifier(innerNullifier: Fr): Promise<void>;
+  isNullifierPending(innerNullifier: Fr, contractAddress: AztecAddress): Promise<boolean>;
+  notifyCreatedContractClassLog(log: ContractClassLog, counter: number): void;
+  callPrivateFunction(
+    targetContractAddress: AztecAddress,
+    functionSelector: FunctionSelector,
+    argsHash: Fr,
+    sideEffectCounter: number,
+    isStaticCall: boolean,
+  ): Promise<{ endSideEffectCounter: Fr; returnsHash: Fr }>;
+  validatePublicCalldata(calldataHash: Fr): Promise<void>;
+  notifyRevertiblePhaseStart(minRevertibleSideEffectCounter: number): Promise<void>;
+  inRevertiblePhase(sideEffectCounter: number): Promise<boolean>;
+  getSenderForTags(): Promise<AztecAddress | undefined>;
+  setSenderForTags(senderForTags: AztecAddress): Promise<void>;
+  getNextAppTagAsSender(sender: AztecAddress, recipient: AztecAddress): Promise<Tag>;
+}

package/src/contract_function_simulator/oracle/legacy_oracle_mappings.ts

@@ -0,0 +1,142 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { ACIRCallback, ACVMField } from '@aztec/simulator/client';
+
+import type { Oracle } from './oracle.js';
+
+/**
+ * Builds legacy oracle name callbacks for pinned protocol contracts whose artifacts are committed and cannot be
+ * changed.
+ * TODO(F-416): Remove these aliases on v5 when protocol contracts are redeployed.
+ */
+export function buildLegacyOracleCallbacks(oracle: Oracle): ACIRCallback {
+  return {
+    // Simple prefix renames (privateXxx/utilityXxx → aztec_prv_/aztec_utl_)
+    utilityLog: (
+      level: ACVMField[],
+      message: ACVMField[],
+      _ignoredFieldsSize: ACVMField[],
+      fields: ACVMField[],
+    ): Promise<ACVMField[]> => oracle.aztec_utl_log(level, message, _ignoredFieldsSize, fields),
+    utilityAssertCompatibleOracleVersion: (version: ACVMField[]): Promise<ACVMField[]> =>
+      oracle.aztec_utl_assertCompatibleOracleVersion(version),
+    utilityLoadCapsule: (
+      contractAddress: ACVMField[],
+      slot: ACVMField[],
+      tSize: ACVMField[],
+    ): Promise<(ACVMField | ACVMField[])[]> => oracle.aztec_utl_loadCapsule(contractAddress, slot, tSize),
+    privateStoreInExecutionCache: (values: ACVMField[], hash: ACVMField[]): Promise<ACVMField[]> =>
+      oracle.aztec_prv_storeInExecutionCache(values, hash),
+    privateLoadFromExecutionCache: (returnsHash: ACVMField[]): Promise<ACVMField[][]> =>
+      oracle.aztec_prv_loadFromExecutionCache(returnsHash),
+    privateCallPrivateFunction: (
+      contractAddress: ACVMField[],
+      functionSelector: ACVMField[],
+      argsHash: ACVMField[],
+      sideEffectCounter: ACVMField[],
+      isStaticCall: ACVMField[],
+    ): Promise<ACVMField[][]> =>
+      oracle.aztec_prv_callPrivateFunction(
+        contractAddress,
+        functionSelector,
+        argsHash,
+        sideEffectCounter,
+        isStaticCall,
+      ),
+    privateIsNullifierPending: (innerNullifier: ACVMField[], contractAddress: ACVMField[]): Promise<ACVMField[]> =>
+      oracle.aztec_prv_isNullifierPending(innerNullifier, contractAddress),
+    privateNotifyCreatedNullifier: (innerNullifier: ACVMField[]): Promise<ACVMField[]> =>
+      oracle.aztec_prv_notifyCreatedNullifier(innerNullifier),
+    privateNotifyCreatedContractClassLog: (
+      contractAddress: ACVMField[],
+      message: ACVMField[],
+      length: ACVMField[],
+      counter: ACVMField[],
+    ): Promise<ACVMField[]> =>
+      oracle.aztec_prv_notifyCreatedContractClassLog(contractAddress, message, length, counter),
+    utilityGetUtilityContext: (): Promise<(ACVMField | ACVMField[])[]> => oracle.aztec_utl_getUtilityContext(),
+    utilityStorageRead: (
+      blockHash: ACVMField[],
+      contractAddress: ACVMField[],
+      startStorageSlot: ACVMField[],
+      numberOfElements: ACVMField[],
+    ): Promise<ACVMField[][]> =>
+      oracle.aztec_utl_storageRead(blockHash, contractAddress, startStorageSlot, numberOfElements),
+    utilityStoreCapsule: (
+      contractAddress: ACVMField[],
+      slot: ACVMField[],
+      capsule: ACVMField[],
+    ): Promise<ACVMField[]> => oracle.aztec_utl_storeCapsule(contractAddress, slot, capsule),
+    utilityCopyCapsule: (
+      contractAddress: ACVMField[],
+      srcSlot: ACVMField[],
+      dstSlot: ACVMField[],
+      numEntries: ACVMField[],
+    ): Promise<ACVMField[]> => oracle.aztec_utl_copyCapsule(contractAddress, srcSlot, dstSlot, numEntries),
+    utilityDeleteCapsule: (contractAddress: ACVMField[], slot: ACVMField[]): Promise<ACVMField[]> =>
+      oracle.aztec_utl_deleteCapsule(contractAddress, slot),
+    utilityAes128Decrypt: (
+      ciphertextBVecStorage: ACVMField[],
+      ciphertextLength: ACVMField[],
+      iv: ACVMField[],
+      symKey: ACVMField[],
+    ): Promise<(ACVMField | ACVMField[])[]> =>
+      oracle.aztec_utl_aes128Decrypt(ciphertextBVecStorage, ciphertextLength, iv, symKey),
+    utilityGetSharedSecret: (
+      address: ACVMField[],
+      ephPKField0: ACVMField[],
+      ephPKField1: ACVMField[],
+      ephPKField2: ACVMField[],
+    ): Promise<ACVMField[]> => oracle.aztec_utl_getSharedSecret(address, ephPKField0, ephPKField1, ephPKField2),
+    utilityFetchTaggedLogs: (pendingTaggedLogArrayBaseSlot: ACVMField[]): Promise<ACVMField[]> =>
+      oracle.aztec_utl_fetchTaggedLogs(pendingTaggedLogArrayBaseSlot),
+    utilityBulkRetrieveLogs: (
+      contractAddress: ACVMField[],
+      logRetrievalRequestsArrayBaseSlot: ACVMField[],
+      logRetrievalResponsesArrayBaseSlot: ACVMField[],
+    ): Promise<ACVMField[]> =>
+      oracle.aztec_utl_bulkRetrieveLogs(
+        contractAddress,
+        logRetrievalRequestsArrayBaseSlot,
+        logRetrievalResponsesArrayBaseSlot,
+      ),
+    utilityGetL1ToL2MembershipWitness: (
+      contractAddress: ACVMField[],
+      messageHash: ACVMField[],
+      secret: ACVMField[],
+    ): Promise<(ACVMField | ACVMField[])[]> =>
+      oracle.aztec_utl_getL1ToL2MembershipWitness(contractAddress, messageHash, secret),
+    utilityEmitOffchainEffect: (data: ACVMField[]): Promise<ACVMField[]> => oracle.aztec_utl_emitOffchainEffect(data),
+    // Adapter: old 3-param signature → new 5-param with injected constants.
+    // Values derived from: MAX_MESSAGE_CONTENT_LEN(11) - RESERVED_FIELDS (3 for notes, 1 for events).
+    utilityValidateAndStoreEnqueuedNotesAndEvents: (
+      contractAddress: ACVMField[],
+      noteValidationRequestsArrayBaseSlot: ACVMField[],
+      eventValidationRequestsArrayBaseSlot: ACVMField[],
+    ): Promise<ACVMField[]> =>
+      oracle.aztec_utl_validateAndStoreEnqueuedNotesAndEvents(
+        contractAddress,
+        noteValidationRequestsArrayBaseSlot,
+        eventValidationRequestsArrayBaseSlot,
+        [new Fr(8).toString()],
+        [new Fr(10).toString()],
+      ),
+    // Renames (same signature, different oracle name)
+    privateNotifySetMinRevertibleSideEffectCounter: (counter: ACVMField[]): Promise<ACVMField[]> =>
+      oracle.aztec_prv_notifyRevertiblePhaseStart(counter),
+    privateIsSideEffectCounterRevertible: (sideEffectCounter: ACVMField[]): Promise<ACVMField[]> =>
+      oracle.aztec_prv_inRevertiblePhase(sideEffectCounter),
+    // Signature changes: old 4-param oracles → new 1-param validatePublicCalldata
+    privateNotifyEnqueuedPublicFunctionCall: (
+      _contractAddress: ACVMField[],
+      calldataHash: ACVMField[],
+      _sideEffectCounter: ACVMField[],
+      _isStaticCall: ACVMField[],
+    ): Promise<ACVMField[]> => oracle.aztec_prv_validatePublicCalldata(calldataHash),
+    privateNotifySetPublicTeardownFunctionCall: (
+      _contractAddress: ACVMField[],
+      calldataHash: ACVMField[],
+      _sideEffectCounter: ACVMField[],
+      _isStaticCall: ACVMField[],
+    ): Promise<ACVMField[]> => oracle.aztec_prv_validatePublicCalldata(calldataHash),
+  };
+}

package/src/contract_function_simulator/oracle/message_load_oracle_inputs.ts

@@ -0,0 +1,23 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { SiblingPath } from '@aztec/foundation/trees';
+
+export class MessageLoadOracleInputs<N extends number> {
+  constructor(
+    /** The index of the message commitment in the merkle tree. */
+    public index: bigint,
+    /** The path in the merkle tree to the message. */
+    public siblingPath: SiblingPath<N>,
+  ) {}
+
+  toFields(): Fr[] {
+    return [new Fr(this.index), ...this.siblingPath.toFields()];
+  }
+
+  /**
+   * Returns a representation of the public data witness as expected by intrinsic Noir deserialization.
+   */
+  public toNoirRepresentation(): (string | string[])[] {
+    // TODO(#12874): remove the stupid as string conversion by modifying ForeignCallOutput type in acvm.js
+    return [new Fr(this.index).toString() as string, this.siblingPath.toFields().map(fr => fr.toString()) as string[]];
+  }
+}

package/src/contract_function_simulator/oracle/note_packing_utils.ts

@@ -0,0 +1,68 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { Note } from '@aztec/stdlib/note';
+
+// TS equivalent of the `NoteMetadata::from_raw_data` function in `aztec/src/note/note_metadata.nr`
+function fromRawData(nonzeroNoteHashCounter: boolean, maybeNoteNonce: Fr): { stage: number; maybeNoteNonce: Fr } {
+  if (nonzeroNoteHashCounter) {
+    if (maybeNoteNonce.equals(Fr.ZERO)) {
+      return { stage: 1, maybeNoteNonce }; // PENDING_SAME_PHASE
+    } else {
+      return { stage: 2, maybeNoteNonce }; // PENDING_PREVIOUS_PHASE
+    }
+  } else if (!maybeNoteNonce.equals(Fr.ZERO)) {
+    return { stage: 3, maybeNoteNonce }; // SETTLED
+  } else {
+    throw new Error('Note has a zero note hash counter and no nonce - existence cannot be proven');
+  }
+}
+
+/**
+ * Packs a note in a format that is compatible with the default Packable implementation of the hinted note.
+ *
+ * @dev Unlike the default Packable implementation, this function first constructs the note metadata from the inputs
+ * and only after that it packs the hinted note. Hence it doesn't map one to one with `HintedNote::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 isPending - True if the note is pending, false if settled
+ * @param note - The note content containing the actual note data
+ * @returns The packed note as an array of field elements
+ */
+export function packAsHintedNote({
+  contractAddress,
+  owner,
+  randomness,
+  storageSlot,
+  noteNonce,
+  isPending,
+  note,
+}: {
+  contractAddress: AztecAddress;
+  owner: AztecAddress;
+  randomness: Fr;
+  storageSlot: Fr;
+  noteNonce: Fr;
+  isPending: boolean;
+  note: Note;
+}) {
+  // If the note is pending it means it has a non-zero note hash counter associated with it.
+  const nonZeroNoteHashCounter = isPending;
+
+  // To pack the note as hinted note we first need to reconstruct the note metadata.
+  const noteMetadata = fromRawData(nonZeroNoteHashCounter, noteNonce);
+
+  // 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,
+  ];
+}