@aztec/pxe 0.0.1-commit.3895657bc → 0.0.1-commit.3e3d0c9cd

package/dest/tagging/sender_sync/utils/load_and_store_new_tagging_indexes.js

@@ -10,6 +10,7 @@ import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
  * @param end - The ending index (exclusive) of the window to process.
  * @param aztecNode - The Aztec node instance to query for logs.
  * @param taggingStore - The data provider to store pending indexes.
+ * @param anchorBlockHash - Hash of a block to use as reference block when querying node.
  * @param jobId - Job identifier, used to keep writes in-memory until they can be persisted in a data integrity
  * preserving way.
  */ export async function loadAndStoreNewTaggingIndexes(extendedSecret, start, end, aztecNode, taggingStore, anchorBlockHash, jobId) {
@@ -21,16 +22,18 @@ import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
             index: start + i
         })));
     const txsForTags = await getTxsContainingTags(siloedTagsForWindow, aztecNode, anchorBlockHash);
-    const highestIndexMap = getTxHighestIndexMap(txsForTags, start, siloedTagsForWindow.length);
-    // Now we iterate over the map, reconstruct the preTags and tx hash and store them in the db.
-    for (const [txHashStr, highestIndex] of highestIndexMap.entries()){
+    const txIndexesMap = getTxIndexesMap(txsForTags, start, siloedTagsForWindow.length);
+    // Now we iterate over the map, construct the tagging index ranges and store them in the db.
+    for (const [txHashStr, indexes] of txIndexesMap.entries()){
         const txHash = TxHash.fromString(txHashStr);
-        await taggingStore.storePendingIndexes([
+        const ranges = [
             {
                 extendedSecret,
-                index: highestIndex
+                lowestIndex: Math.min(...indexes),
+                highestIndex: Math.max(...indexes)
             }
-        ], txHash, jobId);
+        ];
+        await taggingStore.storePendingIndexes(ranges, txHash, jobId);
     }
 }
 // Returns txs that used the given tags. A tag might have been used in multiple txs and for this reason we return
@@ -41,19 +44,29 @@ async function getTxsContainingTags(tags, aztecNode, anchorBlockHash) {
     const allLogs = await getAllPrivateLogsByTags(aztecNode, tags, anchorBlockHash);
     return allLogs.map((logs)=>logs.map((log)=>log.txHash));
 }
