@aztec/pxe 0.0.1-commit.d3ec352c → 0.0.1-commit.d6f2b3f94

package/dest/storage/private_event_store/private_event_store.js

@@ -0,0 +1,273 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { createLogger } from '@aztec/foundation/log';
+import { Semaphore } from '@aztec/foundation/queue';
+import { StoredPrivateEvent } from './stored_private_event.js';
+/**
+ * Stores decrypted private event logs.
+ */ export class PrivateEventStore {
+    storeName = 'private_event';
+    #store;
+    /** Actual private event log entries, keyed by siloedEventCommitment */ #events;
+    /** Multi-map from contractAddress_eventSelector to siloedEventCommitment for efficient lookup */ #eventsByContractAndEventSelector;
+    /** Multi-map from block number to siloedEventCommitment for rollback support */ #eventsByBlockNumber;
+    /** jobId => eventId (event siloed nullifier) => StoredPrivateEvent */ #eventsForJob;
+    /** Per-job locks to prevent concurrent writes from affecting each other. */ #jobLocks;
+    logger = createLogger('private_event_store');
+    constructor(store){
+        this.#store = store;
+        this.#events = this.#store.openMap('private_event_logs');
+        this.#eventsByContractAndEventSelector = this.#store.openMultiMap('events_by_contract_selector');
+        this.#eventsByBlockNumber = this.#store.openMultiMap('events_by_block_number');
+        this.#eventsForJob = new Map();
+        this.#jobLocks = new Map();
+    }
+    /**
+   * Store a private event log.
+   * @param eventSelector - The event selector of the event.
+   * @param randomness - The randomness used for the event commitment.
+   * @param msgContent - The content of the event.
+   * @param siloedEventCommitment - The siloed event commitment (used as unique identifier).
+   * @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, randomness, msgContent, siloedEventCommitment, metadata, jobId) {
+        return this.#withJobLock(jobId, ()=>this.#store.transactionAsync(async ()=>{
+                const { contractAddress, scope, txHash, l2BlockNumber, l2BlockHash, txIndexInBlock, eventIndexInTx } = metadata;
+                const eventId = siloedEventCommitment.toString();
+                this.logger.verbose('storing private event log (job stage)', {
+                    eventId,
+                    contractAddress,
+                    scope,
+                    msgContent,
+                    l2BlockNumber
+                });
+                const existing = await this.#readEvent(eventId, jobId);
+                if (existing) {
+                    // If we already stored this event, we still want to make sure to track it for the given scope
+                    existing.addScope(scope.toString());
+                    this.#writeEvent(eventId, existing, jobId);
+                } else {
+                    this.#writeEvent(eventId, new StoredPrivateEvent(randomness, msgContent, l2BlockNumber, l2BlockHash, txHash, txIndexInBlock, eventIndexInTx, contractAddress, eventSelector, new Set([
+                        scope.toString()
+                    ])), jobId);
+                }
+            }));
+    }
+    /**
+   * 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 in which the event was
+   * included.
+   */ getPrivateEvents(eventSelector, filter) {
+        return this.#store.transactionAsync(async ()=>{
+            const key = this.#keyFor(filter.contractAddress, eventSelector);
+            const targetScopes = new Set(filter.scopes.map((s)=>s.toString()));
+            // Map from eventId to the promise that reads the event buffer.
+            // We start reads during iteration to keep DB requests pending and avoid IndexedDB auto-commit.
+            const eventReadPromises = new Map();
+            for await (const eventId of this.#eventsByContractAndEventSelector.getValuesAsync(key)){
+                eventReadPromises.set(eventId, this.#events.getAsync(eventId));
+            }
+            const eventIds = [
+                ...eventReadPromises.keys()
+            ];
+            const eventBuffers = await Promise.all(eventReadPromises.values());
+            const events = [];
+            for(let i = 0; i < eventIds.length; i++){
+                const eventId = eventIds[i];
+                const eventBuffer = eventBuffers[i];
+                // Defensive, if it happens, there's a problem with how we're handling #eventsByContractAndEventSelector
+                if (!eventBuffer) {
+                    this.logger.verbose(`EventId ${eventId} does not exist in main index but it is referenced from contract event selector index`);
+                    continue;
+                }
+                const storedPrivateEvent = StoredPrivateEvent.fromBuffer(eventBuffer);
+                // Filter by block range
+                if (storedPrivateEvent.l2BlockNumber < filter.fromBlock || storedPrivateEvent.l2BlockNumber >= filter.toBlock) {
+                    continue;
+                }
+                // Filter by scopes
+                if (storedPrivateEvent.scopes.intersection(targetScopes).size === 0) {
+                    continue;
+                }
+                // Filter by txHash
+                if (filter.txHash && !storedPrivateEvent.txHash.equals(filter.txHash)) {
+                    continue;
+                }
+                events.push({
+                    l2BlockNumber: storedPrivateEvent.l2BlockNumber,
+                    txIndexInBlock: storedPrivateEvent.txIndexInBlock,
+                    eventIndexInTx: storedPrivateEvent.eventIndexInTx,
+                    event: {
+                        packedEvent: storedPrivateEvent.msgContent,
+                        l2BlockNumber: BlockNumber(storedPrivateEvent.l2BlockNumber),
+                        txHash: storedPrivateEvent.txHash,
+                        l2BlockHash: storedPrivateEvent.l2BlockHash,
+                        eventSelector
+                    }
+                });
+            }
+            // Sort by block number, then by tx index within block, then by event index within tx
+            events.sort((a, b)=>{
+                if (a.l2BlockNumber !== b.l2BlockNumber) {
+                    return a.l2BlockNumber - b.l2BlockNumber;
+                }
+                if (a.txIndexInBlock !== b.txIndexInBlock) {
+                    return a.txIndexInBlock - b.txIndexInBlock;
+                }
+                return a.eventIndexInTx - b.eventIndexInTx;
+            });
+            return events.map((ev)=>ev.event);
+        });
+    }
+    /**
+   * Rolls back private events that were stored after a given `blockNumber` and up to `synchedBlockNumber` (the block
+   * number up to which PXE managed to sync before the reorg happened).
+   *
+   * We don't need staged writes for a rollback since it's handled in the context of a blockchain rewind.
+   *
+   * Rollbacks are handled by the BlockSynchronizer, which runs a DB transaction across stores when it detects a
+   * re-org, including setting the new anchor block after rolling back.
+   *
+   * So if anything fails in the process of rolling back any store, all DB changes occurring during rollbacks will be
+   * lost and the anchor block will not be updated; which means this code will eventually need to run again
+   * (i.e.: PXE will detect it's basing it work on an invalid block hash, then which re-triggers rewind).
+   *
+   * For further details, refer to `BlockSynchronizer#handleBlockStreamEvent`.
+   *
+   * IMPORTANT: This method must be called within a transaction to ensure atomicity.
+   */ async rollback(blockNumber, synchedBlockNumber) {
+        // First pass: collect all event IDs for all blocks, starting reads during iteration to keep tx alive.
+        const eventsByBlock = new Map();
+        for(let block = blockNumber + 1; block <= synchedBlockNumber; block++){
+            const blockEvents = [];
+            for await (const eventId of this.#eventsByBlockNumber.getValuesAsync(block)){
+                // Start read immediately during iteration to keep IndexedDB transaction alive
+                blockEvents.push({
+                    eventId,
+                    eventReadPromise: this.#events.getAsync(eventId)
+                });
+            }
+            if (blockEvents.length > 0) {
+                eventsByBlock.set(block, blockEvents);
+            }
+        }
+        // Second pass: await reads and perform deletes
+        let removedCount = 0;
+        for (const [block, events] of eventsByBlock){
+            await this.#eventsByBlockNumber.delete(block);
+            for (const { eventId, eventReadPromise } of events){
+                const buffer = await eventReadPromise;
+                if (!buffer) {
+                    throw new Error(`Event not found for eventId ${eventId}`);
+                }
+                const entry = StoredPrivateEvent.fromBuffer(buffer);
+                await this.#events.delete(eventId);
+                await this.#eventsByContractAndEventSelector.deleteValue(this.#keyFor(entry.contractAddress, entry.eventSelector), eventId);
+                removedCount++;
+            }
+        }
+        this.logger.verbose(`Rolled back ${removedCount} private events after block ${blockNumber}`);
+    }
+    /**
+   * Commits in memory job data to persistent storage.
+   *
+   * Called by JobCoordinator when a job completes successfully.
+   *
+   * Note: JobCoordinator wraps all commits in a single transaction, so we don't need our own transactionAsync here
+   * (and using one would throw on IndexedDB as it does not support nested txs).
+   *
+   * @param jobId - The jobId identifying which staged data to commit
+   */ async commit(jobId) {
+        // Note: Don't use #withJobLock here - commit runs within JobCoordinator's transactionAsync,
+        // and awaiting the lock would create a microtask boundary with no pending DB request,
+        // causing IndexedDB to auto-commit the transaction.
+        for (const [eventId, entry] of this.#getEventsForJob(jobId).entries()){
+            const lookupKey = this.#keyFor(entry.contractAddress, entry.eventSelector);
+            this.logger.verbose('storing private event log', {
+                eventId,
+                lookupKey
+            });
+            await Promise.all([
+                this.#events.set(eventId, entry.toBuffer()),
+                this.#eventsByContractAndEventSelector.set(lookupKey, eventId),
+                this.#eventsByBlockNumber.set(entry.l2BlockNumber, eventId)
+            ]);
+        }
+        this.#clearJobData(jobId);
+    }
+    /**
+   * Discards in memory job data without persisting it.
+   */ discardStaged(jobId) {
+        this.#clearJobData(jobId);
+        return Promise.resolve();
+    }
+    /**
+   * Reads an event from in-memory job data first, falling back to persistent storage if not found.
+   *
+   * Returns undefined if the event does not exist in the store overall.
+   */ async #readEvent(eventId, jobId) {
+        // Always issue DB read to keep IndexedDB transaction alive (they auto-commit when a new micro-task starts and there
+        // are no pending read requests). The staged value still takes precedence if it exists.
+        const buffer = await this.#events.getAsync(eventId);
+        const eventForJob = this.#getEventsForJob(jobId).get(eventId);
+        return eventForJob ?? (buffer ? StoredPrivateEvent.fromBuffer(buffer) : undefined);
+    }
+    /**
+   * Writes an event to in-memory job data.
+   *
+   * Writes are only allowed in a job context. Events modified during a job will only be persisted when `commit` is
+   * called.
+   */ #writeEvent(eventId, entry, jobId) {
+        this.#getEventsForJob(jobId).set(eventId, entry);
+    }
+    /**
+   * Get in-memory data only visible to @param jobId
+   */ #getEventsForJob(jobId) {
+        let eventsForJob = this.#eventsForJob.get(jobId);
+        if (eventsForJob === undefined) {
+            eventsForJob = new Map();
+            this.#eventsForJob.set(jobId, eventsForJob);
+        }
+        return eventsForJob;
+    }
+    /**
+   * Clear data structures supporting a specific job.
+   */ #clearJobData(jobId) {
+        this.#eventsForJob.delete(jobId);
+        this.#jobLocks.delete(jobId);
+    }
+    /**
+   * Ensures a function can only run once it acquires a unique per-job lock, and handles proper lock release after it
+   * runs.
+   *
+   * This primitive allows concurrent writes on this store without risking data corruption due to unsound write
+   * interleaving.
+   */ async #withJobLock(jobId, fn) {
+        let lock = this.#jobLocks.get(jobId);
+        if (!lock) {
+            lock = new Semaphore(1);
+            this.#jobLocks.set(jobId, lock);
+        }
+        await lock.acquire();
+        try {
+            return await fn();
+        } finally{
+            lock.release();
+        }
+    }
+    /**
+   * Returns a string key based on @param contractAddress and @param eventSelector.
+   *
+   * The returned key is meant to be used when interacting with index #eventsByContractAndEventSelector.
+   */ #keyFor(contractAddress, eventSelector) {
+        return `${contractAddress.toString()}_${eventSelector.toString()}`;
+    }
+}

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

