@aztec/pxe 0.0.1-commit.fce3e4f → 0.0.1-commit.ff7989d6c

package/dest/tagging/recipient_sync/load_private_logs_for_sender_recipient_pair.js

@@ -0,0 +1,99 @@
+import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../constants.js';
+import { findHighestIndexes } from './utils/find_highest_indexes.js';
+import { loadLogsForRange } from './utils/load_logs_for_range.js';
+/**
+ * Loads private logs for `app` and  sender-recipient pair defined by `secret` and updates the highest aged and
+ * finalized indexes in the db. At most load logs from blocks up to and including `anchorBlockNumber`.
+ *
+ * @dev This function can be safely executed "in parallel" for other sender-recipient pairs because the data in
+ * in the tagging data provider is indexed by the secret and hence completely disjoint.
+ */ export async function loadPrivateLogsForSenderRecipientPair(secret, app, aztecNode, taggingStore, anchorBlockNumber, anchorBlockHash, jobId) {
+    // # Explanation of how the algorithm works
+    // When we perform the sync we will look at logs that correspond to the tagging index range
+    // (highestAgedIndex, highestFinalizedIndex + WINDOW_LEN]
+    //
+    // highestAgedIndex is the highest index that was used in a tx that is included in a block at least
+    //                  `MAX_TX_LIFETIME` seconds ago.
+    // highestFinalizedIndex is the highest index that was used in a tx that is included in a finalized block.
+    //
+    // "(" denotes an open end of the range - the index is not included in the range.
+    // "]" denotes a closed end of the range - the index is included in the range.
+    //
+    // ## Explanation of highestAgedIndex
+    //
+    // highestAgedIndex is chosen such that for all tagging indexes `i <= highestAgedIndex` we know that no new logs can
+    // ever appear.
+    //
+    // This relies on the "maximum inclusion timestamp" rule enforced by the kernel and rollup circuits:
+    // - a transaction's maximum inclusion timestamp is at most `MAX_TX_LIFETIME` seconds after
+    //   the timestamp of its anchor block; and
+    // - a rollup only includes transactions whose inclusion timestamp is >= the L2 block's timestamp.
+    //
+    // Suppose some device used index `I` in a transaction anchored to block `B_N` at time `N`, and that block is now at
+    // least `MAX_TX_LIFETIME` seconds in the past. Then there is no possibility of any *other* device
+    // trying to use an index <= `I` while anchoring to a *newer* block than `B_N` because if we were anchoring to
+    // a newer block than `B_N` then we would already have seen the log with index `I` and hence the device would have
+    // chosen a larger index.
+    //    If that *other* device would anchor to a block older than `B_N` then that tx could never be included in a block
+    // because it would already have been expired.
+    //
+    // Therefore, once we see that index `I` has been used in a block that is at least `MAX_TX_LIFETIME`
+    // seconds old, we can safely stop syncing logs for all indexes <= `I` and set highestAgedIndex = `I`.
+    //
+    // ## Explanation of the upper bound `highestFinalizedIndex + WINDOW_LEN`
+    //
+    // When a sender chooses a tagging index, they will select an index that is at most `WINDOW_LEN` greater than
+    // the highest finalized index. If that index was already used, they will throw an error. For this reason we
+    // don't have to look further than `highestFinalizedIndex + WINDOW_LEN`.
+    let finalizedBlockNumber, currentTimestamp;
+    {
+        const [l2Tips, latestBlockHeader] = await Promise.all([
+            aztecNode.getL2Tips(),
+            aztecNode.getBlockHeader('latest')
+        ]);
+        if (!latestBlockHeader) {
+            throw new Error('Node failed to return latest block header when syncing logs');
+        }
+        [finalizedBlockNumber, currentTimestamp] = [
+            l2Tips.finalized.block.number,
+            latestBlockHeader.globalVariables.timestamp
+        ];
+    }
+    let start, end;
+    {
+        const currentHighestAgedIndex = await taggingStore.getHighestAgedIndex(secret, jobId);
+        const currentHighestFinalizedIndex = await taggingStore.getHighestFinalizedIndex(secret, jobId);
+        // We don't want to include the highest aged index so we start from `currentHighestAgedIndex + 1` (or 0 if not set)
+        start = currentHighestAgedIndex === undefined ? 0 : currentHighestAgedIndex + 1;
+        // The highest index a sender can choose is "highest finalized index + window length" but given that
+        // `loadLogsForRange` expects an exclusive `end` we add 1.
+        end = (currentHighestFinalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
+    }
+    const logs = [];
+    while(true){
+        // Get private logs with their block timestamps and corresponding tagging indexes
+        const privateLogsWithIndexes = await loadLogsForRange(secret, app, aztecNode, start, end, anchorBlockNumber, anchorBlockHash);
+        if (privateLogsWithIndexes.length === 0) {
+            break;
+        }
+        logs.push(...privateLogsWithIndexes.map(({ log })=>log));
+        const { highestAgedIndex, highestFinalizedIndex } = findHighestIndexes(privateLogsWithIndexes, currentTimestamp, finalizedBlockNumber);
+        // Store updates in data provider and update local variables
+        if (highestAgedIndex !== undefined) {
+            await taggingStore.updateHighestAgedIndex(secret, highestAgedIndex, jobId);
+        }
+        if (highestFinalizedIndex === undefined) {
+            break;
+        }
+        if (highestAgedIndex !== undefined && highestAgedIndex > highestFinalizedIndex) {
+            // This is just a sanity check as this should never happen.
+            throw new Error('Highest aged index lower than highest finalized index invariant violated');
+        }
+        await taggingStore.updateHighestFinalizedIndex(secret, highestFinalizedIndex, jobId);
+        // For the next iteration we want to look only at indexes for which we have not attempted to load logs yet while
+        // ensuring that we do not look further than WINDOW_LEN ahead of the highest finalized index.
+        start = end;
+        end = highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1; // `end` is exclusive so we add 1.
+    }
+    return logs;
+}

package/dest/tagging/recipient_sync/utils/find_highest_indexes.d.ts

@@ -0,0 +1,12 @@
+import type { TxScopedL2Log } from '@aztec/stdlib/logs';
+/**
+ * Finds the highest aged and the highest finalized tagging indexes.
+ */
+export declare function findHighestIndexes(privateLogsWithIndexes: Array<{
+    log: TxScopedL2Log;
+    taggingIndex: number;
+}>, currentTimestamp: bigint, finalizedBlockNumber: number): {
+    highestAgedIndex: number | undefined;
+    highestFinalizedIndex: number | undefined;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZF9oaWdoZXN0X2luZGV4ZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy90YWdnaW5nL3JlY2lwaWVudF9zeW5jL3V0aWxzL2ZpbmRfaGlnaGVzdF9pbmRleGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLGFBQWEsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXhEOztHQUVHO0FBQ0gsd0JBQWdCLGtCQUFrQixDQUNoQyxzQkFBc0IsRUFBRSxLQUFLLENBQUM7SUFBRSxHQUFHLEVBQUUsYUFBYSxDQUFDO0lBQUMsWUFBWSxFQUFFLE1BQU0sQ0FBQTtDQUFFLENBQUMsRUFDM0UsZ0JBQWdCLEVBQUUsTUFBTSxFQUN4QixvQkFBb0IsRUFBRSxNQUFNLEdBQzNCO0lBQUUsZ0JBQWdCLEVBQUUsTUFBTSxHQUFHLFNBQVMsQ0FBQztJQUFDLHFCQUFxQixFQUFFLE1BQU0sR0FBRyxTQUFTLENBQUE7Q0FBRSxDQXVCckYifQ==

package/dest/tagging/recipient_sync/utils/find_highest_indexes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find_highest_indexes.d.ts","sourceRoot":"","sources":["../../../../src/tagging/recipient_sync/utils/find_highest_indexes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,sBAAsB,EAAE,KAAK,CAAC;IAAE,GAAG,EAAE,aAAa,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC,EAC3E,gBAAgB,EAAE,MAAM,EACxB,oBAAoB,EAAE,MAAM,GAC3B;IAAE,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,qBAAqB,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAuBrF"}

package/dest/tagging/recipient_sync/utils/find_highest_indexes.js

@@ -0,0 +1,20 @@
+import { MAX_TX_LIFETIME } from '@aztec/constants';
+/**
+ * Finds the highest aged and the highest finalized tagging indexes.
+ */ export function findHighestIndexes(privateLogsWithIndexes, currentTimestamp, finalizedBlockNumber) {
+    let highestAgedIndex = undefined;
+    let highestFinalizedIndex = undefined;
+    for (const { log, taggingIndex } of privateLogsWithIndexes){
+        const ageInSeconds = currentTimestamp - log.blockTimestamp;
+        if (ageInSeconds >= BigInt(MAX_TX_LIFETIME) && (highestAgedIndex === undefined || taggingIndex > highestAgedIndex)) {
+            highestAgedIndex = taggingIndex;
+        }
+        if (log.blockNumber <= finalizedBlockNumber && (highestFinalizedIndex === undefined || taggingIndex > highestFinalizedIndex)) {
+            highestFinalizedIndex = taggingIndex;
+        }
+    }
+    return {
+        highestAgedIndex,
+        highestFinalizedIndex
+    };
+}

package/dest/tagging/recipient_sync/utils/load_logs_for_range.d.ts

@@ -0,0 +1,15 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHash } from '@aztec/stdlib/block';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { DirectionalAppTaggingSecret, TxScopedL2Log } from '@aztec/stdlib/logs';
+/**
+ * Gets private logs with their corresponding block timestamps and tagging indexes for the given index range, `app` and
+ * `secret`. At most load logs from blocks up to and including `anchorBlockNumber`. `start` is inclusive and `end` is
+ * exclusive.
+ */
+export declare function loadLogsForRange(secret: DirectionalAppTaggingSecret, app: AztecAddress, aztecNode: AztecNode, start: number, end: number, anchorBlockNumber: BlockNumber, anchorBlockHash: BlockHash): Promise<Array<{
+    log: TxScopedL2Log;
+    taggingIndex: number;
+}>>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZF9sb2dzX2Zvcl9yYW5nZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvcmVjaXBpZW50X3N5bmMvdXRpbHMvbG9hZF9sb2dzX2Zvcl9yYW5nZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNuRSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNoRSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNyRCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEtBQUssRUFBRSwyQkFBMkIsRUFBVSxhQUFhLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUs3Rjs7OztHQUlHO0FBQ0gsd0JBQXNCLGdCQUFnQixDQUNwQyxNQUFNLEVBQUUsMkJBQTJCLEVBQ25DLEdBQUcsRUFBRSxZQUFZLEVBQ2pCLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLEtBQUssRUFBRSxNQUFNLEVBQ2IsR0FBRyxFQUFFLE1BQU0sRUFDWCxpQkFBaUIsRUFBRSxXQUFXLEVBQzlCLGVBQWUsRUFBRSxTQUFTLEdBQ3pCLE9BQU8sQ0FBQyxLQUFLLENBQUM7SUFBRSxHQUFHLEVBQUUsYUFBYSxDQUFDO0lBQUMsWUFBWSxFQUFFLE1BQU0sQ0FBQTtDQUFFLENBQUMsQ0FBQyxDQTBCOUQifQ==

package/dest/tagging/recipient_sync/utils/load_logs_for_range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load_logs_for_range.d.ts","sourceRoot":"","sources":["../../../../src/tagging/recipient_sync/utils/load_logs_for_range.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,2BAA2B,EAAU,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAK7F;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,2BAA2B,EACnC,GAAG,EAAE,YAAY,EACjB,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,iBAAiB,EAAE,WAAW,EAC9B,eAAe,EAAE,SAAS,GACzB,OAAO,CAAC,KAAK,CAAC;IAAE,GAAG,EAAE,aAAa,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CA0B9D"}

package/dest/tagging/recipient_sync/utils/load_logs_for_range.js

@@ -0,0 +1,32 @@
+import { SiloedTag, Tag } from '@aztec/stdlib/logs';
+import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
+/**
+ * Gets private logs with their corresponding block timestamps and tagging indexes for the given index range, `app` and
+ * `secret`. At most load logs from blocks up to and including `anchorBlockNumber`. `start` is inclusive and `end` is
+ * exclusive.
+ */ export async function loadLogsForRange(secret, app, aztecNode, start, end, anchorBlockNumber, anchorBlockHash) {
+    // Derive tags for the window
+    const preTags = Array(end - start).fill(0).map((_, i)=>({
+            secret,
+            index: start + i
+        }));
+    const siloedTags = await Promise.all(preTags.map((preTag)=>Tag.compute(preTag))).then((tags)=>Promise.all(tags.map((tag)=>SiloedTag.compute(tag, app))));
+    // 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 logs = await getAllPrivateLogsByTags(aztecNode, siloedTags, anchorBlockHash);
+    // Pair logs with their corresponding tagging indexes
+    const logsWithIndexes = [];
+    for(let i = 0; i < logs.length; i++){
+        const logsForTag = logs[i];
+        const taggingIndex = preTags[i].index;
+        for (const log of logsForTag){
+            if (log.blockNumber <= anchorBlockNumber) {
+                logsWithIndexes.push({
+                    log,
+                    taggingIndex
+                });
+            }
+        }
+    }
+    return logsWithIndexes;
+}

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

@@ -0,0 +1,21 @@
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHash } from '@aztec/stdlib/block';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import type { DirectionalAppTaggingSecret } 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, contract) tuple while the direction of
+ * sender -> recipient matters.
+ * @param app - The address of the contract that the logs are tagged for. Needs to be provided because we perform
+ * second round of siloing in this function which is necessary because kernels do it as well (they silo first field
+ * of the private log which corresponds to the tag).
+ * @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: DirectionalAppTaggingSecret, app: AztecAddress, aztecNode: AztecNode, taggingStore: SenderTaggingStore, anchorBlockHash: BlockHash, jobId: string): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luY19zZW5kZXJfdGFnZ2luZ19pbmRleGVzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGFnZ2luZy9zZW5kZXJfc3luYy9zeW5jX3NlbmRlcl90YWdnaW5nX2luZGV4ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDaEUsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDckQsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDakUsT0FBTyxLQUFLLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUV0RSxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHFEQUFxRCxDQUFDO0FBSzlGOzs7Ozs7Ozs7Ozs7O0dBYUc7QUFDSCx3QkFBc0Isd0JBQXdCLENBQzVDLE1BQU0sRUFBRSwyQkFBMkIsRUFDbkMsR0FBRyxFQUFFLFlBQVksRUFDakIsU0FBUyxFQUFFLFNBQVMsRUFDcEIsWUFBWSxFQUFFLGtCQUFrQixFQUNoQyxlQUFlLEVBQUUsU0FBUyxFQUMxQixLQUFLLEVBQUUsTUFBTSxHQUNaLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FtRWYifQ==

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

