@aztec/pxe 5.0.0-private.20260319 → 5.0.0-rc.2

package/dest/tagging/reconcile_tagging_index_ranges.js

@@ -0,0 +1,74 @@
+import { SiloedTag } from '@aztec/stdlib/logs';
+/**
+ * Reconciles tagging index ranges recorded by the PXE during private execution against the set of siloed tags whose
+ * private logs survived to the final kernel output.
+ *
+ * Each input range is the contiguous `[lowestIndex, highestIndex]` set of indexes that the tagging index cache
+ * reserved for a given tagging secret while a tx was being executed. The kernel may then squash some of those logs
+ * (e.g. when a note is created and nullified within the same tx, taking its log with it), so the actual on-chain
+ * footprint can be a strict subset of what was reserved.
+ *
+ * For each input range, this function shrinks `[lowestIndex, highestIndex]` so that both bounds correspond to indexes
+ * that actually survived, trimming any dropped indices at the front or the back. It is possible that some interior
+ * indexes were also dropped, leaving gaps between the lowest and highest indices, but we ignore those and accept the
+ * resulting inefficiency rather than complicate the tagging model with one in which transactions may use interleaved
+ * indices.
+ *
+ * Trimming tailing indices (e.g. `highestIndex`) is highly useful as it lets us reuse those indices in future
+ * transactions. Trimming indices at the front (e.g. `lowestIndex`) is not as impactful since we will not ever use a
+ * tagging index if a larger one exists (same as with gaps), but it does help in both making the consistency check
+ * between database and transaction effects cheaper (as there's fewer logs to test) and making the database more
+ * accurately reflect reality.
+ *
+ * Ranges with no surviving indexes are dropped from the output entirely.
+ *
+ * Example scenario:
+ *   - used indexes 3 to 7, kerel squashed indexes 3, 5, and 7:
+ *      - range: [3, 7]
+ *      - survived: set(3, 5, 7)
+ *      - output: [4, 6]  (trimmed from both ends, gap at 5 is tolerated)
+ *
+ * @param ranges - The tagging index ranges as recorded during private execution (pre-squash).
+ * @param survivingTags - The set of siloed tag values (as strings) of private logs that survived kernel squashing.
+ * @returns The reconciled ranges, with bounds tightened to surviving indexes and fully-squashed ranges removed.
+ */ export async function reconcileTaggingIndexRangesAgainstSurvivingTags(ranges, survivingTags) {
+    const reconciled = [];
+    for (const range of ranges){
+        const newLowestIndex = await findFirstSurvivingIndex(range.extendedSecret, range.lowestIndex, range.highestIndex, survivingTags);
+        if (newLowestIndex === undefined) {
+            continue;
+        }
+        // newLowestIndex is itself a survivor, so the backward scan is guaranteed to find at least that index.
+        const newHighestIndex = await findLastSurvivingIndex(range.extendedSecret, newLowestIndex, range.highestIndex, survivingTags);
+        reconciled.push({
+            extendedSecret: range.extendedSecret,
+            lowestIndex: newLowestIndex,
+            highestIndex: newHighestIndex
+        });
+    }
+    return reconciled;
+}
+/** Scans `[start, end]` ascending and returns the first index whose siloed tag is in `survivingTags`. */ async function findFirstSurvivingIndex(secret, start, end, survivingTags) {
+    for(let index = start; index <= end; index++){
+        const tag = await SiloedTag.compute({
+            extendedSecret: secret,
+            index
+        });
+        if (survivingTags.has(tag.value.toString())) {
+            return index;
+        }
+    }
+    return undefined;
+}
+/** Scans `[start, end]` descending and returns the first index whose siloed tag is in `survivingTags`. */ async function findLastSurvivingIndex(secret, start, end, survivingTags) {
+    for(let index = end; index >= start; index--){
+        const tag = await SiloedTag.compute({
+            extendedSecret: secret,
+            index
+        });
+        if (survivingTags.has(tag.value.toString())) {
+            return index;
+        }
+    }
+    return undefined;
+}

package/dest/tagging/sender_sync/sync_sender_tagging_indexes.d.ts

@@ -1,17 +1,16 @@
 import type { BlockHash } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
