@aztec/pxe 4.0.0-nightly.20260112 → 4.0.0-nightly.20260114

package/dest/storage/capsule_store/capsule_store.js

@@ -1,34 +1,120 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 export class CapsuleStore {
+    storeName = 'capsule';
     #store;
     // Arbitrary data stored by contracts. Key is computed as `${contractAddress}:${key}`
     #capsules;
+    // jobId => `${contractAddress}:${key}` => capsule data
+    // when `#stagedCapsules.get('some-job-id').get('${some-contract-address:some-key') === null`,
+    // it signals that the capsule was deleted during the job, so it needs to be deleted on commit
+    #stagedCapsules;
     logger;
     constructor(store){
         this.#store = store;
         this.#capsules = this.#store.openMap('capsules');
+        this.#stagedCapsules = new Map();
         this.logger = createLogger('pxe:capsule-data-provider');
     }
     /**
+   * Given a job denoted by `jobId`, it returns the
+   * capsules that said job has interacted with.
+   *
+   * Capsules that haven't been committed to persistence KV storage
+   * are kept in-memory in `#stagedCapsules`, this method provides a convenient
+   * way to access that in-memory collection of data.
+   *
+   * @param jobId
+   * @returns
+   */ #getJobStagedCapsules(jobId) {
+        let jobStagedCapsules = this.#stagedCapsules.get(jobId);
+        if (!jobStagedCapsules) {
+            jobStagedCapsules = new Map();
+            this.#stagedCapsules.set(jobId, jobStagedCapsules);
+        }
+        return jobStagedCapsules;
+    }
+    /**
+   * Reads a capsule's slot from the staged version of the data associated to the given jobId.
+   *
+   * If it is not there, it reads it from the KV store.
+   */ async #getFromStage(jobId, dbSlotKey) {
+        const jobStagedCapsules = this.#getJobStagedCapsules(jobId);
+        let staged = jobStagedCapsules.get(dbSlotKey);
+        // Note that if staged === null, we marked it for deletion, so we don't want to
+        // re-read it from DB
+        if (staged === undefined) {
+            // If we don't have a staged version of this dbSlotKey, first we check if there's one in DB
+            staged = await this.#loadCapsuleFromDb(dbSlotKey);
+        }
+        return staged;
+    }
+    /**
+   * Writes a capsule to the stage of a job.
+   */ #setOnStage(jobId, dbSlotKey, capsuleData) {
+        this.#getJobStagedCapsules(jobId).set(dbSlotKey, capsuleData);
+    }
+    /**
+   * Deletes a capsule on the stage of a job. Note the capsule will still
+   * exist in storage until the job is committed.
+   */ #deleteOnStage(jobId, dbSlotKey) {
+        this.#getJobStagedCapsules(jobId).set(dbSlotKey, null);
+    }
+    async #loadCapsuleFromDb(dbSlotKey) {
+        const dataBuffer = await this.#capsules.getAsync(dbSlotKey);
+        if (!dataBuffer) {
+            return null;
+        }
+        return dataBuffer;
+    }
+    /**
+   * Commits staged data to main storage.
+   * Called by JobCoordinator when a job completes successfully.
+   * Note: JobCoordinator wraps all commits in a single transaction, so we don't
+   * need our own transactionAsync here (and using one would deadlock on IndexedDB).
+   * @param jobId - The jobId identifying which staged data to commit
+   */ async commit(jobId) {
+        const jobStagedCapsules = this.#getJobStagedCapsules(jobId);
+        for (const [key, value] of jobStagedCapsules){
+            // In the write stage, we represent deleted capsules with null
+            // (as opposed to undefined, which denotes there was never a capsule there to begin with).
+            // So we delete from actual KV store here.
+            if (value === null) {
+                await this.#capsules.delete(key);
+            } else {
+                await this.#capsules.set(key, value);
+            }
+        }
+        this.#stagedCapsules.delete(jobId);
+    }
+    /**
+   * Discards staged data without committing.
+   */ discardStaged(jobId) {
+        this.#stagedCapsules.delete(jobId);
+        return Promise.resolve();
+    }
+    /**
    * 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.
+   * @param jobId - The context in which this store will be visible until PXE decides to persist it to underlying KV store
    * @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())));
+   */ storeCapsule(contractAddress, slot, capsule, jobId) {
+        const dbSlotKey = dbSlotToKey(contractAddress, slot);
+        // A store overrides any pre-existing data on the slot
+        this.#setOnStage(jobId, dbSlotKey, 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));
+   */ async loadCapsule(contractAddress, slot, jobId) {
+        const dataBuffer = await this.#getFromStage(jobId, dbSlotToKey(contractAddress, slot));
         if (!dataBuffer) {
             this.logger.trace(`Data not found for contract ${contractAddress.toString()} and slot ${slot.toString()}`);
             return null;
@@ -43,8 +129,9 @@ export class CapsuleStore {
    * 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));
+   */ deleteCapsule(contractAddress, slot, jobId) {
+        // When we commit this, we will interpret null as a deletion, so we'll propagate the delete to the KV store
+        this.#deleteOnStage(jobId, dbSlotToKey(contractAddress, slot));
     }
     /**
    * Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data
@@ -56,7 +143,11 @@ export class CapsuleStore {
    * @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) {
+   */ copyCapsule(contractAddress, srcSlot, dstSlot, numEntries, jobId) {
+        // This transactional context gives us "copy atomicity":
+        // there shouldn't be concurrent writes to what's being copied here.
+        // Equally important: this in practice is expected to perform thousands of DB operations
+        // and not using a transaction here would heavily impact performance.
         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
@@ -69,11 +160,11 @@ export class CapsuleStore {
             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);
+                const toCopy = await this.#getFromStage(jobId, currentSrcSlot);
                 if (!toCopy) {
                     throw new Error(`Attempted to copy empty slot ${currentSrcSlot} for contract ${contractAddress.toString()}`);
                 }
-                await this.#capsules.set(currentDstSlot, toCopy);
+                this.#setOnStage(jobId, currentDstSlot, toCopy);
             }
         });
     }
