@aztec/pxe 0.0.1-commit.d431d1c → 0.0.1-commit.d58ff9d0

package/dest/storage/private_event_store/private_event_store.js

@@ -1,86 +1,28 @@
 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';
+import { Semaphore } from '@aztec/foundation/queue';
+import { StoredPrivateEvent } from './stored_private_event.js';
 /**
  * Stores decrypted private event logs.
+ *
+ * Append-only: events are never deleted during normal operation. Reorgs are handled by delete-on-prune, which removes
+ * every event originating on a reorg'd block.
  */ export class PrivateEventStore {
     storeName = 'private_event';
     #store;
-    /** Map storing the actual private event log entries, keyed by siloedEventCommitment */ #eventLogs;
-    /** Multi-map from contractAddress_scope_eventSelector to siloedEventCommitment for efficient lookup */ #eventsByContractScopeSelector;
-    /** Multi-map from block number to siloedEventCommitment for rollback support */ #eventsByBlockNumber;
-    /** Map from siloedEventCommitment to boolean indicating if log has been seen. */ #seenLogs;
-    /** jobId => eventId (event siloed nullifier)  => PrivateEventEntry */ #eventLogsInJobStage;
+    /** 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 delete-on-prune. */ #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.#eventLogs = this.#store.openMap('private_event_logs');
-        this.#eventsByContractScopeSelector = this.#store.openMultiMap('events_by_contract_scope_selector');
-        this.#seenLogs = this.#store.openMap('seen_logs');
+        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.#eventLogsInJobStage = new Map();
-    }
-    #keyFor(contractAddress, scope, eventSelector) {
-        return `${contractAddress.toString()}_${scope.toString()}_${eventSelector.toString()}`;
-    }
-    async commit(jobId) {
-        await Promise.all([
-            ...this.#getEventLogsInJobStage(jobId).entries()
-        ].map(async ([eventId, eventEntry])=>{
-            this.logger.verbose('storing private event log (KV store)', eventEntry);
-            await Promise.all([
-                this.#eventLogs.set(eventId, eventEntry),
-                this.#eventsByContractScopeSelector.set(eventEntry.lookupKey, eventId),
-                this.#eventsByBlockNumber.set(eventEntry.l2BlockNumber, eventId),
-                this.#seenLogs.set(eventId, true)
-            ]);
-        }));
-        return this.discardStaged(jobId);
-    }
-    discardStaged(jobId) {
-        this.#eventLogsInJobStage.delete(jobId);
-        return Promise.resolve();
-    }
-    #getEventLogsInJobStage(jobId) {
-        let jobStage = this.#eventLogsInJobStage.get(jobId);
-        if (jobStage === undefined) {
-            jobStage = new Map();
-            this.#eventLogsInJobStage.set(jobId, jobStage);
-        }
-        return jobStage;
-    }
-    async #isSeenLog(jobId, eventId) {
-        const eventLogsInJobStage = this.#getEventLogsInJobStage(jobId).get(eventId);
-        return !!eventLogsInJobStage || !!await this.#seenLogs.getAsync(eventId);
-    }
-    #addEventLogToStage(jobId, eventId, eventEntry) {
-        this.#getEventLogsInJobStage(jobId).set(eventId, eventEntry);
-    }
-    async #getEventSiloedNullifiers(contractAddress, scope, eventSelector, jobId) {
-        const key = this.#keyFor(contractAddress, scope, eventSelector);
-        const eventSiloedNullifiersInStorage = [];
-        for await (const eventId of this.#eventsByContractScopeSelector.getValuesAsync(key)){
-            eventSiloedNullifiersInStorage.push(eventId);
-        }
-        if (!jobId) {
-            return eventSiloedNullifiersInStorage;
-        }
-        const eventSiloedNullifiersInJobStage = new Set([
-            ...this.#getEventLogsInJobStage(jobId).entries()
-        ].filter(([_, entry])=>entry.lookupKey === key).map(([idx, _])=>idx));
-        return [
-            ...new Set(eventSiloedNullifiersInStorage).union(eventSiloedNullifiersInJobStage)
-        ];
-    }
-    async #getEventLogBySiloedNullifier(eventId, jobId) {
-        if (jobId) {
-            return this.#getEventLogsInJobStage(jobId).get(eventId) ?? await this.#eventLogs.getAsync(eventId);
-        } else {
-            return await this.#eventLogs.getAsync(eventId);
-        }
+        this.#eventsForJob = new Map();
+        this.#jobLocks = new Map();
     }
     /**
    * Store a private event log.
@@ -94,37 +36,27 @@ import { TxHash } from '@aztec/stdlib/tx';
    *  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) {
-        const { contractAddress, scope, txHash, l2BlockNumber, l2BlockHash, txIndexInBlock, eventIndexInTx } = metadata;
-        return this.#store.transactionAsync(async ()=>{
-            const key = this.#keyFor(contractAddress, scope, eventSelector);
-            // The siloed event commitment is guaranteed to be unique as it's inserted into the nullifier tree. For this
-            // reason we use it as id.
-            const eventId = siloedEventCommitment.toString();
-            const hasBeenSeen = await this.#isSeenLog(jobId, eventId);
-            if (hasBeenSeen) {
-                this.logger.verbose('Ignoring duplicate event log', {
-                    txHash: txHash.toString(),
-                    siloedEventCommitment
+        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
                 });
-                return;
-            }
-            this.logger.verbose('storing private event log (job stage)', {
-                contractAddress,
-                scope,
-                msgContent,
-                l2BlockNumber
-            });
-            this.#addEventLogToStage(jobId, eventId, {
-                randomness,
-                msgContent: serializeToBuffer(msgContent),
-                l2BlockNumber,
-                l2BlockHash: l2BlockHash.toBuffer(),
-                txHash: txHash.toBuffer(),
-                txIndexInBlock,
-                eventIndexInTx,
-                lookupKey: key
-            });
-        });
+                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.
@@ -136,87 +68,206 @@ import { TxHash } from '@aztec/stdlib/tx';
    *  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.
-   */ async getPrivateEvents(eventSelector, filter) {
-        const events = [];
-        for (const scope of filter.scopes){
-            const eventIds = await this.#getEventSiloedNullifiers(filter.contractAddress, scope, eventSelector);
-            for (const eventId of eventIds){
-                const entry = await this.#getEventLogBySiloedNullifier(eventId);
-                if (!entry || entry.l2BlockNumber < filter.fromBlock || entry.l2BlockNumber >= filter.toBlock) {
+   */ 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;
                 }
-                // Convert buffer back to Fr array
-                const reader = BufferReader.asReader(entry.msgContent);
-                const numFields = entry.msgContent.length / Fr.SIZE_IN_BYTES;
-                const msgContent = reader.readArray(numFields, Fr);
-                const txHash = TxHash.fromBuffer(entry.txHash);
-                const l2BlockHash = L2BlockHash.fromBuffer(entry.l2BlockHash);
-                if (filter.txHash && !txHash.equals(filter.txHash)) {
+                // Filter by txHash
+                if (filter.txHash && !storedPrivateEvent.txHash.equals(filter.txHash)) {
                     continue;
                 }
                 events.push({
-                    l2BlockNumber: entry.l2BlockNumber,
-                    txIndexInBlock: entry.txIndexInBlock,
-                    eventIndexInTx: entry.eventIndexInTx,
+                    l2BlockNumber: storedPrivateEvent.l2BlockNumber,
+                    txIndexInBlock: storedPrivateEvent.txIndexInBlock,
+                    eventIndexInTx: storedPrivateEvent.eventIndexInTx,
                     event: {
-                        packedEvent: msgContent,
-                        l2BlockNumber: BlockNumber(entry.l2BlockNumber),
-                        txHash,
-                        l2BlockHash,
+                        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);
+        });
+    }
+    /** Returns the ids (siloed event commitments) of all events emitted at the given block number. Used by delete-on-prune. */ async eventIdsAtBlock(blockNumber) {
+        const eventIds = [];
+        for await (const eventId of this.#eventsByBlockNumber.getValuesAsync(blockNumber)){
+            eventIds.push(eventId);
         }
-        // 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 eventIds;
+    }
+    /**
+   * Rolls the store back to `toBlock`: deletes every event anchored to a block strictly above it, as if nothing past
+   * that block height ever happened. Used by the reorg (`chain-pruned`) path to truncate the orphaned tail. Scanning
+   * from `toBlock + 1` upward covers everything above the rollback target without needing to know the chain tip.
+   *
+   * Must be called inside a transaction owned by the caller (it issues no `transactionAsync` of its own, the reorg
+   * path wraps it together with the anchor update, and IndexedDB has no nested transactions). Throws if any job has
+   * uncommitted staged writes, since rolling back mid-job could later re-introduce events anchored to deleted blocks.
+   */ async rollback(toBlock) {
+        if (this.#eventsForJob.size > 0) {
+            throw new Error('PXE private event store rollback is not allowed while jobs are running');
+        }
+        // Snapshot before mutating so we never delete from the multimap we are iterating.
+        const orphaned = [];
+        for await (const [block, eventId] of this.#eventsByBlockNumber.entriesAsync({
+            start: toBlock + 1
+        })){
+            orphaned.push({
+                block,
+                eventId
+            });
+        }
+        let removedCount = 0;
+        for (const { block, eventId } of orphaned){
+            const buf = await this.#events.getAsync(eventId);
+            if (!buf) {
+                throw new Error(`Event not found for eventId ${eventId}`);
             }
-            return a.eventIndexInTx - b.eventIndexInTx;
+            const stored = StoredPrivateEvent.fromBuffer(buf);
+            await this.#events.delete(eventId);
+            await this.#eventsByContractAndEventSelector.deleteValue(this.#keyFor(stored.contractAddress, stored.eventSelector), eventId);
+            await this.#eventsByBlockNumber.deleteValue(block, eventId);
+            removedCount++;
+        }
+        this.logger.verbose('rolled back private events', {
+            removedCount,
+            toBlock
         });
-        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).
+   * Commits in memory job data to persistent storage.
    *
-   * We don't need staged writes for a rollback since it's handled in the context of a blockchain rewind.
+   * Called by JobCoordinator when a job completes successfully.
    *
-   * 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.
+   * 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).
    *
