@veilo/sdk-core 0.4.0 → 0.6.0

package/dist/tests/relayer.test.js

@@ -1,271 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-require("mocha");
-const assert_1 = require("assert");
-const http_1 = __importDefault(require("http"));
-const src_1 = require("../src");
-const tweetnacl_1 = __importDefault(require("tweetnacl"));
-/**
- * Relayer client tests using a local HTTP mock server.
- */
-// Generate a real NaCl keypair for the "relayer"
-const relayerKeyPair = tweetnacl_1.default.box.keyPair();
-const relayerPublicKeyB64 = typeof Buffer !== "undefined"
-    ? Buffer.from(relayerKeyPair.publicKey).toString("base64")
-    : btoa(String.fromCharCode(...relayerKeyPair.publicKey));
-let server;
-let baseUrl;
-let lastRequest;
-function createMockServer(handler) {
-    return new Promise((resolve) => {
-        server = http_1.default.createServer((req, res) => {
-            let body = "";
-            req.on("data", (c) => (body += c));
-            req.on("end", () => {
-                lastRequest = {
-                    method: req.method,
-                    url: req.url,
-                    body: body ? JSON.parse(body) : null,
-                    headers: req.headers,
-                };
-                if (handler) {
-                    handler(req, res);
-                }
-                else {
-                    res.writeHead(200, { "Content-Type": "application/json" });
-                    res.end(JSON.stringify({ success: true }));
-                }
-            });
-        });
-        server.listen(0, () => {
-            const addr = server.address();
-            resolve(`http://127.0.0.1:${addr.port}`);
-        });
-    });
-}
-function makeConfig(url) {
-    return {
-        relayerUrl: url,
-        apiKey: "test-api-key",
-        relayerPublicKey: relayerPublicKeyB64,
-        authToken: "test-token",
-    };
-}
-describe("VeiloRelayerClient", function () {
-    this.timeout(15000);
-    afterEach((done) => {
-        if (server)
-            server.close(done);
-        else
-            done();
-    });
-    // ---------------------------------------------------------------------------
-    // Basic request mechanics
-    // ---------------------------------------------------------------------------
-    it("sends x-api-key header on all requests", async () => {
-        baseUrl = await createMockServer((req, res) => {
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ success: true, available: true }));
-        });
-        const client = new src_1.VeiloRelayerClient(makeConfig(baseUrl));
-        await client.checkUsername("alice");
-        assert_1.strict.equal(lastRequest.headers["x-api-key"], "test-api-key");
-    });
-    it("sends Authorization header for authenticated endpoints", async () => {
-        baseUrl = await createMockServer((req, res) => {
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ success: true, notes: [], total: 0, limit: 50, offset: 0 }));
-        });
-        const client = new src_1.VeiloRelayerClient(makeConfig(baseUrl));
-        await client.queryEncryptedNotes();
-        assert_1.strict.equal(lastRequest.headers["authorization"], "Bearer test-token");
-    });
-    it("does not send Authorization when no authToken", async () => {
-        baseUrl = await createMockServer((req, res) => {
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ success: true, notes: [], total: 0, limit: 50, offset: 0 }));
-        });
-        const cfg = makeConfig(baseUrl);
-        delete cfg.authToken;
-        const client = new src_1.VeiloRelayerClient(cfg);
-        await client.queryEncryptedNotes();
-        assert_1.strict.equal(lastRequest.headers["authorization"], undefined);
-    });
-    // ---------------------------------------------------------------------------
-    // Error handling
-    // ---------------------------------------------------------------------------
-    it("throws VeiloApiError on non-2xx responses", async () => {
-        baseUrl = await createMockServer((req, res) => {
-            res.writeHead(400, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ success: false, error: "BAD_REQUEST", message: "Invalid input" }));
-        });
-        const client = new src_1.VeiloRelayerClient(makeConfig(baseUrl));
-        try {
-            await client.checkUsername("");
-            assert_1.strict.fail("should have thrown");
-        }
-        catch (err) {
-            assert_1.strict.ok(err instanceof src_1.VeiloApiError);
-            assert_1.strict.equal(err.code, "BAD_REQUEST");
-            assert_1.strict.equal(err.status, 400);
-            assert_1.strict.equal(err.message, "Invalid input");
-        }
-    });
-    it("throws VeiloApiError when success=false on 200", async () => {
-        baseUrl = await createMockServer((req, res) => {
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ success: false, error: "DUPLICATE_COMMITMENT" }));
-        });
-        const client = new src_1.VeiloRelayerClient(makeConfig(baseUrl));
-        try {
-            await client.saveEncryptedNote({
-                commitment: "abc",
-                ephemeralPublicKey: "def",
-                encryptedBlob: "ghi",
-                timestamp: Date.now(),
-            });
-            assert_1.strict.fail("should have thrown");
-        }
-        catch (err) {
-            assert_1.strict.ok(err instanceof src_1.VeiloApiError);
-            assert_1.strict.equal(err.code, "DUPLICATE_COMMITMENT");
-        }
-    });
-    // ---------------------------------------------------------------------------
-    // Retry behavior
-    // ---------------------------------------------------------------------------
-    it("retries on 503 and succeeds", async () => {
-        let callCount = 0;
-        baseUrl = await createMockServer((req, res) => {
-            callCount++;
-            if (callCount < 3) {
-                res.writeHead(503, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({ success: false, error: "SERVICE_UNAVAILABLE" }));
-            }
-            else {
-                res.writeHead(200, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({ success: true, available: true }));
-            }
-        });
-        const client = new src_1.VeiloRelayerClient(makeConfig(baseUrl), {
-            maxRetries: 3,
-            baseDelayMs: 50,
-        });
-        const result = await client.checkUsername("bob");
-        assert_1.strict.equal(result.success, true);
-        assert_1.strict.equal(callCount, 3);
-    });
-    it("does not retry on 400", async () => {
-        let callCount = 0;
-        baseUrl = await createMockServer((req, res) => {
-            callCount++;
-            res.writeHead(400, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ success: false, error: "INVALID" }));
-        });
-        const client = new src_1.VeiloRelayerClient(makeConfig(baseUrl), {
-            maxRetries: 3,
-            baseDelayMs: 50,
-        });
-        try {
-            await client.checkUsername("bad");
-            assert_1.strict.fail("should have thrown");
-        }
-        catch {
-            assert_1.strict.equal(callCount, 1, "should not retry on 400");
-        }
-    });
-    it("does not retry transact endpoints", async () => {
-        let callCount = 0;
-        baseUrl = await createMockServer((req, res) => {
-            callCount++;
-            res.writeHead(503, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ success: false, error: "SERVICE_UNAVAILABLE" }));
-        });
-        const client = new src_1.VeiloRelayerClient(makeConfig(baseUrl), {
-            maxRetries: 3,
-            baseDelayMs: 50,
-        });
-        try {
-            await client.submitWithdraw({
-                notes: [],
-                recipient: "11111111111111111111111111111111",
-                amount: "1000000",
-                userPublicKey: "11111111111111111111111111111111",
-                mintAddress: "11111111111111111111111111111111",
-            });
-            assert_1.strict.fail("should have thrown");
-        }
-        catch {
-            assert_1.strict.equal(callCount, 1, "transact endpoints should not retry");
-        }
-    });
-    // ---------------------------------------------------------------------------
-    // Encryption
-    // ---------------------------------------------------------------------------
-    it("encrypts withdraw payload (body contains encryptedPayload)", async () => {
-        baseUrl = await createMockServer((req, res) => {
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ success: true, message: "ok" }));
-        });
-        const client = new src_1.VeiloRelayerClient(makeConfig(baseUrl));
-        await client.submitWithdraw({
-            notes: [],
-            recipient: "11111111111111111111111111111111",
-            amount: "1000000",
-            userPublicKey: "11111111111111111111111111111111",
-            mintAddress: "11111111111111111111111111111111",
-        });
-        assert_1.strict.ok(lastRequest.body.encryptedPayload, "body should contain encryptedPayload");
-        assert_1.strict.equal(typeof lastRequest.body.encryptedPayload, "string");
-        // Decrypt and verify the payload structure
-        const raw = Buffer.from(lastRequest.body.encryptedPayload, "base64");
-        const ephPub = raw.subarray(0, 32);
-        const nonce = raw.subarray(32, 56);
-        const ciphertext = raw.subarray(56);
-        const decrypted = tweetnacl_1.default.box.open(new Uint8Array(ciphertext), new Uint8Array(nonce), new Uint8Array(ephPub), relayerKeyPair.secretKey);
-        assert_1.strict.ok(decrypted, "relayer should be able to decrypt the payload");
-        const payload = JSON.parse(new TextDecoder().decode(decrypted));
-        assert_1.strict.equal(payload.recipient, "11111111111111111111111111111111");
-        assert_1.strict.equal(payload.amount, "1000000");
-        assert_1.strict.ok(payload.timestamp, "should include timestamp");
-        assert_1.strict.ok(payload.nonce, "should include nonce");
-    });
-    // ---------------------------------------------------------------------------
-    // Auth endpoints
-    // ---------------------------------------------------------------------------
-    it("setAuthToken updates subsequent requests", async () => {
-        baseUrl = await createMockServer((req, res) => {
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ success: true, notes: [], total: 0, limit: 50, offset: 0 }));
-        });
-        const cfg = makeConfig(baseUrl);
-        cfg.authToken = undefined;
-        const client = new src_1.VeiloRelayerClient(cfg);
-        // First call — no auth
-        await client.queryEncryptedNotes();
-        assert_1.strict.equal(lastRequest.headers["authorization"], undefined);
-        // Set token and call again
-        client.setAuthToken("new-token");
-        await client.queryEncryptedNotes();
-        assert_1.strict.equal(lastRequest.headers["authorization"], "Bearer new-token");
-    });
-    // ---------------------------------------------------------------------------
-    // Merkle endpoints
-    // ---------------------------------------------------------------------------
-    it("getMerkleRoot passes query params", async () => {
-        baseUrl = await createMockServer((req, res) => {
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({
-                success: true,
-                data: { root: "abc", nextIndex: 5, treeId: 0, onChainTreeId: 0, mintAddress: "So11111111111111111111111111111111111111112" },
-            }));
-        });
-        const client = new src_1.VeiloRelayerClient(makeConfig(baseUrl));
-        await client.getMerkleRoot("So11111111111111111111111111111111111111112", 0);
-        assert_1.strict.ok(lastRequest.url.includes("mintAddress=So11111111111111111111111111111111111111112"));
-        assert_1.strict.ok(lastRequest.url.includes("treeId=0"));
-    });
-});