@@ -84,32 +175,42 @@ export class CapsuleStore {
    * @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) {
+   */ appendToCapsuleArray(contractAddress, baseSlot, content, jobId) {
+        // We wrap this in a transaction to serialize concurrent calls from Promise.all.
+        // Without this, concurrent appends to the same array could race: both read length=0,
+        // both write at the same slots, one overwrites the other.
+        // Equally important: this in practice is expected to perform thousands of DB operations
+        // and not using a transaction here would heavily impact performance.
         return this.#store.transactionAsync(async ()=>{
             // Load current length, defaulting to 0 if not found
-            const lengthData = await this.loadCapsule(contractAddress, baseSlot);
+            const lengthData = await this.loadCapsule(contractAddress, baseSlot, jobId);
             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]);
+                this.storeCapsule(contractAddress, nextSlot, content[i], jobId);
             }
             // Update length to include all new capsules
             const newLength = currentLength + content.length;
-            await this.storeCapsule(contractAddress, baseSlot, [
+            this.storeCapsule(contractAddress, baseSlot, [
                 new Fr(newLength)
-            ]);
+            ], jobId);
         });
     }
-    readCapsuleArray(contractAddress, baseSlot) {
+    readCapsuleArray(contractAddress, baseSlot, jobId) {
+        // I'm leaving this transactional context here though because I'm assuming this
+        // gives us "read array atomicity": there shouldn't be concurrent writes to what's being copied
+        // here.
+        // This is one point we should revisit in the future if we want to relax the concurrency
+        // of jobs: different calls running concurrently on the same contract may cause trouble.
         return this.#store.transactionAsync(async ()=>{
             // Load length, defaulting to 0 if not found
-            const maybeLength = await this.loadCapsule(contractAddress, baseSlot);
+            const maybeLength = await this.loadCapsule(contractAddress, baseSlot, jobId);
             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));
+                const currentValue = await this.loadCapsule(contractAddress, arraySlot(baseSlot, i), jobId);
                 if (currentValue == undefined) {
                     throw new Error(`Expected non-empty value at capsule array in base slot ${baseSlot} at index ${i} for contract ${contractAddress}`);
                 }
@@ -118,22 +219,30 @@ export class CapsuleStore {
             return values;
         });
     }
