@aztec/pxe 3.0.0-canary.a9708bd → 3.0.0-devnet.2-patch.1

package/dest/storage/note_data_provider/note_data_provider.js

@@ -2,8 +2,13 @@ import { toBufferBE } from '@aztec/foundation/bigint-buffer';
 import { toArray } from '@aztec/foundation/iterable';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { NoteStatus } from '@aztec/stdlib/note';
-import { NoteDao } from './note_dao.js';
-export class NoteDataProvider {
+import { NoteDao } from '@aztec/stdlib/note';
+/**
+ * NoteDataProvider manages the storage and retrieval of notes.
+ *
+ * Notes can be active or nullified. This class processes new notes, nullifications,
+ * and performs rollback handling in the case of a reorg.
+ **/ export class NoteDataProvider {
     #store;
     #notes;
     #nullifiedNotes;
@@ -12,15 +17,11 @@ export class NoteDataProvider {
     #nullifiedNotesToScope;
     #nullifiedNotesByContract;
     #nullifiedNotesByStorageSlot;
-    #nullifiedNotesByTxHash;
-    #nullifiedNotesByRecipient;
     #nullifiedNotesByNullifier;
     #scopes;
     #notesToScope;
     #notesByContractAndScope;
     #notesByStorageSlotAndScope;
-    #notesByTxHashAndScope;
-    #notesByRecipientAndScope;
     constructor(store){
         this.#store = store;
         this.#notes = store.openMap('notes');
@@ -30,27 +31,37 @@ export class NoteDataProvider {
         this.#nullifiedNotesToScope = store.openMultiMap('nullified_notes_to_scope');
         this.#nullifiedNotesByContract = store.openMultiMap('nullified_notes_by_contract');
         this.#nullifiedNotesByStorageSlot = store.openMultiMap('nullified_notes_by_storage_slot');
-        this.#nullifiedNotesByTxHash = store.openMultiMap('nullified_notes_by_tx_hash');
-        this.#nullifiedNotesByRecipient = store.openMultiMap('nullified_notes_by_recipient');
         this.#nullifiedNotesByNullifier = store.openMap('nullified_notes_by_nullifier');
         this.#scopes = store.openMap('scopes');
         this.#notesToScope = store.openMultiMap('notes_to_scope');
         this.#notesByContractAndScope = new Map();
         this.#notesByStorageSlotAndScope = new Map();
-        this.#notesByTxHashAndScope = new Map();
-        this.#notesByRecipientAndScope = new Map();
     }
-    static async create(store) {
+    /**
+   * Creates and initializes a new NoteDataProvider instance.
+   *
+   * This factory method creates a NoteDataProvider and restores any existing
+   * scope-specific indexes from the database.
+   *
+   * @param store - The key-value store to use for persistence
+   * @returns Promise resolving to a fully initialized NoteDataProvider instance
+   */ static async create(store) {
         const pxeDB = new NoteDataProvider(store);
         for await (const scope of pxeDB.#scopes.keysAsync()){
             pxeDB.#notesByContractAndScope.set(scope, store.openMultiMap(`${scope}:notes_by_contract`));
             pxeDB.#notesByStorageSlotAndScope.set(scope, store.openMultiMap(`${scope}:notes_by_storage_slot`));
-            pxeDB.#notesByTxHashAndScope.set(scope, store.openMultiMap(`${scope}:notes_by_tx_hash`));
-            pxeDB.#notesByRecipientAndScope.set(scope, store.openMultiMap(`${scope}:notes_by_recipient`));
         }
         return pxeDB;
     }
-    async addScope(scope) {
+    /**
+   * Adds a new scope to the note data provider.
+   *
+   * Scopes provide privacy isolation by creating separate indexes for each user.
+   * Each scope gets its own set of indexes for efficient note retrieval by various criteria.
+   *
+   * @param scope - The AztecAddress representing the scope/user to add
+   * @returns Promise resolving to true if scope was added, false if it already existed
+   */ async addScope(scope) {
         const scopeString = scope.toString();
         if (await this.#scopes.hasAsync(scopeString)) {
             return false;
@@ -58,32 +69,53 @@ export class NoteDataProvider {
         await this.#scopes.set(scopeString, true);
         this.#notesByContractAndScope.set(scopeString, this.#store.openMultiMap(`${scopeString}:notes_by_contract`));
         this.#notesByStorageSlotAndScope.set(scopeString, this.#store.openMultiMap(`${scopeString}:notes_by_storage_slot`));
-        this.#notesByTxHashAndScope.set(scopeString, this.#store.openMultiMap(`${scopeString}:notes_by_tx_hash`));
-        this.#notesByRecipientAndScope.set(scopeString, this.#store.openMultiMap(`${scopeString}:notes_by_recipient`));
         return true;
     }
-    addNotes(notes, scope = AztecAddress.ZERO) {
+    /**
+   * Adds multiple notes to the data provider under the specified scope.
+   *
+   * Notes are stored using their index from the notes hash tree as the key, which provides
+   * uniqueness and maintains creation order. 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
+   */ addNotes(notes, scope) {
         return this.#store.transactionAsync(async ()=>{
             if (!await this.#scopes.hasAsync(scope.toString())) {
                 await this.addScope(scope);
             }
             for (const dao of notes){
-                // store notes by their index in the notes hash tree
-                // this provides the uniqueness we need to store individual notes
-                // and should also return notes in the order that they were created.
-                // Had we stored them by their nullifier, they would be returned in random order
                 const noteIndex = toBufferBE(dao.index, 32).toString('hex');
                 await this.#notes.set(noteIndex, dao.toBuffer());
                 await this.#notesToScope.set(noteIndex, scope.toString());
                 await this.#nullifierToNoteId.set(dao.siloedNullifier.toString(), noteIndex);
                 await this.#notesByContractAndScope.get(scope.toString()).set(dao.contractAddress.toString(), noteIndex);
                 await this.#notesByStorageSlotAndScope.get(scope.toString()).set(dao.storageSlot.toString(), noteIndex);
-                await this.#notesByTxHashAndScope.get(scope.toString()).set(dao.txHash.toString(), noteIndex);
-                await this.#notesByRecipientAndScope.get(scope.toString()).set(dao.recipient.toString(), noteIndex);
             }
         });
     }
-    removeNotesAfter(blockNumber) {
+    /**
+   * Synchronizes notes and nullifiers to a specific block number.
+   *
+   * This method ensures that the state of notes and nullifiers is consistent with the
+   * specified block number. It restores any notes that were nullified after the given block
+   * and deletes any active notes created after that block.
+   *
+   * @param blockNumber - The new chain tip after a reorg
+   * @param synchedBlockNumber - The block number up to which PXE managed to sync before the reorg happened.
+   */ async rollbackNotesAndNullifiers(blockNumber, synchedBlockNumber) {
+        await this.#rewindNullifiersAfterBlock(blockNumber, synchedBlockNumber);
+        await this.#deleteActiveNotesAfterBlock(blockNumber);
+    }
+    /**
+   * Deletes (removes) all active notes created after the specified block number.
+   *
+   * Permanently delete notes from the active notes store, e.g. during a reorg.
+   * Note: This only affects #notes (active notes), not #nullifiedNotes.
+   *
+   * @param blockNumber - Notes created after this block number will be deleted
+   */ #deleteActiveNotesAfterBlock(blockNumber) {
         return this.#store.transactionAsync(async ()=>{
             const notes = await toArray(this.#notes.valuesAsync());
             for (const note of notes){
@@ -95,8 +127,6 @@ export class NoteDataProvider {
                     await this.#nullifierToNoteId.delete(noteDao.siloedNullifier.toString());
                     const scopes = await toArray(this.#scopes.keysAsync());
                     for (const scope of scopes){
-                        await this.#notesByRecipientAndScope.get(scope).deleteValue(noteDao.recipient.toString(), noteIndex);
-                        await this.#notesByTxHashAndScope.get(scope).deleteValue(noteDao.txHash.toString(), noteIndex);
                         await this.#notesByContractAndScope.get(scope).deleteValue(noteDao.contractAddress.toString(), noteIndex);
                         await this.#notesByStorageSlotAndScope.get(scope).deleteValue(noteDao.storageSlot.toString(), noteIndex);
                     }
@@ -104,12 +134,20 @@ export class NoteDataProvider {
             }
         });
     }
-    async unnullifyNotesAfter(blockNumber, synchedBlockNumber) {
+    /**
+   * Rewinds nullifications after a given block number.
+   *
+   * This operation "unnullifies" notes, rolling back nullifications that occurred
+   * in orphaned blocks, e.g. during a reorg.  The notes are restored to the
+   * active notes store and removed from the nullified store.
+   *
+   * @param blockNumber - Revert nullifications that occurred after this block
+   * @param synchedBlockNumber - Upper bound for the block range to process
+   */ async #rewindNullifiersAfterBlock(blockNumber, synchedBlockNumber) {
         await this.#store.transactionAsync(async ()=>{
             const nullifiersToUndo = [];
             const currentBlockNumber = blockNumber + 1;
-            const maxBlockNumber = synchedBlockNumber ?? currentBlockNumber;
-            for(let i = currentBlockNumber; i <= maxBlockNumber; i++){
+            for(let i = currentBlockNumber; i <= synchedBlockNumber; i++){
                 nullifiersToUndo.push(...await toArray(this.#nullifiersByBlockNumber.getValuesAsync(i)));
             }
             const notesIndexesToReinsert = await Promise.all(nullifiersToUndo.map((nullifier)=>this.#nullifiedNotesByNullifier.getAsync(nullifier)));
@@ -120,17 +158,15 @@ export class NoteDataProvider {
                 const noteIndex = toBufferBE(dao.index, 32).toString('hex');
                 await this.#notes.set(noteIndex, dao.toBuffer());
                 await this.#nullifierToNoteId.set(dao.siloedNullifier.toString(), noteIndex);
-                let scopes = await toArray(this.#nullifiedNotesToScope.getValuesAsync(noteIndex)) ?? [];
+                const scopes = await toArray(this.#nullifiedNotesToScope.getValuesAsync(noteIndex));
                 if (scopes.length === 0) {
-                    scopes = [
-                        dao.recipient.toString()
-                    ];
+                    // We should never run into this error because notes always have a scope assigned to them - either on initial
+                    // insertion via `addNotes` or when removing their nullifiers.
+                    throw new Error(`No scopes found for nullified note with index ${noteIndex}`);
                 }
                 for (const scope of scopes){
                     await this.#notesByContractAndScope.get(scope.toString()).set(dao.contractAddress.toString(), noteIndex);
                     await this.#notesByStorageSlotAndScope.get(scope.toString()).set(dao.storageSlot.toString(), noteIndex);
-                    await this.#notesByTxHashAndScope.get(scope.toString()).set(dao.txHash.toString(), noteIndex);
-                    await this.#notesByRecipientAndScope.get(scope.toString()).set(dao.recipient.toString(), noteIndex);
                     await this.#notesToScope.set(noteIndex, scope);
                 }
                 await this.#nullifiedNotes.delete(noteIndex);
@@ -138,33 +174,58 @@ export class NoteDataProvider {
                 await this.#nullifiersByBlockNumber.deleteValue(dao.l2BlockNumber, dao.siloedNullifier.toString());
                 await this.#nullifiedNotesByContract.deleteValue(dao.contractAddress.toString(), noteIndex);
                 await this.#nullifiedNotesByStorageSlot.deleteValue(dao.storageSlot.toString(), noteIndex);
-                await this.#nullifiedNotesByTxHash.deleteValue(dao.txHash.toString(), noteIndex);
-                await this.#nullifiedNotesByRecipient.deleteValue(dao.recipient.toString(), noteIndex);
                 await this.#nullifiedNotesByNullifier.delete(dao.siloedNullifier.toString());
             }
         });
     }
-    async getNotes(filter) {
+    /**
+   * Retrieves notes based on the provided filter criteria.
+   *
+   * This method queries both active and optionally nullified notes based on the filter
+   * parameters.
+   *
+   * @param filter - Filter criteria including contractAddress (required), and optional
+   *                 owner, storageSlot, status, scopes, and siloedNullifier.
+   * @returns Filtered and deduplicated notes (a note might be present in multiple scopes - we ensure it is only
+   * returned once if this is the case)
+   * @throws If filtering by an empty scopes array. Scopes have to be set to undefined or to a non-empty array.
+   */ async getNotes(filter) {
         filter.status = filter.status ?? NoteStatus.ACTIVE;
+        // throw early if scopes is an empty array
+        if (filter.scopes !== undefined && filter.scopes.length === 0) {
+            throw new Error('Trying to get notes with an empty scopes array. Scopes have to be set to undefined if intending on not filtering by scopes.');
+        }
         const candidateNoteSources = [];
         filter.scopes ??= (await toArray(this.#scopes.keysAsync())).map((addressString)=>AztecAddress.fromString(addressString));
         const activeNoteIdsPerScope = [];
         for (const scope of new Set(filter.scopes)){
             const formattedScopeString = scope.toString();
             if (!await this.#scopes.hasAsync(formattedScopeString)) {
-                throw new Error('Trying to get incoming notes of an scope that is not in the PXE database');
+                throw new Error('Trying to get incoming notes of a scope that is not in the PXE database');
             }
-            activeNoteIdsPerScope.push(filter.recipient ? await toArray(this.#notesByRecipientAndScope.get(formattedScopeString).getValuesAsync(filter.recipient.toString())) : filter.txHash ? await toArray(this.#notesByTxHashAndScope.get(formattedScopeString).getValuesAsync(filter.txHash.toString())) : filter.storageSlot ? await toArray(this.#notesByStorageSlotAndScope.get(formattedScopeString).getValuesAsync(filter.storageSlot.toString())) : await toArray(this.#notesByContractAndScope.get(formattedScopeString).getValuesAsync(filter.contractAddress.toString())));
+            activeNoteIdsPerScope.push(filter.storageSlot ? await toArray(this.#notesByStorageSlotAndScope.get(formattedScopeString).getValuesAsync(filter.storageSlot.toString())) : await toArray(this.#notesByContractAndScope.get(formattedScopeString).getValuesAsync(filter.contractAddress.toString())));
         }
         candidateNoteSources.push({
             ids: new Set(activeNoteIdsPerScope.flat()),
             notes: this.#notes
         });
-        if (filter.status == NoteStatus.ACTIVE_OR_NULLIFIED) {
-            candidateNoteSources.push({
-                ids: filter.recipient ? await toArray(this.#nullifiedNotesByRecipient.getValuesAsync(filter.recipient.toString())) : filter.txHash ? await toArray(this.#nullifiedNotesByTxHash.getValuesAsync(filter.txHash.toString())) : filter.storageSlot ? await toArray(this.#nullifiedNotesByStorageSlot.getValuesAsync(filter.storageSlot.toString())) : await toArray(this.#nullifiedNotesByContract.getValuesAsync(filter.contractAddress.toString())),
-                notes: this.#nullifiedNotes
-            });
+        // If status is ACTIVE_OR_NULLIFIED we add nullified notes as candidates on top of the default active ones.
+        if (filter.status === NoteStatus.ACTIVE_OR_NULLIFIED) {
+            const nullifiedIds = filter.storageSlot ? await toArray(this.#nullifiedNotesByStorageSlot.getValuesAsync(filter.storageSlot.toString())) : await toArray(this.#nullifiedNotesByContract.getValuesAsync(filter.contractAddress.toString()));
+            const setOfScopes = new Set(filter.scopes.map((s)=>s.toString()));
+            const filteredNullifiedIds = new Set();
+            for (const noteId of nullifiedIds){
+                const scopeList = await toArray(this.#nullifiedNotesToScope.getValuesAsync(noteId));
+                if (scopeList.some((scope)=>setOfScopes.has(scope))) {
+                    filteredNullifiedIds.add(noteId);
+                }
+            }
+            if (filteredNullifiedIds.size > 0) {
+                candidateNoteSources.push({
+                    ids: filteredNullifiedIds,
+                    notes: this.#nullifiedNotes
+                });
+            }
         }
         const result = [];
         for (const { ids, notes } of candidateNoteSources){
@@ -177,24 +238,38 @@ export class NoteDataProvider {
                 if (!note.contractAddress.equals(filter.contractAddress)) {
                     continue;
                 }
-                if (filter.txHash && !note.txHash.equals(filter.txHash)) {
+                if (filter.owner && !note.owner.equals(filter.owner)) {
                     continue;
                 }
                 if (filter.storageSlot && !note.storageSlot.equals(filter.storageSlot)) {
                     continue;
                 }
-                if (filter.recipient && !note.recipient.equals(filter.recipient)) {
-                    continue;
-                }
                 if (filter.siloedNullifier && !note.siloedNullifier.equals(filter.siloedNullifier)) {
                     continue;
                 }
                 result.push(note);
             }
         }
-        return result;
+        // A note might be present in multiple scopes - we ensure it is only returned once
+        const deduplicated = [];
+        for (const note of result){
+            if (!deduplicated.some((existing)=>existing.equals(note))) {
+                deduplicated.push(note);
+            }
+        }
+        return deduplicated;
     }
-    removeNullifiedNotes(nullifiers, recipient) {
+    /**
+   * Transitions notes from "active" to "nullified" state.
+   *
+   * This operation processes a batch of nullifiers to mark the corresponding notes
+   * as spent/nullified.  The operation is atomic - if any nullifier is not found,
+   * the entire operation fails and no notes are modified.
+   *
+   * @param nullifiers - Array of nullifiers with their block numbers to process
+   * @returns Promise resolving to array of nullified NoteDao objects
+   * @throws Error if any nullifier is not found in the active notes
+   */ applyNullifiers(nullifiers) {
         if (nullifiers.length === 0) {
             return Promise.resolve([]);
         }
@@ -202,59 +277,46 @@ export class NoteDataProvider {
             const nullifiedNotes = [];
             for (const blockScopedNullifier of nullifiers){
                 const { data: nullifier, l2BlockNumber: blockNumber } = blockScopedNullifier;
-                const noteIndex = await this.#nullifierToNoteId.getAsync(nullifier.toString());
+                const nullifierKey = nullifier.toString();
+                const noteIndex = await this.#nullifierToNoteId.getAsync(nullifierKey);
                 if (!noteIndex) {
-                    throw new Error('Nullifier not found in removeNullifiedNotes');
+                    // Check if already nullified?
+                    const alreadyNullified = await this.#nullifiedNotesByNullifier.getAsync(nullifierKey);
+                    if (alreadyNullified) {
+                        throw new Error(`Nullifier already applied in applyNullifiers`);
+                    }
+                    throw new Error('Nullifier not found in applyNullifiers');
                 }
                 const noteBuffer = noteIndex ? await this.#notes.getAsync(noteIndex) : undefined;
                 if (!noteBuffer) {
-                    throw new Error('Note not found in removeNullifiedNotes');
+                    throw new Error('Note not found in applyNullifiers');
                 }
-                const noteScopes = await toArray(this.#notesToScope.getValuesAsync(noteIndex)) ?? [];
-                const note = NoteDao.fromBuffer(noteBuffer);
-                if (!note.recipient.equals(recipient)) {
-                    throw new Error("Tried to nullify someone else's note");
+                const noteScopes = await toArray(this.#notesToScope.getValuesAsync(noteIndex));
+                if (noteScopes.length === 0) {
+                    // We should never run into this error because notes always have a scope assigned to them - either on initial
+                    // insertion via `addNotes` or when removing their nullifiers.
+                    throw new Error('Note scopes are missing in applyNullifiers');
                 }
+                const note = NoteDao.fromBuffer(noteBuffer);
                 nullifiedNotes.push(note);
                 await this.#notes.delete(noteIndex);
                 await this.#notesToScope.delete(noteIndex);
                 const scopes = await toArray(this.#scopes.keysAsync());
                 for (const scope of scopes){
-                    await this.#notesByRecipientAndScope.get(scope).deleteValue(note.recipient.toString(), noteIndex);
-                    await this.#notesByTxHashAndScope.get(scope).deleteValue(note.txHash.toString(), noteIndex);
                     await this.#notesByContractAndScope.get(scope).deleteValue(note.contractAddress.toString(), noteIndex);
                     await this.#notesByStorageSlotAndScope.get(scope).deleteValue(note.storageSlot.toString(), noteIndex);
                 }
-                if (noteScopes !== undefined) {
-                    for (const scope of noteScopes){
-                        await this.#nullifiedNotesToScope.set(noteIndex, scope);
-                    }
+                for (const scope of noteScopes){
+                    await this.#nullifiedNotesToScope.set(noteIndex, scope);
                 }
                 await this.#nullifiedNotes.set(noteIndex, note.toBuffer());
                 await this.#nullifiersByBlockNumber.set(blockNumber, nullifier.toString());
                 await this.#nullifiedNotesByContract.set(note.contractAddress.toString(), noteIndex);
                 await this.#nullifiedNotesByStorageSlot.set(note.storageSlot.toString(), noteIndex);
-                await this.#nullifiedNotesByTxHash.set(note.txHash.toString(), noteIndex);
-                await this.#nullifiedNotesByRecipient.set(note.recipient.toString(), noteIndex);
                 await this.#nullifiedNotesByNullifier.set(nullifier.toString(), noteIndex);
                 await this.#nullifierToNoteId.delete(nullifier.toString());
             }
             return nullifiedNotes;
         });
     }
-    async getSize() {
-        const scopes = await toArray(this.#scopes.keysAsync());
-        const contractAddresses = new Set();
-        // Collect all unique contract addresses across all scopes
-        for (const scope of scopes){
-            const addresses = await toArray(this.#notesByContractAndScope.get(scope).keysAsync());
-            addresses.forEach((addr)=>contractAddresses.add(addr));
-        }
-        // Get all notes for each contract address
-        const allNotes = await Promise.all(Array.from(contractAddresses).map((addr)=>this.getNotes({
-                contractAddress: AztecAddress.fromString(addr)
-            })));
-        // Reduce all notes to get total size
-        return allNotes.flat().reduce((sum, note)=>sum + note.getSize(), 0);
-    }
 }

package/dest/storage/private_event_data_provider/private_event_data_provider.d.ts

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

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

@@ -1 +1 @@
-{"version":3,"file":"private_event_data_provider.d.ts","sourceRoot":"","sources":["../../../src/storage/private_event_data_provider/private_event_data_provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAG9C,OAAO,KAAK,EAAmB,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACzF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAQxD;;GAEG;AACH,qBAAa,wBAAyB,YAAW,YAAY;;IAS3D,MAAM,yCAA+C;gBAEzC,KAAK,EAAE,iBAAiB;IAOpC;;;;;;;;;OASG;IACH,oBAAoB,CAClB,eAAe,EAAE,YAAY,EAC7B,SAAS,EAAE,YAAY,EACvB,aAAa,EAAE,aAAa,EAC5B,UAAU,EAAE,EAAE,EAAE,EAChB,MAAM,EAAE,MAAM,EACd,oBAAoB,EAAE,MAAM,EAC5B,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC;IA4BhB;;;;;;;;OAQG;IACU,gBAAgB,CAC3B,eAAe,EAAE,YAAY,EAC7B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,YAAY,EAAE,EAC1B,aAAa,EAAE,aAAa,GAC3B,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC;IAgClB,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;CAG3B"}
+{"version":3,"file":"private_event_data_provider.d.ts","sourceRoot":"","sources":["../../../src/storage/private_event_data_provider/private_event_data_provider.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAGpD,OAAO,KAAK,EAAmB,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACzF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD,MAAM,MAAM,8BAA8B,GAAG;IAC3C,eAAe,EAAE,YAAY,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAUF,KAAK,oBAAoB,GAAG,IAAI,GAAG;IACjC,eAAe,EAAE,YAAY,CAAC;IAC9B,KAAK,EAAE,YAAY,CAAC;CACrB,CAAC;AAEF;;GAEG;AACH,qBAAa,wBAAwB;;IASnC,MAAM,yCAA+C;IAErD,YAAY,KAAK,EAAE,iBAAiB,EAKnC;IAMD;;;;;;;;;;OAUG;IACH,oBAAoB,CAClB,aAAa,EAAE,aAAa,EAC5B,UAAU,EAAE,EAAE,EAAE,EAChB,oBAAoB,EAAE,MAAM,EAC5B,QAAQ,EAAE,oBAAoB,GAC7B,OAAO,CAAC,IAAI,CAAC,CA8Bf;IAED;;;;;;;;;;OAUG;IACU,gBAAgB,CAC3B,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,8BAA8B,GACrC,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAwC/B;CACF"}

package/dest/storage/private_event_data_provider/private_event_data_provider.js

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

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

@@ -1,2 +1,2 @@
 export { SyncDataProvider } from './sync_data_provider.js';
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL3N5bmNfZGF0YV9wcm92aWRlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQyJ9

package/dest/storage/sync_data_provider/sync_data_provider.d.ts

@@ -1,12 +1,11 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import { BlockHeader } from '@aztec/stdlib/tx';
-import type { DataProvider } from '../data_provider.js';
-export declare class SyncDataProvider implements DataProvider {
+export declare class SyncDataProvider {
     #private;
     constructor(store: AztecAsyncKVStore);
     setHeader(header: BlockHeader): Promise<void>;
-    getBlockNumber(): Promise<number>;
+    getBlockNumber(): Promise<BlockNumber>;
     getBlockHeader(): Promise<BlockHeader>;
-    getSize(): Promise<number>;
 }
-//# sourceMappingURL=sync_data_provider.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luY19kYXRhX3Byb3ZpZGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3RvcmFnZS9zeW5jX2RhdGFfcHJvdmlkZXIvc3luY19kYXRhX3Byb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ25FLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUF1QixNQUFNLGlCQUFpQixDQUFDO0FBQzlFLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUUvQyxxQkFBYSxnQkFBZ0I7O0lBSTNCLFlBQVksS0FBSyxFQUFFLGlCQUFpQixFQUduQztJQUVLLFNBQVMsQ0FBQyxNQUFNLEVBQUUsV0FBVyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FFbEQ7SUFFSyxjQUFjLElBQUksT0FBTyxDQUFDLFdBQVcsQ0FBQyxDQU8zQztJQUVLLGNBQWMsSUFBSSxPQUFPLENBQUMsV0FBVyxDQUFDLENBTzNDO0NBQ0YifQ==

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

@@ -1 +1 @@
-{"version":3,"file":"sync_data_provider.d.ts","sourceRoot":"","sources":["../../../src/storage/sync_data_provider/sync_data_provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAuB,MAAM,iBAAiB,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,qBAAa,gBAAiB,YAAW,YAAY;;gBAIvC,KAAK,EAAE,iBAAiB;IAK9B,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAI7C,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC;IASjC,cAAc,IAAI,OAAO,CAAC,WAAW,CAAC;IAStC,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;CAGjC"}
+{"version":3,"file":"sync_data_provider.d.ts","sourceRoot":"","sources":["../../../src/storage/sync_data_provider/sync_data_provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,iBAAiB,EAAuB,MAAM,iBAAiB,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAE/C,qBAAa,gBAAgB;;IAI3B,YAAY,KAAK,EAAE,iBAAiB,EAGnC;IAEK,SAAS,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAElD;IAEK,cAAc,IAAI,OAAO,CAAC,WAAW,CAAC,CAO3C;IAEK,cAAc,IAAI,OAAO,CAAC,WAAW,CAAC,CAO3C;CACF"}

package/dest/storage/sync_data_provider/sync_data_provider.js

@@ -23,7 +23,4 @@ export class SyncDataProvider {
         }
         return BlockHeader.fromBuffer(headerBuffer);
     }
-    async getSize() {
-        return (await this.#synchronizedHeader.getAsync())?.length ?? 0;
-    }
 }