@interest-protocol/vortex-sdk 2.0.0 → 3.0.0

package/dist/entities/merkle-tree.d.ts

@@ -1,81 +1,3 @@
-/**
- * Sparse Merkle tree using Tornado Cash Nova's paired insertion strategy.
- * Inserts two leaves at once for better efficiency and privacy.
- */
-export declare class MerkleTree {
-    levels: number;
-    capacity: number;
-    zeroElement: bigint;
-    private zeros;
-    private subtrees;
-    private _nextIndex;
-    private leaves;
-    private _root;
-    constructor(levels: number);
-    /**
-     * Returns the current Merkle root
-     */
-    root(): bigint;
-    /**
-     * Insert elements in bulk (must be even number for pairing)
-     */
-    bulkInsert(elements: bigint[]): void;
-    /**
-     * Insert a pair of leaves (Nova style)
-     * This is the primary insertion method
-     */
-    insertPair(leaf1: bigint, leaf2: bigint): void;
-    /**
-     * Insert a single leaf (for backward compatibility)
-     * Pairs it with a zero leaf
-     */
-    insert(leaf: bigint): void;
-    /**
-     * Generate Merkle path for a leaf at given index
-     * Returns sibling hashes and indices for verification
-     */
-    path(index: number): {
-        pathElements: bigint[];
-        pathIndices: number[];
-    };
-    /**
-     * Get all leaves in the tree
-     */
-    elements(): bigint[];
-    /**
-     * Find the index of a specific leaf
-     */
-    indexOf(element: bigint, comparator?: Function | null): number;
-    /**
-     * Serialize tree state
-     */
-    serialize(): {
-        levels: number;
-        zeros: bigint[];
-        subtrees: bigint[];
-        nextIndex: number;
-        leaves: bigint[];
-        root: bigint;
-    };
-    /**
-     * Verify a Merkle path is valid for a given leaf and root
-     */
-    verify(leaf: bigint, pathElements: bigint[], pathIndices: number[], root: bigint): boolean;
-    /**
-     * Get the current number of leaves in the tree
-     */
-    get nextIndex(): number;
-    /**
-     * Check if the tree is full
-     */
-    isFull(): boolean;
-    /**
-     * Get the maximum capacity of the tree
-     */
-    getCapacity(): number;
-    /**
-     * Get the current fill percentage
-     */
-    getFillPercentage(): number;
-}
+import { MerkleTree as FixedMerkleTree } from 'fixed-merkle-tree';
+export declare const buildMerkleTree: () => FixedMerkleTree;
 //# sourceMappingURL=merkle-tree.d.ts.map

package/dist/entities/merkle-tree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"merkle-tree.d.ts","sourceRoot":"","sources":["../../src/entities/merkle-tree.ts"],"names":[],"mappings":"AASA;;;GAGG;AACH,qBAAa,UAAU;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IAEpB,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,KAAK,CAAS;gBAEV,MAAM,EAAE,MAAM;IAyB1B;;OAEG;IACH,IAAI,IAAI,MAAM;IAId;;OAEG;IACH,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE;IAU7B;;;OAGG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAuCvC;;;OAGG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM;IAInB;;;OAGG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG;QAAE,YAAY,EAAE,MAAM,EAAE,CAAC;QAAC,WAAW,EAAE,MAAM,EAAE,CAAA;KAAE;IAyCtE;;OAEG;IACH,QAAQ,IAAI,MAAM,EAAE;IAIpB;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,GAAE,QAAQ,GAAG,IAAW,GAAG,MAAM;IAOpE;;OAEG;IACH,SAAS;;;;;;;;IAWT;;OAEG;IACH,MAAM,CACJ,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,MAAM,EAAE,EACtB,WAAW,EAAE,MAAM,EAAE,EACrB,IAAI,EAAE,MAAM,GACX,OAAO;IAwBV;;OAEG;IACH,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED;;OAEG;IACH,MAAM,IAAI,OAAO;IAIjB;;OAEG;IACH,WAAW,IAAI,MAAM;IAIrB;;OAEG;IACH,iBAAiB,IAAI,MAAM;CAG5B"}
+{"version":3,"file":"merkle-tree.d.ts","sourceRoot":"","sources":["../../src/entities/merkle-tree.ts"],"names":[],"mappings":"AAIA,OAAO,EAAW,UAAU,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAE3E,eAAO,MAAM,eAAe,uBAKxB,CAAC"}

