@aztec/pxe 0.0.1-commit.c2eed6949 → 0.0.1-commit.c52d6e7

package/src/tagging/sender_sync/utils/classify_pending_txs.ts

@@ -0,0 +1,91 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import { TxHash, TxStatus } from '@aztec/stdlib/tx';
+
+import type { PendingTx } from '../../../storage/tagging_store/sender_tagging_store.js';
+import type { TxInLogs } from './load_and_store_new_tagging_indexes.js';
+
+/** A sync window's pending txs, grouped by what the window's logs evidence about each of them. */
+export type LogClassification = {
+  txHashesFinalized: TxHash[];
+  txHashesWithExecutionReverted: TxHash[];
+  txHashesAbsent: TxHash[];
+};
+
+/** Groups a window's pending txs by what its logs say about them. */
+export function classifyPendingTxsFromLogs(
+  pendingTxs: PendingTx[],
+  txsInLogs: Map<string, TxInLogs>,
+  finalizedBlockNumber: BlockNumber,
+): LogClassification {
+  const txHashesFinalized: TxHash[] = [];
+  const txHashesWithExecutionReverted: TxHash[] = [];
+  const txHashesAbsent: TxHash[] = [];
+
+  for (const pendingTx of pendingTxs) {
+    const txHash = TxHash.fromString(pendingTx.txHash);
+    const txInLogs = txsInLogs.get(pendingTx.txHash);
+    if (!txInLogs) {
+      txHashesAbsent.push(txHash);
+    } else if (txInLogs.blockNumber > finalizedBlockNumber) {
+      // A tx in the logs is mined in the log's block, so it is finalized exactly when that block is at or below the
+      // finalized tip. This one is not, so it belongs to no group until the tip catches up.
+    } else if (txInLogs.taggingIndexes.includes(pendingTx.highestIndex)) {
+      txHashesFinalized.push(txHash);
+    } else {
+      // A partially reverted tx: the revert dropped the logs carrying its higher indexes.
+      txHashesWithExecutionReverted.push(txHash);
+    }
+  }
+
+  return { txHashesFinalized, txHashesWithExecutionReverted, txHashesAbsent };
+}
+
+/** A batch of pending txs grouped by what their receipts report about them. */
+export type ReceiptClassification = {
+  txHashesFinalized: TxHash[];
+  txHashesDropped: TxHash[];
+  txHashesWithExecutionReverted: TxHash[];
+};
+
+/** Groups pending txs by what their receipts say, for the txs the logs could not resolve. */
+export async function classifyPendingTxsFromReceipts(
+  pending: TxHash[],
+  aztecNode: AztecNode,
+): Promise<ReceiptClassification> {
+  const receipts = await Promise.all(pending.map(pendingTxHash => aztecNode.getTxReceipt(pendingTxHash)));
+
+  const txHashesFinalized: TxHash[] = [];
+  const txHashesDropped: TxHash[] = [];
+  const txHashesWithExecutionReverted: TxHash[] = [];
+
+  for (let i = 0; i < receipts.length; i++) {
+    const receipt = receipts[i];
+    const txHash = pending[i];
+
+    if (receipt.status === TxStatus.FINALIZED) {
+      // Tx has been included in a block and the corresponding block is finalized
+      if (receipt.hasExecutionSucceeded()) {
+        // No part of execution reverted - we just finalize all the indexes.
+        txHashesFinalized.push(txHash);
+      } else if (receipt.hasExecutionReverted()) {
+        // Tx was mined but execution reverted (app logic, teardown, or both). Some logs from the non-revertible
+        // phase may still be onchain. We check which tags made it onchain and finalize those; drop the rest.
+        txHashesWithExecutionReverted.push(txHash);
+      } else {
+        // Defensive check - this branch should never be triggered
+        throw new Error(
+          'Both hasExecutionSucceeded and hasExecutionReverted on the receipt returned false. This should never happen and it implies a bug. Please open an issue.',
+        );
+      }
+    } else if (receipt.isDropped()) {
+      // Tx was dropped from the mempool --> we drop the corresponding pending indexes.
+      txHashesDropped.push(txHash);
+    } else {
+      // Tx is still pending, not yet finalized, or was mined successfully but not yet finalized --> we don't do
+      // anything.
+    }
+  }
+
+  return { txHashesFinalized, txHashesDropped, txHashesWithExecutionReverted };
+}

