@aztec/pxe 0.0.1-commit.3100065 → 0.0.1-commit.321f6a9

package/dest/storage/fact_store/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/fact_store/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAClG,YAAY,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EACL,gBAAgB,EAChB,wBAAwB,EACxB,uBAAuB,EACvB,qBAAqB,EACrB,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EACxB,KAAK,6BAA6B,GACnC,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/fact_store/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAClG,YAAY,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EACL,gBAAgB,EAChB,wBAAwB,EACxB,0BAA0B,EAC1B,uBAAuB,EACvB,qBAAqB,EACrB,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,mBAAmB,EACxB,KAAK,6BAA6B,GACnC,MAAM,mBAAmB,CAAC"}

package/dest/storage/fact_store/index.js

@@ -1,4 +1,4 @@
 export { FactStore } from './fact_store.js';
 export { FactService } from './fact_service.js';
 export { FactCollectionKey, FactCollectionTypeKey } from './fact_store_keys.js';
-export { OriginBlockState, classifyOriginBlockState, anchoredTipBlockNumbers, toFactWithOriginState } from './origin_state.js';
+export { OriginBlockState, classifyOriginBlockState, originBlockStateFromNumber, anchoredTipBlockNumbers, toFactWithOriginState } from './origin_state.js';

package/dest/storage/fact_store/origin_state.d.ts

@@ -18,6 +18,8 @@ export declare enum OriginBlockState {
     Proven = 2,
     Finalized = 3
 }
