@interest-protocol/vortex-sdk 2.0.0 → 3.0.0

package/dist/index.mjs

@@ -1,6 +1,7 @@
 import { devInspectAndGetReturnValues } from '@polymedia/suitcase-core';
 import invariant from 'tiny-invariant';
 import { pathOr } from 'ramda';
+import { MerkleTree } from 'fixed-merkle-tree';
 import require$$0 from 'fs';
 import { BN } from 'bn.js';
 
@@ -38841,201 +38842,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 MerkleTree(MERKLE_TREE_HEIGHT, [], {
+    hashFunction: (left, right) => poseidon2(BigInt(left), BigInt(right)).toString(),
+    zeroElement: ZERO_VALUE.toString(),
+});
 
 class Utxo {
     constructor({ amount, blinding, keypair, index }) {
@@ -39610,7 +39420,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)
@@ -39621,13 +39431,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;
@@ -39641,13 +39451,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,
@@ -39759,7 +39569,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: Action.Deposit,
         extDataHash: extDataHashBigInt,
@@ -39860,7 +39670,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: Action.Withdraw,
         extDataHash: extDataHashBigInt,
@@ -39879,5 +39689,5 @@ const withdraw = async ({ tx = new Transaction(), amount, unspentUtxos = [], vor
     return tx4;
 };
 
-export { Action, BASIS_POINTS, BN254_FIELD_MODULUS, DEPOSIT_FEE_IN_BASIS_POINTS, EMPTY_COMMITMENT, EMPTY_SUBTREE_HASHES, ERROR_CODES, INITIAL_SHARED_VERSION, LSK_ENCRYPTED_OUTPUTS, LSK_FETCH_OFFSET, MERKLE_TREE_HEIGHT, MerkleTree, Modules, OPT, Output, REGISTRY_OBJECT_ID, ROOT_HISTORY_SIZE, TREASURY_ADDRESS, UPGRADE_CAP, Utxo, VORTEX_PACKAGE_ID, VORTEX_POOL_OBJECT_ID, VORTEX_SIGNATURE_DOMAIN, Vortex, VortexKeypair, ZERO_VALUE, bytesToBigInt, computeExtDataHash, deposit, getMerklePath, getUnspentUtxos, parseNewCommitmentEvent, poseidon1, poseidon2, poseidon3, prove, reverseBytes, toProveInput, verify, vortexSDK, withdraw };
+export { Action, BASIS_POINTS, BN254_FIELD_MODULUS, DEPOSIT_FEE_IN_BASIS_POINTS, EMPTY_COMMITMENT, EMPTY_SUBTREE_HASHES, ERROR_CODES, INITIAL_SHARED_VERSION, LSK_ENCRYPTED_OUTPUTS, LSK_FETCH_OFFSET, MERKLE_TREE_HEIGHT, Modules, OPT, Output, REGISTRY_OBJECT_ID, ROOT_HISTORY_SIZE, TREASURY_ADDRESS, UPGRADE_CAP, Utxo, VORTEX_PACKAGE_ID, VORTEX_POOL_OBJECT_ID, VORTEX_SIGNATURE_DOMAIN, Vortex, VortexKeypair, ZERO_VALUE, buildMerkleTree, bytesToBigInt, computeExtDataHash, deposit, getMerklePath, getUnspentUtxos, parseNewCommitmentEvent, poseidon1, poseidon2, poseidon3, prove, reverseBytes, toProveInput, verify, vortexSDK, withdraw };
 //# sourceMappingURL=index.mjs.map