package/src/tagging/sender_sync/utils/load_and_store_new_tagging_indexes.ts

@@ -1,85 +1,90 @@
-import type { BlockHash } from '@aztec/stdlib/block';
+import type { BlockNumber } from '@aztec/foundation/branded-types';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
-import type { ExtendedDirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
-import { SiloedTag } from '@aztec/stdlib/logs';
+import { type AppTaggingSecret, type LogResult, SiloedTag } from '@aztec/stdlib/logs';
 import { TxHash } from '@aztec/stdlib/tx';
 
 import type { SenderTaggingStore } from '../../../storage/tagging_store/sender_tagging_store.js';
-import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
+import { type LogQueryAnchor, getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
 
 /**
- * Loads tagging indexes from the Aztec node and stores them in the tagging data provider.
+ * Loads tagging indexes from the Aztec node and stores them in the tagging data provider. Returns the txs the
+ * window's logs carried, keyed by tx hash string, with the block each was mined in and the window indexes it used,
+ * so the caller can classify their finalization status without further node queries.
  * @remarks This function is one of two places by which a pending index can get to the tagging data provider. The other
  * place is when a tx is being sent from this PXE.
- * @param extendedSecret - The extended directional app tagging secret that's unique for (sender, recipient, app) tuple.
+ * @param extendedSecret - The app tagging secret whose indexes are being synced.
  * @param start - The starting index (inclusive) of the window to process.
  * @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 anchor - Block the log query is anchored to.
  * @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: ExtendedDirectionalAppTaggingSecret,
+  extendedSecret: AppTaggingSecret,
   start: number,
   end: number,
   aztecNode: AztecNode,
   taggingStore: SenderTaggingStore,
-  anchorBlockHash: BlockHash,
+  anchor: LogQueryAnchor,
   jobId: string,
-) {
+): Promise<Map<string, TxInLogs>> {
   // We compute the tags for the current window of indexes
   const siloedTagsForWindow = await Promise.all(
     Array.from({ length: end - start }, (_, i) => SiloedTag.compute({ extendedSecret, index: start + i })),
   );
 
-  const txsForTags = await getTxsContainingTags(siloedTagsForWindow, aztecNode, anchorBlockHash);
-  const txIndexesMap = getTxIndexesMap(txsForTags, start, siloedTagsForWindow.length);
+  const allLogs = await getAllPrivateLogsByTags(aztecNode, siloedTagsForWindow, anchor);
+  if (allLogs.length !== siloedTagsForWindow.length) {
+    throw new Error(
+      `Number of log arrays does not match number of tags. ${allLogs.length} !== ${siloedTagsForWindow.length}`,
+    );
+  }
+
+  const txsInLogs = getTxsInLogs(allLogs, start);
 
-  // Now we iterate over the map, construct the tagging index ranges and store them in the db.
-  for (const [txHashStr, indexes] of txIndexesMap.entries()) {
+  // Now we iterate over the map, construct the tagging index ranges and store them in the db. A tx already tracked
+  // in the store is merged rather than range-checked: if this PXE sent the tx and it partially reverted, the chain
+  // only shows the surviving sub-range of the prove-time entry (the finalized receipt step of the sync owns
+  // resolving that difference), and a tx from another PXE may straddle a sync window boundary, in which case the
+  // entry is widened so the next index choice covers the full onchain range.
+  for (const [txHashStr, { taggingIndexes }] of txsInLogs.entries()) {
     const txHash = TxHash.fromString(txHashStr);
-    const ranges = [{ extendedSecret, lowestIndex: Math.min(...indexes), highestIndex: Math.max(...indexes) }];
-    await taggingStore.storePendingIndexes(ranges, txHash, jobId);
+    const ranges = [
+      { extendedSecret, lowestIndex: Math.min(...taggingIndexes), highestIndex: Math.max(...taggingIndexes) },
+    ];
+    await taggingStore.mergePendingIndexes(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
-// an array for each tag.
-async function getTxsContainingTags(
-  tags: SiloedTag[],
-  aztecNode: AztecNode,
-  anchorBlockHash: BlockHash,
-): Promise<TxHash[][]> {
-  // We use the utility function below to retrieve all logs for the tags across all pages, so we don't need to handle
-  // pagination here.
-  const allLogs = await getAllPrivateLogsByTags(aztecNode, tags, anchorBlockHash);
-  return allLogs.map(logs => logs.map(log => log.txHash));
+  return txsInLogs;
 }
 
-// Returns a map of txHash to all indexes for that txHash.
-function getTxIndexesMap(txHashesForTags: TxHash[][], start: number, count: number): Map<string, number[]> {
-  if (txHashesForTags.length !== count) {
-    throw new Error(`Number of tx hashes arrays does not match number of tags. ${txHashesForTags.length} !== ${count}`);
-  }
+/** A tx that a sync window's logs carried. */
+export type TxInLogs = {
+  /** The block the tx was mined in, which decides whether it is finalized. */
+  blockNumber: BlockNumber;
+  /** The window's tagging indexes whose siloed tags this tx's logs carried. */
+  taggingIndexes: number[];
+};
 
-  const indexesMap = new Map<string, number[]>();
+// Returns a map of txHash to the block it was mined in and all window indexes used by it.
+function getTxsInLogs(logsForTags: LogResult[][], start: number): Map<string, TxInLogs> {
+  const txsInLogs = new Map<string, TxInLogs>();
   // Iterate over indexes
-  for (let i = 0; i < txHashesForTags.length; i++) {
+  for (let i = 0; i < logsForTags.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();
-      const existing = indexesMap.get(key);
+    // iterate over logs that used that index (tag)
+    for (const log of logsForTags[i]) {
+      const key = log.txHash.toString();
+      const existing = txsInLogs.get(key);
       // Add the index to the tx's indexes
       if (existing) {
-        existing.push(taggingIndex);
+        existing.taggingIndexes.push(taggingIndex);
       } else {
-        indexesMap.set(key, [taggingIndex]);
+        txsInLogs.set(key, { blockNumber: log.blockNumber, taggingIndexes: [taggingIndex] });
       }
     }
   }
-  return indexesMap;
+  return txsInLogs;
 }

package/src/tagging/sender_sync/utils/resolve_pending_txs.ts

@@ -0,0 +1,64 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import { type MinedTxReceipt, type TxHash, type TxReceipt, TxStatus } from '@aztec/stdlib/tx';
+
+import type { PendingTx } from '../../../storage/tagging_store/sender_tagging_store.js';
+import { classifyPendingTxsFromLogs, classifyPendingTxsFromReceipts } from './classify_pending_txs.js';
+import type { TxInLogs } from './load_and_store_new_tagging_indexes.js';
+
+/** What a window's node reads established about each of its pending txs. */
+export type ResolvedPendingTxs = {
+  txHashesFinalizedFromLogs: TxHash[];
+  txHashesFinalizedFromReceipts: TxHash[];
+  txHashesDropped: TxHash[];
+  /** Both sources land here: the logs when a surviving tag fell inside the window, a receipt otherwise. */
+  receiptsWithExecutionReverted: MinedTxReceipt<{ includeTxEffect: true }>[];
+};
+
+/**
+ * Resolves a window's pending txs. All of the window's node reads happen here.
+ *
+ * The logs it is handed settle most txs on their own, as {@link classifyPendingTxsFromLogs} explains. Two groups are
+ * left over, and share one further round trip:
+ *
+ * - txs absent from the logs, whose receipt is what tells whether they are still in the mempool, dropped, or reverted;
+ * - txs the logs show as reverted, which only their tx effect resolves.
+ *
+ * A third round trip is paid only when those receipts reveal a reverted tx, since its effect cannot be requested
+ * before its status says it reverted.
+ */
+export async function resolvePendingTxs(
+  pendingTxs: PendingTx[],
+  txsInLogs: Map<string, TxInLogs>,
+  finalizedBlockNumber: BlockNumber,
+  aztecNode: AztecNode,
+): Promise<ResolvedPendingTxs> {
+  const statusFromLogs = classifyPendingTxsFromLogs(pendingTxs, txsInLogs, finalizedBlockNumber);
+
+  const [statusOfAbsent, receiptsOfRevertedInLogs] = await Promise.all([
+    classifyPendingTxsFromReceipts(statusFromLogs.txHashesAbsent, aztecNode),
+    getReceiptsWithEffect(statusFromLogs.txHashesWithExecutionReverted, aztecNode),
+  ]);
+
+  const receiptsOfRevertedAbsent = await getReceiptsWithEffect(statusOfAbsent.txHashesWithExecutionReverted, aztecNode);
+
+  return {
+    txHashesFinalizedFromLogs: statusFromLogs.txHashesFinalized,
+    txHashesFinalizedFromReceipts: statusOfAbsent.txHashesFinalized,
+    txHashesDropped: statusOfAbsent.txHashesDropped,
+    // Both groups were judged finalized before this fetch, the first off our own tip and the second off an earlier
+    // receipt, so both are confirmed against what the node says now. Finalizing off a reorgeable block would burn
+    // the indexes.
+    receiptsWithExecutionReverted: [...receiptsOfRevertedInLogs, ...receiptsOfRevertedAbsent].filter(isFinalized),
+  };
+}
+
+function getReceiptsWithEffect(txHashes: TxHash[], aztecNode: AztecNode) {
+  return Promise.all(txHashes.map(txHash => aztecNode.getTxReceipt(txHash, { includeTxEffect: true })));
+}
+
+function isFinalized(
+  receipt: TxReceipt<{ includeTxEffect: true }>,
+): receipt is MinedTxReceipt<{ includeTxEffect: true }> {
+  return receipt.status === TxStatus.FINALIZED;
+}

package/src/tagging/sender_sync/utils/test_utils.ts

@@ -0,0 +1,46 @@
+import { BlockNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { BlockHash } from '@aztec/stdlib/block';
+import type { MinedTxStatus, TxEffect, TxHash } from '@aztec/stdlib/tx';
+import { MinedTxReceipt, TxExecutionResult } from '@aztec/stdlib/tx';
+
+import type { PendingTx } from '../../../storage/tagging_store/sender_tagging_store.js';
+import type { TxInLogs } from './load_and_store_new_tagging_indexes.js';
+
+/** A tx the store holds as pending, tracked up to the given index. */
+export function pendingTx(txHash: TxHash, highestIndex: number): PendingTx {
+  return { txHash: txHash.toString(), highestIndex };
+}
+
+/** One tx as a window's logs show it: the block it was mined in and the tagging indexes its logs carried. */
+export function minedIn(blockNumber: number, taggingIndexes: number[]): TxInLogs {
+  return { blockNumber: BlockNumber(blockNumber), taggingIndexes };
+}
+
+/** Builds the tx-hash-keyed map a window's logs would produce. */
+export function txsInLogs(...entries: [TxHash, TxInLogs][]): Map<string, TxInLogs> {
+  return new Map(entries.map(([txHash, txInLogs]) => [txHash.toString(), txInLogs]));
+}
+
+/** The receipt of a mined tx, successful and without a tx effect unless stated otherwise. */
+export function minedReceipt(
+  txHash: TxHash,
+  status: MinedTxStatus,
+  blockNumber: number,
+  {
+    executionResult = TxExecutionResult.SUCCESS,
+    txEffect,
+  }: { executionResult?: TxExecutionResult; txEffect?: TxEffect } = {},
+): MinedTxReceipt {
+  return new MinedTxReceipt(
+    txHash,
+    status,
+    executionResult,
+    1n,
+    BlockHash.random(),
+    BlockNumber(blockNumber),
+    SlotNumber(Number(blockNumber)),
+    0,
+    EpochNumber(1),
+    txEffect,
+  );
+}

package/src/tagging/testing/tag_query_test_utils.ts

@@ -0,0 +1,11 @@
+import { type AppTaggingSecret, type PrivateLogsQuery, SiloedTag, type TagQuery } from '@aztec/stdlib/logs';
+
+/** Computes the siloed tag */
+export function computeSiloedTagForIndex(secret: AppTaggingSecret, index: number): Promise<SiloedTag> {
+  return SiloedTag.compute({ extendedSecret: secret, index });
+}
+
+/** Extracts the bare-tag set from a query */
+export function extractTags(query: PrivateLogsQuery): SiloedTag[] {
+  return query.tags.map((entry: TagQuery<SiloedTag>) => (entry instanceof SiloedTag ? entry : entry.tag));
+}

package/dest/access_scopes.d.ts

@@ -1,9 +0,0 @@
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-/**
- * Controls which accounts' private state and keys are accessible during execution.
- * - `'ALL_SCOPES'`: All registered accounts' private state and keys are accessible.
- * - `AztecAddress[]` with entries: Only the specified accounts' private state and keys are accessible.
- * - `[]` (empty array): Deny-all. No private state is visible and no keys are accessible.
- */
-export type AccessScopes = 'ALL_SCOPES' | AztecAddress[];
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWNjZXNzX3Njb3Blcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2FjY2Vzc19zY29wZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFFaEU7Ozs7O0dBS0c7QUFDSCxNQUFNLE1BQU0sWUFBWSxHQUFHLFlBQVksR0FBRyxZQUFZLEVBQUUsQ0FBQyJ9

package/dest/access_scopes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"access_scopes.d.ts","sourceRoot":"","sources":["../src/access_scopes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,YAAY,EAAE,CAAC"}

package/dest/access_scopes.js

@@ -1,6 +0,0 @@
-/**
- * Controls which accounts' private state and keys are accessible during execution.
- * - `'ALL_SCOPES'`: All registered accounts' private state and keys are accessible.
- * - `AztecAddress[]` with entries: Only the specified accounts' private state and keys are accessible.
- * - `[]` (empty array): Deny-all. No private state is visible and no keys are accessible.
- */ export { };

package/dest/contract_function_simulator/benchmarked_node.d.ts

@@ -1,9 +0,0 @@
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { NodeStats } from '@aztec/stdlib/tx';
-export type BenchmarkedNode = AztecNode & {
-    getStats(): NodeStats;
-};
-export declare class BenchmarkedNodeFactory {
-    static create(node: AztecNode): BenchmarkedNode;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmVuY2htYXJrZWRfbm9kZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0X2Z1bmN0aW9uX3NpbXVsYXRvci9iZW5jaG1hcmtlZF9ub2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ2pFLE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBa0IsTUFBTSxrQkFBa0IsQ0FBQztBQWlCbEUsTUFBTSxNQUFNLGVBQWUsR0FBRyxTQUFTLEdBQUc7SUFBRSxRQUFRLElBQUksU0FBUyxDQUFBO0NBQUUsQ0FBQztBQUVwRSxxQkFBYSxzQkFBc0I7SUFDakMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsU0FBUyxHQUFHLGVBQWUsQ0ErRTlDO0NBQ0YifQ==

package/dest/contract_function_simulator/benchmarked_node.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"benchmarked_node.d.ts","sourceRoot":"","sources":["../../src/contract_function_simulator/benchmarked_node.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,kBAAkB,CAAC;AAiBlE,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG;IAAE,QAAQ,IAAI,SAAS,CAAA;CAAE,CAAC;AAEpE,qBAAa,sBAAsB;IACjC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,SAAS,GAAG,eAAe,CA+E9C;CACF"}

package/dest/contract_function_simulator/benchmarked_node.js

@@ -1,77 +0,0 @@
-import { Timer } from '@aztec/foundation/timer';
-export class BenchmarkedNodeFactory {
-    static create(node) {
-        // Per-method call stats
-        const perMethod = {};
-        // Round trip tracking
-        let inFlightCount = 0;
-        let currentRoundTripTimer = null;
-        let currentRoundTripMethods = [];
-        const roundTrips = {
-            roundTrips: 0,
-            totalBlockingTime: 0,
-            roundTripDurations: [],
-            roundTripMethods: []
-        };
-        return new Proxy(node, {
-            get (target, prop) {
-                if (prop === 'getStats') {
-                    return ()=>{
-                        return {
-                            perMethod,
-                            roundTrips
-                        };
-                    };
-                } else {
-                    return function(...args) {
-                        // Track per-method stats
-                        if (!perMethod[prop]) {
-                            perMethod[prop] = {
-                                times: []
-                            };
-                        }
-                        // Start of a new round trip batch?
-                        if (inFlightCount === 0) {
-                            roundTrips.roundTrips++;
-                            currentRoundTripTimer = new Timer();
-                            currentRoundTripMethods = [];
-                        }
-                        inFlightCount++;
-                        currentRoundTripMethods.push(prop);
-                        const callTimer = new Timer();
-                        const result = target[prop].apply(target, args);
-                        // Handle completion - called when the call finishes (after Promise resolves)
-                        const handleCompletion = ()=>{
-                            const callTime = callTimer.ms();
-                            perMethod[prop].times.push(callTime);
-                            inFlightCount--;
-                            // End of round trip batch - all concurrent calls completed
-                            if (inFlightCount === 0 && currentRoundTripTimer) {
-                                const roundTripTime = currentRoundTripTimer.ms();
-                                roundTrips.totalBlockingTime += roundTripTime;
-                                roundTrips.roundTripDurations.push(roundTripTime);
-                                roundTrips.roundTripMethods.push(currentRoundTripMethods);
-                                currentRoundTripTimer = null;
-                                currentRoundTripMethods = [];
-                            }
-                        };
-                        // If the result is a Promise, chain the completion handler
-                        if (result && typeof result.then === 'function') {
-                            return result.then((value)=>{
-                                handleCompletion();
-                                return value;
-                            }, (error)=>{
-                                handleCompletion();
-                                throw error;
-                            });
-                        } else {
-                            // Synchronous method - handle completion immediately
-                            handleCompletion();
-                            return result;
-                        }
-                    };
-                }
-            }
-        });
-    }
-}

package/dest/contract_function_simulator/noir-structs/message_tx_context.d.ts

@@ -1,16 +0,0 @@
-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 declare class MessageTxContext {
-    txHash: TxHash;
-    uniqueNoteHashesInTx: Fr[];
-    firstNullifierInTx: Fr;
-    constructor(txHash: TxHash, uniqueNoteHashesInTx: Fr[], firstNullifierInTx: Fr);
-    toFields(): Fr[];
-    static toEmptyFields(): Fr[];
-    static toSerializedOption(response: MessageTxContext | null): Fr[];
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnZV90eF9jb250ZXh0LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29udHJhY3RfZnVuY3Rpb25fc2ltdWxhdG9yL25vaXItc3RydWN0cy9tZXNzYWdlX3R4X2NvbnRleHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3BELE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRS9DOzs7R0FHRztBQUNILHFCQUFhLGdCQUFnQjtJQUVsQixNQUFNLEVBQUUsTUFBTTtJQUNkLG9CQUFvQixFQUFFLEVBQUUsRUFBRTtJQUMxQixrQkFBa0IsRUFBRSxFQUFFO0lBSC9CLFlBQ1MsTUFBTSxFQUFFLE1BQU0sRUFDZCxvQkFBb0IsRUFBRSxFQUFFLEVBQUUsRUFDMUIsa0JBQWtCLEVBQUUsRUFBRSxFQUMzQjtJQUVKLFFBQVEsSUFBSSxFQUFFLEVBQUUsQ0FNZjtJQUVELE1BQU0sQ0FBQyxhQUFhLElBQUksRUFBRSxFQUFFLENBSTNCO0lBRUQsTUFBTSxDQUFDLGtCQUFrQixDQUFDLFFBQVEsRUFBRSxnQkFBZ0IsR0FBRyxJQUFJLEdBQUcsRUFBRSxFQUFFLENBTWpFO0NBQ0YifQ==

package/dest/contract_function_simulator/noir-structs/message_tx_context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"message_tx_context.d.ts","sourceRoot":"","sources":["../../../src/contract_function_simulator/noir-structs/message_tx_context.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C;;;GAGG;AACH,qBAAa,gBAAgB;IAElB,MAAM,EAAE,MAAM;IACd,oBAAoB,EAAE,EAAE,EAAE;IAC1B,kBAAkB,EAAE,EAAE;IAH/B,YACS,MAAM,EAAE,MAAM,EACd,oBAAoB,EAAE,EAAE,EAAE,EAC1B,kBAAkB,EAAE,EAAE,EAC3B;IAEJ,QAAQ,IAAI,EAAE,EAAE,CAMf;IAED,MAAM,CAAC,aAAa,IAAI,EAAE,EAAE,CAI3B;IAED,MAAM,CAAC,kBAAkB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI,GAAG,EAAE,EAAE,CAMjE;CACF"}

package/dest/contract_function_simulator/noir-structs/message_tx_context.js

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

@@ -1,9 +0,0 @@
-import type { ACIRCallback } 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 declare function buildLegacyOracleCallbacks(oracle: Oracle): ACIRCallback;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGVnYWN5X29yYWNsZV9tYXBwaW5ncy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NvbnRyYWN0X2Z1bmN0aW9uX3NpbXVsYXRvci9vcmFjbGUvbGVnYWN5X29yYWNsZV9tYXBwaW5ncy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQWEsTUFBTSx5QkFBeUIsQ0FBQztBQUV2RSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFFMUM7Ozs7R0FJRztBQUNILHdCQUFnQiwwQkFBMEIsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFlBQVksQ0E0SHZFIn0=

package/dest/contract_function_simulator/oracle/legacy_oracle_mappings.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"legacy_oracle_mappings.d.ts","sourceRoot":"","sources":["../../../src/contract_function_simulator/oracle/legacy_oracle_mappings.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAa,MAAM,yBAAyB,CAAC;AAEvE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CA4HvE"}

package/dest/contract_function_simulator/oracle/legacy_oracle_mappings.js

@@ -1,42 +0,0 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
-/**
- * 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) {
-    return {
-        // Simple prefix renames (privateXxx/utilityXxx → aztec_prv_/aztec_utl_)
-        utilityLog: (level, message, _ignoredFieldsSize, fields)=>oracle.aztec_utl_log(level, message, _ignoredFieldsSize, fields),
-        utilityAssertCompatibleOracleVersion: (version)=>oracle.aztec_utl_assertCompatibleOracleVersion(version),
-        utilityLoadCapsule: (contractAddress, slot, tSize)=>oracle.aztec_utl_loadCapsule(contractAddress, slot, tSize),
-        privateStoreInExecutionCache: (values, hash)=>oracle.aztec_prv_storeInExecutionCache(values, hash),
-        privateLoadFromExecutionCache: (returnsHash)=>oracle.aztec_prv_loadFromExecutionCache(returnsHash),
-        privateCallPrivateFunction: (contractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall)=>oracle.aztec_prv_callPrivateFunction(contractAddress, functionSelector, argsHash, sideEffectCounter, isStaticCall),
-        privateIsNullifierPending: (innerNullifier, contractAddress)=>oracle.aztec_prv_isNullifierPending(innerNullifier, contractAddress),
-        privateNotifyCreatedNullifier: (innerNullifier)=>oracle.aztec_prv_notifyCreatedNullifier(innerNullifier),
-        privateNotifyCreatedContractClassLog: (contractAddress, message, length, counter)=>oracle.aztec_prv_notifyCreatedContractClassLog(contractAddress, message, length, counter),
-        utilityGetUtilityContext: ()=>oracle.aztec_utl_getUtilityContext(),
-        utilityStorageRead: (blockHash, contractAddress, startStorageSlot, numberOfElements)=>oracle.aztec_utl_storageRead(blockHash, contractAddress, startStorageSlot, numberOfElements),
-        utilityStoreCapsule: (contractAddress, slot, capsule)=>oracle.aztec_utl_storeCapsule(contractAddress, slot, capsule),
-        utilityCopyCapsule: (contractAddress, srcSlot, dstSlot, numEntries)=>oracle.aztec_utl_copyCapsule(contractAddress, srcSlot, dstSlot, numEntries),
-        utilityDeleteCapsule: (contractAddress, slot)=>oracle.aztec_utl_deleteCapsule(contractAddress, slot),
-        utilityGetSharedSecret: (address, ephPKField0, ephPKField1, ephPKField2)=>oracle.aztec_utl_getSharedSecret(address, ephPKField0, ephPKField1, ephPKField2),
-        utilityFetchTaggedLogs: (pendingTaggedLogArrayBaseSlot)=>oracle.aztec_utl_fetchTaggedLogs(pendingTaggedLogArrayBaseSlot),
-        utilityBulkRetrieveLogs: (contractAddress, logRetrievalRequestsArrayBaseSlot, logRetrievalResponsesArrayBaseSlot)=>oracle.aztec_utl_bulkRetrieveLogs(contractAddress, logRetrievalRequestsArrayBaseSlot, logRetrievalResponsesArrayBaseSlot),
-        utilityGetL1ToL2MembershipWitness: (contractAddress, messageHash, secret)=>oracle.aztec_utl_getL1ToL2MembershipWitness(contractAddress, messageHash, secret),
-        utilityEmitOffchainEffect: (data)=>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, noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot)=>oracle.aztec_utl_validateAndStoreEnqueuedNotesAndEvents(contractAddress, noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot, [
-                new Fr(8).toString()
-            ], [
-                new Fr(10).toString()
-            ]),
-        // Renames (same signature, different oracle name)
-        privateNotifySetMinRevertibleSideEffectCounter: (counter)=>oracle.aztec_prv_notifyRevertiblePhaseStart(counter),
-        privateIsSideEffectCounterRevertible: (sideEffectCounter)=>oracle.aztec_prv_inRevertiblePhase(sideEffectCounter),
-        // Signature changes: old 4-param oracles → new 1-param validatePublicCalldata
-        privateNotifyEnqueuedPublicFunctionCall: (_contractAddress, calldataHash, _sideEffectCounter, _isStaticCall)=>oracle.aztec_prv_validatePublicCalldata(calldataHash),
-        privateNotifySetPublicTeardownFunctionCall: (_contractAddress, calldataHash, _sideEffectCounter, _isStaticCall)=>oracle.aztec_prv_validatePublicCalldata(calldataHash)
-    };
-}