-    setCapsuleArray(contractAddress, baseSlot, content) {
+    setCapsuleArray(contractAddress, baseSlot, content, jobId) {
+        // This transactional context in theory isn't so critical now because we aren't
+        // writing to DB so if there's exceptions midway and it blows up, no visible impact
+        // to persistent storage will happen.
+        // I'm leaving this transactional context here though because I'm assuming this
+        // gives us "write array atomicity": there shouldn't be concurrent writes to what's being copied
+        // here.
+        // This is one point we should revisit in the future if we want to relax the concurrency
+        // of jobs: different calls running concurrently on the same contract may cause trouble.
         return this.#store.transactionAsync(async ()=>{
             // Load current length, defaulting to 0 if not found
-            const maybeLength = await this.loadCapsule(contractAddress, baseSlot);
+            const maybeLength = await this.loadCapsule(contractAddress, baseSlot, jobId);
             const originalLength = maybeLength ? maybeLength[0].toNumber() : 0;
             // Set the new length
-            await this.storeCapsule(contractAddress, baseSlot, [
+            this.storeCapsule(contractAddress, baseSlot, [
                 new Fr(content.length)
-            ]);
+            ], jobId);
             // 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]);
+                this.storeCapsule(contractAddress, arraySlot(baseSlot, i), content[i], jobId);
             }
             // Clear any stragglers
             for(let i = content.length; i < originalLength; i++){
-                await this.deleteCapsule(contractAddress, arraySlot(baseSlot, i));
+                this.deleteCapsule(contractAddress, arraySlot(baseSlot, i), jobId);
             }
         });
     }

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

