@aztec/pxe 0.0.1-commit.d431d1c → 0.0.1-commit.d939eb5aa

package/src/contract_function_simulator/ephemeral_array_service.ts

@@ -0,0 +1,110 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+
+/** In-memory store for ephemeral arrays scoped to a single contract call frame. */
+export class EphemeralArrayService {
+  /**
+   * Maps a slot to the elements of the array stored at that slot. Each element is a serialized representation of
+   * the original type.
+   */
+  #arrays: Map<string, Fr[][]> = new Map();
+
+  /** Returns all elements in the array, or an empty array if uninitialized. */
+  readArrayAt(slot: Fr): Fr[][] {
+    return this.#arrays.get(slot.toString()) ?? [];
+  }
+
+  #setArray(slot: Fr, array: Fr[][]): void {
+    this.#arrays.set(slot.toString(), array);
+  }
+
+  /** Returns the number of elements in the array at the given slot. */
+  len(slot: Fr): number {
+    return this.readArrayAt(slot).length;
+  }
+
+  /** Appends an element to the array and returns the new length. */
+  push(slot: Fr, elements: Fr[]): number {
+    const array = this.readArrayAt(slot);
+    array.push(elements);
+    this.#setArray(slot, array);
+    return array.length;
+  }
+
+  /** Removes and returns the last element. Throws if empty. */
+  pop(slot: Fr): Fr[] {
+    const array = this.readArrayAt(slot);
+    if (array.length === 0) {
+      throw new Error(`Ephemeral array at slot ${slot} is empty`);
+    }
+    const element = array.pop()!;
+    this.#setArray(slot, array);
+    return element;
+  }
+
+  /** Returns the element at the given index. Throws if out of bounds. */
+  get(slot: Fr, index: number): Fr[] {
+    const array = this.readArrayAt(slot);
+    if (index < 0 || index >= array.length) {
+      throw new Error(
+        `Ephemeral array index ${index} out of bounds for array of length ${array.length} at slot ${slot}`,
+      );
+    }
+    return array[index];
+  }
+
+  /** Overwrites the element at the given index. Throws if out of bounds. */
+  set(slot: Fr, index: number, value: Fr[]): void {
+    const array = this.readArrayAt(slot);
+    if (index < 0 || index >= array.length) {
+      throw new Error(
+        `Ephemeral array index ${index} out of bounds for array of length ${array.length} at slot ${slot}`,
+      );
+    }
+    array[index] = value;
+  }
+
+  /** Removes the element at the given index, shifting subsequent elements backward. Throws if out of bounds. */
+  remove(slot: Fr, index: number): void {
+    const array = this.readArrayAt(slot);
+    if (index < 0 || index >= array.length) {
+      throw new Error(
+        `Ephemeral array index ${index} out of bounds for array of length ${array.length} at slot ${slot}`,
+      );
+    }
+    array.splice(index, 1);
+  }
+
+  /** Removes all elements from the array. */
+  clear(slot: Fr): void {
+    this.#arrays.delete(slot.toString());
+  }
+
+  /** Allocates a fresh, unused slot for a new ephemeral array. */
+  allocateSlot(): Fr {
+    let slot: Fr;
+    do {
+      slot = Fr.random();
+    } while (this.#arrays.has(slot.toString()));
+    return slot;
+  }
+
+  /** Creates a new ephemeral array pre-populated with the given elements and returns its slot. */
+  newArray(elements: Fr[][]): Fr {
+    const slot = this.allocateSlot();
+    this.#setArray(slot, elements);
+    return slot;
+  }
+
+  /** Copies `count` elements from the source array to the destination array (overwrites destination). */
+  copy(srcSlot: Fr, dstSlot: Fr, count: number): void {
+    const srcArray = this.readArrayAt(srcSlot);
+    if (count > srcArray.length) {
+      throw new Error(
+        `Cannot copy ${count} elements from ephemeral array of length ${srcArray.length} at slot ${srcSlot}`,
+      );
+    }
+    // Deep copy the elements to avoid aliasing
+    const copied = srcArray.slice(0, count).map(el => [...el]);
+    this.#setArray(dstSlot, copied);
+  }
+}

package/src/contract_function_simulator/execution_tagging_index_cache.ts

