@aztec/pxe 0.0.1-commit.03f7ef2 → 0.0.1-commit.08c5969dc

package/dest/storage/capsule_data_provider/capsule_data_provider.js

@@ -1,146 +0,0 @@
-import { Fr } from '@aztec/foundation/curves/bn254';
-import { createLogger } from '@aztec/foundation/log';
-export class CapsuleDataProvider {
-    #store;
-    // Arbitrary data stored by contracts. Key is computed as `${contractAddress}:${key}`
-    #capsules;
-    logger;
-    constructor(store){
-        this.#store = store;
-        this.#capsules = this.#store.openMap('capsules');
-        this.logger = createLogger('pxe:capsule-data-provider');
-    }
-    /**
-   * Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `loadCapsule`.
-   * * If data was already stored at this slot, it is overwritten.
-   * @param contractAddress - The contract address to scope the data under.
-   * @param slot - The slot in the database in which to store the value. Slots need not be contiguous.
-   * @param capsule - An array of field elements representing the capsule.
-   * @remarks A capsule is a "blob" of data that is passed to the contract through an oracle. It works similarly
-   * to public contract storage in that it's indexed by the contract address and storage slot but instead of the global
-   * network state it's backed by local PXE db.
-   */ async storeCapsule(contractAddress, slot, capsule) {
-        await this.#capsules.set(dbSlotToKey(contractAddress, slot), Buffer.concat(capsule.map((value)=>value.toBuffer())));
-    }
-    /**
-   * Returns data previously stored via `storeCapsule` in the per-contract non-volatile database.
-   * @param contractAddress - The contract address under which the data is scoped.
-   * @param slot - The slot in the database to read.
-   * @returns The stored data or `null` if no data is stored under the slot.
-   */ async loadCapsule(contractAddress, slot) {
-        const dataBuffer = await this.#capsules.getAsync(dbSlotToKey(contractAddress, slot));
-        if (!dataBuffer) {
-            this.logger.trace(`Data not found for contract ${contractAddress.toString()} and slot ${slot.toString()}`);
-            return null;
-        }
-        const capsule = [];
-        for(let i = 0; i < dataBuffer.length; i += Fr.SIZE_IN_BYTES){
-            capsule.push(Fr.fromBuffer(dataBuffer.subarray(i, i + Fr.SIZE_IN_BYTES)));
-        }
-        return capsule;
-    }
-    /**
-   * Deletes data in the per-contract non-volatile database. Does nothing if no data was present.
-   * @param contractAddress - The contract address under which the data is scoped.
-   * @param slot - The slot in the database to delete.
-   */ async deleteCapsule(contractAddress, slot) {
-        await this.#capsules.delete(dbSlotToKey(contractAddress, slot));
-    }
-    /**
-   * Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data
-   * structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.
-   * Supports overlapping source and destination regions (which will result in the overlapped source values being
-   * overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)
-   *
-   * @param contractAddress - The contract address under which the data is scoped.
-   * @param srcSlot - The first slot to copy from.
-   * @param dstSlot - The first slot to copy to.
-   * @param numEntries - The number of entries to copy.
-   */ copyCapsule(contractAddress, srcSlot, dstSlot, numEntries) {
-        return this.#store.transactionAsync(async ()=>{
-            // In order to support overlapping source and destination regions, we need to check the relative positions of source
-            // and destination. If destination is ahead of source, then by the time we overwrite source elements using forward
-            // indexes we'll have already read those. On the contrary, if source is ahead of destination we need to use backward
-            // indexes to avoid reading elements that've been overwritten.
-            const indexes = Array.from(Array(numEntries).keys());
-            if (srcSlot.lt(dstSlot)) {
-                indexes.reverse();
-            }
-            for (const i of indexes){
-                const currentSrcSlot = dbSlotToKey(contractAddress, srcSlot.add(new Fr(i)));
-                const currentDstSlot = dbSlotToKey(contractAddress, dstSlot.add(new Fr(i)));
-                const toCopy = await this.#capsules.getAsync(currentSrcSlot);
-                if (!toCopy) {
-                    throw new Error(`Attempted to copy empty slot ${currentSrcSlot} for contract ${contractAddress.toString()}`);
-                }
-                await this.#capsules.set(currentDstSlot, toCopy);
-            }
-        });
-    }
-    /**
-   * Appends multiple capsules to a capsule array stored at the base slot.
-   * The array length is stored at the base slot, and elements are stored in consecutive slots after it.
-   * All operations are performed in a single transaction.
-   * @param contractAddress - The contract address that owns the capsule array
-   * @param baseSlot - The slot where the array length is stored
-   * @param content - Array of capsule data to append
-   */ appendToCapsuleArray(contractAddress, baseSlot, content) {
-        return this.#store.transactionAsync(async ()=>{
-            // Load current length, defaulting to 0 if not found
-            const lengthData = await this.loadCapsule(contractAddress, baseSlot);
-            const currentLength = lengthData ? lengthData[0].toNumber() : 0;
-            // Store each capsule at consecutive slots after baseSlot + 1 + currentLength
-            for(let i = 0; i < content.length; i++){
-                const nextSlot = arraySlot(baseSlot, currentLength + i);
-                await this.storeCapsule(contractAddress, nextSlot, content[i]);
-            }
-            // Update length to include all new capsules
-            const newLength = currentLength + content.length;
-            await this.storeCapsule(contractAddress, baseSlot, [
-                new Fr(newLength)
-            ]);
-        });
-    }
-    readCapsuleArray(contractAddress, baseSlot) {
-        return this.#store.transactionAsync(async ()=>{
-            // Load length, defaulting to 0 if not found
-            const maybeLength = await this.loadCapsule(contractAddress, baseSlot);
-            const length = maybeLength ? maybeLength[0].toBigInt() : 0n;
-            const values = [];
-            // Read each capsule at consecutive slots after baseSlot
-            for(let i = 0; i < length; i++){
-                const currentValue = await this.loadCapsule(contractAddress, arraySlot(baseSlot, i));
-                if (currentValue == undefined) {
-                    throw new Error(`Expected non-empty value at capsule array in base slot ${baseSlot} at index ${i} for contract ${contractAddress}`);
-                }
-                values.push(currentValue);
-            }
-            return values;
-        });
-    }
-    setCapsuleArray(contractAddress, baseSlot, content) {
-        return this.#store.transactionAsync(async ()=>{
-            // Load current length, defaulting to 0 if not found
-            const maybeLength = await this.loadCapsule(contractAddress, baseSlot);
-            const originalLength = maybeLength ? maybeLength[0].toNumber() : 0;
-            // Set the new length
-            await this.storeCapsule(contractAddress, baseSlot, [
-                new Fr(content.length)
-            ]);
-            // Store the new content, possibly overwriting existing values
-            for(let i = 0; i < content.length; i++){
-                await this.storeCapsule(contractAddress, arraySlot(baseSlot, i), content[i]);
-            }
-            // Clear any stragglers
-            for(let i = content.length; i < originalLength; i++){
-                await this.deleteCapsule(contractAddress, arraySlot(baseSlot, i));
-            }
-        });
-    }
-}
-function dbSlotToKey(contractAddress, slot) {
-    return `${contractAddress.toString()}:${slot.toString()}`;
-}
-function arraySlot(baseSlot, index) {
-    return baseSlot.add(new Fr(1)).add(new Fr(index));
-}

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