@@ -0,0 +1,23 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { EventSelector } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { BlockHash } from '@aztec/stdlib/block';
+import { TxHash } from '@aztec/stdlib/tx';
+/** Serializable private event entry with scope tracking. */
+export declare class StoredPrivateEvent {
+    readonly randomness: Fr;
+    readonly msgContent: Fr[];
+    readonly l2BlockNumber: number;
+    readonly l2BlockHash: BlockHash;
+    readonly txHash: TxHash;
+    readonly txIndexInBlock: number;
+    readonly eventIndexInTx: number;
+    readonly contractAddress: AztecAddress;
+    readonly eventSelector: EventSelector;
+    readonly scopes: Set<string>;
+    constructor(randomness: Fr, msgContent: Fr[], l2BlockNumber: number, l2BlockHash: BlockHash, txHash: TxHash, txIndexInBlock: number, eventIndexInTx: number, contractAddress: AztecAddress, eventSelector: EventSelector, scopes: Set<string>);
+    addScope(scope: string): void;
+    toBuffer(): Buffer;
+    static fromBuffer(buffer: Buffer): StoredPrivateEvent;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmVkX3ByaXZhdGVfZXZlbnQuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL3ByaXZhdGVfZXZlbnRfc3RvcmUvc3RvcmVkX3ByaXZhdGVfZXZlbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXBELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNsRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDM0QsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ2hELE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUUxQyw0REFBNEQ7QUFDNUQscUJBQWEsa0JBQWtCO0lBRTNCLFFBQVEsQ0FBQyxVQUFVLEVBQUUsRUFBRTtJQUN2QixRQUFRLENBQUMsVUFBVSxFQUFFLEVBQUUsRUFBRTtJQUN6QixRQUFRLENBQUMsYUFBYSxFQUFFLE1BQU07SUFDOUIsUUFBUSxDQUFDLFdBQVcsRUFBRSxTQUFTO0lBQy9CLFFBQVEsQ0FBQyxNQUFNLEVBQUUsTUFBTTtJQUN2QixRQUFRLENBQUMsY0FBYyxFQUFFLE1BQU07SUFDL0IsUUFBUSxDQUFDLGNBQWMsRUFBRSxNQUFNO0lBQy9CLFFBQVEsQ0FBQyxlQUFlLEVBQUUsWUFBWTtJQUN0QyxRQUFRLENBQUMsYUFBYSxFQUFFLGFBQWE7SUFDckMsUUFBUSxDQUFDLE1BQU0sRUFBRSxHQUFHLENBQUMsTUFBTSxDQUFDO0lBVjlCLFlBQ1csVUFBVSxFQUFFLEVBQUUsRUFDZCxVQUFVLEVBQUUsRUFBRSxFQUFFLEVBQ2hCLGFBQWEsRUFBRSxNQUFNLEVBQ3JCLFdBQVcsRUFBRSxTQUFTLEVBQ3RCLE1BQU0sRUFBRSxNQUFNLEVBQ2QsY0FBYyxFQUFFLE1BQU0sRUFDdEIsY0FBYyxFQUFFLE1BQU0sRUFDdEIsZUFBZSxFQUFFLFlBQVksRUFDN0IsYUFBYSxFQUFFLGFBQWEsRUFDNUIsTUFBTSxFQUFFLEdBQUcsQ0FBQyxNQUFNLENBQUMsRUFDMUI7SUFFSixRQUFRLENBQUMsS0FBSyxFQUFFLE1BQU0sUUFFckI7SUFFRCxRQUFRLElBQUksTUFBTSxDQWdCakI7SUFFRCxNQUFNLENBQUMsVUFBVSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsa0JBQWtCLENBMkJwRDtDQUNGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"stored_private_event.d.ts","sourceRoot":"","sources":["../../../src/storage/private_event_store/stored_private_event.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEpD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE1C,4DAA4D;AAC5D,qBAAa,kBAAkB;IAE3B,QAAQ,CAAC,UAAU,EAAE,EAAE;IACvB,QAAQ,CAAC,UAAU,EAAE,EAAE,EAAE;IACzB,QAAQ,CAAC,aAAa,EAAE,MAAM;IAC9B,QAAQ,CAAC,WAAW,EAAE,SAAS;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,cAAc,EAAE,MAAM;IAC/B,QAAQ,CAAC,cAAc,EAAE,MAAM;IAC/B,QAAQ,CAAC,eAAe,EAAE,YAAY;IACtC,QAAQ,CAAC,aAAa,EAAE,aAAa;IACrC,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC;IAV9B,YACW,UAAU,EAAE,EAAE,EACd,UAAU,EAAE,EAAE,EAAE,EAChB,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,SAAS,EACtB,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,YAAY,EAC7B,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,EAC1B;IAEJ,QAAQ,CAAC,KAAK,EAAE,MAAM,QAErB;IAED,QAAQ,IAAI,MAAM,CAgBjB;IAED,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB,CA2BpD;CACF"}

package/dest/storage/private_event_store/stored_private_event.js

@@ -0,0 +1,56 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { EventSelector } from '@aztec/stdlib/abi';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { BlockHash } from '@aztec/stdlib/block';
+import { TxHash } from '@aztec/stdlib/tx';
+/** Serializable private event entry with scope tracking. */ export class StoredPrivateEvent {
+    randomness;
+    msgContent;
+    l2BlockNumber;
+    l2BlockHash;
+    txHash;
+    txIndexInBlock;
+    eventIndexInTx;
+    contractAddress;
+    eventSelector;
+    scopes;
+    constructor(randomness, msgContent, l2BlockNumber, l2BlockHash, txHash, txIndexInBlock, eventIndexInTx, contractAddress, eventSelector, scopes){
+        this.randomness = randomness;
+        this.msgContent = msgContent;
+        this.l2BlockNumber = l2BlockNumber;
+        this.l2BlockHash = l2BlockHash;
+        this.txHash = txHash;
+        this.txIndexInBlock = txIndexInBlock;
+        this.eventIndexInTx = eventIndexInTx;
+        this.contractAddress = contractAddress;
+        this.eventSelector = eventSelector;
+        this.scopes = scopes;
+    }
+    addScope(scope) {
+        this.scopes.add(scope);
+    }
+    toBuffer() {
+        const scopesArray = [
+            ...this.scopes
+        ];
+        return serializeToBuffer(this.randomness, this.msgContent.length, ...this.msgContent, this.l2BlockNumber, this.l2BlockHash, this.txHash, this.txIndexInBlock, this.eventIndexInTx, this.contractAddress, this.eventSelector.toBuffer(), scopesArray.length, ...scopesArray);
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        const randomness = Fr.fromBuffer(reader);
+        const msgContentLength = reader.readNumber();
+        const msgContent = reader.readArray(msgContentLength, Fr);
+        const l2BlockNumber = reader.readNumber();
+        const l2BlockHash = new BlockHash(Fr.fromBuffer(reader));
+        const txHash = TxHash.fromBuffer(reader);
+        const txIndexInBlock = reader.readNumber();
+        const eventIndexInTx = reader.readNumber();
+        const contractAddress = AztecAddress.fromBuffer(reader);
+        const eventSelector = EventSelector.fromBuffer(reader);
+        const scopes = reader.readVector({
+            fromBuffer: (r)=>r.readString()
+        });
+        return new StoredPrivateEvent(randomness, msgContent, l2BlockNumber, l2BlockHash, txHash, txIndexInBlock, eventIndexInTx, contractAddress, eventSelector, new Set(scopes));
+    }
+}

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,28 @@
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import type { DirectionalAppTaggingSecret } from '@aztec/stdlib/logs';
+import type { StagedStore } from '../../job_coordinator/job_coordinator.js';
+/**
+ * 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.
+ */
+export declare class RecipientTaggingStore implements StagedStore {
+    #private;
+    storeName: string;
+    constructor(store: AztecAsyncKVStore);
+    /**
+     * Writes all job-specific in-memory data to persistent storage.
+     *
+     * @remark This method must run in a DB transaction context. It's designed to be called from JobCoordinator#commitJob.
+     */
+    commit(jobId: string): Promise<void>;
+    discardStaged(jobId: string): Promise<void>;
+    getHighestAgedIndex(secret: DirectionalAppTaggingSecret, jobId: string): Promise<number | undefined>;
+    updateHighestAgedIndex(secret: DirectionalAppTaggingSecret, index: number, jobId: string): Promise<void>;
+    getHighestFinalizedIndex(secret: DirectionalAppTaggingSecret, jobId: string): Promise<number | undefined>;
+    updateHighestFinalizedIndex(secret: DirectionalAppTaggingSecret, index: number, jobId: string): Promise<void>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVjaXBpZW50X3RhZ2dpbmdfc3RvcmUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL3RhZ2dpbmdfc3RvcmUvcmVjaXBpZW50X3RhZ2dpbmdfc3RvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQWlCLE1BQU0saUJBQWlCLENBQUM7QUFDeEUsT0FBTyxLQUFLLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUV0RSxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSwwQ0FBMEMsQ0FBQztBQUU1RTs7Ozs7OztHQU9HO0FBQ0gscUJBQWEscUJBQXNCLFlBQVcsV0FBVzs7SUFDdkQsU0FBUyxFQUFFLE1BQU0sQ0FBdUI7SUFheEMsWUFBWSxLQUFLLEVBQUUsaUJBQWlCLEVBUW5DO0lBNENEOzs7O09BSUc7SUFDRyxNQUFNLENBQUMsS0FBSyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBZ0J6QztJQUVELGFBQWEsQ0FBQyxLQUFLLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FJMUM7SUFFRCxtQkFBbUIsQ0FBQyxNQUFNLEVBQUUsMkJBQTJCLEVBQUUsS0FBSyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQyxDQUVuRztJQUVELHNCQUFzQixDQUFDLE1BQU0sRUFBRSwyQkFBMkIsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQVN2RztJQUVELHdCQUF3QixDQUFDLE1BQU0sRUFBRSwyQkFBMkIsRUFBRSxLQUFLLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDLENBRXhHO0lBRUQsMkJBQTJCLENBQUMsTUFBTSxFQUFFLDJCQUEyQixFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBVTVHO0NBQ0YifQ==

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,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0CAA0C,CAAC;AAE5E;;;;;;;GAOG;AACH,qBAAa,qBAAsB,YAAW,WAAW;;IACvD,SAAS,EAAE,MAAM,CAAuB;IAaxC,YAAY,KAAK,EAAE,iBAAiB,EAQnC;IA4CD;;;;OAIG;IACG,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBzC;IAED,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI1C;IAED,mBAAmB,CAAC,MAAM,EAAE,2BAA2B,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAEnG;IAED,sBAAsB,CAAC,MAAM,EAAE,2BAA2B,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CASvG;IAED,wBAAwB,CAAC,MAAM,EAAE,2BAA2B,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAExG;IAED,2BAA2B,CAAC,MAAM,EAAE,2BAA2B,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAU5G;CACF"}

package/dest/storage/tagging_store/recipient_tagging_store.js

@@ -0,0 +1,111 @@
+/**
+ * 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.
+ */ export class RecipientTaggingStore {
+    storeName = 'recipient_tagging';
+    #store;
+    #highestAgedIndex;
+    #highestFinalizedIndex;
+    // jobId => secret => number
+    #highestAgedIndexForJob;
+    // jobId => secret => number
+    #highestFinalizedIndexForJob;
+    constructor(store){
+        this.#store = store;
+        this.#highestAgedIndex = this.#store.openMap('highest_aged_index');
+        this.#highestFinalizedIndex = this.#store.openMap('highest_finalized_index');
+        this.#highestAgedIndexForJob = new Map();
+        this.#highestFinalizedIndexForJob = new Map();
+    }
+    #getHighestAgedIndexForJob(jobId) {
+        let highestAgedIndexForJob = this.#highestAgedIndexForJob.get(jobId);
+        if (!highestAgedIndexForJob) {
+            highestAgedIndexForJob = new Map();
+            this.#highestAgedIndexForJob.set(jobId, highestAgedIndexForJob);
+        }
+        return highestAgedIndexForJob;
+    }
+    async #readHighestAgedIndex(jobId, secret) {
+        // Always issue DB read to keep IndexedDB transaction alive (they auto-commit when a new micro-task starts and there
+        // are no pending read requests). The staged value still takes precedence if it exists.
+        const dbValue = await this.#highestAgedIndex.getAsync(secret);
+        const staged = this.#getHighestAgedIndexForJob(jobId).get(secret);
+        return staged ?? dbValue;
+    }
+    #writeHighestAgedIndex(jobId, secret, index) {
+        this.#getHighestAgedIndexForJob(jobId).set(secret, index);
+    }
+    #getHighestFinalizedIndexForJob(jobId) {
+        let jobStagedHighestFinalizedIndex = this.#highestFinalizedIndexForJob.get(jobId);
+        if (!jobStagedHighestFinalizedIndex) {
+            jobStagedHighestFinalizedIndex = new Map();
+            this.#highestFinalizedIndexForJob.set(jobId, jobStagedHighestFinalizedIndex);
+        }
+        return jobStagedHighestFinalizedIndex;
+    }
+    async #readHighestFinalizedIndex(jobId, secret) {
+        // Always issue DB read to keep IndexedDB transaction alive (they auto-commit when a new micro-task starts and there
+        // are no pending read requests). The staged value still takes precedence if it exists.
+        const dbValue = await this.#highestFinalizedIndex.getAsync(secret);
+        const staged = this.#getHighestFinalizedIndexForJob(jobId).get(secret);
+        return staged ?? dbValue;
+    }
+    #writeHighestFinalizedIndex(jobId, secret, index) {
+        this.#getHighestFinalizedIndexForJob(jobId).set(secret, index);
+    }
+    /**
+   * Writes all job-specific in-memory data to persistent storage.
+   *
+   * @remark This method must run in a DB transaction context. It's designed to be called from JobCoordinator#commitJob.
+   */ async commit(jobId) {
+        const highestAgedIndexForJob = this.#highestAgedIndexForJob.get(jobId);
+        if (highestAgedIndexForJob) {
+            for (const [secret, index] of highestAgedIndexForJob.entries()){
+                await this.#highestAgedIndex.set(secret, index);
+            }
+        }
+        const highestFinalizedIndexForJob = this.#highestFinalizedIndexForJob.get(jobId);
+        if (highestFinalizedIndexForJob) {
+            for (const [secret, index] of highestFinalizedIndexForJob.entries()){
+                await this.#highestFinalizedIndex.set(secret, index);
+            }
+        }
+        return this.discardStaged(jobId);
+    }
+    discardStaged(jobId) {
+        this.#highestAgedIndexForJob.delete(jobId);
+        this.#highestFinalizedIndexForJob.delete(jobId);
+        return Promise.resolve();
+    }
+    getHighestAgedIndex(secret, jobId) {
+        return this.#store.transactionAsync(()=>this.#readHighestAgedIndex(jobId, secret.toString()));
+    }
+    updateHighestAgedIndex(secret, index, jobId) {
+        return this.#store.transactionAsync(async ()=>{
+            const currentIndex = await this.#readHighestAgedIndex(jobId, 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})`);
+            }
+            this.#writeHighestAgedIndex(jobId, secret.toString(), index);
+        });
+    }
+    getHighestFinalizedIndex(secret, jobId) {
+        return this.#store.transactionAsync(()=>this.#readHighestFinalizedIndex(jobId, secret.toString()));
+    }
+    updateHighestFinalizedIndex(secret, index, jobId) {
+        return this.#store.transactionAsync(async ()=>{
+            const currentIndex = await this.#readHighestFinalizedIndex(jobId, 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})`);
+            }
+            this.#writeHighestFinalizedIndex(jobId, 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VuZGVyX2FkZHJlc3NfYm9va19zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0b3JhZ2UvdGFnZ2luZ19zdG9yZS9zZW5kZXJfYWRkcmVzc19ib29rX3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFpQixNQUFNLGlCQUFpQixDQUFDO0FBQ3hFLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUUzRDs7O0dBR0c7QUFDSCxxQkFBYSxzQkFBc0I7O0lBSWpDLFlBQVksS0FBSyxFQUFFLGlCQUFpQixFQUluQztJQUVELFNBQVMsQ0FBQyxPQUFPLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FVakQ7SUFFRCxVQUFVLElBQUksT0FBTyxDQUFDLFlBQVksRUFBRSxDQUFDLENBSXBDO0lBRUQsWUFBWSxDQUFDLE9BQU8sRUFBRSxZQUFZLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQVVwRDtDQUNGIn0=

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;IAED,SAAS,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAUjD;IAED,UAAU,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAIpC;IAED,YAAY,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAUpD;CACF"}

package/dest/storage/tagging_store/sender_address_book_store.js

@@ -0,0 +1,36 @@
+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');
+    }
+    addSender(address) {
+        return this.#store.transactionAsync(async ()=>{
+            if (await this.#addressBook.hasAsync(address.toString())) {
+                return false;
+            }
+            await this.#addressBook.set(address.toString(), true);
+            return true;
+        });
+    }
+    getSenders() {
+        return this.#store.transactionAsync(async ()=>{
+            return (await toArray(this.#addressBook.keysAsync())).map(AztecAddress.fromString);
+        });
+    }
+    removeSender(address) {
+        return this.#store.transactionAsync(async ()=>{
+            if (!await this.#addressBook.hasAsync(address.toString())) {
+                return false;
+            }
+            await this.#addressBook.delete(address.toString());
+            return true;
+        });
+    }
+}