@@ -0,0 +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,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qDAAqD,CAAC;AAK9F;;;;;;;;;;;;;GAaG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,2BAA2B,EACnC,GAAG,EAAE,YAAY,EACjB,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,kBAAkB,EAChC,eAAe,EAAE,SAAS,EAC1B,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAmEf"}

package/dest/tagging/sender_sync/sync_sender_tagging_indexes.js

@@ -0,0 +1,74 @@
+import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../constants.js';
+import { getStatusChangeOfPending } 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, contract) tuple while the direction of
+ * sender -> recipient matters.
+ * @param app - The address of the contract that the logs are tagged for. Needs to be provided because we perform
+ * second round of siloing in this function which is necessary because kernels do it as well (they silo first field
+ * of the private log which corresponds to the tag).
+ * @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 async function syncSenderTaggingIndexes(secret, app, aztecNode, taggingStore, anchorBlockHash, jobId) {
+    // # Explanation of how syncing works
+    //
+    // When choosing an index, we select: highest pending index + 1 (or highest finalized index + 1 if no pending).
+    // If the chosen index is more than WINDOW_LEN from the highest finalized index, we throw an error. By having this
+    // hard limit we give a guarantee to a recipient that he doesn't need to look further than WINDOW_LEN ahead of the
+    // highest finalized index.
+    //
+    // This function synchronizes the finalized and pending indexes by iteratively querying the node for a window of
+    // indexes at a time, storing all those indexes as pending, and then checking the status of each pending index to
+    // update its finalization status accordingly. If we stumble upon a window with no indexes, we stop the loop.
+    //
+    // Stopping at that point is safe because of the limit described above - there can never be an index that is more
+    // than WINDOW_LEN from the highest finalized index.
+    //
+    // # Note on performance
+    // Each window advance requires two queries (logs + tx status). For example, syncing indexes 0–500 with a window of
+    // 100 takes at least 10 round trips (5 windows × 2 queries).
+    const finalizedIndex = await taggingStore.getLastFinalizedIndex(secret, jobId);
+    let start = finalizedIndex === undefined ? 0 : finalizedIndex + 1;
+    let end = start + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN;
+    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, app, 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) {
+            break;
+        }
+        const { txHashesToFinalize, txHashesToDrop } = await getStatusChangeOfPending(pendingTxHashes, aztecNode);
+        await taggingStore.dropPendingIndexes(txHashesToDrop, jobId);
+        await taggingStore.finalizePendingIndexes(txHashesToFinalize, jobId);
+        // We check if the finalized index has been updated.
+        newFinalizedIndex = await taggingStore.getLastFinalizedIndex(secret, jobId);
+        if (previousFinalizedIndex !== newFinalizedIndex) {
+            // A new finalized index was found, so we'll run the loop again. For example:
+            // - Previous finalized index: 10
+            // - New finalized index: 13
+            // - Window length: 10
+            //
+            // In the last iteration, we processed indexes 11-20. To avoid reprocessing the same logs,
+            // we'll only look at the new indexes 21-23:
+            //
+            //    Previous window: [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
+            //    New window:                                             [21, 22, 23]
+            const previousEnd = end;
+            // Add 1 because `end` is exclusive and the known finalized index is not included in the window.
+            end = newFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
+            start = previousEnd;
+            previousFinalizedIndex = newFinalizedIndex;
+        } else {
+            break;
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import { TxHash } from '@aztec/stdlib/tx';
+/**
+ * Based on receipts obtained from `aztecNode` returns which pending transactions changed their status to finalized or
+ * dropped.
+ */
+export declare function getStatusChangeOfPending(pending: TxHash[], aztecNode: AztecNode): Promise<{
+    txHashesToFinalize: TxHash[];
+    txHashesToDrop: TxHash[];
+}>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0X3N0YXR1c19jaGFuZ2Vfb2ZfcGVuZGluZy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvZ2V0X3N0YXR1c19jaGFuZ2Vfb2ZfcGVuZGluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEVBQUUsTUFBTSxFQUFZLE1BQU0sa0JBQWtCLENBQUM7QUFFcEQ7OztHQUdHO0FBQ0gsd0JBQXNCLHdCQUF3QixDQUM1QyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQ2pCLFNBQVMsRUFBRSxTQUFTLEdBQ25CLE9BQU8sQ0FBQztJQUFFLGtCQUFrQixFQUFFLE1BQU0sRUFBRSxDQUFDO0lBQUMsY0FBYyxFQUFFLE1BQU0sRUFBRSxDQUFBO0NBQUUsQ0FBQyxDQXlCckUifQ==

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

@@ -0,0 +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;IAAE,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAAC,cAAc,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAyBrE"}

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

@@ -0,0 +1,29 @@
+import { TxStatus } from '@aztec/stdlib/tx';
+/**
+ * Based on receipts obtained from `aztecNode` returns which pending transactions changed their status to finalized or
+ * dropped.
+ */ export async function getStatusChangeOfPending(pending, aztecNode) {
+    // Get receipts for all pending tx hashes.
+    const receipts = await Promise.all(pending.map((pendingTxHash)=>aztecNode.getTxReceipt(pendingTxHash)));
+    const txHashesToFinalize = [];
+    const txHashesToDrop = [];
+    for(let i = 0; i < receipts.length; i++){
+        const receipt = receipts[i];
+        const txHash = pending[i];
+        if (receipt.status === TxStatus.FINALIZED && receipt.hasExecutionSucceeded()) {
+            // Tx has been included in a block and the corresponding block is finalized --> we mark the indexes as
+            // finalized.
+            txHashesToFinalize.push(txHash);
+        } else if (receipt.isDropped() || receipt.hasExecutionReverted()) {
+            // Tx was dropped or reverted --> we drop the corresponding pending indexes.
+            // TODO(#17615): Don't drop pending indexes corresponding to non-revertible phases.
+            txHashesToDrop.push(txHash);
+        } else {
+        // Tx is still pending, not yet finalized, or was mined successfully but not yet finalized --> we don't do anything.
+        }
+    }
+    return {
+        txHashesToFinalize,
+        txHashesToDrop
+    };
+}

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

@@ -0,0 +1,21 @@
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { BlockHash } from '@aztec/stdlib/block';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import type { DirectionalAppTaggingSecret } 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 secret - The directional app tagging secret that's unique for (sender, recipient, contract) tuple.
+ * @param app - The address of the contract that the logs are tagged for. Used for siloing tags to match
+ * kernel circuit behavior.
+ * @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 jobId - Job identifier, used to keep writes in-memory until they can be persisted in a data integrity
+ * preserving way.
+ */
+export declare function loadAndStoreNewTaggingIndexes(secret: DirectionalAppTaggingSecret, app: AztecAddress, start: number, end: number, aztecNode: AztecNode, taggingStore: SenderTaggingStore, anchorBlockHash: BlockHash, jobId: string): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvbG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNoRSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNyRCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEtBQUssRUFBRSwyQkFBMkIsRUFBVSxNQUFNLG9CQUFvQixDQUFDO0FBSTlFLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFHakc7Ozs7Ozs7Ozs7Ozs7R0FhRztBQUNILHdCQUFzQiw2QkFBNkIsQ0FDakQsTUFBTSxFQUFFLDJCQUEyQixFQUNuQyxHQUFHLEVBQUUsWUFBWSxFQUNqQixLQUFLLEVBQUUsTUFBTSxFQUNiLEdBQUcsRUFBRSxNQUFNLEVBQ1gsU0FBUyxFQUFFLFNBQVMsRUFDcEIsWUFBWSxFQUFFLGtCQUFrQixFQUNoQyxlQUFlLEVBQUUsU0FBUyxFQUMxQixLQUFLLEVBQUUsTUFBTSxpQkFrQmQifQ==

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

@@ -0,0 +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,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,2BAA2B,EAAU,MAAM,oBAAoB,CAAC;AAI9E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wDAAwD,CAAC;AAGjG;;;;;;;;;;;;;GAaG;AACH,wBAAsB,6BAA6B,CACjD,MAAM,EAAE,2BAA2B,EACnC,GAAG,EAAE,YAAY,EACjB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,kBAAkB,EAChC,eAAe,EAAE,SAAS,EAC1B,KAAK,EAAE,MAAM,iBAkBd"}

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

@@ -0,0 +1,60 @@
+import { SiloedTag, Tag } from '@aztec/stdlib/logs';
+import { TxHash } from '@aztec/stdlib/tx';
+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 secret - The directional app tagging secret that's unique for (sender, recipient, contract) tuple.
+ * @param app - The address of the contract that the logs are tagged for. Used for siloing tags to match
+ * kernel circuit behavior.
+ * @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 jobId - Job identifier, used to keep writes in-memory until they can be persisted in a data integrity
+ * preserving way.
+ */ export async function loadAndStoreNewTaggingIndexes(secret, app, start, end, aztecNode, taggingStore, anchorBlockHash, jobId) {
+    // We compute the tags for the current window of indexes
+    const preTagsForWindow = Array(end - start).fill(0).map((_, i)=>({
+            secret,
+            index: start + i
+        }));
+    const siloedTagsForWindow = await Promise.all(preTagsForWindow.map(async (preTag)=>SiloedTag.compute(await Tag.compute(preTag), app)));
+    const txsForTags = await getTxsContainingTags(siloedTagsForWindow, aztecNode, anchorBlockHash);
+    const highestIndexMap = getTxHighestIndexMap(txsForTags, preTagsForWindow);
+    // 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 txHash = TxHash.fromString(txHashStr);
+        await taggingStore.storePendingIndexes([
+            {
+                secret,
+                index: highestIndex
+            }
+        ], 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, 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.
+    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, preTagsForWindow) {
+    if (txHashesForTags.length !== preTagsForWindow.length) {
+        throw new Error(`Number of tx hashes arrays does not match number of pre-tags. ${txHashesForTags.length} !== ${preTagsForWindow.length}`);
+    }
+    const highestIndexMap = new Map();
+    for(let i = 0; i < txHashesForTags.length; i++){
+        const taggingIndex = preTagsForWindow[i].index;
+        const txHashesForTag = txHashesForTags[i];
+        for (const txHash of txHashesForTag){
+            const key = txHash.toString();
+            highestIndexMap.set(key, Math.max(highestIndexMap.get(key) ?? 0, taggingIndex));
+        }
+    }
+    return highestIndexMap;
+}

package/package.json

@@ -1,7 +1,16 @@
 {
   "name": "@aztec/pxe",
-  "version": "0.0.1-commit.fce3e4f",
+  "version": "0.0.1-commit.ff7989d6c",
   "type": "module",
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/entrypoints/server/index.ts",
+      "./src/entrypoints/client/lazy/index.ts",
+      "./src/config/index.ts"
+    ],
+    "name": "PXE",
+    "tsconfig": "./tsconfig.json"
+  },
   "exports": {
     "./server": "./dest/entrypoints/server/index.js",
     "./client/lazy": "./dest/entrypoints/client/lazy/index.js",
@@ -11,8 +20,8 @@
   },
   "bin": "./dest/bin/index.js",
   "scripts": {
-    "build": "yarn clean && yarn generate && tsgo -b",
-    "build:dev": "tsgo -b --watch",
+    "build": "yarn clean && yarn generate && ../scripts/tsc.sh",
+    "build:dev": "../scripts/tsc.sh --watch",
     "clean": "rm -rf ./dest .tsbuildinfo ./src/config/package_info.ts",
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}",
     "generate": "node ./scripts/generate_package_info.js",
@@ -61,19 +70,19 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb-prover": "0.0.1-commit.fce3e4f",
-    "@aztec/bb.js": "0.0.1-commit.fce3e4f",
-    "@aztec/builder": "0.0.1-commit.fce3e4f",
-    "@aztec/constants": "0.0.1-commit.fce3e4f",
-    "@aztec/ethereum": "0.0.1-commit.fce3e4f",
-    "@aztec/foundation": "0.0.1-commit.fce3e4f",
-    "@aztec/key-store": "0.0.1-commit.fce3e4f",
-    "@aztec/kv-store": "0.0.1-commit.fce3e4f",
-    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.fce3e4f",
-    "@aztec/noir-types": "0.0.1-commit.fce3e4f",
-    "@aztec/protocol-contracts": "0.0.1-commit.fce3e4f",
-    "@aztec/simulator": "0.0.1-commit.fce3e4f",
-    "@aztec/stdlib": "0.0.1-commit.fce3e4f",
+    "@aztec/bb-prover": "0.0.1-commit.ff7989d6c",
+    "@aztec/bb.js": "0.0.1-commit.ff7989d6c",
+    "@aztec/builder": "0.0.1-commit.ff7989d6c",
+    "@aztec/constants": "0.0.1-commit.ff7989d6c",
+    "@aztec/ethereum": "0.0.1-commit.ff7989d6c",
+    "@aztec/foundation": "0.0.1-commit.ff7989d6c",
+    "@aztec/key-store": "0.0.1-commit.ff7989d6c",
+    "@aztec/kv-store": "0.0.1-commit.ff7989d6c",
+    "@aztec/noir-protocol-circuits-types": "0.0.1-commit.ff7989d6c",
+    "@aztec/noir-types": "0.0.1-commit.ff7989d6c",
+    "@aztec/protocol-contracts": "0.0.1-commit.ff7989d6c",
+    "@aztec/simulator": "0.0.1-commit.ff7989d6c",
+    "@aztec/stdlib": "0.0.1-commit.ff7989d6c",
     "koa": "^2.16.1",
     "koa-router": "^13.1.1",
     "lodash.omit": "^4.5.0",
@@ -82,14 +91,14 @@
     "viem": "npm:@aztec/viem@2.38.2"
   },
   "devDependencies": {
-    "@aztec/merkle-tree": "0.0.1-commit.fce3e4f",
-    "@aztec/noir-test-contracts.js": "0.0.1-commit.fce3e4f",
+    "@aztec/merkle-tree": "0.0.1-commit.ff7989d6c",
+    "@aztec/noir-test-contracts.js": "0.0.1-commit.ff7989d6c",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/lodash.omit": "^4.5.7",
     "@types/lodash.times": "^4.3.9",
     "@types/node": "^22.15.17",
-    "@typescript/native-preview": "7.0.0-dev.20251126.1",
+    "@typescript/native-preview": "7.0.0-dev.20260113.1",
     "jest": "^30.0.0",
     "jest-mock-extended": "^4.0.0",
     "lodash.times": "^4.3.2",

package/src/access_scopes.ts

@@ -0,0 +1,9 @@
+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[];