@@ -36,9 +36,8 @@ export declare class NoteStore {
     /**
      * 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.
+     * 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
@@ -51,10 +50,12 @@ export declare class NoteStore {
      * specified block number. It restores any notes that were nullified after the given block
      * and deletes any active notes created after that block.
      *
+     * IMPORTANT: This method must be called within a transaction to ensure atomicity.
+     *
      * @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>;
+    rollback(blockNumber: number, synchedBlockNumber: number): Promise<void>;
     /**
      * Retrieves notes based on the provided filter criteria.
      *
@@ -81,4 +82,4 @@ export declare class NoteStore {
      */
     applyNullifiers(nullifiers: DataInBlock<Fr>[]): Promise<NoteDao[]>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90ZV9zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0b3JhZ2Uvbm90ZV9zdG9yZS9ub3RlX3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXpELE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFxQyxNQUFNLGlCQUFpQixDQUFDO0FBQzVGLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUMzRCxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN2RCxPQUFPLEVBQWMsS0FBSyxXQUFXLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNsRSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFN0M7Ozs7O0lBS0k7QUFDSixxQkFBYSxTQUFTOztJQWlCcEIsT0FBTyxlQWdCTjtJQUVEOzs7Ozs7OztPQVFHO0lBQ0gsT0FBb0IsTUFBTSxDQUFDLEtBQUssRUFBRSxpQkFBaUIsR0FBRyxPQUFPLENBQUMsU0FBUyxDQUFDLENBT3ZFO0lBRUQ7Ozs7Ozs7O09BUUc7SUFDVSxRQUFRLENBQUMsS0FBSyxFQUFFLFlBQVksR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLENBWTNEO0lBRUQ7Ozs7Ozs7OztPQVNHO0lBQ0gsUUFBUSxDQUFDLEtBQUssRUFBRSxPQUFPLEVBQUUsRUFBRSxLQUFLLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FnQjdEO0lBRUQ7Ozs7Ozs7OztPQVNHO0lBQ1UsMEJBQTBCLENBQUMsV0FBVyxFQUFFLE1BQU0sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUd0RztJQXVGRDs7Ozs7Ozs7Ozs7T0FXRztJQUNHLFFBQVEsQ0FBQyxNQUFNLEVBQUUsV0FBVyxHQUFHLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQXdHdEQ7SUFFRDs7Ozs7Ozs7OztPQVVHO0lBQ0gsZUFBZSxDQUFDLFVBQVUsRUFBRSxXQUFXLENBQUMsRUFBRSxDQUFDLEVBQUUsR0FBRyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUMsQ0E4RGpFO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90ZV9zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0b3JhZ2Uvbm90ZV9zdG9yZS9ub3RlX3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBRXpELE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFxQyxNQUFNLGlCQUFpQixDQUFDO0FBQzVGLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUMzRCxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN2RCxPQUFPLEVBQWMsS0FBSyxXQUFXLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNsRSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFN0M7Ozs7O0lBS0k7QUFDSixxQkFBYSxTQUFTOztJQTRCcEIsT0FBTyxlQWNOO0lBRUQ7Ozs7Ozs7O09BUUc7SUFDSCxPQUFvQixNQUFNLENBQUMsS0FBSyxFQUFFLGlCQUFpQixHQUFHLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FPdkU7SUFFRDs7Ozs7Ozs7T0FRRztJQUNVLFFBQVEsQ0FBQyxLQUFLLEVBQUUsWUFBWSxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FZM0Q7SUFFRDs7Ozs7Ozs7T0FRRztJQUNILFFBQVEsQ0FBQyxLQUFLLEVBQUUsT0FBTyxFQUFFLEVBQUUsS0FBSyxFQUFFLFlBQVksR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBZTdEO0lBRUQ7Ozs7Ozs7Ozs7O09BV0c7SUFDVSxRQUFRLENBQUMsV0FBVyxFQUFFLE1BQU0sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUdwRjtJQWlGRDs7Ozs7Ozs7Ozs7T0FXRztJQUNHLFFBQVEsQ0FBQyxNQUFNLEVBQUUsV0FBVyxHQUFHLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQyxDQW1IdEQ7SUFFRDs7Ozs7Ozs7OztPQVVHO0lBQ0gsZUFBZSxDQUFDLFVBQVUsRUFBRSxXQUFXLENBQUMsRUFBRSxDQUFDLEVBQUUsR0FBRyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FvRGpFO0NBQ0YifQ==

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

@@ -1 +1 @@
-{"version":3,"file":"note_store.d.ts","sourceRoot":"","sources":["../../../src/storage/note_store/note_store.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,SAAS;;IAiBpB,OAAO,eAgBN;IAED;;;;;;;;OAQG;IACH,OAAoB,MAAM,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,SAAS,CAAC,CAOvE;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"}
+{"version":3,"file":"note_store.d.ts","sourceRoot":"","sources":["../../../src/storage/note_store/note_store.ts"],"names":[],"mappings":"AAAA,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,SAAS;;IA4BpB,OAAO,eAcN;IAED;;;;;;;;OAQG;IACH,OAAoB,MAAM,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,SAAS,CAAC,CAOvE;IAED;;;;;;;;OAQG;IACU,QAAQ,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,OAAO,CAAC,CAY3D;IAED;;;;;;;;OAQG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAe7D;IAED;;;;;;;;;;;OAWG;IACU,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGpF;IAiFD;;;;;;;;;;;OAWG;IACG,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAmHtD;IAED;;;;;;;;;;OAUG;IACH,eAAe,CAAC,UAAU,EAAE,WAAW,CAAC,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAoDjE;CACF"}

package/dest/storage/note_store/note_store.js

@@ -1,4 +1,3 @@
-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';
@@ -10,28 +9,25 @@ import { NoteDao } from '@aztec/stdlib/note';
  * and performs rollback handling in the case of a reorg.
  **/ export class NoteStore {
     #store;
-    #notes;
-    #nullifiedNotes;
-    #nullifierToNoteId;
-    #nullifiersByBlockNumber;
-    #nullifiedNotesToScope;
-    #nullifiedNotesByContract;
-    #nullifiedNotesByStorageSlot;
-    #nullifiedNotesByNullifier;
-    #scopes;
-    #notesToScope;
-    #notesByContractAndScope;
-    #notesByStorageSlotAndScope;
+    // Note that we use the siloedNullifier as the note id in the store as it's guaranteed to be unique.
+    /** noteId (siloedNullifier) -> NoteDao (serialized) */ #notes;
+    /** noteId (siloedNullifier) -> NoteDao (serialized) */ #nullifiedNotes;
+    /** blockNumber -> siloedNullifier */ #nullifiersByBlockNumber;
+    /** noteId (siloedNullifier) -> scope */ #nullifiedNotesToScope;
+    /** contractAddress -> noteId (siloedNullifier) */ #nullifiedNotesByContract;
+    /** storageSlot -> noteId (siloedNullifier) */ #nullifiedNotesByStorageSlot;
+    /** scope (AztecAddress) -> true */ #scopes;
+    /** noteId (siloedNullifier) -> scope */ #notesToScope;
+    /** scope -> MultiMap(contractAddress -> noteId) */ #notesByContractAndScope;
+    /** scope -> MultiMap(storageSlot -> noteId) */ #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();
@@ -74,9 +70,8 @@ import { NoteDao } from '@aztec/stdlib/note';
     /**
    * 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.
+   * 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
@@ -86,12 +81,11 @@ import { NoteDao } from '@aztec/stdlib/note';
                 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);
+                const noteId = dao.siloedNullifier.toString();
+                await this.#notes.set(noteId, dao.toBuffer());
+                await this.#notesToScope.set(noteId, scope.toString());
+                await this.#notesByContractAndScope.get(scope.toString()).set(dao.contractAddress.toString(), noteId);
+                await this.#notesByStorageSlotAndScope.get(scope.toString()).set(dao.storageSlot.toString(), noteId);
             }
         });
     }
@@ -102,9 +96,11 @@ import { NoteDao } from '@aztec/stdlib/note';
    * specified block number. It restores any notes that were nullified after the given block
    * and deletes any active notes created after that block.
    *
+   * IMPORTANT: This method must be called within a transaction to ensure atomicity.
+   *
    * @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) {
+   */ async rollback(blockNumber, synchedBlockNumber) {
         await this.#rewindNullifiersAfterBlock(blockNumber, synchedBlockNumber);
         await this.#deleteActiveNotesAfterBlock(blockNumber);
     }
@@ -115,24 +111,21 @@ import { NoteDao } from '@aztec/stdlib/note';
    * 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);
-                    }
+   */ async #deleteActiveNotesAfterBlock(blockNumber) {
+        const notes = await toArray(this.#notes.valuesAsync());
+        for (const note of notes){
+            const noteDao = NoteDao.fromBuffer(note);
+            if (noteDao.l2BlockNumber > blockNumber) {
+                const noteId = noteDao.siloedNullifier.toString();
+                await this.#notes.delete(noteId);
+                await this.#notesToScope.delete(noteId);
+                const scopes = await toArray(this.#scopes.keysAsync());
+                for (const scope of scopes){
+                    await this.#notesByContractAndScope.get(scope).deleteValue(noteDao.contractAddress.toString(), noteId);
+                    await this.#notesByStorageSlotAndScope.get(scope).deleteValue(noteDao.storageSlot.toString(), noteId);
                 }
             }
-        });
+        }
     }
     /**
    * Rewinds nullifications after a given block number.
@@ -144,39 +137,38 @@ import { NoteDao } from '@aztec/stdlib/note';
    * @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 noteIdsToReinsert = [];
+        const currentBlockNumber = blockNumber + 1;
+        for(let i = currentBlockNumber; i <= synchedBlockNumber; i++){
+            // noteId === siloedNullifier.toString(), so we can use nullifiers directly as noteIds
+            noteIdsToReinsert.push(...await toArray(this.#nullifiersByBlockNumber.getValuesAsync(i)));
+        }
+        const nullifiedNoteBuffers = await Promise.all(noteIdsToReinsert.map((noteId)=>this.#nullifiedNotes.getAsync(noteId)));
+        const noteDaos = nullifiedNoteBuffers.filter((buffer)=>buffer != undefined).map((buffer)=>NoteDao.fromBuffer(buffer));
+        for (const dao of noteDaos){
+            const noteId = dao.siloedNullifier.toString();
+            const scopes = await toArray(this.#nullifiedNotesToScope.getValuesAsync(noteId));
+            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 nullifier ${noteId}`);
             }
-            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());
+            for (const scope of scopes){
+                await Promise.all([
+                    this.#notesByContractAndScope.get(scope.toString()).set(dao.contractAddress.toString(), noteId),
+                    this.#notesByStorageSlotAndScope.get(scope.toString()).set(dao.storageSlot.toString(), noteId),
+                    this.#notesToScope.set(noteId, scope)
+                ]);
             }
-        });
+            await Promise.all([
+                this.#notes.set(noteId, dao.toBuffer()),
+                this.#nullifiedNotes.delete(noteId),
+                this.#nullifiedNotesToScope.delete(noteId),
+                this.#nullifiersByBlockNumber.deleteValue(dao.l2BlockNumber, dao.siloedNullifier.toString()),
+                this.#nullifiedNotesByContract.deleteValue(dao.contractAddress.toString(), noteId),
+                this.#nullifiedNotesByStorageSlot.deleteValue(dao.storageSlot.toString(), noteId)
+            ]);
+        }
     }
     /**
    * Retrieves notes based on the provided filter criteria.
@@ -257,6 +249,16 @@ import { NoteDao } from '@aztec/stdlib/note';
                 deduplicated.push(note);
             }
         }
+        // Sort by block number, then by tx index within block, then by note index within tx
+        deduplicated.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;
+        });
         return deduplicated;
     }
     /**
@@ -277,21 +279,16 @@ import { NoteDao } from '@aztec/stdlib/note';
             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) {
+                const noteId = nullifier.toString();
+                const noteBuffer = await this.#notes.getAsync(noteId);
+                if (!noteBuffer) {
+                    // Check if already nullified (noteId === siloedNullifier, so we can check #nullifiedNotes directly)
+                    if (await this.#nullifiedNotes.hasAsync(noteId)) {
                         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));
+                const noteScopes = await toArray(this.#notesToScope.getValuesAsync(noteId));
                 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.
@@ -299,22 +296,20 @@ import { NoteDao } from '@aztec/stdlib/note';
                 }
                 const note = NoteDao.fromBuffer(noteBuffer);
                 nullifiedNotes.push(note);
-                await this.#notes.delete(noteIndex);
-                await this.#notesToScope.delete(noteIndex);
+                await this.#notes.delete(noteId);
+                await this.#notesToScope.delete(noteId);
                 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);
+                    await this.#notesByContractAndScope.get(scope).deleteValue(note.contractAddress.toString(), noteId);
+                    await this.#notesByStorageSlotAndScope.get(scope).deleteValue(note.storageSlot.toString(), noteId);
                 }
                 for (const scope of noteScopes){
-                    await this.#nullifiedNotesToScope.set(noteIndex, scope);
+                    await this.#nullifiedNotesToScope.set(noteId, 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());
+                await this.#nullifiedNotes.set(noteId, note.toBuffer());
+                await this.#nullifiersByBlockNumber.set(blockNumber, noteId);
+                await this.#nullifiedNotesByContract.set(note.contractAddress.toString(), noteId);
+                await this.#nullifiedNotesByStorageSlot.set(note.storageSlot.toString(), noteId);
             }
             return nullifiedNotes;
         });

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

@@ -14,6 +14,10 @@ export type PrivateEventStoreFilter = {
 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.
@@ -25,15 +29,16 @@ export declare class PrivateEventStore {
     /**
      * 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 eventCommitmentIndex - The index of the event commitment in the nullifier tree.
+     * @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[], eventCommitmentIndex: number, metadata: PrivateEventMetadata): Promise<void>;
+    storePrivateEventLog(eventSelector: EventSelector, randomness: Fr, msgContent: Fr[], siloedEventCommitment: Fr, metadata: PrivateEventMetadata): Promise<void>;
     /**
      * Returns the private events given search parameters.
      * @param eventSelector - The event selector to filter by.
@@ -42,15 +47,17 @@ export declare class PrivateEventStore {
      *  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 .
+     * @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[]>;
     /**
      * Rolls back private events that were stored after a given `blockNumber` and up to `synchedBlockNumber` (the block
      * number up to which PXE managed to sync before the reorg happened).
+     *
+     * IMPORTANT: This method must be called within a transaction to ensure atomicity.
      */
