@veilo/sdk-core 0.4.0 → 0.5.0

package/dist/tests/config.test.js

@@ -1,102 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("mocha");
-const assert_1 = require("assert");
-const web3_js_1 = require("@solana/web3.js");
-const src_1 = require("../src");
-describe("Config constants and fee helpers", function () {
-    // ---------------------------------------------------------------------------
-    // Constants
-    // ---------------------------------------------------------------------------
-    describe("constants", () => {
-        it("DEFAULT_FEE_BPS is 50 (0.5%)", () => {
-            assert_1.strict.equal(src_1.DEFAULT_FEE_BPS, 50);
-        });
-        it("MERKLE_TREE_DEPTH is 22", () => {
-            assert_1.strict.equal(src_1.MERKLE_TREE_DEPTH, 22);
-        });
-        it("ROOT_HISTORY_SIZE is 256", () => {
-            assert_1.strict.equal(src_1.ROOT_HISTORY_SIZE, 256);
-        });
-        it("NATIVE_SOL_MINT is the all-zeros public key", () => {
-            assert_1.strict.equal(src_1.NATIVE_SOL_MINT.toBase58(), "11111111111111111111111111111111");
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // sol()
-    // ---------------------------------------------------------------------------
-    describe("sol()", () => {
-        it("converts 1 SOL to 1_000_000_000 lamports", () => {
-            assert_1.strict.equal((0, src_1.sol)(1), BigInt(web3_js_1.LAMPORTS_PER_SOL));
-        });
-        it("converts 0 SOL to 0 lamports", () => {
-            assert_1.strict.equal((0, src_1.sol)(0), 0n);
-        });
-        it("converts 0.1 SOL correctly", () => {
-            assert_1.strict.equal((0, src_1.sol)(0.1), BigInt(0.1 * web3_js_1.LAMPORTS_PER_SOL));
-        });
-        it("returns a bigint", () => {
-            assert_1.strict.equal(typeof (0, src_1.sol)(1), "bigint");
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // computeWithdrawalFee
-    // ---------------------------------------------------------------------------
-    describe("computeWithdrawalFee", () => {
-        it("uses percentage fee when it exceeds minimum", () => {
-            // 1_000_000 * 50 / 10_000 = 5000  >  0 (min)
-            const { fee, toRecipient } = (0, src_1.computeWithdrawalFee)(1000000n, 50, 0n);
-            assert_1.strict.equal(fee, 5000n);
-            assert_1.strict.equal(toRecipient, 995000n);
-        });
-        it("uses minimum fee when percentage is below it", () => {
-            // 100 * 50 / 10_000 = 0, min = 500 → fee = 500
-            const { fee, toRecipient } = (0, src_1.computeWithdrawalFee)(10000n, 50, 1000n);
-            // 10_000 * 50 / 10_000 = 50 < 1000 → fee = 1000
-            assert_1.strict.equal(fee, 1000n);
-            assert_1.strict.equal(toRecipient, 9000n);
-        });
-        it("toRecipient = amount - fee", () => {
-            const amount = 5000000n;
-            const { fee, toRecipient } = (0, src_1.computeWithdrawalFee)(amount, 100, 0n);
-            assert_1.strict.equal(fee + toRecipient, amount);
-        });
-        it("zero feeBps with zero minimum gives zero fee", () => {
-            const { fee, toRecipient } = (0, src_1.computeWithdrawalFee)(999n, 0, 0n);
-            assert_1.strict.equal(fee, 0n);
-            assert_1.strict.equal(toRecipient, 999n);
-        });
-        it("100% feeBps (10000) takes the entire amount", () => {
-            const { fee, toRecipient } = (0, src_1.computeWithdrawalFee)(1000n, 10000, 0n);
-            assert_1.strict.equal(fee, 1000n);
-            assert_1.strict.equal(toRecipient, 0n);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // computeSwapFee
-    // ---------------------------------------------------------------------------
-    describe("computeSwapFee", () => {
-        it("uses percentage fee when it exceeds minimum", () => {
-            // 100_000 * 50 / 10_000 = 500  >  0 (min)
-            const { relayerFee, destAmount } = (0, src_1.computeSwapFee)(100000n, 50, 0n, 90000n);
-            assert_1.strict.equal(relayerFee, 500n);
-            assert_1.strict.equal(destAmount, 89500n);
-        });
-        it("uses minimum fee when percentage is below it", () => {
-            // 100_000 * 50 / 10_000 = 500 < 1000 → relayerFee = 1000
-            const { relayerFee, destAmount } = (0, src_1.computeSwapFee)(100000n, 50, 1000n, 90000n);
-            assert_1.strict.equal(relayerFee, 1000n);
-            assert_1.strict.equal(destAmount, 89000n);
-        });
-        it("destAmount = minAmountOut - relayerFee", () => {
-            const minAmountOut = 50000n;
-            const { relayerFee, destAmount } = (0, src_1.computeSwapFee)(200000n, 100, 0n, minAmountOut);
-            assert_1.strict.equal(relayerFee + destAmount, minAmountOut);
-        });
-        it("zero swapFeeBps with zero min fee gives zero relayer fee", () => {
-            const { relayerFee, destAmount } = (0, src_1.computeSwapFee)(100000n, 0, 0n, 80000n);
-            assert_1.strict.equal(relayerFee, 0n);
-            assert_1.strict.equal(destAmount, 80000n);
-        });
-    });
-});

package/dist/tests/edge-cases.test.d.ts

@@ -1 +0,0 @@
-import "mocha";

package/dist/tests/edge-cases.test.js

@@ -1,220 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("mocha");
-const assert_1 = require("assert");
-const src_1 = require("../src");
-const web3_js_1 = require("@solana/web3.js");
-describe("Edge cases", function () {
-    this.timeout(15000);
-    before(async () => {
-        await (0, src_1.initPoseidon)();
-    });
-    // ---------------------------------------------------------------------------
-    // Zero amounts
-    // ---------------------------------------------------------------------------
-    describe("Zero-amount UTXOs", () => {
-        it("creates a UTXO with amount 0", () => {
-            const kp = (0, src_1.generateKeypair)();
-            const utxo = (0, src_1.createUTXO)({
-                amount: 0n,
-                pubkey: kp.publicKey,
-                mintAddress: src_1.NATIVE_SOL_MINT,
-            });
-            assert_1.strict.equal(utxo.amount, 0n);
-            assert_1.strict.equal(utxo.commitment.length, 32);
-        });
-        it("zero-amount UTXOs produce unique commitments due to blinding", () => {
-            const kp = (0, src_1.generateKeypair)();
-            const utxo1 = (0, src_1.createUTXO)({ amount: 0n, pubkey: kp.publicKey, mintAddress: src_1.NATIVE_SOL_MINT });
-            const utxo2 = (0, src_1.createUTXO)({ amount: 0n, pubkey: kp.publicKey, mintAddress: src_1.NATIVE_SOL_MINT });
-            // Different blinding values should give different commitments
-            if (utxo1.blinding !== utxo2.blinding) {
-                assert_1.strict.notDeepEqual(utxo1.commitment, utxo2.commitment);
-            }
-        });
-        it("owned zero UTXO has correct structure", () => {
-            const pk = 99999n;
-            const utxo = (0, src_1.createOwnedZeroUTXO)(pk, src_1.NATIVE_SOL_MINT);
-            assert_1.strict.equal(utxo.amount, 0n);
-            assert_1.strict.equal(utxo.privateKey, pk);
-            assert_1.strict.equal(utxo.commitment.length, 32);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // Large / boundary amounts
-    // ---------------------------------------------------------------------------
-    describe("Boundary amounts", () => {
-        it("handles amount of 1 (smallest positive)", () => {
-            const kp = (0, src_1.generateKeypair)();
-            const utxo = (0, src_1.createUTXO)({ amount: 1n, pubkey: kp.publicKey, mintAddress: src_1.NATIVE_SOL_MINT });
-            assert_1.strict.equal(utxo.amount, 1n);
-            assert_1.strict.equal(utxo.commitment.length, 32);
-        });
-        it("handles large amount near u64 max", () => {
-            const kp = (0, src_1.generateKeypair)();
-            const amount = (1n << 64n) - 1n; // u64 max
-            const utxo = (0, src_1.createUTXO)({ amount, pubkey: kp.publicKey, mintAddress: src_1.NATIVE_SOL_MINT });
-            assert_1.strict.equal(utxo.amount, amount);
-            assert_1.strict.equal(utxo.commitment.length, 32);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // Merkle tree edge cases
-    // ---------------------------------------------------------------------------
-    describe("Merkle tree", () => {
-        it("small depth=1 tree holds exactly 2 leaves", () => {
-            const tree = new src_1.MerkleTree(1);
-            const c1 = new Uint8Array(32).fill(0xaa);
-            const c2 = new Uint8Array(32).fill(0xbb);
-            tree.insert(c1);
-            tree.insert(c2);
-            // Tree should be full
-            assert_1.strict.equal(tree.getPath(0).path.length, 1);
-            assert_1.strict.equal(tree.getPath(1).path.length, 1);
-        });
-        it("tree root changes with each insert", () => {
-            const tree = new src_1.MerkleTree(4);
-            const roots = [];
-            for (let i = 0; i < 5; i++) {
-                const c = new Uint8Array(32);
-                c[0] = i;
-                tree.insert(c);
-                roots.push(Uint8Array.from(tree.root));
-            }
-            // All roots should be unique
-            for (let i = 0; i < roots.length; i++) {
-                for (let j = i + 1; j < roots.length; j++) {
-                    assert_1.strict.notDeepEqual(roots[i], roots[j], `root ${i} and ${j} should differ`);
-                }
-            }
-        });
-        it("proof for non-existent index returns zero-leaf path elements", () => {
-            const tree = new src_1.MerkleTree(4);
-            const c = new Uint8Array(32).fill(0x01);
-            tree.insert(c);
-            // Index 0 has our commitment; index 1 was never inserted
-            const proof = tree.getPath(1);
-            assert_1.strict.ok(proof, "should return a path even for empty leaf");
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // ExtData hash edge cases
-    // ---------------------------------------------------------------------------
-    describe("ExtData hash", () => {
-        it("zero fee and refund produce valid hash", () => {
-            const hash = (0, src_1.computeExtDataHash)({
-                recipient: web3_js_1.PublicKey.default,
-                relayer: web3_js_1.PublicKey.default,
-                fee: 0n,
-                refund: 0n,
-                claimant: web3_js_1.PublicKey.default,
-            });
-            assert_1.strict.equal(hash.length, 32);
-        });
-        it("different recipients produce different hashes", () => {
-            const base = {
-                relayer: web3_js_1.PublicKey.default,
-                fee: 100n,
-                refund: 0n,
-                claimant: web3_js_1.PublicKey.default,
-            };
-            const hash1 = (0, src_1.computeExtDataHash)({
-                ...base,
-                recipient: web3_js_1.PublicKey.default,
-            });
-            const hash2 = (0, src_1.computeExtDataHash)({
-                ...base,
-                recipient: new web3_js_1.PublicKey("11111111111111111111111111111112"),
-            });
-            assert_1.strict.notDeepEqual(hash1, hash2);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // parseOnChainError
-    // ---------------------------------------------------------------------------
-    describe("parseOnChainError", () => {
-        it("maps known hex error code", () => {
-            const msg = (0, src_1.parseOnChainError)(new Error("custom program error: 0x1770"));
-            assert_1.strict.equal(msg, "The pool is temporarily paused. Please try again later.");
-        });
-        it("maps known decimal error number", () => {
-            const msg = (0, src_1.parseOnChainError)(new Error("Error Number: 6005"));
-            assert_1.strict.equal(msg, "These funds have already been spent.");
-        });
-        it("handles blockhash not found", () => {
-            const msg = (0, src_1.parseOnChainError)(new Error("Blockhash not found"));
-            assert_1.strict.ok(msg.includes("expired"));
-        });
-        it("handles insufficient funds", () => {
-            const msg = (0, src_1.parseOnChainError)(new Error("Insufficient funds for rent"));
-            assert_1.strict.ok(msg.includes("SOL"));
-        });
-        it("returns generic message for unknown errors", () => {
-            const msg = (0, src_1.parseOnChainError)(new Error("something completely unknown xyz"));
-            assert_1.strict.ok(msg.includes("could not be completed"));
-        });
-        it("handles null/undefined input", () => {
-            const msg = (0, src_1.parseOnChainError)(null);
-            assert_1.strict.ok(msg.includes("could not be completed"));
-        });
-        // Verify newly added codes
-        it("maps code 6001 (NoDenoms)", () => {
-            const msg = (0, src_1.parseOnChainError)(new Error("Error Number: 6001"));
-            assert_1.strict.ok(msg.includes("denominations"));
-        });
-        it("maps code 6044 (InvalidTreeId)", () => {
-            const msg = (0, src_1.parseOnChainError)(new Error("Error Number: 6044"));
-            assert_1.strict.ok(msg.includes("tree"));
-        });
-        it("maps code 6056 (JupiterInsufficientAccounts)", () => {
-            const msg = (0, src_1.parseOnChainError)(new Error("Error Number: 6056"));
-            assert_1.strict.ok(msg.includes("Jupiter"));
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // withRpcRetry
-    // ---------------------------------------------------------------------------
-    describe("withRpcRetry", () => {
-        it("returns result on first success", async () => {
-            const result = await (0, src_1.withRpcRetry)(() => Promise.resolve("ok"));
-            assert_1.strict.equal(result, "ok");
-        });
-        it("retries on blockhash not found", async () => {
-            let calls = 0;
-            const result = await (0, src_1.withRpcRetry)(() => {
-                calls++;
-                if (calls < 3)
-                    throw new Error("Blockhash not found");
-                return Promise.resolve("done");
-            }, { baseDelayMs: 10 });
-            assert_1.strict.equal(result, "done");
-            assert_1.strict.equal(calls, 3);
-        });
-        it("does not retry on program error", async () => {
-            let calls = 0;
-            try {
-                await (0, src_1.withRpcRetry)(() => {
-                    calls++;
-                    throw new Error("custom program error: 0x1770");
-                }, { baseDelayMs: 10 });
-                assert_1.strict.fail("should throw");
-            }
-            catch {
-                assert_1.strict.equal(calls, 1, "should not retry program errors");
-            }
-        });
-        it("gives up after maxRetries", async () => {
-            let calls = 0;
-            try {
-                await (0, src_1.withRpcRetry)(() => {
-                    calls++;
-                    throw new Error("503 Service Unavailable");
-                }, { maxRetries: 2, baseDelayMs: 10 });
-                assert_1.strict.fail("should throw");
-            }
-            catch {
-                assert_1.strict.equal(calls, 3, "should try 1 + 2 retries");
-            }
-        });
-    });
-});

package/dist/tests/encryption.test.d.ts

@@ -1 +0,0 @@
-import "mocha";

package/dist/tests/encryption.test.js

@@ -1,215 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("mocha");
-const assert_1 = require("assert");
-const web3_js_1 = require("@solana/web3.js");
-const src_1 = require("../src");
-describe("Encryption helpers", function () {
-    this.timeout(10000);
-    before(async () => {
-        await (0, src_1.initPoseidon)();
-    });
-    // ---------------------------------------------------------------------------
-    // computeSignature
-    // ---------------------------------------------------------------------------
-    describe("computeSignature", () => {
-        it("returns a bigint in [0, BN254_FR_MODULUS)", () => {
-            const sig = (0, src_1.computeSignature)(1n, 2n, 3n);
-            assert_1.strict.ok(sig >= 0n && sig < src_1.BN254_FR_MODULUS);
-        });
-        it("is deterministic", () => {
-            assert_1.strict.equal((0, src_1.computeSignature)(1n, 2n, 3n), (0, src_1.computeSignature)(1n, 2n, 3n));
-        });
-        it("produces different output when private key changes", () => {
-            assert_1.strict.notEqual((0, src_1.computeSignature)(1n, 2n, 3n), (0, src_1.computeSignature)(99n, 2n, 3n));
-        });
-        it("produces different output when commitment changes", () => {
-            assert_1.strict.notEqual((0, src_1.computeSignature)(1n, 2n, 3n), (0, src_1.computeSignature)(1n, 99n, 3n));
-        });
-        it("produces different output when pathIndex changes", () => {
-            assert_1.strict.notEqual((0, src_1.computeSignature)(1n, 2n, 3n), (0, src_1.computeSignature)(1n, 2n, 99n));
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // inputUTXOToCircuitFormat
-    // ---------------------------------------------------------------------------
-    describe("inputUTXOToCircuitFormat", () => {
-        it("converts pathElements from Uint8Array[] to bigint[]", () => {
-            const tree = new src_1.MerkleTree(4);
-            const kp = (0, src_1.generateKeypair)();
-            const utxo = (0, src_1.createOwnedUTXO)({
-                amount: 500n,
-                privateKey: kp.privateKey,
-                mintAddress: src_1.NATIVE_SOL_MINT,
-            });
-            const { index } = tree.insert(utxo.commitment);
-            const { path } = tree.getPath(index);
-            const input = {
-                ...utxo,
-                pathIndex: index,
-                pathElements: path,
-                privateKey: kp.privateKey,
-            };
-            const fmt = (0, src_1.inputUTXOToCircuitFormat)(input);
-            assert_1.strict.equal(fmt.amount, utxo.amount);
-            assert_1.strict.equal(fmt.pubkey, utxo.pubkey);
-            assert_1.strict.equal(fmt.blinding, utxo.blinding);
-            assert_1.strict.equal(fmt.pathIndex, index);
-            assert_1.strict.equal(fmt.privateKey, kp.privateKey);
-            assert_1.strict.equal(fmt.pathElements.length, path.length);
-            assert_1.strict.ok(fmt.pathElements.every((e) => typeof e === "bigint"));
-        });
-        it("reduces pathElements modulo BN254_FR_MODULUS", () => {
-            const tree = new src_1.MerkleTree(4);
-            const kp = (0, src_1.generateKeypair)();
-            const utxo = (0, src_1.createOwnedUTXO)({
-                amount: 0n,
-                privateKey: kp.privateKey,
-                mintAddress: src_1.NATIVE_SOL_MINT,
-            });
-            const { index } = tree.insert(utxo.commitment);
-            const { path } = tree.getPath(index);
-            const input = {
-                ...utxo,
-                pathIndex: index,
-                pathElements: path,
-                privateKey: kp.privateKey,
-            };
-            const fmt = (0, src_1.inputUTXOToCircuitFormat)(input);
-            assert_1.strict.ok(fmt.pathElements.every((e) => e < src_1.BN254_FR_MODULUS));
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // deriveEncryptionKeypair
-    // ---------------------------------------------------------------------------
-    describe("deriveEncryptionKeypair", () => {
-        it("returns 32-byte public and secret keys", () => {
-            const kp = (0, src_1.deriveEncryptionKeypair)(12345n);
-            assert_1.strict.equal(kp.publicKey.length, 32);
-            assert_1.strict.equal(kp.secretKey.length, 32);
-        });
-        it("is deterministic", () => {
-            const kp1 = (0, src_1.deriveEncryptionKeypair)(12345n);
-            const kp2 = (0, src_1.deriveEncryptionKeypair)(12345n);
-            assert_1.strict.equal(Buffer.compare(Buffer.from(kp1.publicKey), Buffer.from(kp2.publicKey)), 0);
-            assert_1.strict.equal(Buffer.compare(Buffer.from(kp1.secretKey), Buffer.from(kp2.secretKey)), 0);
-        });
-        it("produces different keys for different private keys", () => {
-            const kp1 = (0, src_1.deriveEncryptionKeypair)(1n);
-            const kp2 = (0, src_1.deriveEncryptionKeypair)(2n);
-            assert_1.strict.notEqual(Buffer.compare(Buffer.from(kp1.publicKey), Buffer.from(kp2.publicKey)), 0);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // encryptUTXONote / decryptUTXONote
-    // ---------------------------------------------------------------------------
-    describe("encryptUTXONote / decryptUTXONote round-trip", () => {
-        it("decrypts to the original UTXO", () => {
-            const kp = (0, src_1.generateKeypair)();
-            const utxo = (0, src_1.createOwnedUTXO)({
-                amount: 1000000n,
-                privateKey: kp.privateKey,
-                mintAddress: src_1.NATIVE_SOL_MINT,
-            });
-            const utxoWithKey = { ...utxo, privateKey: kp.privateKey };
-            const recipientEncKp = (0, src_1.deriveEncryptionKeypair)(kp.privateKey);
-            const note = (0, src_1.encryptUTXONote)(utxoWithKey, recipientEncKp.publicKey);
-            const decrypted = (0, src_1.decryptUTXONote)(note, kp.privateKey, utxo.commitment, src_1.NATIVE_SOL_MINT);
-            assert_1.strict.ok(decrypted !== null, "decryption should succeed");
-            assert_1.strict.equal(decrypted.amount, utxo.amount);
-            assert_1.strict.equal(decrypted.blinding, utxo.blinding);
-            assert_1.strict.equal(decrypted.privateKey, kp.privateKey);
-        });
-        it("returns null when decrypting with the wrong private key", () => {
-            const kp = (0, src_1.generateKeypair)();
-            const utxo = (0, src_1.createOwnedUTXO)({
-                amount: 500n,
-                privateKey: kp.privateKey,
-                mintAddress: src_1.NATIVE_SOL_MINT,
-            });
-            const utxoWithKey = { ...utxo, privateKey: kp.privateKey };
-            const recipientEncKp = (0, src_1.deriveEncryptionKeypair)(kp.privateKey);
-            const note = (0, src_1.encryptUTXONote)(utxoWithKey, recipientEncKp.publicKey);
-            const wrongKey = (0, src_1.generateKeypair)().privateKey;
-            const result = (0, src_1.decryptUTXONote)(note, wrongKey, utxo.commitment, src_1.NATIVE_SOL_MINT);
-            assert_1.strict.equal(result, null);
-        });
-        it("returns null when the commitment does not match", () => {
-            const kp = (0, src_1.generateKeypair)();
-            const utxo = (0, src_1.createOwnedUTXO)({
-                amount: 500n,
-                privateKey: kp.privateKey,
-                mintAddress: src_1.NATIVE_SOL_MINT,
-            });
-            const utxo2 = (0, src_1.createOwnedUTXO)({
-                amount: 999n,
-                privateKey: kp.privateKey,
-                mintAddress: src_1.NATIVE_SOL_MINT,
-            });
-            const utxoWithKey = { ...utxo, privateKey: kp.privateKey };
-            const recipientEncKp = (0, src_1.deriveEncryptionKeypair)(kp.privateKey);
-            const note = (0, src_1.encryptUTXONote)(utxoWithKey, recipientEncKp.publicKey);
-            const result = (0, src_1.decryptUTXONote)(note, kp.privateKey, utxo2.commitment, // wrong commitment
-            src_1.NATIVE_SOL_MINT);
-            assert_1.strict.equal(result, null);
-        });
-        it("each encryption is unique (nonce randomness)", () => {
-            const kp = (0, src_1.generateKeypair)();
-            const utxo = (0, src_1.createOwnedUTXO)({
-                amount: 1n,
-                privateKey: kp.privateKey,
-                mintAddress: src_1.NATIVE_SOL_MINT,
-            });
-            const utxoWithKey = { ...utxo, privateKey: kp.privateKey };
-            const recipientEncKp = (0, src_1.deriveEncryptionKeypair)(kp.privateKey);
-            const note1 = (0, src_1.encryptUTXONote)(utxoWithKey, recipientEncKp.publicKey);
-            const note2 = (0, src_1.encryptUTXONote)(utxoWithKey, recipientEncKp.publicKey);
-            // Different nonces / ephemeral keys
-            assert_1.strict.notEqual(Buffer.compare(Buffer.from(note1.nonce), Buffer.from(note2.nonce)), 0);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // encryptBlindMailboxNote / decryptBlindMailboxNote
-    // ---------------------------------------------------------------------------
-    describe("encryptBlindMailboxNote / decryptBlindMailboxNote round-trip", () => {
-        function makeRecipient() {
-            return web3_js_1.Keypair.generate();
-        }
-        function makeNoteData() {
-            return {
-                blinding: new Uint8Array(32).fill(0xab),
-                leafIndex: 7,
-                commitment: new Uint8Array(32).fill(0xcd),
-                amount: 2500000n,
-                mintAddress: src_1.NATIVE_SOL_MINT.toBase58(),
-                treeId: 0,
-            };
-        }
-        it("decrypts back to the original note data", () => {
-            const recipient = makeRecipient();
-            const noteData = makeNoteData();
-            const { ephemeralPublicKey, encryptedBlob } = (0, src_1.encryptBlindMailboxNote)(recipient.publicKey.toBytes(), noteData);
-            const decrypted = (0, src_1.decryptBlindMailboxNote)(recipient.secretKey, ephemeralPublicKey, encryptedBlob);
-            assert_1.strict.equal(decrypted.amount, noteData.amount);
-            assert_1.strict.equal(decrypted.leafIndex, noteData.leafIndex);
-            assert_1.strict.equal(decrypted.treeId, noteData.treeId);
-            assert_1.strict.equal(decrypted.mintAddress, noteData.mintAddress);
-            assert_1.strict.equal(Buffer.compare(Buffer.from(decrypted.blinding), Buffer.from(noteData.blinding)), 0);
-            assert_1.strict.equal(Buffer.compare(Buffer.from(decrypted.commitment), Buffer.from(noteData.commitment)), 0);
-        });
-        it("throws when decrypting with a different recipient key", () => {
-            const recipient1 = makeRecipient();
-            const recipient2 = makeRecipient();
-            const noteData = makeNoteData();
-            const { ephemeralPublicKey, encryptedBlob } = (0, src_1.encryptBlindMailboxNote)(recipient1.publicKey.toBytes(), noteData);
-            assert_1.strict.throws(() => (0, src_1.decryptBlindMailboxNote)(recipient2.secretKey, ephemeralPublicKey, encryptedBlob), /decryption failed/i);
-        });
-        it("each encryption produces a unique ephemeral key", () => {
-            const recipient = makeRecipient();
-            const noteData = makeNoteData();
-            const enc1 = (0, src_1.encryptBlindMailboxNote)(recipient.publicKey.toBytes(), noteData);
-            const enc2 = (0, src_1.encryptBlindMailboxNote)(recipient.publicKey.toBytes(), noteData);
-            assert_1.strict.notEqual(Buffer.compare(Buffer.from(enc1.ephemeralPublicKey), Buffer.from(enc2.ephemeralPublicKey)), 0);
-        });
-    });
-});

package/dist/tests/events.test.d.ts

@@ -1 +0,0 @@
-import "mocha";

package/dist/tests/events.test.js

@@ -1,78 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("mocha");
-const assert_1 = require("assert");
-const src_1 = require("../src");
-/**
- * Events module tests.
- *
- * scanCommitmentEvents / scanNullifierEvents / buildTreeFromEvents depend on
- * live RPC, so here we test the tree-reconstruction logic they feed into and
- * the type/shape contracts of the event types.
- */
-describe("Events — tree reconstruction from commitment data", function () {
-    this.timeout(10000);
-    before(async () => {
-        await (0, src_1.initPoseidon)();
-    });
-    it("builds a tree from ordered commitments matching manual inserts", () => {
-        const depth = 8; // small tree for testing
-        const tree1 = new src_1.MerkleTree(depth);
-        const tree2 = new src_1.MerkleTree(depth);
-        // Simulate 5 commitment events with deterministic data
-        const commitments = [];
-        for (let i = 0; i < 5; i++) {
-            const c = new Uint8Array(32);
-            c[0] = i + 1;
-            c[31] = 0xff - i;
-            commitments.push(c);
-        }
-        // Insert in order (mimicking what buildTreeFromEvents does)
-        for (const c of commitments) {
-            tree1.insert(c);
-            tree2.insert(c);
-        }
-        assert_1.strict.deepEqual(tree1.root, tree2.root, "trees built identically should have the same root");
-    });
-    it("filters commitments by treeId correctly", () => {
-        const events = [
-            { treeId: 0, leafIndex: 0, commitment: new Uint8Array(32).fill(1) },
-            { treeId: 1, leafIndex: 0, commitment: new Uint8Array(32).fill(2) },
-            { treeId: 0, leafIndex: 1, commitment: new Uint8Array(32).fill(3) },
-            { treeId: 1, leafIndex: 1, commitment: new Uint8Array(32).fill(4) },
-            { treeId: 0, leafIndex: 2, commitment: new Uint8Array(32).fill(5) },
-        ];
-        const tree0Events = events
-            .filter((e) => e.treeId === 0)
-            .sort((a, b) => a.leafIndex - b.leafIndex);
-        assert_1.strict.equal(tree0Events.length, 3);
-        assert_1.strict.equal(tree0Events[0].leafIndex, 0);
-        assert_1.strict.equal(tree0Events[1].leafIndex, 1);
-        assert_1.strict.equal(tree0Events[2].leafIndex, 2);
-        const tree1Events = events
-            .filter((e) => e.treeId === 1)
-            .sort((a, b) => a.leafIndex - b.leafIndex);
-        assert_1.strict.equal(tree1Events.length, 2);
-    });
-    it("handles empty event list", () => {
-        const tree = new src_1.MerkleTree(8);
-        // No inserts — root should be the zero-leaf Merkle root
-        const root = tree.root;
-        assert_1.strict.equal(root.length, 32, "root should be 32 bytes");
-    });
-    it("reconstructed tree produces valid inclusion proofs", () => {
-        const tree = new src_1.MerkleTree(8);
-        const commitments = [];
-        for (let i = 0; i < 3; i++) {
-            const c = new Uint8Array(32);
-            c[0] = i + 10;
-            commitments.push(c);
-            tree.insert(c);
-        }
-        // Get proof for leaf 1
-        const proof = tree.getPath(1);
-        assert_1.strict.ok(proof, "should return a proof");
-        assert_1.strict.equal(proof.leafIndex, 1);
-        assert_1.strict.equal(proof.path.length, 8, "proof depth should match tree depth");
-    });
-});

package/dist/tests/multi-tree.test.d.ts

@@ -1 +0,0 @@
-import "mocha";