@aztec-labs/pxe 6.0.0-nightly.20260829

package/dest/storage/note_store/note_store.js

@@ -0,0 +1,273 @@
+import { createLogger } from '@aztec-labs/foundation/log';
+import { allToCompletion } from '@aztec-labs/foundation/promise';
+import { NoteStatus } from '@aztec-labs/stdlib/note';
+import { BaseStagingStore } from '../base_staging_store.js';
+import { StoredNote } from './stored_note.js';
+/**
+ * NoteStore manages the storage and retrieval of notes using an append-only model.
+ *
+ * Notes are written once (keyed by siloedNullifier) and never mutated. They might be deleted in case of reorg though.
+ * Nullifier emissions are recorded as separate append-only entries: a map from nullifier to the number of the block
+ * that emitted it.
+ *
+ * Reorgs are handled by delete-on-prune: the `chain-pruned` event triggers deletion of every note and nullifier
+ * originating on a reorg'd block.
+ */ export class NoteStore extends BaseStagingStore {
+    #logger = createLogger('note_store');
+    constructor(store){
+        super({
+            storeName: 'note',
+            store,
+            buildChangeSet: ()=>({
+                    notes: new Map(),
+                    nullifierEmissions: new Map()
+                }),
+            buildDb: (db)=>({
+                    notes: db.openMap('notes'),
+                    notesByContractAddress: db.openMultiMap('note_nullifiers_by_contract'),
+                    notesByBlockNumber: db.openMultiMap('note_nullifiers_by_block'),
+                    nullifierEmissions: db.openMap('note_nullifications_by_nullifier'),
+                    nullifierEmissionsByBlockNumber: db.openMultiMap('note_nullifications_by_block')
+                })
+        });
+    }
+    /**
+   * Adds multiple notes to the notes store under the specified scope.
+   *
+   * Notes are stored using their siloedNullifier as the key, which provides uniqueness. Each note is indexed by
+   * multiple criteria for efficient retrieval.
+   *
+   * @param notes - Notes to store
+   * @param scope - The scope (user/account) under which to store the notes
+   * @param changeSetId - The change set to stage writes under
+   */ addNotes(notes, scope, changeSetId) {
+        return this.withChangeSetAndDb(changeSetId, (changeSet, db)=>allToCompletion(notes.map(async (note)=>{
+                const noteForChangeSet = await this.#readNote(changeSet, db, note.siloedNullifier.toString()) ?? new StoredNote(note, new Set());
+                noteForChangeSet.addScope(scope.toString());
+                changeSet.notes.set(note.siloedNullifier.toString(), noteForChangeSet);
+            })));
+    }
+    async #readNote(changeSet, db, nullifier) {
+        // 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 noteBuffer = await db.notes.getAsync(nullifier);
+        const noteForChangeSet = changeSet.notes.get(nullifier);
+        return noteForChangeSet ?? (noteBuffer ? StoredNote.fromBuffer(noteBuffer) : undefined);
+    }
+    /**
+   * Reads the block number at which a note's nullifier was emitted, layering the current change set's emission over
+   * committed state, the nullifier emission counterpart to {@link #readNote}. Returns the emission block number if the
+   * nullifier has been emitted (committed or currently staged), or `undefined` if it has not.
+   */ async #readNullifierEmission(changeSet, db, nullifier) {
+        // Always issue the DB read to keep the IndexedDB transaction alive (see #readNote); the staged emission still takes
+        // precedence if present.
+        const committed = await db.nullifierEmissions.getAsync(nullifier);
+        return changeSet.nullifierEmissions.get(nullifier) ?? committed;
+    }
+    /**
+   * Retrieves notes based on the provided filter criteria.
+   *
+   * A note is considered nullified iff its corresponding nullifier emission has been recorded.
+   *
+   * All DB reads are kicked off before any await so IndexedDB does not auto-commit the transaction mid-read.
+   *
+   * @param filter - Filter criteria including contractAddress (required), and optional owner,
+   *                 storageSlot, status, scopes, and siloedNullifier.
+   * @param changeSetId - the change set to read staged data from.
+   * @returns Filtered and deduplicated notes (a note might be present in multiple scopes, but returned at most once)
+   */ getNotes(filter, changeSetId) {
+        return this.withChangeSetAndDb(changeSetId, async (changeSet, db)=>{
+            if (filter.scopes.length === 0) {
+                return [];
+            }
+            const targetStatus = filter.status ?? NoteStatus.ACTIVE;
+            // Collect note-read and nullifier-emission-read promises together in one map so all DB reads are in-flight
+            // before any await. This keeps the IndexedDB transaction alive (IndexedDB auto-commits when a new micro-task
+            // starts with no pending read requests), so both promises must be started during the synchronous iteration.
+            const candidates = new Map();
+            // Committed notes indexed by contract address
+            for await (const nullifier of db.notesByContractAddress.getValuesAsync(filter.contractAddress.toString())){
+                candidates.set(nullifier, {
+                    notePromise: this.#readNote(changeSet, db, nullifier),
+                    nullificationPromise: this.#readNullifierEmission(changeSet, db, nullifier)
+                });
+            }
+            // Staged notes from the current change set (not yet committed to the DB index)
+            for (const storedNote of changeSet.notes.values()){
+                if (storedNote.noteDao.contractAddress.equals(filter.contractAddress)) {
+                    const nullifier = storedNote.noteDao.siloedNullifier.toString();
+                    if (!candidates.has(nullifier)) {
+                        candidates.set(nullifier, {
+                            notePromise: Promise.resolve(storedNote),
+                            nullificationPromise: this.#readNullifierEmission(changeSet, db, nullifier)
+                        });
+                    }
+                }
+            }
+            // Await all DB reads together before the await-free tail.
+            const entries = [
+                ...candidates.entries()
+            ];
+            const notes = await allToCompletion(entries.map(([, { notePromise }])=>notePromise));
+            const nullifierEmissions = await allToCompletion(entries.map(([, { nullificationPromise }])=>nullificationPromise));
+            // Await-free tail: filter and sort. No DB ops from here on.
+            // Build a lookup: nullifier => emission block number
+            const emissionByNullifier = new Map();
+            for(let i = 0; i < entries.length; i++){
+                emissionByNullifier.set(entries[i][0], nullifierEmissions[i]);
+            }
+            const foundNotes = new Map();
+            for (const note of notes){
+                // Defensive: hitting this case means we're mishandling contract indices or in-memory staged data
+                if (!note) {
+                    throw new Error('PXE note database is corrupted.');
+                }
+                // A note is nullified once its nullifier emission has been recorded (committed or currently staged).
+                const nullified = emissionByNullifier.get(note.noteDao.siloedNullifier.toString()) !== undefined;
+                if (targetStatus === NoteStatus.ACTIVE && nullified) {
+                    continue;
+                }
+                if (filter.owner && !note.noteDao.owner.equals(filter.owner)) {
+                    continue;
+                }
+                if (filter.storageSlot && !note.noteDao.storageSlot.equals(filter.storageSlot)) {
+                    continue;
+                }
+                if (filter.siloedNullifier && !note.noteDao.siloedNullifier.equals(filter.siloedNullifier)) {
+                    continue;
+                }
+                if (note.scopes.intersection(new Set(filter.scopes.map((s)=>s.toString()))).size === 0) {
+                    continue;
+                }
+                foundNotes.set(note.noteDao.siloedNullifier.toString(), note.noteDao);
+            }
+            // Sort by block number, then by tx index within block, then by note index within tx
+            return [
+                ...foundNotes.values()
+            ].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.noteIndexInTx - b.noteIndexInTx;
+            });
+        });
+    }
+    /**
+   * Records emission of the given siloed nullifiers, which causes notes to be considered nullified.
+   *
+   * Each nullifier gets an append-only entry recording the block number at which it was emitted.
+   *
+   * Every nullifier passed must correspond to a note already present in this store. Callers only apply nullifiers for
+   * notes of scopes they track, and a note is always discovered before the nullifier that spends it, so a nullifier
+   * with no matching note signals a bug (broken nonce/index discovery, a sync-ordering error, store corruption, etc).
+   *
+   * `applyNullifiers` is idempotent: a nullifier whose emission is already recorded (committed or currently staged) is
+   * skipped, so re-applying it neither re-writes the emission, changes note visibility, nor appears in the result.
+   *
+   * @param siloedNullifiers - Array of nullifiers with their block locations to record
+   * @param changeSetId - The change set to stage writes under
+   * @returns The notes that transition from active to nullified in this call; already-nullified notes are skipped, so
+   *          a repeat application returns an empty array.
+   * @throws If any nullifier has no matching note in this store, or was emitted at block 0.
+   */ applyNullifiers(siloedNullifiers, changeSetId) {
+        if (siloedNullifiers.length === 0) {
+            return Promise.resolve([]);
+        }
+        if (siloedNullifiers.some((n)=>n.l2BlockNumber === 0)) {
+            return Promise.reject(new Error('applyNullifiers: nullifiers cannot have been emitted at block 0'));
+        }
+        return this.withChangeSetAndDb(changeSetId, async (changeSet, db)=>{
+            // Kick off the note read and the existing-emission read together during the synchronous map so all are in
+            // flight before the first await, which keeps the IndexedDB transaction alive.
+            const resolved = await allToCompletion(siloedNullifiers.map(async (nullifier)=>{
+                const key = nullifier.data.toString();
+                const [storedNote, existingEmission] = await allToCompletion([
+                    this.#readNote(changeSet, db, key),
+                    this.#readNullifierEmission(changeSet, db, key)
+                ]);
+                if (!storedNote) {
+                    throw new Error(`Attempted to mark a note as nullified which does not exist in PXE DB: ${key}`);
+                }
+                return {
+                    nullifier,
+                    storedNote,
+                    alreadyEmitted: existingEmission !== undefined
+                };
+            }));
+            // Await-free tail: record an emission only for notes not already nullified, and return exactly those that
+            // transition active -> nullified in this call.
+            const affected = [];
+            for (const { nullifier, storedNote, alreadyEmitted } of resolved){
+                if (alreadyEmitted) {
+                    continue;
+                }
+                changeSet.nullifierEmissions.set(nullifier.data.toString(), nullifier.l2BlockNumber);
+                affected.push(storedNote.noteDao);
+            }
+            return affected;
+        });
+    }
+    async flushChangeSet(changeSet, db) {
+        for (const [nullifier, storedNote] of changeSet.notes){
+            await db.notes.set(nullifier, storedNote.toBuffer());
+            await db.notesByContractAddress.set(storedNote.noteDao.contractAddress.toString(), nullifier);
+            await db.notesByBlockNumber.set(storedNote.noteDao.l2BlockNumber, nullifier);
+        }
+        for (const [nullifier, blockNumber] of changeSet.nullifierEmissions){
+            await db.nullifierEmissions.set(nullifier, blockNumber);
+            await db.nullifierEmissionsByBlockNumber.set(blockNumber, nullifier);
+        }
+    }
+    /**
+   * Deletes every note and nullifier emission originating on a block strictly above `toBlock`, as if nothing past that
+   * block height ever happened, retracting notes and nullifiers on a reorg.
+   */ async applyRollback(toBlock, db) {
+        // Snapshot the orphaned (block, nullifier) pairs before mutating so we never delete from the cursor we are
+        // iterating. Scanning from `toBlock + 1` upward covers everything above the rollback target without needing to know
+        // the chain tip. Each nullifier's rows are independent (nullifiers are globally unique), so the deletes run
+        // concurrently. Keeping requests in flight also prevents the IndexedDB transaction from auto-committing mid-way.
+        const orphanedNotes = [];
+        for await (const [block, siloedNullifier] of db.notesByBlockNumber.entriesAsync({
+            start: toBlock + 1
+        })){
+            orphanedNotes.push({
+                block,
+                siloedNullifier
+            });
+        }
+        let removedNotes = 0;
+        await allToCompletion(orphanedNotes.map(async ({ block, siloedNullifier })=>{
+            const buf = await db.notes.getAsync(siloedNullifier);
+            if (!buf) {
+                throw new Error(`Note not found for siloedNullifier ${siloedNullifier}`);
+            }
+            const stored = StoredNote.fromBuffer(buf);
+            await db.notes.delete(siloedNullifier);
+            await db.notesByContractAddress.deleteValue(stored.noteDao.contractAddress.toString(), siloedNullifier);
+            await db.notesByBlockNumber.deleteValue(block, siloedNullifier);
+            removedNotes++;
+        }));
+        // Same procedure, with nullifier emissions
+        const orphanedEmissions = [];
+        for await (const [block, siloedNullifier] of db.nullifierEmissionsByBlockNumber.entriesAsync({
+            start: toBlock + 1
+        })){
+            orphanedEmissions.push({
+                block,
+                siloedNullifier
+            });
+        }
+        await allToCompletion(orphanedEmissions.map(async ({ block, siloedNullifier })=>{
+            await db.nullifierEmissions.delete(siloedNullifier);
+            await db.nullifierEmissionsByBlockNumber.deleteValue(block, siloedNullifier);
+        }));
+        this.#logger.verbose('rolled back notes and nullifier emissions', {
+            removedNotes,
+            removedNullifierEmissions: orphanedEmissions.length,
+            toBlock
+        });
+    }
+}

