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

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

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

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

@@ -0,0 +1,53 @@
+import { MAX_NOTE_HASHES_PER_TX } from '@aztec/constants';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { TxHash } from '@aztec/stdlib/tx';
+
+/**
+ * The resolved on-chain context of a transaction.
+ *
+ * Carries the note hashes and first nullifier needed to discover notes that originated from the transaction, plus the
+ * number and hash of the block in which it was mined.
+ *
+ * A TS version of the `ResolvedTx` struct in `oracle/tx_resolution.nr`.
+ */
+export class ResolvedTx {
+  constructor(
+    public txHash: TxHash,
+    public uniqueNoteHashesInTx: Fr[],
+    public firstNullifierInTx: Fr,
+    public blockNumber: number,
+    public blockHash: Fr,
+  ) {}
+
+  toFields(): Fr[] {
+    return [
+      this.txHash.hash,
+      ...serializeBoundedVec(this.uniqueNoteHashesInTx, MAX_NOTE_HASHES_PER_TX),
+      this.firstNullifierInTx,
+      new Fr(this.blockNumber),
+      this.blockHash,
+    ];
+  }
+
+  static empty(): ResolvedTx {
+    return new ResolvedTx(TxHash.zero(), [], Fr.ZERO, 0, Fr.ZERO);
+  }
+}
+
+/**
+ * Helper function to serialize a bounded vector according to Noir's BoundedVec format: the storage array padded to
+ * `maxLength`, followed by the actual length.
+ * @param values - The values to serialize
+ * @param maxLength - The maximum length of the bounded vector
+ * @returns The serialized bounded vector as Fr[]
+ */
+function serializeBoundedVec(values: Fr[], maxLength: number): Fr[] {
+  const storage = padArrayEnd(
+    values,
+    Fr.ZERO,
+    maxLength,
+    `Attempted to serialize ${values} values into a BoundedVec with max length ${maxLength}`,
+  );
+  return [...storage, new Fr(values.length)];
+}

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

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

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

@@ -1,23 +1,11 @@
-import { toACVMField } from '@aztec/simulator/client';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 
 /**
  * TypeScript counterpart of utility_context.nr. Used only as a return value for the utilityGetUtilityContext oracle.
  */
