@aztec/pxe 0.0.1-commit.d431d1c → 0.0.1-commit.d58ff9d0

package/dest/tagging/recipient_sync/sync_tagged_private_logs.js

@@ -0,0 +1,238 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { isDefined } from '@aztec/foundation/types';
+import { AppTaggingSecretKind, SiloedTag } from '@aztec/stdlib/logs';
+import { INITIAL_CONSTRAINED_PROBE_LEN, 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. Handles both constrained and unconstrained secrets, which differ in their scan strategy
+ * but share the same batching infrastructure.
+ *
+ * # Unconstrained secrets
+ *
+ * For each unconstrained 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`.
+ *
+ * # Constrained secrets
+ *
+ * Constrained delivery enforces a contiguous index sequence (each send proves the predecessor's nullifier,
+ * chaining back to the handshake), so there is only one sender and indexes are sequential. This means:
+ * - The lower bound is `highestFinalizedIndex + 1`. The `highestAgedIndex` mechanism is unnecessary because
+ *   the nullifier chain prevents out-of-order index usage: no device can fill in a lower index after a higher
+ *   one is already on-chain.
+ * - Because the sequence is gapless, the scan stops at the first missing index: that gap proves the sequence has
+ *   ended and no further logs exist. We exploit this with a doubling first-miss probe (see
+ *   `INITIAL_CONSTRAINED_PROBE_LEN` in ../constants.ts), so a
+ *   steady-state sync with no new logs costs two tags instead of the whole window. The probe length is in-memory
+ *   state scoped to one sync call, so every sync restarts at the initial probe.
+ * - The upper bound is the same as unconstrained: `highestFinalizedIndex + WINDOW_LEN`. Advancing the probe is
+ *   decoupled from persisting the finalized index, so unfinalized logs at the top of the run are still fetched
+ *   while only the finalized prefix is persisted.
+ *
+ * # Batching across secrets
+ *
+ * Instead of running one RPC call per secret, we merge tags from all pending secrets (both constrained and
+ * unconstrained) 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 pendingSecret.kind === AppTaggingSecretKind.CONSTRAINED ? await processConstrainedResults(pendingSecret, logsFoundWithSecret, taggingStore, currentTimestamp, finalizedBlockNumber, jobId) : await processUnconstrainedResults(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 currentHighestFinalizedIndex = await taggingStore.getHighestFinalizedIndex(secret, jobId);
+        const boundEnd = (currentHighestFinalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
+        if (secret.kind === AppTaggingSecretKind.CONSTRAINED) {
+            // Constrained streams are gapless and resume at the finalized index, so probe a small initial window and stop
+            // at the first missing tag instead of always fetching the full window. The probe grows each round up to the
+            // window cap.
+            const start = currentHighestFinalizedIndex === undefined ? 0 : currentHighestFinalizedIndex + 1;
+            return {
+                kind: AppTaggingSecretKind.CONSTRAINED,
+                secret,
+                start,
+                end: Math.min(boundEnd, start + INITIAL_CONSTRAINED_PROBE_LEN),
+                boundEnd,
+                probeLen: INITIAL_CONSTRAINED_PROBE_LEN
+            };
+        }
+        // Unconstrained secrets can have gaps, so they scan the whole window starting past the highest aged index.
+        const highestAgedIndex = await taggingStore.getHighestAgedIndex(secret, jobId);
+        const start = highestAgedIndex === undefined ? 0 : highestAgedIndex + 1;
+        return {
+            kind: AppTaggingSecretKind.UNCONSTRAINED,
+            secret,
+            start,
+            end: boundEnd
+        };
+    }));
+}
+/**
+ * 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 fetched logs for a constrained secret: persists the finalized index and advances the probe. See the
+ * "# Constrained secrets" section above for why the scan stops at the first missing index. Only `highestFinalizedIndex`
+ * is tracked (no aged index).
+ */ async function processConstrainedResults(pending, logsWithIndexes, taggingStore, currentTimestamp, finalizedBlockNumber, jobId) {
+    // Find where the contiguous run of indexes ends; all logs in the batch fall within this prefix.
+    const indexesWithLogs = new Set(logsWithIndexes.map((l)=>l.taggingIndex));
+    let firstMissingIndex = pending.start;
+    while(firstMissingIndex < pending.end && indexesWithLogs.has(firstMissingIndex)){
+        firstMissingIndex++;
+    }
+    // Persist the highest finalized index found. The nullifier for a constrained-delivery log is emitted in the same
+    // transaction, guaranteeing the log cannot disappear once included, so we persist even when a gap stops the scan.
+    // This lets the next sync round skip already-finalized indexes.
+    const { highestFinalizedIndex } = findHighestIndexes(logsWithIndexes, currentTimestamp, finalizedBlockNumber);
+    if (highestFinalizedIndex !== undefined) {
+        await taggingStore.updateHighestFinalizedIndex(pending.secret, highestFinalizedIndex, jobId);
+    }
+    // Advancing the probe is decoupled from persisting the finalized index: keep scanning as long as the probe was
+    // entirely hits (no gap) and there is room before the protocol bound, even if none of those hits is finalized yet.
+    // Gating this on finalization would drop logs in unfinalized blocks, which sit at the top of the contiguous run.
+    // The bound re-anchors to any finalized index found this round.
+    const probeFullyConsumed = firstMissingIndex >= pending.end;
+    const boundEnd = highestFinalizedIndex !== undefined ? Math.max(pending.boundEnd, highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1) : pending.boundEnd;
+    // Double the probe each round, capped at the window (see INITIAL_CONSTRAINED_PROBE_LEN in ../constants.ts).
+    // The queried range is already bounded by boundEnd (a probe can never reach
+    // more than WINDOW_LEN past the finalized frontier); this cap just keeps the stored length from growing unbounded
+    // once the probe saturates the window.
+    const nextProbeLen = Math.min(pending.probeLen * 2, UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN);
+    if (probeFullyConsumed && pending.end < boundEnd) {
+        return {
+            kind: AppTaggingSecretKind.CONSTRAINED,
+            secret: pending.secret,
+            start: pending.end,
+            end: Math.min(boundEnd, pending.end + nextProbeLen),
+            boundEnd,
+            probeLen: nextProbeLen
+        };
+    }
+    return undefined;
+}
+/**
+ * Processes a single unconstrained 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 processUnconstrainedResults(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.
+    const end = highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
+    return {
+        kind: AppTaggingSecretKind.UNCONSTRAINED,
+        secret: pending.secret,
+        start: pending.end,
+        end
+    };
+}

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

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

@@ -1,20 +1,16 @@
-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 { 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, 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).
+ * @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: DirectionalAppTaggingSecret, app: AztecAddress, aztecNode: AztecNode, taggingStore: SenderTaggingStore, jobId: string): Promise<void>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luY19zZW5kZXJfdGFnZ2luZ19pbmRleGVzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGFnZ2luZy9zZW5kZXJfc3luYy9zeW5jX3NlbmRlcl90YWdnaW5nX2luZGV4ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDaEUsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDakUsT0FBTyxLQUFLLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUV0RSxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHFEQUFxRCxDQUFDO0FBSzlGOzs7Ozs7Ozs7Ozs7O0dBYUc7QUFDSCx3QkFBc0Isd0JBQXdCLENBQzVDLE1BQU0sRUFBRSwyQkFBMkIsRUFDbkMsR0FBRyxFQUFFLFlBQVksRUFDakIsU0FBUyxFQUFFLFNBQVMsRUFDcEIsWUFBWSxFQUFFLGtCQUFrQixFQUNoQyxLQUFLLEVBQUUsTUFBTSxHQUNaLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FtRWYifQ==
+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,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,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,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAmEf"}
+{"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,20 +1,16 @@
 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, 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).
+ * @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 async function syncSenderTaggingIndexes(secret, app, aztecNode, taggingStore, jobId) {
+ */ export async function syncSenderTaggingIndexes(secret, 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).
@@ -38,17 +34,39 @@ 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, app, start, end, aztecNode, taggingStore, 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 } = await getStatusChangeOfPending(pendingTxHashes, aztecNode);
+        // Receipts for pending tx hashes that the logs query just surfaced still need a sequential follow-up call.
+        // `mergePendingIndexes` 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 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(receipt.txEffect, jobId);
+            }
+        }
         // We check if the finalized index has been updated.
         newFinalizedIndex = await taggingStore.getLastFinalizedIndex(secret, jobId);
         if (previousFinalizedIndex !== newFinalizedIndex) {

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

@@ -1,11 +1,17 @@
 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<{
+/** Classification of a batch of pending tx hashes by the status change implied by their receipts. */
+export type StatusChange = {
     txHashesToFinalize: TxHash[];
     txHashesToDrop: TxHash[];
-}>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0X3N0YXR1c19jaGFuZ2Vfb2ZfcGVuZGluZy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvZ2V0X3N0YXR1c19jaGFuZ2Vfb2ZfcGVuZGluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEVBQUUsTUFBTSxFQUFZLE1BQU0sa0JBQWtCLENBQUM7QUFFcEQ7OztHQUdHO0FBQ0gsd0JBQXNCLHdCQUF3QixDQUM1QyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQ2pCLFNBQVMsRUFBRSxTQUFTLEdBQ25CLE9BQU8sQ0FBQztJQUFFLGtCQUFrQixFQUFFLE1BQU0sRUFBRSxDQUFDO0lBQUMsY0FBYyxFQUFFLE1BQU0sRUFBRSxDQUFBO0NBQUUsQ0FBQyxDQXFDckUifQ==
+    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<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;IAAE,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAAC,cAAc,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAqCrE"}
+{"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,32 +1,60 @@
 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 or
- * dropped.
+ * Based on receipts obtained from `aztecNode` returns which pending transactions changed their status to finalized,
+ * dropped, or execution-reverted (but mined).
  */ export async function getStatusChangeOfPending(pending, aztecNode) {
-    // Get receipts for all pending tx hashes and the finalized block number.
-    const [receipts, tips] = await Promise.all([
-        Promise.all(pending.map((pendingTxHash)=>aztecNode.getTxReceipt(pendingTxHash))),
-        aztecNode.getL2Tips()
-    ]);
+    // Get receipts for all pending tx hashes.
+    const receipts = await Promise.all(pending.map((pendingTxHash)=>aztecNode.getTxReceipt(pendingTxHash)));
     const txHashesToFinalize = [];
     const txHashesToDrop = [];
+    const txHashesWithExecutionReverted = [];
     for(let i = 0; i < receipts.length; i++){
         const receipt = receipts[i];
         const txHash = pending[i];
-        if (receipt.status === TxStatus.SUCCESS && receipt.blockNumber && receipt.blockNumber <= tips.finalized.block.number) {
-            // 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.status === TxStatus.DROPPED || receipt.status === TxStatus.APP_LOGIC_REVERTED || receipt.status === TxStatus.TEARDOWN_REVERTED || receipt.status === TxStatus.BOTH_REVERTED) {
-            // Tx was dropped or reverted --> we drop the corresponding pending indexes.
-            // TODO(#17615): Don't drop pending indexes corresponding to non-revertible phases.
+        if (receipt.status === TxStatus.FINALIZED) {
+            // Tx has been included in a block and the corresponding block is finalized
+            if (receipt.hasExecutionSucceeded()) {
+                // No part of execution reverted - we just finalize all the indexes.
+                txHashesToFinalize.push(txHash);
+            } else if (receipt.hasExecutionReverted()) {
+                // Tx was mined but execution reverted (app logic, teardown, or both). Some logs from the non-revertible
+                // phase may still be onchain. We check which tags made it onchain and finalize those; drop the rest.
+                txHashesWithExecutionReverted.push(txHash);
+            } else {
+                // Defensive check - this branch should never be triggered
+                throw new Error('Both hasExecutionSucceeded and hasExecutionReverted on the receipt returned false. This should never happen and it implies a bug. Please open an issue.');
+            }
+        } else if (receipt.isDropped()) {
+            // Tx was dropped from the mempool --> we drop the corresponding pending indexes.
             txHashesToDrop.push(txHash);
         } else {
-        // Tx is still pending or the corresponding block is not yet finalized --> we don't do anything.
+        // Tx is still pending, not yet finalized, or was mined successfully but not yet finalized --> we don't do anything.
         }
     }
     return {
         txHashesToFinalize,
-        txHashesToDrop
+        txHashesToDrop,
+        txHashesWithExecutionReverted
     };
 }