-// Returns a map of txHash to the highest index for that txHash.
-function getTxHighestIndexMap(txHashesForTags, start, count) {
+// Returns a map of txHash to all indexes for that txHash.
+function getTxIndexesMap(txHashesForTags, start, count) {
     if (txHashesForTags.length !== count) {
         throw new Error(`Number of tx hashes arrays does not match number of tags. ${txHashesForTags.length} !== ${count}`);
     }
-    const highestIndexMap = new Map();
+    const indexesMap = new Map();
+    // Iterate over indexes
     for(let i = 0; i < txHashesForTags.length; i++){
         const taggingIndex = start + i;
         const txHashesForTag = txHashesForTags[i];
+        // iterate over tx hashes that used that index (tag)
         for (const txHash of txHashesForTag){
             const key = txHash.toString();
-            highestIndexMap.set(key, Math.max(highestIndexMap.get(key) ?? 0, taggingIndex));
+            const existing = indexesMap.get(key);
+            // Add the index to the tx's indexes
+            if (existing) {
+                existing.push(taggingIndex);
+            } else {
+                indexesMap.set(key, [
+                    taggingIndex
+                ]);
+            }
         }
     }
-    return highestIndexMap;
+    return indexesMap;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/pxe",
-  "version": "0.0.1-commit.3895657bc",
+  "version": "0.0.1-commit.3e3d0c9cd",
   "type": "module",
   "typedocOptions": {
     "entryPoints": [
@@ -70,19 +70,19 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb-prover": "0.0.1-commit.3895657bc",
-    "@aztec/bb.js": "0.0.1-commit.3895657bc",
-    "@aztec/builder": "0.0.1-commit.3895657bc",
-    "@aztec/constants": "0.0.1-commit.3895657bc",
-    "@aztec/ethereum": "0.0.1-commit.3895657bc",
-    "@aztec/foundation": "0.0.1-commit.3895657bc",
-    "@aztec/key-store": "0.0.1-commit.3895657bc",
-    "@aztec/kv-store": "0.0.1-commit.3895657bc",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.3895657bc",
-    "@aztec/noir-types": "0.0.1-commit.3895657bc",
-    "@aztec/protocol-contracts": "0.0.1-commit.3895657bc",
-    "@aztec/simulator": "0.0.1-commit.3895657bc",
-    "@aztec/stdlib": "0.0.1-commit.3895657bc",
+    "@aztec/bb-prover": "0.0.1-commit.3e3d0c9cd",
+    "@aztec/bb.js": "0.0.1-commit.3e3d0c9cd",
+    "@aztec/builder": "0.0.1-commit.3e3d0c9cd",
+    "@aztec/constants": "0.0.1-commit.3e3d0c9cd",
+    "@aztec/ethereum": "0.0.1-commit.3e3d0c9cd",
+    "@aztec/foundation": "0.0.1-commit.3e3d0c9cd",
+    "@aztec/key-store": "0.0.1-commit.3e3d0c9cd",
+    "@aztec/kv-store": "0.0.1-commit.3e3d0c9cd",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.3e3d0c9cd",
+    "@aztec/noir-types": "0.0.1-commit.3e3d0c9cd",
+    "@aztec/protocol-contracts": "0.0.1-commit.3e3d0c9cd",
+    "@aztec/simulator": "0.0.1-commit.3e3d0c9cd",
+    "@aztec/stdlib": "0.0.1-commit.3e3d0c9cd",
     "koa": "^2.16.1",
     "koa-router": "^13.1.1",
     "lodash.omit": "^4.5.0",
@@ -91,8 +91,8 @@
     "viem": "npm:@aztec/viem@2.38.2"
   },
   "devDependencies": {
-    "@aztec/merkle-tree": "0.0.1-commit.3895657bc",
-    "@aztec/noir-test-contracts.js": "0.0.1-commit.3895657bc",
+    "@aztec/noir-test-contracts.js": "0.0.1-commit.3e3d0c9cd",
+    "@aztec/world-state": "0.0.1-commit.3e3d0c9cd",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/lodash.omit": "^4.5.7",

package/src/contract_function_simulator/contract_function_simulator.ts

@@ -17,6 +17,7 @@ import {
   MAX_NULLIFIERS_PER_TX,
   MAX_NULLIFIER_READ_REQUESTS_PER_TX,
   MAX_PRIVATE_LOGS_PER_TX,
+  MAX_TX_LIFETIME,
   PRIVATE_TX_L2_GAS_OVERHEAD,
   PUBLIC_TX_L2_GAS_OVERHEAD,
   TX_DA_GAS_OVERHEAD,
@@ -79,6 +80,7 @@ import {
   BlockHeader,
   CallContext,
   HashedValues,
+  type OffchainEffect,
   PrivateExecutionResult,
   TxConstantData,
   TxExecutionRequest,
@@ -89,6 +91,7 @@ import {
 
 import type { AccessScopes } from '../access_scopes.js';
 import type { ContractSyncService } from '../contract_sync/contract_sync_service.js';
+import type { MessageContextService } from '../messages/message_context_service.js';
 import type { AddressStore } from '../storage/address_store/address_store.js';
 import type { CapsuleStore } from '../storage/capsule_store/capsule_store.js';
 import type { ContractStore } from '../storage/contract_store/contract_store.js';
@@ -138,6 +141,7 @@ export type ContractFunctionSimulatorArgs = {
   privateEventStore: PrivateEventStore;
   simulator: CircuitSimulator;
   contractSyncService: ContractSyncService;
+  messageContextService: MessageContextService;
 };
 
 /**
@@ -157,6 +161,7 @@ export class ContractFunctionSimulator {
   private readonly privateEventStore: PrivateEventStore;
   private readonly simulator: CircuitSimulator;
   private readonly contractSyncService: ContractSyncService;
+  private readonly messageContextService: MessageContextService;
 
   constructor(args: ContractFunctionSimulatorArgs) {
     this.contractStore = args.contractStore;
@@ -171,6 +176,7 @@ export class ContractFunctionSimulator {
     this.privateEventStore = args.privateEventStore;
     this.simulator = args.simulator;
     this.contractSyncService = args.contractSyncService;
+    this.messageContextService = args.messageContextService;
     this.log = createLogger('simulator');
   }
 
@@ -241,6 +247,7 @@ export class ContractFunctionSimulator {
       senderAddressBookStore: this.senderAddressBookStore,
       capsuleStore: this.capsuleStore,
       privateEventStore: this.privateEventStore,
+      messageContextService: this.messageContextService,
       contractSyncService: this.contractSyncService,
       jobId,
       totalPublicCalldataCount: 0,
@@ -314,7 +321,7 @@ export class ContractFunctionSimulator {
     anchorBlockHeader: BlockHeader,
     scopes: AccessScopes,
     jobId: string,
-  ): Promise<Fr[]> {
+  ): Promise<{ result: Fr[]; offchainEffects: OffchainEffect[] }> {
     const entryPointArtifact = await this.contractStore.getFunctionArtifactWithDebugMetadata(call.to, call.selector);
 
     if (entryPointArtifact.functionType !== FunctionType.UTILITY) {
@@ -335,6 +342,7 @@ export class ContractFunctionSimulator {
       senderAddressBookStore: this.senderAddressBookStore,
       capsuleStore: this.capsuleStore,
       privateEventStore: this.privateEventStore,
+      messageContextService: this.messageContextService,
       jobId,
       scopes,
     });
@@ -362,7 +370,10 @@ export class ContractFunctionSimulator {
         });
 
       this.log.verbose(`Utility execution for ${call.to}.${call.selector} completed`);
-      return witnessMapToFields(acirExecutionResult.returnWitness);
+      return {
+        result: witnessMapToFields(acirExecutionResult.returnWitness),
+        offchainEffects: oracle.getOffchainEffects(),
+      };
     } catch (err) {
       throw createSimulationError(err instanceof Error ? err : new Error('Unknown error during private execution'));
     }
@@ -432,12 +443,23 @@ export async function generateSimulatedProvingResult(
 
   let publicTeardownCallRequest;
 
+  // We set expiration timestamp to anchor_block_timestamp + MAX_TX_LIFETIME (24h) just like kernels do
+  let expirationTimestamp =
+    privateExecutionResult.entrypoint.publicInputs.anchorBlockHeader.globalVariables.timestamp +
+    BigInt(MAX_TX_LIFETIME);
+
   const executions = [privateExecutionResult.entrypoint];
 
   while (executions.length !== 0) {
     const execution = executions.shift()!;
     executions.unshift(...execution!.nestedExecutionResults);
 
+    // Just like kernels we overwrite the default value if the call sets it.
+    const callExpirationTimestamp = execution.publicInputs.expirationTimestamp;
+    if (callExpirationTimestamp !== 0n && callExpirationTimestamp < expirationTimestamp) {
+      expirationTimestamp = callExpirationTimestamp;
+    }
+
     const { contractAddress } = execution.publicInputs.callContext;
 
     scopedNoteHashes.push(
@@ -661,7 +683,7 @@ export async function generateSimulatedProvingResult(
       }),
     ),
     /*feePayer=*/ AztecAddress.zero(),
-    /*expirationTimestamp=*/ 0n,
+    /*expirationTimestamp=*/ expirationTimestamp,
     hasPublicCalls ? inputsForPublic : undefined,
     !hasPublicCalls ? inputsForRollup : undefined,
   );

package/src/contract_function_simulator/execution_tagging_index_cache.ts

@@ -1,32 +1,37 @@
-import { ExtendedDirectionalAppTaggingSecret, type PreTag } from '@aztec/stdlib/logs';
+import { ExtendedDirectionalAppTaggingSecret, type TaggingIndexRange } from '@aztec/stdlib/logs';
 
 /**
- * A map that stores the tagging index for a given extended 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: ExtendedDirectionalAppTaggingSecret): number | undefined {
-    return this.taggingIndexMap.get(secret.toString());
+    return this.taggingIndexMap.get(secret.toString())?.highestIndex;
   }
 
   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]) => ({
+  public getUsedTaggingIndexRanges(): TaggingIndexRange[] {
+    return Array.from(this.taggingIndexMap.entries()).map(([secret, { lowestIndex, highestIndex }]) => ({
       extendedSecret: ExtendedDirectionalAppTaggingSecret.fromString(secret),
-      index,
+      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,9 +4,6 @@ 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 = 10;
-
 /**
  * Intermediate struct used to perform batch event validation by PXE. The `utilityValidateAndStoreEnqueuedNotesAndEvents` oracle
  * expects for values of this type to be stored in a `CapsuleArray`.
@@ -22,7 +19,7 @@ export class EventValidationRequest {
     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,7 +27,7 @@ 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);
 
@@ -38,6 +35,12 @@ export class EventValidationRequest {
     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,
       eventTypeId,

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

@@ -3,10 +3,7 @@ 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

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

@@ -0,0 +1,55 @@
+import { MAX_NOTE_HASHES_PER_TX } from '@aztec/constants';
+import { range } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { TxHash } from '@aztec/stdlib/tx';
+
+/**
+ * Intermediate struct used to return resolved message contexts from PXE. The
+ * `utilityResolveMessageContexts` oracle stores values of this type in a CapsuleArray.
+ */
+export class MessageTxContext {
+  constructor(
+    public txHash: TxHash,
+    public uniqueNoteHashesInTx: Fr[],
+    public firstNullifierInTx: Fr,
+  ) {}
+
+  toFields(): Fr[] {
+    return [
+      this.txHash.hash,
+      ...serializeBoundedVec(this.uniqueNoteHashesInTx, MAX_NOTE_HASHES_PER_TX),
+      this.firstNullifierInTx,
+    ];
+  }
+
+  static toEmptyFields(): Fr[] {
+    const serializationLen =
+      1 /* txHash */ + MAX_NOTE_HASHES_PER_TX + 1 /* uniqueNoteHashesInTx BVec */ + 1; /* firstNullifierInTx */
+    return range(serializationLen).map(_ => Fr.zero());
+  }
+
+  static toSerializedOption(response: MessageTxContext | null): Fr[] {
+    if (response) {
+      return [new Fr(1), ...response.toFields()];
+    } else {
+      return [new Fr(0), ...MessageTxContext.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)];
+}

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

@@ -3,9 +3,6 @@ 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 = 8;
-
 /**
  * Intermediate struct used to perform batch note validation by PXE. The `utilityValidateAndStoreEnqueuedNotesAndEvents` oracle
  * expects for values of this type to be stored in a `CapsuleArray`.
@@ -24,7 +21,7 @@ export class NoteValidationRequest {
     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,7 +30,7 @@ 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);
 
@@ -44,7 +41,7 @@ export class NoteValidationRequest {
 
     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}).`,
       );
     }
 

package/src/contract_function_simulator/oracle/interfaces.ts

@@ -6,8 +6,9 @@ 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 { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
+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';
@@ -85,7 +86,9 @@ export interface IUtilityExecutionOracle {
     nullifier: Fr,
   ): Promise<NullifierMembershipWitness | undefined>;
   getBlockHeader(blockNumber: BlockNumber): Promise<BlockHeader | undefined>;
-  tryGetPublicKeysAndPartialAddress(account: AztecAddress): Promise<CompleteAddress | undefined>;
+  tryGetPublicKeysAndPartialAddress(
+    account: AztecAddress,
+  ): Promise<{ publicKeys: PublicKeys; partialAddress: PartialAddress } | undefined>;
   getAuthWitness(messageHash: Fr): Promise<Fr[] | undefined>;
   getNotes(
     owner: AztecAddress | undefined,
@@ -121,18 +124,26 @@ export interface IUtilityExecutionOracle {
     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>;
 }
 
 /**
@@ -164,22 +175,10 @@ export interface IPrivateExecutionOracle {
     sideEffectCounter: number,
     isStaticCall: boolean,
   ): Promise<{ endSideEffectCounter: Fr; returnsHash: Fr }>;
-  notifyEnqueuedPublicFunctionCall(
-    targetContractAddress: AztecAddress,
-    calldataHash: Fr,
-    sideEffectCounter: number,
-    isStaticCall: boolean,
-  ): Promise<void>;
-  notifySetPublicTeardownFunctionCall(
-    targetContractAddress: AztecAddress,
-    calldataHash: Fr,
-    sideEffectCounter: number,
-    isStaticCall: boolean,
-  ): Promise<void>;
-  notifySetMinRevertibleSideEffectCounter(minRevertibleSideEffectCounter: number): Promise<void>;
-  isSideEffectCounterRevertible(sideEffectCounter: number): Promise<boolean>;
+  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>;
-  emitOffchainEffect(data: Fr[]): Promise<void>;
 }

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),
+  };
+}