@aztec/pxe 0.0.1-commit.2f68f620 → 0.0.1-commit.3100065

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,8 +1,9 @@
-import { BlockNumber } from '@aztec/foundation/branded-types';
+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 {
@@ -15,47 +16,20 @@ export enum LogSource {
  * Intermediate struct used to perform batch log retrieval by PXE. The `utilityBulkRetrieveLogs` oracle expects values of this
  * type to be stored in a `EphemeralArray`.
  */
-export class LogRetrievalRequest {
-  constructor(
-    public contractAddress: AztecAddress,
-    public tag: Tag,
-    public source: LogSource = LogSource.PUBLIC_AND_PRIVATE,
-    public fromBlock?: BlockNumber,
-    public toBlock?: BlockNumber,
-  ) {}
-
-  toFields(): Fr[] {
-    return [
-      this.contractAddress.toField(),
-      this.tag.value,
-      new Fr(this.source),
-      new Fr(this.fromBlock !== undefined ? 1 : 0),
-      new Fr(this.fromBlock ?? 0),
-      new Fr(this.toBlock !== undefined ? 1 : 0),
-      new Fr(this.toBlock ?? 0),
-    ];
-  }
-
-  static fromFields(fields: Fr[] | FieldReader): LogRetrievalRequest {
-    const reader = FieldReader.asReader(fields);
-
-    const contractAddress = AztecAddress.fromField(reader.readField());
-    const tag = new Tag(reader.readField());
-    const sourceNum = reader.readField().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(', ')}`);
-    }
-    const source = sourceNum as LogSource;
-
-    const fromBlockIsSome = reader.readBoolean();
-    const fromBlockValue = reader.readField();
-    const fromBlock = fromBlockIsSome ? BlockNumber(fromBlockValue.toNumber()) : undefined;
-
-    const toBlockIsSome = reader.readBoolean();
-    const toBlockValue = reader.readField();
-    const toBlock = toBlockIsSome ? BlockNumber(toBlockValue.toNumber()) : undefined;
-
-    return new LogRetrievalRequest(contractAddress, tag, source, fromBlock, toBlock);
+export type LogRetrievalRequest = {
+  contractAddress: AztecAddress;
+  tag: Tag;
+  source: LogSource;
+  fromBlock: Option<BlockNumber>;
+  toBlock: Option<BlockNumber>;
+};
+
+/** 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 `EphemeralArray`.
  */
-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[]
- */
-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_validation_request.ts

@@ -23,8 +23,8 @@ export class 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();

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

@@ -8,7 +8,9 @@
 export class Option<T> {
   private constructor(
     public readonly value: T | undefined,
-    public readonly template: T | undefined,
+    // `unknown` (not the descriptor shape) keeps this generic Option decoupled from the serialization layer's
+    // `{ length }`/`{ maxLength }` size descriptors; only the None-serialization path inspects it.
+    public readonly size: unknown,
   ) {}
 
   /**
@@ -26,25 +28,22 @@ export class Option<T> {
   /**
    * Construct an absent Option.
    *
-   * When serialized back to ACVM, the `None` case must produce the same number of fields as `Some`.
-   * For types whose wire size varies per call site (`BoundedVec`, `FixedArray`), pass a `template` so the
-   * serializer knows how many zero fields to emit. Omit the template when the Option will not be
-   * re-serialized (e.g. deserialized input params).
-   *
-   * @param template - A representative empty `T` whose serialization determines the zero-filled wire format.
+   * When serialized back to ACVM, the `None` case must produce the same number of fields as `Some`. For an inner type whose
+   * wire size varies per call site (`BoundedVec`, an array), pass a `size` descriptor so the inner type's shape can
+   * resolve how many zero fields to emit; fixed-size inners take no argument.
    *
    * @example None for a fixed-size type:
    * ```ts
-   * return Option.none(AztecAddress.ZERO);
+   * return Option.none();
    * ```
    *
    * @example None for a dynamic-size type:
    * ```ts
-   * return Option.none(BoundedVec.empty<number>({ maxLength: ciphertext.maxLength }));
+   * return Option.none({ maxLength: ciphertext.maxLength });
    * ```
    */
-  static none<T>(template?: T): Option<T> {
-    return new Option<T>(undefined, template);
+  static none<T>(size?: unknown): Option<T> {
+    return new Option<T>(undefined, size);
   }
 
   /**
@@ -66,4 +65,11 @@ export class Option<T> {
   isNone(): this is Option<T> & { value: undefined } {
     return this.value === undefined;
   }
+
+  equals(other: Option<T>, innerEquals: (a: T, b: T) => boolean): boolean {
+    if (this.isSome() && other.isSome()) {
+      return innerEquals(this.value, other.value);
+    }
+    return this.isNone() && other.isNone();
+  }
 }

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

@@ -0,0 +1,8 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+
+/**
+ * The block a retractable fact originates from.
+ *
+ * A TS version of the `OriginBlock` struct in `facts/mod.nr`.
+ */
+export type OriginBlock = { blockNumber: number; blockHash: Fr };

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

@@ -0,0 +1,12 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+
+import type { ResolvedTx } from './resolved_tx.js';
+
+/**
+ * Represents a pending tagged log as it is stored in the pending tagged log array to which the fetchTaggedLogs oracle
+ * inserts found private logs. A TS version of `pending_tagged_log.nr`.
+ */
+export type PendingTaggedLog = {
+  log: Fr[];
+  context: ResolvedTx;
+};

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

@@ -1,27 +1,5 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { FieldReader } from '@aztec/foundation/serialize';
-import { AppTaggingSecretKind } from '@aztec/stdlib/logs';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { AppTaggingSecretKind } from '@aztec/stdlib/logs';
 
-/** A tagging secret an app supplies explicitly to `getPendingTaggedLogs` when PXE cannot derive it internally. */
-export class ProvidedSecret {
-  constructor(
-    public secret: Fr,
-    public mode: AppTaggingSecretKind,
-  ) {}
-
-  static fromFields(fields: Fr[] | FieldReader): ProvidedSecret {
-    const reader = FieldReader.asReader(fields);
-    return new ProvidedSecret(reader.readField(), kindFromField(reader.readField()));
-  }
-}
-
-function kindFromField(mode: Fr): AppTaggingSecretKind {
-  switch (mode.toBigInt()) {
-    case 0n:
-      return AppTaggingSecretKind.UNCONSTRAINED;
-    case 1n:
-      return AppTaggingSecretKind.CONSTRAINED;
-    default:
-      throw new Error(`Invalid app tagging secret kind: ${mode.toString()}`);
-  }
-}
+/** A tagging secret an app supplies explicitly to `getPendingTaggedLogsV2` when PXE cannot derive it internally. */
+export type ProvidedSecret = { secret: Fr; mode: AppTaggingSecretKind };

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

@@ -0,0 +1,66 @@
+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:
+      assertAbsentSecret(kind, secret);
+      return { type: 'non-interactive-handshake' };
+    case INTERACTIVE_HANDSHAKE:
+      assertAbsentSecret(kind, secret);
+      return { type: 'interactive-handshake' };
+    case UNCONSTRAINED_SECRET:
+      return { type: 'unconstrained-secret', secret };
+    default:
+      throw new Error(`Unrecognized resolved tagging strategy kind: ${kind}`);
+  }
+}
+
+function assertAbsentSecret(kind: number, secret: Fr): void {
+  if (!secret.isZero()) {
+    throw new Error(`Resolved tagging strategy ${kind} must not include a secret`);
+  }
+}

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 ? await 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}`);
+  }
+}