package/dist/index.js

@@ -3,6 +3,7 @@
 var suitcaseCore = require('@polymedia/suitcase-core');
 var invariant = require('tiny-invariant');
 var ramda = require('ramda');
+var fixedMerkleTree = require('fixed-merkle-tree');
 var require$$0 = require('fs');
 var bn_js = require('bn.js');
 
@@ -38843,201 +38844,10 @@ _VortexKeypair_instances = new WeakSet(), _VortexKeypair_decrypt = function _Vor
 };
 
 // packages/vortex/src/entities/merkle-tree.ts
-/**
- * Sparse Merkle tree using Tornado Cash Nova's paired insertion strategy.
- * Inserts two leaves at once for better efficiency and privacy.
- */
-class MerkleTree {
-    constructor(levels) {
-        this.levels = levels;
-        this.capacity = 2 ** levels;
-        this.zeroElement = ZERO_VALUE;
-        this.zeros = [];
-        this.subtrees = [];
-        this._nextIndex = 0;
-        this.leaves = [];
-        // Initialize zero hashes (0 to levels, inclusive)
-        // We need levels+1 elements: zeros[0] through zeros[levels]
-        for (let i = 0; i <= levels; i++) {
-            this.zeros[i] = EMPTY_SUBTREE_HASHES[i];
-        }
-        // Initialize subtrees[0..levels-1] (matching Nova's filledSubtrees)
-        // subtrees[0] is initialized but never used (Nova quirk)
-        for (let i = 0; i < levels; i++) {
-            this.subtrees[i] = this.zeros[i];
-        }
-        // Empty root is zeros[levels]
-        this._root = this.zeros[levels];
-    }
-    /**
-     * Returns the current Merkle root
-     */
-    root() {
-        return this._root;
-    }
-    /**
-     * Insert elements in bulk (must be even number for pairing)
-     */
-    bulkInsert(elements) {
-        if (elements.length % 2 !== 0) {
-            throw new Error('Must insert even number of elements (pairs)');
-        }
-        for (let i = 0; i < elements.length; i += 2) {
-            this.insertPair(elements[i], elements[i + 1]);
-        }
-    }
-    /**
-     * Insert a pair of leaves (Nova style)
-     * This is the primary insertion method
-     */
-    insertPair(leaf1, leaf2) {
-        if (this._nextIndex >= this.capacity) {
-            throw new Error('Merkle tree is full. No more leaves can be added');
-        }
-        // Store both leaves
-        this.leaves.push(leaf1, leaf2);
-        // Start by hashing the pair (level 0)
-        let currentIndex = Math.floor(this._nextIndex / 2);
-        let currentLevelHash = poseidon2(leaf1, leaf2);
-        // Increment by 2 since we're inserting a pair
-        this._nextIndex += 2;
-        // Process levels 1 to levels-1 (matching Nova: for i = 1; i < levels)
-        for (let i = 1; i < this.levels; i++) {
-            let left;
-            let right;
-            if (currentIndex % 2 === 0) {
-                // Current is left child
-                left = currentLevelHash;
-                right = this.zeros[i];
-                this.subtrees[i] = currentLevelHash; // Cache left subtree
-            }
-            else {
-                // Current is right child
-                left = this.subtrees[i]; // Get cached left subtree
-                right = currentLevelHash;
-            }
-            currentLevelHash = poseidon2(left, right);
-            currentIndex = Math.floor(currentIndex / 2);
-        }
-        // Update root
-        this._root = currentLevelHash;
-    }
-    /**
-     * Insert a single leaf (for backward compatibility)
-     * Pairs it with a zero leaf
-     */
-    insert(leaf) {
-        this.insertPair(leaf, this.zeros[0]);
-    }
-    /**
-     * Generate Merkle path for a leaf at given index
-     * Returns sibling hashes and indices for verification
-     */
-    path(index) {
-        if (index < 0 || index >= this._nextIndex) {
-            throw new Error(`Index out of bounds: ${index} (tree has ${this._nextIndex} leaves)`);
-        }
-        const pathElements = [];
-        const pathIndices = [];
-        // Level 0: Get sibling leaf
-        const isLeftAtLevel0 = index % 2 === 0;
-        pathIndices.push(isLeftAtLevel0 ? 0 : 1);
-        const siblingIndex = isLeftAtLevel0 ? index + 1 : index - 1;
-        const sibling = siblingIndex < this._nextIndex
-            ? this.leaves[siblingIndex]
-            : this.zeros[0];
-        pathElements.push(sibling);
-        // Levels 1 to levels-1 (matching Nova's loop structure)
-        let currentIndex = Math.floor(index / 2);
-        for (let i = 1; i < this.levels; i++) {
-            const isLeft = currentIndex % 2 === 0;
-            pathIndices.push(isLeft ? 0 : 1);
-            if (isLeft) {
-                // We're left child, sibling is right (zero hash)
-                pathElements.push(this.zeros[i]);
-            }
-            else {
-                // We're right child, sibling is the cached left subtree
-                pathElements.push(this.subtrees[i]);
-            }
-            currentIndex = Math.floor(currentIndex / 2);
-        }
-        return { pathElements, pathIndices };
-    }
-    /**
-     * Get all leaves in the tree
-     */
-    elements() {
-        return this.leaves;
-    }
-    /**
-     * Find the index of a specific leaf
-     */
-    indexOf(element, comparator = null) {
-        if (comparator) {
-            return this.leaves.findIndex((leaf) => comparator(element, leaf));
-        }
-        return this.leaves.findIndex((leaf) => leaf === element);
-    }
-    /**
-     * Serialize tree state
-     */
-    serialize() {
-        return {
-            levels: this.levels,
-            zeros: this.zeros,
-            subtrees: this.subtrees,
-            nextIndex: this._nextIndex,
-            leaves: this.leaves,
-            root: this._root,
-        };
-    }
-    /**
-     * Verify a Merkle path is valid for a given leaf and root
-     */
-    verify(leaf, pathElements, pathIndices, root) {
-        if (pathElements.length !== this.levels ||
-            pathIndices.length !== this.levels) {
-            return false;
-        }
-        let currentHash = leaf;
-        for (let i = 0; i < this.levels; i++) {
-            const sibling = pathElements[i];
-            const isLeft = pathIndices[i] === 0;
-            if (isLeft) {
-                currentHash = poseidon2(currentHash, sibling);
-            }
-            else {
-                currentHash = poseidon2(sibling, currentHash);
-            }
-        }
-        return currentHash === root;
-    }
-    /**
-     * Get the current number of leaves in the tree
-     */
-    get nextIndex() {
-        return this._nextIndex;
-    }
-    /**
-     * Check if the tree is full
-     */
-    isFull() {
-        return this._nextIndex >= this.capacity;
-    }
-    /**
-     * Get the maximum capacity of the tree
-     */
-    getCapacity() {
-        return this.capacity;
-    }
-    /**
-     * Get the current fill percentage
-     */
-    getFillPercentage() {
-        return (this._nextIndex / this.capacity) * 100;
-    }
-}
+const buildMerkleTree = () => new fixedMerkleTree.MerkleTree(MERKLE_TREE_HEIGHT, [], {
+    hashFunction: (left, right) => poseidon2(BigInt(left), BigInt(right)).toString(),
+    zeroElement: ZERO_VALUE.toString(),
+});
 
 class Utxo {
     constructor({ amount, blinding, keypair, index }) {
@@ -39612,7 +39422,7 @@ function getMerklePath(merkleTree, utxo) {
             .map(() => [ZERO_VALUE.toString(), ZERO_VALUE.toString()]);
     }
     const utxoIndex = Number(utxo.index);
-    const treeSize = merkleTree.elements().length;
+    const treeSize = merkleTree.elements.length;
     // For deposits, input UTXOs don't exist yet
     if (utxoIndex < 0 || utxoIndex >= treeSize) {
         return Array(MERKLE_TREE_HEIGHT)
@@ -39623,13 +39433,13 @@ function getMerklePath(merkleTree, utxo) {
     const { pathElements, pathIndices } = merkleTree.path(utxoIndex);
     const commitment = utxo.commitment();
     // Verify commitment matches what's in the tree
-    const storedCommitment = merkleTree.elements()[utxoIndex];
+    const storedCommitment = BigInt(merkleTree.elements[utxoIndex]);
     invariant(storedCommitment === commitment, `Commitment mismatch at index ${utxoIndex}: expected ${commitment}, got ${storedCommitment}`);
     // Build WASM-compatible path (always [left, right] format)
     const wasmPath = [];
     let currentHash = commitment;
     for (let i = 0; i < MERKLE_TREE_HEIGHT; i++) {
-        const sibling = pathElements[i];
+        const sibling = BigInt(pathElements[i]);
         const isLeft = pathIndices[i] === 0;
         invariant(sibling !== undefined, `Sibling undefined at level ${i}`);
         const leftHash = isLeft ? currentHash : sibling;
@@ -39643,13 +39453,13 @@ function getMerklePath(merkleTree, utxo) {
         currentHash = nextHash;
     }
     const calculatedRoot = currentHash;
-    const expectedRoot = merkleTree.root();
+    const expectedRoot = BigInt(merkleTree.root);
     invariant(calculatedRoot === expectedRoot, `Root mismatch: calculated ${calculatedRoot}, expected ${expectedRoot}`);
     return wasmPath;
 }
 const toProveInput = ({ merkleTree, publicAmount, extDataHash, nullifier0, nullifier1, commitment0, commitment1, vortexKeypair, inputUtxo0, inputUtxo1, outputUtxo0, outputUtxo1, }) => {
     return {
-        root: merkleTree.root(),
+        root: BigInt(merkleTree.root),
         publicAmount,
         extDataHash,
         inputNullifier0: nullifier0,
@@ -39761,7 +39571,7 @@ const deposit = async ({ tx = new Transaction(), amount, unspentUtxos = [], vort
     const { proof: moveProof, tx: tx3 } = vortex.newProof({
         tx: tx2,
         proofPoints: fromHex('0x' + proof.proofSerializedHex),
-        root: merkleTree.root(),
+        root: BigInt(merkleTree.root),
         publicValue: amountMinusFrontendFee,
         action: exports.Action.Deposit,
         extDataHash: extDataHashBigInt,
@@ -39862,7 +39672,7 @@ const withdraw = async ({ tx = new Transaction(), amount, unspentUtxos = [], vor
     const { proof: moveProof, tx: tx3 } = vortex.newProof({
         tx: tx2,
         proofPoints: fromHex('0x' + proof.proofSerializedHex),
-        root: merkleTree.root(),
+        root: BigInt(merkleTree.root),
         publicValue: amount + relayerFee,
         action: exports.Action.Withdraw,
         extDataHash: extDataHashBigInt,
@@ -39891,7 +39701,6 @@ exports.INITIAL_SHARED_VERSION = INITIAL_SHARED_VERSION;
 exports.LSK_ENCRYPTED_OUTPUTS = LSK_ENCRYPTED_OUTPUTS;
 exports.LSK_FETCH_OFFSET = LSK_FETCH_OFFSET;
 exports.MERKLE_TREE_HEIGHT = MERKLE_TREE_HEIGHT;
-exports.MerkleTree = MerkleTree;
 exports.OPT = OPT;
 exports.REGISTRY_OBJECT_ID = REGISTRY_OBJECT_ID;
 exports.ROOT_HISTORY_SIZE = ROOT_HISTORY_SIZE;
@@ -39904,6 +39713,7 @@ exports.VORTEX_SIGNATURE_DOMAIN = VORTEX_SIGNATURE_DOMAIN;
 exports.Vortex = Vortex;
 exports.VortexKeypair = VortexKeypair;
 exports.ZERO_VALUE = ZERO_VALUE;
+exports.buildMerkleTree = buildMerkleTree;
 exports.bytesToBigInt = bytesToBigInt;
 exports.computeExtDataHash = computeExtDataHash;
 exports.deposit = deposit;