@aztec/pxe 0.0.0-test.0 → 0.0.1-commit.03f7ef2

package/dest/storage/tagging_data_provider/recipient_tagging_data_provider.js

@@ -0,0 +1,65 @@
+import { toArray } from '@aztec/foundation/iterable';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+/**
+ * Data provider of tagging data used when syncing the logs as a recipient. The sender counterpart of this class is
+ * called SenderTaggingDataProvider. We have the providers separate for the sender and recipient because
+ * the algorithms are completely disjoint and there is not data reuse between the 2.
+ */ export class RecipientTaggingDataProvider {
+    #store;
+    #addressBook;
+    // Stores the last used index for each directional app tagging secret.
+    #lastUsedIndexes;
+    constructor(store){
+        this.#store = store;
+        this.#addressBook = this.#store.openMap('address_book');
+        this.#lastUsedIndexes = this.#store.openMap('last_used_indexes');
+    }
+    /**
+   * Sets the last used indexes when looking for logs.
+   * @param preTags - The pre-tags containing the directional app tagging secrets and the indexes that are to be
+   * updated in the db.
+   * @throws If any two pre-tags contain the same directional app tagging secret
+   */ setLastUsedIndexes(preTags) {
+        // Non-unique secrets would indicate a bug in the caller function.
+        const secretsSet = new Set(preTags.map((preTag)=>preTag.secret.toString()));
+        if (secretsSet.size !== preTags.length) {
+            throw new Error(`Duplicate secrets found when setting last used indexes`);
+        }
+        return Promise.all(preTags.map(({ secret, index })=>this.#lastUsedIndexes.set(secret.toString(), index)));
+    }
+    /**
+   * Returns the last used indexes when looking for logs.
+   * @param secrets - The directional app tagging secrets to obtain the indexes for.
+   * @returns The last used indexes for the given directional app tagging secrets, or undefined if have never yet found
+   * a log for a given secret.
+   */ getLastUsedIndexes(secrets) {
+        return Promise.all(secrets.map((secret)=>this.#lastUsedIndexes.getAsync(secret.toString())));
+    }
+    resetNoteSyncData() {
+        return this.#store.transactionAsync(async ()=>{
+            const keys = await toArray(this.#lastUsedIndexes.keysAsync());
+            await Promise.all(keys.map((secret)=>this.#lastUsedIndexes.delete(secret)));
+        });
+    }
+    // It might seem weird that the following 3 methods are in RecipientTaggingDataProvider and not
+    // in SenderTaggingDataProvider but that is because this data is truly only used for the purposes of syncing logs
+    // as a recipient. When sending logs or when syncing sender tagging indexes we only receive directional app tagging
+    // secret from Aztec.nr via an oracle and we don't need to access sender addresses.
+    async addSenderAddress(address) {
+        if (await this.#addressBook.hasAsync(address.toString())) {
+            return false;
+        }
+        await this.#addressBook.set(address.toString(), true);
+        return true;
+    }
+    async getSenderAddresses() {
+        return (await toArray(this.#addressBook.keysAsync())).map(AztecAddress.fromString);
+    }
+    async removeSenderAddress(address) {
+        if (!await this.#addressBook.hasAsync(address.toString())) {
+            return false;
+        }
+        await this.#addressBook.delete(address.toString());
+        return true;
+    }
+}

package/dest/storage/tagging_data_provider/sender_tagging_data_provider.d.ts

@@ -0,0 +1,67 @@
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { DirectionalAppTaggingSecret, PreTag } from '@aztec/stdlib/logs';
+import { TxHash } from '@aztec/stdlib/tx';
+/**
+ * Data provider of tagging data used when syncing the sender tagging indexes. The recipient counterpart of this class
+ * is called RecipientTaggingDataProvider. We have the providers separate for the sender and recipient because
+ * the algorithms are completely disjoint and there is not data reuse between the two.
+ */
+export declare class SenderTaggingDataProvider {
+    #private;
+    constructor(store: AztecAsyncKVStore);
+    /**
+     * Stores pending indexes.
+     * @remarks Ignores the index if the same preTag + txHash combination already exists in the db with the same index.
+     * This is expected to happen because whenever we start sync we start from the last finalized index and we can have
+     * pending indexes already stored from previous syncs.
+     * @param preTags - The pre-tags containing the directional app tagging secrets and the indexes that are to be
+     * stored in the db.
+     * @param txHash - The tx in which the pretags were used in private logs.
+     * @throws If any two pre-tags contain the same directional app tagging secret. This is enforced because we care
+     * only about the highest index for a given secret that was used in the tx. Hence this check is a good way to catch
+     * bugs.
+     * @throws If the newly stored pending index is further than window length from the highest finalized index for the
+     * same secret. This is enforced in order to give a guarantee to a recipient that he doesn't need to look further than
+     * window length ahead of the highest finalized index.
+     * @throws If a secret + txHash pair already exists in the db with a different index value. It should never happen
+     * that we would attempt to store a different index for a given secret-txHash pair because we always store just the
+     * highest index for a given secret-txHash pair. Hence this is a good way to catch bugs.
+     * @throws If the newly stored pending index is lower than or equal to the last finalized index for the same secret.
+     * This is enforced because this should never happen if the syncing is done correctly as we look for logs from higher
+     * indexes than finalized ones.
+     */
+    storePendingIndexes(preTags: PreTag[], txHash: TxHash): Promise<void>;
+    /**
+     * Returns the transaction hashes of all pending transactions that contain indexes within a specified range
+     * for a given directional app tagging secret.
+     * @param secret - The directional app tagging secret to query pending indexes for.
+     * @param startIndex - The lower bound of the index range (inclusive).
+     * @param endIndex - The upper bound of the index range (exclusive).
+     * @returns An array of unique transaction hashes for pending transactions that contain indexes in the range
+     * [startIndex, endIndex). Returns an empty array if no pending indexes exist in the range.
+     */
+    getTxHashesOfPendingIndexes(secret: DirectionalAppTaggingSecret, startIndex: number, endIndex: number): Promise<TxHash[]>;
+    /**
+     * Returns the last (highest) finalized index for a given secret.
+     * @param secret - The secret to get the last finalized index for.
+     * @returns The last (highest) finalized index for the given secret.
+     */
+    getLastFinalizedIndex(secret: DirectionalAppTaggingSecret): Promise<number | undefined>;
+    /**
+     * Returns the last used index for a given directional app tagging secret, considering both finalized and pending
+     * indexes.
+     * @param secret - The directional app tagging secret to query the last used index for.
+     * @returns The last used index.
+     */
+    getLastUsedIndex(secret: DirectionalAppTaggingSecret): Promise<number | undefined>;
+    /**
+     * Drops all pending indexes corresponding to the given transaction hashes.
+     */
+    dropPendingIndexes(txHashes: TxHash[]): Promise<void>;
+    /**
+     * Updates pending indexes corresponding to the given transaction hashes to be finalized and prunes any lower pending
+     * indexes.
+     */
+    finalizePendingIndexes(txHashes: TxHash[]): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VuZGVyX3RhZ2dpbmdfZGF0YV9wcm92aWRlci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0b3JhZ2UvdGFnZ2luZ19kYXRhX3Byb3ZpZGVyL3NlbmRlcl90YWdnaW5nX2RhdGFfcHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQWlCLE1BQU0saUJBQWlCLENBQUM7QUFDeEUsT0FBTyxLQUFLLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDOUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBSTFDOzs7O0dBSUc7QUFDSCxxQkFBYSx5QkFBeUI7O0lBa0JwQyxZQUFZLEtBQUssRUFBRSxpQkFBaUIsRUFLbkM7SUFFRDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7T0FvQkc7SUFDRyxtQkFBbUIsQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQUUsTUFBTSxFQUFFLE1BQU0saUJBaUQxRDtJQUVEOzs7Ozs7OztPQVFHO0lBQ0csMkJBQTJCLENBQy9CLE1BQU0sRUFBRSwyQkFBMkIsRUFDbkMsVUFBVSxFQUFFLE1BQU0sRUFDbEIsUUFBUSxFQUFFLE1BQU0sR0FDZixPQUFPLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FNbkI7SUFFRDs7OztPQUlHO0lBQ0gscUJBQXFCLENBQUMsTUFBTSxFQUFFLDJCQUEyQixHQUFHLE9BQU8sQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLENBRXRGO0lBRUQ7Ozs7O09BS0c7SUFDRyxnQkFBZ0IsQ0FBQyxNQUFNLEVBQUUsMkJBQTJCLEdBQUcsT0FBTyxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUMsQ0FZdkY7SUFFRDs7T0FFRztJQUNHLGtCQUFrQixDQUFDLFFBQVEsRUFBRSxNQUFNLEVBQUUsaUJBcUIxQztJQUVEOzs7T0FHRztJQUNHLHNCQUFzQixDQUFDLFFBQVEsRUFBRSxNQUFNLEVBQUUsaUJBcUQ5QztDQUNGIn0=

package/dest/storage/tagging_data_provider/sender_tagging_data_provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sender_tagging_data_provider.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_data_provider/sender_tagging_data_provider.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC9E,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAI1C;;;;GAIG;AACH,qBAAa,yBAAyB;;IAkBpC,YAAY,KAAK,EAAE,iBAAiB,EAKnC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,iBAiD1D;IAED;;;;;;;;OAQG;IACG,2BAA2B,CAC/B,MAAM,EAAE,2BAA2B,EACnC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,EAAE,CAAC,CAMnB;IAED;;;;OAIG;IACH,qBAAqB,CAAC,MAAM,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAEtF;IAED;;;;;OAKG;IACG,gBAAgB,CAAC,MAAM,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAYvF;IAED;;OAEG;IACG,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,iBAqB1C;IAED;;;OAGG;IACG,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,iBAqD9C;CACF"}

package/dest/storage/tagging_data_provider/sender_tagging_data_provider.js

@@ -0,0 +1,196 @@
+import { toArray } from '@aztec/foundation/iterable';
+import { TxHash } from '@aztec/stdlib/tx';
+import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../../tagging/sync/sync_sender_tagging_indexes.js';
+/**
+ * Data provider of tagging data used when syncing the sender tagging indexes. The recipient counterpart of this class
+ * is called RecipientTaggingDataProvider. We have the providers separate for the sender and recipient because
+ * the algorithms are completely disjoint and there is not data reuse between the two.
+ */ export class SenderTaggingDataProvider {
+    #store;
+    // Stores the pending indexes for each directional app tagging secret. Pending here means that the tx that contained
+    // the private logs with tags corresponding to these indexes has not been finalized yet.
+    //
+    // We don't store just the highest index because if their transaction is dropped we'd then need the information about
+    // the lower pending indexes. For each secret-tx pair however we only store the largest index used in that tx, since
+    // the smaller ones are irrelevant due to tx atomicity.
+    //
+    // TODO(#17615): This assumes no logs are used in the non-revertible phase.
+    #pendingIndexes;
+    // Stores the last (highest) finalized index for each directional app tagging secret. We care only about the last
+    // index because unlike the pending indexes, it will never happen that a finalized index would be removed and hence
+    // we don't need to store the history.
+    #lastFinalizedIndexes;
+    constructor(store){
+        this.#store = store;
+        this.#pendingIndexes = this.#store.openMap('pending_indexes');
+        this.#lastFinalizedIndexes = this.#store.openMap('last_finalized_indexes');
+    }
+    /**
+   * Stores pending indexes.
+   * @remarks Ignores the index if the same preTag + txHash combination already exists in the db with the same index.
+   * This is expected to happen because whenever we start sync we start from the last finalized index and we can have
+   * pending indexes already stored from previous syncs.
+   * @param preTags - The pre-tags containing the directional app tagging secrets and the indexes that are to be
+   * stored in the db.
+   * @param txHash - The tx in which the pretags were used in private logs.
+   * @throws If any two pre-tags contain the same directional app tagging secret. This is enforced because we care
+   * only about the highest index for a given secret that was used in the tx. Hence this check is a good way to catch
+   * bugs.
+   * @throws If the newly stored pending index is further than window length from the highest finalized index for the
+   * same secret. This is enforced in order to give a guarantee to a recipient that he doesn't need to look further than
+   * window length ahead of the highest finalized index.
+   * @throws If a secret + txHash pair already exists in the db with a different index value. It should never happen
+   * that we would attempt to store a different index for a given secret-txHash pair because we always store just the
+   * highest index for a given secret-txHash pair. Hence this is a good way to catch bugs.
+   * @throws If the newly stored pending index is lower than or equal to the last finalized index for the same secret.
+   * This is enforced because this should never happen if the syncing is done correctly as we look for logs from higher
+   * indexes than finalized ones.
+   */ async storePendingIndexes(preTags, txHash) {
+        // The secrets in pre-tags should be unique because we always store just the highest index per given secret-txHash
+        // pair. Below we check that this is the case.
+        const secretsSet = new Set(preTags.map((preTag)=>preTag.secret.toString()));
+        if (secretsSet.size !== preTags.length) {
+            throw new Error(`Duplicate secrets found when storing pending indexes`);
+        }
+        for (const { secret, index } of preTags){
+            // First we check that for any secret the highest used index in tx is not further than window length from
+            // the highest finalized index.
+            const finalizedIndex = await this.getLastFinalizedIndex(secret) ?? 0;
+            if (index > finalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN) {
+                throw new Error(`Highest used index ${index} is further than window length from the highest finalized index ${finalizedIndex}.
+          Tagging window length ${UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN} is configured too low. Contact the Aztec team
+          to increase it!`);
+            }
+            // Throw if the new pending index is lower than or equal to the last finalized index
+            const secretStr = secret.toString();
+            const lastFinalizedIndex = await this.#lastFinalizedIndexes.getAsync(secretStr);
+            if (lastFinalizedIndex !== undefined && index <= lastFinalizedIndex) {
+                throw new Error(`Cannot store pending index ${index} for secret ${secretStr}: ` + `it is lower than or equal to the last finalized index ${lastFinalizedIndex}`);
+            }
+            // Check if this secret + txHash combination already exists
+            const txHashStr = txHash.toString();
+            const existingForSecret = await this.#pendingIndexes.getAsync(secretStr) ?? [];
+            const existingForSecretAndTx = existingForSecret.find((entry)=>entry.txHash === txHashStr);
+            if (existingForSecretAndTx) {
+                // If it exists with a different index, throw an error
+                if (existingForSecretAndTx.index !== index) {
+                    throw new Error(`Cannot store index ${index} for secret ${secretStr} and txHash ${txHashStr}: ` + `a different index ${existingForSecretAndTx.index} already exists for this secret-txHash pair`);
+                }
+            // If it exists with the same index, ignore the update (no-op)
+            } else {
+                // If it doesn't exist, add it
+                await this.#pendingIndexes.set(secretStr, [
+                    ...existingForSecret,
+                    {
+                        index,
+                        txHash: txHashStr
+                    }
+                ]);
+            }
+        }
+    }
+    /**
+   * Returns the transaction hashes of all pending transactions that contain indexes within a specified range
+   * for a given directional app tagging secret.
+   * @param secret - The directional app tagging secret to query pending indexes for.
+   * @param startIndex - The lower bound of the index range (inclusive).
+   * @param endIndex - The upper bound of the index range (exclusive).
+   * @returns An array of unique transaction hashes for pending transactions that contain indexes in the range
+   * [startIndex, endIndex). Returns an empty array if no pending indexes exist in the range.
+   */ async getTxHashesOfPendingIndexes(secret, startIndex, endIndex) {
+        const existing = await this.#pendingIndexes.getAsync(secret.toString()) ?? [];
+        const txHashes = existing.filter((entry)=>entry.index >= startIndex && entry.index < endIndex).map((entry)=>entry.txHash);
+        return Array.from(new Set(txHashes)).map(TxHash.fromString);
+    }
+    /**
+   * Returns the last (highest) finalized index for a given secret.
+   * @param secret - The secret to get the last finalized index for.
+   * @returns The last (highest) finalized index for the given secret.
+   */ getLastFinalizedIndex(secret) {
+        return this.#lastFinalizedIndexes.getAsync(secret.toString());
+    }
+    /**
+   * Returns the last used index for a given directional app tagging secret, considering both finalized and pending
+   * indexes.
+   * @param secret - The directional app tagging secret to query the last used index for.
+   * @returns The last used index.
+   */ async getLastUsedIndex(secret) {
+        const secretStr = secret.toString();
+        const pendingTxScopedIndexes = await this.#pendingIndexes.getAsync(secretStr) ?? [];
+        const pendingIndexes = pendingTxScopedIndexes.map((entry)=>entry.index);
+        if (pendingTxScopedIndexes.length === 0) {
+            return this.#lastFinalizedIndexes.getAsync(secretStr);
+        }
+        // As the last used index we return the highest one from the pending indexes. Note that this value will be always
+        // higher than the last finalized index because we prune lower pending indexes when a tx is finalized.
+        return Math.max(...pendingIndexes);
+    }
+    /**
+   * Drops all pending indexes corresponding to the given transaction hashes.
+   */ async dropPendingIndexes(txHashes) {
+        if (txHashes.length === 0) {
+            return;
+        }
+        const txHashStrs = new Set(txHashes.map((txHash)=>txHash.toString()));
+        const allSecrets = await toArray(this.#pendingIndexes.keysAsync());
+        for (const secret of allSecrets){
+            const pendingData = await this.#pendingIndexes.getAsync(secret);
+            if (pendingData) {
+                const filtered = pendingData.filter((item)=>!txHashStrs.has(item.txHash));
+                if (filtered.length === 0) {
+                    await this.#pendingIndexes.delete(secret);
+                } else if (filtered.length !== pendingData.length) {
+                    // Some items were filtered out, so update the pending data
+                    await this.#pendingIndexes.set(secret, filtered);
+                }
+            // else: No items were filtered out (txHashes not found for this secret) --> no-op
+            }
+        }
+    }
+    /**
+   * Updates pending indexes corresponding to the given transaction hashes to be finalized and prunes any lower pending
+   * indexes.
+   */ async finalizePendingIndexes(txHashes) {
+        if (txHashes.length === 0) {
+            return;
+        }
+        for (const txHash of txHashes){
+            const txHashStr = txHash.toString();
+            const allSecrets = await toArray(this.#pendingIndexes.keysAsync());
+            for (const secret of allSecrets){
+                const pendingData = await this.#pendingIndexes.getAsync(secret);
+                if (!pendingData) {
+                    continue;
+                }
+                const matchingIndexes = pendingData.filter((item)=>item.txHash === txHashStr).map((item)=>item.index);
+                if (matchingIndexes.length === 0) {
+                    continue;
+                }
+                if (matchingIndexes.length > 1) {
+                    // We should always just store the highest pending index for a given tx hash and secret because the lower
+                    // values are irrelevant.
+                    throw new Error(`Multiple pending indexes found for tx hash ${txHashStr} and secret ${secret}`);
+                }
+                let lastFinalized = await this.#lastFinalizedIndexes.getAsync(secret);
+                const newFinalized = matchingIndexes[0];
+                if (newFinalized < (lastFinalized ?? 0)) {
+                    // This should never happen because when last finalized index was finalized we should have pruned the lower
+                    // pending indexes.
+                    throw new Error(`New finalized index ${newFinalized} is smaller than the current last finalized index ${lastFinalized}`);
+                }
+                await this.#lastFinalizedIndexes.set(secret, newFinalized);
+                lastFinalized = newFinalized;
+                // When we add pending indexes, we ensure they are higher than the last finalized index. However, because we
+                // cannot control the order in which transactions are finalized, there may be pending indexes that are now
+                // obsolete because they are lower than the most recently finalized index. For this reason, we prune these
+                // outdated pending indexes.
+                const remainingItemsOfHigherIndex = pendingData.filter((item)=>item.index > (lastFinalized ?? 0));
+                if (remainingItemsOfHigherIndex.length === 0) {
+                    await this.#pendingIndexes.delete(secret);
+                } else {
+                    await this.#pendingIndexes.set(secret, remainingItemsOfHigherIndex);
+                }
+            }
+        }
+    }
+}

package/dest/tagging/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const WINDOW_HALF_SIZE = 10;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGFnZ2luZy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsZUFBTyxNQUFNLGdCQUFnQixLQUFLLENBQUMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/tagging/constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB,KAAK,CAAC"}

package/dest/tagging/constants.js

@@ -0,0 +1,3 @@
+// Half the size of the window we slide over the tagging indexes.
+// TODO(#17775): Move this to the recipient log sync function once it's implemented in this directory.
+export const WINDOW_HALF_SIZE = 10;

package/dest/tagging/index.d.ts

@@ -0,0 +1,5 @@
+export * from './constants.js';
+export * from './utils.js';
+export { DirectionalAppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';
+export { type PreTag } from '@aztec/stdlib/logs';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90YWdnaW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxZQUFZLENBQUM7QUFDM0IsT0FBTyxFQUFFLDJCQUEyQixFQUFFLEdBQUcsRUFBRSxTQUFTLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNqRixPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQyJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tagging/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,2BAA2B,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACjF,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC"}

package/dest/tagging/index.js

@@ -0,0 +1,3 @@
+export * from './constants.js';
+export * from './utils.js';
+export { DirectionalAppTaggingSecret, Tag, SiloedTag } from '@aztec/stdlib/logs';

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

@@ -0,0 +1,14 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { DirectionalAppTaggingSecret, TxScopedL2Log } from '@aztec/stdlib/logs';
+import type { NewRecipientTaggingDataProvider } from './new_recipient_tagging_data_provider.js';
+/**
+ * Loads private logs for `app` and  sender-recipient pair defined by `secret` and updates the highest aged and
+ * finalized indexes in the db. At most load logs from blocks up to and including `anchorBlockNumber`.
+ *
+ * @dev This function can be safely executed "in parallel" for other sender-recipient pairs because the data in
+ * in the tagging data provider is indexed by the secret and hence completely disjoint.
+ */
+export declare function loadPrivateLogsForSenderRecipientPair(secret: DirectionalAppTaggingSecret, app: AztecAddress, aztecNode: AztecNode, taggingDataProvider: NewRecipientTaggingDataProvider, anchorBlockNumber: BlockNumber): Promise<TxScopedL2Log[]>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZF9wcml2YXRlX2xvZ3NfZm9yX3NlbmRlcl9yZWNpcGllbnRfcGFpci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3RhZ2dpbmcvcmVjaXBpZW50X3N5bmMvbG9hZF9wcml2YXRlX2xvZ3NfZm9yX3NlbmRlcl9yZWNpcGllbnRfcGFpci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNuRSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNoRSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEtBQUssRUFBRSwyQkFBMkIsRUFBRSxhQUFhLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUdyRixPQUFPLEtBQUssRUFBRSwrQkFBK0IsRUFBRSxNQUFNLDBDQUEwQyxDQUFDO0FBSWhHOzs7Ozs7R0FNRztBQUNILHdCQUFzQixxQ0FBcUMsQ0FDekQsTUFBTSxFQUFFLDJCQUEyQixFQUNuQyxHQUFHLEVBQUUsWUFBWSxFQUNqQixTQUFTLEVBQUUsU0FBUyxFQUNwQixtQkFBbUIsRUFBRSwrQkFBK0IsRUFDcEQsaUJBQWlCLEVBQUUsV0FBVyxHQUM3QixPQUFPLENBQUMsYUFBYSxFQUFFLENBQUMsQ0F5RzFCIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"load_private_logs_for_sender_recipient_pair.d.ts","sourceRoot":"","sources":["../../../src/tagging/recipient_sync/load_private_logs_for_sender_recipient_pair.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,2BAA2B,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAGrF,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,0CAA0C,CAAC;AAIhG;;;;;;GAMG;AACH,wBAAsB,qCAAqC,CACzD,MAAM,EAAE,2BAA2B,EACnC,GAAG,EAAE,YAAY,EACjB,SAAS,EAAE,SAAS,EACpB,mBAAmB,EAAE,+BAA+B,EACpD,iBAAiB,EAAE,WAAW,GAC7B,OAAO,CAAC,aAAa,EAAE,CAAC,CAyG1B"}

package/dest/tagging/recipient_sync/load_private_logs_for_sender_recipient_pair.js

@@ -0,0 +1,99 @@
+import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../sync/sync_sender_tagging_indexes.js';
+import { findHighestIndexes } from './utils/find_highest_indexes.js';
+import { loadLogsForRange } from './utils/load_logs_for_range.js';
+/**
+ * Loads private logs for `app` and  sender-recipient pair defined by `secret` and updates the highest aged and
+ * finalized indexes in the db. At most load logs from blocks up to and including `anchorBlockNumber`.
+ *
+ * @dev This function can be safely executed "in parallel" for other sender-recipient pairs because the data in
+ * in the tagging data provider is indexed by the secret and hence completely disjoint.
+ */ export async function loadPrivateLogsForSenderRecipientPair(secret, app, aztecNode, taggingDataProvider, anchorBlockNumber) {
+    // # Explanation of how the algorithm works
+    // When we perform the sync we will look at logs that correspond to the tagging index range
+    // (highestAgedIndex, highestFinalizedIndex + WINDOW_LEN]
+    //
+    // highestAgedIndex is the highest index that was used in a tx that is included in a block at least
+    //                  `MAX_INCLUDE_BY_TIMESTAMP_DURATION` seconds ago.
+    // highestFinalizedIndex is the highest index that was used in a tx that is included in a finalized block.
+    //
+    // "(" denotes an open end of the range - the index is not included in the range.
+    // "]" denotes a closed end of the range - the index is included in the range.
+    //
+    // ## Explanation of highestAgedIndex
+    //
+    // highestAgedIndex is chosen such that for all tagging indexes `i <= highestAgedIndex` we know that no new logs can
+    // ever appear.
+    //
+    // This relies on the "maximum inclusion timestamp" rule enforced by the kernel and rollup circuits:
+    // - a transaction's maximum inclusion timestamp is at most `MAX_INCLUDE_BY_TIMESTAMP_DURATION` seconds after
+    //   the timestamp of its anchor block; and
+    // - a rollup only includes transactions whose inclusion timestamp is >= the L2 block's timestamp.
+    //
+    // Suppose some device used index `I` in a transaction anchored to block `B_N` at time `N`, and that block is now at
+    // least `MAX_INCLUDE_BY_TIMESTAMP_DURATION` seconds in the past. Then there is no possibility of any *other* device
+    // trying to use an index <= `I` while anchoring to a *newer* block than `B_N` because if we were anchoring to
+    // a newer block than `B_N` then we would already have seen the log with index `I` and hence the device would have
+    // chosen a larger index.
+    //    If that *other* device would anchor to a block older than `B_N` then that tx could never be included in a block
+    // because it would already have been expired.
+    //
+    // Therefore, once we see that index `I` has been used in a block that is at least `MAX_INCLUDE_BY_TIMESTAMP_DURATION`
+    // seconds old, we can safely stop syncing logs for all indexes <= `I` and set highestAgedIndex = `I`.
+    //
+    // ## Explanation of the upper bound `highestFinalizedIndex + WINDOW_LEN`
+    //
+    // When a sender chooses a tagging index, they will select an index that is at most `WINDOW_LEN` greater than
+    // the highest finalized index. If that index was already used, they will throw an error. For this reason we
+    // don't have to look further than `highestFinalizedIndex + WINDOW_LEN`.
+    let finalizedBlockNumber, currentTimestamp;
+    {
+        const [l2Tips, latestBlockHeader] = await Promise.all([
+            aztecNode.getL2Tips(),
+            aztecNode.getBlockHeader('latest')
+        ]);
+        if (!latestBlockHeader) {
+            throw new Error('Node failed to return latest block header when syncing logs');
+        }
+        [finalizedBlockNumber, currentTimestamp] = [
+            l2Tips.finalized.number,
+            latestBlockHeader.globalVariables.timestamp
+        ];
+    }
+    let start, end;
+    {
+        const currentHighestAgedIndex = await taggingDataProvider.getHighestAgedIndex(secret);
+        const currentHighestFinalizedIndex = await taggingDataProvider.getHighestFinalizedIndex(secret);
+        // We don't want to include the highest aged index so we start from `currentHighestAgedIndex + 1` (or 0 if not set)
+        start = currentHighestAgedIndex === undefined ? 0 : currentHighestAgedIndex + 1;
+        // The highest index a sender can choose is "highest finalized index + window length" but given that
+        // `loadLogsForRange` expects an exclusive `end` we add 1.
+        end = (currentHighestFinalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
+    }
+    const logs = [];
+    while(true){
+        // Get private logs with their block timestamps and corresponding tagging indexes
+        const privateLogsWithIndexes = await loadLogsForRange(secret, app, aztecNode, start, end, anchorBlockNumber);
+        if (privateLogsWithIndexes.length === 0) {
+            break;
+        }
+        logs.push(...privateLogsWithIndexes.map(({ log })=>log));
+        const { highestAgedIndex, highestFinalizedIndex } = findHighestIndexes(privateLogsWithIndexes, currentTimestamp, finalizedBlockNumber);
+        // Store updates in data provider and update local variables
+        if (highestAgedIndex !== undefined) {
+            await taggingDataProvider.updateHighestAgedIndex(secret, highestAgedIndex);
+        }
+        if (highestFinalizedIndex === undefined) {
+            break;
+        }
+        if (highestAgedIndex !== undefined && highestAgedIndex > highestFinalizedIndex) {
+            // This is just a sanity check as this should never happen.
+            throw new Error('Highest aged index lower than highest finalized index invariant violated');
+        }
+        await taggingDataProvider.updateHighestFinalizedIndex(secret, highestFinalizedIndex);
+        // For the next iteration we want to look only at indexes for which we have not attempted to load logs yet while
+        // ensuring that we do not look further than WINDOW_LEN ahead of the highest finalized index.
+        start = end;
+        end = highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1; // `end` is exclusive so we add 1.
+    }
+    return logs;
+}

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

@@ -0,0 +1,21 @@
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
+/**
+ * Data provider of tagging data used when syncing the logs as a recipient. The sender counterpart of this class
+ * is called SenderTaggingDataProvider. We have the providers separate for the sender and recipient because
+ * the algorithms are completely disjoint and there is not data reuse between the two.
+ *
+ * @dev Chain reorgs do not need to be handled here because both the finalized and aged indexes refer to finalized
+ * blocks, which by definition cannot be affected by reorgs.
+ *
+ * TODO(benesjan): Rename as to RecipientTaggingDataProvider and relocate once the old tagging sync is purged.
+ */
+export declare class NewRecipientTaggingDataProvider {
+    #private;
+    constructor(store: AztecAsyncKVStore);
+    getHighestAgedIndex(secret: DirectionalAppTaggingSecret): Promise<number | undefined>;
+    updateHighestAgedIndex(secret: DirectionalAppTaggingSecret, index: number): Promise<void>;
+    getHighestFinalizedIndex(secret: DirectionalAppTaggingSecret): Promise<number | undefined>;
+    updateHighestFinalizedIndex(secret: DirectionalAppTaggingSecret, index: number): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV3X3JlY2lwaWVudF90YWdnaW5nX2RhdGFfcHJvdmlkZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90YWdnaW5nL3JlY2lwaWVudF9zeW5jL25ld19yZWNpcGllbnRfdGFnZ2luZ19kYXRhX3Byb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFpQixNQUFNLGlCQUFpQixDQUFDO0FBQ3hFLE9BQU8sS0FBSyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFdEU7Ozs7Ozs7OztHQVNHO0FBQ0gscUJBQWEsK0JBQStCOztJQU0xQyxZQUFZLEtBQUssRUFBRSxpQkFBaUIsRUFLbkM7SUFFRCxtQkFBbUIsQ0FBQyxNQUFNLEVBQUUsMkJBQTJCLEdBQUcsT0FBTyxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUMsQ0FFcEY7SUFFSyxzQkFBc0IsQ0FBQyxNQUFNLEVBQUUsMkJBQTJCLEVBQUUsS0FBSyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBTzlGO0lBRUQsd0JBQXdCLENBQUMsTUFBTSxFQUFFLDJCQUEyQixHQUFHLE9BQU8sQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLENBRXpGO0lBRUssMkJBQTJCLENBQUMsTUFBTSxFQUFFLDJCQUEyQixFQUFFLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQVFuRztDQUNGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"new_recipient_tagging_data_provider.d.ts","sourceRoot":"","sources":["../../../src/tagging/recipient_sync/new_recipient_tagging_data_provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAC;AAEtE;;;;;;;;;GASG;AACH,qBAAa,+BAA+B;;IAM1C,YAAY,KAAK,EAAE,iBAAiB,EAKnC;IAED,mBAAmB,CAAC,MAAM,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAEpF;IAEK,sBAAsB,CAAC,MAAM,EAAE,2BAA2B,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAO9F;IAED,wBAAwB,CAAC,MAAM,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAEzF;IAEK,2BAA2B,CAAC,MAAM,EAAE,2BAA2B,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQnG;CACF"}

package/dest/tagging/recipient_sync/new_recipient_tagging_data_provider.js

@@ -0,0 +1,42 @@
+/**
+ * Data provider of tagging data used when syncing the logs as a recipient. The sender counterpart of this class
+ * is called SenderTaggingDataProvider. We have the providers separate for the sender and recipient because
+ * the algorithms are completely disjoint and there is not data reuse between the two.
+ *
+ * @dev Chain reorgs do not need to be handled here because both the finalized and aged indexes refer to finalized
+ * blocks, which by definition cannot be affected by reorgs.
+ *
+ * TODO(benesjan): Rename as to RecipientTaggingDataProvider and relocate once the old tagging sync is purged.
+ */ export class NewRecipientTaggingDataProvider {
+    #store;
+    #highestAgedIndex;
+    #highestFinalizedIndex;
+    constructor(store){
+        this.#store = store;
+        this.#highestAgedIndex = this.#store.openMap('highest_aged_index');
+        this.#highestFinalizedIndex = this.#store.openMap('highest_finalized_index');
+    }
+    getHighestAgedIndex(secret) {
+        return this.#highestAgedIndex.getAsync(secret.toString());
+    }
+    async updateHighestAgedIndex(secret, index) {
+        const currentIndex = await this.#highestAgedIndex.getAsync(secret.toString());
+        if (currentIndex !== undefined && index <= currentIndex) {
+            // Log sync should never set a lower highest aged index.
+            throw new Error(`New highest aged index (${index}) must be higher than the current one (${currentIndex})`);
+        }
+        await this.#highestAgedIndex.set(secret.toString(), index);
+    }
+    getHighestFinalizedIndex(secret) {
+        return this.#highestFinalizedIndex.getAsync(secret.toString());
+    }
+    async updateHighestFinalizedIndex(secret, index) {
+        const currentIndex = await this.#highestFinalizedIndex.getAsync(secret.toString());
+        if (currentIndex !== undefined && index < currentIndex) {
+            // Log sync should never set a lower highest finalized index but it can happen that it would try to set the same
+            // one because we are loading logs from highest aged index + 1 and not from the highest finalized index.
+            throw new Error(`New highest finalized index (${index}) must be higher than the current one (${currentIndex})`);
+        }
+        await this.#highestFinalizedIndex.set(secret.toString(), index);
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"find_highest_indexes.d.ts","sourceRoot":"","sources":["../../../../src/tagging/recipient_sync/utils/find_highest_indexes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAExD;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,sBAAsB,EAAE,KAAK,CAAC;IAAE,GAAG,EAAE,aAAa,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC,EAC3E,gBAAgB,EAAE,MAAM,EACxB,oBAAoB,EAAE,MAAM,GAC3B;IAAE,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,qBAAqB,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAuBrF"}

package/dest/tagging/recipient_sync/utils/find_highest_indexes.js

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

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

@@ -0,0 +1,14 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { DirectionalAppTaggingSecret, TxScopedL2Log } from '@aztec/stdlib/logs';
+/**
+ * Gets private logs with their corresponding block timestamps and tagging indexes for the given index range, `app` and
+ * `secret`. At most load logs from blocks up to and including `anchorBlockNumber`. `start` is inclusive and `end` is
+ * exclusive.
+ */
+export declare function loadLogsForRange(secret: DirectionalAppTaggingSecret, app: AztecAddress, aztecNode: AztecNode, start: number, end: number, anchorBlockNumber: BlockNumber): Promise<Array<{
+    log: TxScopedL2Log;
+    taggingIndex: number;
+}>>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZF9sb2dzX2Zvcl9yYW5nZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvcmVjaXBpZW50X3N5bmMvdXRpbHMvbG9hZF9sb2dzX2Zvcl9yYW5nZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNuRSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNoRSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEtBQUssRUFBRSwyQkFBMkIsRUFBVSxhQUFhLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUc3Rjs7OztHQUlHO0FBQ0gsd0JBQXNCLGdCQUFnQixDQUNwQyxNQUFNLEVBQUUsMkJBQTJCLEVBQ25DLEdBQUcsRUFBRSxZQUFZLEVBQ2pCLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLEtBQUssRUFBRSxNQUFNLEVBQ2IsR0FBRyxFQUFFLE1BQU0sRUFDWCxpQkFBaUIsRUFBRSxXQUFXLEdBQzdCLE9BQU8sQ0FBQyxLQUFLLENBQUM7SUFBRSxHQUFHLEVBQUUsYUFBYSxDQUFDO0lBQUMsWUFBWSxFQUFFLE1BQU0sQ0FBQTtDQUFFLENBQUMsQ0FBQyxDQXdCOUQifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"load_logs_for_range.d.ts","sourceRoot":"","sources":["../../../../src/tagging/recipient_sync/utils/load_logs_for_range.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,2BAA2B,EAAU,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAG7F;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,2BAA2B,EACnC,GAAG,EAAE,YAAY,EACjB,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,iBAAiB,EAAE,WAAW,GAC7B,OAAO,CAAC,KAAK,CAAC;IAAE,GAAG,EAAE,aAAa,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAwB9D"}