-   * 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).
+   * @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.
    *
-   * For further details, refer to `BlockSynchronizer#handleBlockStreamEvent`.
+   * 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.
    *
-   * IMPORTANT: This method must be called within a transaction to ensure atomicity.
-   */ async rollback(blockNumber, synchedBlockNumber) {
-        let removedCount = 0;
-        for(let block = blockNumber + 1; block <= synchedBlockNumber; block++){
-            const eventIds = [];
-            for await (const eventId of this.#eventsByBlockNumber.getValuesAsync(block)){
-                eventIds.push(eventId);
-            }
-            if (eventIds.length > 0) {
-                await this.#eventsByBlockNumber.delete(block);
-                for (const eventId of eventIds){
-                    const entry = await this.#eventLogs.getAsync(eventId);
-                    if (!entry) {
-                        throw new Error(`Event log not found for eventId ${eventId}`);
-                    }
-                    await this.#eventLogs.delete(eventId);
-                    await this.#seenLogs.delete(eventId);
-                    await this.#eventsByContractScopeSelector.deleteValue(entry.lookupKey, eventId);
-                    removedCount++;
-                }
-            }
+   * 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);
         }
-        this.logger.verbose(`Rolled back ${removedCount} private events after block ${blockNumber}`);
+        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 = BlockHash.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/store_identity.d.ts

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

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

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

package/dest/storage/store_identity.js

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

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

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

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

@@ -1 +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"}
+{"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,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAC9E,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC"}

package/dest/storage/tagging_store/index.js

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