-    rollbackEventsAfterBlock(blockNumber: number, synchedBlockNumber: number): Promise<void>;
+    rollback(blockNumber: number, synchedBlockNumber: number): Promise<void>;
 }
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZV9ldmVudF9zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0b3JhZ2UvcHJpdmF0ZV9ldmVudF9zdG9yZS9wcml2YXRlX2V2ZW50X3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUdwRCxPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBaUIsTUFBTSxpQkFBaUIsQ0FBQztBQUN4RSxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUN2RCxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUVoRSxPQUFPLEVBQUUsS0FBSyxJQUFJLEVBQUUsTUFBTSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFckQsT0FBTyxLQUFLLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFdkQsTUFBTSxNQUFNLHVCQUF1QixHQUFHO0lBQ3BDLGVBQWUsRUFBRSxZQUFZLENBQUM7SUFDOUIsU0FBUyxFQUFFLE1BQU0sQ0FBQztJQUNsQixPQUFPLEVBQUUsTUFBTSxDQUFDO0lBQ2hCLE1BQU0sRUFBRSxZQUFZLEVBQUUsQ0FBQztJQUN2QixNQUFNLENBQUMsRUFBRSxNQUFNLENBQUM7Q0FDakIsQ0FBQztBQWFGLEtBQUssb0JBQW9CLEdBQUcsSUFBSSxHQUFHO0lBQ2pDLGVBQWUsRUFBRSxZQUFZLENBQUM7SUFDOUIsS0FBSyxFQUFFLFlBQVksQ0FBQztDQUNyQixDQUFDO0FBRUY7O0dBRUc7QUFDSCxxQkFBYSxpQkFBaUI7O0lBVzVCLE1BQU0seUNBQXVDO0lBRTdDLFlBQVksS0FBSyxFQUFFLGlCQUFpQixFQU1uQztJQU1EOzs7Ozs7Ozs7O09BVUc7SUFDSCxvQkFBb0IsQ0FDbEIsYUFBYSxFQUFFLGFBQWEsRUFDNUIsVUFBVSxFQUFFLEVBQUUsRUFDZCxVQUFVLEVBQUUsRUFBRSxFQUFFLEVBQ2hCLG9CQUFvQixFQUFFLE1BQU0sRUFDNUIsUUFBUSxFQUFFLG9CQUFvQixHQUM3QixPQUFPLENBQUMsSUFBSSxDQUFDLENBa0NmO0lBRUQ7Ozs7Ozs7Ozs7T0FVRztJQUNVLGdCQUFnQixDQUMzQixhQUFhLEVBQUUsYUFBYSxFQUM1QixNQUFNLEVBQUUsdUJBQXVCLEdBQzlCLE9BQU8sQ0FBQyxrQkFBa0IsRUFBRSxDQUFDLENBd0MvQjtJQUVEOzs7T0FHRztJQUNVLHdCQUF3QixDQUFDLFdBQVcsRUFBRSxNQUFNLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FxQ3BHO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpdmF0ZV9ldmVudF9zdG9yZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3N0b3JhZ2UvcHJpdmF0ZV9ldmVudF9zdG9yZS9wcml2YXRlX2V2ZW50X3N0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUdwRCxPQUFPLEtBQUssRUFBRSxpQkFBaUIsRUFBaUIsTUFBTSxpQkFBaUIsQ0FBQztBQUN4RSxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUN2RCxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUVoRSxPQUFPLEVBQUUsS0FBSyxJQUFJLEVBQUUsTUFBTSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFckQsT0FBTyxLQUFLLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFdkQsTUFBTSxNQUFNLHVCQUF1QixHQUFHO0lBQ3BDLGVBQWUsRUFBRSxZQUFZLENBQUM7SUFDOUIsU0FBUyxFQUFFLE1BQU0sQ0FBQztJQUNsQixPQUFPLEVBQUUsTUFBTSxDQUFDO0lBQ2hCLE1BQU0sRUFBRSxZQUFZLEVBQUUsQ0FBQztJQUN2QixNQUFNLENBQUMsRUFBRSxNQUFNLENBQUM7Q0FDakIsQ0FBQztBQWdCRixLQUFLLG9CQUFvQixHQUFHLElBQUksR0FBRztJQUNqQyxlQUFlLEVBQUUsWUFBWSxDQUFDO0lBQzlCLEtBQUssRUFBRSxZQUFZLENBQUM7SUFDcEIsMkNBQTJDO0lBQzNDLGNBQWMsRUFBRSxNQUFNLENBQUM7SUFDdkIseUVBQXlFO0lBQ3pFLGNBQWMsRUFBRSxNQUFNLENBQUM7Q0FDeEIsQ0FBQztBQUVGOztHQUVHO0FBQ0gscUJBQWEsaUJBQWlCOztJQVc1QixNQUFNLHlDQUF1QztJQUU3QyxZQUFZLEtBQUssRUFBRSxpQkFBaUIsRUFNbkM7SUFNRDs7Ozs7Ozs7Ozs7T0FXRztJQUNILG9CQUFvQixDQUNsQixhQUFhLEVBQUUsYUFBYSxFQUM1QixVQUFVLEVBQUUsRUFBRSxFQUNkLFVBQVUsRUFBRSxFQUFFLEVBQUUsRUFDaEIscUJBQXFCLEVBQUUsRUFBRSxFQUN6QixRQUFRLEVBQUUsb0JBQW9CLEdBQzdCLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FzQ2Y7SUFFRDs7Ozs7Ozs7OztPQVVHO0lBQ1UsZ0JBQWdCLENBQzNCLGFBQWEsRUFBRSxhQUFhLEVBQzVCLE1BQU0sRUFBRSx1QkFBdUIsR0FDOUIsT0FBTyxDQUFDLGtCQUFrQixFQUFFLENBQUMsQ0F1RC9CO0lBRUQ7Ozs7O09BS0c7SUFDVSxRQUFRLENBQUMsV0FBVyxFQUFFLE1BQU0sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQW1DcEY7Q0FDRiJ9