@@ -1,32 +1,37 @@
-import { DirectionalAppTaggingSecret, type PreTag } from '@aztec/stdlib/logs';
+import { ExtendedDirectionalAppTaggingSecret, type TaggingIndexRange } from '@aztec/stdlib/logs';
 
 /**
- * A map that stores the tagging index for a given directional app tagging secret.
+ * A map that stores the tagging index range for a given extended directional app tagging secret.
  * Note: The directional app tagging secret is unique for a (sender, recipient, contract) tuple while the direction
  * of sender -> recipient matters.
  */
 export class ExecutionTaggingIndexCache {
-  private taggingIndexMap: Map<string, number> = new Map();
+  private taggingIndexMap: Map<string, { lowestIndex: number; highestIndex: number }> = new Map();
 
-  public getLastUsedIndex(secret: DirectionalAppTaggingSecret): number | undefined {
-    return this.taggingIndexMap.get(secret.toString());
+  public getLastUsedIndex(secret: ExtendedDirectionalAppTaggingSecret): number | undefined {
+    return this.taggingIndexMap.get(secret.toString())?.highestIndex;
   }
 
-  public setLastUsedIndex(secret: DirectionalAppTaggingSecret, index: number) {
+  public setLastUsedIndex(secret: ExtendedDirectionalAppTaggingSecret, index: number) {
     const currentValue = this.taggingIndexMap.get(secret.toString());
-    if (currentValue !== undefined && currentValue !== index - 1) {
-      throw new Error(`Invalid tagging index update. Current value: ${currentValue}, new value: ${index}`);
+    if (currentValue !== undefined && currentValue.highestIndex !== index - 1) {
+      throw new Error(`Invalid tagging index update. Current value: ${currentValue.highestIndex}, new value: ${index}`);
+    }
+    if (currentValue !== undefined) {
+      currentValue.highestIndex = index;
+    } else {
+      this.taggingIndexMap.set(secret.toString(), { lowestIndex: index, highestIndex: index });
     }
-    this.taggingIndexMap.set(secret.toString(), index);
   }
 
   /**
-   * Returns the pre-tags that were used in this execution (and that need to be stored in the db).
+   * Returns the tagging index ranges that were used in this execution (and that need to be stored in the db).
    */
-  public getUsedPreTags(): PreTag[] {
-    return Array.from(this.taggingIndexMap.entries()).map(([secret, index]) => ({
-      secret: DirectionalAppTaggingSecret.fromString(secret),
-      index,
+  public getUsedTaggingIndexRanges(): TaggingIndexRange[] {
+    return Array.from(this.taggingIndexMap.entries()).map(([secret, { lowestIndex, highestIndex }]) => ({
+      extendedSecret: ExtendedDirectionalAppTaggingSecret.fromString(secret),
+      lowestIndex,
+      highestIndex,
     }));
   }
 }

package/src/contract_function_simulator/index.ts

@@ -4,6 +4,7 @@ export { HashedValuesCache } from './hashed_values_cache.js';
 export { pickNotes } from './pick_notes.js';
 export type { NoteData, IMiscOracle, IUtilityExecutionOracle, IPrivateExecutionOracle } from './oracle/interfaces.js';
 export { MessageLoadOracleInputs } from './oracle/message_load_oracle_inputs.js';
+export { MessageContextService } from '../messages/message_context_service.js';
 export { UtilityExecutionOracle } from './oracle/utility_execution_oracle.js';
 export { PrivateExecutionOracle } from './oracle/private_execution_oracle.js';
 export { Oracle } from './oracle/oracle.js';

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

@@ -4,12 +4,9 @@ import { EventSelector } from '@aztec/stdlib/abi';
 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_EVENT_SERIALIZED_LEN = 12;
-
 /**
- * Intermediate struct used to perform batch event validation by PXE. The `utilityValidateEnqueuedNotesAndEvents` oracle
- * expects for values of this type to be stored in a `CapsuleArray`.
+ * Intermediate struct used to perform batch event validation by PXE. The `utilityValidateAndStoreEnqueuedNotesAndEvents` oracle
+ * expects for values of this type to be stored in a `EphemeralArray`.
  */
 export class EventValidationRequest {
   constructor(
@@ -19,10 +16,9 @@ export class EventValidationRequest {
     public serializedEvent: Fr[],
     public eventCommitment: Fr,
     public txHash: TxHash,
-    public recipient: AztecAddress,
   ) {}
 
-  static fromFields(fields: Fr[] | FieldReader): EventValidationRequest {
+  static fromFields(fields: Fr[], maxEventSerializedLen: number): EventValidationRequest {
     const reader = FieldReader.asReader(fields);
 
     const contractAddress = AztecAddress.fromField(reader.readField());
@@ -30,13 +26,18 @@ export class EventValidationRequest {
 
     const randomness = reader.readField();
 
-    const eventStorage = reader.readFieldArray(MAX_EVENT_SERIALIZED_LEN);
+    const eventStorage = reader.readFieldArray(maxEventSerializedLen);
     const eventLen = reader.readField().toNumber();
     const serializedEvent = eventStorage.slice(0, eventLen);
 
     const eventCommitment = reader.readField();
     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 EventValidationRequest: expected ${reader.cursor} fields but received ${fields.length} (maxEventSerializedLen=${maxEventSerializedLen}).`,
+      );
+    }
 
     return new EventValidationRequest(
       contractAddress,
@@ -45,7 +46,6 @@ export class EventValidationRequest {
       serializedEvent,
       eventCommitment,
       txHash,
-      recipient,
     );
   }
 }

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

@@ -5,7 +5,7 @@ import { Tag } from '@aztec/stdlib/logs';
 
 /**
  * Intermediate struct used to perform batch log retrieval by PXE. The `utilityBulkRetrieveLogs` oracle expects values of this
- * type to be stored in a `CapsuleArray`.
+ * type to be stored in a `EphemeralArray`.
  */
 export class LogRetrievalRequest {
   constructor(

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

@@ -3,14 +3,11 @@ import { range } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { TxHash } from '@aztec/stdlib/tx';
 
-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);
+const MAX_LOG_CONTENT_LEN = PRIVATE_LOG_CIPHERTEXT_LEN;
 
 /**
  * Intermediate struct used to perform batch log retrieval by PXE. The `utilityBulkRetrieveLogs` oracle stores values of this
- * type in a `CapsuleArray`.
+ * type in a `EphemeralArray`.
  */
 export class LogRetrievalResponse {
   constructor(

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

@@ -3,12 +3,9 @@ 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.
-export const MAX_NOTE_PACKED_LEN = 10;
-
 /**
- * Intermediate struct used to perform batch note validation by PXE. The `utilityValidateEnqueuedNotesAndEvents` oracle
- * expects for values of this type to be stored in a `CapsuleArray`.
+ * Intermediate struct used to perform batch note validation by PXE. The `utilityValidateAndStoreEnqueuedNotesAndEvents` oracle
+ * expects for values of this type to be stored in a `EphemeralArray`.
  */
 export class NoteValidationRequest {
   constructor(
@@ -21,10 +18,9 @@ export class NoteValidationRequest {
     public noteHash: Fr,
     public nullifier: Fr,
     public txHash: TxHash,
-    public recipient: AztecAddress,
   ) {}
 
-  static fromFields(fields: Fr[] | FieldReader): NoteValidationRequest {
+  static fromFields(fields: Fr[], maxNotePackedLen: number): NoteValidationRequest {
     const reader = FieldReader.asReader(fields);
 
     const contractAddress = AztecAddress.fromField(reader.readField());
@@ -33,18 +29,17 @@ export class NoteValidationRequest {
     const randomness = reader.readField();
     const noteNonce = reader.readField();
 
-    const contentStorage = reader.readFieldArray(MAX_NOTE_PACKED_LEN);
+    const contentStorage = reader.readFieldArray(maxNotePackedLen);
     const contentLen = reader.readField().toNumber();
     const content = contentStorage.slice(0, contentLen);
 
     const noteHash = reader.readField();
     const nullifier = reader.readField();
     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.`,
+        `Error converting array of fields to NoteValidationRequest: expected ${reader.cursor} fields but received ${fields.length} (maxNotePackedLen=${maxNotePackedLen}).`,
       );
     }
 
@@ -58,7 +53,6 @@ export class NoteValidationRequest {
       noteHash,
       nullifier,
       txHash,
-      recipient,
     );
   }
 }

package/src/contract_function_simulator/oracle/interfaces.ts

@@ -1,15 +1,17 @@
-import type { L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants';
+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 { L2BlockHash } from '@aztec/stdlib/block';
-import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
+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 MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
+import { type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 
 import type { UtilityContext } from '../noir-structs/utility_context.js';
@@ -51,9 +53,9 @@ export interface NoteData {
 export interface IMiscOracle {
   isMisc: true;
 
-  utilityGetRandomField(): Fr;
-  utilityAssertCompatibleOracleVersion(version: number): void;
-  utilityDebugLog(level: number, message: string, fields: Fr[]): void;
+  getRandomField(): Fr;
+  assertCompatibleOracleVersion(major: number, minor: number): void;
+  log(level: number, message: string, fields: Fr[]): Promise<void>;
 }
 
 /**
@@ -63,23 +65,32 @@ export interface IMiscOracle {
 export interface IUtilityExecutionOracle {
   isUtility: true;
 
-  utilityGetUtilityContext(): UtilityContext;
-  utilityGetKeyValidationRequest(pkMHash: Fr): Promise<KeyValidationRequest>;
-  utilityGetContractInstance(address: AztecAddress): Promise<ContractInstance>;
-  utilityGetMembershipWitness(blockHash: L2BlockHash, treeId: MerkleTreeId, leafValue: Fr): Promise<Fr[] | undefined>;
-  utilityGetNullifierMembershipWitness(
-    blockHash: L2BlockHash,
+  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>;
-  utilityGetPublicDataWitness(blockHash: L2BlockHash, leafSlot: Fr): Promise<PublicDataWitness | undefined>;
-  utilityGetLowNullifierMembershipWitness(
-    blockHash: L2BlockHash,
+  getPublicDataWitness(anchorBlockHash: BlockHash, leafSlot: Fr): Promise<PublicDataWitness | undefined>;
+  getLowNullifierMembershipWitness(
+    anchorBlockHash: BlockHash,
     nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined>;
-  utilityGetBlockHeader(blockNumber: BlockNumber): Promise<BlockHeader | undefined>;
-  utilityGetPublicKeysAndPartialAddress(account: AztecAddress): Promise<CompleteAddress>;
-  utilityGetAuthWitness(messageHash: Fr): Promise<Fr[] | undefined>;
-  utilityGetNotes(
+  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,
@@ -96,35 +107,72 @@ export interface IUtilityExecutionOracle {
     offset: number,
     status: NoteStatus,
   ): Promise<NoteData[]>;
-  utilityCheckNullifierExists(innerNullifier: Fr): Promise<boolean>;
-  utilityGetL1ToL2MembershipWitness(
+  doesNullifierExist(innerNullifier: Fr): Promise<boolean>;
+  getL1ToL2MembershipWitness(
     contractAddress: AztecAddress,
     messageHash: Fr,
     secret: Fr,
   ): Promise<MessageLoadOracleInputs<typeof L1_TO_L2_MSG_TREE_HEIGHT>>;
-  utilityStorageRead(
-    blockHash: L2BlockHash,
+  getFromPublicStorage(
+    anchorBlockHash: BlockHash,
     contractAddress: AztecAddress,
     startStorageSlot: Fr,
     numberOfElements: number,
   ): Promise<Fr[]>;
-  utilityFetchTaggedLogs(pendingTaggedLogArrayBaseSlot: Fr): Promise<void>;
-  utilityValidateEnqueuedNotesAndEvents(
+  getPendingTaggedLogs(pendingTaggedLogArrayBaseSlot: Fr, scope: AztecAddress): Promise<void>;
+  getPendingTaggedLogsV2(scope: AztecAddress): Promise<Fr>;
+  validateAndStoreEnqueuedNotesAndEvents(
     contractAddress: AztecAddress,
     noteValidationRequestsArrayBaseSlot: Fr,
     eventValidationRequestsArrayBaseSlot: Fr,
+    maxNotePackedLen: number,
+    maxEventSerializedLen: number,
+    scope: AztecAddress,
   ): Promise<void>;
-  utilityBulkRetrieveLogs(
+  getLogsByTag(
     contractAddress: AztecAddress,
     logRetrievalRequestsArrayBaseSlot: Fr,
     logRetrievalResponsesArrayBaseSlot: Fr,
+    scope: AztecAddress,
   ): 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>;
+  validateAndStoreEnqueuedNotesAndEventsV2(
+    noteValidationRequestsArrayBaseSlot: Fr,
+    eventValidationRequestsArrayBaseSlot: Fr,
+    maxNotePackedLen: number,
+    maxEventSerializedLen: number,
+    scope: AztecAddress,
+  ): Promise<void>;
+  getLogsByTagV2(requestArrayBaseSlot: Fr): Promise<Fr>;
+  getMessageContextsByTxHashV2(requestArrayBaseSlot: Fr): Promise<Fr>;
+  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>;
+
+  // Ephemeral array methods
+  pushEphemeral(slot: Fr, elements: Fr[]): number;
+  popEphemeral(slot: Fr): Fr[];
+  getEphemeral(slot: Fr, index: number): Fr[];
+  setEphemeral(slot: Fr, index: number, elements: Fr[]): void;
+  getEphemeralLen(slot: Fr): number;
+  removeEphemeral(slot: Fr, index: number): void;
+  clearEphemeral(slot: Fr): void;
 }
 
 /**
@@ -134,9 +182,9 @@ export interface IUtilityExecutionOracle {
 export interface IPrivateExecutionOracle {
   isPrivate: true;
 
-  privateStoreInExecutionCache(values: Fr[], hash: Fr): void;
-  privateLoadFromExecutionCache(hash: Fr): Promise<Fr[]>;
-  privateNotifyCreatedNote(
+  setHashPreimage(values: Fr[], hash: Fr): void;
+  getHashPreimage(hash: Fr): Promise<Fr[]>;
+  notifyCreatedNote(
     owner: AztecAddress,
     storageSlot: Fr,
     randomness: Fr,
@@ -145,32 +193,21 @@ export interface IPrivateExecutionOracle {
     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(
+  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 }>;
-  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>;
+  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>;
 }

package/src/contract_function_simulator/oracle/legacy_oracle_mappings.ts

@@ -0,0 +1,104 @@
+import { toACVMField } from '@aztec/simulator/client';
+import type { ACIRCallback, ACVMField } from '@aztec/simulator/client';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+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 {
+  // If you are about to add a new mapping ensure that the old oracle name is different from the new one - this can
+  // commonly occur when only the args are getting modified.
+  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_assertCompatibleOracleVersionV2(version, [toACVMField(0)]),
+    // Old 1-arg oracle before minor/major split. Maps to V2 with minor=0.
+    // eslint-disable-next-line camelcase
+    aztec_utl_assertCompatibleOracleVersion: (version: ACVMField[]): Promise<ACVMField[]> =>
+      oracle.aztec_utl_assertCompatibleOracleVersionV2(version, [toACVMField(0)]),
+    utilityLoadCapsule: (
+      contractAddress: ACVMField[],
+      slot: ACVMField[],
+      tSize: ACVMField[],
+    ): Promise<(ACVMField | ACVMField[])[]> =>
+      oracle.aztec_utl_getCapsule(contractAddress, slot, tSize, [toACVMField(AztecAddress.ZERO)]),
+    privateStoreInExecutionCache: (values: ACVMField[], hash: ACVMField[]): Promise<ACVMField[]> =>
+      oracle.aztec_prv_setHashPreimage(values, hash),
+    privateLoadFromExecutionCache: (returnsHash: ACVMField[]): Promise<ACVMField[][]> =>
+      oracle.aztec_prv_getHashPreimage(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_getFromPublicStorage(blockHash, contractAddress, startStorageSlot, numberOfElements),
+    utilityStoreCapsule: (
+      contractAddress: ACVMField[],
+      slot: ACVMField[],
+      capsule: ACVMField[],
+    ): Promise<ACVMField[]> =>
+      oracle.aztec_utl_setCapsule(contractAddress, slot, capsule, [toACVMField(AztecAddress.ZERO)]),
+    utilityCopyCapsule: (
+      contractAddress: ACVMField[],
+      srcSlot: ACVMField[],
+      dstSlot: ACVMField[],
+      numEntries: ACVMField[],
+    ): Promise<ACVMField[]> =>
+      oracle.aztec_utl_copyCapsule(contractAddress, srcSlot, dstSlot, numEntries, [toACVMField(AztecAddress.ZERO)]),
+    utilityDeleteCapsule: (contractAddress: ACVMField[], slot: ACVMField[]): Promise<ACVMField[]> =>
+      oracle.aztec_utl_deleteCapsule(contractAddress, slot, [toACVMField(AztecAddress.ZERO)]),
+    utilityGetL1ToL2MembershipWitness: (
+      contractAddress: ACVMField[],
+      messageHash: ACVMField[],
+      secret: ACVMField[],
+    ): Promise<(ACVMField | ACVMField[])[]> =>
+      oracle.aztec_utl_getL1ToL2MembershipWitness(contractAddress, messageHash, secret),
+    // Renames (same signature, different oracle name)
+    privateNotifySetMinRevertibleSideEffectCounter: (counter: ACVMField[]): Promise<ACVMField[]> =>
+      oracle.aztec_prv_notifyRevertiblePhaseStart(counter),
+    // Signature changes: old 4-param oracles → new 1-param validatePublicCalldata
+    privateNotifyEnqueuedPublicFunctionCall: (
+      _contractAddress: ACVMField[],
+      calldataHash: ACVMField[],
+      _sideEffectCounter: ACVMField[],
+      _isStaticCall: ACVMField[],
+    ): Promise<ACVMField[]> => oracle.aztec_prv_assertValidPublicCalldata(calldataHash),
+  };
+}