@aztec/pxe 5.0.0-rc.2 → 5.0.1

package/dest/storage/store_identity.d.ts

@@ -0,0 +1,35 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+/** The triple that determine which physical store a logical store name maps to. */
+export type StoreIdentity = {
+    /** Chain ID of the L1 the rollup is deployed to. */
+    l1ChainId: number;
+    /** Address of the rollup contract the store's data pertains to. */
+    rollupAddress: EthAddress;
+    /** Schema version of the data held in the store. */
+    schemaVersion: number;
+};
+/**
+ * Composes the store-name discriminator for a store identity. Two identities map to the same physical store iff
+ * their slugs are equal, so the format must stay stable: `<l1ChainId>-<rollupAddress>-v<schemaVersion>` — changing
+ * it orphans every existing store.
+ */
+export declare function storeIdentitySlug({ l1ChainId, rollupAddress, schemaVersion }: StoreIdentity): string;
+/** Composes the physical store name for a logical store name and identity. */
+export declare function effectiveStoreName(name: string, identity: StoreIdentity): string;
+/**
+ * Invariant check for stores whose physical name carries their identity: the recorded version can
+ * only disagree with the expected one if there is a store-naming bug.
+ */
+export declare function assertStoreIdentity(store: AztecAsyncKVStore, storeName: string, identity: StoreIdentity): Promise<void>;
+/**
+ * Thrown when a store's recorded identity does not match the identity it was opened under. Since the identity is
+ * part of the physical store name, this can only indicate a store-naming bug; the store is left untouched.
+ */
+export declare class StoreIdentityMismatchError extends Error {
+    readonly storeName: string;
+    readonly expected: string;
+    readonly actual: string;
+    constructor(storeName: string, expected: string, actual: string);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmVfaWRlbnRpdHkuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdG9yYWdlL3N0b3JlX2lkZW50aXR5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ2hFLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFHekQsbUZBQW1GO0FBQ25GLE1BQU0sTUFBTSxhQUFhLEdBQUc7SUFDMUIsb0RBQW9EO0lBQ3BELFNBQVMsRUFBRSxNQUFNLENBQUM7SUFDbEIsbUVBQW1FO0lBQ25FLGFBQWEsRUFBRSxVQUFVLENBQUM7SUFDMUIsb0RBQW9EO0lBQ3BELGFBQWEsRUFBRSxNQUFNLENBQUM7Q0FDdkIsQ0FBQztBQUVGOzs7O0dBSUc7QUFDSCx3QkFBZ0IsaUJBQWlCLENBQUMsRUFBRSxTQUFTLEVBQUUsYUFBYSxFQUFFLGFBQWEsRUFBRSxFQUFFLGFBQWEsR0FBRyxNQUFNLENBRXBHO0FBRUQsOEVBQThFO0FBQzlFLHdCQUFnQixrQkFBa0IsQ0FBQyxJQUFJLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxhQUFhLEdBQUcsTUFBTSxDQUVoRjtBQUVEOzs7R0FHRztBQUNILHdCQUFzQixtQkFBbUIsQ0FDdkMsS0FBSyxFQUFFLGlCQUFpQixFQUN4QixTQUFTLEVBQUUsTUFBTSxFQUNqQixRQUFRLEVBQUUsYUFBYSxHQUN0QixPQUFPLENBQUMsSUFBSSxDQUFDLENBaUJmO0FBRUQ7OztHQUdHO0FBQ0gscUJBQWEsMEJBQTJCLFNBQVEsS0FBSzthQUVqQyxTQUFTLEVBQUUsTUFBTTthQUNqQixRQUFRLEVBQUUsTUFBTTthQUNoQixNQUFNLEVBQUUsTUFBTTtJQUhoQyxZQUNrQixTQUFTLEVBQUUsTUFBTSxFQUNqQixRQUFRLEVBQUUsTUFBTSxFQUNoQixNQUFNLEVBQUUsTUFBTSxFQU8vQjtDQUNGIn0=

package/dest/storage/store_identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store_identity.d.ts","sourceRoot":"","sources":["../../src/storage/store_identity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAGzD,mFAAmF;AACnF,MAAM,MAAM,aAAa,GAAG;IAC1B,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB,mEAAmE;IACnE,aAAa,EAAE,UAAU,CAAC;IAC1B,oDAAoD;IACpD,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,SAAS,EAAE,aAAa,EAAE,aAAa,EAAE,EAAE,aAAa,GAAG,MAAM,CAEpG;AAED,8EAA8E;AAC9E,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,aAAa,GAAG,MAAM,CAEhF;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,iBAAiB,EACxB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,aAAa,GACtB,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED;;;GAGG;AACH,qBAAa,0BAA2B,SAAQ,KAAK;aAEjC,SAAS,EAAE,MAAM;aACjB,QAAQ,EAAE,MAAM;aAChB,MAAM,EAAE,MAAM;IAHhC,YACkB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EAO/B;CACF"}

package/dest/storage/store_identity.js

@@ -0,0 +1,44 @@
+import { DatabaseVersion } from '@aztec/stdlib/database-version/version';
+/**
+ * Composes the store-name discriminator for a store identity. Two identities map to the same physical store iff
+ * their slugs are equal, so the format must stay stable: `<l1ChainId>-<rollupAddress>-v<schemaVersion>` — changing
+ * it orphans every existing store.
+ */ export function storeIdentitySlug({ l1ChainId, rollupAddress, schemaVersion }) {
+    return `${l1ChainId}-${rollupAddress.toString()}-v${schemaVersion}`;
+}
+/** Composes the physical store name for a logical store name and identity. */ export function effectiveStoreName(name, identity) {
+    return `${name}_${storeIdentitySlug(identity)}`;
+}
+/**
+ * Invariant check for stores whose physical name carries their identity: the recorded version can
+ * only disagree with the expected one if there is a store-naming bug.
+ */ export async function assertStoreIdentity(store, storeName, identity) {
+    const expected = new DatabaseVersion(identity.schemaVersion, identity.rollupAddress);
+    const singleton = store.openSingleton('dbVersion');
+    const stored = await singleton.getAsync();
+    if (stored === undefined) {
+        await singleton.set(expected.toBuffer().toString('utf-8'));
+        return;
+    }
+    let storedVersion;
+    try {
+        storedVersion = DatabaseVersion.fromBuffer(Buffer.from(stored, 'utf-8'));
+    } catch  {
+        throw new StoreIdentityMismatchError(storeName, expected.toString(), stored);
+    }
+    if (!storedVersion.equals(expected)) {
+        throw new StoreIdentityMismatchError(storeName, expected.toString(), storedVersion.toString());
+    }
+}
+/**
+ * Thrown when a store's recorded identity does not match the identity it was opened under. Since the identity is
+ * part of the physical store name, this can only indicate a store-naming bug; the store is left untouched.
+ */ export class StoreIdentityMismatchError extends Error {
+    storeName;
+    expected;
+    actual;
+    constructor(storeName, expected, actual){
+        super(`Store '${storeName}' records identity ${actual} but was opened as ${expected}. ` + `Refusing to open; data was NOT modified.`), this.storeName = storeName, this.expected = expected, this.actual = actual;
+        this.name = 'StoreIdentityMismatchError';
+    }
+}

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

@@ -19,10 +19,11 @@ export declare class SenderTaggingStore implements StagedStore {
     commit(jobId: string): Promise<void>;
     discardStaged(jobId: string): Promise<void>;
     /**
-     * Stores pending index ranges.
+     * Stores pending index ranges, rejecting any range that disagrees with an already-stored one.
      * @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.
+     * ranges already stored from previous syncs. If the ranges differ, it throws an error as that indicates a bug in
+     * callers that record indexes at prove time. Discovery from onchain logs must use `mergePendingIndexes` instead.
      * @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.
@@ -32,6 +33,21 @@ export declare class SenderTaggingStore implements StagedStore {
      * @throws If a different range already exists for the same (secret, txHash) pair.
      */
     storePendingIndexes(ranges: TaggingIndexRange[], txHash: TxHash, jobId: string): Promise<void>;
+    /**
+     * Stores pending index ranges, widening an existing entry for the same (secret, txHash) pair to the union of the
+     * stored and incoming ranges instead of throwing on a mismatch. Discovery from onchain logs needs this: it may see
+     * only the surviving (non-revertible phase) sub-range of a partially reverted tx recorded at prove time (the
+     * finalized receipt step of the sync resolves that difference), or indexes beyond a partially discovered entry
+     * when a tx from another PXE straddles a sync window boundary. Callers that record indexes at prove time must use
+     * `storePendingIndexes` instead, so that a range disagreement surfaces as a bug rather than being absorbed.
+     * @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 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.
+     */
+    mergePendingIndexes(ranges: TaggingIndexRange[], txHash: TxHash, jobId: string): Promise<void>;
     /**
      * 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
@@ -75,4 +91,4 @@ export declare class SenderTaggingStore implements StagedStore {
      */
     finalizePendingIndexesOfAPartiallyRevertedTx(txEffect: TxEffect, jobId: string): Promise<void>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VuZGVyX3RhZ2dpbmdfc3RvcmUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL3RhZ2dpbmdfc3RvcmUvc2VuZGVyX3RhZ2dpbmdfc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQWlCLE1BQU0saUJBQWlCLENBQUM7QUFDeEUsT0FBTyxFQUFFLGdCQUFnQixFQUFhLEtBQUssaUJBQWlCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUN6RixPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRXBELE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLDBDQUEwQyxDQUFDO0FBTTVFOzs7O0dBSUc7QUFDSCxxQkFBYSxrQkFBbUIsWUFBVyxXQUFXOztJQUNwRCxRQUFRLENBQUMsU0FBUyxvQkFBb0I7SUE0QnRDLFlBQVksS0FBSyxFQUFFLGlCQUFpQixFQVFuQztJQTRDRDs7OztPQUlHO0lBQ0csTUFBTSxDQUFDLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQW9CekM7SUFFRCxhQUFhLENBQUMsS0FBSyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBSTFDO0lBRUQ7Ozs7Ozs7Ozs7OztPQVlHO0lBQ0gsbUJBQW1CLENBQUMsTUFBTSxFQUFFLGlCQUFpQixFQUFFLEVBQUUsTUFBTSxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FpRTdGO0lBRUQ7Ozs7Ozs7OztPQVNHO0lBQ0gsMkJBQTJCLENBQ3pCLE1BQU0sRUFBRSxnQkFBZ0IsRUFDeEIsVUFBVSxFQUFFLE1BQU0sRUFDbEIsUUFBUSxFQUFFLE1BQU0sRUFDaEIsS0FBSyxFQUFFLE1BQU0sR0FDWixPQUFPLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FRbkI7SUFFRDs7OztPQUlHO0lBQ0gscUJBQXFCLENBQUMsTUFBTSxFQUFFLGdCQUFnQixFQUFFLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUMsQ0FFMUY7SUFFRDs7Ozs7T0FLRztJQUNILGdCQUFnQixDQUFDLE1BQU0sRUFBRSxnQkFBZ0IsRUFBRSxLQUFLLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLENBaUJyRjtJQUVEOztPQUVHO0lBQ0gsa0JBQWtCLENBQUMsUUFBUSxFQUFFLE1BQU0sRUFBRSxFQUFFLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQTJDbkU7SUE0Q0Q7OztPQUdHO0lBQ0csc0JBQXNCLENBQUMsUUFBUSxFQUFFLE1BQU0sRUFBRSxFQUFFLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQXNEN0U7SUFFRDs7Ozs7OztPQU9HO0lBQ0csNENBQTRDLENBQUMsUUFBUSxFQUFFLFFBQVEsRUFBRSxLQUFLLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FnRG5HO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,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

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,EAAE,gBAAgB,EAAa,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACzF,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,gBAAgB,EACxB,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,gBAAgB,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAE1F;IAED;;;;;OAKG;IACH,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAiBrF;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"}
+{"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,gBAAgB,EAAa,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACzF,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;;;;;;;;;;;;;OAaG;IACH,mBAAmB,CAAC,MAAM,EAAE,iBAAiB,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE7F;IAED;;;;;;;;;;;;;OAaG;IACH,mBAAmB,CAAC,MAAM,EAAE,iBAAiB,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE7F;IA6FD;;;;;;;;;OASG;IACH,2BAA2B,CACzB,MAAM,EAAE,gBAAgB,EACxB,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,gBAAgB,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAE1F;IAED;;;;;OAKG;IACH,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAiBrF;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

@@ -100,10 +100,11 @@ import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.
         return Promise.resolve();
     }
     /**
-   * Stores pending index ranges.
+   * Stores pending index ranges, rejecting any range that disagrees with an already-stored one.
    * @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.
+   * ranges already stored from previous syncs. If the ranges differ, it throws an error as that indicates a bug in
+   * callers that record indexes at prove time. Discovery from onchain logs must use `mergePendingIndexes` instead.
    * @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.
@@ -112,6 +113,25 @@ import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.
    * @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) {
+        return this.#storePendingIndexes(ranges, txHash, jobId, false);
+    }
+    /**
+   * Stores pending index ranges, widening an existing entry for the same (secret, txHash) pair to the union of the
+   * stored and incoming ranges instead of throwing on a mismatch. Discovery from onchain logs needs this: it may see
+   * only the surviving (non-revertible phase) sub-range of a partially reverted tx recorded at prove time (the
+   * finalized receipt step of the sync resolves that difference), or indexes beyond a partially discovered entry
+   * when a tx from another PXE straddles a sync window boundary. Callers that record indexes at prove time must use
+   * `storePendingIndexes` instead, so that a range disagreement surfaces as a bug rather than being absorbed.
+   * @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 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.
+   */ mergePendingIndexes(ranges, txHash, jobId) {
+        return this.#storePendingIndexes(ranges, txHash, jobId, true);
+    }
+    #storePendingIndexes(ranges, txHash, jobId, mergeExisting) {
         if (ranges.length === 0) {
             return Promise.resolve();
         }
@@ -144,21 +164,38 @@ import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/constants.
                 }
                 // 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}]`);
-                    }
-                // Exact duplicate — skip
-                } else {
-                    this.#writePendingIndexes(jobId, secretStr, [
+                let updatedPending;
+                if (!existingEntry) {
+                    updatedPending = [
                         ...pendingData,
                         {
                             lowestIndex: range.lowestIndex,
                             highestIndex: range.highestIndex,
                             txHash: txHashStr
                         }
-                    ]);
+                    ];
+                } else if (mergeExisting) {
+                    // Widen the entry to the union of both ranges, never shrink it: replacing would drop prove-time
+                    // indexes the chain doesn't show (partially reverted tx), and skipping would drop onchain indexes
+                    // discovered in a later sync window (tx straddling the window boundary).
+                    const lowestIndex = Math.min(existingEntry.lowestIndex, range.lowestIndex);
+                    const highestIndex = Math.max(existingEntry.highestIndex, range.highestIndex);
+                    if (lowestIndex !== existingEntry.lowestIndex || highestIndex !== existingEntry.highestIndex) {
+                        updatedPending = pendingData.map((entry)=>entry === existingEntry ? {
+                                lowestIndex,
+                                highestIndex,
+                                txHash: entry.txHash
+                            } : entry);
+                    }
+                } else if (existingEntry.lowestIndex !== range.lowestIndex || existingEntry.highestIndex !== range.highestIndex) {
+                    // Different ranges for the same (secret, txHash) indicate a bug in callers that record indexes at prove
+                    // time.
+                    throw new Error(`Conflicting range for secret ${secretStr} and txHash ${txHashStr}: ` + `existing [${existingEntry.lowestIndex}, ${existingEntry.highestIndex}] vs ` + `new [${range.lowestIndex}, ${range.highestIndex}]`);
+                }
+                // Remaining cases (a merge whose union equals the stored range, or an identical range without
+                // mergeExisting): duplicate evidence, nothing to write.
+                if (updatedPending) {
+                    this.#writePendingIndexes(jobId, secretStr, updatedPending);
                 }
             }
         });

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