@@ -1,2 +0,0 @@
-export { CapsuleDataProvider } from './capsule_data_provider.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL2NhcHN1bGVfZGF0YV9wcm92aWRlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQyJ9

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/capsule_data_provider/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC"}

package/dest/storage/capsule_data_provider/index.js

@@ -1 +0,0 @@
-export { CapsuleDataProvider } from './capsule_data_provider.js';

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

@@ -1 +0,0 @@
-{"version":3,"file":"contract_data_provider.d.ts","sourceRoot":"","sources":["../../../src/storage/contract_data_provider/contract_data_provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAEhB,KAAK,gCAAgC,EACrC,YAAY,EACZ,KAAK,qBAAqB,EAC1B,gBAAgB,EAMjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,2BAA2B,EAGjC,MAAM,wBAAwB,CAAC;AAIhC;;;;;;GAMG;AACH,qBAAa,oBAAoB;;IAW/B,YAAY,KAAK,EAAE,iBAAiB,EAGnC;IAIY,mBAAmB,CAAC,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBlF;IAEK,mBAAmB,CAAC,QAAQ,EAAE,2BAA2B,GAAG,OAAO,CAAC,IAAI,CAAC,CAO9E;IA4CK,qBAAqB,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAGrD;IAED,4EAA4E;IAC/D,mBAAmB,CAAC,eAAe,EAAE,YAAY,GAAG,OAAO,CAAC,2BAA2B,GAAG,SAAS,CAAC,CAGhH;IAEY,mBAAmB,CAAC,eAAe,EAAE,EAAE,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAI3F;IAED,0EAA0E;IAC7D,gBAAgB,CAAC,eAAe,EAAE,EAAE,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAGrF;IAEY,WAAW,CACtB,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,CAAC,2BAA2B,GAAG,gBAAgB,CAAC,GAAG,SAAS,CAAC,CAUvE;IAED;;;;;;;;OAQG;IACU,mBAAmB,CAC9B,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,gCAAgC,GAAG,SAAS,CAAC,CAIvD;IAEY,oCAAoC,CAC/C,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,gCAAgC,CAAC,CAU3C;IAEY,yBAAyB,CACpC,eAAe,EAAE,YAAY,GAC5B,OAAO,CAAC,gCAAgC,GAAG,SAAS,CAAC,CAIvD;IAEY,cAAc,CACzB,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAGlC;IAED;;;;;;;;;OASG;IACU,wBAAwB,CACnC,eAAe,EAAE,YAAY,EAC7B,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,qBAAqB,GAAG,SAAS,CAAC,CAI5C;IAEY,8BAA8B,CACzC,eAAe,EAAE,YAAY,GAC5B,OAAO,CAAC,qBAAqB,GAAG,SAAS,CAAC,CAI5C;IAED;;;;;;;;OAQG;IACU,4BAA4B,CACvC,eAAe,EAAE,EAAE,EACnB,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,iBAAiB,CAAC,OAAO,oBAAoB,CAAC,GAAG,SAAS,CAAC,CAGrE;IAEY,oBAAoB,CAAC,eAAe,EAAE,YAAY,+BAG9D;IAEY,oBAAoB,CAAC,eAAe,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,mBAI1F;IA8BY,eAAe,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAuBvG;CACF"}

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

@@ -1,2 +0,0 @@
-export { ContractDataProvider } from './contract_data_provider.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL2NvbnRyYWN0X2RhdGFfcHJvdmlkZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sNkJBQTZCLENBQUMifQ==

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/contract_data_provider/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC"}

package/dest/storage/contract_data_provider/index.js

@@ -1 +0,0 @@
-export { ContractDataProvider } from './contract_data_provider.js';

package/dest/storage/contract_data_provider/private_functions_tree.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"private_functions_tree.d.ts","sourceRoot":"","sources":["../../../src/storage/contract_data_provider/private_functions_tree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAGxD,OAAO,EAAE,iBAAiB,EAAmB,MAAM,yBAAyB,CAAC;AAC7E,OAAO,EAAE,KAAK,gBAAgB,EAAE,gBAAgB,EAAgB,MAAM,mBAAmB,CAAC;AAQ1F;;;;;GAKG;AACH,qBAAa,oBAAoB;IAGX,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IAFrD,OAAO,CAAC,IAAI,CAAC,CAAa;IAE1B,OAAO,eAAqE;IAE5E,OAAa,MAAM,CAAC,QAAQ,EAAE,gBAAgB,iCAO7C;IAED;;;;;;;;OAQG;IACU,4BAA4B,CACvC,QAAQ,EAAE,gBAAgB,GACzB,OAAO,CAAC,iBAAiB,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAezD;YAEa,OAAO;CAMtB"}

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

@@ -1,3 +0,0 @@
-export { NoteDao } from '@aztec/stdlib/note';
-export { NoteDataProvider } from './note_data_provider.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9zdG9yYWdlL25vdGVfZGF0YV9wcm92aWRlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDN0MsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0seUJBQXlCLENBQUMifQ==

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/note_data_provider/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC"}

package/dest/storage/note_data_provider/index.js

@@ -1,2 +0,0 @@
-export { NoteDao } from '@aztec/stdlib/note';
-export { NoteDataProvider } from './note_data_provider.js';

package/dest/storage/note_data_provider/note_data_provider.d.ts

@@ -1,84 +0,0 @@
-import type { Fr } from '@aztec/foundation/curves/bn254';
-import type { AztecAsyncKVStore } from '@aztec/kv-store';
-import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { DataInBlock } from '@aztec/stdlib/block';
-import { type NotesFilter } from '@aztec/stdlib/note';
-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 declare class NoteDataProvider {
-    #private;
-    private constructor();
-    /**
-     * 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 create(store: AztecAsyncKVStore): Promise<NoteDataProvider>;
-    /**
-     * 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
-     */
-    addScope(scope: AztecAddress): Promise<boolean>;
-    /**
-     * 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: NoteDao[], scope: AztecAddress): Promise<void>;
-    /**
-     * 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.
-     */
-    rollbackNotesAndNullifiers(blockNumber: number, synchedBlockNumber: number): Promise<void>;
-    /**
-     * 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.
-     */
-    getNotes(filter: NotesFilter): Promise<NoteDao[]>;
-    /**
-     * 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: DataInBlock<Fr>[]): Promise<NoteDao[]>;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90ZV9kYXRhX3Byb3ZpZGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3RvcmFnZS9ub3RlX2RhdGFfcHJvdmlkZXIvbm90ZV9kYXRhX3Byb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXpELE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFxQyxNQUFNLGlCQUFpQixDQUFDO0FBQzVGLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUMzRCxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN2RCxPQUFPLEVBQWMsS0FBSyxXQUFXLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNsRSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFN0M7Ozs7O0lBS0k7QUFDSixxQkFBYSxnQkFBZ0I7O0lBaUIzQixPQUFPLGVBZ0JOO0lBRUQ7Ozs7Ozs7O09BUUc7SUFDSCxPQUFvQixNQUFNLENBQUMsS0FBSyxFQUFFLGlCQUFpQixHQUFHLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQU85RTtJQUVEOzs7Ozs7OztPQVFHO0lBQ1UsUUFBUSxDQUFDLEtBQUssRUFBRSxZQUFZLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQVkzRDtJQUVEOzs7Ozs7Ozs7T0FTRztJQUNILFFBQVEsQ0FBQyxLQUFLLEVBQUUsT0FBTyxFQUFFLEVBQUUsS0FBSyxFQUFFLFlBQVksR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBZ0I3RDtJQUVEOzs7Ozs7Ozs7T0FTRztJQUNVLDBCQUEwQixDQUFDLFdBQVcsRUFBRSxNQUFNLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FHdEc7SUF1RkQ7Ozs7Ozs7Ozs7O09BV0c7SUFDRyxRQUFRLENBQUMsTUFBTSxFQUFFLFdBQVcsR0FBRyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUMsQ0F3R3REO0lBRUQ7Ozs7Ozs7Ozs7T0FVRztJQUNILGVBQWUsQ0FBQyxVQUFVLEVBQUUsV0FBVyxDQUFDLEVBQUUsQ0FBQyxFQUFFLEdBQUcsT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDLENBOERqRTtDQUNGIn0=

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

@@ -1 +0,0 @@
-{"version":3,"file":"note_data_provider.d.ts","sourceRoot":"","sources":["../../../src/storage/note_data_provider/note_data_provider.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AAEzD,OAAO,KAAK,EAAE,iBAAiB,EAAqC,MAAM,iBAAiB,CAAC;AAC5F,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAc,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAClE,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C;;;;;IAKI;AACJ,qBAAa,gBAAgB;;IAiB3B,OAAO,eAgBN;IAED;;;;;;;;OAQG;IACH,OAAoB,MAAM,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAO9E;IAED;;;;;;;;OAQG;IACU,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAY3D;IAED;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAgB7D;IAED;;;;;;;;;OASG;IACU,0BAA0B,CAAC,WAAW,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGtG;IAuFD;;;;;;;;;;;OAWG;IACG,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAwGtD;IAED;;;;;;;;;;OAUG;IACH,eAAe,CAAC,UAAU,EAAE,WAAW,CAAC,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CA8DjE;CACF"}

package/dest/storage/note_data_provider/note_data_provider.js

@@ -1,322 +0,0 @@
-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 '@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;
-    #nullifierToNoteId;
-    #nullifiersByBlockNumber;
-    #nullifiedNotesToScope;
-    #nullifiedNotesByContract;
-    #nullifiedNotesByStorageSlot;
-    #nullifiedNotesByNullifier;
-    #scopes;
-    #notesToScope;
-    #notesByContractAndScope;
-    #notesByStorageSlotAndScope;
-    constructor(store){
-        this.#store = store;
-        this.#notes = store.openMap('notes');
-        this.#nullifiedNotes = store.openMap('nullified_notes');
-        this.#nullifierToNoteId = store.openMap('nullifier_to_note');
-        this.#nullifiersByBlockNumber = store.openMultiMap('nullifier_to_block_number');
-        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.#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();
-    }
-    /**
-   * 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`));
-        }
-        return pxeDB;
-    }
-    /**
-   * 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;
-        }
-        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`));
-        return true;
-    }
-    /**
-   * 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){
-                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);
-            }
-        });
-    }
-    /**
-   * 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){
-                const noteDao = NoteDao.fromBuffer(note);
-                if (noteDao.l2BlockNumber > blockNumber) {
-                    const noteIndex = toBufferBE(noteDao.index, 32).toString('hex');
-                    await this.#notes.delete(noteIndex);
-                    await this.#notesToScope.delete(noteIndex);
-                    await this.#nullifierToNoteId.delete(noteDao.siloedNullifier.toString());
-                    const scopes = await toArray(this.#scopes.keysAsync());
-                    for (const scope of scopes){
-                        await this.#notesByContractAndScope.get(scope).deleteValue(noteDao.contractAddress.toString(), noteIndex);
-                        await this.#notesByStorageSlotAndScope.get(scope).deleteValue(noteDao.storageSlot.toString(), noteIndex);
-                    }
-                }
-            }
-        });
-    }
-    /**
-   * 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;
-            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)));
-            const notNullNoteIndexes = notesIndexesToReinsert.filter((noteIndex)=>noteIndex != undefined);
-            const nullifiedNoteBuffers = await Promise.all(notNullNoteIndexes.map((noteIndex)=>this.#nullifiedNotes.getAsync(noteIndex)));
-            const noteDaos = nullifiedNoteBuffers.filter((buffer)=>buffer != undefined).map((buffer)=>NoteDao.fromBuffer(buffer));
-            for (const dao of noteDaos){
-                const noteIndex = toBufferBE(dao.index, 32).toString('hex');
-                await this.#notes.set(noteIndex, dao.toBuffer());
-                await this.#nullifierToNoteId.set(dao.siloedNullifier.toString(), noteIndex);
-                const scopes = await toArray(this.#nullifiedNotesToScope.getValuesAsync(noteIndex));
-                if (scopes.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(`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.#notesToScope.set(noteIndex, scope);
-                }
-                await this.#nullifiedNotes.delete(noteIndex);
-                await this.#nullifiedNotesToScope.delete(noteIndex);
-                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.#nullifiedNotesByNullifier.delete(dao.siloedNullifier.toString());
-            }
-        });
-    }
-    /**
-   * 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 a scope that is not in the PXE database');
-            }
-            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 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){
-            for (const id of ids){
-                const serializedNote = await notes.getAsync(id);
-                if (!serializedNote) {
-                    continue;
-                }
-                const note = NoteDao.fromBuffer(serializedNote);
-                if (!note.contractAddress.equals(filter.contractAddress)) {
-                    continue;
-                }
-                if (filter.owner && !note.owner.equals(filter.owner)) {
-                    continue;
-                }
-                if (filter.storageSlot && !note.storageSlot.equals(filter.storageSlot)) {
-                    continue;
-                }
-                if (filter.siloedNullifier && !note.siloedNullifier.equals(filter.siloedNullifier)) {
-                    continue;
-                }
-                result.push(note);
-            }
-        }
-        // A note might be present in multiple scopes - we ensure it is only returned once
-        const deduplicated = [];
-        for (const note of result){
-            if (!deduplicated.some((existing)=>existing.equals(note))) {
-                deduplicated.push(note);
-            }
-        }
-        return deduplicated;
-    }
-    /**
-   * Transitions notes from "active" to "nullified" state.
-   *
-   * 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([]);
-        }
-        return this.#store.transactionAsync(async ()=>{
-            const nullifiedNotes = [];
-            for (const blockScopedNullifier of nullifiers){
-                const { data: nullifier, l2BlockNumber: blockNumber } = blockScopedNullifier;
-                const nullifierKey = nullifier.toString();
-                const noteIndex = await this.#nullifierToNoteId.getAsync(nullifierKey);
-                if (!noteIndex) {
-                    // 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 applyNullifiers');
-                }
-                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.#notesByContractAndScope.get(scope).deleteValue(note.contractAddress.toString(), noteIndex);
-                    await this.#notesByStorageSlotAndScope.get(scope).deleteValue(note.storageSlot.toString(), noteIndex);
-                }
-                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.#nullifiedNotesByNullifier.set(nullifier.toString(), noteIndex);
-                await this.#nullifierToNoteId.delete(nullifier.toString());
-            }
-            return nullifiedNotes;
-        });
-    }
-}