@aztec/pxe 0.0.1-commit.ef17749e1 → 0.0.1-commit.f1b29a41e

package/dest/storage/tagging_store/sender_tagging_store.d.ts

@@ -1,6 +1,6 @@
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
-import type { ExtendedDirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
-import { TxHash } from '@aztec/stdlib/tx';
+import { ExtendedDirectionalAppTaggingSecret, type TaggingIndexRange } from '@aztec/stdlib/logs';
+import { TxEffect, TxHash } from '@aztec/stdlib/tx';
 import type { StagedStore } from '../../job_coordinator/job_coordinator.js';
 /**
  * Data provider of tagging data used when syncing the sender tagging indexes. The recipient counterpart of this class
@@ -19,31 +19,23 @@ export declare class SenderTaggingStore implements StagedStore {
     commit(jobId: string): Promise<void>;
     discardStaged(jobId: string): Promise<void>;
     /**
-     * Stores pending indexes.
-     * @remarks Ignores the index if the same preTag + txHash combination already exists in the db with the same index.
-     * This is expected to happen because whenever we start sync we start from the last finalized index and we can have
-     * pending indexes already stored from previous syncs.
-     * @param preTags - The pre-tags containing the directional app tagging secrets and the indexes that are to be
-     * stored in the db.
-     * @param txHash - The tx in which the pretags were used in private logs.
+     * Stores pending index ranges.
+     * @remarks If the same (secret, txHash) pair already exists in the db with an equal range, it's a no-op. This is
+     * expected to happen because whenever we start sync we start from the last finalized index and we can have pending
+     * ranges already stored from previous syncs. If the ranges differ, it throws an error as that indicates a bug.
+     * @param ranges - The tagging index ranges containing the directional app tagging secrets and the index ranges that are
+     * to be stored in the db.
+     * @param txHash - The tx in which the tagging indexes were used in private logs.
      * @param jobId - job context for staged writes to this store. See `JobCoordinator` for more details.
-     * @throws If any two pre-tags contain the same directional app tagging secret. This is enforced because we care
-     * only about the highest index for a given secret that was used in the tx. Hence this check is a good way to catch
-     * bugs.
-     * @throws If the newly stored pending index is further than window length from the highest finalized index for the
-     * same secret. This is enforced in order to give a guarantee to a recipient that he doesn't need to look further than
-     * window length ahead of the highest finalized index.
-     * @throws If a secret + txHash pair already exists in the db with a different index value. It should never happen
-     * that we would attempt to store a different index for a given secret-txHash pair because we always store just the
-     * highest index for a given secret-txHash pair. Hence this is a good way to catch bugs.
-     * @throws If the newly stored pending index is lower than or equal to the last finalized index for the same secret.
-     * This is enforced because this should never happen if the syncing is done correctly as we look for logs from higher
-     * indexes than finalized ones.
+     * @throws If the highestIndex is further than window length from the highest finalized index for the same secret.
+     * @throws If the lowestIndex is lower than or equal to the last finalized index for the same secret.
+     * @throws If a different range already exists for the same (secret, txHash) pair.
      */
-    storePendingIndexes(preTags: PreTag[], txHash: TxHash, jobId: string): Promise<void>;
+    storePendingIndexes(ranges: TaggingIndexRange[], txHash: TxHash, jobId: string): Promise<void>;
     /**
-     * Returns the transaction hashes of all pending transactions that contain indexes within a specified range
-     * for a given directional app tagging secret.
+     * Returns the transaction hashes of all pending transactions that contain highest indexes within a specified range
+     * for a given directional app tagging secret. We check based on the highest indexes only as that is the relevant
+     * information for the caller of this function.
      * @param secret - The directional app tagging secret to query pending indexes for.
      * @param startIndex - The lower bound of the index range (inclusive).
      * @param endIndex - The upper bound of the index range (exclusive).
@@ -73,5 +65,14 @@ export declare class SenderTaggingStore implements StagedStore {
      * indexes.
      */
     finalizePendingIndexes(txHashes: TxHash[], jobId: string): Promise<void>;
+    /**
+     * Handles finalization of pending indexes for a transaction whose execution was partially reverted.
+     * Recomputes the siloed tags for each pending index of the given tx and checks which ones appear in the
+     * TxEffect's private logs (i.e., which ones made it onchain). Those that survived are finalized; those that
+     * didn't are dropped.
+     * @param txEffect - The tx effect of the partially reverted transaction.
+     * @param jobId - job context for staged writes to this store. See `JobCoordinator` for more details.
+     */
+    finalizePendingIndexesOfAPartiallyRevertedTx(txEffect: TxEffect, jobId: string): Promise<void>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VuZGVyX3RhZ2dpbmdfc3RvcmUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL3RhZ2dpbmdfc3RvcmUvc2VuZGVyX3RhZ2dpbmdfc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQWlCLE1BQU0saUJBQWlCLENBQUM7QUFDeEUsT0FBTyxLQUFLLEVBQUUsbUNBQW1DLEVBQUUsTUFBTSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDdEYsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRTFDLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLDBDQUEwQyxDQUFDO0FBRzVFOzs7O0dBSUc7QUFDSCxxQkFBYSxrQkFBbUIsWUFBVyxXQUFXOztJQUNwRCxRQUFRLENBQUMsU0FBUyxvQkFBb0I7SUE2QnRDLFlBQVksS0FBSyxFQUFFLGlCQUFpQixFQVFuQztJQTRDRDs7OztPQUlHO0lBQ0csTUFBTSxDQUFDLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQW9CekM7SUFFRCxhQUFhLENBQUMsS0FBSyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBSTFDO0lBRUQ7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztPQXFCRztJQUNILG1CQUFtQixDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFBRSxNQUFNLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQTBFbkY7SUFFRDs7Ozs7Ozs7T0FRRztJQUNILDJCQUEyQixDQUN6QixNQUFNLEVBQUUsbUNBQW1DLEVBQzNDLFVBQVUsRUFBRSxNQUFNLEVBQ2xCLFFBQVEsRUFBRSxNQUFNLEVBQ2hCLEtBQUssRUFBRSxNQUFNLEdBQ1osT0FBTyxDQUFDLE1BQU0sRUFBRSxDQUFDLENBUW5CO0lBRUQ7Ozs7T0FJRztJQUNILHFCQUFxQixDQUFDLE1BQU0sRUFBRSxtQ0FBbUMsRUFBRSxLQUFLLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLENBRTdHO0lBRUQ7Ozs7O09BS0c7SUFDSCxnQkFBZ0IsQ0FBQyxNQUFNLEVBQUUsbUNBQW1DLEVBQUUsS0FBSyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQyxDQWtCeEc7SUFFRDs7T0FFRztJQUNILGtCQUFrQixDQUFDLFFBQVEsRUFBRSxNQUFNLEVBQUUsRUFBRSxLQUFLLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0EyQ25FO0lBRUQ7OztPQUdHO0lBQ0gsc0JBQXNCLENBQUMsUUFBUSxFQUFFLE1BQU0sRUFBRSxFQUFFLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQTJGdkU7Q0FDRiJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VuZGVyX3RhZ2dpbmdfc3RvcmUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL3RhZ2dpbmdfc3RvcmUvc2VuZGVyX3RhZ2dpbmdfc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQWlCLE1BQU0saUJBQWlCLENBQUM7QUFDeEUsT0FBTyxFQUFFLG1DQUFtQyxFQUFhLEtBQUssaUJBQWlCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUM1RyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRXBELE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLDBDQUEwQyxDQUFDO0FBTTVFOzs7O0dBSUc7QUFDSCxxQkFBYSxrQkFBbUIsWUFBVyxXQUFXOztJQUNwRCxRQUFRLENBQUMsU0FBUyxvQkFBb0I7SUE0QnRDLFlBQVksS0FBSyxFQUFFLGlCQUFpQixFQVFuQztJQTRDRDs7OztPQUlHO0lBQ0csTUFBTSxDQUFDLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQW9CekM7SUFFRCxhQUFhLENBQUMsS0FBSyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBSTFDO0lBRUQ7Ozs7Ozs7Ozs7OztPQVlHO0lBQ0gsbUJBQW1CLENBQUMsTUFBTSxFQUFFLGlCQUFpQixFQUFFLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FpRTdGO0lBRUQ7Ozs7Ozs7OztPQVNHO0lBQ0gsMkJBQTJCLENBQ3pCLE1BQU0sRUFBRSxtQ0FBbUMsRUFDM0MsVUFBVSxFQUFFLE1BQU0sRUFDbEIsUUFBUSxFQUFFLE1BQU0sRUFDaEIsS0FBSyxFQUFFLE1BQU0sR0FDWixPQUFPLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FRbkI7SUFFRDs7OztPQUlHO0lBQ0gscUJBQXFCLENBQUMsTUFBTSxFQUFFLG1DQUFtQyxFQUFFLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUMsQ0FFN0c7SUFFRDs7Ozs7T0FLRztJQUNILGdCQUFnQixDQUFDLE1BQU0sRUFBRSxtQ0FBbUMsRUFBRSxLQUFLLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLENBaUJ4RztJQUVEOztPQUVHO0lBQ0gsa0JBQWtCLENBQUMsUUFBUSxFQUFFLE1BQU0sRUFBRSxFQUFFLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQTJDbkU7SUE0Q0Q7OztPQUdHO0lBQ0csc0JBQXNCLENBQUMsUUFBUSxFQUFFLE1BQU0sRUFBRSxFQUFFLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQXNEN0U7SUFFRDs7Ozs7OztPQU9HO0lBQ0csNENBQTRDLENBQUMsUUFBUSxFQUFFLFFBQVEsRUFBRSxLQUFLLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FnRG5HO0NBQ0YifQ==

package/dest/storage/tagging_store/sender_tagging_store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sender_tagging_store.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_store/sender_tagging_store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACtF,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0CAA0C,CAAC;AAG5E;;;;GAIG;AACH,qBAAa,kBAAmB,YAAW,WAAW;;IACpD,QAAQ,CAAC,SAAS,oBAAoB;IA6BtC,YAAY,KAAK,EAAE,iBAAiB,EAQnC;IA4CD;;;;OAIG;IACG,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAoBzC;IAED,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI1C;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA0EnF;IAED;;;;;;;;OAQG;IACH,2BAA2B,CACzB,MAAM,EAAE,mCAAmC,EAC3C,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,MAAM,EAAE,CAAC,CAQnB;IAED;;;;OAIG;IACH,qBAAqB,CAAC,MAAM,EAAE,mCAAmC,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAE7G;IAED;;;;;OAKG;IACH,gBAAgB,CAAC,MAAM,EAAE,mCAAmC,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAkBxG;IAED;;OAEG;IACH,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA2CnE;IAED;;;OAGG;IACH,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA2FvE;CACF"}
+{"version":3,"file":"sender_tagging_store.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_store/sender_tagging_store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,mCAAmC,EAAa,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5G,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0CAA0C,CAAC;AAM5E;;;;GAIG;AACH,qBAAa,kBAAmB,YAAW,WAAW;;IACpD,QAAQ,CAAC,SAAS,oBAAoB;IA4BtC,YAAY,KAAK,EAAE,iBAAiB,EAQnC;IA4CD;;;;OAIG;IACG,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAoBzC;IAED,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI1C;IAED;;;;;;;;;;;;OAYG;IACH,mBAAmB,CAAC,MAAM,EAAE,iBAAiB,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAiE7F;IAED;;;;;;;;;OASG;IACH,2BAA2B,CACzB,MAAM,EAAE,mCAAmC,EAC3C,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,MAAM,EAAE,CAAC,CAQnB;IAED;;;;OAIG;IACH,qBAAqB,CAAC,MAAM,EAAE,mCAAmC,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAE7G;IAED;;;;;OAKG;IACH,gBAAgB,CAAC,MAAM,EAAE,mCAAmC,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAiBxG;IAED;;OAEG;IACH,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA2CnE;IA4CD;;;OAGG;IACG,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAsD7E;IAED;;;;;;;OAOG;IACG,4CAA4C,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAgDnG;CACF"}

package/dest/storage/tagging_store/sender_tagging_store.js

@@ -1,3 +1,4 @@
+import { ExtendedDirectionalAppTaggingSecret, SiloedTag } from '@aztec/stdlib/logs';
 import { TxHash } from '@aztec/stdlib/tx';
 import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.js';
 /**
@@ -7,18 +8,17 @@ import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.
  */ export class SenderTaggingStore {
     storeName = 'sender_tagging';
     #store;
-    // Stores the pending indexes for each directional app tagging secret. Pending here means that the tx that contained
-    // the private logs with tags corresponding to these indexes has not been finalized yet.
+    // Stores the pending index ranges for each directional app tagging secret. Pending here means that the tx that
+    // contained the private logs with tags corresponding to these indexes has not been finalized yet.
     //
-    // We don't store just the highest index because if their transaction is dropped we'd then need the information about
-    // the lower pending indexes. For each secret-tx pair however we only store the largest index used in that tx, since
-    // the smaller ones are irrelevant due to tx atomicity.
+    // We store the full range (lowestIndex, highestIndex) for each secret-tx pair because transactions can partially
+    // revert, in which case only some logs (from the non-revertible phase) survive onchain. By storing the range,
+    // we can expand it and check each individual siloed tag against the TxEffect to determine which indexes made it
+    // onchain.
     //
-    // TODO(#17615): This assumes no logs are used in the non-revertible phase.
-    //
-    // directional app tagging secret => { pending index, txHash }[]
+    // directional app tagging secret => { lowestIndex, highestIndex, txHash }[]
     #pendingIndexes;
-    // jobId => directional app tagging secret => { pending index, txHash }[]
+    // jobId => directional app tagging secret => { lowestIndex, highestIndex, txHash }[]
     #pendingIndexesForJob;
     // Stores the last (highest) finalized index for each directional app tagging secret. We care only about the last
     // index because unlike the pending indexes, it will never happen that a finalized index would be removed and hence
@@ -100,82 +100,62 @@ import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.
         return Promise.resolve();
     }
     /**
-   * Stores pending indexes.
-   * @remarks Ignores the index if the same preTag + txHash combination already exists in the db with the same index.
-   * This is expected to happen because whenever we start sync we start from the last finalized index and we can have
-   * pending indexes already stored from previous syncs.
-   * @param preTags - The pre-tags containing the directional app tagging secrets and the indexes that are to be
-   * stored in the db.
-   * @param txHash - The tx in which the pretags were used in private logs.
+   * Stores pending index ranges.
+   * @remarks If the same (secret, txHash) pair already exists in the db with an equal range, it's a no-op. This is
+   * expected to happen because whenever we start sync we start from the last finalized index and we can have pending
+   * ranges already stored from previous syncs. If the ranges differ, it throws an error as that indicates a bug.
+   * @param ranges - The tagging index ranges containing the directional app tagging secrets and the index ranges that are
+   * to be stored in the db.
+   * @param txHash - The tx in which the tagging indexes were used in private logs.
    * @param jobId - job context for staged writes to this store. See `JobCoordinator` for more details.
-   * @throws If any two pre-tags contain the same directional app tagging secret. This is enforced because we care
-   * only about the highest index for a given secret that was used in the tx. Hence this check is a good way to catch
-   * bugs.
-   * @throws If the newly stored pending index is further than window length from the highest finalized index for the
-   * same secret. This is enforced in order to give a guarantee to a recipient that he doesn't need to look further than
-   * window length ahead of the highest finalized index.
-   * @throws If a secret + txHash pair already exists in the db with a different index value. It should never happen
-   * that we would attempt to store a different index for a given secret-txHash pair because we always store just the
-   * highest index for a given secret-txHash pair. Hence this is a good way to catch bugs.
-   * @throws If the newly stored pending index is lower than or equal to the last finalized index for the same secret.
-   * This is enforced because this should never happen if the syncing is done correctly as we look for logs from higher
-   * indexes than finalized ones.
-   */ storePendingIndexes(preTags, txHash, jobId) {
-        if (preTags.length === 0) {
+   * @throws If the highestIndex is further than window length from the highest finalized index for the same secret.
+   * @throws If the lowestIndex is lower than or equal to the last finalized index for the same secret.
+   * @throws If a different range already exists for the same (secret, txHash) pair.
+   */ storePendingIndexes(ranges, txHash, jobId) {
+        if (ranges.length === 0) {
             return Promise.resolve();
         }
-        // The secrets in pre-tags should be unique because we always store just the highest index per given secret-txHash
-        // pair. Below we check that this is the case.
-        const secretsSet = new Set(preTags.map((preTag)=>preTag.extendedSecret.toString()));
-        if (secretsSet.size !== preTags.length) {
-            return Promise.reject(new Error(`Duplicate secrets found when storing pending indexes`));
-        }
         const txHashStr = txHash.toString();
         return this.#store.transactionAsync(async ()=>{
             // Prefetch all data, start reads during iteration to keep IndexedDB transaction alive
-            const preTagReadPromises = preTags.map(({ extendedSecret, index })=>{
-                const secretStr = extendedSecret.toString();
-                return {
-                    extendedSecret,
-                    secretStr,
-                    index,
-                    pending: this.#readPendingIndexes(jobId, secretStr),
-                    finalized: this.#readLastFinalizedIndex(jobId, secretStr)
-                };
-            });
+            const rangeReadPromises = ranges.map((range)=>({
+                    range,
+                    secretStr: range.extendedSecret.toString(),
+                    pending: this.#readPendingIndexes(jobId, range.extendedSecret.toString()),
+                    finalized: this.#readLastFinalizedIndex(jobId, range.extendedSecret.toString())
+                }));
             // Await all reads together
-            const preTagData = await Promise.all(preTagReadPromises.map(async (item)=>({
+            const rangeData = await Promise.all(rangeReadPromises.map(async (item)=>({
                     ...item,
                     pendingData: await item.pending,
                     finalizedIndex: await item.finalized
                 })));
             // Process in memory and validate
-            for (const { secretStr, index, pendingData, finalizedIndex } of preTagData){
-                // First we check that for any secret the highest used index in tx is not further than window length from
-                // the highest finalized index.
-                if (index > (finalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN) {
-                    throw new Error(`Highest used index ${index} is further than window length from the highest finalized index ${finalizedIndex ?? 0}.
+            for (const { range, secretStr, pendingData, finalizedIndex } of rangeData){
+                // Check that the highest index is not further than window length from the highest finalized index.
+                if (range.highestIndex > (finalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN) {
+                    throw new Error(`Highest used index ${range.highestIndex} is further than window length from the highest finalized index ${finalizedIndex ?? 0}.
             Tagging window length ${UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN} is configured too low. Contact the Aztec team
             to increase it!`);
                 }
-                // Throw if the new pending index is lower than or equal to the last finalized index
-                if (finalizedIndex !== undefined && index <= finalizedIndex) {
-                    throw new Error(`Cannot store pending index ${index} for secret ${secretStr}: ` + `it is lower than or equal to the last finalized index ${finalizedIndex}`);
+                // Throw if the lowest index is lower than or equal to the last finalized index
+                if (finalizedIndex !== undefined && range.lowestIndex <= finalizedIndex) {
+                    throw new Error(`Cannot store pending index range [${range.lowestIndex}, ${range.highestIndex}] for secret ${secretStr}: ` + `lowestIndex is lower than or equal to the last finalized index ${finalizedIndex}`);
                 }
-                // Check if this secret + txHash combination already exists
-                const existingForSecretAndTx = pendingData.find((entry)=>entry.txHash === txHashStr);
-                if (existingForSecretAndTx) {
-                    // If it exists with a different index, throw an error
-                    if (existingForSecretAndTx.index !== index) {
-                        throw new Error(`Cannot store index ${index} for secret ${secretStr} and txHash ${txHashStr}: ` + `a different index ${existingForSecretAndTx.index} already exists for this secret-txHash pair`);
+                // Check if an entry with the same txHash already exists
+                const existingEntry = pendingData.find((entry)=>entry.txHash === txHashStr);
+                if (existingEntry) {
+                    // Assert that the ranges are equal — different ranges for the same (secret, txHash) indicates a bug
+                    if (existingEntry.lowestIndex !== range.lowestIndex || existingEntry.highestIndex !== range.highestIndex) {
+                        throw new Error(`Conflicting range for secret ${secretStr} and txHash ${txHashStr}: ` + `existing [${existingEntry.lowestIndex}, ${existingEntry.highestIndex}] vs ` + `new [${range.lowestIndex}, ${range.highestIndex}]`);
                     }
-                // If it exists with the same index, ignore the update (no-op)
+                // Exact duplicate — skip
                 } else {
-                    // If it doesn't exist, add it
                     this.#writePendingIndexes(jobId, secretStr, [
                         ...pendingData,
                         {
-                            index,
+                            lowestIndex: range.lowestIndex,
+                            highestIndex: range.highestIndex,
                             txHash: txHashStr
                         }
                     ]);
@@ -184,8 +164,9 @@ import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.
         });
     }
     /**
-   * Returns the transaction hashes of all pending transactions that contain indexes within a specified range
-   * for a given directional app tagging secret.
+   * Returns the transaction hashes of all pending transactions that contain highest indexes within a specified range
+   * for a given directional app tagging secret. We check based on the highest indexes only as that is the relevant
+   * information for the caller of this function.
    * @param secret - The directional app tagging secret to query pending indexes for.
    * @param startIndex - The lower bound of the index range (inclusive).
    * @param endIndex - The upper bound of the index range (exclusive).
@@ -194,7 +175,7 @@ import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.
    */ getTxHashesOfPendingIndexes(secret, startIndex, endIndex, jobId) {
         return this.#store.transactionAsync(async ()=>{
             const existing = await this.#readPendingIndexes(jobId, secret.toString());
-            const txHashes = existing.filter((entry)=>entry.index >= startIndex && entry.index < endIndex).map((entry)=>entry.txHash);
+            const txHashes = existing.filter((entry)=>entry.highestIndex >= startIndex && entry.highestIndex < endIndex).map((entry)=>entry.txHash);
             return Array.from(new Set(txHashes)).map(TxHash.fromString);
         });
     }
@@ -215,17 +196,16 @@ import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.
         return this.#store.transactionAsync(async ()=>{
             const pendingPromise = this.#readPendingIndexes(jobId, secretStr);
             const finalizedPromise = this.#readLastFinalizedIndex(jobId, secretStr);
-            const [pendingTxScopedIndexes, lastFinalized] = await Promise.all([
+            const [pendingEntries, lastFinalized] = await Promise.all([
                 pendingPromise,
                 finalizedPromise
             ]);
-            const pendingIndexes = pendingTxScopedIndexes.map((entry)=>entry.index);
-            if (pendingTxScopedIndexes.length === 0) {
+            if (pendingEntries.length === 0) {
                 return lastFinalized;
             }
-            // As the last used index we return the highest one from the pending indexes. Note that this value will be always
-            // higher than the last finalized index because we prune lower pending indexes when a tx is finalized.
-            return Math.max(...pendingIndexes);
+            // As the last used index we return the highest one from the pending index ranges. Note that this value will be
+            // always higher than the last finalized index because we prune lower pending indexes when a tx is finalized.
+            return Math.max(...pendingEntries.map((entry)=>entry.highestIndex));
         });
     }
     /**
@@ -269,14 +249,7 @@ import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.
             }
         });
     }
-    /**
-   * Updates pending indexes corresponding to the given transaction hashes to be finalized and prunes any lower pending
-   * indexes.
-   */ finalizePendingIndexes(txHashes, jobId) {
-        if (txHashes.length === 0) {
-            return Promise.resolve();
-        }
-        const txHashStrings = new Set(txHashes.map((tx)=>tx.toString()));
+    /** Prefetches all pending and finalized index data for every secret (from both DB and staged writes). */ #getSecretsWithPendingData(jobId) {
         return this.#store.transactionAsync(async ()=>{
             // Prefetch all data, start reads during iteration to keep IndexedDB transaction alive
             const secretDataPromises = new Map();
@@ -304,45 +277,98 @@ import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.
                     pendingData: await secretDataPromises.get(secret).pending,
                     lastFinalized: await secretDataPromises.get(secret).finalized
                 })));
-            // Process all txHashes for each secret in memory
-            for (const { secret, pendingData, lastFinalized } of dataResults){
-                if (!pendingData || pendingData.length === 0) {
+            return dataResults.filter((r)=>r.pendingData.length > 0);
+        });
+    }
+    /**
+   * Updates pending indexes corresponding to the given transaction hashes to be finalized and prunes any lower pending
+   * indexes.
+   */ async finalizePendingIndexes(txHashes, jobId) {
+        if (txHashes.length === 0) {
+            return;
+        }
+        const txHashStrings = new Set(txHashes.map((tx)=>tx.toString()));
+        const secretsWithData = await this.#getSecretsWithPendingData(jobId);
+        for (const { secret, pendingData, lastFinalized } of secretsWithData){
+            let currentPending = pendingData;
+            let currentFinalized = lastFinalized;
+            // Process all txHashes for this secret
+            for (const txHashStr of txHashStrings){
+                const matchingEntries = currentPending.filter((item)=>item.txHash === txHashStr);
+                if (matchingEntries.length === 0) {
                     continue;
                 }
-                let currentPending = pendingData;
-                let currentFinalized = lastFinalized;
-                // Process all txHashes for this secret
-                for (const txHashStr of txHashStrings){
-                    const matchingIndexes = currentPending.filter((item)=>item.txHash === txHashStr).map((item)=>item.index);
-                    if (matchingIndexes.length === 0) {
-                        continue;
-                    }
-                    if (matchingIndexes.length > 1) {
-                        // We should always just store the highest pending index for a given tx hash and secret because the lower
-                        // values are irrelevant.
-                        throw new Error(`Multiple pending indexes found for tx hash ${txHashStr} and secret ${secret}`);
-                    }
-                    const newFinalized = matchingIndexes[0];
-                    if (newFinalized < (currentFinalized ?? 0)) {
-                        // This should never happen because when last finalized index was finalized we should have pruned the lower
-                        // pending indexes.
-                        throw new Error(`New finalized index ${newFinalized} is smaller than the current last finalized index ${currentFinalized}`);
-                    }
-                    currentFinalized = newFinalized;
-                    // When we add pending indexes, we ensure they are higher than the last finalized index. However, because we
-                    // cannot control the order in which transactions are finalized, there may be pending indexes that are now
-                    // obsolete because they are lower than the most recently finalized index. For this reason, we prune these
-                    // outdated pending indexes.
-                    currentPending = currentPending.filter((item)=>item.index > currentFinalized);
+                if (matchingEntries.length > 1) {
+                    // We should always just store the highest pending index for a given tx hash and secret because the lower
+                    // values are irrelevant.
+                    throw new Error(`Multiple pending entries found for tx hash ${txHashStr} and secret ${secret}`);
                 }
-                // Write final state if changed
-                if (currentFinalized !== lastFinalized) {
-                    this.#writeLastFinalizedIndex(jobId, secret, currentFinalized);
+                const newFinalized = matchingEntries[0].highestIndex;
+                if (newFinalized < (currentFinalized ?? 0)) {
+                    // This should never happen because when last finalized index was finalized we should have pruned the lower
+                    // pending indexes.
+                    throw new Error(`New finalized index ${newFinalized} is smaller than the current last finalized index ${currentFinalized}`);
                 }
-                if (currentPending !== pendingData) {
-                    this.#writePendingIndexes(jobId, secret, currentPending);
+                currentFinalized = newFinalized;
+                // When we add pending indexes, we ensure they are higher than the last finalized index. However, because we
+                // cannot control the order in which transactions are finalized, there may be pending indexes that are now
+                // obsolete because they are lower than the most recently finalized index. For this reason, we prune these
+                // outdated pending indexes.
+                currentPending = currentPending.filter((item)=>item.highestIndex > currentFinalized);
+            }
+            // Write final state if changed
+            if (currentFinalized !== lastFinalized) {
+                this.#writeLastFinalizedIndex(jobId, secret, currentFinalized);
+            }
+            if (currentPending !== pendingData) {
+                this.#writePendingIndexes(jobId, secret, currentPending);
+            }
+        }
+    }
+    /**
+   * Handles finalization of pending indexes for a transaction whose execution was partially reverted.
+   * Recomputes the siloed tags for each pending index of the given tx and checks which ones appear in the
+   * TxEffect's private logs (i.e., which ones made it onchain). Those that survived are finalized; those that
+   * didn't are dropped.
+   * @param txEffect - The tx effect of the partially reverted transaction.
+   * @param jobId - job context for staged writes to this store. See `JobCoordinator` for more details.
+   */ async finalizePendingIndexesOfAPartiallyRevertedTx(txEffect, jobId) {
+        const txHashStr = txEffect.txHash.toString();
+        // Build a set of all siloed tag values that made it onchain (first field of each private log).
+        const onChainTags = new Set(txEffect.privateLogs.map((log)=>log.fields[0].toString()));
+        const secretsWithData = await this.#getSecretsWithPendingData(jobId);
+        for (const { secret, pendingData, lastFinalized } of secretsWithData){
+            const matchingEntries = pendingData.filter((item)=>item.txHash === txHashStr);
+            if (matchingEntries.length === 0) {
+                continue;
+            }
+            if (matchingEntries.length > 1) {
+                // We should always just store the highest pending index for a given tx hash and secret because the lower
+                // values are irrelevant.
+                throw new Error(`Multiple pending entries found for tx hash ${txHashStr} and secret ${secret}`);
+            }
+            const pendingEntry = matchingEntries[0];
+            // Expand each matching entry's range and recompute siloed tags for each index.
+            const extendedSecret = ExtendedDirectionalAppTaggingSecret.fromString(secret);
+            let highestSurvivingIndex;
+            for(let index = pendingEntry.lowestIndex; index <= pendingEntry.highestIndex; index++){
+                const siloedTag = await SiloedTag.compute({
+                    extendedSecret,
+                    index
+                });
+                if (onChainTags.has(siloedTag.value.toString())) {
+                    highestSurvivingIndex = highestSurvivingIndex !== undefined ? Math.max(highestSurvivingIndex, index) : index;
                 }
             }
-        });
+            // Remove all entries for this txHash from pending (both surviving and non-surviving).
+            let currentPending = pendingData.filter((item)=>item.txHash !== txHashStr);
+            if (highestSurvivingIndex !== undefined) {
+                const newFinalized = Math.max(lastFinalized ?? 0, highestSurvivingIndex);
+                this.#writeLastFinalizedIndex(jobId, secret, newFinalized);
+                // Prune pending indexes that are now <= the finalized index.
+                currentPending = currentPending.filter((item)=>item.highestIndex > newFinalized);
+            }
+            this.#writePendingIndexes(jobId, secret, currentPending);
+        }
     }
 }

package/dest/tagging/index.d.ts

@@ -13,5 +13,5 @@ export { syncSenderTaggingIndexes } from './sender_sync/sync_sender_tagging_inde
 export { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from './constants.js';
 export { getAllPrivateLogsByTags, getAllPublicLogsByTagsFromContract } from './get_all_logs_by_tags.js';
 export { ExtendedDirectionalAppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';
-export { type PreTag } from '@aztec/stdlib/logs';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90YWdnaW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7R0FTRztBQUVILE9BQU8sRUFBRSxxQ0FBcUMsRUFBRSxNQUFNLGlFQUFpRSxDQUFDO0FBQ3hILE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBQ3hGLE9BQU8sRUFBRSxzQ0FBc0MsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3hFLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxrQ0FBa0MsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBR3hHLE9BQU8sRUFBRSxtQ0FBbUMsRUFBRSxHQUFHLEVBQUUsU0FBUyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDekYsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFFLE1BQU0sb0JBQW9CLENBQUMifQ==
+export { type PreTag, type TaggingIndexRange } from '@aztec/stdlib/logs';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90YWdnaW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7R0FTRztBQUVILE9BQU8sRUFBRSxxQ0FBcUMsRUFBRSxNQUFNLGlFQUFpRSxDQUFDO0FBQ3hILE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBQ3hGLE9BQU8sRUFBRSxzQ0FBc0MsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3hFLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxrQ0FBa0MsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBR3hHLE9BQU8sRUFBRSxtQ0FBbUMsRUFBRSxHQUFHLEVBQUUsU0FBUyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDekYsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFFLEtBQUssaUJBQWlCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQyJ9

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,mCAAmC,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACzF,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,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,mCAAmC,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACzF,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC"}

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

@@ -14,4 +14,4 @@ import type { SenderTaggingStore } from '../../storage/tagging_store/sender_tagg
  * updates its status accordingly.
  */
 export declare function syncSenderTaggingIndexes(secret: ExtendedDirectionalAppTaggingSecret, aztecNode: AztecNode, taggingStore: SenderTaggingStore, anchorBlockHash: BlockHash, jobId: string): Promise<void>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luY19zZW5kZXJfdGFnZ2luZ19pbmRleGVzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGFnZ2luZy9zZW5kZXJfc3luYy9zeW5jX3NlbmRlcl90YWdnaW5nX2luZGV4ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDckQsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDakUsT0FBTyxLQUFLLEVBQUUsbUNBQW1DLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUU5RSxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHFEQUFxRCxDQUFDO0FBSzlGOzs7Ozs7Ozs7O0dBVUc7QUFDSCx3QkFBc0Isd0JBQXdCLENBQzVDLE1BQU0sRUFBRSxtQ0FBbUMsRUFDM0MsU0FBUyxFQUFFLFNBQVMsRUFDcEIsWUFBWSxFQUFFLGtCQUFrQixFQUNoQyxlQUFlLEVBQUUsU0FBUyxFQUMxQixLQUFLLEVBQUUsTUFBTSxHQUNaLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FtRWYifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luY19zZW5kZXJfdGFnZ2luZ19pbmRleGVzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGFnZ2luZy9zZW5kZXJfc3luYy9zeW5jX3NlbmRlcl90YWdnaW5nX2luZGV4ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDckQsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDakUsT0FBTyxLQUFLLEVBQUUsbUNBQW1DLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUU5RSxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHFEQUFxRCxDQUFDO0FBSzlGOzs7Ozs7Ozs7O0dBVUc7QUFDSCx3QkFBc0Isd0JBQXdCLENBQzVDLE1BQU0sRUFBRSxtQ0FBbUMsRUFDM0MsU0FBUyxFQUFFLFNBQVMsRUFDcEIsWUFBWSxFQUFFLGtCQUFrQixFQUNoQyxlQUFlLEVBQUUsU0FBUyxFQUMxQixLQUFLLEVBQUUsTUFBTSxHQUNaLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FxRmYifQ==

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

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

package/dest/tagging/sender_sync/sync_sender_tagging_indexes.js

@@ -43,9 +43,18 @@ import { loadAndStoreNewTaggingIndexes } from './utils/load_and_store_new_taggin
         if (pendingTxHashes.length === 0) {
             break;
         }
-        const { txHashesToFinalize, txHashesToDrop } = await getStatusChangeOfPending(pendingTxHashes, aztecNode);
+        const { txHashesToFinalize, txHashesToDrop, txHashesWithExecutionReverted } = await getStatusChangeOfPending(pendingTxHashes, aztecNode);
         await taggingStore.dropPendingIndexes(txHashesToDrop, jobId);
         await taggingStore.finalizePendingIndexes(txHashesToFinalize, jobId);
+        if (txHashesWithExecutionReverted.length > 0) {
+            const indexedTxEffects = await Promise.all(txHashesWithExecutionReverted.map((txHash)=>aztecNode.getTxEffect(txHash)));
+            for (const indexedTxEffect of indexedTxEffects){
+                if (indexedTxEffect === undefined) {
+                    throw new Error('TxEffect not found for execution-reverted tx. This is either a bug or a reorg has occurred.');
+                }
+                await taggingStore.finalizePendingIndexesOfAPartiallyRevertedTx(indexedTxEffect.data, jobId);
+            }
+        }
         // 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,12 @@
 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.
+ * Based on receipts obtained from `aztecNode` returns which pending transactions changed their status to finalized,
+ * dropped, or execution-reverted (but mined).
  */
 export declare function getStatusChangeOfPending(pending: TxHash[], aztecNode: AztecNode): Promise<{
     txHashesToFinalize: TxHash[];
     txHashesToDrop: TxHash[];
+    txHashesWithExecutionReverted: TxHash[];
 }>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0X3N0YXR1c19jaGFuZ2Vfb2ZfcGVuZGluZy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvZ2V0X3N0YXR1c19jaGFuZ2Vfb2ZfcGVuZGluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEVBQUUsTUFBTSxFQUFZLE1BQU0sa0JBQWtCLENBQUM7QUFFcEQ7OztHQUdHO0FBQ0gsd0JBQXNCLHdCQUF3QixDQUM1QyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQ2pCLFNBQVMsRUFBRSxTQUFTLEdBQ25CLE9BQU8sQ0FBQztJQUFFLGtCQUFrQixFQUFFLE1BQU0sRUFBRSxDQUFDO0lBQUMsY0FBYyxFQUFFLE1BQU0sRUFBRSxDQUFBO0NBQUUsQ0FBQyxDQXlCckUifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0X3N0YXR1c19jaGFuZ2Vfb2ZfcGVuZGluZy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvZ2V0X3N0YXR1c19jaGFuZ2Vfb2ZfcGVuZGluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEVBQUUsTUFBTSxFQUFZLE1BQU0sa0JBQWtCLENBQUM7QUFFcEQ7OztHQUdHO0FBQ0gsd0JBQXNCLHdCQUF3QixDQUM1QyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQ2pCLFNBQVMsRUFBRSxTQUFTLEdBQ25CLE9BQU8sQ0FBQztJQUNULGtCQUFrQixFQUFFLE1BQU0sRUFBRSxDQUFDO0lBQzdCLGNBQWMsRUFBRSxNQUFNLEVBQUUsQ0FBQztJQUN6Qiw2QkFBNkIsRUFBRSxNQUFNLEVBQUUsQ0FBQztDQUN6QyxDQUFDLENBb0NEIn0=

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,CAyBrE"}
+{"version":3,"file":"get_status_change_of_pending.d.ts","sourceRoot":"","sources":["../../../../src/tagging/sender_sync/utils/get_status_change_of_pending.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,MAAM,EAAY,MAAM,kBAAkB,CAAC;AAEpD;;;GAGG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,MAAM,EAAE,EACjB,SAAS,EAAE,SAAS,GACnB,OAAO,CAAC;IACT,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,6BAA6B,EAAE,MAAM,EAAE,CAAC;CACzC,CAAC,CAoCD"}

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

@@ -1,22 +1,31 @@
 import { TxStatus } from '@aztec/stdlib/tx';
 /**
- * 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.
     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.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.
+        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, not yet finalized, or was mined successfully but not yet finalized --> we don't do anything.
@@ -24,6 +33,7 @@ import { TxStatus } from '@aztec/stdlib/tx';
     }
     return {
         txHashesToFinalize,
-        txHashesToDrop
+        txHashesToDrop,
+        txHashesWithExecutionReverted
     };
 }

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

@@ -11,8 +11,9 @@ import type { SenderTaggingStore } from '../../../storage/tagging_store/sender_t
  * @param end - The ending index (exclusive) of the window to process.
  * @param aztecNode - The Aztec node instance to query for logs.
  * @param taggingStore - The data provider to store pending indexes.
+ * @param anchorBlockHash - Hash of a block to use as reference block when querying node.
  * @param jobId - Job identifier, used to keep writes in-memory until they can be persisted in a data integrity
  * preserving way.
  */
 export declare function loadAndStoreNewTaggingIndexes(extendedSecret: ExtendedDirectionalAppTaggingSecret, start: number, end: number, aztecNode: AztecNode, taggingStore: SenderTaggingStore, anchorBlockHash: BlockHash, jobId: string): Promise<void>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvbG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNyRCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEtBQUssRUFBRSxtQ0FBbUMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBSTlFLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFHakc7Ozs7Ozs7Ozs7O0dBV0c7QUFDSCx3QkFBc0IsNkJBQTZCLENBQ2pELGNBQWMsRUFBRSxtQ0FBbUMsRUFDbkQsS0FBSyxFQUFFLE1BQU0sRUFDYixHQUFHLEVBQUUsTUFBTSxFQUNYLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLFlBQVksRUFBRSxrQkFBa0IsRUFDaEMsZUFBZSxFQUFFLFNBQVMsRUFDMUIsS0FBSyxFQUFFLE1BQU0saUJBZWQifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvbG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNyRCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEtBQUssRUFBRSxtQ0FBbUMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBSTlFLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFHakc7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsd0JBQXNCLDZCQUE2QixDQUNqRCxjQUFjLEVBQUUsbUNBQW1DLEVBQ25ELEtBQUssRUFBRSxNQUFNLEVBQ2IsR0FBRyxFQUFFLE1BQU0sRUFDWCxTQUFTLEVBQUUsU0FBUyxFQUNwQixZQUFZLEVBQUUsa0JBQWtCLEVBQ2hDLGVBQWUsRUFBRSxTQUFTLEVBQzFCLEtBQUssRUFBRSxNQUFNLGlCQWdCZCJ9

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

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