@@ -1,6 +1,15 @@
 import { Point } from '@aztec/foundation/curves/grumpkin';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
+/**
+ * The kinds of shared secret an entry can hold.
+ */
+export type SharedSecretKind = 'arbitrary-secret' | 'handshake';
+/** A shared secret registered for a recipient, with the kind that determines which tag streams it backs. */
+export type SharedSecret = {
+    kind: SharedSecretKind;
+    secret: Point;
+};
 /**
  * Stores the sources from which directional app tagging secrets are derived during recipient log synchronization.
  *
@@ -11,7 +20,8 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
  * - Pre-shared tagging secrets: shared secret points registered directly, bypassing ECDH. These are scoped to a
  *   specific recipient, since the derivation of the directional app tagging secret does not require any secret
  *   recipient data: given the original secret anyone can derive a recipient's app-siloed directional tagging secret,
- *   and so these must not be reused to preserve privacy.
+ *   and so these must not be reused across recipients to preserve privacy. Each carries the {@link SharedSecretKind}
+ *   it was registered through, which determines the tag streams it is scanned under.
  */
 export declare class TaggingSecretSourcesStore {
     #private;
@@ -23,18 +33,19 @@ export declare class TaggingSecretSourcesStore {
      * Registers a pre-shared tagging secret scoped to a recipient.
      * @returns true if the secret was newly added, false if it was already registered for that recipient.
      */
-    addSharedSecret(recipient: AztecAddress, secret: Point): Promise<boolean>;
+    addSharedSecret(recipient: AztecAddress, kind: SharedSecretKind, secret: Point): Promise<boolean>;
     /** Returns the pre-shared tagging secrets registered for a given recipient. */
-    getSharedSecretsForRecipient(recipient: AztecAddress): Promise<Point[]>;
+    getSharedSecretsForRecipient(recipient: AztecAddress): Promise<SharedSecret[]>;
     /** Returns every registered pre-shared tagging secret, each paired with the recipient it is scoped to. */
     getAllSharedSecrets(): Promise<{
         recipient: AztecAddress;
+        kind: SharedSecretKind;
         secret: Point;
     }[]>;
     /**
-     * Removes a pre-shared tagging secret scoped to a recipient.
+     * Removes a pre-shared tagging secret scoped to a recipient. Both the secret and its kind must match.
      * @returns true if the secret was registered and removed, false if it was not registered for that recipient.
      */
-    removeSharedSecret(recipient: AztecAddress, secret: Point): Promise<boolean>;
+    removeSharedSecret(recipient: AztecAddress, kind: SharedSecretKind, secret: Point): Promise<boolean>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFnZ2luZ19zZWNyZXRfc291cmNlc19zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0b3JhZ2UvdGFnZ2luZ19zdG9yZS90YWdnaW5nX3NlY3JldF9zb3VyY2VzX3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUUxRCxPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBcUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM1RixPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFFM0Q7Ozs7Ozs7Ozs7O0dBV0c7QUFDSCxxQkFBYSx5QkFBeUI7O0lBS3BDLFlBQVksS0FBSyxFQUFFLGlCQUFpQixFQUtuQztJQUVELFNBQVMsQ0FBQyxPQUFPLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FVakQ7SUFFRCxVQUFVLElBQUksT0FBTyxDQUFDLFlBQVksRUFBRSxDQUFDLENBSXBDO0lBRUQsWUFBWSxDQUFDLE9BQU8sRUFBRSxZQUFZLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQVVwRDtJQUVEOzs7T0FHRztJQUNILGVBQWUsQ0FBQyxTQUFTLEVBQUUsWUFBWSxFQUFFLE1BQU0sRUFBRSxLQUFLLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQWN4RTtJQUVELCtFQUErRTtJQUMvRSw0QkFBNEIsQ0FBQyxTQUFTLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxLQUFLLEVBQUUsQ0FBQyxDQU10RTtJQUVELDBHQUEwRztJQUMxRyxtQkFBbUIsSUFBSSxPQUFPLENBQUM7UUFBRSxTQUFTLEVBQUUsWUFBWSxDQUFDO1FBQUMsTUFBTSxFQUFFLEtBQUssQ0FBQTtLQUFFLEVBQUUsQ0FBQyxDQVEzRTtJQUVEOzs7T0FHRztJQUNILGtCQUFrQixDQUFDLFNBQVMsRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLEtBQUssR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBWTNFO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFnZ2luZ19zZWNyZXRfc291cmNlc19zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0b3JhZ2UvdGFnZ2luZ19zdG9yZS90YWdnaW5nX3NlY3JldF9zb3VyY2VzX3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQztBQUUxRCxPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBcUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM1RixPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFFM0Q7O0dBRUc7QUFDSCxNQUFNLE1BQU0sZ0JBQWdCLEdBQUcsa0JBQWtCLEdBQUcsV0FBVyxDQUFDO0FBRWhFLDRHQUE0RztBQUM1RyxNQUFNLE1BQU0sWUFBWSxHQUFHO0lBQUUsSUFBSSxFQUFFLGdCQUFnQixDQUFDO0lBQUMsTUFBTSxFQUFFLEtBQUssQ0FBQTtDQUFFLENBQUM7QUFFckU7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gscUJBQWEseUJBQXlCOztJQUtwQyxZQUFZLEtBQUssRUFBRSxpQkFBaUIsRUFLbkM7SUFFRCxTQUFTLENBQUMsT0FBTyxFQUFFLFlBQVksR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBVWpEO0lBRUQsVUFBVSxJQUFJLE9BQU8sQ0FBQyxZQUFZLEVBQUUsQ0FBQyxDQUlwQztJQUVELFlBQVksQ0FBQyxPQUFPLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FVcEQ7SUFFRDs7O09BR0c7SUFDSCxlQUFlLENBQUMsU0FBUyxFQUFFLFlBQVksRUFBRSxJQUFJLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxFQUFFLEtBQUssR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBbUJoRztJQUVELCtFQUErRTtJQUMvRSw0QkFBNEIsQ0FBQyxTQUFTLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxZQUFZLEVBQUUsQ0FBQyxDQU03RTtJQUVELDBHQUEwRztJQUMxRyxtQkFBbUIsSUFBSSxPQUFPLENBQUM7UUFBRSxTQUFTLEVBQUUsWUFBWSxDQUFDO1FBQUMsSUFBSSxFQUFFLGdCQUFnQixDQUFDO1FBQUMsTUFBTSxFQUFFLEtBQUssQ0FBQTtLQUFFLEVBQUUsQ0FBQyxDQVFuRztJQUVEOzs7T0FHRztJQUNILGtCQUFrQixDQUFDLFNBQVMsRUFBRSxZQUFZLEVBQUUsSUFBSSxFQUFFLGdCQUFnQixFQUFFLE1BQU0sRUFBRSxLQUFLLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQVluRztDQUNGIn0=

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

@@ -1 +1 @@
-{"version":3,"file":"tagging_secret_sources_store.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_store/tagging_secret_sources_store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAE1D,OAAO,KAAK,EAAE,iBAAiB,EAAqC,MAAM,iBAAiB,CAAC;AAC5F,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D;;;;;;;;;;;GAWG;AACH,qBAAa,yBAAyB;;IAKpC,YAAY,KAAK,EAAE,iBAAiB,EAKnC;IAED,SAAS,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAUjD;IAED,UAAU,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAIpC;IAED,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAUpD;IAED;;;OAGG;IACH,eAAe,CAAC,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAcxE;IAED,+EAA+E;IAC/E,4BAA4B,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAMtE;IAED,0GAA0G;IAC1G,mBAAmB,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,YAAY,CAAC;QAAC,MAAM,EAAE,KAAK,CAAA;KAAE,EAAE,CAAC,CAQ3E;IAED;;;OAGG;IACH,kBAAkB,CAAC,SAAS,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAY3E;CACF"}
+{"version":3,"file":"tagging_secret_sources_store.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_store/tagging_secret_sources_store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAE1D,OAAO,KAAK,EAAE,iBAAiB,EAAqC,MAAM,iBAAiB,CAAC;AAC5F,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,kBAAkB,GAAG,WAAW,CAAC;AAEhE,4GAA4G;AAC5G,MAAM,MAAM,YAAY,GAAG;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,KAAK,CAAA;CAAE,CAAC;AAErE;;;;;;;;;;;;GAYG;AACH,qBAAa,yBAAyB;;IAKpC,YAAY,KAAK,EAAE,iBAAiB,EAKnC;IAED,SAAS,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAUjD;IAED,UAAU,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAIpC;IAED,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAUpD;IAED;;;OAGG;IACH,eAAe,CAAC,SAAS,EAAE,YAAY,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAmBhG;IAED,+EAA+E;IAC/E,4BAA4B,CAAC,SAAS,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAM7E;IAED,0GAA0G;IAC1G,mBAAmB,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,YAAY,CAAC;QAAC,IAAI,EAAE,gBAAgB,CAAC;QAAC,MAAM,EAAE,KAAK,CAAA;KAAE,EAAE,CAAC,CAQnG;IAED;;;OAGG;IACH,kBAAkB,CAAC,SAAS,EAAE,YAAY,EAAE,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAYnG;CACF"}

package/dest/storage/tagging_store/tagging_secret_sources_store.js

@@ -11,7 +11,8 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
  * - Pre-shared tagging secrets: shared secret points registered directly, bypassing ECDH. These are scoped to a
  *   specific recipient, since the derivation of the directional app tagging secret does not require any secret
  *   recipient data: given the original secret anyone can derive a recipient's app-siloed directional tagging secret,
- *   and so these must not be reused to preserve privacy.
+ *   and so these must not be reused across recipients to preserve privacy. Each carries the {@link SharedSecretKind}
+ *   it was registered through, which determines the tag streams it is scanned under.
  */ export class TaggingSecretSourcesStore {
     #store;
     #senders;
@@ -47,42 +48,48 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
     /**
    * Registers a pre-shared tagging secret scoped to a recipient.
    * @returns true if the secret was newly added, false if it was already registered for that recipient.
-   */ addSharedSecret(recipient, secret) {
+   */ addSharedSecret(recipient, kind, secret) {
         return this.#store.transactionAsync(async ()=>{
             const secretStr = secret.toString();
             // MultiMap.set silently ignores an identical (key, value), so we scan to report whether this is a new secret.
             for await (const existing of this.#sharedSecretsByRecipient.getValuesAsync(recipient.toString())){
-                if (existing === secretStr) {
+                if (existing.secret === secretStr) {
+                    if (existing.kind !== kind) {
+                        throw new Error(`Secret already registered for recipient with kind '${existing.kind}', cannot re-register it as '${kind}'.`);
+                    }
                     return false;
                 }
             }
-            await this.#sharedSecretsByRecipient.set(recipient.toString(), secretStr);
+            await this.#sharedSecretsByRecipient.set(recipient.toString(), {
+                kind,
+                secret: secretStr
+            });
             return true;
         });
     }
     /** Returns the pre-shared tagging secrets registered for a given recipient. */ getSharedSecretsForRecipient(recipient) {
         return this.#store.transactionAsync(async ()=>{
-            return (await toArray(this.#sharedSecretsByRecipient.getValuesAsync(recipient.toString()))).map((secret)=>Point.fromString(secret));
+            return (await toArray(this.#sharedSecretsByRecipient.getValuesAsync(recipient.toString()))).map(deserializeSharedSecret);
         });
     }
     /** Returns every registered pre-shared tagging secret, each paired with the recipient it is scoped to. */ getAllSharedSecrets() {
         return this.#store.transactionAsync(async ()=>{
             const entries = await toArray(this.#sharedSecretsByRecipient.entriesAsync());
-            return entries.map(([recipient, secret])=>({
+            return entries.map(([recipient, entry])=>({
                     recipient: AztecAddress.fromStringUnsafe(recipient),
-                    secret: Point.fromString(secret)
+                    ...deserializeSharedSecret(entry)
                 }));
         });
     }
     /**
-   * Removes a pre-shared tagging secret scoped to a recipient.
+   * Removes a pre-shared tagging secret scoped to a recipient. Both the secret and its kind must match.
    * @returns true if the secret was registered and removed, false if it was not registered for that recipient.
-   */ removeSharedSecret(recipient, secret) {
+   */ removeSharedSecret(recipient, kind, secret) {
         return this.#store.transactionAsync(async ()=>{
             const secretStr = secret.toString();
             for await (const existing of this.#sharedSecretsByRecipient.getValuesAsync(recipient.toString())){
-                if (existing === secretStr) {
-                    await this.#sharedSecretsByRecipient.deleteValue(recipient.toString(), secretStr);
+                if (existing.kind === kind && existing.secret === secretStr) {
+                    await this.#sharedSecretsByRecipient.deleteValue(recipient.toString(), existing);
                     return true;
                 }
             }
@@ -90,3 +97,9 @@ import { AztecAddress } from '@aztec/stdlib/aztec-address';
         });
     }
 }
+function deserializeSharedSecret(entry) {
+    return {
+        kind: entry.kind,
+        secret: Point.fromString(entry.secret)
+    };
+}

package/dest/tagging/constants.d.ts

@@ -1,2 +1,2 @@
-export declare const UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN = 20;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGFnZ2luZy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBU0EsZUFBTyxNQUFNLHNDQUFzQyxLQUFLLENBQUMifQ==
+export declare const UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN: number;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGFnZ2luZy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBbUJBLGVBQU8sTUFBTSxzQ0FBc0MsUUFBK0IsQ0FBQyJ9

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

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/tagging/constants.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,sCAAsC,KAAK,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/tagging/constants.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,sCAAsC,QAA+B,CAAC"}

package/dest/tagging/constants.js

@@ -1,10 +1,19 @@
-// This window has to be as large as the largest expected number of logs emitted in a tx for a given directional app
-// tagging secret. If we get more tag indexes consumed than this window, an error is thrown in `PXE::proveTx` function.
-// This is set to a larger value than MAX_PRIVATE_LOGS_PER_TX (currently 64) because there could be more than
-// MAX_PRIVATE_LOGS_PER_TX indexes consumed in case the logs are squashed. This happens when the log contains a note
-// and the note is nullified in the same tx.
+import { MAX_PRIVATE_LOGS_PER_TX } from '@aztec/constants';
+// This window bounds how far a sender's next tag index for a directional app tagging secret can run ahead of that
+// secret's highest finalized index before `PXE::proveTx` throws.
 //
-// Having a large window significantly slowed down `e2e_l1_with_wall_time` test as there we perform sync for more than
-// 1000 secrets. For this reason we set it to a relatively low value of 20. 20 should be sufficient for all the use
-// cases.
-export const UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN = 20;
+// MAX_PRIVATE_LOGS_PER_TX is a floor for ordinary transaction patterns: the private kernel accumulates every
+// surviving private log into a single tx-wide array of exactly this size, so a fresh secret's very first
+// ordinary tx can consume that many indexes before anything is finalized.
+//
+// The +20 on top is headroom for multiple pending ordinary txs to the same counterparty stacking up
+// before the first one is observed as mined. Only a run of near-MAX_PRIVATE_LOGS_PER_TX txs back-to-back would
+// exhaust this; ordinary transfers use far fewer logs per tx, so the same margin covers many more of those. Keep the
+// margin additive rather than another multiple of the floor. A larger window also makes recipient-side sync more
+// expensive, since discovery has to probe ahead of the last finalized index for every active secret.
+//
+// TODO(F-783): MAX_PRIVATE_LOGS_PER_TX is not a hard ceiling in general — a tx that creates and nullifies (squashes)
+// many notes/logs to the same secret can drive that secret's raw tag index arbitrarily higher, since indexes are
+// reserved at log emission time, before squashing is decided, and the kernel's reset/squash loop is not bounded by
+// MAX_PRIVATE_LOGS_PER_TX. No fixed window value closes that gap.
+export const UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN = MAX_PRIVATE_LOGS_PER_TX + 20;

package/dest/tagging/sender_sync/sync_sender_tagging_indexes.js

@@ -48,7 +48,7 @@ import { loadAndStoreNewTaggingIndexes } from './utils/load_and_store_new_taggin
             break;
         }
         // Receipts for pending tx hashes that the logs query just surfaced still need a sequential follow-up call.
-        // `storePendingIndexes` is idempotent on (secret, txHash), so a re-discovered hash stays classified as known
+        // `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()));

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

@@ -16,4 +16,4 @@ import type { SenderTaggingStore } from '../../../storage/tagging_store/sender_t
  * preserving way.
  */
 export declare function loadAndStoreNewTaggingIndexes(extendedSecret: AppTaggingSecret, start: number, end: number, aztecNode: AztecNode, taggingStore: SenderTaggingStore, anchorBlockHash: BlockHash, jobId: string): Promise<void>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvbG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNyRCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEVBQUUsS0FBSyxnQkFBZ0IsRUFBYSxNQUFNLG9CQUFvQixDQUFDO0FBR3RFLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFHakc7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsd0JBQXNCLDZCQUE2QixDQUNqRCxjQUFjLEVBQUUsZ0JBQWdCLEVBQ2hDLEtBQUssRUFBRSxNQUFNLEVBQ2IsR0FBRyxFQUFFLE1BQU0sRUFDWCxTQUFTLEVBQUUsU0FBUyxFQUNwQixZQUFZLEVBQUUsa0JBQWtCLEVBQ2hDLGVBQWUsRUFBRSxTQUFTLEVBQzFCLEtBQUssRUFBRSxNQUFNLGlCQWdCZCJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvbG9hZF9hbmRfc3RvcmVfbmV3X3RhZ2dpbmdfaW5kZXhlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNyRCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEVBQUUsS0FBSyxnQkFBZ0IsRUFBYSxNQUFNLG9CQUFvQixDQUFDO0FBR3RFLE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFHakc7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsd0JBQXNCLDZCQUE2QixDQUNqRCxjQUFjLEVBQUUsZ0JBQWdCLEVBQ2hDLEtBQUssRUFBRSxNQUFNLEVBQ2IsR0FBRyxFQUFFLE1BQU0sRUFDWCxTQUFTLEVBQUUsU0FBUyxFQUNwQixZQUFZLEVBQUUsa0JBQWtCLEVBQ2hDLGVBQWUsRUFBRSxTQUFTLEVBQzFCLEtBQUssRUFBRSxNQUFNLGlCQW9CZCJ9

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

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

@@ -23,7 +23,11 @@ import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
         })));
     const txsForTags = await getTxsContainingTags(siloedTagsForWindow, aztecNode, anchorBlockHash);
     const txIndexesMap = getTxIndexesMap(txsForTags, start, siloedTagsForWindow.length);
