@veilo/sdk-core 0.3.3 → 0.4.0

package/dist/tests/multi-tree.test.js

@@ -0,0 +1,405 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// tests/multi-tree.test.ts
+require("mocha");
+const assert_1 = require("assert");
+const anchor = __importStar(require("@coral-xyz/anchor"));
+const web3_js_1 = require("@solana/web3.js");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const src_1 = require("../src");
+// ---- IDL + Provider helpers ----
+function loadIdl() {
+    const idlPath = path_1.default.join(__dirname, "../../../privacy-program/target/idl/privacy_pool.json");
+    if (!fs_1.default.existsSync(idlPath)) {
+        return null;
+    }
+    const raw = fs_1.default.readFileSync(idlPath, "utf8");
+    return JSON.parse(raw);
+}
+function makeProvider() {
+    try {
+        const url = process.env.ANCHOR_PROVIDER_URL ?? "http://127.0.0.1:8899";
+        const connection = new anchor.web3.Connection(url, "confirmed");
+        const keypairPath = process.env.ANCHOR_WALLET ??
+            path_1.default.join(os_1.default.homedir(), ".config", "solana", "id.json");
+        if (!fs_1.default.existsSync(keypairPath)) {
+            return null;
+        }
+        const secret = JSON.parse(fs_1.default.readFileSync(keypairPath, "utf8"));
+        const kp = web3_js_1.Keypair.fromSecretKey(Uint8Array.from(secret));
+        const wallet = new anchor.Wallet(kp);
+        return new anchor.AnchorProvider(connection, wallet, {
+            commitment: "confirmed",
+            preflightCommitment: "confirmed",
+        });
+    }
+    catch {
+        return null;
+    }
+}
+describe("Constants", function () {
+    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);
+    });
+});
+describe("MerkleTree with new depth", function () {
+    this.timeout(30000);
+    before(async () => {
+        await (0, src_1.initPoseidon)();
+    });
+    it("creates tree with default depth of 22", () => {
+        const tree = new src_1.MerkleTree();
+        assert_1.strict.equal(tree.depth, 22);
+        assert_1.strict.equal(tree.capacity, 2 ** 22); // 4,194,304 leaves
+    });
+    it("can still create tree with explicit depth", () => {
+        const tree = new src_1.MerkleTree(16);
+        assert_1.strict.equal(tree.depth, 16);
+        assert_1.strict.equal(tree.capacity, 2 ** 16);
+    });
+    it("generates correct path length for depth 22", () => {
+        const tree = new src_1.MerkleTree(22);
+        const keypair = (0, src_1.generateKeypair)();
+        const utxo = (0, src_1.createUTXO)({
+            amount: (0, src_1.sol)(1),
+            pubkey: keypair.publicKey,
+            mintAddress: src_1.NATIVE_SOL_MINT,
+        });
+        const { index } = tree.insert(utxo.commitment);
+        const path = tree.getPath(index);
+        assert_1.strict.equal(path.path.length, 22);
+        assert_1.strict.equal(path.indices.length, 22);
+    });
+});
+describe("Multi-tree PDA scenarios", function () {
+    const programId = new web3_js_1.PublicKey("6Cq2rfH7hcreu6Lz4LFoVvZC37Q5uzNq1cStuTnjFdBU");
+    it("each tree ID produces unique PDA", () => {
+        const pdas = new Set();
+        for (let treeId = 0; treeId < 10; treeId++) {
+            const pda = (0, src_1.getNoteTreePda)(programId, src_1.NATIVE_SOL_MINT, treeId);
+            const pdaStr = pda.toBase58();
+            assert_1.strict.ok(!pdas.has(pdaStr), `Tree ${treeId} should have unique PDA`);
+            pdas.add(pdaStr);
+        }
+        assert_1.strict.equal(pdas.size, 10);
+    });
+    it("nullifier markers are global — same nullifier always produces same PDA", () => {
+        const nullifier = new Uint8Array(32);
+        nullifier[0] = 0x42;
+        // No tree_id in seeds: one spent nullifier blocks re-use across all trees.
+        const marker1 = (0, src_1.getNullifierMarkerPda)(programId, src_1.NATIVE_SOL_MINT, nullifier);
+        const marker2 = (0, src_1.getNullifierMarkerPda)(programId, src_1.NATIVE_SOL_MINT, nullifier);
+        assert_1.strict.equal(marker1.toBase58(), marker2.toBase58(), "Same nullifier should always produce the same marker");
+    });
+    it("different nullifiers produce different markers", () => {
+        const nullifiers = [
+            new Uint8Array(32).fill(0xab),
+            new Uint8Array(32).fill(0xcd),
+            new Uint8Array(32).fill(0xef),
+        ];
+        const markers = nullifiers.map((n) => (0, src_1.getNullifierMarkerPda)(programId, src_1.NATIVE_SOL_MINT, n).toBase58());
+        assert_1.strict.equal(new Set(markers).size, 3);
+    });
+});
+describe("High-level helper function signatures", function () {
+    this.timeout(10000);
+    before(async () => {
+        await (0, src_1.initPoseidon)();
+    });
+    it("deposit accepts treeId parameter", () => {
+        // Type check - deposit should accept treeId
+        const depositParams = {
+            program: {},
+            depositor: {},
+            amount: 1000n,
+            mintAddress: src_1.NATIVE_SOL_MINT,
+            recipientPubkey: 12345n,
+            tree: new src_1.MerkleTree(16),
+            proofBuilder: async () => ({}),
+            treeId: 5, // This should be accepted
+        };
+        // If this compiles, the type is correct
+        assert_1.strict.equal(depositParams.treeId, 5);
+    });
+    it("withdraw requires inputTreeId and outputTreeId", () => {
+        const withdrawParams = {
+            program: {},
+            relayer: web3_js_1.Keypair.generate(),
+            recipient: web3_js_1.Keypair.generate().publicKey,
+            mintAddress: src_1.NATIVE_SOL_MINT,
+            inputUTXOs: [{}, {}],
+            changePubkey: 12345n,
+            withdrawAmount: 1000n,
+            fee: 10n,
+            refund: 0n,
+            root: new Uint8Array(32),
+            inputTreeId: 0,
+            outputTreeId: 1,
+            tree: new src_1.MerkleTree(16),
+            proofBuilder: async () => ({}),
+        };
+        assert_1.strict.equal(withdrawParams.inputTreeId, 0);
+        assert_1.strict.equal(withdrawParams.outputTreeId, 1);
+    });
+    it("privateTransfer requires inputTreeId and outputTreeId", () => {
+        const transferParams = {
+            program: {},
+            relayer: web3_js_1.Keypair.generate(),
+            mintAddress: src_1.NATIVE_SOL_MINT,
+            inputUTXOs: [{}, {}],
+            outputPubkeys: [123n, 456n],
+            outputAmounts: [500n, 500n],
+            root: new Uint8Array(32),
+            inputTreeId: 2,
+            outputTreeId: 3,
+            tree: new src_1.MerkleTree(16),
+            proofBuilder: async () => ({}),
+        };
+        assert_1.strict.equal(transferParams.inputTreeId, 2);
+        assert_1.strict.equal(transferParams.outputTreeId, 3);
+    });
+    it("transact requires inputTreeId and outputTreeId", () => {
+        const transactParams = {
+            program: {},
+            relayer: web3_js_1.Keypair.generate(),
+            recipient: web3_js_1.Keypair.generate().publicKey,
+            mintAddress: src_1.NATIVE_SOL_MINT,
+            root: new Uint8Array(32),
+            inputTreeId: 0,
+            outputTreeId: 0,
+            publicAmount: 1000n,
+            inputNullifiers: [new Uint8Array(32), new Uint8Array(32)],
+            outputCommitments: [new Uint8Array(32), new Uint8Array(32)],
+            extData: {
+                recipient: web3_js_1.Keypair.generate().publicKey,
+                relayer: web3_js_1.Keypair.generate().publicKey,
+                fee: 0n,
+                refund: 0n,
+            },
+            proof: {
+                proofA: new Array(64).fill(0),
+                proofB: new Array(128).fill(0),
+                proofC: new Array(64).fill(0),
+            },
+        };
+        assert_1.strict.equal(transactParams.inputTreeId, 0);
+        assert_1.strict.equal(transactParams.outputTreeId, 0);
+    });
+});
+describe("PrivacyConfigAccount type", function () {
+    it("has correct shape with new fields", () => {
+        const mockConfig = {
+            bump: 255,
+            vaultBump: 254,
+            admin: web3_js_1.Keypair.generate().publicKey,
+            feeBps: 50,
+            feeErrorMarginBps: 10,
+            minWithdrawalFee: 1000n,
+            minSwapFee: 0n,
+            swapFeeBps: 0,
+            totalTvl: 1000000n,
+            mintAddress: src_1.NATIVE_SOL_MINT,
+            minDepositAmount: 100000n,
+            maxDepositAmount: 10000000000n,
+            minWithdrawAmount: 100000n,
+            maxWithdrawAmount: 10000000000n,
+            numRelayers: 2,
+            relayers: [web3_js_1.Keypair.generate().publicKey, web3_js_1.Keypair.generate().publicKey],
+            numTrees: 3,
+            nextTreeIndex: 150,
+        };
+        // Verify new fields exist
+        assert_1.strict.equal(mockConfig.feeErrorMarginBps, 10);
+        assert_1.strict.equal(mockConfig.numTrees, 3);
+        assert_1.strict.equal(mockConfig.nextTreeIndex, 150);
+        // Verify paused field is NOT present (removed)
+        assert_1.strict.ok(!("paused" in mockConfig));
+    });
+});
+// Integration tests that require a running validator
+describe("Multi-tree integration tests", function () {
+    this.timeout(120000);
+    const provider = makeProvider();
+    const idl = loadIdl();
+    // Skip if no provider or IDL available
+    before(function () {
+        if (!provider || !idl) {
+            console.log("Skipping integration tests: no provider or IDL available");
+            this.skip();
+        }
+    });
+    let program;
+    let wallet;
+    let connection;
+    // Use a unique mint for these tests to avoid conflicts
+    let testMint;
+    async function airdropAndConfirm(pubkey, lamports) {
+        const sig = await connection.requestAirdrop(pubkey, lamports);
+        const latestBlockhash = await connection.getLatestBlockhash();
+        await connection.confirmTransaction({
+            signature: sig,
+            blockhash: latestBlockhash.blockhash,
+            lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
+        });
+    }
+    before(async function () {
+        if (!provider || !idl) {
+            return;
+        }
+        await (0, src_1.initPoseidon)();
+        anchor.setProvider(provider);
+        program = new anchor.Program(idl, provider);
+        wallet = provider.wallet;
+        connection = provider.connection;
+        // Use a unique "mint" for these tests (just a random pubkey for native SOL tests)
+        // In production, you'd use NATIVE_SOL_MINT or an actual SPL token mint
+        testMint = src_1.NATIVE_SOL_MINT;
+    });
+    it("initializes global config if needed", async function () {
+        if (!provider)
+            this.skip();
+        const globalConfig = (0, src_1.getGlobalConfigPda)(program.programId);
+        const existingConfig = await connection.getAccountInfo(globalConfig);
+        if (!existingConfig) {
+            await airdropAndConfirm(wallet.publicKey, 2 * web3_js_1.LAMPORTS_PER_SOL);
+            await (0, src_1.initializeGlobalConfig)({
+                program,
+                admin: wallet,
+                payer: wallet.payer,
+            });
+        }
+    });
+    it("initializes pool with tree 0", async function () {
+        if (!provider)
+            this.skip();
+        const { config } = (0, src_1.getPoolPdas)(program.programId, testMint);
+        const existingConfig = await connection.getAccountInfo(config);
+        if (!existingConfig) {
+            await airdropAndConfirm(wallet.publicKey, 5 * web3_js_1.LAMPORTS_PER_SOL);
+            await (0, src_1.initializePool)({
+                program,
+                admin: wallet,
+                payer: wallet.payer,
+                feeBps: 50,
+                mintAddress: testMint,
+                minDepositAmount: (0, src_1.sol)(0.01),
+                maxDepositAmount: (0, src_1.sol)(100),
+                minWithdrawAmount: (0, src_1.sol)(0.01),
+                maxWithdrawAmount: (0, src_1.sol)(100),
+            });
+        }
+        // Verify tree 0 exists
+        const tree0Pda = (0, src_1.getNoteTreePda)(program.programId, testMint, 0);
+        const tree0Account = await connection.getAccountInfo(tree0Pda);
+        assert_1.strict.ok(tree0Account !== null, "Tree 0 should exist after initialization");
+    });
+    it("fetches pool config with new fields", async function () {
+        if (!provider)
+            this.skip();
+        const config = await (0, src_1.getPoolConfig)(program, testMint);
+        assert_1.strict.ok(typeof config.bump === "number");
+        assert_1.strict.ok(typeof config.vaultBump === "number");
+        assert_1.strict.ok(config.admin instanceof web3_js_1.PublicKey);
+        assert_1.strict.ok(typeof config.feeBps === "number");
+        assert_1.strict.ok(typeof config.feeErrorMarginBps === "number");
+        assert_1.strict.ok(typeof config.minWithdrawalFee === "bigint");
+        assert_1.strict.ok(typeof config.totalTvl === "bigint");
+        assert_1.strict.ok(config.mintAddress instanceof web3_js_1.PublicKey);
+        assert_1.strict.ok(typeof config.numTrees === "number");
+        assert_1.strict.ok(typeof config.nextTreeIndex === "number");
+        console.log("Pool config:", {
+            feeBps: config.feeBps,
+            feeErrorMarginBps: config.feeErrorMarginBps,
+            numTrees: config.numTrees,
+            nextTreeIndex: config.nextTreeIndex,
+        });
+    });
+    it("updates pool config with feeErrorMarginBps", async function () {
+        if (!provider)
+            this.skip();
+        const newFeeErrorMarginBps = 25;
+        await (0, src_1.updatePoolConfig)({
+            program,
+            admin: wallet,
+            mintAddress: testMint,
+            feeErrorMarginBps: newFeeErrorMarginBps,
+        });
+        const config = await (0, src_1.getPoolConfig)(program, testMint);
+        assert_1.strict.equal(config.feeErrorMarginBps, newFeeErrorMarginBps, "feeErrorMarginBps should be updated");
+    });
+    it("adds a second merkle tree", async function () {
+        if (!provider)
+            this.skip();
+        const configBefore = await (0, src_1.getPoolConfig)(program, testMint);
+        const expectedTreeId = configBefore.numTrees;
+        // Check if tree already exists
+        const tree1Pda = (0, src_1.getNoteTreePda)(program.programId, testMint, expectedTreeId);
+        const existingTree = await connection.getAccountInfo(tree1Pda);
+        if (!existingTree) {
+            // Use wallet.payer (admin) since only admin/relayers can add trees
+            await (0, src_1.addMerkleTree)({
+                program,
+                relayer: wallet.payer,
+                mintAddress: testMint,
+                treeId: expectedTreeId,
+            });
+        }
+        // Verify tree exists
+        const treeAccount = await connection.getAccountInfo(tree1Pda);
+        assert_1.strict.ok(treeAccount !== null, `Tree ${expectedTreeId} should exist`);
+        // Verify numTrees increased
+        const configAfter = await (0, src_1.getPoolConfig)(program, testMint);
+        assert_1.strict.ok(configAfter.numTrees > configBefore.numTrees || existingTree !== null, "numTrees should have increased");
+    });
+    it("can derive PDAs for multiple trees", async function () {
+        if (!provider)
+            this.skip();
+        const config = await (0, src_1.getPoolConfig)(program, testMint);
+        for (let treeId = 0; treeId < config.numTrees; treeId++) {
+            const treePda = (0, src_1.getNoteTreePda)(program.programId, testMint, treeId);
+            const treeAccount = await connection.getAccountInfo(treePda);
+            assert_1.strict.ok(treeAccount !== null, `Tree ${treeId} should exist (numTrees=${config.numTrees})`);
+        }
+    });
+});

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

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

