@aztec/pxe 0.0.1-commit.e3c1de76 → 0.0.1-commit.e57c76e

package/dest/tagging/get_all_logs_by_tags.js

@@ -1,46 +1,59 @@
-import { MAX_LOGS_PER_TAG } from '@aztec/stdlib/interfaces/api-limit';
+import { MAX_RPC_LEN } from '@aztec/stdlib/interfaces/api-limit';
+import { queryAllPrivateLogsByTags, queryAllPublicLogsByTags } from '@aztec/stdlib/logs';
 /**
- * Generic pagination helper that fetches all pages of results.
- * @param numTags - The number of tags being queried (determines result array size).
- * @param fetchPage - Function that fetches a single page of results given a page number.
- * @returns An array of arrays, one per tag, containing all results across all pages.
- */ async function getAllPages(numTags, fetchPage) {
-    const allResultsPerTag = Array.from({
-        length: numTags
-    }, ()=>[]);
-    let page = 0;
-    let hasMore = true;
-    while(hasMore){
-        const resultsPage = await fetchPage(page);
-        hasMore = false;
-        for(let i = 0; i < resultsPage.length; i++){
-            allResultsPerTag[i].push(...resultsPage[i]);
-            if (resultsPage[i].length === MAX_LOGS_PER_TAG) {
-                hasMore = true;
-            }
-        }
-        page++;
+ * Splits tags into chunks of MAX_RPC_LEN, paginates each chunk via the stdlib per-tag cursor helper,
+ * then stitches the results back into a single array preserving the original tag order.
+ */ async function getAllPagesInBatches(tags, fetchAllPagesForBatch) {
+    if (tags.length === 0) {
+        return [];
     }
-    return allResultsPerTag;
+    if (tags.length <= MAX_RPC_LEN) {
+        return fetchAllPagesForBatch(tags);
+    }
+    const batches = [];
+    for(let i = 0; i < tags.length; i += MAX_RPC_LEN){
+        batches.push(tags.slice(i, i + MAX_RPC_LEN));
+    }
+    const batchResults = await Promise.all(batches.map(fetchAllPagesForBatch));
+    return batchResults.flat();
 }
 /**
- * Fetches all private logs for the given tags, automatically paginating through all pages.
+ * Fetches all private logs for the given tags, automatically paginating per-tag via `afterLog` cursors.
+ *
  * @param aztecNode - The Aztec node to query.
  * @param tags - The siloed tags to search for.
- * @param anchorBlockHash - reference block for the Aztec node query, throws if block is not found there (typically
- * because of reorgs).
+ * @param anchorBlockHash - Reference block for the Aztec node query, throws if block is not found there (typically
+ *   because of reorgs).
+ * @param options - Optional `fromBlock`/`toBlock` range and `includeEffects` opt-in.
  * @returns An array of log arrays, one per tag, containing all logs across all pages.
- */ export function getAllPrivateLogsByTags(aztecNode, tags, anchorBlockHash) {
-    return getAllPages(tags.length, (page)=>aztecNode.getPrivateLogsByTags(tags, page, anchorBlockHash));
+ */ export function getAllPrivateLogsByTags(aztecNode, tags, anchorBlockHash, options = {}) {
+    return getAllPagesInBatches(tags, (batch)=>queryAllPrivateLogsByTags(aztecNode, {
+            tags: batch,
+            referenceBlock: anchorBlockHash,
+            fromBlock: options.fromBlock,
+            toBlock: options.toBlock,
+            includeEffects: options.includeEffects ?? false,
+            limitPerTag: options.limitPerTag
+        }));
 }
 /**
- * Fetches all public logs for the given tags from a contract, automatically paginating through all pages.
+ * Fetches all public logs for the given tags from a contract, automatically paginating per-tag via `afterLog` cursors.
+ *
  * @param aztecNode - The Aztec node to query.
  * @param contractAddress - The contract address to search logs for.
  * @param tags - The tags to search for.
- * @param anchorBlockHash - reference block for the Aztec node query, throws if block is not found there (typically
- * because of reorgs).
+ * @param anchorBlockHash - Reference block for the Aztec node query, throws if block is not found there (typically
+ *   because of reorgs).
+ * @param options - Optional `fromBlock`/`toBlock` range and `includeEffects` opt-in.
  * @returns An array of log arrays, one per tag, containing all logs across all pages.
- */ export function getAllPublicLogsByTagsFromContract(aztecNode, contractAddress, tags, anchorBlockHash) {
-    return getAllPages(tags.length, (page)=>aztecNode.getPublicLogsByTagsFromContract(contractAddress, tags, page, anchorBlockHash));
+ */ export function getAllPublicLogsByTagsFromContract(aztecNode, contractAddress, tags, anchorBlockHash, options = {}) {
+    return getAllPagesInBatches(tags, (batch)=>queryAllPublicLogsByTags(aztecNode, {
+            contractAddress,
+            tags: batch,
+            referenceBlock: anchorBlockHash,
+            fromBlock: options.fromBlock,
+            toBlock: options.toBlock,
+            includeEffects: options.includeEffects ?? false,
+            limitPerTag: options.limitPerTag
+        }));
 }

package/dest/tagging/index.d.ts

@@ -4,14 +4,15 @@
  * The objective of the sender sync algorithm is to determine which tags have already been used by a sender, thereby
  * deciding which tag should be used next.
  *
- * The objective of the recipient sync algorithm is to load and process the corresponding logs.
+ * The objective of the recipient sync algorithm is to fetch and sync the corresponding logs.
  *
  * @module tagging
  */
-export { loadPrivateLogsForSenderRecipientPair } from './recipient_sync/load_private_logs_for_sender_recipient_pair.js';
+export { syncTaggedPrivateLogs } from './recipient_sync/sync_tagged_private_logs.js';
 export { syncSenderTaggingIndexes } from './sender_sync/sync_sender_tagging_indexes.js';
+export { persistSenderTaggingIndexRangesForTx } from './persist_sender_tagging_index_ranges.js';
 export { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from './constants.js';
 export { getAllPrivateLogsByTags, getAllPublicLogsByTagsFromContract } from './get_all_logs_by_tags.js';
-export { DirectionalAppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';
-export { type PreTag } from '@aztec/stdlib/logs';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90YWdnaW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7R0FTRztBQUVILE9BQU8sRUFBRSxxQ0FBcUMsRUFBRSxNQUFNLGlFQUFpRSxDQUFDO0FBQ3hILE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBQ3hGLE9BQU8sRUFBRSxzQ0FBc0MsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3hFLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxrQ0FBa0MsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBR3hHLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxHQUFHLEVBQUUsU0FBUyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDakYsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFFLE1BQU0sb0JBQW9CLENBQUMifQ==
+export { AppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';
+export { type PreTag, type TaggingIndexRange } from '@aztec/stdlib/logs';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90YWdnaW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7R0FTRztBQUVILE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBQ3JGLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBQ3hGLE9BQU8sRUFBRSxvQ0FBb0MsRUFBRSxNQUFNLDBDQUEwQyxDQUFDO0FBQ2hHLE9BQU8sRUFBRSxzQ0FBc0MsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3hFLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxrQ0FBa0MsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBR3hHLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxHQUFHLEVBQUUsU0FBUyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDdEUsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFFLEtBQUssaUJBQWlCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQyJ9

package/dest/tagging/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tagging/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,qCAAqC,EAAE,MAAM,iEAAiE,CAAC;AACxH,OAAO,EAAE,wBAAwB,EAAE,MAAM,8CAA8C,CAAC;AACxF,OAAO,EAAE,sCAAsC,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,EAAE,uBAAuB,EAAE,kCAAkC,EAAE,MAAM,2BAA2B,CAAC;AAGxG,OAAO,EAAE,2BAA2B,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACjF,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tagging/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,EAAE,wBAAwB,EAAE,MAAM,8CAA8C,CAAC;AACxF,OAAO,EAAE,oCAAoC,EAAE,MAAM,0CAA0C,CAAC;AAChG,OAAO,EAAE,sCAAsC,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,EAAE,uBAAuB,EAAE,kCAAkC,EAAE,MAAM,2BAA2B,CAAC;AAGxG,OAAO,EAAE,gBAAgB,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACtE,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC"}

package/dest/tagging/index.js

@@ -4,12 +4,13 @@
  * The objective of the sender sync algorithm is to determine which tags have already been used by a sender, thereby
  * deciding which tag should be used next.
  *
- * The objective of the recipient sync algorithm is to load and process the corresponding logs.
+ * The objective of the recipient sync algorithm is to fetch and sync the corresponding logs.
  *
  * @module tagging
- */ export { loadPrivateLogsForSenderRecipientPair } from './recipient_sync/load_private_logs_for_sender_recipient_pair.js';
+ */ export { syncTaggedPrivateLogs } from './recipient_sync/sync_tagged_private_logs.js';
 export { syncSenderTaggingIndexes } from './sender_sync/sync_sender_tagging_indexes.js';
+export { persistSenderTaggingIndexRangesForTx } from './persist_sender_tagging_index_ranges.js';
 export { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from './constants.js';
 export { getAllPrivateLogsByTags, getAllPublicLogsByTagsFromContract } from './get_all_logs_by_tags.js';
 // Re-export tagging-related types from stdlib
-export { DirectionalAppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';
+export { AppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';

package/dest/tagging/persist_sender_tagging_index_ranges.d.ts

@@ -0,0 +1,29 @@
+import type { Logger } from '@aztec/foundation/log';
+import type { PrivateKernelTailCircuitPublicInputs } from '@aztec/stdlib/kernel';
+import type { TaggingIndexRange } from '@aztec/stdlib/logs';
+import type { TxHash } from '@aztec/stdlib/tx';
+import type { SenderTaggingStore } from '../storage/tagging_store/sender_tagging_store.js';
+/**
+ * Persists the tagging index ranges that a tx used as a sender, after reconciling them against the kernel's surviving
+ * private logs.
+ *
+ * The tagging index cache reserves an index for every log emission attempted during private execution, but the kernel
+ * may then squash some of those logs (e.g. when a note is created and nullified within the same tx). This function
+ * shrinks the recorded ranges to match the actual on-chain footprint before writing them, so that what we persist is
+ * consistent with what the network will see.
+ *
+ * @remarks Storing the recorded ranges in the DB may not be seen as necessary because we sync from chain before sending
+ * new logs, but the sync can only see logs already included in blocks. If we sent another transaction before this one
+ * was included from the same PXE, and that transaction contained a log with a tag derived from the same secret, we
+ * would reuse the tag and the transactions would be linked. Persisting in the DB prevents that linkage.
+ *
+ * @param store - The sender tagging store.
+ * @param recordedRanges - The tagging index ranges as recorded during private execution (pre-squash).
+ * @param publicInputs - The final kernel public inputs, used to determine which private logs survived squashing.
+ * @param getTxHash - Lazy accessor for the tx hash. Called only when there is something to persist, since computing
+ * the tx hash is expensive.
+ * @param jobId - Job context for staged writes to the store. See `JobCoordinator` for more details.
+ * @param log - Logger.
+ */
+export declare function persistSenderTaggingIndexRangesForTx(store: SenderTaggingStore, recordedRanges: TaggingIndexRange[], publicInputs: PrivateKernelTailCircuitPublicInputs, getTxHash: () => Promise<TxHash>, jobId: string, log: Logger): Promise<void>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVyc2lzdF9zZW5kZXJfdGFnZ2luZ19pbmRleF9yYW5nZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90YWdnaW5nL3BlcnNpc3Rfc2VuZGVyX3RhZ2dpbmdfaW5kZXhfcmFuZ2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ3BELE9BQU8sS0FBSyxFQUFFLG9DQUFvQyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDakYsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUM1RCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUUvQyxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGtEQUFrRCxDQUFDO0FBRzNGOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FxQkc7QUFDSCx3QkFBc0Isb0NBQW9DLENBQ3hELEtBQUssRUFBRSxrQkFBa0IsRUFDekIsY0FBYyxFQUFFLGlCQUFpQixFQUFFLEVBQ25DLFlBQVksRUFBRSxvQ0FBb0MsRUFDbEQsU0FBUyxFQUFFLE1BQU0sT0FBTyxDQUFDLE1BQU0sQ0FBQyxFQUNoQyxLQUFLLEVBQUUsTUFBTSxFQUNiLEdBQUcsRUFBRSxNQUFNLEdBQ1YsT0FBTyxDQUFDLElBQUksQ0FBQyxDQW1CZiJ9

package/dest/tagging/persist_sender_tagging_index_ranges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persist_sender_tagging_index_ranges.d.ts","sourceRoot":"","sources":["../../src/tagging/persist_sender_tagging_index_ranges.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,oCAAoC,EAAE,MAAM,sBAAsB,CAAC;AACjF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kDAAkD,CAAC;AAG3F;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,oCAAoC,CACxD,KAAK,EAAE,kBAAkB,EACzB,cAAc,EAAE,iBAAiB,EAAE,EACnC,YAAY,EAAE,oCAAoC,EAClD,SAAS,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,EAChC,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,IAAI,CAAC,CAmBf"}

package/dest/tagging/persist_sender_tagging_index_ranges.js

@@ -0,0 +1,42 @@
+import { reconcileTaggingIndexRangesAgainstSurvivingTags } from './reconcile_tagging_index_ranges.js';
+/**
+ * Persists the tagging index ranges that a tx used as a sender, after reconciling them against the kernel's surviving
+ * private logs.
+ *
+ * The tagging index cache reserves an index for every log emission attempted during private execution, but the kernel
+ * may then squash some of those logs (e.g. when a note is created and nullified within the same tx). This function
+ * shrinks the recorded ranges to match the actual on-chain footprint before writing them, so that what we persist is
+ * consistent with what the network will see.
+ *
+ * @remarks Storing the recorded ranges in the DB may not be seen as necessary because we sync from chain before sending
+ * new logs, but the sync can only see logs already included in blocks. If we sent another transaction before this one
+ * was included from the same PXE, and that transaction contained a log with a tag derived from the same secret, we
+ * would reuse the tag and the transactions would be linked. Persisting in the DB prevents that linkage.
+ *
+ * @param store - The sender tagging store.
+ * @param recordedRanges - The tagging index ranges as recorded during private execution (pre-squash).
+ * @param publicInputs - The final kernel public inputs, used to determine which private logs survived squashing.
+ * @param getTxHash - Lazy accessor for the tx hash. Called only when there is something to persist, since computing
+ * the tx hash is expensive.
+ * @param jobId - Job context for staged writes to the store. See `JobCoordinator` for more details.
+ * @param log - Logger.
+ */ export async function persistSenderTaggingIndexRangesForTx(store, recordedRanges, publicInputs, getTxHash, jobId, log) {
+    if (recordedRanges.length === 0) {
+        log.debug(`No tagging index ranges used in the tx`);
+        return;
+    }
+    const survivingTags = new Set(publicInputs.getNonEmptyPrivateLogs().map((privateLog)=>privateLog.fields[0].toString()));
+    const reconciledRanges = await reconcileTaggingIndexRangesAgainstSurvivingTags(recordedRanges, survivingTags);
+    if (reconciledRanges.length === 0) {
+        log.debug(`All tagging index ranges used in the tx were squashed by the kernel`, {
+            recordedRanges
+        });
+        return;
+    }
+    const txHash = await getTxHash();
+    await store.storePendingIndexes(reconciledRanges, txHash, jobId);
+    log.debug(`Stored used tagging index ranges as sender for the tx`, {
+        recordedRanges,
+        reconciledRanges
+    });
+}

package/dest/tagging/recipient_sync/sync_tagged_private_logs.d.ts

@@ -0,0 +1,56 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { AppTaggingSecret, LogResult } from '@aztec/stdlib/logs';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+import type { RecipientTaggingStore } from '../../storage/tagging_store/recipient_tagging_store.js';
+/**
+ * Fetches and syncs tagged private logs for multiple sender-recipient pairs, batching tag queries across all secrets
+ * into shared RPC calls.
+ *
+ * # Explanation of how the algorithm works
+ *
+ * For each secret we sync 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`.
+ *
+ * ## Batching across secrets
+ *
+ * Instead of running one RPC call per secret, we merge tags from all pending secrets into a single flat array,
+ * make one batched `getAllPrivateLogsByTags` call (which internally chunks at MAX_RPC_LEN), then split results
+ * back per secret using tracked offsets. Only secrets whose window advanced are kept for the next iteration.
+ */
+export declare function syncTaggedPrivateLogs(secrets: AppTaggingSecret[], aztecNode: AztecNode, taggingStore: RecipientTaggingStore, anchorBlockHeader: BlockHeader, finalizedBlockNumber: BlockNumber, jobId: string): Promise<LogResult[]>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luY190YWdnZWRfcHJpdmF0ZV9sb2dzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGFnZ2luZy9yZWNpcGllbnRfc3luYy9zeW5jX3RhZ2dlZF9wcml2YXRlX2xvZ3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRzlELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ2pFLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLFNBQVMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXRFLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRXBELE9BQU8sS0FBSyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFLcEc7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQWdERztBQUNILHdCQUFzQixxQkFBcUIsQ0FDekMsT0FBTyxFQUFFLGdCQUFnQixFQUFFLEVBQzNCLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLFlBQVksRUFBRSxxQkFBcUIsRUFDbkMsaUJBQWlCLEVBQUUsV0FBVyxFQUM5QixvQkFBb0IsRUFBRSxXQUFXLEVBQ2pDLEtBQUssRUFBRSxNQUFNLEdBQ1osT0FBTyxDQUFDLFNBQVMsRUFBRSxDQUFDLENBNEN0QiJ9

package/dest/tagging/recipient_sync/sync_tagged_private_logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync_tagged_private_logs.d.ts","sourceRoot":"","sources":["../../../src/tagging/recipient_sync/sync_tagged_private_logs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAG9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wDAAwD,CAAC;AAKpG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,gBAAgB,EAAE,EAC3B,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,qBAAqB,EACnC,iBAAiB,EAAE,WAAW,EAC9B,oBAAoB,EAAE,WAAW,EACjC,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,SAAS,EAAE,CAAC,CA4CtB"}

package/dest/tagging/recipient_sync/sync_tagged_private_logs.js

@@ -0,0 +1,163 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { isDefined } from '@aztec/foundation/types';
+import { SiloedTag } from '@aztec/stdlib/logs';
+import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../constants.js';
+import { getAllPrivateLogsByTags } from '../get_all_logs_by_tags.js';
+import { findHighestIndexes } from './utils/find_highest_indexes.js';
+/**
+ * Fetches and syncs tagged private logs for multiple sender-recipient pairs, batching tag queries across all secrets
+ * into shared RPC calls.
+ *
+ * # Explanation of how the algorithm works
+ *
+ * For each secret we sync 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`.
+ *
+ * ## Batching across secrets
+ *
+ * Instead of running one RPC call per secret, we merge tags from all pending secrets into a single flat array,
+ * make one batched `getAllPrivateLogsByTags` call (which internally chunks at MAX_RPC_LEN), then split results
+ * back per secret using tracked offsets. Only secrets whose window advanced are kept for the next iteration.
+ */ export async function syncTaggedPrivateLogs(secrets, aztecNode, taggingStore, anchorBlockHeader, finalizedBlockNumber, jobId) {
+    if (secrets.length === 0) {
+        return [];
+    }
+    const anchorBlockNumber = anchorBlockHeader.getBlockNumber();
+    const anchorBlockHash = await anchorBlockHeader.hash();
+    const currentTimestamp = anchorBlockHeader.globalVariables.timestamp;
+    // Read stored indexes from the db and compute the initial [start, end) range for each secret
+    let pending = await getIndexRangesForSecrets(secrets, taggingStore, jobId);
+    const allLogs = [];
+    while(pending.length > 0){
+        // Compute tags for all pending secrets and fetch logs in batched RPC calls
+        const logsPerSecret = await fetchLogsForSecrets(pending, aztecNode, anchorBlockNumber, anchorBlockHash);
+        const nextRound = await Promise.all(pending.map(async (pendingSecret, i)=>{
+            const logsFoundWithSecret = logsPerSecret[i];
+            if (logsFoundWithSecret.length === 0) {
+                // No logs found, no need to update indexes or advance window.
+                return undefined;
+            }
+            allLogs.push(...logsFoundWithSecret.map(({ log })=>log));
+            // Persist new indexes. If the finalized index moved forward, the window advances
+            // and we need another round for this secret.
+            return await updateIndexesAndAdvanceWindow(pendingSecret, logsFoundWithSecret, taggingStore, currentTimestamp, finalizedBlockNumber, jobId);
+        }));
+        pending = nextRound.filter(isDefined);
+    }
+    return allLogs;
+}
+/** Reads stored indexes for each secret and computes the initial index range to query. */ function getIndexRangesForSecrets(secrets, taggingStore, jobId) {
+    return Promise.all(secrets.map(async (secret)=>{
+        const [currentHighestAgedIndex, currentHighestFinalizedIndex] = await Promise.all([
+            taggingStore.getHighestAgedIndex(secret, jobId),
+            taggingStore.getHighestFinalizedIndex(secret, jobId)
+        ]);
+        const start = currentHighestAgedIndex === undefined ? 0 : currentHighestAgedIndex + 1;
+        const end = (currentHighestFinalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
+        return {
+            secret,
+            start,
+            end
+        };
+    }));
+}
+/**
+ * Computes siloed tags for all pending secrets' index ranges, fetches logs in one batched RPC call,
+ * and returns the results grouped back per secret.
+ */ async function fetchLogsForSecrets(pending, aztecNode, anchorBlockNumber, anchorBlockHash) {
+    // Determine the index range for each secret
+    const indexesPerSecret = pending.map(({ start, end })=>Array.from({
+            length: end - start
+        }, (_, i)=>start + i));
+    // Compute siloed tags for all indexes
+    const tagsPerSecret = await Promise.all(pending.map(({ secret }, i)=>Promise.all(indexesPerSecret[i].map((index)=>SiloedTag.compute({
+                extendedSecret: secret,
+                index
+            })))));
+    const allTags = tagsPerSecret.flat();
+    // getAllPrivateLogsByTags handles MAX_RPC_LEN chunking internally. Recipient sync builds `PendingTaggedLog` from
+    // each log's note hashes and first nullifier, so we opt into effects. The `toBlock` cap (anchor block + 1,
+    // exclusive) tells the node to skip any logs in blocks past the anchor — the same guard previously enforced
+    // by an in-memory filter on the response.
+    const allResults = await getAllPrivateLogsByTags(aztecNode, allTags, anchorBlockHash, {
+        includeEffects: true,
+        toBlock: BlockNumber(anchorBlockNumber + 1)
+    });
+    // Split flat results back per secret using the known lengths
+    const logsPerSecret = [];
+    let offset = 0;
+    for (const indexes of indexesPerSecret){
+        const logsForSecret = [];
+        for(let i = 0; i < indexes.length; i++){
+            for (const log of allResults[offset + i]){
+                logsForSecret.push({
+                    log,
+                    taggingIndex: indexes[i]
+                });
+            }
+        }
+        logsPerSecret.push(logsForSecret);
+        offset += indexes.length;
+    }
+    return logsPerSecret;
+}
+/**
+ * Processes a single secret's fetched logs: updates stored indexes and returns a new PendingSecret
+ * if the window needs to advance, or undefined if this secret is done.
+ */ async function updateIndexesAndAdvanceWindow(pending, logsWithIndexes, taggingStore, currentTimestamp, finalizedBlockNumber, jobId) {
+    const { highestAgedIndex, highestFinalizedIndex } = findHighestIndexes(logsWithIndexes, currentTimestamp, finalizedBlockNumber);
+    // Store updates in data provider and update local variables
+    if (highestAgedIndex !== undefined) {
+        await taggingStore.updateHighestAgedIndex(pending.secret, highestAgedIndex, jobId);
+    }
+    if (highestFinalizedIndex === undefined) {
+        // We have not found a new highest finalized index, so there is no need to move the window forward.
+        return undefined;
+    }
+    if (highestAgedIndex !== undefined && highestAgedIndex > highestFinalizedIndex) {
+        // This is just a sanity check as this should never happen.
+        throw new Error(`Highest aged index (${highestAgedIndex}) must not exceed highest finalized index (${highestFinalizedIndex})`);
+    }
+    await taggingStore.updateHighestFinalizedIndex(pending.secret, highestFinalizedIndex, jobId);
+    // For the next iteration we want to look only at indexes for which we have not yet fetched logs while
+    // ensuring that we do not look further than WINDOW_LEN ahead of the highest finalized index.
+    return {
+        secret: pending.secret,
+        start: pending.end,
+        end: highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1
+    };
+}

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

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

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

@@ -1 +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"}
+{"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,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,sBAAsB,EAAE,KAAK,CAAC;IAAE,GAAG,EAAE,SAAS,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC,EACvE,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

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

package/dest/tagging/reconcile_tagging_index_ranges.d.ts

@@ -0,0 +1,36 @@
+import { type TaggingIndexRange } 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 declare function reconcileTaggingIndexRangesAgainstSurvivingTags(ranges: TaggingIndexRange[], survivingTags: Set<string>): Promise<TaggingIndexRange[]>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVjb25jaWxlX3RhZ2dpbmdfaW5kZXhfcmFuZ2VzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGFnZ2luZy9yZWNvbmNpbGVfdGFnZ2luZ19pbmRleF9yYW5nZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFvQyxLQUFLLGlCQUFpQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFOUY7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBZ0NHO0FBQ0gsd0JBQXNCLCtDQUErQyxDQUNuRSxNQUFNLEVBQUUsaUJBQWlCLEVBQUUsRUFDM0IsYUFBYSxFQUFFLEdBQUcsQ0FBQyxNQUFNLENBQUMsR0FDekIsT0FBTyxDQUFDLGlCQUFpQixFQUFFLENBQUMsQ0ErQjlCIn0=

package/dest/tagging/reconcile_tagging_index_ranges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile_tagging_index_ranges.d.ts","sourceRoot":"","sources":["../../src/tagging/reconcile_tagging_index_ranges.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoC,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE9F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAsB,+CAA+C,CACnE,MAAM,EAAE,iBAAiB,EAAE,EAC3B,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,GACzB,OAAO,CAAC,iBAAiB,EAAE,CAAC,CA+B9B"}

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