@veilo/sdk-core 0.3.3 → 0.4.0

package/dist/tests/relayer.test.js

@@ -0,0 +1,271 @@
+"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

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

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

@@ -0,0 +1,330 @@
+"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

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