+/** Parses a numeric origin-block-state discriminant, rejecting unknown values. */
+export declare function originBlockStateFromNumber(value: number): OriginBlockState;
 /** The two chain-tip block numbers needed to classify an origin block (`finalized <= proven` always holds). */
 export type TipBlockNumbers = {
     provenBlockNumber: number;
@@ -54,4 +56,4 @@ export type FactCollectionWithOriginState = {
 export declare function classifyOriginBlockState(blockNumber: number, tips: TipBlockNumbers): OriginBlockState;
 /** Enriches a stored fact with the chain state of its origin block (when retractable). */
 export declare function toFactWithOriginState(fact: Fact, tips: TipBlockNumbers): FactWithOriginState;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3JpZ2luX3N0YXRlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3RvcmFnZS9mYWN0X3N0b3JlL29yaWdpbl9zdGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN6RCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVsRCxPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBRSxXQUFXLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUMzRSxPQUFPLEtBQUssRUFBRSxJQUFJLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUU3Qzs7Ozs7Ozs7OztHQVVHO0FBQ0gsb0JBQVksZ0JBQWdCO0lBQzFCLE9BQU8sSUFBSTtJQUNYLE1BQU0sSUFBSTtJQUNWLFNBQVMsSUFBSTtDQUNkO0FBRUQsK0dBQStHO0FBQy9HLE1BQU0sTUFBTSxlQUFlLEdBQUc7SUFBRSxpQkFBaUIsRUFBRSxNQUFNLENBQUM7SUFBQyxvQkFBb0IsRUFBRSxNQUFNLENBQUE7Q0FBRSxDQUFDO0FBRTFGOzs7Ozs7O0dBT0c7QUFDSCx3QkFBZ0IsdUJBQXVCLENBQUMsSUFBSSxFQUFFLE1BQU0sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLEdBQUcsZUFBZSxDQUtoRztBQUVELHlGQUF5RjtBQUN6RixNQUFNLE1BQU0scUJBQXFCLEdBQUcsV0FBVyxHQUFHO0lBQUUsVUFBVSxFQUFFLGdCQUFnQixDQUFBO0NBQUUsQ0FBQztBQUVuRixzR0FBc0c7QUFDdEcsTUFBTSxNQUFNLG1CQUFtQixHQUFHO0lBQUUsVUFBVSxFQUFFLEVBQUUsQ0FBQztJQUFDLE9BQU8sRUFBRSxFQUFFLEVBQUUsQ0FBQztJQUFDLFdBQVcsRUFBRSxxQkFBcUIsR0FBRyxTQUFTLENBQUE7Q0FBRSxDQUFDO0FBRXBILDhEQUE4RDtBQUM5RCxNQUFNLE1BQU0sNkJBQTZCLEdBQUc7SUFBRSxHQUFHLEVBQUUsaUJBQWlCLENBQUM7SUFBQyxLQUFLLEVBQUUsbUJBQW1CLEVBQUUsQ0FBQTtDQUFFLENBQUM7QUFFckc7OztHQUdHO0FBQ0gsd0JBQWdCLHdCQUF3QixDQUFDLFdBQVcsRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLGVBQWUsR0FBRyxnQkFBZ0IsQ0FRckc7QUFFRCwwRkFBMEY7QUFDMUYsd0JBQWdCLHFCQUFxQixDQUFDLElBQUksRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLGVBQWUsR0FBRyxtQkFBbUIsQ0FTNUYifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3JpZ2luX3N0YXRlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3RvcmFnZS9mYWN0X3N0b3JlL29yaWdpbl9zdGF0ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN6RCxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVsRCxPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBRSxXQUFXLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUMzRSxPQUFPLEtBQUssRUFBRSxJQUFJLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUU3Qzs7Ozs7Ozs7OztHQVVHO0FBQ0gsb0JBQVksZ0JBQWdCO0lBQzFCLE9BQU8sSUFBSTtJQUNYLE1BQU0sSUFBSTtJQUNWLFNBQVMsSUFBSTtDQUNkO0FBRUQsa0ZBQWtGO0FBQ2xGLHdCQUFnQiwwQkFBMEIsQ0FBQyxLQUFLLEVBQUUsTUFBTSxHQUFHLGdCQUFnQixDQU0xRTtBQUVELCtHQUErRztBQUMvRyxNQUFNLE1BQU0sZUFBZSxHQUFHO0lBQUUsaUJBQWlCLEVBQUUsTUFBTSxDQUFDO0lBQUMsb0JBQW9CLEVBQUUsTUFBTSxDQUFBO0NBQUUsQ0FBQztBQUUxRjs7Ozs7OztHQU9HO0FBQ0gsd0JBQWdCLHVCQUF1QixDQUFDLElBQUksRUFBRSxNQUFNLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxHQUFHLGVBQWUsQ0FLaEc7QUFFRCx5RkFBeUY7QUFDekYsTUFBTSxNQUFNLHFCQUFxQixHQUFHLFdBQVcsR0FBRztJQUFFLFVBQVUsRUFBRSxnQkFBZ0IsQ0FBQTtDQUFFLENBQUM7QUFFbkYsc0dBQXNHO0FBQ3RHLE1BQU0sTUFBTSxtQkFBbUIsR0FBRztJQUFFLFVBQVUsRUFBRSxFQUFFLENBQUM7SUFBQyxPQUFPLEVBQUUsRUFBRSxFQUFFLENBQUM7SUFBQyxXQUFXLEVBQUUscUJBQXFCLEdBQUcsU0FBUyxDQUFBO0NBQUUsQ0FBQztBQUVwSCw4REFBOEQ7QUFDOUQsTUFBTSxNQUFNLDZCQUE2QixHQUFHO0lBQUUsR0FBRyxFQUFFLGlCQUFpQixDQUFDO0lBQUMsS0FBSyxFQUFFLG1CQUFtQixFQUFFLENBQUE7Q0FBRSxDQUFDO0FBRXJHOzs7R0FHRztBQUNILHdCQUFnQix3QkFBd0IsQ0FBQyxXQUFXLEVBQUUsTUFBTSxFQUFFLElBQUksRUFBRSxlQUFlLEdBQUcsZ0JBQWdCLENBUXJHO0FBRUQsMEZBQTBGO0FBQzFGLHdCQUFnQixxQkFBcUIsQ0FBQyxJQUFJLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxlQUFlLEdBQUcsbUJBQW1CLENBUzVGIn0=

package/dest/storage/fact_store/origin_state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"origin_state.d.ts","sourceRoot":"","sources":["../../../src/storage/fact_store/origin_state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC3E,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAE7C;;;;;;;;;;GAUG;AACH,oBAAY,gBAAgB;IAC1B,OAAO,IAAI;IACX,MAAM,IAAI;IACV,SAAS,IAAI;CACd;AAED,+GAA+G;AAC/G,MAAM,MAAM,eAAe,GAAG;IAAE,iBAAiB,EAAE,MAAM,CAAC;IAAC,oBAAoB,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1F;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,GAAG,eAAe,CAKhG;AAED,yFAAyF;AACzF,MAAM,MAAM,qBAAqB,GAAG,WAAW,GAAG;IAAE,UAAU,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAEnF,sGAAsG;AACtG,MAAM,MAAM,mBAAmB,GAAG;IAAE,UAAU,EAAE,EAAE,CAAC;IAAC,OAAO,EAAE,EAAE,EAAE,CAAC;IAAC,WAAW,EAAE,qBAAqB,GAAG,SAAS,CAAA;CAAE,CAAC;AAEpH,8DAA8D;AAC9D,MAAM,MAAM,6BAA6B,GAAG;IAAE,GAAG,EAAE,iBAAiB,CAAC;IAAC,KAAK,EAAE,mBAAmB,EAAE,CAAA;CAAE,CAAC;AAErG;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,GAAG,gBAAgB,CAQrG;AAED,0FAA0F;AAC1F,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,eAAe,GAAG,mBAAmB,CAS5F"}
+{"version":3,"file":"origin_state.d.ts","sourceRoot":"","sources":["../../../src/storage/fact_store/origin_state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC3E,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAE7C;;;;;;;;;;GAUG;AACH,oBAAY,gBAAgB;IAC1B,OAAO,IAAI;IACX,MAAM,IAAI;IACV,SAAS,IAAI;CACd;AAED,kFAAkF;AAClF,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,CAM1E;AAED,+GAA+G;AAC/G,MAAM,MAAM,eAAe,GAAG;IAAE,iBAAiB,EAAE,MAAM,CAAC;IAAC,oBAAoB,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1F;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,GAAG,eAAe,CAKhG;AAED,yFAAyF;AACzF,MAAM,MAAM,qBAAqB,GAAG,WAAW,GAAG;IAAE,UAAU,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAEnF,sGAAsG;AACtG,MAAM,MAAM,mBAAmB,GAAG;IAAE,UAAU,EAAE,EAAE,CAAC;IAAC,OAAO,EAAE,EAAE,EAAE,CAAC;IAAC,WAAW,EAAE,qBAAqB,GAAG,SAAS,CAAA;CAAE,CAAC;AAEpH,8DAA8D;AAC9D,MAAM,MAAM,6BAA6B,GAAG;IAAE,GAAG,EAAE,iBAAiB,CAAC;IAAC,KAAK,EAAE,mBAAmB,EAAE,CAAA;CAAE,CAAC;AAErG;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,GAAG,gBAAgB,CAQrG;AAED,0FAA0F;AAC1F,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,eAAe,GAAG,mBAAmB,CAS5F"}

package/dest/storage/fact_store/origin_state.js

@@ -14,6 +14,13 @@
     OriginBlockState[OriginBlockState["Finalized"] = 3] = "Finalized";
     return OriginBlockState;
 }({});
+/** Parses a numeric origin-block-state discriminant, rejecting unknown values. */ export function originBlockStateFromNumber(value) {
+    if (!(value in OriginBlockState)) {
+        const validNames = Object.keys(OriginBlockState).filter((k)=>isNaN(Number(k)));
+        throw new Error(`Invalid OriginBlockState value ${value}, expected one of ${validNames.join(', ')}`);
+    }
+    return value;
+}
 /**
  * Projects the live chain tips to the block numbers used for classification, capped at the anchor block.
  *

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/tagging/constants.d.ts

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

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

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

package/dest/tagging/constants.js

@@ -17,3 +17,12 @@ import { MAX_PRIVATE_LOGS_PER_TX } from '@aztec/constants';
 // 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;
+// The number of tags probed per constrained secret in the first round.
+//
+// The probe doubles each round (2, 4, 8, ..., capped at UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN) while every probed
+// index is a hit, stopping at the first missing tag. Constrained delivery is gapless, so a single missing tag proves
+// the stream has ended: at steady state this turns a full WINDOW_LEN probe into two tags. A secret K logs behind
+// catches up in ~log2(K) round-trips while the probe is still doubling (2, 4, 8, 16, 32), but once it saturates the cap
+// and advances WINDOW_LEN tags per round, deeper catch-up is linear at ~K/WINDOW_LEN rounds. Either way it beats both
+// the full window every round and one round per log.
+export const INITIAL_CONSTRAINED_PROBE_LEN = 2;

package/dest/tagging/index.d.ts

@@ -11,8 +11,8 @@
 export { syncTaggedPrivateLogs } from './recipient_sync/sync_tagged_private_logs.js';
 export { syncSenderTaggingIndexes } from './sender_sync/sync_sender_tagging_indexes.js';
 export { persistSenderTaggingIndexRangesForTx } from './persist_sender_tagging_index_ranges.js';
-export { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from './constants.js';
+export { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN, INITIAL_CONSTRAINED_PROBE_LEN } from './constants.js';
 export { getAllPrivateLogsByTags, getAllPublicLogsByTagsFromContract } from './get_all_logs_by_tags.js';
 export { AppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';
 export { type PreTag, type TaggingIndexRange } from '@aztec/stdlib/logs';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90YWdnaW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7R0FTRztBQUVILE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBQ3JGLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBQ3hGLE9BQU8sRUFBRSxvQ0FBb0MsRUFBRSxNQUFNLDBDQUEwQyxDQUFDO0FBQ2hHLE9BQU8sRUFBRSxzQ0FBc0MsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3hFLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxrQ0FBa0MsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBR3hHLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxHQUFHLEVBQUUsU0FBUyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDdEUsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFFLEtBQUssaUJBQWlCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90YWdnaW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7R0FTRztBQUVILE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBQ3JGLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBQ3hGLE9BQU8sRUFBRSxvQ0FBb0MsRUFBRSxNQUFNLDBDQUEwQyxDQUFDO0FBQ2hHLE9BQU8sRUFBRSxzQ0FBc0MsRUFBRSw2QkFBNkIsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ3ZHLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxrQ0FBa0MsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBR3hHLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxHQUFHLEVBQUUsU0FBUyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDdEUsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFFLEtBQUssaUJBQWlCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQyJ9

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,qBAAqB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,EAAE,wBAAwB,EAAE,MAAM,8CAA8C,CAAC;AACxF,OAAO,EAAE,oCAAoC,EAAE,MAAM,0CAA0C,CAAC;AAChG,OAAO,EAAE,sCAAsC,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,EAAE,uBAAuB,EAAE,kCAAkC,EAAE,MAAM,2BAA2B,CAAC;AAGxG,OAAO,EAAE,gBAAgB,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACtE,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tagging/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,EAAE,wBAAwB,EAAE,MAAM,8CAA8C,CAAC;AACxF,OAAO,EAAE,oCAAoC,EAAE,MAAM,0CAA0C,CAAC;AAChG,OAAO,EAAE,sCAAsC,EAAE,6BAA6B,EAAE,MAAM,gBAAgB,CAAC;AACvG,OAAO,EAAE,uBAAuB,EAAE,kCAAkC,EAAE,MAAM,2BAA2B,CAAC;AAGxG,OAAO,EAAE,gBAAgB,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACtE,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC"}

package/dest/tagging/index.js

@@ -10,7 +10,7 @@
  */ export { syncTaggedPrivateLogs } from './recipient_sync/sync_tagged_private_logs.js';
 export { syncSenderTaggingIndexes } from './sender_sync/sync_sender_tagging_indexes.js';
 export { persistSenderTaggingIndexRangesForTx } from './persist_sender_tagging_index_ranges.js';
-export { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from './constants.js';
+export { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN, INITIAL_CONSTRAINED_PROBE_LEN } from './constants.js';
 export { getAllPrivateLogsByTags, getAllPublicLogsByTagsFromContract } from './get_all_logs_by_tags.js';
 // Re-export tagging-related types from stdlib
 export { AppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';

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

@@ -54,9 +54,14 @@ import type { RecipientTaggingStore } from '../../storage/tagging_store/recipien
  * - The lower bound is `highestFinalizedIndex + 1`. The `highestAgedIndex` mechanism is unnecessary because
  *   the nullifier chain prevents out-of-order index usage: no device can fill in a lower index after a higher
  *   one is already on-chain.
- * - The scan stops at the first gap in the index sequence. If all indexes in the batch have logs, the window
- *   advances. If a gap is found, the sequence has ended and no further logs exist.
- * - The upper bound is the same as unconstrained: `highestFinalizedIndex + WINDOW_LEN`.
+ * - Because the sequence is gapless, the scan stops at the first missing index: that gap proves the sequence has
+ *   ended and no further logs exist. We exploit this with a doubling first-miss probe (see
+ *   `INITIAL_CONSTRAINED_PROBE_LEN` in ../constants.ts), so a
+ *   steady-state sync with no new logs costs two tags instead of the whole window. The probe length is in-memory
+ *   state scoped to one sync call, so every sync restarts at the initial probe.
+ * - The upper bound is the same as unconstrained: `highestFinalizedIndex + WINDOW_LEN`. Advancing the probe is
+ *   decoupled from persisting the finalized index, so unfinalized logs at the top of the run are still fetched
+ *   while only the finalized prefix is persisted.
  *
  * # Batching across secrets
  *
@@ -66,4 +71,4 @@ import type { RecipientTaggingStore } from '../../storage/tagging_store/recipien
  * advanced are kept for the next iteration.
  */
 export declare function syncTaggedPrivateLogs(secrets: AppTaggingSecret[], aztecNode: AztecNode, taggingStore: RecipientTaggingStore, anchorBlockHeader: BlockHeader, finalizedBlockNumber: BlockNumber, jobId: string): Promise<LogResult[]>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luY190YWdnZWRfcHJpdmF0ZV9sb2dzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGFnZ2luZy9yZWNpcGllbnRfc3luYy9zeW5jX3RhZ2dlZF9wcml2YXRlX2xvZ3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRzlELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ2pFLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLFNBQVMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXRFLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRXBELE9BQU8sS0FBSyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFLcEc7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0E2REc7QUFDSCx3QkFBc0IscUJBQXFCLENBQ3pDLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxFQUMzQixTQUFTLEVBQUUsU0FBUyxFQUNwQixZQUFZLEVBQUUscUJBQXFCLEVBQ25DLGlCQUFpQixFQUFFLFdBQVcsRUFDOUIsb0JBQW9CLEVBQUUsV0FBVyxFQUNqQyxLQUFLLEVBQUUsTUFBTSxHQUNaLE9BQU8sQ0FBQyxTQUFTLEVBQUUsQ0FBQyxDQWlEdEIifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luY190YWdnZWRfcHJpdmF0ZV9sb2dzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdGFnZ2luZy9yZWNpcGllbnRfc3luYy9zeW5jX3RhZ2dlZF9wcml2YXRlX2xvZ3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRzlELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ2pFLE9BQU8sS0FBSyxFQUFFLGdCQUFnQixFQUFFLFNBQVMsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRXRFLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRXBELE9BQU8sS0FBSyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFLcEc7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQWtFRztBQUNILHdCQUFzQixxQkFBcUIsQ0FDekMsT0FBTyxFQUFFLGdCQUFnQixFQUFFLEVBQzNCLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLFlBQVksRUFBRSxxQkFBcUIsRUFDbkMsaUJBQWlCLEVBQUUsV0FBVyxFQUM5QixvQkFBb0IsRUFBRSxXQUFXLEVBQ2pDLEtBQUssRUFBRSxNQUFNLEdBQ1osT0FBTyxDQUFDLFNBQVMsRUFBRSxDQUFDLENBcUR0QiJ9

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

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

package/dest/tagging/recipient_sync/sync_tagged_private_logs.js

@@ -1,7 +1,7 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
 import { isDefined } from '@aztec/foundation/types';
 import { AppTaggingSecretKind, SiloedTag } from '@aztec/stdlib/logs';
-import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../constants.js';
+import { INITIAL_CONSTRAINED_PROBE_LEN, UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../constants.js';
 import { getAllPrivateLogsByTags } from '../get_all_logs_by_tags.js';
 import { findHighestIndexes } from './utils/find_highest_indexes.js';
 /**
@@ -55,9 +55,14 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
  * - The lower bound is `highestFinalizedIndex + 1`. The `highestAgedIndex` mechanism is unnecessary because
  *   the nullifier chain prevents out-of-order index usage: no device can fill in a lower index after a higher
  *   one is already on-chain.
- * - The scan stops at the first gap in the index sequence. If all indexes in the batch have logs, the window
- *   advances. If a gap is found, the sequence has ended and no further logs exist.
- * - The upper bound is the same as unconstrained: `highestFinalizedIndex + WINDOW_LEN`.
+ * - Because the sequence is gapless, the scan stops at the first missing index: that gap proves the sequence has
+ *   ended and no further logs exist. We exploit this with a doubling first-miss probe (see
+ *   `INITIAL_CONSTRAINED_PROBE_LEN` in ../constants.ts), so a
+ *   steady-state sync with no new logs costs two tags instead of the whole window. The probe length is in-memory
+ *   state scoped to one sync call, so every sync restarts at the initial probe.
+ * - The upper bound is the same as unconstrained: `highestFinalizedIndex + WINDOW_LEN`. Advancing the probe is
+ *   decoupled from persisting the finalized index, so unfinalized logs at the top of the run are still fetched
+ *   while only the finalized prefix is persisted.
  *
  * # Batching across secrets
  *
@@ -87,8 +92,7 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
             allLogs.push(...logsFoundWithSecret.map(({ log })=>log));
             // Persist new indexes. If the finalized index moved forward, the window advances
             // and we need another round for this secret.
-            const processForKind = pendingSecret.secret.kind === AppTaggingSecretKind.CONSTRAINED ? processConstrainedResults : processUnconstrainedResults;
-            return await processForKind(pendingSecret, logsFoundWithSecret, taggingStore, currentTimestamp, finalizedBlockNumber, jobId);
+            return pendingSecret.kind === AppTaggingSecretKind.CONSTRAINED ? await processConstrainedResults(pendingSecret, logsFoundWithSecret, taggingStore, currentTimestamp, finalizedBlockNumber, jobId) : await processUnconstrainedResults(pendingSecret, logsFoundWithSecret, taggingStore, currentTimestamp, finalizedBlockNumber, jobId);
         }));
         pending = nextRound.filter(isDefined);
     }
@@ -97,13 +101,29 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
 /** Reads stored indexes for each secret and computes the initial index range to query. */ function getIndexRangesForSecrets(secrets, taggingStore, jobId) {
     return Promise.all(secrets.map(async (secret)=>{
         const currentHighestFinalizedIndex = await taggingStore.getHighestFinalizedIndex(secret, jobId);
-        const highestIndexBeforeStart = secret.kind === AppTaggingSecretKind.CONSTRAINED ? currentHighestFinalizedIndex : await taggingStore.getHighestAgedIndex(secret, jobId);
-        const start = highestIndexBeforeStart === undefined ? 0 : highestIndexBeforeStart + 1;
-        const end = (currentHighestFinalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
+        const boundEnd = (currentHighestFinalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
+        if (secret.kind === AppTaggingSecretKind.CONSTRAINED) {
+            // Constrained streams are gapless and resume at the finalized index, so probe a small initial window and stop
+            // at the first missing tag instead of always fetching the full window. The probe grows each round up to the
+            // window cap.
+            const start = currentHighestFinalizedIndex === undefined ? 0 : currentHighestFinalizedIndex + 1;
+            return {
+                kind: AppTaggingSecretKind.CONSTRAINED,
+                secret,
+                start,
+                end: Math.min(boundEnd, start + INITIAL_CONSTRAINED_PROBE_LEN),
+                boundEnd,
+                probeLen: INITIAL_CONSTRAINED_PROBE_LEN
+            };
+        }
+        // Unconstrained secrets can have gaps, so they scan the whole window starting past the highest aged index.
+        const highestAgedIndex = await taggingStore.getHighestAgedIndex(secret, jobId);
+        const start = highestAgedIndex === undefined ? 0 : highestAgedIndex + 1;
         return {
+            kind: AppTaggingSecretKind.UNCONSTRAINED,
             secret,
             start,
-            end
+            end: boundEnd
         };
     }));
 }
@@ -148,30 +168,43 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
     return logsPerSecret;
 }
 /**
- * Processes fetched logs for a constrained secret. Constrained delivery guarantees contiguous index sequences,
- * so we scan from the start of the queried range and stop at the first missing index. Only `highestFinalizedIndex`
+ * Processes fetched logs for a constrained secret: persists the finalized index and advances the probe. See the
+ * "# Constrained secrets" section above for why the scan stops at the first missing index. Only `highestFinalizedIndex`
  * is tracked (no aged index).
  */ async function processConstrainedResults(pending, logsWithIndexes, taggingStore, currentTimestamp, finalizedBlockNumber, jobId) {
-    // Find where the contiguous run of indexes ends. Constrained delivery guarantees there are no logs after the
-    // first gap, so all logs in the batch are within this prefix.
+    // Find where the contiguous run of indexes ends; all logs in the batch fall within this prefix.
     const indexesWithLogs = new Set(logsWithIndexes.map((l)=>l.taggingIndex));
     let firstMissingIndex = pending.start;
     while(firstMissingIndex < pending.end && indexesWithLogs.has(firstMissingIndex)){
         firstMissingIndex++;
     }
-    // Finalize any logs before the gap. The nullifier for a constrained-delivery log is emitted in the same
-    // transaction, guaranteeing the log cannot disappear once included, so we persist the highest finalized
-    // index even when a gap stops the scan. This lets the next sync round skip already-finalized indexes.
+    // Persist the highest finalized index found. The nullifier for a constrained-delivery log is emitted in the same
+    // transaction, guaranteeing the log cannot disappear once included, so we persist even when a gap stops the scan.
+    // This lets the next sync round skip already-finalized indexes.
     const { highestFinalizedIndex } = findHighestIndexes(logsWithIndexes, currentTimestamp, finalizedBlockNumber);
     if (highestFinalizedIndex !== undefined) {
         await taggingStore.updateHighestFinalizedIndex(pending.secret, highestFinalizedIndex, jobId);
-        if (firstMissingIndex >= pending.end) {
-            return {
-                secret: pending.secret,
-                start: pending.end,
-                end: highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1
-            };
-        }
+    }
+    // Advancing the probe is decoupled from persisting the finalized index: keep scanning as long as the probe was
+    // entirely hits (no gap) and there is room before the protocol bound, even if none of those hits is finalized yet.
+    // Gating this on finalization would drop logs in unfinalized blocks, which sit at the top of the contiguous run.
+    // The bound re-anchors to any finalized index found this round.
+    const probeFullyConsumed = firstMissingIndex >= pending.end;
+    const boundEnd = highestFinalizedIndex !== undefined ? Math.max(pending.boundEnd, highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1) : pending.boundEnd;
+    // Double the probe each round, capped at the window (see INITIAL_CONSTRAINED_PROBE_LEN in ../constants.ts).
+    // The queried range is already bounded by boundEnd (a probe can never reach
+    // more than WINDOW_LEN past the finalized frontier); this cap just keeps the stored length from growing unbounded
+    // once the probe saturates the window.
+    const nextProbeLen = Math.min(pending.probeLen * 2, UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN);
+    if (probeFullyConsumed && pending.end < boundEnd) {
+        return {
+            kind: AppTaggingSecretKind.CONSTRAINED,
+            secret: pending.secret,
+            start: pending.end,
+            end: Math.min(boundEnd, pending.end + nextProbeLen),
+            boundEnd,
+            probeLen: nextProbeLen
+        };
     }
     return undefined;
 }
@@ -195,9 +228,11 @@ import { findHighestIndexes } from './utils/find_highest_indexes.js';
     await taggingStore.updateHighestFinalizedIndex(pending.secret, highestFinalizedIndex, jobId);
     // For the next iteration we want to look only at indexes for which we have not yet fetched logs while
     // ensuring that we do not look further than WINDOW_LEN ahead of the highest finalized index.
+    const end = highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
     return {
+        kind: AppTaggingSecretKind.UNCONSTRAINED,
         secret: pending.secret,
         start: pending.end,
-        end: highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1
+        end
     };
 }

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/dest/tagging/testing/tag_query_test_utils.d.ts

@@ -0,0 +1,6 @@
+import { type AppTaggingSecret, type PrivateLogsQuery, SiloedTag } from '@aztec/stdlib/logs';
+/** Computes the siloed tag */
+export declare function computeSiloedTagForIndex(secret: AppTaggingSecret, index: number): Promise<SiloedTag>;
+/** Extracts the bare-tag set from a query */
+export declare function extractTags(query: PrivateLogsQuery): SiloedTag[];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFnX3F1ZXJ5X3Rlc3RfdXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90YWdnaW5nL3Rlc3RpbmcvdGFnX3F1ZXJ5X3Rlc3RfdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssZ0JBQWdCLEVBQUUsS0FBSyxnQkFBZ0IsRUFBRSxTQUFTLEVBQWlCLE1BQU0sb0JBQW9CLENBQUM7QUFFNUcsOEJBQThCO0FBQzlCLHdCQUFnQix3QkFBd0IsQ0FBQyxNQUFNLEVBQUUsZ0JBQWdCLEVBQUUsS0FBSyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsU0FBUyxDQUFDLENBRXBHO0FBRUQsNkNBQTZDO0FBQzdDLHdCQUFnQixXQUFXLENBQUMsS0FBSyxFQUFFLGdCQUFnQixHQUFHLFNBQVMsRUFBRSxDQUVoRSJ9

package/dest/tagging/testing/tag_query_test_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag_query_test_utils.d.ts","sourceRoot":"","sources":["../../../src/tagging/testing/tag_query_test_utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,SAAS,EAAiB,MAAM,oBAAoB,CAAC;AAE5G,8BAA8B;AAC9B,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CAEpG;AAED,6CAA6C;AAC7C,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB,GAAG,SAAS,EAAE,CAEhE"}