package/dist/tests/sdk.integration.test.d.ts

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

package/dist/tests/sdk.integration.test.js

@@ -1,330 +0,0 @@
-"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 });
-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() {
-    // NOTE: this path is relative to dist/tests at runtime
-    const idlPath = path_1.default.join(__dirname, "../../idl/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("privacy-pool SDK integration (UTXO model)", function () {
-    this.timeout(60000);
-    const provider = makeProvider();
-    const idl = loadIdl();
-    // Skip on-chain tests when no provider or IDL is available, or program not deployed
-    before(async function () {
-        if (!provider || !idl) {
-            console.log("Skipping on-chain integration tests: no provider or IDL available");
-            this.skip();
-            return;
-        }
-        try {
-            const programId = new web3_js_1.PublicKey(idl.address);
-            const info = await provider.connection.getAccountInfo(programId);
-            if (!info) {
-                console.log(`Skipping on-chain integration tests: program ${programId.toBase58()} not deployed on this cluster`);
-                this.skip();
-            }
-        }
-        catch {
-            console.log("Skipping on-chain integration tests: could not reach cluster");
-            this.skip();
-        }
-    });
-    // These bindings are populated only when the suite runs
-    let program;
-    let wallet;
-    let connection;
-    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;
-    });
-    const FEE_BPS = 50; // 0.5%
-    const MIN_DEPOSIT = (0, src_1.sol)(0.1);
-    const MAX_DEPOSIT = (0, src_1.sol)(100);
-    const MIN_WITHDRAW = (0, src_1.sol)(0.1);
-    const MAX_WITHDRAW = (0, src_1.sol)(100);
-    async function airdropAndConfirm(pubkey, lamports) {
-        const sig = await connection.requestAirdrop(pubkey, lamports);
-        await connection.confirmTransaction(sig, "confirmed");
-    }
-    it("initializes global config", async () => {
-        const globalConfig = (0, src_1.getGlobalConfigPda)(program.programId);
-        // Check if already initialized
-        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,
-            });
-            console.log("Global config initialized");
-        }
-        else {
-            console.log("Global config already exists, skipping initialization");
-        }
-    });
-    it("initializes pool with new parameters", async () => {
-        const { config } = (0, src_1.getPoolPdas)(program.programId, src_1.NATIVE_SOL_MINT);
-        // Check if already initialized
-        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: FEE_BPS,
-                mintAddress: src_1.NATIVE_SOL_MINT,
-                minDepositAmount: MIN_DEPOSIT,
-                maxDepositAmount: MAX_DEPOSIT,
-                minWithdrawAmount: MIN_WITHDRAW,
-                maxWithdrawAmount: MAX_WITHDRAW,
-            });
-            console.log("Pool initialized for native SOL");
-        }
-        else {
-            console.log("Pool already exists, skipping initialization");
-        }
-        // Verify the PDAs exist
-        const configAcc = await connection.getAccountInfo(config);
-        (0, assert_1.strict)(configAcc !== null, "Config account should exist");
-    });
-    it("adds a relayer to the pool", async () => {
-        const relayer = web3_js_1.Keypair.generate();
-        await airdropAndConfirm(relayer.publicKey, 1 * web3_js_1.LAMPORTS_PER_SOL);
-        await (0, src_1.addRelayer)({
-            program,
-            admin: wallet,
-            mintAddress: src_1.NATIVE_SOL_MINT,
-            newRelayer: relayer.publicKey,
-        });
-        console.log(`Relayer added: ${relayer.publicKey.toBase58()}`);
-    });
-    it("creates UTXOs with correct structure", () => {
-        const keypair = (0, src_1.generateKeypair)();
-        const amount = (0, src_1.sol)(1);
-        const utxo = (0, src_1.createUTXO)({
-            amount,
-            pubkey: keypair.publicKey,
-            mintAddress: src_1.NATIVE_SOL_MINT,
-        });
-        assert_1.strict.equal(utxo.amount, amount);
-        assert_1.strict.equal(utxo.pubkey, keypair.publicKey);
-        assert_1.strict.equal(utxo.commitment.length, 32);
-        assert_1.strict.ok(utxo.blinding > 0n);
-    });
-    it("derives nullifiers correctly", () => {
-        const privateKey = 12345n;
-        const utxo = (0, src_1.createOwnedUTXO)({
-            amount: (0, src_1.sol)(1),
-            privateKey,
-            mintAddress: src_1.NATIVE_SOL_MINT,
-        });
-        const pathIndex = 0;
-        const nullifier = (0, src_1.deriveNullifier)(utxo, pathIndex, privateKey);
-        assert_1.strict.equal(nullifier.length, 32);
-        // Verify determinism
-        const nullifier2 = (0, src_1.deriveNullifier)(utxo, pathIndex, privateKey);
-        assert_1.strict.equal(Buffer.compare(Buffer.from(nullifier), Buffer.from(nullifier2)), 0);
-    });
-    it("computes extDataHash correctly", () => {
-        const extData = {
-            recipient: web3_js_1.Keypair.generate().publicKey,
-            relayer: web3_js_1.Keypair.generate().publicKey,
-            fee: (0, src_1.sol)(0.01),
-            refund: 0n,
-            claimant: web3_js_1.PublicKey.default,
-        };
-        const hash = (0, src_1.computeExtDataHash)(extData);
-        assert_1.strict.equal(hash.length, 32);
-        // Verify determinism
-        const hash2 = (0, src_1.computeExtDataHash)(extData);
-        assert_1.strict.equal(Buffer.compare(Buffer.from(hash), Buffer.from(hash2)), 0);
-    });
-    it("builds Merkle tree with correct depth", () => {
-        const tree = new src_1.MerkleTree(16);
-        assert_1.strict.equal(tree.depth, 16);
-        assert_1.strict.equal(tree.capacity, 65536);
-        assert_1.strict.equal(tree.root.length, 32);
-        assert_1.strict.equal(tree.nextIndex, 0);
-    });
-    it("inserts commitments and generates paths", () => {
-        const tree = new src_1.MerkleTree(16);
-        const keypair = (0, src_1.generateKeypair)();
-        // Create and insert a UTXO
-        const utxo = (0, src_1.createUTXO)({
-            amount: (0, src_1.sol)(1),
-            pubkey: keypair.publicKey,
-            mintAddress: src_1.NATIVE_SOL_MINT,
-        });
-        const { index, root } = tree.insert(utxo.commitment);
-        assert_1.strict.equal(index, 0);
-        assert_1.strict.equal(root.length, 32);
-        // Get the path
-        const path = tree.getPath(index);
-        assert_1.strict.equal(path.leafIndex, 0);
-        assert_1.strict.equal(path.path.length, 16);
-        assert_1.strict.equal(path.indices.length, 16);
-        // All path elements should be 32 bytes
-        for (const element of path.path) {
-            assert_1.strict.equal(element.length, 32);
-        }
-    });
-    it("generates circuit-compatible paths", () => {
-        const tree = new src_1.MerkleTree(16);
-        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 circuitPath = tree.getCircuitPath(index);
-        assert_1.strict.equal(circuitPath.pathIndex, 0);
-        assert_1.strict.equal(circuitPath.pathElements.length, 16);
-        // All elements should be bigints
-        for (const element of circuitPath.pathElements) {
-            assert_1.strict.equal(typeof element, "bigint");
-        }
-    });
-    // Note: The actual transact instruction test requires a valid ZK proof
-    // which would need the full circuit setup. This is a placeholder for
-    // when proof generation is available.
-    it.skip("executes a deposit transaction", async () => {
-        // This test would require:
-        // 1. A valid snarkjs proof
-        // 2. The circuit WASM and zkey files
-        // 3. A running local validator with the contract deployed
-        const relayer = web3_js_1.Keypair.generate();
-        const recipient = web3_js_1.Keypair.generate();
-        await airdropAndConfirm(relayer.publicKey, 2 * web3_js_1.LAMPORTS_PER_SOL);
-        const keypair = (0, src_1.generateKeypair)();
-        const tree = new src_1.MerkleTree(16);
-        // Create zero inputs for deposit
-        const zeroInput0 = (0, src_1.createOwnedZeroUTXO)(keypair.privateKey, src_1.NATIVE_SOL_MINT);
-        const zeroInput1 = (0, src_1.createOwnedZeroUTXO)(keypair.privateKey, src_1.NATIVE_SOL_MINT);
-        tree.insert(zeroInput0.commitment);
-        const { root } = tree.insert(zeroInput1.commitment);
-        // Create output UTXOs
-        const outputUTXO0 = (0, src_1.createUTXO)({
-            amount: (0, src_1.sol)(1),
-            pubkey: keypair.publicKey,
-            mintAddress: src_1.NATIVE_SOL_MINT,
-        });
-        const outputUTXO1 = (0, src_1.createUTXO)({
-            amount: 0n,
-            pubkey: keypair.publicKey,
-            mintAddress: src_1.NATIVE_SOL_MINT,
-        });
-        const extData = {
-            recipient: recipient.publicKey,
-            relayer: relayer.publicKey,
-            fee: 0n,
-            refund: 0n,
-            claimant: web3_js_1.PublicKey.default,
-        };
-        // Mock proof (would need real proof in production)
-        const mockProof = {
-            proofA: new Array(64).fill(0),
-            proofB: new Array(128).fill(0),
-            proofC: new Array(64).fill(0),
-        };
-        // This would fail without a valid proof, but tests the API
-        try {
-            await (0, src_1.transact)({
-                program,
-                relayer,
-                recipient: recipient.publicKey,
-                mintAddress: src_1.NATIVE_SOL_MINT,
-                root,
-                inputTreeId: 0,
-                outputTreeId: 0,
-                publicAmount: (0, src_1.sol)(1),
-                inputNullifiers: [
-                    (0, src_1.deriveNullifier)(zeroInput0, 0, keypair.privateKey),
-                    (0, src_1.deriveNullifier)(zeroInput1, 1, keypair.privateKey),
-                ],
-                outputCommitments: [outputUTXO0.commitment, outputUTXO1.commitment],
-                extData,
-                proof: mockProof,
-            });
-        }
-        catch (e) {
-            // Expected to fail with VerifyFailed since we're using a mock proof
-            console.log("Transaction failed as expected with mock proof:", e.message);
-        }
-    });
-});

package/dist/tests/shield-owner.test.d.ts

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