package/dist/tests/pda.test.js

@@ -0,0 +1,229 @@
+"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");
+// Test program ID (use a deterministic one for reproducible tests)
+const TEST_PROGRAM_ID = new web3_js_1.PublicKey("6Cq2rfH7hcreu6Lz4LFoVvZC37Q5uzNq1cStuTnjFdBU");
+describe("PDA Derivation", function () {
+    describe("getPoolPdas", () => {
+        it("returns config, vault, and nullifiers PDAs", () => {
+            const pdas = (0, src_1.getPoolPdas)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT);
+            assert_1.strict.ok(pdas.config instanceof web3_js_1.PublicKey);
+            assert_1.strict.ok(pdas.vault instanceof web3_js_1.PublicKey);
+            assert_1.strict.ok(pdas.nullifiers instanceof web3_js_1.PublicKey);
+            // Should NOT have noteTree (removed in favor of getNoteTreePda)
+            assert_1.strict.ok(!("noteTree" in pdas), "noteTree should not be in getPoolPdas result");
+        });
+        it("derives different PDAs for different mints", () => {
+            const mint1 = src_1.NATIVE_SOL_MINT;
+            const mint2 = web3_js_1.Keypair.generate().publicKey;
+            const pdas1 = (0, src_1.getPoolPdas)(TEST_PROGRAM_ID, mint1);
+            const pdas2 = (0, src_1.getPoolPdas)(TEST_PROGRAM_ID, mint2);
+            assert_1.strict.notEqual(pdas1.config.toBase58(), pdas2.config.toBase58(), "Different mints should have different config PDAs");
+            assert_1.strict.notEqual(pdas1.vault.toBase58(), pdas2.vault.toBase58(), "Different mints should have different vault PDAs");
+        });
+        it("derives PDAs deterministically", () => {
+            const pdas1 = (0, src_1.getPoolPdas)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT);
+            const pdas2 = (0, src_1.getPoolPdas)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT);
+            assert_1.strict.equal(pdas1.config.toBase58(), pdas2.config.toBase58());
+            assert_1.strict.equal(pdas1.vault.toBase58(), pdas2.vault.toBase58());
+            assert_1.strict.equal(pdas1.nullifiers.toBase58(), pdas2.nullifiers.toBase58());
+        });
+        it("uses v3 seed for config PDA", () => {
+            // Manually derive with v3 seed to verify
+            const [expectedConfig] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("privacy_config_v3"), src_1.NATIVE_SOL_MINT.toBuffer()], TEST_PROGRAM_ID);
+            const pdas = (0, src_1.getPoolPdas)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT);
+            assert_1.strict.equal(pdas.config.toBase58(), expectedConfig.toBase58(), "Config PDA should use privacy_config_v3 seed");
+        });
+    });
+    describe("getGlobalConfigPda", () => {
+        it("returns a valid PublicKey", () => {
+            const globalConfig = (0, src_1.getGlobalConfigPda)(TEST_PROGRAM_ID);
+            assert_1.strict.ok(globalConfig instanceof web3_js_1.PublicKey);
+        });
+        it("derives deterministically", () => {
+            const pda1 = (0, src_1.getGlobalConfigPda)(TEST_PROGRAM_ID);
+            const pda2 = (0, src_1.getGlobalConfigPda)(TEST_PROGRAM_ID);
+            assert_1.strict.equal(pda1.toBase58(), pda2.toBase58());
+        });
+        it("uses global_config_v1 seed", () => {
+            const [expected] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("global_config_v1")], TEST_PROGRAM_ID);
+            const pda = (0, src_1.getGlobalConfigPda)(TEST_PROGRAM_ID);
+            assert_1.strict.equal(pda.toBase58(), expected.toBase58());
+        });
+    });
+    describe("getNoteTreePda", () => {
+        it("returns a valid PublicKey", () => {
+            const noteTree = (0, src_1.getNoteTreePda)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT, 0);
+            assert_1.strict.ok(noteTree instanceof web3_js_1.PublicKey);
+        });
+        it("derives different PDAs for different tree IDs", () => {
+            const tree0 = (0, src_1.getNoteTreePda)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT, 0);
+            const tree1 = (0, src_1.getNoteTreePda)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT, 1);
+            const tree2 = (0, src_1.getNoteTreePda)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT, 2);
+            assert_1.strict.notEqual(tree0.toBase58(), tree1.toBase58());
+            assert_1.strict.notEqual(tree1.toBase58(), tree2.toBase58());
+            assert_1.strict.notEqual(tree0.toBase58(), tree2.toBase58());
+        });
+        it("derives different PDAs for different mints", () => {
+            const mint1 = src_1.NATIVE_SOL_MINT;
+            const mint2 = web3_js_1.Keypair.generate().publicKey;
+            const tree1 = (0, src_1.getNoteTreePda)(TEST_PROGRAM_ID, mint1, 0);
+            const tree2 = (0, src_1.getNoteTreePda)(TEST_PROGRAM_ID, mint2, 0);
+            assert_1.strict.notEqual(tree1.toBase58(), tree2.toBase58());
+        });
+        it("derives deterministically", () => {
+            const tree1 = (0, src_1.getNoteTreePda)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT, 5);
+            const tree2 = (0, src_1.getNoteTreePda)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT, 5);
+            assert_1.strict.equal(tree1.toBase58(), tree2.toBase58());
+        });
+        it("uses correct seed format with tree ID", () => {
+            const treeId = 3;
+            const treeIdBuffer = Buffer.alloc(2);
+            treeIdBuffer.writeUInt16LE(treeId);
+            const [expected] = web3_js_1.PublicKey.findProgramAddressSync([
+                Buffer.from("privacy_note_tree_v3"),
+                src_1.NATIVE_SOL_MINT.toBuffer(),
+                treeIdBuffer,
+            ], TEST_PROGRAM_ID);
+            const actual = (0, src_1.getNoteTreePda)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT, treeId);
+            assert_1.strict.equal(actual.toBase58(), expected.toBase58());
+        });
+        it("handles large tree IDs", () => {
+            const largeTreeId = 255;
+            const tree = (0, src_1.getNoteTreePda)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT, largeTreeId);
+            assert_1.strict.ok(tree instanceof web3_js_1.PublicKey);
+        });
+    });
+    describe("getNullifierMarkerPda", () => {
+        const mockNullifier = new Uint8Array(32).fill(1);
+        it("returns a valid PublicKey", () => {
+            const marker = (0, src_1.getNullifierMarkerPda)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT, mockNullifier);
+            assert_1.strict.ok(marker instanceof web3_js_1.PublicKey);
+        });
+        it("is global — same nullifier always produces the same marker", () => {
+            // Nullifier markers have no tree_id in their seeds; one spent nullifier
+            // prevents re-use across all trees in the pool.
+            const marker1 = (0, src_1.getNullifierMarkerPda)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT, mockNullifier);
+            const marker2 = (0, src_1.getNullifierMarkerPda)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT, mockNullifier);
+            assert_1.strict.equal(marker1.toBase58(), marker2.toBase58(), "Same nullifier should always produce the same marker");
+        });
+        it("derives different PDAs for different nullifiers", () => {
+            const nullifier1 = new Uint8Array(32).fill(1);
+            const nullifier2 = new Uint8Array(32).fill(2);
+            const marker1 = (0, src_1.getNullifierMarkerPda)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT, nullifier1);
+            const marker2 = (0, src_1.getNullifierMarkerPda)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT, nullifier2);
+            assert_1.strict.notEqual(marker1.toBase58(), marker2.toBase58());
+        });
+        it("derives different PDAs for different mints", () => {
+            const otherMint = web3_js_1.Keypair.generate().publicKey;
+            const marker1 = (0, src_1.getNullifierMarkerPda)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT, mockNullifier);
+            const marker2 = (0, src_1.getNullifierMarkerPda)(TEST_PROGRAM_ID, otherMint, mockNullifier);
+            assert_1.strict.notEqual(marker1.toBase58(), marker2.toBase58());
+        });
+        it("derives deterministically", () => {
+            const marker1 = (0, src_1.getNullifierMarkerPda)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT, mockNullifier);
+            const marker2 = (0, src_1.getNullifierMarkerPda)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT, mockNullifier);
+            assert_1.strict.equal(marker1.toBase58(), marker2.toBase58());
+        });
+        it("uses nullifier_v3 seed without tree ID", () => {
+            const [expected] = web3_js_1.PublicKey.findProgramAddressSync([
+                Buffer.from("nullifier_v3"),
+                src_1.NATIVE_SOL_MINT.toBuffer(),
+                mockNullifier,
+            ], TEST_PROGRAM_ID);
+            const actual = (0, src_1.getNullifierMarkerPda)(TEST_PROGRAM_ID, src_1.NATIVE_SOL_MINT, mockNullifier);
+            assert_1.strict.equal(actual.toBase58(), expected.toBase58());
+        });
+    });
+    // -------------------------------------------------------------------------
+    // getSwapExecutorPda
+    // -------------------------------------------------------------------------
+    describe("getSwapExecutorPda", () => {
+        const sourceMint = new web3_js_1.PublicKey("So11111111111111111111111111111111111111112");
+        const destMint = new web3_js_1.PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
+        const relayer = web3_js_1.Keypair.generate().publicKey;
+        const inputNullifier0 = new Uint8Array(32).fill(0x01);
+        it("returns a valid PublicKey", () => {
+            const executor = (0, src_1.getSwapExecutorPda)(TEST_PROGRAM_ID, sourceMint, destMint, inputNullifier0, relayer);
+            assert_1.strict.ok(executor instanceof web3_js_1.PublicKey);
+        });
+        it("is deterministic", () => {
+            const e1 = (0, src_1.getSwapExecutorPda)(TEST_PROGRAM_ID, sourceMint, destMint, inputNullifier0, relayer);
+            const e2 = (0, src_1.getSwapExecutorPda)(TEST_PROGRAM_ID, sourceMint, destMint, inputNullifier0, relayer);
+            assert_1.strict.equal(e1.toBase58(), e2.toBase58());
+        });
+        it("uses swap_executor seed", () => {
+            const [expected] = web3_js_1.PublicKey.findProgramAddressSync([
+                Buffer.from("swap_executor"),
+                sourceMint.toBuffer(),
+                destMint.toBuffer(),
+                inputNullifier0,
+                relayer.toBuffer(),
+            ], TEST_PROGRAM_ID);
+            const actual = (0, src_1.getSwapExecutorPda)(TEST_PROGRAM_ID, sourceMint, destMint, inputNullifier0, relayer);
+            assert_1.strict.equal(actual.toBase58(), expected.toBase58());
+        });
+        it("produces different PDA for different nullifiers", () => {
+            const nullifier2 = new Uint8Array(32).fill(0x02);
+            const e1 = (0, src_1.getSwapExecutorPda)(TEST_PROGRAM_ID, sourceMint, destMint, inputNullifier0, relayer);
+            const e2 = (0, src_1.getSwapExecutorPda)(TEST_PROGRAM_ID, sourceMint, destMint, nullifier2, relayer);
+            assert_1.strict.notEqual(e1.toBase58(), e2.toBase58());
+        });
+        it("produces different PDA for different relayers", () => {
+            const relayer2 = web3_js_1.Keypair.generate().publicKey;
+            const e1 = (0, src_1.getSwapExecutorPda)(TEST_PROGRAM_ID, sourceMint, destMint, inputNullifier0, relayer);
+            const e2 = (0, src_1.getSwapExecutorPda)(TEST_PROGRAM_ID, sourceMint, destMint, inputNullifier0, relayer2);
+            assert_1.strict.notEqual(e1.toBase58(), e2.toBase58());
+        });
+    });
+});
+// =============================================================================
+// parseOnChainError
+// =============================================================================
+describe("parseOnChainError", function () {
+    it("maps hex program error code 0x1770 (6000) to the pause message", () => {
+        const err = new Error("custom program error: 0x1770");
+        assert_1.strict.equal((0, src_1.parseOnChainError)(err), "The pool is temporarily paused. Please try again later.");
+    });
+    it("maps hex program error code 0x1775 (6005) to double-spend message", () => {
+        const err = new Error("custom program error: 0x1775");
+        assert_1.strict.equal((0, src_1.parseOnChainError)(err), "These funds have already been spent.");
+    });
+    it("maps decimal error number 6012 to proof verification message", () => {
+        const err = new Error("Error number: 6012");
+        assert_1.strict.equal((0, src_1.parseOnChainError)(err), "Zero-knowledge proof verification failed. Please try again.");
+    });
+    it("maps 6035 to below-minimum message", () => {
+        const err = new Error("custom program error: 0x178b"); // 0x178b = 6027? let me recalculate: 6035 = 0x1793
+        // 6035 decimal = 0x1793 hex
+        const err2 = new Error("Error number: 6035");
+        assert_1.strict.equal((0, src_1.parseOnChainError)(err2), "Amount is below the pool minimum.");
+    });
+    it("returns blockhash-expired message for 'blockhash not found'", () => {
+        const err = new Error("Blockhash not found");
+        assert_1.strict.equal((0, src_1.parseOnChainError)(err), "The transaction expired before it could be confirmed. Please try again.");
+    });
+    it("returns timeout message for 'timed out' errors", () => {
+        const err = new Error("Request timed out");
+        assert_1.strict.equal((0, src_1.parseOnChainError)(err), "The request timed out. Please try again.");
+    });
+    it("returns simulation failed message", () => {
+        const err = new Error("Transaction simulation failed");
+        assert_1.strict.equal((0, src_1.parseOnChainError)(err), "Transaction simulation failed. Please refresh and try again.");
+    });
+    it("returns generic fallback for unknown error", () => {
+        const err = new Error("some unknown error");
+        assert_1.strict.equal((0, src_1.parseOnChainError)(err), "The transaction could not be completed. Your funds are safe — please try again.");
+    });
+    it("handles non-Error objects with toString()", () => {
+        const result = (0, src_1.parseOnChainError)("some unknown string error");
+        assert_1.strict.equal(result, "The transaction could not be completed. Your funds are safe — please try again.");
+    });
+    it("handles null/undefined gracefully", () => {
+        const result = (0, src_1.parseOnChainError)(null);
+        assert_1.strict.equal(result, "The transaction could not be completed. Your funds are safe — please try again.");
+    });
+});

package/dist/tests/poseidon-builder-parity.test.d.ts

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