-    // Now we iterate over the map, construct the tagging index ranges and store them in the db.
+    // Now we iterate over the map, construct the tagging index ranges and store them in the db. A tx already tracked
+    // in the store is merged rather than range-checked: if this PXE sent the tx and it partially reverted, the chain
+    // only shows the surviving sub-range of the prove-time entry (the finalized receipt step of the sync owns
+    // resolving that difference), and a tx from another PXE may straddle a sync window boundary, in which case the
+    // entry is widened so the next index choice covers the full onchain range.
     for (const [txHashStr, indexes] of txIndexesMap.entries()){
         const txHash = TxHash.fromString(txHashStr);
         const ranges = [
@@ -33,7 +37,7 @@ import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
                 highestIndex: Math.max(...indexes)
             }
         ];
-        await taggingStore.storePendingIndexes(ranges, txHash, jobId);
+        await taggingStore.mergePendingIndexes(ranges, txHash, jobId);
     }
 }
 // Returns txs that used the given tags. A tag might have been used in multiple txs and for this reason we return

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/pxe",
-  "version": "5.0.0-rc.2",
+  "version": "5.0.1",
   "type": "module",
   "typedocOptions": {
     "entryPoints": [
@@ -71,20 +71,20 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb-prover": "5.0.0-rc.2",
-    "@aztec/bb.js": "5.0.0-rc.2",
-    "@aztec/builder": "5.0.0-rc.2",
-    "@aztec/constants": "5.0.0-rc.2",
-    "@aztec/ethereum": "5.0.0-rc.2",
-    "@aztec/foundation": "5.0.0-rc.2",
-    "@aztec/key-store": "5.0.0-rc.2",
-    "@aztec/kv-store": "5.0.0-rc.2",
-    "@aztec/noir-protocol-circuits-types": "5.0.0-rc.2",
-    "@aztec/noir-types": "5.0.0-rc.2",
-    "@aztec/protocol-contracts": "5.0.0-rc.2",
-    "@aztec/simulator": "5.0.0-rc.2",
-    "@aztec/standard-contracts": "5.0.0-rc.2",
-    "@aztec/stdlib": "5.0.0-rc.2",
+    "@aztec/bb-prover": "5.0.1",
+    "@aztec/bb.js": "5.0.1",
+    "@aztec/builder": "5.0.1",
+    "@aztec/constants": "5.0.1",
+    "@aztec/ethereum": "5.0.1",
+    "@aztec/foundation": "5.0.1",
+    "@aztec/key-store": "5.0.1",
+    "@aztec/kv-store": "5.0.1",
+    "@aztec/noir-protocol-circuits-types": "5.0.1",
+    "@aztec/noir-types": "5.0.1",
+    "@aztec/protocol-contracts": "5.0.1",
+    "@aztec/simulator": "5.0.1",
+    "@aztec/standard-contracts": "5.0.1",
+    "@aztec/stdlib": "5.0.1",
     "koa": "^2.16.1",
     "koa-router": "^13.1.1",
     "lodash.omit": "^4.5.0",
@@ -93,8 +93,8 @@
     "viem": "npm:@aztec/viem@2.38.2"
   },
   "devDependencies": {
-    "@aztec/noir-test-contracts.js": "5.0.0-rc.2",
-    "@aztec/world-state": "5.0.0-rc.2",
+    "@aztec/noir-test-contracts.js": "5.0.1",
+    "@aztec/world-state": "5.0.1",
     "@jest/globals": "^30.0.0",
     "@types/jest": "^30.0.0",
     "@types/lodash.omit": "^4.5.7",

package/src/block_synchronizer/block_synchronizer.ts

@@ -8,7 +8,8 @@ import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 
 import type { BlockSynchronizerConfig } from '../config/index.js';
-import type { ContractSyncService } from '../contract_sync/contract_sync_service.js';
+import type { ContractClassService } from '../contract/contract_class_service.js';
+import type { ContractSyncService } from '../contract/contract_sync_service.js';
 import type { AnchorBlockStore } from '../storage/anchor_block_store/index.js';
 import type { FactStore } from '../storage/fact_store/fact_store.js';
 import type { NoteStore } from '../storage/note_store/index.js';
@@ -35,6 +36,7 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     private readonly factStore: FactStore,
     private readonly l2TipsStore: L2TipsKVStore,
     private readonly contractSyncService: ContractSyncService,
+    private readonly contractClassService: ContractClassService,
     private readonly config: Partial<BlockSynchronizerConfig> = {},
     bindings?: LoggerBindings,
   ) {
@@ -177,6 +179,12 @@ export class BlockSynchronizer implements L2BlockStreamEventHandler {
     // Therefore, we clear the contract synchronization cache here such that the sync is re-triggered upon new
     // execution.
     this.contractSyncService.wipe();
+
+    // The contract class service keeps a per-block cache - since updating our anchor means it is very unlikely we'd
+    // ever re-simulate at past anchors, we wipe its cache to prevent runaway memory growth on very long-lived PXE
+    // instances.
+    this.contractClassService.wipe();
+
     this.log.verbose(`Updated pxe last block to ${blockHeader.getBlockNumber()}`, blockHeader.toInspect());
     await this.anchorBlockStore.setHeader(blockHeader);
   }