package/dest/storage/note_store/stored_note.d.ts

@@ -0,0 +1,11 @@
+import { NoteDao } from '@aztec-labs/stdlib/note';
+/** A note as stored by the PXE: the note DAO plus the scopes that observed it. Append-only — never mutated. */
+export declare class StoredNote {
+    readonly noteDao: NoteDao;
+    readonly scopes: Set<string>;
+    constructor(noteDao: NoteDao, scopes: Set<string>);
+    static fromBuffer(buffer: Buffer): StoredNote;
+    toBuffer(): Buffer;
+    addScope(scope: string): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmVkX25vdGUuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL25vdGVfc3RvcmUvc3RvcmVkX25vdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRWxELGlIQUErRztBQUMvRyxxQkFBYSxVQUFVO0lBRW5CLFFBQVEsQ0FBQyxPQUFPLEVBQUUsT0FBTztJQUN6QixRQUFRLENBQUMsTUFBTSxFQUFFLEdBQUcsQ0FBQyxNQUFNLENBQUM7SUFGOUIsWUFDVyxPQUFPLEVBQUUsT0FBTyxFQUNoQixNQUFNLEVBQUUsR0FBRyxDQUFDLE1BQU0sQ0FBQyxFQUMxQjtJQUVKLE1BQU0sQ0FBQyxVQUFVLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxVQUFVLENBSzVDO0lBRUQsUUFBUSxJQUFJLE1BQU0sQ0FHakI7SUFFRCxRQUFRLENBQUMsS0FBSyxFQUFFLE1BQU0sR0FBRyxJQUFJLENBRTVCO0NBQ0YifQ==

package/dest/storage/note_store/stored_note.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stored_note.d.ts","sourceRoot":"","sources":["../../../src/storage/note_store/stored_note.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAElD,iHAA+G;AAC/G,qBAAa,UAAU;IAEnB,QAAQ,CAAC,OAAO,EAAE,OAAO;IACzB,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC;IAF9B,YACW,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,EAC1B;IAEJ,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAK5C;IAED,QAAQ,IAAI,MAAM,CAGjB;IAED,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAE5B;CACF"}

package/dest/storage/note_store/stored_note.js

@@ -0,0 +1,27 @@
+import { BufferReader, serializeToBuffer } from '@aztec-labs/foundation/serialize';
+import { NoteDao } from '@aztec-labs/stdlib/note';
+/** A note as stored by the PXE: the note DAO plus the scopes that observed it. Append-only — never mutated. */ export class StoredNote {
+    noteDao;
+    scopes;
+    constructor(noteDao, scopes){
+        this.noteDao = noteDao;
+        this.scopes = scopes;
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        const noteDao = NoteDao.fromBuffer(reader);
+        const scopes = reader.readVector({
+            fromBuffer: (r)=>r.readString()
+        });
+        return new StoredNote(noteDao, new Set(scopes));
+    }
+    toBuffer() {
+        const scopesArray = [
+            ...this.scopes
+        ];
+        return serializeToBuffer(this.noteDao, scopesArray.length, ...scopesArray);
+    }
+    addScope(scope) {
+        this.scopes.add(scope);
+    }
+}

package/dest/storage/note_store/test_utils.d.ts

@@ -0,0 +1,9 @@
+import type { NoteDao } from '@aztec-labs/stdlib/note';
+import type { NotesFilter } from '../../notes_filter.js';
+import type { NoteStore } from './note_store.js';
+/**
+ * Reads notes in a change set opened and closed around the read. A test that reads and then rolls back needs this: the
+ * store rejects a rollback while a change set is open.
+ */
+export declare function readNotes(store: NoteStore, filter: NotesFilter): Promise<NoteDao[]>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdF91dGlscy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0b3JhZ2Uvbm90ZV9zdG9yZS90ZXN0X3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLE9BQU8sRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRXZELE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ3pELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRWpEOzs7R0FHRztBQUNILHdCQUFzQixTQUFTLENBQUMsS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLEVBQUUsV0FBVyxHQUFHLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQU16RiJ9

package/dest/storage/note_store/test_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test_utils.d.ts","sourceRoot":"","sources":["../../../src/storage/note_store/test_utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAEvD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;;GAGG;AACH,wBAAsB,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAMzF"}

package/dest/storage/note_store/test_utils.js

@@ -0,0 +1,10 @@
+/**
+ * Reads notes in a change set opened and closed around the read. A test that reads and then rolls back needs this: the
+ * store rejects a rollback while a change set is open.
+ */ export async function readNotes(store, filter) {
+    const changeSetId = 'read-change-set';
+    store.beginChangeSet(changeSetId);
+    const notes = await store.getNotes(filter, changeSetId);
+    store.discardChangeSet(changeSetId);
+    return notes;
+}

package/dest/storage/open_pxe_stores.d.ts

@@ -0,0 +1,35 @@
+import { KeyStore } from '@aztec-labs/key-store';
+import type { AztecAsyncKVStore } from '@aztec-labs/kv-store';
+import { L2TipsKVStore } from '@aztec-labs/kv-store/stores';
+import type { BlockHash } from '@aztec-labs/stdlib/block';
+import { AddressStore } from './address_store/address_store.js';
+import { AnchorBlockStore } from './anchor_block_store/anchor_block_store.js';
+import { CapsuleStore } from './capsule_store/capsule_store.js';
+import { ContractStore } from './contract_store/contract_store.js';
+import { FactStore } from './fact_store/fact_store.js';
+import { NoteStore } from './note_store/note_store.js';
+import { PrivateEventStore } from './private_event_store/private_event_store.js';
+import { RecipientTaggingStore, SenderTaggingStore, TaggingSecretSourcesStore } from './tagging_store/index.js';
+/**
+ * The set of sub-stores opened against a single `AztecAsyncKVStore` to back PXE state.
+ */
+export type PxeStores = {
+    addressStore: AddressStore;
+    privateEventStore: PrivateEventStore;
+    contractStore: ContractStore;
+    noteStore: NoteStore;
+    anchorBlockStore: AnchorBlockStore;
+    senderTaggingStore: SenderTaggingStore;
+    taggingSecretSourcesStore: TaggingSecretSourcesStore;
+    recipientTaggingStore: RecipientTaggingStore;
+    capsuleStore: CapsuleStore;
+    keyStore: KeyStore;
+    l2TipsStore: L2TipsKVStore;
+    factStore: FactStore;
+};
+/**
+ * Opens every PXE sub-store against the given backing store. The `initialBlockHash` seeds the
+ * `L2TipsKVStore` so it agrees with the node's archiver on the dynamic genesis header hash.
+ */
+export declare function openPxeStores(store: AztecAsyncKVStore, initialBlockHash: BlockHash): PxeStores;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3Blbl9weGVfc3RvcmVzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3RvcmFnZS9vcGVuX3B4ZV9zdG9yZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ2pELE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFDOUQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQzVELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRTFELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQztBQUNoRSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSw0Q0FBNEMsQ0FBQztBQUM5RSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFDaEUsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQ25FLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUN2RCxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDdkQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sOENBQThDLENBQUM7QUFDakYsT0FBTyxFQUFFLHFCQUFxQixFQUFFLGtCQUFrQixFQUFFLHlCQUF5QixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFFaEg7O0dBRUc7QUFDSCxNQUFNLE1BQU0sU0FBUyxHQUFHO0lBQ3RCLFlBQVksRUFBRSxZQUFZLENBQUM7SUFDM0IsaUJBQWlCLEVBQUUsaUJBQWlCLENBQUM7SUFDckMsYUFBYSxFQUFFLGFBQWEsQ0FBQztJQUM3QixTQUFTLEVBQUUsU0FBUyxDQUFDO0lBQ3JCLGdCQUFnQixFQUFFLGdCQUFnQixDQUFDO0lBQ25DLGtCQUFrQixFQUFFLGtCQUFrQixDQUFDO0lBQ3ZDLHlCQUF5QixFQUFFLHlCQUF5QixDQUFDO0lBQ3JELHFCQUFxQixFQUFFLHFCQUFxQixDQUFDO0lBQzdDLFlBQVksRUFBRSxZQUFZLENBQUM7SUFDM0IsUUFBUSxFQUFFLFFBQVEsQ0FBQztJQUNuQixXQUFXLEVBQUUsYUFBYSxDQUFDO0lBQzNCLFNBQVMsRUFBRSxTQUFTLENBQUM7Q0FDdEIsQ0FBQztBQUVGOzs7R0FHRztBQUNILHdCQUFnQixhQUFhLENBQUMsS0FBSyxFQUFFLGlCQUFpQixFQUFFLGdCQUFnQixFQUFFLFNBQVMsR0FBRyxTQUFTLENBZTlGIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"open_pxe_stores.d.ts","sourceRoot":"","sources":["../../src/storage/open_pxe_stores.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE1D,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAC9E,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AACnE,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,8CAA8C,CAAC;AACjF,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAEhH;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,YAAY,EAAE,YAAY,CAAC;IAC3B,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,aAAa,EAAE,aAAa,CAAC;IAC7B,SAAS,EAAE,SAAS,CAAC;IACrB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,yBAAyB,EAAE,yBAAyB,CAAC;IACrD,qBAAqB,EAAE,qBAAqB,CAAC;IAC7C,YAAY,EAAE,YAAY,CAAC;IAC3B,QAAQ,EAAE,QAAQ,CAAC;IACnB,WAAW,EAAE,aAAa,CAAC;IAC3B,SAAS,EAAE,SAAS,CAAC;CACtB,CAAC;AAEF;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,SAAS,GAAG,SAAS,CAe9F"}

package/dest/storage/open_pxe_stores.js

@@ -0,0 +1,29 @@
+import { KeyStore } from '@aztec-labs/key-store';
+import { L2TipsKVStore } from '@aztec-labs/kv-store/stores';
+import { AddressStore } from './address_store/address_store.js';
+import { AnchorBlockStore } from './anchor_block_store/anchor_block_store.js';
+import { CapsuleStore } from './capsule_store/capsule_store.js';
+import { ContractStore } from './contract_store/contract_store.js';
+import { FactStore } from './fact_store/fact_store.js';
+import { NoteStore } from './note_store/note_store.js';
+import { PrivateEventStore } from './private_event_store/private_event_store.js';
+import { RecipientTaggingStore, SenderTaggingStore, TaggingSecretSourcesStore } from './tagging_store/index.js';
+/**
+ * Opens every PXE sub-store against the given backing store. The `initialBlockHash` seeds the
+ * `L2TipsKVStore` so it agrees with the node's archiver on the dynamic genesis header hash.
+ */ export function openPxeStores(store, initialBlockHash) {
+    return {
+        addressStore: new AddressStore(store),
+        privateEventStore: new PrivateEventStore(store),
+        contractStore: new ContractStore(store),
+        noteStore: new NoteStore(store),
+        anchorBlockStore: new AnchorBlockStore(store),
+        senderTaggingStore: new SenderTaggingStore(store),
+        taggingSecretSourcesStore: new TaggingSecretSourcesStore(store),
+        recipientTaggingStore: new RecipientTaggingStore(store),
+        capsuleStore: new CapsuleStore(store),
+        keyStore: new KeyStore(store),
+        l2TipsStore: new L2TipsKVStore(store, 'pxe', initialBlockHash),
+        factStore: new FactStore(store)
+    };
+}

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

@@ -0,0 +1,90 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { AztecAsyncKVStore } from '@aztec-labs/kv-store';
+import type { EventSelector } from '@aztec-labs/stdlib/abi';
+import type { AztecAddress } from '@aztec-labs/stdlib/aztec-address';
+import type { InTx, TxHash } from '@aztec-labs/stdlib/tx';
+import type { PackedPrivateEvent } from '../../pxe.js';
+import type { Rollbackable } from '../rollbackable.js';
+import type { ChangeSetId, StagedStore } from '../staged_write_coordinator.js';
+export type PrivateEventStoreFilter = {
+    contractAddress: AztecAddress;
+    fromBlock: number;
+    toBlock: number;
+    scopes: AztecAddress[];
+    txHash?: TxHash;
+};
+type PrivateEventMetadata = InTx & {
+    contractAddress: AztecAddress;
+    scope: AztecAddress;
+    /** The index of the tx within the block */
+    txIndexInBlock: number;
+    /** The index of the event within the tx (based on nullifier position) */
+    eventIndexInTx: number;
+};
+/**
+ * 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 declare class PrivateEventStore implements StagedStore, Rollbackable {
+    #private;
+    readonly storeName: string;
+    logger: import("@aztec-labs/foundation/log").Logger;
+    constructor(store: AztecAsyncKVStore);
+    /**
+     * 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: EventSelector, randomness: Fr, msgContent: Fr[], siloedEventCommitment: Fr, metadata: PrivateEventMetadata, changeSetId: ChangeSetId): 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 in which the event was
+     * included.
+     */
+    getPrivateEvents(eventSelector: EventSelector, filter: PrivateEventStoreFilter): Promise<PackedPrivateEvent[]>;
+    /** Returns the ids (siloed event commitments) of all events emitted at the given block number. Used by delete-on-prune. */
+    eventIdsAtBlock(blockNumber: number): Promise<string[]>;
+    /**
+     * 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 change set has
+     * uncommitted staged writes, since rolling back mid-change-set could later re-introduce events anchored to deleted
+     * blocks.
+     */
+    rollbackToBlock(toBlock: number): Promise<void>;
+    /**
+     * Commits in-memory staged data to persistent storage.
+     *
+     * Called by StagedWriteCoordinator when an operation completes successfully.
+     *
+     * Note: StagedWriteCoordinator 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 changeSetId - The changeSetId identifying which staged data to commit
+     */
+    commitChangeSet(changeSetId: ChangeSetId): Promise<void>;
+    /**
+     * Discards in-memory staged data without persisting it.
+     */
+    discardChangeSet(changeSetId: ChangeSetId): void;
+}
+export {};
+//# sourceMappingURL=data:application/json;base64,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

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,qCAAqC,CAAC;AAIzD,OAAO,KAAK,EAAE,iBAAiB,EAAqC,MAAM,sBAAsB,CAAC;AACjG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAG/E,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;AAEF,KAAK,oBAAoB,GAAG,IAAI,GAAG;IACjC,eAAe,EAAE,YAAY,CAAC;IAC9B,KAAK,EAAE,YAAY,CAAC;IACpB,2CAA2C;IAC3C,cAAc,EAAE,MAAM,CAAC;IACvB,yEAAyE;IACzE,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAQF;;;;;GAKG;AACH,qBAAa,iBAAkB,YAAW,WAAW,EAAE,YAAY;;IACjE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAmB;IAgB7C,MAAM,8CAAuC;IAE7C,YAAY,KAAK,EAAE,iBAAiB,EAQnC;IAED;;;;;;;;;;;OAWG;IACH,oBAAoB,CAClB,aAAa,EAAE,aAAa,EAC5B,UAAU,EAAE,EAAE,EACd,UAAU,EAAE,EAAE,EAAE,EAChB,qBAAqB,EAAE,EAAE,EACzB,QAAQ,EAAE,oBAAoB,EAC9B,WAAW,EAAE,WAAW,iBAyCzB;IAED;;;;;;;;;;OAUG;IACI,gBAAgB,CACrB,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,uBAAuB,GAC9B,OAAO,CAAC,kBAAkB,EAAE,CAAC,CA+E/B;IAED,2HAA2H;IAC9G,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAMnE;IAED;;;;;;;;;OASG;IACU,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAyB3D;IAED;;;;;;;;;OASG;IACG,eAAe,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAgB7D;IAED;;OAEG;IACH,gBAAgB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAE/C;CA0EF"}