@aztec/merkle-tree 0.7.2 → 0.7.3

package/dest/sparse_tree/sparse_tree.js

@@ -0,0 +1,31 @@
+import { INITIAL_LEAF, TreeBase } from '../tree_base.js';
+/**
+ * A Merkle tree implementation that uses a LevelDB database to store the tree.
+ */
+export class SparseTree extends TreeBase {
+    /**
+     * Updates a leaf in the tree.
+     * @param leaf - New contents of the leaf.
+     * @param index - Index of the leaf to be updated.
+     */
+    async updateLeaf(leaf, index) {
+        if (index > this.maxIndex) {
+            throw Error(`Index out of bounds. Index ${index}, max index: ${this.maxIndex}.`);
+        }
+        const insertingZeroElement = leaf.equals(INITIAL_LEAF);
+        const originallyZeroElement = (await this.getLeafValue(index, true))?.equals(INITIAL_LEAF);
+        if (insertingZeroElement && originallyZeroElement) {
+            return;
+        }
+        await this.addLeafToCacheAndHashToRoot(leaf, index);
+        if (insertingZeroElement) {
+            // Deleting element (originally non-zero and new value is zero)
+            this.cachedSize = (this.cachedSize ?? this.size) - 1n;
+        }
+        else if (originallyZeroElement) {
+            // Inserting new element (originally zero and new value is non-zero)
+            this.cachedSize = (this.cachedSize ?? this.size) + 1n;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3BhcnNlX3RyZWUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3BhcnNlX3RyZWUvc3BhcnNlX3RyZWUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFlBQVksRUFBRSxRQUFRLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUV6RDs7R0FFRztBQUNILE1BQU0sT0FBTyxVQUFXLFNBQVEsUUFBUTtJQUN0Qzs7OztPQUlHO0lBQ0ksS0FBSyxDQUFDLFVBQVUsQ0FBQyxJQUFZLEVBQUUsS0FBYTtRQUNqRCxJQUFJLEtBQUssR0FBRyxJQUFJLENBQUMsUUFBUSxFQUFFO1lBQ3pCLE1BQU0sS0FBSyxDQUFDLDhCQUE4QixLQUFLLGdCQUFnQixJQUFJLENBQUMsUUFBUSxHQUFHLENBQUMsQ0FBQztTQUNsRjtRQUVELE1BQU0sb0JBQW9CLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUN2RCxNQUFNLHFCQUFxQixHQUFHLENBQUMsTUFBTSxJQUFJLENBQUMsWUFBWSxDQUFDLEtBQUssRUFBRSxJQUFJLENBQUMsQ0FBQyxFQUFFLE1BQU0sQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUMzRixJQUFJLG9CQUFvQixJQUFJLHFCQUFxQixFQUFFO1lBQ2pELE9BQU87U0FDUjtRQUNELE1BQU0sSUFBSSxDQUFDLDJCQUEyQixDQUFDLElBQUksRUFBRSxLQUFLLENBQUMsQ0FBQztRQUNwRCxJQUFJLG9CQUFvQixFQUFFO1lBQ3hCLCtEQUErRDtZQUMvRCxJQUFJLENBQUMsVUFBVSxHQUFHLENBQUMsSUFBSSxDQUFDLFVBQVUsSUFBSSxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDO1NBQ3ZEO2FBQU0sSUFBSSxxQkFBcUIsRUFBRTtZQUNoQyxvRUFBb0U7WUFDcEUsSUFBSSxDQUFDLFVBQVUsR0FBRyxDQUFDLElBQUksQ0FBQyxVQUFVLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQztTQUN2RDtJQUNILENBQUM7Q0FDRiJ9

package/dest/sparse_tree/sparse_tree.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sparse_tree.test.d.ts.map

package/dest/sparse_tree/sparse_tree.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sparse_tree.test.d.ts","sourceRoot":"","sources":["../../src/sparse_tree/sparse_tree.test.ts"],"names":[],"mappings":""}

package/dest/sparse_tree/sparse_tree.test.js

@@ -0,0 +1,133 @@
+import { CircuitsWasm } from '@aztec/circuits.js';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { SiblingPath } from '@aztec/types';
+import { randomBytes } from 'crypto';
+import { default as levelup } from 'levelup';
+import { INITIAL_LEAF, newTree } from '../index.js';
+import { loadTree } from '../load_tree.js';
+import { Pedersen } from '../pedersen.js';
+import { standardBasedTreeTestSuite } from '../test/standard_based_test_suite.js';
+import { treeTestSuite } from '../test/test_suite.js';
+import { createMemDown } from '../test/utils/create_mem_down.js';
+import { SparseTree } from './sparse_tree.js';
+const log = createDebugLogger('aztec:sparse_tree_test');
+const createDb = async (levelUp, hasher, name, depth) => {
+    return await newTree(SparseTree, levelUp, hasher, name, depth);
+};
+const createFromName = async (levelUp, hasher, name) => {
+    return await loadTree(SparseTree, levelUp, hasher, name);
+};
+const TEST_TREE_DEPTH = 3;
+treeTestSuite('SparseTree', createDb, createFromName);
+standardBasedTreeTestSuite('SparseTree', createDb);
+describe('SparseTreeSpecific', () => {
+    let wasm;
+    let pedersen;
+    beforeEach(async () => {
+        wasm = await CircuitsWasm.get();
+        pedersen = new Pedersen(wasm);
+    });
+    it('throws when index is bigger than (2^DEPTH - 1) ', async () => {
+        const db = levelup(createMemDown());
+        const depth = 32;
+        const tree = await createDb(db, pedersen, 'test', depth);
+        const index = 2n ** BigInt(depth);
+        await expect(tree.updateLeaf(Buffer.alloc(32), index)).rejects.toThrow();
+    });
+    it('updating non-empty leaf does not change tree size', async () => {
+        const depth = 32;
+        const maxIndex = 2 ** depth - 1;
+        const db = levelup(createMemDown());
+        const tree = await createDb(db, pedersen, 'test', depth);
+        const randomIndex = BigInt(Math.floor(Math.random() * maxIndex));
+        expect(tree.getNumLeaves(false)).toEqual(0n);
+        // Insert a leaf
+        await tree.updateLeaf(randomBytes(32), randomIndex);
+        expect(tree.getNumLeaves(true)).toEqual(1n);
+        // Update a leaf
+        await tree.updateLeaf(randomBytes(32), randomIndex);
+        expect(tree.getNumLeaves(true)).toEqual(1n);
+    });
+    it('deleting leaf decrements tree size', async () => {
+        const depth = 254;
+        const maxIndex = 2 ** depth - 1;
+        const db = levelup(createMemDown());
+        const tree = await createDb(db, pedersen, 'test', depth);
+        const randomIndex = BigInt(Math.floor(Math.random() * maxIndex));
+        expect(tree.getNumLeaves(false)).toEqual(0n);
+        // Insert a leaf
+        await tree.updateLeaf(randomBytes(32), randomIndex);
+        expect(tree.getNumLeaves(true)).toEqual(1n);
+        // Delete a leaf
+        await tree.updateLeaf(INITIAL_LEAF, randomIndex);
+        expect(tree.getNumLeaves(true)).toEqual(0n);
+    });
+    it('should have correct root and sibling path after in a "non-append-only" way', async () => {
+        const db = levelup(createMemDown());
+        const tree = await createDb(db, pedersen, 'test', 3);
+        const level2ZeroHash = pedersen.compress(INITIAL_LEAF, INITIAL_LEAF);
+        const level1ZeroHash = pedersen.compress(level2ZeroHash, level2ZeroHash);
+        expect(tree.getNumLeaves(false)).toEqual(0n);
+        expect(tree.getRoot(false)).toEqual(pedersen.compress(level1ZeroHash, level1ZeroHash));
+        // Insert leaf at index 3
+        let level1LeftHash;
+        const leafAtIndex3 = randomBytes(32);
+        {
+            await tree.updateLeaf(leafAtIndex3, 3n);
+            expect(tree.getNumLeaves(true)).toEqual(1n);
+            const level2Hash = pedersen.compress(INITIAL_LEAF, leafAtIndex3);
+            level1LeftHash = pedersen.compress(level2ZeroHash, level2Hash);
+            const root = pedersen.compress(level1LeftHash, level1ZeroHash);
+            expect(tree.getRoot(true)).toEqual(root);
+            expect(await tree.getSiblingPath(3n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, level2ZeroHash, level1ZeroHash]));
+        }
+        // Insert leaf at index 6
+        let level1RightHash;
+        {
+            const leafAtIndex6 = randomBytes(32);
+            await tree.updateLeaf(leafAtIndex6, 6n);
+            expect(tree.getNumLeaves(true)).toEqual(2n);
+            const level2Hash = pedersen.compress(leafAtIndex6, INITIAL_LEAF);
+            level1RightHash = pedersen.compress(level2ZeroHash, level2Hash);
+            const root = pedersen.compress(level1LeftHash, level1RightHash);
+            expect(tree.getRoot(true)).toEqual(root);
+            expect(await tree.getSiblingPath(6n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [INITIAL_LEAF, level2ZeroHash, level1LeftHash]));
+        }
+        // Insert leaf at index 2
+        const leafAtIndex2 = randomBytes(32);
+        {
+            await tree.updateLeaf(leafAtIndex2, 2n);
+            expect(tree.getNumLeaves(true)).toEqual(3n);
+            const level2Hash = pedersen.compress(leafAtIndex2, leafAtIndex3);
+            level1LeftHash = pedersen.compress(level2ZeroHash, level2Hash);
+            const root = pedersen.compress(level1LeftHash, level1RightHash);
+            expect(tree.getRoot(true)).toEqual(root);
+            expect(await tree.getSiblingPath(2n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [leafAtIndex3, level2ZeroHash, level1RightHash]));
+        }
+        // Updating leaf at index 3
+        {
+            const updatedLeafAtIndex3 = randomBytes(32);
+            await tree.updateLeaf(updatedLeafAtIndex3, 3n);
+            expect(tree.getNumLeaves(true)).toEqual(3n);
+            const level2Hash = pedersen.compress(leafAtIndex2, updatedLeafAtIndex3);
+            level1LeftHash = pedersen.compress(level2ZeroHash, level2Hash);
+            const root = pedersen.compress(level1LeftHash, level1RightHash);
+            expect(tree.getRoot(true)).toEqual(root);
+            expect(await tree.getSiblingPath(3n, true)).toEqual(new SiblingPath(TEST_TREE_DEPTH, [leafAtIndex2, level2ZeroHash, level1RightHash]));
+        }
+    });
+    // This one is a performance measurement and is enabled only to check regression in performance.
+    it.skip('measures time of inserting 1000 leaves at random positions for depth 254', async () => {
+        const depth = 254;
+        const maxIndex = 2 ** depth - 1;
+        const db = levelup(createMemDown());
+        const tree = await createDb(db, pedersen, 'test', depth);
+        const leaves = Array.from({ length: 1000 }).map(() => randomBytes(32));
+        const indices = Array.from({ length: 1000 }).map(() => BigInt(Math.floor(Math.random() * maxIndex)));
+        const start = Date.now();
+        await Promise.all(leaves.map((leaf, i) => tree.updateLeaf(leaf, indices[i])));
+        const end = Date.now();
+        log(`Inserting 1000 leaves at random positions for depth 254 took ${end - start}ms`);
+    }, 300000);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sparse_tree.test.js","sourceRoot":"","sources":["../../src/sparse_tree/sparse_tree.test.ts"],"names":[],"mappings":"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"}

package/dest/standard_indexed_tree/standard_indexed_tree.d.ts

@@ -0,0 +1,245 @@
+/// <reference types="node" resolution-mode="require"/>
+import { SiblingPath } from '@aztec/types';
+import { IndexedTree, LeafData } from '../interfaces/indexed_tree.js';
+import { TreeBase } from '../tree_base.js';
+/**
+ * All of the data to be return during batch insertion.
+ */
+export interface LowLeafWitnessData<N extends number> {
+    /**
+     * Preimage of the low nullifier that proves non membership.
+     */
+    leafData: LeafData;
+    /**
+     * Sibling path to prove membership of low nullifier.
+     */
+    siblingPath: SiblingPath<N>;
+    /**
+     * The index of low nullifier.
+     */
+    index: bigint;
+}
+/**
+ * Indexed merkle tree.
+ */
+export declare class StandardIndexedTree extends TreeBase implements IndexedTree {
+    protected leaves: LeafData[];
+    protected cachedLeaves: {
+        [key: number]: LeafData;
+    };
+    /**
+     * Appends the given leaves to the tree.
+     * @param _leaves - The leaves to append.
+     * @returns Empty promise.
+     * @remarks Use batchInsert method instead.
+     */
+    appendLeaves(_leaves: Buffer[]): Promise<void>;
+    /**
+     * Commits the changes to the database.
+     * @returns Empty promise.
+     */
+    commit(): Promise<void>;
+    /**
+     * Rolls back the not-yet-committed changes.
+     * @returns Empty promise.
+     */
+    rollback(): Promise<void>;
+    /**
+     * Gets the value of the leaf at the given index.
+     * @param index - Index of the leaf of which to obtain the value.
+     * @param includeUncommitted - Indicates whether to include uncommitted leaves in the computation.
+     * @returns The value of the leaf at the given index or undefined if the leaf is empty.
+     */
+    getLeafValue(index: bigint, includeUncommitted: boolean): Promise<Buffer | undefined>;
+    /**
+     * Finds the index of the largest leaf whose value is less than or equal to the provided value.
+     * @param newValue - The new value to be inserted into the tree.
+     * @param includeUncommitted - If true, the uncommitted changes are included in the search.
+     * @returns The found leaf index and a flag indicating if the corresponding leaf's value is equal to `newValue`.
+     */
+    findIndexOfPreviousValue(newValue: bigint, includeUncommitted: boolean): {
+        /**
+         * The index of the found leaf.
+         */
+        index: number;
+        /**
+         * A flag indicating if the corresponding leaf's value is equal to `newValue`.
+         */
+        alreadyPresent: boolean;
+    };
+    /**
+     * Gets the latest LeafData copy.
+     * @param index - Index of the leaf of which to obtain the LeafData copy.
+     * @param includeUncommitted - If true, the uncommitted changes are included in the search.
+     * @returns A copy of the leaf data at the given index or undefined if the leaf was not found.
+     */
+    getLatestLeafDataCopy(index: number, includeUncommitted: boolean): LeafData | undefined;
+    /**
+     * Finds the index of the minimum value in an array.
+     * @param values - The collection of values to be searched.
+     * @returns The index of the minimum value in the array.
+     */
+    private findMinIndex;
+    /**
+     * Initializes the tree.
+     * @param prefilledSize - A number of leaves that are prefilled with values.
+     * @returns Empty promise.
+     *
+     * @remarks Explanation of pre-filling:
+     *    There needs to be an initial (0,0,0) leaf in the tree, so that when we insert the first 'proper' leaf, we can
+     *    prove that any value greater than 0 doesn't exist in the tree yet. We prefill/pad the tree with "the number of
+     *    leaves that are added by one block" so that the first 'proper' block can insert a full subtree.
+     *
+     *    Without this padding, there would be a leaf (0,0,0) at leaf index 0, making it really difficult to insert e.g.
+     *    1024 leaves for the first block, because there's only neat space for 1023 leaves after 0. By padding with 1023
+     *    more leaves, we can then insert the first block of 1024 leaves into indices 1024:2047.
+     */
+    init(prefilledSize: number): Promise<void>;
+    /**
+     * Loads Merkle tree data from a database and assigns them to this object.
+     */
+    initFromDb(): Promise<void>;
+    /**
+     * Commits all the leaves to the database and removes them from a cache.
+     */
+    private commitLeaves;
+    /**
+     * Clears the cache.
+     */
+    private clearCachedLeaves;
+    /**
+     * Updates a leaf in the tree.
+     * @param leaf - New contents of the leaf.
+     * @param index - Index of the leaf to be updated.
+     */
+    protected updateLeaf(leaf: LeafData, index: bigint): Promise<void>;
+    /**
+     *
+     * Each base rollup needs to provide non membership / inclusion proofs for each of the nullifier.
+     * This method will return membership proofs and perform partial node updates that will
+     * allow the circuit to incrementally update the tree and perform a batch insertion.
+     *
+     * This offers massive circuit performance savings over doing incremental insertions.
+     *
+     * A description of the algorithm can be found here: https://colab.research.google.com/drive/1A0gizduSi4FIiIJZ8OylwIpO9-OTqV-R
+     *
+     * WARNING: This function has side effects, it will insert values into the tree.
+     *
+     * Assumptions:
+     * 1. There are 8 nullifiers provided and they are either unique or empty. (denoted as 0)
+     * 2. If kc 0 has 1 nullifier, and kc 1 has 3 nullifiers the layout will assume to be the sparse
+     *   nullifier layout: [kc0-0, 0, 0, 0, kc1-0, kc1-1, kc1-2, 0]
+     *
+     * Algorithm overview
+     *
+     * In general, if we want to batch insert items, we first need to update their low nullifier to point to them,
+     * then batch insert all of the values at once in the final step.
+     * To update a low nullifier, we provide an insertion proof that the low nullifier currently exists to the
+     * circuit, then update the low nullifier.
+     * Updating this low nullifier will in turn change the root of the tree. Therefore future low nullifier insertion proofs
+     * must be given against this new root.
+     * As a result, each low nullifier membership proof will be provided against an intermediate tree state, each with differing
+     * roots.
+     *
+     * This become tricky when two items that are being batch inserted need to update the same low nullifier, or need to use
+     * a value that is part of the same batch insertion as their low nullifier. In this case a zero low nullifier path is given
+     * to the circuit, and it must determine from the set of batch inserted values if the insertion is valid.
+     *
+     * The following example will illustrate attempting to insert 2,3,20,19 into a tree already containing 0,5,10,15
+     *
+     * The example will explore two cases. In each case the values low nullifier will exist within the batch insertion,
+     * One where the low nullifier comes before the item in the set (2,3), and one where it comes after (20,19).
+     *
+     * The original tree:                       Pending insertion subtree
+     *
+     *  index     0       2       3       4         -       -       -       -
+     *  -------------------------------------      ----------------------------
+     *  val       0       5      10      15         -       -       -       -
+     *  nextIdx   1       2       3       0         -       -       -       -
+     *  nextVal   5      10      15       0         -       -       -       -
+     *
+     *
+     * Inserting 2: (happy path)
+     * 1. Find the low nullifier (0) - provide inclusion proof
+     * 2. Update its pointers
+     * 3. Insert 2 into the pending subtree
+     *
+     *  index     0       2       3       4         5       -       -       -
+     *  -------------------------------------      ----------------------------
+     *  val       0       5      10      15         2       -       -       -
+     *  nextIdx   5       2       3       0         2       -       -       -
+     *  nextVal   2      10      15       0         5       -       -       -
+     *
+     * Inserting 3: The low nullifier exists within the insertion current subtree
+     * 1. When looking for the low nullifier for 3, we will receive 0 again as we have not inserted 2 into the main tree
+     *    This is problematic, as we cannot use either 0 or 2 as our inclusion proof.
+     *    Why cant we?
+     *      - Index 0 has a val 0 and nextVal of 2. This is NOT enough to prove non inclusion of 2.
+     *      - Our existing tree is in a state where we cannot prove non inclusion of 3.
+     *    We do not provide a non inclusion proof to out circuit, but prompt it to look within the insertion subtree.
+     * 2. Update pending insertion subtree
+     * 3. Insert 3 into pending subtree
+     *
+     * (no inclusion proof provided)
+     *  index     0       2       3       4         5       6       -       -
+     *  -------------------------------------      ----------------------------
+     *  val       0       5      10      15         2       3       -       -
+     *  nextIdx   5       2       3       0         6       2       -       -
+     *  nextVal   2      10      15       0         3       5       -       -
+     *
+     * Inserting 20: (happy path)
+     * 1. Find the low nullifier (15) - provide inclusion proof
+     * 2. Update its pointers
+     * 3. Insert 20 into the pending subtree
+     *
+     *  index     0       2       3       4         5       6       7       -
+     *  -------------------------------------      ----------------------------
+     *  val       0       5      10      15         2       3      20       -
+     *  nextIdx   5       2       3       7         6       2       0       -
+     *  nextVal   2      10      15      20         3       5       0       -
+     *
+     * Inserting 19:
+     * 1. In this case we can find a low nullifier, but we are updating a low nullifier that has already been updated
+     *    We can provide an inclusion proof of this intermediate tree state.
+     * 2. Update its pointers
+     * 3. Insert 19 into the pending subtree
+     *
+     *  index     0       2       3       4         5       6       7       8
+     *  -------------------------------------      ----------------------------
+     *  val       0       5      10      15         2       3      20       19
+     *  nextIdx   5       2       3       8         6       2       0       7
+     *  nextVal   2      10      15      19         3       5       0       20
+     *
+     * Perform subtree insertion
+     *
+     *  index     0       2       3       4       5       6       7       8
+     *  ---------------------------------------------------------------------
+     *  val       0       5      10      15       2       3      20       19
+     *  nextIdx   5       2       3       8       6       2       0       7
+     *  nextVal   2      10      15      19       3       5       0       20
+     *
+     * TODO: this implementation will change once the zero value is changed from h(0,0,0). Changes incoming over the next sprint
+     * @param leaves - Values to insert into the tree.
+     * @param subtreeHeight - Height of the subtree.
+     * @returns The data for the leaves to be updated when inserting the new ones.
+     */
+    batchInsert<TreeHeight extends number, SubtreeHeight extends number, SubtreeSiblingPathHeight extends number>(leaves: Buffer[], subtreeHeight: SubtreeHeight): Promise<[LowLeafWitnessData<TreeHeight>[], SiblingPath<SubtreeSiblingPathHeight>] | [undefined, SiblingPath<SubtreeSiblingPathHeight>]>;
+    getSubtreeSiblingPath<SubtreeHeight extends number, SubtreeSiblingPathHeight extends number>(subtreeHeight: SubtreeHeight, includeUncommitted: boolean): Promise<SiblingPath<SubtreeSiblingPathHeight>>;
+    /**
+     * Encodes leaves and appends them to a tree.
+     * @param leaves - Leaves to encode.
+     * @param hash0Leaf - Indicates whether 0 value leaf should be hashed. See {@link encodeLeaf}.
+     * @returns Empty promise
+     */
+    private encodeAndAppendLeaves;
+    /**
+     * Encode a leaf into a buffer.
+     * @param leaf - Leaf to encode.
+     * @param hash0Leaf - Indicates whether 0 value leaf should be hashed. Not hashing 0 value can represent a forced
+     *                    null leaf insertion. Detecting this case by checking for 0 value is safe as in the case of
+     *                    nullifier it is improbable that a valid nullifier would be 0.
+     * @returns Leaf encoded in a buffer.
+     */
+    private encodeLeaf;
+}
+//# sourceMappingURL=standard_indexed_tree.d.ts.map

package/dest/standard_indexed_tree/standard_indexed_tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard_indexed_tree.d.ts","sourceRoot":"","sources":["../../src/standard_indexed_tree/standard_indexed_tree.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3C,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAc3C;;GAEG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC,SAAS,MAAM;IAClD;;OAEG;IACH,QAAQ,EAAE,QAAQ,CAAC;IACnB;;OAEG;IACH,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IAC5B;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAkCD;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,QAAS,YAAW,WAAW;IACtE,SAAS,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAM;IAClC,SAAS,CAAC,YAAY,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAAA;KAAE,CAAM;IAEzD;;;;;OAKG;IACI,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAIrD;;;OAGG;IACU,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAKpC;;;OAGG;IACU,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAKtC;;;;;OAKG;IACI,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;IAM5F;;;;;OAKG;IACH,wBAAwB,CACtB,QAAQ,EAAE,MAAM,EAChB,kBAAkB,EAAE,OAAO,GAC1B;QACD;;WAEG;QACH,KAAK,EAAE,MAAM,CAAC;QACd;;WAEG;QACH,cAAc,EAAE,OAAO,CAAC;KACzB;IAuBD;;;;;OAKG;IACI,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,OAAO,GAAG,QAAQ,GAAG,SAAS;IAW9F;;;;OAIG;IACH,OAAO,CAAC,YAAY;IAapB;;;;;;;;;;;;;OAaG;IACU,IAAI,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BvD;;OAEG;IACU,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA0BxC;;OAEG;YACW,YAAY;IAY1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAIzB;;;;OAIG;cACa,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM;IAgBxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6GG;IACU,WAAW,CACtB,UAAU,SAAS,MAAM,EACzB,aAAa,SAAS,MAAM,EAC5B,wBAAwB,SAAS,MAAM,EAEvC,MAAM,EAAE,MAAM,EAAE,EAChB,aAAa,EAAE,aAAa,GAC3B,OAAO,CACN,CAAC,kBAAkB,CAAC,UAAU,CAAC,EAAE,EAAE,WAAW,CAAC,wBAAwB,CAAC,CAAC,GACzE,CAAC,SAAS,EAAE,WAAW,CAAC,wBAAwB,CAAC,CAAC,CACrD;IA8GK,qBAAqB,CAAC,aAAa,SAAS,MAAM,EAAE,wBAAwB,SAAS,MAAM,EAC/F,aAAa,EAAE,aAAa,EAC5B,kBAAkB,EAAE,OAAO,GAC1B,OAAO,CAAC,WAAW,CAAC,wBAAwB,CAAC,CAAC;IAQjD;;;;;OAKG;YACW,qBAAqB;IAWnC;;;;;;;OAOG;IACH,OAAO,CAAC,UAAU;CAWnB"}