-import type { ExtendedDirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
+import type { AppTaggingSecret } from '@aztec/stdlib/logs';
 import type { SenderTaggingStore } from '../../storage/tagging_store/sender_tagging_store.js';
 /**
  * Syncs tagging indexes. This function needs to be called whenever a private log is being sent.
  *
- * @param secret - The secret that's unique for (sender, recipient, app) tuple while the direction of
- * sender -> recipient matters.
+ * @param secret - The sender-side tagging `AppTaggingSecret`.
  * @remarks When syncing the indexes as sender we don't care about the log contents - we only care about the highest
  * pending and highest finalized indexes as that guides the next index choice when sending a log. The next index choice
  * is simply the highest pending index plus one (or finalized if pending is undefined).
  * @dev This function looks for new indexes, adds them to pending, then it checks status of each pending index and
  * updates its status accordingly.
  */
-export declare function syncSenderTaggingIndexes(secret: ExtendedDirectionalAppTaggingSecret, aztecNode: AztecNode, taggingStore: SenderTaggingStore, anchorBlockHash: BlockHash, jobId: string): Promise<void>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luY19zZW5kZXJfdGFnZ2luZ19pbmRleGVzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGFnZ2luZy9zZW5kZXJfc3luYy9zeW5jX3NlbmRlcl90YWdnaW5nX2luZGV4ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDckQsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDakUsT0FBTyxLQUFLLEVBQUUsbUNBQW1DLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUU5RSxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHFEQUFxRCxDQUFDO0FBSzlGOzs7Ozs7Ozs7O0dBVUc7QUFDSCx3QkFBc0Isd0JBQXdCLENBQzVDLE1BQU0sRUFBRSxtQ0FBbUMsRUFDM0MsU0FBUyxFQUFFLFNBQVMsRUFDcEIsWUFBWSxFQUFFLGtCQUFrQixFQUNoQyxlQUFlLEVBQUUsU0FBUyxFQUMxQixLQUFLLEVBQUUsTUFBTSxHQUNaLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FxRmYifQ==
+export declare function syncSenderTaggingIndexes(secret: AppTaggingSecret, aztecNode: AztecNode, taggingStore: SenderTaggingStore, anchorBlockHash: BlockHash, jobId: string): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luY19zZW5kZXJfdGFnZ2luZ19pbmRleGVzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGFnZ2luZy9zZW5kZXJfc3luYy9zeW5jX3NlbmRlcl90YWdnaW5nX2luZGV4ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDckQsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDakUsT0FBTyxLQUFLLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUUzRCxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHFEQUFxRCxDQUFDO0FBUzlGOzs7Ozs7Ozs7R0FTRztBQUNILHdCQUFzQix3QkFBd0IsQ0FDNUMsTUFBTSxFQUFFLGdCQUFnQixFQUN4QixTQUFTLEVBQUUsU0FBUyxFQUNwQixZQUFZLEVBQUUsa0JBQWtCLEVBQ2hDLGVBQWUsRUFBRSxTQUFTLEVBQzFCLEtBQUssRUFBRSxNQUFNLEdBQ1osT0FBTyxDQUFDLElBQUksQ0FBQyxDQXdHZiJ9

package/dest/tagging/sender_sync/sync_sender_tagging_indexes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sync_sender_tagging_indexes.d.ts","sourceRoot":"","sources":["../../../src/tagging/sender_sync/sync_sender_tagging_indexes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,oBAAoB,CAAC;AAE9E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qDAAqD,CAAC;AAK9F;;;;;;;;;;GAUG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,mCAAmC,EAC3C,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,kBAAkB,EAChC,eAAe,EAAE,SAAS,EAC1B,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAqFf"}
+{"version":3,"file":"sync_sender_tagging_indexes.d.ts","sourceRoot":"","sources":["../../../src/tagging/sender_sync/sync_sender_tagging_indexes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qDAAqD,CAAC;AAS9F;;;;;;;;;GASG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,gBAAgB,EACxB,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,kBAAkB,EAChC,eAAe,EAAE,SAAS,EAC1B,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAwGf"}

package/dest/tagging/sender_sync/sync_sender_tagging_indexes.js

@@ -1,11 +1,10 @@
 import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../constants.js';
-import { getStatusChangeOfPending } from './utils/get_status_change_of_pending.js';
+import { EMPTY_STATUS_CHANGE, getStatusChangeOfPending, mergeStatusChanges } from './utils/get_status_change_of_pending.js';
 import { loadAndStoreNewTaggingIndexes } from './utils/load_and_store_new_tagging_indexes.js';
 /**
  * Syncs tagging indexes. This function needs to be called whenever a private log is being sent.
  *
- * @param secret - The secret that's unique for (sender, recipient, app) tuple while the direction of
- * sender -> recipient matters.
+ * @param secret - The sender-side tagging `AppTaggingSecret`.
  * @remarks When syncing the indexes as sender we don't care about the log contents - we only care about the highest
  * pending and highest finalized indexes as that guides the next index choice when sending a log. The next index choice
  * is simply the highest pending index plus one (or finalized if pending is undefined).
@@ -35,24 +34,37 @@ import { loadAndStoreNewTaggingIndexes } from './utils/load_and_store_new_taggin
     let previousFinalizedIndex = finalizedIndex;
     let newFinalizedIndex = undefined;
     while(true){
-        // Load and store indexes for the current window. These indexes may already exist in the database if txs using
-        // them were previously sent from this PXE. Any duplicates are handled by the tagging data provider.
-        await loadAndStoreNewTaggingIndexes(secret, start, end, aztecNode, taggingStore, anchorBlockHash, jobId);
-        // Retrieve all indexes within the current window from storage and update their status accordingly.
-        const pendingTxHashes = await taggingStore.getTxHashesOfPendingIndexes(secret, start, end, jobId);
-        if (pendingTxHashes.length === 0) {
+        // Pending tx hashes already in the store for this window (from prior syncs or txs this PXE itself sent).
+        // Reading these before issuing any RPC lets us fetch their receipts in parallel with the logs query below.
+        const knownPendingTxHashes = await taggingStore.getTxHashesOfPendingIndexes(secret, start, end, jobId);
+        // Fire the logs query and the known-pending receipts query in parallel
+        const [, statusOfKnown] = await Promise.all([
+            loadAndStoreNewTaggingIndexes(secret, start, end, aztecNode, taggingStore, anchorBlockHash, jobId),
+            knownPendingTxHashes.length > 0 ? getStatusChangeOfPending(knownPendingTxHashes, aztecNode) : Promise.resolve(EMPTY_STATUS_CHANGE)
+        ]);
+        // Re-read pending tx hashes after the logs query writes any newly-discovered ones to the store.
+        const allPendingTxHashes = await taggingStore.getTxHashesOfPendingIndexes(secret, start, end, jobId);
+        if (allPendingTxHashes.length === 0) {
             break;
         }
-        const { txHashesToFinalize, txHashesToDrop, txHashesWithExecutionReverted } = await getStatusChangeOfPending(pendingTxHashes, aztecNode);
+        // Receipts for pending tx hashes that the logs query just surfaced still need a sequential follow-up call.
+        // `storePendingIndexes` is idempotent on (secret, txHash), so a re-discovered hash stays classified as known
+        // and is not re-fetched here.
+        const knownSet = new Set(knownPendingTxHashes.map((h)=>h.toString()));
+        const newPendingTxHashes = allPendingTxHashes.filter((h)=>!knownSet.has(h.toString()));
+        const statusOfNew = newPendingTxHashes.length > 0 ? await getStatusChangeOfPending(newPendingTxHashes, aztecNode) : EMPTY_STATUS_CHANGE;
+        const { txHashesToFinalize, txHashesToDrop, txHashesWithExecutionReverted } = mergeStatusChanges(statusOfKnown, statusOfNew);
         await taggingStore.dropPendingIndexes(txHashesToDrop, jobId);
         await taggingStore.finalizePendingIndexes(txHashesToFinalize, jobId);
         if (txHashesWithExecutionReverted.length > 0) {
-            const indexedTxEffects = await Promise.all(txHashesWithExecutionReverted.map((txHash)=>aztecNode.getTxEffect(txHash)));
-            for (const indexedTxEffect of indexedTxEffects){
-                if (indexedTxEffect === undefined) {
+            const receipts = await Promise.all(txHashesWithExecutionReverted.map((txHash)=>aztecNode.getTxReceipt(txHash, {
+                    includeTxEffect: true
+                })));
+            for (const receipt of receipts){
+                if (!receipt.isMined() || !receipt.txEffect) {
                     throw new Error('TxEffect not found for execution-reverted tx. This is either a bug or a reorg has occurred.');
                 }
-                await taggingStore.finalizePendingIndexesOfAPartiallyRevertedTx(indexedTxEffect.data, jobId);
+                await taggingStore.finalizePendingIndexesOfAPartiallyRevertedTx(receipt.txEffect, jobId);
             }
         }
         // We check if the finalized index has been updated.

package/dest/tagging/sender_sync/utils/get_status_change_of_pending.d.ts

@@ -1,12 +1,17 @@
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
 import { TxHash } from '@aztec/stdlib/tx';
+/** Classification of a batch of pending tx hashes by the status change implied by their receipts. */
+export type StatusChange = {
+    txHashesToFinalize: TxHash[];
+    txHashesToDrop: TxHash[];
+    txHashesWithExecutionReverted: TxHash[];
+};
+export declare const EMPTY_STATUS_CHANGE: StatusChange;
+/** Concatenates two status changes field-by-field. */
+export declare function mergeStatusChanges(a: StatusChange, b: StatusChange): StatusChange;
 /**
  * Based on receipts obtained from `aztecNode` returns which pending transactions changed their status to finalized,
  * dropped, or execution-reverted (but mined).
  */
-export declare function getStatusChangeOfPending(pending: TxHash[], aztecNode: AztecNode): Promise<{
-    txHashesToFinalize: TxHash[];
-    txHashesToDrop: TxHash[];
-    txHashesWithExecutionReverted: TxHash[];
-}>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0X3N0YXR1c19jaGFuZ2Vfb2ZfcGVuZGluZy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvZ2V0X3N0YXR1c19jaGFuZ2Vfb2ZfcGVuZGluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEVBQUUsTUFBTSxFQUFZLE1BQU0sa0JBQWtCLENBQUM7QUFFcEQ7OztHQUdHO0FBQ0gsd0JBQXNCLHdCQUF3QixDQUM1QyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQ2pCLFNBQVMsRUFBRSxTQUFTLEdBQ25CLE9BQU8sQ0FBQztJQUNULGtCQUFrQixFQUFFLE1BQU0sRUFBRSxDQUFDO0lBQzdCLGNBQWMsRUFBRSxNQUFNLEVBQUUsQ0FBQztJQUN6Qiw2QkFBNkIsRUFBRSxNQUFNLEVBQUUsQ0FBQztDQUN6QyxDQUFDLENBb0NEIn0=
+export declare function getStatusChangeOfPending(pending: TxHash[], aztecNode: AztecNode): Promise<StatusChange>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0X3N0YXR1c19jaGFuZ2Vfb2ZfcGVuZGluZy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvZ2V0X3N0YXR1c19jaGFuZ2Vfb2ZfcGVuZGluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEVBQUUsTUFBTSxFQUFZLE1BQU0sa0JBQWtCLENBQUM7QUFFcEQscUdBQXFHO0FBQ3JHLE1BQU0sTUFBTSxZQUFZLEdBQUc7SUFDekIsa0JBQWtCLEVBQUUsTUFBTSxFQUFFLENBQUM7SUFDN0IsY0FBYyxFQUFFLE1BQU0sRUFBRSxDQUFDO0lBQ3pCLDZCQUE2QixFQUFFLE1BQU0sRUFBRSxDQUFDO0NBQ3pDLENBQUM7QUFFRixlQUFPLE1BQU0sbUJBQW1CLEVBQUUsWUFJakMsQ0FBQztBQUVGLHNEQUFzRDtBQUN0RCx3QkFBZ0Isa0JBQWtCLENBQUMsQ0FBQyxFQUFFLFlBQVksRUFBRSxDQUFDLEVBQUUsWUFBWSxHQUFHLFlBQVksQ0FNakY7QUFFRDs7O0dBR0c7QUFDSCx3QkFBc0Isd0JBQXdCLENBQUMsT0FBTyxFQUFFLE1BQU0sRUFBRSxFQUFFLFNBQVMsRUFBRSxTQUFTLEdBQUcsT0FBTyxDQUFDLFlBQVksQ0FBQyxDQW9DN0cifQ==

package/dest/tagging/sender_sync/utils/get_status_change_of_pending.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get_status_change_of_pending.d.ts","sourceRoot":"","sources":["../../../../src/tagging/sender_sync/utils/get_status_change_of_pending.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,MAAM,EAAY,MAAM,kBAAkB,CAAC;AAEpD;;;GAGG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,MAAM,EAAE,EACjB,SAAS,EAAE,SAAS,GACnB,OAAO,CAAC;IACT,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,6BAA6B,EAAE,MAAM,EAAE,CAAC;CACzC,CAAC,CAoCD"}
+{"version":3,"file":"get_status_change_of_pending.d.ts","sourceRoot":"","sources":["../../../../src/tagging/sender_sync/utils/get_status_change_of_pending.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,MAAM,EAAY,MAAM,kBAAkB,CAAC;AAEpD,qGAAqG;AACrG,MAAM,MAAM,YAAY,GAAG;IACzB,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,6BAA6B,EAAE,MAAM,EAAE,CAAC;CACzC,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,YAIjC,CAAC;AAEF,sDAAsD;AACtD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,GAAG,YAAY,CAMjF;AAED;;;GAGG;AACH,wBAAsB,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,YAAY,CAAC,CAoC7G"}

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

@@ -1,4 +1,25 @@
 import { TxStatus } from '@aztec/stdlib/tx';
+export const EMPTY_STATUS_CHANGE = {
+    txHashesToFinalize: [],
+    txHashesToDrop: [],
+    txHashesWithExecutionReverted: []
+};
+/** Concatenates two status changes field-by-field. */ export function mergeStatusChanges(a, b) {
+    return {
+        txHashesToFinalize: [
+            ...a.txHashesToFinalize,
+            ...b.txHashesToFinalize
+        ],
+        txHashesToDrop: [
+            ...a.txHashesToDrop,
+            ...b.txHashesToDrop
+        ],
+        txHashesWithExecutionReverted: [
+            ...a.txHashesWithExecutionReverted,
+            ...b.txHashesWithExecutionReverted
+        ]
+    };
+}
 /**
  * Based on receipts obtained from `aztecNode` returns which pending transactions changed their status to finalized,
  * dropped, or execution-reverted (but mined).

package/dest/tagging/sender_sync/utils/load_and_store_new_tagging_indexes.d.ts

@@ -1,12 +1,12 @@
 import type { BlockHash } from '@aztec/stdlib/block';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
-import type { ExtendedDirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
+import { type AppTaggingSecret } from '@aztec/stdlib/logs';
 import type { SenderTaggingStore } from '../../../storage/tagging_store/sender_tagging_store.js';
 /**
  * Loads tagging indexes from the Aztec node and stores them in the tagging data provider.
  * @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.
@@ -15,5 +15,5 @@ import type { SenderTaggingStore } from '../../../storage/tagging_store/sender_t
  * @param jobId - Job identifier, used to keep writes in-memory until they can be persisted in a data integrity
  * preserving way.
  */
-export declare function loadAndStoreNewTaggingIndexes(extendedSecret: ExtendedDirectionalAppTaggingSecret, start: number, end: number, aztecNode: AztecNode, taggingStore: SenderTaggingStore, anchorBlockHash: BlockHash, jobId: string): Promise<void>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvbG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNyRCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEtBQUssRUFBRSxtQ0FBbUMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBSTlFLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFHakc7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsd0JBQXNCLDZCQUE2QixDQUNqRCxjQUFjLEVBQUUsbUNBQW1DLEVBQ25ELEtBQUssRUFBRSxNQUFNLEVBQ2IsR0FBRyxFQUFFLE1BQU0sRUFDWCxTQUFTLEVBQUUsU0FBUyxFQUNwQixZQUFZLEVBQUUsa0JBQWtCLEVBQ2hDLGVBQWUsRUFBRSxTQUFTLEVBQzFCLEtBQUssRUFBRSxNQUFNLGlCQWdCZCJ9
+export declare function loadAndStoreNewTaggingIndexes(extendedSecret: AppTaggingSecret, start: number, end: number, aztecNode: AztecNode, taggingStore: SenderTaggingStore, anchorBlockHash: BlockHash, jobId: string): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvbG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNyRCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEVBQUUsS0FBSyxnQkFBZ0IsRUFBYSxNQUFNLG9CQUFvQixDQUFDO0FBR3RFLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFHakc7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsd0JBQXNCLDZCQUE2QixDQUNqRCxjQUFjLEVBQUUsZ0JBQWdCLEVBQ2hDLEtBQUssRUFBRSxNQUFNLEVBQ2IsR0FBRyxFQUFFLE1BQU0sRUFDWCxTQUFTLEVBQUUsU0FBUyxFQUNwQixZQUFZLEVBQUUsa0JBQWtCLEVBQ2hDLGVBQWUsRUFBRSxTQUFTLEVBQzFCLEtBQUssRUFBRSxNQUFNLGlCQWdCZCJ9

package/dest/tagging/sender_sync/utils/load_and_store_new_tagging_indexes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load_and_store_new_tagging_indexes.d.ts","sourceRoot":"","sources":["../../../../src/tagging/sender_sync/utils/load_and_store_new_tagging_indexes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,oBAAoB,CAAC;AAI9E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wDAAwD,CAAC;AAGjG;;;;;;;;;;;;GAYG;AACH,wBAAsB,6BAA6B,CACjD,cAAc,EAAE,mCAAmC,EACnD,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,kBAAkB,EAChC,eAAe,EAAE,SAAS,EAC1B,KAAK,EAAE,MAAM,iBAgBd"}
+{"version":3,"file":"load_and_store_new_tagging_indexes.d.ts","sourceRoot":"","sources":["../../../../src/tagging/sender_sync/utils/load_and_store_new_tagging_indexes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,KAAK,gBAAgB,EAAa,MAAM,oBAAoB,CAAC;AAGtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wDAAwD,CAAC;AAGjG;;;;;;;;;;;;GAYG;AACH,wBAAsB,6BAA6B,CACjD,cAAc,EAAE,gBAAgB,EAChC,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,kBAAkB,EAChC,eAAe,EAAE,SAAS,EAC1B,KAAK,EAAE,MAAM,iBAgBd"}

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

@@ -5,7 +5,7 @@ import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
  * Loads tagging indexes from the Aztec node and stores them in the tagging data provider.
  * @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.
@@ -40,7 +40,7 @@ import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
 // an array for each tag.
 async function getTxsContainingTags(tags, aztecNode, anchorBlockHash) {
     // 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.
+    // pagination here. Sender sync only needs `txHash` from each log, so we leave `includeEffects` off.
     const allLogs = await getAllPrivateLogsByTags(aztecNode, tags, anchorBlockHash);
     return allLogs.map((logs)=>logs.map((log)=>log.txHash));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/pxe",
-  "version": "5.0.0-private.20260319",
+  "version": "5.0.0-rc.2",
   "type": "module",
   "typedocOptions": {
     "entryPoints": [
@@ -16,7 +16,8 @@
     "./client/lazy": "./dest/entrypoints/client/lazy/index.js",
     "./client/bundle": "./dest/entrypoints/client/bundle/index.js",
     "./simulator": "./dest/contract_function_simulator/index.js",
-    "./config": "./dest/config/index.js"
+    "./config": "./dest/config/index.js",
+    "./bin": "./dest/bin/index.js"
   },
   "bin": "./dest/bin/index.js",
   "scripts": {
@@ -70,19 +71,20 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb-prover": "5.0.0-private.20260319",
-    "@aztec/bb.js": "5.0.0-private.20260319",
-    "@aztec/builder": "5.0.0-private.20260319",
-    "@aztec/constants": "5.0.0-private.20260319",
-    "@aztec/ethereum": "5.0.0-private.20260319",
-    "@aztec/foundation": "5.0.0-private.20260319",
-    "@aztec/key-store": "5.0.0-private.20260319",
-    "@aztec/kv-store": "5.0.0-private.20260319",
-    "@aztec/noir-protocol-circuits-types": "5.0.0-private.20260319",
-    "@aztec/noir-types": "5.0.0-private.20260319",
-    "@aztec/protocol-contracts": "5.0.0-private.20260319",
-    "@aztec/simulator": "5.0.0-private.20260319",
-    "@aztec/stdlib": "5.0.0-private.20260319",
+    "@aztec/bb-prover": "5.0.0-rc.2",
+    "@aztec/bb.js": "5.0.0-rc.2",
+    "@aztec/builder": "5.0.0-rc.2",
+    "@aztec/constants": "5.0.0-rc.2",
+    "@aztec/ethereum": "5.0.0-rc.2",
+    "@aztec/foundation": "5.0.0-rc.2",
+    "@aztec/key-store": "5.0.0-rc.2",
+    "@aztec/kv-store": "5.0.0-rc.2",
+    "@aztec/noir-protocol-circuits-types": "5.0.0-rc.2",
+    "@aztec/noir-types": "5.0.0-rc.2",
+    "@aztec/protocol-contracts": "5.0.0-rc.2",
+    "@aztec/simulator": "5.0.0-rc.2",
+    "@aztec/standard-contracts": "5.0.0-rc.2",
+    "@aztec/stdlib": "5.0.0-rc.2",
     "koa": "^2.16.1",
     "koa-router": "^13.1.1",
     "lodash.omit": "^4.5.0",
@@ -91,8 +93,8 @@
     "viem": "npm:@aztec/viem@2.38.2"
   },
   "devDependencies": {
-    "@aztec/noir-test-contracts.js": "5.0.0-private.20260319",
-    "@aztec/world-state": "5.0.0-private.20260319",
+    "@aztec/noir-test-contracts.js": "5.0.0-rc.2",
+    "@aztec/world-state": "5.0.0-rc.2",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/lodash.omit": "^4.5.7",
@@ -100,6 +102,7 @@
     "@types/node": "^22.15.17",
     "@typescript/native-preview": "7.0.0-dev.20260113.1",
     "jest": "^30.0.0",
+    "jest-file-snapshot": "^0.7.0",
     "jest-mock-extended": "^4.0.0",
     "lodash.times": "^4.3.2",
     "ts-node": "^10.9.1",

package/src/bin/check_oracle_version.ts

@@ -1,161 +1,79 @@
-/* eslint-disable import-x/no-named-as-default-member */
 import { keccak256String } from '@aztec/foundation/crypto/keccak';
 
-import { readFileSync } from 'fs';
 import { dirname, join } from 'path';
-import ts from 'typescript';
 import { fileURLToPath } from 'url';
 
-import { ORACLE_INTERFACE_HASH } from '../oracle_version.js';
+import { ORACLE_INTERFACE_HASH, ORACLE_VERSION_MAJOR } from '../oracle_version.js';
+import { getOracleRegistrySignature, readNumericGlobal } from './oracle_version_helpers.js';
 
 /**
  * Verifies that the Oracle interface matches the expected interface hash.
  *
  * The Oracle interface needs to be versioned to ensure compatibility between Aztec.nr and PXE. This function computes
- * a hash of the Oracle interface and compares it against a known hash. If they don't match, it means the interface has
- * changed and the ORACLE_VERSION constant needs to be incremented and the ORACLE_INTERFACE_HASH constant needs to be
- * updated.
- *
- * TODO(#16581): The following only takes into consideration changes to the oracles defined in Oracle.ts and omits TXE
- * oracles. Ensure this checks TXE oracles as well. This hasn't been implemented yet since we don't have a clean TXE
- * oracle interface like we do in PXE (i.e., there is no single Oracle class that contains only the oracles).
+ * a hash of the `ORACLE_REGISTRY` declaration (where each oracle's parameter names, parameter types, and return type
+ * live) and compares it against a known hash. If they don't match, it means the interface has changed and the oracle
+ * version needs to be bumped:
+ *   - If the change is backward-breaking (e.g. removing/renaming an oracle, or changing its params/return), bump
+ *     ORACLE_VERSION_MAJOR.
+ *   - If the change is an oracle addition (non-breaking), bump ORACLE_VERSION_MINOR.
  */
 function assertOracleInterfaceMatches(): void {
-  const oracleInterfaceSignature = getOracleInterfaceSignature();
+  // The script runs from dest/bin/ after compilation, so we go up to the package root then into src/ to find
+  // the source file.
+  const currentDir = dirname(fileURLToPath(import.meta.url));
+  const packageRoot = dirname(dirname(currentDir)); // Go up from bin/ to pxe/
+  const registrySourcePath = join(packageRoot, 'src/contract_function_simulator/oracle/oracle_registry.ts');
+
+  const oracleInterfaceSignature = getOracleRegistrySignature(registrySourcePath, 'ORACLE_REGISTRY');
 
   // We use keccak256 here just because we already have it in the dependencies.
   const oracleInterfaceHash = keccak256String(oracleInterfaceSignature);
   if (oracleInterfaceHash !== ORACLE_INTERFACE_HASH) {
-    // This check exists only to notify you when you need to update the ORACLE_VERSION constant.
     throw new Error(
-      `The Oracle interface has changed, which implies a breaking change in the aztec.nr/PXE oracle interface. Update ORACLE_INTERFACE_HASH to ${oracleInterfaceHash} and bump ORACLE_VERSION in pxe/src/oracle_version.ts.`,
+      `The Oracle interface has changed. Update ORACLE_INTERFACE_HASH to ${oracleInterfaceHash} in pxe/src/oracle_version.ts and bump the oracle version (ORACLE_VERSION_MAJOR for breaking changes, ORACLE_VERSION_MINOR for oracle additions).`,
     );
   }
 }
 
 /**
- * Constructs a signature of the Oracle interface while ignoring methods that are not foreign call handlers.
+ * Verifies that `ORACLE_VERSION_MAJOR` is identical across all of its hand-maintained copies.
+ *
+ * The major version is duplicated across the PXE TypeScript constant and two Noir constants (Aztec.nr and the protocol
+ * contracts' `aztec_sublib`) because those layers can't import each other. This static check fails fast at build time,
+ * naming each file and its value.
+ *
+ * Only the major version is checked: the minor version legitimately diverges under the "environment minor >= contract
+ * minor" tolerance, so asserting minor equality would false-positive.
  */
-function getOracleInterfaceSignature(): string {
-  const excludedProps = [
-    'handler',
-    'constructor',
-    'toACIRCallback',
-    'handlerAsMisc',
-    'handlerAsUtility',
-    'handlerAsPrivate',
-  ] as const;
-
-  // Get the path to Oracle.ts source file
-  // The script runs from dest/bin/ after compilation, so we need to go up to the package root
-  // then into src/ to find the source file
+function assertContractOracleVersionMajorInSync(): void {
   const currentDir = dirname(fileURLToPath(import.meta.url));
-  // Go up from dest/bin/ or src/bin/ to the package root (pxe/), then into src/
-  const packageRoot = dirname(dirname(currentDir)); // Go up from bin/ to pxe/
-  const oracleSourcePath = join(packageRoot, 'src/contract_function_simulator/oracle/oracle.ts');
-
-  // Read and parse the TypeScript source file
-  const sourceCode = readFileSync(oracleSourcePath, 'utf-8');
-  const sourceFile = ts.createSourceFile('oracle.ts', sourceCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-
-  // Extract method signatures from the Oracle class
-  const methodSignatures: string[] = [];
-
-  function visit(node: ts.Node) {
-    // Look for class declaration named "Oracle"
-    if (ts.isClassDeclaration(node) && node.name?.text === 'Oracle') {
-      // Visit all members of the class
-      node.members.forEach(member => {
-        if (ts.isMethodDeclaration(member) && member.name && ts.isIdentifier(member.name)) {
-          const methodName = member.name.text;
-
-          // Skip excluded methods
-          if (excludedProps.includes(methodName as (typeof excludedProps)[number])) {
-            return;
-          }
-
-          // Extract parameter signatures
-          const paramSignatures: string[] = [];
-          member.parameters.forEach(param => {
-            const paramName = extractParameterName(param, sourceFile);
-            const paramType = extractTypeString(param.type, sourceFile);
-            paramSignatures.push(`${paramName}: ${paramType}`);
-          });
-
-          // Extract return type
-          const returnType = extractTypeString(member.type, sourceFile);
-
-          // Build full signature: methodName(param1: Type1, param2: Type2): ReturnType
-          const signature = `${methodName}(${paramSignatures.join(', ')}): ${returnType}`;
-          methodSignatures.push(signature);
-        }
-      });
-    }
-
-    ts.forEachChild(node, visit);
-  }
-
-  visit(sourceFile);
-
-  // Sort signatures alphabetically for consistent hashing
-  methodSignatures.sort();
-
-  // Create a hashable representation by concatenating all signatures
-  return methodSignatures.join('');
-}
-
-/**
- * Extracts the parameter name from a parameter node, handling destructured parameters.
- */
-function extractParameterName(param: ts.ParameterDeclaration, sourceFile: ts.SourceFile): string {
-  const name = param.name;
-
-  if (ts.isIdentifier(name)) {
-    return name.text;
-  }
-
-  if (ts.isArrayBindingPattern(name)) {
-    // Handle destructured parameters like [blockNumber]: ACVMField[]
-    // Extract the first element name
-    if (name.elements.length > 0) {
-      const element = name.elements[0];
-      if (ts.isBindingElement(element)) {
-        const elementName = element.name;
-        if (ts.isIdentifier(elementName)) {
-          return elementName.text;
-        }
-        // Nested destructuring - use text representation
-        if (ts.isArrayBindingPattern(elementName) || ts.isObjectBindingPattern(elementName)) {
-          return elementName.getText(sourceFile);
-        }
-      }
-    }
-    // Fallback: return the text representation
-    return name.getText(sourceFile);
+  // Go up from dest/bin/ or src/bin/ to the package root (pxe/), then up two more to the git root.
+  const packageRoot = dirname(dirname(currentDir));
+  const gitRoot = join(packageRoot, '..', '..');
+
+  const copies = [
+    { label: 'pxe/src/oracle_version.ts', value: ORACLE_VERSION_MAJOR },
+    {
+      label: 'aztec-nr/aztec/src/oracle/version.nr',
+      value: readNumericGlobal(
+        join(gitRoot, 'noir-projects/aztec-nr/aztec/src/oracle/version.nr'),
+        'ORACLE_VERSION_MAJOR',
+      ),
+    },
+    {
+      label: 'aztec_sublib/src/oracle/version.nr',
+      value: readNumericGlobal(
+        join(gitRoot, 'noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/version.nr'),
+        'ORACLE_VERSION_MAJOR',
+      ),
+    },
+  ];
+
+  if (new Set(copies.map(copy => copy.value)).size > 1) {
+    const details = copies.map(copy => `${copy.label}=${copy.value}`).join(', ');
+    throw new Error(`ORACLE_VERSION_MAJOR is out of sync: ${details}. Bump all copies together.`);
   }
-
-  if (ts.isObjectBindingPattern(name)) {
-    // Handle object destructuring
-    return name.getText(sourceFile);
-  }
-
-  // Fallback for any other case - this should never happen but TypeScript needs it
-  return (name as ts.Node).getText(sourceFile);
-}
-
-/**
- * Extracts the type string from a type node, normalizing whitespace.
- */
-function extractTypeString(typeNode: ts.TypeNode | undefined, sourceFile: ts.SourceFile): string {
-  if (!typeNode) {
-    return 'void';
-  }
-
-  // Get the type text and normalize whitespace
-  let typeText = typeNode.getText(sourceFile);
-  // Normalize whitespace: remove extra spaces, newlines, and tabs
-  typeText = typeText.replace(/\s+/g, ' ').trim();
-  return typeText;
 }
 
 assertOracleInterfaceMatches();
+assertContractOracleVersionMajorInSync();

package/src/bin/index.ts

@@ -0,0 +1,5 @@
+export {
+  getOracleInterfaceSignature,
+  getOracleRegistrySignature,
+  readNumericGlobal,
+} from './oracle_version_helpers.js';