@aztec/pxe 0.0.1-commit.b655e406 → 0.0.1-commit.c7c42ec

package/dest/storage/{note_data_provider/note_data_provider.js → note_store/note_store.js}

@@ -2,13 +2,13 @@ import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { toArray } from '@aztec/foundation/iterable';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { NoteStatus } from '@aztec/stdlib/note';
-import { NoteDao } from './note_dao.js';
+import { NoteDao } from '@aztec/stdlib/note';
 /**
- * NoteDataProvider manages the storage and retrieval of notes.
+ * NoteStore manages the storage and retrieval of notes.
  *
  * Notes can be active or nullified. This class processes new notes, nullifications,
  * and performs rollback handling in the case of a reorg.
- **/ export class NoteDataProvider {
+ **/ export class NoteStore {
     #store;
     #notes;
     #nullifiedNotes;
@@ -38,15 +38,15 @@ import { NoteDao } from './note_dao.js';
         this.#notesByStorageSlotAndScope = new Map();
     }
     /**
-   * Creates and initializes a new NoteDataProvider instance.
+   * Creates and initializes a new NoteStore instance.
    *
-   * This factory method creates a NoteDataProvider and restores any existing
+   * This factory method creates a NoteStore and restores any existing
    * scope-specific indexes from the database.
    *
    * @param store - The key-value store to use for persistence
-   * @returns Promise resolving to a fully initialized NoteDataProvider instance
+   * @returns Promise resolving to a fully initialized NoteStore instance
    */ static async create(store) {
-        const pxeDB = new NoteDataProvider(store);
+        const pxeDB = new NoteStore(store);
         for await (const scope of pxeDB.#scopes.keysAsync()){
             pxeDB.#notesByContractAndScope.set(scope, store.openMultiMap(`${scope}:notes_by_contract`));
             pxeDB.#notesByStorageSlotAndScope.set(scope, store.openMultiMap(`${scope}:notes_by_storage_slot`));
@@ -158,11 +158,11 @@ import { NoteDao } from './note_dao.js';
                 const noteIndex = toBufferBE(dao.index, 32).toString('hex');
                 await this.#notes.set(noteIndex, dao.toBuffer());
                 await this.#nullifierToNoteId.set(dao.siloedNullifier.toString(), noteIndex);
-                let scopes = await toArray(this.#nullifiedNotesToScope.getValuesAsync(noteIndex)) ?? [];
+                const scopes = await toArray(this.#nullifiedNotesToScope.getValuesAsync(noteIndex));
                 if (scopes.length === 0) {
-                    scopes = [
-                        dao.recipient.toString()
-                    ];
+                    // We should never run into this error because notes always have a scope assigned to them - either on initial
+                    // insertion via `addNotes` or when removing their nullifiers.
+                    throw new Error(`No scopes found for nullified note with index ${noteIndex}`);
                 }
                 for (const scope of scopes){
                     await this.#notesByContractAndScope.get(scope.toString()).set(dao.contractAddress.toString(), noteIndex);
@@ -185,8 +185,9 @@ import { NoteDao } from './note_dao.js';
    * parameters.
    *
    * @param filter - Filter criteria including contractAddress (required), and optional
-   *                 storageSlot, status, scopes and siloedNullifier.
-   * @returns Promise resolving to array of NoteDao objects matching the filter
+   *                 owner, storageSlot, status, scopes, and siloedNullifier.
+   * @returns Filtered and deduplicated notes (a note might be present in multiple scopes - we ensure it is only
+   * returned once if this is the case)
    * @throws If filtering by an empty scopes array. Scopes have to be set to undefined or to a non-empty array.
    */ async getNotes(filter) {
         filter.status = filter.status ?? NoteStatus.ACTIVE;
@@ -237,6 +238,9 @@ import { NoteDao } from './note_dao.js';
                 if (!note.contractAddress.equals(filter.contractAddress)) {
                     continue;
                 }
+                if (filter.owner && !note.owner.equals(filter.owner)) {
+                    continue;
+                }
                 if (filter.storageSlot && !note.storageSlot.equals(filter.storageSlot)) {
                     continue;
                 }
@@ -246,7 +250,14 @@ import { NoteDao } from './note_dao.js';
                 result.push(note);
             }
         }
-        return result;
+        // A note might be present in multiple scopes - we ensure it is only returned once
+        const deduplicated = [];
+        for (const note of result){
+            if (!deduplicated.some((existing)=>existing.equals(note))) {
+                deduplicated.push(note);
+            }
+        }
+        return deduplicated;
     }
     /**
    * Transitions notes from "active" to "nullified" state.
@@ -280,7 +291,12 @@ import { NoteDao } from './note_dao.js';
                 if (!noteBuffer) {
                     throw new Error('Note not found in applyNullifiers');
                 }
-                const noteScopes = await toArray(this.#notesToScope.getValuesAsync(noteIndex)) ?? [];
+                const noteScopes = await toArray(this.#notesToScope.getValuesAsync(noteIndex));
+                if (noteScopes.length === 0) {
+                    // We should never run into this error because notes always have a scope assigned to them - either on initial
+                    // insertion via `addNotes` or when removing their nullifiers.
+                    throw new Error('Note scopes are missing in applyNullifiers');
+                }
                 const note = NoteDao.fromBuffer(noteBuffer);
                 nullifiedNotes.push(note);
                 await this.#notes.delete(noteIndex);
@@ -290,10 +306,8 @@ import { NoteDao } from './note_dao.js';
                     await this.#notesByContractAndScope.get(scope).deleteValue(note.contractAddress.toString(), noteIndex);
                     await this.#notesByStorageSlotAndScope.get(scope).deleteValue(note.storageSlot.toString(), noteIndex);
                 }
-                if (noteScopes !== undefined) {
-                    for (const scope of noteScopes){
-                        await this.#nullifiedNotesToScope.set(noteIndex, scope);
-                    }
+                for (const scope of noteScopes){
+                    await this.#nullifiedNotesToScope.set(noteIndex, scope);
                 }
                 await this.#nullifiedNotes.set(noteIndex, note.toBuffer());
                 await this.#nullifiersByBlockNumber.set(blockNumber, nullifier.toString());

package/dest/storage/private_event_store/private_event_store.d.ts

@@ -0,0 +1,51 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { EventSelector } from '@aztec/stdlib/abi';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type InTx, TxHash } from '@aztec/stdlib/tx';
+import type { PackedPrivateEvent } from '../../pxe.js';
+export type PrivateEventStoreFilter = {
+    contractAddress: AztecAddress;
+    fromBlock: number;
+    toBlock: number;
+    scopes: AztecAddress[];
+    txHash?: TxHash;
+};
+type PrivateEventMetadata = InTx & {
+    contractAddress: AztecAddress;
+    scope: AztecAddress;
+};
+/**
+ * Stores decrypted private event logs.
+ */
+export declare class PrivateEventStore {
+    #private;
+    logger: import("@aztec/foundation/log").Logger;
+    constructor(store: AztecAsyncKVStore);
+    /**
+     * Store a private event log.
+     * @param eventSelector - The event selector of the event.
+     * @param msgContent - The content of the event.
+     * @param eventCommitmentIndex - The index of the event commitment in the nullifier tree.
+     * @param metadata
+     *  contractAddress - The address of the contract that emitted the event.
+     *  scope - The address to which the event is scoped.
+     *  txHash - The transaction hash of the event log.
+     *  blockNumber - The block number in which the event was emitted.
+     */
+    storePrivateEventLog(eventSelector: EventSelector, msgContent: Fr[], eventCommitmentIndex: number, metadata: PrivateEventMetadata): Promise<void>;
+    /**
+     * Returns the private events given search parameters.
+     * @param eventSelector - The event selector to filter by.
+     * @param filter - Filtering criteria:
+     *  contractAddress: The address of the contract to get events from.
+     *  fromBlock: The block number to search from (inclusive).
+     *  toBlock: The block number to search upto (exclusive).
+     *  scope: - The addresses that decrypted the logs.
+     * @returns - The event log contents, augmented with metadata about
+     *  the transaction and block it the event was included in .
+     */
+    getPrivateEvents(eventSelector: EventSelector, filter: PrivateEventStoreFilter): Promise<PackedPrivateEvent[]>;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZV9ldmVudF9zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0b3JhZ2UvcHJpdmF0ZV9ldmVudF9zdG9yZS9wcml2YXRlX2V2ZW50X3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUdwRCxPQUFPLEtBQUssRUFBbUIsaUJBQWlCLEVBQWlCLE1BQU0saUJBQWlCLENBQUM7QUFDekYsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDdkQsT0FBTyxLQUFLLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFFaEUsT0FBTyxFQUFFLEtBQUssSUFBSSxFQUFFLE1BQU0sRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRXJELE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sY0FBYyxDQUFDO0FBRXZELE1BQU0sTUFBTSx1QkFBdUIsR0FBRztJQUNwQyxlQUFlLEVBQUUsWUFBWSxDQUFDO0lBQzlCLFNBQVMsRUFBRSxNQUFNLENBQUM7SUFDbEIsT0FBTyxFQUFFLE1BQU0sQ0FBQztJQUNoQixNQUFNLEVBQUUsWUFBWSxFQUFFLENBQUM7SUFDdkIsTUFBTSxDQUFDLEVBQUUsTUFBTSxDQUFDO0NBQ2pCLENBQUM7QUFVRixLQUFLLG9CQUFvQixHQUFHLElBQUksR0FBRztJQUNqQyxlQUFlLEVBQUUsWUFBWSxDQUFDO0lBQzlCLEtBQUssRUFBRSxZQUFZLENBQUM7Q0FDckIsQ0FBQztBQUVGOztHQUVHO0FBQ0gscUJBQWEsaUJBQWlCOztJQVM1QixNQUFNLHlDQUF1QztJQUU3QyxZQUFZLEtBQUssRUFBRSxpQkFBaUIsRUFLbkM7SUFNRDs7Ozs7Ozs7OztPQVVHO0lBQ0gsb0JBQW9CLENBQ2xCLGFBQWEsRUFBRSxhQUFhLEVBQzVCLFVBQVUsRUFBRSxFQUFFLEVBQUUsRUFDaEIsb0JBQW9CLEVBQUUsTUFBTSxFQUM1QixRQUFRLEVBQUUsb0JBQW9CLEdBQzdCLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0E4QmY7SUFFRDs7Ozs7Ozs7OztPQVVHO0lBQ1UsZ0JBQWdCLENBQzNCLGFBQWEsRUFBRSxhQUFhLEVBQzVCLE1BQU0sRUFBRSx1QkFBdUIsR0FDOUIsT0FBTyxDQUFDLGtCQUFrQixFQUFFLENBQUMsQ0F3Qy9CO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"private_event_store.d.ts","sourceRoot":"","sources":["../../../src/storage/private_event_store/private_event_store.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAGpD,OAAO,KAAK,EAAmB,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACzF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,MAAM,MAAM,uBAAuB,GAAG;IACpC,eAAe,EAAE,YAAY,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAUF,KAAK,oBAAoB,GAAG,IAAI,GAAG;IACjC,eAAe,EAAE,YAAY,CAAC;IAC9B,KAAK,EAAE,YAAY,CAAC;CACrB,CAAC;AAEF;;GAEG;AACH,qBAAa,iBAAiB;;IAS5B,MAAM,yCAAuC;IAE7C,YAAY,KAAK,EAAE,iBAAiB,EAKnC;IAMD;;;;;;;;;;OAUG;IACH,oBAAoB,CAClB,aAAa,EAAE,aAAa,EAC5B,UAAU,EAAE,EAAE,EAAE,EAChB,oBAAoB,EAAE,MAAM,EAC5B,QAAQ,EAAE,oBAAoB,GAC7B,OAAO,CAAC,IAAI,CAAC,CA8Bf;IAED;;;;;;;;;;OAUG;IACU,gBAAgB,CAC3B,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,uBAAuB,GAC9B,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAwC/B;CACF"}

package/dest/storage/{private_event_data_provider/private_event_data_provider.js → private_event_store/private_event_store.js}

@@ -1,34 +1,40 @@
-import { Fr } from '@aztec/foundation/fields';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { L2BlockHash } from '@aztec/stdlib/block';
 import { TxHash } from '@aztec/stdlib/tx';
 /**
  * Stores decrypted private event logs.
- */ export class PrivateEventDataProvider {
+ */ export class PrivateEventStore {
     #store;
     /** Array storing the actual private event log entries containing the log content and block number */ #eventLogs;
-    /** Map from contract_address_recipient_eventSelector to array of indices into #eventLogs for efficient lookup */ #eventLogIndex;
+    /** Map from contract_address_scope_eventSelector to array of indices into #eventLogs for efficient lookup */ #eventLogIndex;
     /** Map from eventCommitmentIndex to boolean indicating if log has been seen. */ #seenLogs;
-    logger = createLogger('private_event_data_provider');
+    logger = createLogger('private_event_store');
     constructor(store){
         this.#store = store;
         this.#eventLogs = this.#store.openArray('private_event_logs');
         this.#eventLogIndex = this.#store.openMap('private_event_log_index');
         this.#seenLogs = this.#store.openMap('seen_logs');
     }
+    #keyFor(contractAddress, scope, eventSelector) {
+        return `${contractAddress.toString()}_${scope.toString()}_${eventSelector.toString()}`;
+    }
     /**
    * Store a private event log.
-   * @param contractAddress - The address of the contract that emitted the event.
-   * @param recipient - The recipient of the event.
    * @param eventSelector - The event selector of the event.
    * @param msgContent - The content of the event.
-   * @param txHash - The transaction hash of the event log.
    * @param eventCommitmentIndex - The index of the event commitment in the nullifier tree.
-   * @param blockNumber - The block number in which the event was emitted.
-   */ storePrivateEventLog(contractAddress, recipient, eventSelector, msgContent, txHash, eventCommitmentIndex, blockNumber, blockHash) {
+   * @param metadata
+   *  contractAddress - The address of the contract that emitted the event.
+   *  scope - The address to which the event is scoped.
+   *  txHash - The transaction hash of the event log.
+   *  blockNumber - The block number in which the event was emitted.
+   */ storePrivateEventLog(eventSelector, msgContent, eventCommitmentIndex, metadata) {
+        const { contractAddress, scope, txHash, l2BlockNumber, l2BlockHash } = metadata;
         return this.#store.transactionAsync(async ()=>{
-            const key = `${contractAddress.toString()}_${recipient.toString()}_${eventSelector.toString()}`;
+            const key = this.#keyFor(contractAddress, scope, eventSelector);
             // Check if this exact log has already been stored using eventCommitmentIndex as unique identifier
             const hasBeenSeen = await this.#seenLogs.getAsync(eventCommitmentIndex);
             if (hasBeenSeen) {
@@ -40,15 +46,15 @@ import { TxHash } from '@aztec/stdlib/tx';
             }
             this.logger.verbose('storing private event log', {
                 contractAddress,
-                recipient,
+                scope,
                 msgContent,
-                blockNumber
+                l2BlockNumber
             });
             const index = await this.#eventLogs.lengthAsync();
             await this.#eventLogs.push({
                 msgContent: serializeToBuffer(msgContent),
-                blockNumber,
-                blockHash: blockHash.toBuffer(),
+                l2BlockNumber,
+                l2BlockHash: l2BlockHash.toBuffer(),
                 eventCommitmentIndex,
                 txHash: txHash.toBuffer()
             });
@@ -63,20 +69,22 @@ import { TxHash } from '@aztec/stdlib/tx';
     }
     /**
    * Returns the private events given search parameters.
-   * @param contractAddress - The address of the contract to get events from.
-   * @param from - The block number to search from.
-   * @param numBlocks - The amount of blocks to search.
-   * @param recipients - The addresses that decrypted the logs.
    * @param eventSelector - The event selector to filter by.
-   * @returns - The event log contents.
-   */ async getPrivateEvents(contractAddress, from, numBlocks, recipients, eventSelector) {
+   * @param filter - Filtering criteria:
+   *  contractAddress: The address of the contract to get events from.
+   *  fromBlock: The block number to search from (inclusive).
+   *  toBlock: The block number to search upto (exclusive).
+   *  scope: - The addresses that decrypted the logs.
+   * @returns - The event log contents, augmented with metadata about
+   *  the transaction and block it the event was included in .
+   */ async getPrivateEvents(eventSelector, filter) {
         const events = [];
-        for (const recipient of recipients){
-            const key = `${contractAddress.toString()}_${recipient.toString()}_${eventSelector.toString()}`;
+        for (const scope of filter.scopes){
+            const key = this.#keyFor(filter.contractAddress, scope, eventSelector);
             const indices = await this.#eventLogIndex.getAsync(key) || [];
             for (const index of indices){
                 const entry = await this.#eventLogs.atAsync(index);
-                if (!entry || entry.blockNumber < from || entry.blockNumber >= from + numBlocks) {
+                if (!entry || entry.l2BlockNumber < filter.fromBlock || entry.l2BlockNumber >= filter.toBlock) {
                     continue;
                 }
                 // Convert buffer back to Fr array
@@ -84,15 +92,18 @@ import { TxHash } from '@aztec/stdlib/tx';
                 const numFields = entry.msgContent.length / Fr.SIZE_IN_BYTES;
                 const msgContent = reader.readArray(numFields, Fr);
                 const txHash = TxHash.fromBuffer(entry.txHash);
-                const blockHash = L2BlockHash.fromBuffer(entry.blockHash);
+                const l2BlockHash = L2BlockHash.fromBuffer(entry.l2BlockHash);
+                if (filter.txHash && !txHash.equals(filter.txHash)) {
+                    continue;
+                }
                 events.push({
                     eventCommitmentIndex: entry.eventCommitmentIndex,
                     event: {
-                        msgContent,
-                        blockNumber: entry.blockNumber,
-                        recipient,
+                        packedEvent: msgContent,
+                        l2BlockNumber: BlockNumber(entry.l2BlockNumber),
                         txHash,
-                        blockHash
+                        l2BlockHash,
+                        eventSelector
                     }
                 });
             }

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

@@ -0,0 +1,4 @@
+export { SenderTaggingStore } from './sender_tagging_store.js';
+export { SenderAddressBookStore } from './sender_address_book_store.js';
+export { RecipientTaggingStore } from './recipient_tagging_store.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL3RhZ2dpbmdfc3RvcmUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDL0QsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDeEUsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sOEJBQThCLENBQUMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_store/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC"}

package/dest/storage/tagging_store/index.js

@@ -0,0 +1,3 @@
+export { SenderTaggingStore } from './sender_tagging_store.js';
+export { SenderAddressBookStore } from './sender_address_book_store.js';
+export { RecipientTaggingStore } from './recipient_tagging_store.js';

package/dest/storage/tagging_store/recipient_tagging_store.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 SenderTaggingStore. 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): Relocate to yarn-project/pxe/src/storage/tagging_store
+ */
+export declare class RecipientTaggingStore {
+    #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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVjaXBpZW50X3RhZ2dpbmdfc3RvcmUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL3RhZ2dpbmdfc3RvcmUvcmVjaXBpZW50X3RhZ2dpbmdfc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQWlCLE1BQU0saUJBQWlCLENBQUM7QUFDeEUsT0FBTyxLQUFLLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUV0RTs7Ozs7Ozs7O0dBU0c7QUFDSCxxQkFBYSxxQkFBcUI7O0lBTWhDLFlBQVksS0FBSyxFQUFFLGlCQUFpQixFQUtuQztJQUVELG1CQUFtQixDQUFDLE1BQU0sRUFBRSwyQkFBMkIsR0FBRyxPQUFPLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQyxDQUVwRjtJQUVLLHNCQUFzQixDQUFDLE1BQU0sRUFBRSwyQkFBMkIsRUFBRSxLQUFLLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FPOUY7SUFFRCx3QkFBd0IsQ0FBQyxNQUFNLEVBQUUsMkJBQTJCLEdBQUcsT0FBTyxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUMsQ0FFekY7SUFFSywyQkFBMkIsQ0FBQyxNQUFNLEVBQUUsMkJBQTJCLEVBQUUsS0FBSyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBUW5HO0NBQ0YifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"recipient_tagging_store.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_store/recipient_tagging_store.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,qBAAqB;;IAMhC,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/storage/tagging_store/recipient_tagging_store.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 SenderTaggingStore. 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): Relocate to yarn-project/pxe/src/storage/tagging_store
+ */ export class RecipientTaggingStore {
+    #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/storage/tagging_store/sender_address_book_store.d.ts

@@ -0,0 +1,14 @@
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+/**
+ * Stores sender addresses. During recipient log synchronization, these senders are used, along with a given recipient,
+ * to derive directional app tagging secrets that are then used to sync the logs.
+ */
+export declare class SenderAddressBookStore {
+    #private;
+    constructor(store: AztecAsyncKVStore);
+    addSender(address: AztecAddress): Promise<boolean>;
+    getSenders(): Promise<AztecAddress[]>;
+    removeSender(address: AztecAddress): Promise<boolean>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VuZGVyX2FkZHJlc3NfYm9va19zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0b3JhZ2UvdGFnZ2luZ19zdG9yZS9zZW5kZXJfYWRkcmVzc19ib29rX3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFpQixNQUFNLGlCQUFpQixDQUFDO0FBQ3hFLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUUzRDs7O0dBR0c7QUFDSCxxQkFBYSxzQkFBc0I7O0lBSWpDLFlBQVksS0FBSyxFQUFFLGlCQUFpQixFQUluQztJQUVLLFNBQVMsQ0FBQyxPQUFPLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FRdkQ7SUFFSyxVQUFVLElBQUksT0FBTyxDQUFDLFlBQVksRUFBRSxDQUFDLENBRTFDO0lBRUssWUFBWSxDQUFDLE9BQU8sRUFBRSxZQUFZLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQVExRDtDQUNGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"sender_address_book_store.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_store/sender_address_book_store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D;;;GAGG;AACH,qBAAa,sBAAsB;;IAIjC,YAAY,KAAK,EAAE,iBAAiB,EAInC;IAEK,SAAS,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAQvD;IAEK,UAAU,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAE1C;IAEK,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAQ1D;CACF"}

package/dest/storage/tagging_store/sender_address_book_store.js

@@ -0,0 +1,30 @@
+import { toArray } from '@aztec/foundation/iterable';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+/**
+ * Stores sender addresses. During recipient log synchronization, these senders are used, along with a given recipient,
+ * to derive directional app tagging secrets that are then used to sync the logs.
+ */ export class SenderAddressBookStore {
+    #store;
+    #addressBook;
+    constructor(store){
+        this.#store = store;
+        this.#addressBook = this.#store.openMap('address_book');
+    }
+    async addSender(address) {
+        if (await this.#addressBook.hasAsync(address.toString())) {
+            return false;
+        }
+        await this.#addressBook.set(address.toString(), true);
+        return true;
+    }
+    async getSenders() {
+        return (await toArray(this.#addressBook.keysAsync())).map(AztecAddress.fromString);
+    }
+    async removeSender(address) {
+        if (!await this.#addressBook.hasAsync(address.toString())) {
+            return false;
+        }
+        await this.#addressBook.delete(address.toString());
+        return true;
+    }
+}

package/dest/storage/tagging_store/sender_tagging_store.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 RecipientTaggingStore. 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 SenderTaggingStore {
+    #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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VuZGVyX3RhZ2dpbmdfc3RvcmUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL3RhZ2dpbmdfc3RvcmUvc2VuZGVyX3RhZ2dpbmdfc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQWlCLE1BQU0saUJBQWlCLENBQUM7QUFDeEUsT0FBTyxLQUFLLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDOUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBSTFDOzs7O0dBSUc7QUFDSCxxQkFBYSxrQkFBa0I7O0lBa0I3QixZQUFZLEtBQUssRUFBRSxpQkFBaUIsRUFLbkM7SUFFRDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7T0FvQkc7SUFDRyxtQkFBbUIsQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQUUsTUFBTSxFQUFFLE1BQU0saUJBaUQxRDtJQUVEOzs7Ozs7OztPQVFHO0lBQ0csMkJBQTJCLENBQy9CLE1BQU0sRUFBRSwyQkFBMkIsRUFDbkMsVUFBVSxFQUFFLE1BQU0sRUFDbEIsUUFBUSxFQUFFLE1BQU0sR0FDZixPQUFPLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FNbkI7SUFFRDs7OztPQUlHO0lBQ0gscUJBQXFCLENBQUMsTUFBTSxFQUFFLDJCQUEyQixHQUFHLE9BQU8sQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLENBRXRGO0lBRUQ7Ozs7O09BS0c7SUFDRyxnQkFBZ0IsQ0FBQyxNQUFNLEVBQUUsMkJBQTJCLEdBQUcsT0FBTyxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUMsQ0FZdkY7SUFFRDs7T0FFRztJQUNHLGtCQUFrQixDQUFDLFFBQVEsRUFBRSxNQUFNLEVBQUUsaUJBcUIxQztJQUVEOzs7T0FHRztJQUNHLHNCQUFzQixDQUFDLFFBQVEsRUFBRSxNQUFNLEVBQUUsaUJBcUQ5QztDQUNGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"sender_tagging_store.d.ts","sourceRoot":"","sources":["../../../src/storage/tagging_store/sender_tagging_store.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,kBAAkB;;IAkB7B,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"}