-export class UtilityContext {
-  constructor(
-    public readonly blockHeader: BlockHeader,
-    public readonly contractAddress: AztecAddress,
-  ) {}
-
-  /**
-   * 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
-    const blockHeaderFields = this.blockHeader.toFields().map(toACVMField);
-    return [...blockHeaderFields, this.contractAddress.toString() as string];
-  }
-}
+export type UtilityContext = {
+  blockHeader: BlockHeader;
+  contractAddress: AztecAddress;
+  msgSender: AztecAddress;
+};

package/src/contract_function_simulator/oracle/acir_callback.ts

@@ -0,0 +1,154 @@
+import type { ACIRCallback, ACVMField } from '@aztec/simulator/client';
+
+import { ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR } from '../../oracle_version.js';
+import type { IMiscOracle, IPrivateExecutionOracle, IUtilityExecutionOracle } from './interfaces.js';
+import { LEGACY_ORACLE_REGISTRY, type LegacyOracleEntry } from './legacy_oracle_registry.js';
+import { type NamedValue, ORACLE_REGISTRY, type OracleRegistryEntry, makeEntry } from './oracle_registry.js';
+
+export class UnavailableOracleError extends Error {
+  constructor(oracleName: string) {
+    super(`${oracleName} oracles not available with the current handler`);
+  }
+}
+
+/**
+ * Builds an ACIR callback from the oracle registry and a handler object.
+ *
+ * Each oracle call is dispatched by matching the oracle name against the registry for serialization, parsing the
+ * `aztec_{scope}_{methodName}` convention to resolve the handler, and calling the method directly. Unknown oracle
+ * names produce enhanced error messages based on the contract's oracle version.
+ */
+export function buildACIRCallback(
+  handler: OracleHandler,
+  registries: {
+    real?: Record<string, OracleRegistryEntry>;
+    legacy?: Record<string, LegacyOracleEntry>;
+  } = {},
+): ACIRCallback {
+  const { real = ORACLE_REGISTRY, legacy: legacyRegistry = LEGACY_ORACLE_REGISTRY } = registries;
+  const target = {} as ACIRCallback;
+  for (const [oracleKey, entry] of Object.entries(real)) {
+    const { scope, methodName } = parseOracleName(oracleKey, 'Oracle');
+    target[oracleKey] = async (...inputs: ACVMField[][]) => {
+      assertHandlerSupportsScope(handler, scope);
+      const named = entry.deserializeParams(inputs);
+      const positional = named.map((p: NamedValue) => p.value);
+      const result = await (handler as any)[methodName](...positional);
+      return entry.serializeReturn(result);
+    };
+  }
+
+  // Legacy oracle names: served for contracts compiled against a retired oracle version. Each reuses the current
+  // handler of its `modernOracle` and reshapes the wire (params and/or return) back to what the old bytecode expects.
+  for (const [legacyKey, legacy] of Object.entries(legacyRegistry)) {
+    const { scope } = parseOracleName(legacyKey, 'Legacy oracle');
+    if (legacyKey in target) {
+      throw new Error(`Legacy oracle "${legacyKey}" collides with a live oracle of the same name in the registry`);
+    }
+    const modernEntry = real[legacy.modernOracle];
+    const { methodName } = parseOracleName(legacy.modernOracle, 'Oracle');
+    // Override only the side whose wire changed; inherit the other from the modern entry.
+    const paramOverride = legacy.params;
+    const paramSource = paramOverride ? makeEntry({ params: [...paramOverride.legacyType] }) : modernEntry;
+    const returnOverride = legacy.returnType;
+    const returnSource = returnOverride ? makeEntry({ returnType: returnOverride.legacyType }) : modernEntry;
+    target[legacyKey] = async (...inputs: ACVMField[][]) => {
+      assertHandlerSupportsScope(handler, scope);
+      const legacyArgs = paramSource.deserializeParams(inputs).map(p => p.value);
+      const positional = paramOverride ? paramOverride.mapping(legacyArgs) : legacyArgs;
+      const result = await (handler as any)[methodName](...positional);
+      return returnSource.serializeReturn(returnOverride ? returnOverride.mapping(result) : result);
+    };
+  }
+
+  return new Proxy(target, makeUnknownOracleTrap(handler));
+}
+
+/** Parses an `aztec_{scope}_{method}` oracle name into its parts, throwing if it doesn't follow the convention. */
+function parseOracleName(key: string, label: string): { scope: string; methodName: string } {
+  const match = key.match(/^aztec_(\w+?)_(.+)$/);
+  if (!match) {
+    throw new Error(`${label} "${key}" does not follow the aztec_{scope}_{method} convention`);
+  }
+  return { scope: match[1], methodName: match[2] };
+}
+
+/**
+ * Proxy trap for the callback table: a known oracle name passes through; an unknown one throws a diagnostic keyed on
+ * the contract's oracle version (version unknown, contract newer than this environment, or a same-version mismatch).
+ */
+function makeUnknownOracleTrap(handler: OracleHandler): ProxyHandler<ACIRCallback> {
+  return {
+    get(obj, prop: string) {
+      // Own-property check only: `in` would match inherited `Object.prototype` keys (e.g. `constructor`, `toString`)
+      // and return the built-in instead of falling through to the unknown-oracle diagnostic below.
+      if (Object.hasOwn(obj, prop)) {
+        return (obj as Record<string, unknown>)[prop];
+      }
+
+      return () => {
+        let contractVersion = undefined;
+        if ('nonOracleFunctionGetContractOracleVersion' in handler) {
+          contractVersion = (
+            handler as unknown as NonOracleFunctionGetContractOracleVersion
+          ).nonOracleFunctionGetContractOracleVersion();
+        }
+        if (!contractVersion) {
+          throw new Error(
+            `Oracle '${prop}' not found and the contract's oracle version is unknown (the version check oracle ` +
+              `was not called before '${prop}'). This usually means the contract was not compiled with the ` +
+              `#[aztec] macro, which injects the version check as the first oracle call in every private/utility ` +
+              `external function. If you're using a custom entry point, ensure assert_compatible_oracle_version() ` +
+              `is called before any other oracle calls. See https://docs.aztec.network/errors/8`,
+          );
+        } else if (contractVersion.minor > ORACLE_VERSION_MINOR) {
+          throw new Error(
+            `Oracle '${prop}' not found.` +
+              ` This usually means the contract requires a newer private execution environment than you have.` +
+              ` Upgrade your private execution environment to a compatible version. The contract was compiled with` +
+              ` Aztec.nr oracle version ${contractVersion.major}.${contractVersion.minor}, but this private` +
+              ` execution environment only supports up to ${ORACLE_VERSION_MAJOR}.${ORACLE_VERSION_MINOR}.` +
+              ` See https://docs.aztec.network/errors/8`,
+          );
+        } else {
+          throw new Error(
+            `Oracle '${prop}' not found.` +
+              ` The contract's oracle version (${contractVersion.major}.${contractVersion.minor}) is compatible` +
+              ` with this private execution environment (${ORACLE_VERSION_MAJOR}.${ORACLE_VERSION_MINOR}), so all` +
+              ` standard oracles should be available. This could mean the contract was compiled against a modified` +
+              ` version of Aztec.nr, or that it references an oracle that does not exist.` +
+              ` See https://docs.aztec.network/errors/8`,
+          );
+        }
+      };
+    },
+  };
+}
+
+type OracleHandler = IMiscOracle & (IUtilityExecutionOracle | IPrivateExecutionOracle);
+
+type NonOracleFunctionGetContractOracleVersion = {
+  nonOracleFunctionGetContractOracleVersion(): { major: number; minor: number } | undefined;
+};
+
+function assertHandlerSupportsScope(handler: OracleHandler, scope: string): void {
+  switch (scope) {
+    case 'misc':
+      if (!('isMisc' in handler)) {
+        throw new UnavailableOracleError('Misc');
+      }
+      break;
+    case 'utl':
+      if (!('isUtility' in handler)) {
+        throw new UnavailableOracleError('Utility');
+      }
+      break;
+    case 'prv':
+      if (!('isPrivate' in handler)) {
+        throw new UnavailableOracleError('Private');
+      }
+      break;
+    default:
+      throw new Error(`Unknown oracle scope: ${scope}`);
+  }
+}

package/src/contract_function_simulator/oracle/index.ts

@@ -1,16 +1,2 @@
-import type { Oracle } from './oracle.js';
-
-export * from './oracle.js';
+export * from './acir_callback.js';
 export * from './interfaces.js';
-
-/**
- * A conditional type that takes a type `T` and returns a union of its method names.
- */
-type MethodNames<T> = {
-  [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
-}[keyof T];
-
-/**
- * Available oracle function names.
- */
-export type ORACLE_NAMES = MethodNames<Oracle>;

package/src/contract_function_simulator/oracle/interfaces.ts

@@ -1,194 +1,20 @@
-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.
+import type { HandlersForPrefix, ORACLE_REGISTRY } from './oracle_registry.js';
 
 /**
- * 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).
+ * Miscellaneous oracle methods, not very Aztec-specific and expected to be available in 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>;
-}
+export type IMiscOracle = HandlersForPrefix<typeof ORACLE_REGISTRY, 'misc'> & { isMisc: true };
 
 /**
- * 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.
+ * Oracle methods associated with the execution of an Aztec #[external("utility")] function. Note that the IMiscOracle
+ * methods 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>;
-  getPublicKeysAndPartialAddress(
-    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[]>;
-  doesNullifierExist(innerNullifier: Fr): Promise<boolean>;
-  getL1ToL2MembershipWitness(
-    contractAddress: AztecAddress,
-    messageHash: Fr,
-    secret: Fr,
-  ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>>;
-  getFromPublicStorage(
-    anchorBlockHash: BlockHash,
-    contractAddress: AztecAddress,
-    startStorageSlot: Fr,
-    numberOfElements: number,
-  ): Promise<Fr[]>;
-  getPendingTaggedLogs(pendingTaggedLogArrayBaseSlot: Fr, scope: AztecAddress): Promise<void>;
-  validateAndStoreEnqueuedNotesAndEvents(
-    contractAddress: AztecAddress,
-    noteValidationRequestsArrayBaseSlot: Fr,
-    eventValidationRequestsArrayBaseSlot: Fr,
-    maxNotePackedLen: number,
-    maxEventSerializedLen: number,
-    scope: AztecAddress,
-  ): Promise<void>;
-  getLogsByTag(
-    contractAddress: AztecAddress,
-    logRetrievalRequestsArrayBaseSlot: Fr,
-    logRetrievalResponsesArrayBaseSlot: Fr,
-    scope: AztecAddress,
-  ): Promise<void>;
-  getMessageContextsByTxHash(
-    contractAddress: AztecAddress,
-    messageContextRequestsArrayBaseSlot: Fr,
-    messageContextResponsesArrayBaseSlot: Fr,
-    scope: AztecAddress,
-  ): Promise<void>;
-  setCapsule(contractAddress: AztecAddress, key: Fr, capsule: Fr[], scope: AztecAddress): void;
-  getCapsule(contractAddress: AztecAddress, key: Fr, scope: AztecAddress): Promise<Fr[] | null>;
-  deleteCapsule(contractAddress: AztecAddress, key: Fr, scope: AztecAddress): void;
-  copyCapsule(
-    contractAddress: AztecAddress,
-    srcKey: Fr,
-    dstKey: Fr,
-    numEntries: number,
-    scope: AztecAddress,
-  ): Promise<void>;
-  decryptAes128(ciphertext: Buffer, iv: Buffer, symKey: Buffer): Promise<Buffer>;
-  getSharedSecret(address: AztecAddress, ephPk: Point, contractAddress: AztecAddress): Promise<Fr>;
-  setContractSyncCacheInvalid(contractAddress: AztecAddress, scopes: AztecAddress[]): void;
-  emitOffchainEffect(data: Fr[]): Promise<void>;
-}
+export type IUtilityExecutionOracle = HandlersForPrefix<typeof ORACLE_REGISTRY, 'utl'> & { isUtility: true };
 
 /**
- * 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.
+ * Oracle methods associated with the execution of an Aztec #[external("private")] function. Note that both the
+ * IMiscOracle and IUtilityExecutionOracle methods are also expected to be available in these contexts.
  */
-export interface IPrivateExecutionOracle {
-  isPrivate: true;
-
-  setHashPreimage(values: Fr[], hash: Fr): void;
-  getHashPreimage(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 }>;
-  assertValidPublicCalldata(calldataHash: Fr): Promise<void>;
-  notifyRevertiblePhaseStart(minRevertibleSideEffectCounter: number): Promise<void>;
-  isExecutionInRevertiblePhase(sideEffectCounter: number): Promise<boolean>;
-  getSenderForTags(): Promise<AztecAddress | undefined>;
-  setSenderForTags(senderForTags: AztecAddress): Promise<void>;
-  getNextAppTagAsSender(sender: AztecAddress, recipient: AztecAddress): Promise<Tag>;
-}
+export type IPrivateExecutionOracle = HandlersForPrefix<typeof ORACLE_REGISTRY, 'prv'> & { isPrivate: true };

package/src/contract_function_simulator/oracle/legacy_oracle_registry.ts

@@ -0,0 +1,120 @@
+/* eslint-disable camelcase */
+import { MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_CIPHERTEXT_LEN, PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+
+import type { EphemeralArray } from '../noir-structs/ephemeral_array.js';
+import type { LogRetrievalResponse } from '../noir-structs/log_retrieval_response.js';
+import type { PendingTaggedLog } from '../noir-structs/pending_tagged_log.js';
+import type { ResolvedTx } from '../noir-structs/resolved_tx.js';
+import {
+  type InferDeserializedParams,
+  ORACLE_REGISTRY,
+  type OracleRegistryEntry,
+  type ParamTypes,
+  type RegistryParam,
+} from './oracle_registry.js';
+import {
+  EPHEMERAL_ARRAY,
+  FIELD,
+  FIXED_BOUNDED_VEC,
+  STRUCT,
+  TX_HASH,
+  type TypeMapping,
+} from './oracle_type_mappings.js';
+
+const LEGACY_LOG_RETRIEVAL_RESPONSE: TypeMapping<LegacyLogRetrievalResponse> = STRUCT([
+  { name: 'logPayload', type: FIXED_BOUNDED_VEC(FIELD, PRIVATE_LOG_CIPHERTEXT_LEN) },
+  { name: 'txHash', type: TX_HASH },
+  { name: 'uniqueNoteHashesInTx', type: FIXED_BOUNDED_VEC(FIELD, MAX_NOTE_HASHES_PER_TX) },
+  { name: 'firstNullifierInTx', type: FIELD },
+]);
+
+// Block-less transaction context: the prefix of `ResolvedTx`'s wire carried by the original `getPendingTaggedLogs`
+// oracle. Known as `MessageContext` in the Aztec.nr versions that call that oracle.
+const LEGACY_MESSAGE_CONTEXT: TypeMapping<LegacyMessageContext> = STRUCT<LegacyMessageContext>([
+  { name: 'txHash', type: TX_HASH },
+  { name: 'uniqueNoteHashesInTx', type: FIXED_BOUNDED_VEC(FIELD, MAX_NOTE_HASHES_PER_TX) },
+  { name: 'firstNullifierInTx', type: FIELD },
+]);
+
+const LEGACY_PENDING_TAGGED_LOG: TypeMapping<LegacyPendingTaggedLog> = STRUCT<LegacyPendingTaggedLog>([
+  { name: 'log', type: FIXED_BOUNDED_VEC(FIELD, PRIVATE_LOG_SIZE_IN_FIELDS) },
+  { name: 'context', type: LEGACY_MESSAGE_CONTEXT },
+]);
+
+/**
+ * Wire shapes that already-deployed contracts still call by their original oracle name, keyed by that retired name.
+ * New Aztec.nr calls the current name in `ORACLE_REGISTRY`; old bytecode keeps calling the name compiled into it and
+ * is served from here, so versioning an oracle's wire (e.g. adding return fields) stops being a breaking change.
+ *
+ * Append-only. Drop an entry only once the `ORACLE_VERSION_MAJOR` that introduced its successor is retired, since
+ * older contracts can no longer run against this environment.
+ */
+export const LEGACY_ORACLE_REGISTRY: Record<string, LegacyOracleEntry> = {
+  aztec_utl_getLogsByTag: legacyOracle({
+    modernOracle: 'aztec_utl_getLogsByTagV2',
+    returnType: {
+      legacyType: EPHEMERAL_ARRAY(EPHEMERAL_ARRAY(LEGACY_LOG_RETRIEVAL_RESPONSE)),
+      // We can map this directly, since the new type is a superset of the old type
+      mapping: result => result as unknown as EphemeralArray<EphemeralArray<LegacyLogRetrievalResponse>>,
+    },
+  }),
+  aztec_utl_getPendingTaggedLogs: legacyOracle({
+    modernOracle: 'aztec_utl_getPendingTaggedLogsV2',
+    returnType: {
+      legacyType: EPHEMERAL_ARRAY(LEGACY_PENDING_TAGGED_LOG),
+      // We can map this directly, since `ResolvedTx` carries the legacy context's fields under the same names
+      mapping: result => result as unknown as EphemeralArray<LegacyPendingTaggedLog>,
+    },
+  }),
+};
+
+type LegacyLogRetrievalResponse = Pick<
+  LogRetrievalResponse,
+  'logPayload' | 'txHash' | 'uniqueNoteHashesInTx' | 'firstNullifierInTx'
+>;
+
+type LegacyMessageContext = Pick<ResolvedTx, 'txHash' | 'uniqueNoteHashesInTx' | 'firstNullifierInTx'>;
+
+type LegacyPendingTaggedLog = {
+  log: PendingTaggedLog['log'];
+  context: LegacyMessageContext;
+};
+
+type Registry = typeof ORACLE_REGISTRY;
+
+/** The handler return value type of a modern oracle entry. */
+type ReturnValueOf<K extends keyof Registry> = Registry[K] extends OracleRegistryEntry<any, infer R> ? R : never;
+
+/** The modern handler's positional argument tuple, derived from the oracle's declared params. */
+type HandlerArgsOf<K extends keyof Registry> = ParamTypes<ReturnType<Registry[K]['deserializeParams']>>;
+
+/**
+ * A legacy oracle adapter, stored under the retired oracle name that already-deployed contracts still call. It reuses
+ * the handler of `modernOracle` and overrides only the wire side(s) that changed; an omitted side falls back to that
+ * modern entry.
+ */
+export interface LegacyOracleEntry {
+  /** The current oracle whose handler this reuses and whose param/return wire it inherits by default. */
+  modernOracle: keyof Registry;
+  /**
+   * Old param wire. `legacyType` deserializes the old wire; `mapping` bridges the deserialized legacy args to the
+   * modern handler's args. Omit when the param wire is unchanged.
+   */
+  params?: { legacyType: readonly RegistryParam[]; mapping: (legacyArgs: any) => readonly unknown[] };
+  /**
+   * Old return wire. `legacyType` serializes the subset the old contract reads; `mapping` bridges the handler's
+   * current result to that subset's value type. Omit when the return wire is unchanged.
+   */
+  returnType?: { legacyType: TypeMapping; mapping: (result: any) => unknown };
+}
+
+function legacyOracle<K extends keyof Registry, W = never, const TLegacyParams extends RegistryParam[] = []>(entry: {
+  modernOracle: K;
+  params?: {
+    legacyType: [...TLegacyParams];
+    mapping: (legacyArgs: ParamTypes<InferDeserializedParams<TLegacyParams>>) => HandlerArgsOf<K>;
+  };
+  returnType?: { legacyType: TypeMapping<W>; mapping: (result: ReturnValueOf<K>) => W };
+}): LegacyOracleEntry {
+  return entry;
+}