@veilo/sdk-core 0.4.0 → 0.5.0

package/dist/tests/poseidon-builder-parity.test.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-require("mocha");
-const assert_1 = require("assert");
-const circomlibjs_1 = require("circomlibjs");
-/**
- * core-sdk initializes Poseidon with `buildPoseidonReference` (src/poseidon.ts:13).
- * All three production `handleDeposit` implementations (extension, wallet-app,
- * veilo-dapp) use `buildPoseidon` instead.
- *
- * Both are circomlibjs and are *supposed* to agree, but nothing in this repo
- * proved it. If they ever diverge, core-sdk would produce commitments that no
- * production client can locate and no one can ever spend — silent, permanent
- * fund loss with no error at any layer.
- *
- * These vectors are the cheapest possible insurance.
- */
-describe("Poseidon builder parity (buildPoseidon vs buildPoseidonReference)", function () {
-    this.timeout(30000);
-    let fast;
-    let reference;
-    before(async () => {
-        fast = await (0, circomlibjs_1.buildPoseidon)();
-        reference = await (0, circomlibjs_1.buildPoseidonReference)();
-    });
-    const toBigInt = (impl, out) => impl.F.toObject(out);
-    const VECTORS = [
-        { name: "arity 1, zero", inputs: [0n] },
-        { name: "arity 1, one", inputs: [1n] },
-        { name: "arity 2, zero pair (merkle zero chain seed)", inputs: [0n, 0n] },
-        { name: "arity 2, small", inputs: [1n, 2n] },
-        { name: "arity 3, nullifier shape", inputs: [1n, 2n, 3n] },
-        {
-            name: "arity 4, commitment shape (amount, pubkey, blinding, mint)",
-            inputs: [
-                1000000000n,
-                12345678901234567890123456789012345678901234567890n,
-                98765432109876543210987654321098765432109876543210n,
-                0n,
-            ],
-        },
-        {
-            name: "arity 2, near-field-modulus operands",
-            inputs: [
-                21888242871839275222246405745257275088548364400416034343698204186575808495616n,
-                21888242871839275222246405745257275088548364400416034343698204186575808495615n,
-            ],
-        },
-    ];
-    for (const { name, inputs } of VECTORS) {
-        it(`agrees on ${name}`, () => {
-            const a = toBigInt(fast, fast(inputs));
-            const b = toBigInt(reference, reference(inputs));
-            assert_1.strict.equal(a.toString(), b.toString(), `Poseidon builders DIVERGED on [${inputs.join(", ")}]. ` +
-                `core-sdk (reference) would produce commitments unspendable by production clients.`);
-        });
-    }
-    it("agrees across a randomized arity-2 sweep", () => {
-        const FR = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
-        for (let i = 0; i < 64; i++) {
-            const l = BigInt(`0x${Buffer.from(randomBytes(31)).toString("hex")}`) % FR;
-            const r = BigInt(`0x${Buffer.from(randomBytes(31)).toString("hex")}`) % FR;
-            assert_1.strict.equal(toBigInt(fast, fast([l, r])).toString(), toBigInt(reference, reference([l, r])).toString(), `Poseidon builders diverged on [${l}, ${r}]`);
-        }
-    });
-});
-function randomBytes(n) {
-    const out = new Uint8Array(n);
-    for (let i = 0; i < n; i++)
-        out[i] = Math.floor(Math.random() * 256);
-    return out;
-}

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

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

package/dist/tests/poseidon.test.js

@@ -1,142 +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("Poseidon utilities", function () {
-    this.timeout(10000);
-    before(async () => {
-        await (0, src_1.initPoseidon)();
-    });
-    // ---------------------------------------------------------------------------
-    // bytesToBigIntBE / bigIntToBytesBE
-    // ---------------------------------------------------------------------------
-    describe("bytesToBigIntBE", () => {
-        it("converts all-zero bytes to 0n", () => {
-            assert_1.strict.equal((0, src_1.bytesToBigIntBE)(new Uint8Array(32)), 0n);
-        });
-        it("converts [0x01] to 1n", () => {
-            assert_1.strict.equal((0, src_1.bytesToBigIntBE)(new Uint8Array([0x01])), 1n);
-        });
-        it("converts [0x01, 0x00] to 256n", () => {
-            assert_1.strict.equal((0, src_1.bytesToBigIntBE)(new Uint8Array([0x01, 0x00])), 256n);
-        });
-        it("converts [0xff, 0xff] to 65535n", () => {
-            assert_1.strict.equal((0, src_1.bytesToBigIntBE)(new Uint8Array([0xff, 0xff])), 65535n);
-        });
-        it("interprets bytes as big-endian (first byte is MSB)", () => {
-            // [0x00, 0x01] should be 1, not 256
-            assert_1.strict.equal((0, src_1.bytesToBigIntBE)(new Uint8Array([0x00, 0x01])), 1n);
-        });
-    });
-    describe("bigIntToBytesBE", () => {
-        it("encodes 0n as 32 zero bytes", () => {
-            const bytes = (0, src_1.bigIntToBytesBE)(0n);
-            assert_1.strict.equal(bytes.length, 32);
-            assert_1.strict.ok(bytes.every((b) => b === 0));
-        });
-        it("always returns exactly 32 bytes", () => {
-            assert_1.strict.equal((0, src_1.bigIntToBytesBE)(1n).length, 32);
-            assert_1.strict.equal((0, src_1.bigIntToBytesBE)(src_1.BN254_FR_MODULUS - 1n).length, 32);
-        });
-        it("round-trips with bytesToBigIntBE", () => {
-            for (const v of [1n, 256n, 65535n, 0xdeadbeefn, src_1.BN254_FR_MODULUS - 1n]) {
-                assert_1.strict.equal((0, src_1.bytesToBigIntBE)((0, src_1.bigIntToBytesBE)(v)), v);
-            }
-        });
-        it("places the value in the least-significant bytes", () => {
-            const bytes = (0, src_1.bigIntToBytesBE)(1n);
-            assert_1.strict.equal(bytes[31], 1); // last byte is 1
-            assert_1.strict.equal(bytes[0], 0); // first byte is 0
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // getPoseidon
-    // ---------------------------------------------------------------------------
-    describe("getPoseidon", () => {
-        it("returns a hash function after initPoseidon()", () => {
-            const p = (0, src_1.getPoseidon)();
-            assert_1.strict.equal(typeof p, "function");
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // poseidon1 / poseidon2 / poseidon3 / poseidon4
-    // ---------------------------------------------------------------------------
-    describe("poseidon1", () => {
-        it("returns a bigint in [0, BN254_FR_MODULUS)", () => {
-            const h = (0, src_1.poseidon1)(42n);
-            assert_1.strict.ok(h >= 0n && h < src_1.BN254_FR_MODULUS);
-        });
-        it("is deterministic", () => {
-            assert_1.strict.equal((0, src_1.poseidon1)(123n), (0, src_1.poseidon1)(123n));
-        });
-        it("produces different outputs for different inputs", () => {
-            assert_1.strict.notEqual((0, src_1.poseidon1)(1n), (0, src_1.poseidon1)(2n));
-        });
-    });
-    describe("poseidon2", () => {
-        it("returns a bigint in [0, BN254_FR_MODULUS)", () => {
-            const h = (0, src_1.poseidon2)(1n, 2n);
-            assert_1.strict.ok(h >= 0n && h < src_1.BN254_FR_MODULUS);
-        });
-        it("is deterministic", () => {
-            assert_1.strict.equal((0, src_1.poseidon2)(7n, 8n), (0, src_1.poseidon2)(7n, 8n));
-        });
-        it("is non-commutative (different output when args swapped)", () => {
-            const h1 = (0, src_1.poseidon2)(1n, 2n);
-            const h2 = (0, src_1.poseidon2)(2n, 1n);
-            assert_1.strict.notEqual(h1, h2);
-        });
-    });
-    describe("poseidon3", () => {
-        it("returns a bigint in field range", () => {
-            const h = (0, src_1.poseidon3)(1n, 2n, 3n);
-            assert_1.strict.ok(h >= 0n && h < src_1.BN254_FR_MODULUS);
-        });
-        it("is deterministic", () => {
-            assert_1.strict.equal((0, src_1.poseidon3)(4n, 5n, 6n), (0, src_1.poseidon3)(4n, 5n, 6n));
-        });
-        it("produces different outputs for different third argument", () => {
-            assert_1.strict.notEqual((0, src_1.poseidon3)(1n, 2n, 0n), (0, src_1.poseidon3)(1n, 2n, 99n));
-        });
-    });
-    describe("poseidon4", () => {
-        it("returns a bigint in field range", () => {
-            const h = (0, src_1.poseidon4)(1n, 2n, 3n, 4n);
-            assert_1.strict.ok(h >= 0n && h < src_1.BN254_FR_MODULUS);
-        });
-        it("is deterministic", () => {
-            assert_1.strict.equal((0, src_1.poseidon4)(5n, 6n, 7n, 8n), (0, src_1.poseidon4)(5n, 6n, 7n, 8n));
-        });
-        it("produces different outputs when any argument changes", () => {
-            const base = (0, src_1.poseidon4)(1n, 2n, 3n, 4n);
-            assert_1.strict.notEqual((0, src_1.poseidon4)(99n, 2n, 3n, 4n), base);
-            assert_1.strict.notEqual((0, src_1.poseidon4)(1n, 99n, 3n, 4n), base);
-            assert_1.strict.notEqual((0, src_1.poseidon4)(1n, 2n, 99n, 4n), base);
-            assert_1.strict.notEqual((0, src_1.poseidon4)(1n, 2n, 3n, 99n), base);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // pubkeyToField
-    // ---------------------------------------------------------------------------
-    describe("pubkeyToField", () => {
-        it("converts NATIVE_SOL_MINT (all zeros) to 0n", () => {
-            assert_1.strict.equal((0, src_1.pubkeyToField)(src_1.NATIVE_SOL_MINT), 0n);
-        });
-        it("returns a value in [0, BN254_FR_MODULUS)", () => {
-            const randomKey = new web3_js_1.PublicKey("6Cq2rfH7hcreu6Lz4LFoVvZC37Q5uzNq1cStuTnjFdBU");
-            const field = (0, src_1.pubkeyToField)(randomKey);
-            assert_1.strict.ok(field >= 0n && field < src_1.BN254_FR_MODULUS);
-        });
-        it("is deterministic", () => {
-            const key = new web3_js_1.PublicKey("6Cq2rfH7hcreu6Lz4LFoVvZC37Q5uzNq1cStuTnjFdBU");
-            assert_1.strict.equal((0, src_1.pubkeyToField)(key), (0, src_1.pubkeyToField)(key));
-        });
-        it("produces different values for different keys", () => {
-            const key1 = new web3_js_1.PublicKey("6Cq2rfH7hcreu6Lz4LFoVvZC37Q5uzNq1cStuTnjFdBU");
-            const key2 = new web3_js_1.PublicKey("So11111111111111111111111111111111111111112");
-            assert_1.strict.notEqual((0, src_1.pubkeyToField)(key1), (0, src_1.pubkeyToField)(key2));
-        });
-    });
-});

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

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

package/dist/tests/proof.test.js

@@ -1,296 +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");
-// A minimal well-formed Groth16 proof with non-trivial field values.
-const MOCK_PROOF = {
-    pi_a: ["100", "200", "0"],
-    pi_b: [
-        ["300", "400"],
-        ["500", "600"],
-        ["0", "0"],
-    ],
-    pi_c: ["700", "800", "0"],
-    protocol: "groth16",
-    curve: "bn128",
-};
-describe("Proof helpers", function () {
-    this.timeout(10000);
-    before(async () => {
-        await (0, src_1.initPoseidon)();
-    });
-    // ---------------------------------------------------------------------------
-    // i64ToField
-    // ---------------------------------------------------------------------------
-    describe("i64ToField", () => {
-        it("returns 0n for 0n", () => {
-            assert_1.strict.equal((0, src_1.i64ToField)(0n), 0n);
-        });
-        it("returns positive values unchanged (within field)", () => {
-            assert_1.strict.equal((0, src_1.i64ToField)(1000n), 1000n);
-            assert_1.strict.equal((0, src_1.i64ToField)(1000000n), 1000000n);
-        });
-        it("wraps negative values via modular arithmetic", () => {
-            assert_1.strict.equal((0, src_1.i64ToField)(-1n), src_1.BN254_FR_MODULUS - 1n);
-            assert_1.strict.equal((0, src_1.i64ToField)(-100n), src_1.BN254_FR_MODULUS - 100n);
-        });
-        it("maps -1n to a value distinguishable from positive 1n", () => {
-            assert_1.strict.notEqual((0, src_1.i64ToField)(-1n), (0, src_1.i64ToField)(1n));
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // computeExtDataHash
-    // ---------------------------------------------------------------------------
-    describe("computeExtDataHash", () => {
-        const recipient = web3_js_1.Keypair.generate().publicKey;
-        const relayer = web3_js_1.Keypair.generate().publicKey;
-        const claimant = web3_js_1.Keypair.generate().publicKey;
-        it("returns exactly 32 bytes", () => {
-            const extData = { recipient, relayer, fee: 50n, refund: 0n, claimant };
-            assert_1.strict.equal((0, src_1.computeExtDataHash)(extData).length, 32);
-        });
-        it("is deterministic", () => {
-            const extData = { recipient, relayer, fee: 50n, refund: 0n, claimant };
-            const h1 = (0, src_1.computeExtDataHash)(extData);
-            const h2 = (0, src_1.computeExtDataHash)(extData);
-            assert_1.strict.equal(Buffer.compare(Buffer.from(h1), Buffer.from(h2)), 0);
-        });
-        it("produces different hashes for different recipients", () => {
-            const extData1 = { recipient, relayer, fee: 50n, refund: 0n, claimant };
-            const extData2 = {
-                recipient: web3_js_1.Keypair.generate().publicKey,
-                relayer,
-                fee: 50n,
-                refund: 0n,
-                claimant,
-            };
-            assert_1.strict.notEqual(Buffer.compare(Buffer.from((0, src_1.computeExtDataHash)(extData1)), Buffer.from((0, src_1.computeExtDataHash)(extData2))), 0);
-        });
-        it("produces different hashes for different fees", () => {
-            const extData1 = { recipient, relayer, fee: 0n, refund: 0n, claimant };
-            const extData2 = { recipient, relayer, fee: 999n, refund: 0n, claimant };
-            assert_1.strict.notEqual(Buffer.compare(Buffer.from((0, src_1.computeExtDataHash)(extData1)), Buffer.from((0, src_1.computeExtDataHash)(extData2))), 0);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // packProofToBytes
-    // ---------------------------------------------------------------------------
-    describe("packProofToBytes", () => {
-        it("returns exactly 256 bytes", () => {
-            const bytes = (0, src_1.packProofToBytes)(MOCK_PROOF);
-            assert_1.strict.equal(bytes.length, 256);
-        });
-        it("is deterministic", () => {
-            const b1 = (0, src_1.packProofToBytes)(MOCK_PROOF);
-            const b2 = (0, src_1.packProofToBytes)(MOCK_PROOF);
-            assert_1.strict.equal(Buffer.compare(Buffer.from(b1), Buffer.from(b2)), 0);
-        });
-        it("produces different output for different proof values", () => {
-            const otherProof = {
-                ...MOCK_PROOF,
-                pi_a: ["999", "888", "0"],
-            };
-            const b1 = (0, src_1.packProofToBytes)(MOCK_PROOF);
-            const b2 = (0, src_1.packProofToBytes)(otherProof);
-            assert_1.strict.notEqual(Buffer.compare(Buffer.from(b1), Buffer.from(b2)), 0);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // encodeSnarkjsProofToTransactionProof
-    // ---------------------------------------------------------------------------
-    describe("encodeSnarkjsProofToTransactionProof", () => {
-        it("produces proofA of 64 bytes", () => {
-            const p = (0, src_1.encodeSnarkjsProofToTransactionProof)(MOCK_PROOF);
-            assert_1.strict.equal(p.proofA.length, 64);
-        });
-        it("produces proofB of 128 bytes", () => {
-            const p = (0, src_1.encodeSnarkjsProofToTransactionProof)(MOCK_PROOF);
-            assert_1.strict.equal(p.proofB.length, 128);
-        });
-        it("produces proofC of 64 bytes", () => {
-            const p = (0, src_1.encodeSnarkjsProofToTransactionProof)(MOCK_PROOF);
-            assert_1.strict.equal(p.proofC.length, 64);
-        });
-        it("all values are numbers (u8)", () => {
-            const p = (0, src_1.encodeSnarkjsProofToTransactionProof)(MOCK_PROOF);
-            const all = [...p.proofA, ...p.proofB, ...p.proofC];
-            assert_1.strict.ok(all.every((b) => typeof b === "number" && b >= 0 && b <= 255));
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // computeSwapParamsHash
-    // ---------------------------------------------------------------------------
-    describe("computeSwapParamsHash", () => {
-        const sourceMint = new web3_js_1.PublicKey("So11111111111111111111111111111111111111112");
-        const destMint = new web3_js_1.PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
-        it("returns exactly 32 bytes", () => {
-            const hash = (0, src_1.computeSwapParamsHash)(sourceMint, destMint, 1000n, 0n);
-            assert_1.strict.equal(hash.length, 32);
-        });
-        it("is deterministic", () => {
-            const h1 = (0, src_1.computeSwapParamsHash)(sourceMint, destMint, 1000n, 0n);
-            const h2 = (0, src_1.computeSwapParamsHash)(sourceMint, destMint, 1000n, 0n);
-            assert_1.strict.equal(Buffer.compare(Buffer.from(h1), Buffer.from(h2)), 0);
-        });
-        it("produces different hash for different source mints", () => {
-            const h1 = (0, src_1.computeSwapParamsHash)(sourceMint, destMint, 1000n, 0n);
-            const h2 = (0, src_1.computeSwapParamsHash)(src_1.NATIVE_SOL_MINT, destMint, 1000n, 0n);
-            assert_1.strict.notEqual(Buffer.compare(Buffer.from(h1), Buffer.from(h2)), 0);
-        });
-        it("produces different hash for different minAmountOut", () => {
-            const h1 = (0, src_1.computeSwapParamsHash)(sourceMint, destMint, 1000n, 0n);
-            const h2 = (0, src_1.computeSwapParamsHash)(sourceMint, destMint, 9999n, 0n);
-            assert_1.strict.notEqual(Buffer.compare(Buffer.from(h1), Buffer.from(h2)), 0);
-        });
-        it("accepts optional destAmount and produces different hash when provided", () => {
-            const withoutDest = (0, src_1.computeSwapParamsHash)(sourceMint, destMint, 1000n, 0n);
-            const withDest = (0, src_1.computeSwapParamsHash)(sourceMint, destMint, 1000n, 0n, 800n);
-            assert_1.strict.notEqual(Buffer.compare(Buffer.from(withoutDest), Buffer.from(withDest)), 0);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // computeSwapDataHash
-    // ---------------------------------------------------------------------------
-    describe("computeSwapDataHash", () => {
-        it("returns exactly 32 bytes", () => {
-            const hash = (0, src_1.computeSwapDataHash)(new Uint8Array([1, 2, 3, 4]));
-            assert_1.strict.equal(hash.length, 32);
-        });
-        it("is deterministic", () => {
-            const data = new Uint8Array([0xde, 0xad, 0xbe, 0xef]);
-            const h1 = (0, src_1.computeSwapDataHash)(data);
-            const h2 = (0, src_1.computeSwapDataHash)(data);
-            assert_1.strict.equal(Buffer.compare(Buffer.from(h1), Buffer.from(h2)), 0);
-        });
-        it("accepts a Buffer as input", () => {
-            const buf = Buffer.from([1, 2, 3]);
-            const hash = (0, src_1.computeSwapDataHash)(buf);
-            assert_1.strict.equal(hash.length, 32);
-        });
-        it("produces different hashes for different inputs", () => {
-            const h1 = (0, src_1.computeSwapDataHash)(new Uint8Array([1]));
-            const h2 = (0, src_1.computeSwapDataHash)(new Uint8Array([2]));
-            assert_1.strict.notEqual(Buffer.compare(Buffer.from(h1), Buffer.from(h2)), 0);
-        });
-    });
-    // ---------------------------------------------------------------------------
-    // prepareTransactionInputs + formatInputsForSnarkjs
-    // ---------------------------------------------------------------------------
-    describe("prepareTransactionInputs", () => {
-        function makeInputs() {
-            const tree = new src_1.MerkleTree(4);
-            const kp = (0, src_1.generateKeypair)();
-            const utxo0 = (0, src_1.createOwnedZeroUTXO)(kp.privateKey, src_1.NATIVE_SOL_MINT);
-            const utxo1 = (0, src_1.createOwnedZeroUTXO)(kp.privateKey, src_1.NATIVE_SOL_MINT);
-            const { index: idx0 } = tree.insert(utxo0.commitment);
-            const { index: idx1 } = tree.insert(utxo1.commitment);
-            const path0 = tree.getPath(idx0);
-            const path1 = tree.getPath(idx1);
-            const input0 = {
-                ...utxo0,
-                pathIndex: idx0,
-                pathElements: path0.path,
-                privateKey: kp.privateKey,
-            };
-            const input1 = {
-                ...utxo1,
-                pathIndex: idx1,
-                pathElements: path1.path,
-                privateKey: kp.privateKey,
-            };
-            const out0 = (0, src_1.createOwnedZeroUTXO)(kp.privateKey, src_1.NATIVE_SOL_MINT);
-            const out1 = (0, src_1.createOwnedZeroUTXO)(kp.privateKey, src_1.NATIVE_SOL_MINT);
-            const recipient = web3_js_1.Keypair.generate().publicKey;
-            const relayer = web3_js_1.Keypair.generate().publicKey;
-            const extData = {
-                recipient,
-                relayer,
-                fee: 0n,
-                refund: 0n,
-                claimant: web3_js_1.PublicKey.default,
-            };
-            return (0, src_1.prepareTransactionInputs)({
-                inputUTXOs: [input0, input1],
-                outputUTXOs: [out0, out1],
-                root: tree.root,
-                publicAmount: 0n,
-                extData,
-                mintAddress: src_1.NATIVE_SOL_MINT,
-            });
-        }
-        it("returns 32-byte extDataHash", () => {
-            const inputs = makeInputs();
-            assert_1.strict.equal(inputs.extDataHash.length, 32);
-        });
-        it("returns two 32-byte nullifiers", () => {
-            const inputs = makeInputs();
-            assert_1.strict.equal(inputs.inputNullifiers[0].length, 32);
-            assert_1.strict.equal(inputs.inputNullifiers[1].length, 32);
-        });
-        it("returns two 32-byte output commitments", () => {
-            const inputs = makeInputs();
-            assert_1.strict.equal(inputs.outputCommitments[0].length, 32);
-            assert_1.strict.equal(inputs.outputCommitments[1].length, 32);
-        });
-        it("populates inAmount from input UTXOs", () => {
-            const inputs = makeInputs();
-            assert_1.strict.equal(inputs.inAmount[0], 0n);
-            assert_1.strict.equal(inputs.inAmount[1], 0n);
-        });
-        it("inPathElements has depth-many entries per input", () => {
-            const inputs = makeInputs();
-            assert_1.strict.equal(inputs.inPathElements[0].length, 4);
-            assert_1.strict.equal(inputs.inPathElements[1].length, 4);
-        });
-    });
-    describe("formatInputsForSnarkjs", () => {
-        it("converts all fields to strings or string arrays", () => {
-            const tree = new src_1.MerkleTree(4);
-            const kp = (0, src_1.generateKeypair)();
-            const utxo0 = (0, src_1.createOwnedZeroUTXO)(kp.privateKey, src_1.NATIVE_SOL_MINT);
-            const utxo1 = (0, src_1.createOwnedZeroUTXO)(kp.privateKey, src_1.NATIVE_SOL_MINT);
-            const { index: idx0 } = tree.insert(utxo0.commitment);
-            const { index: idx1 } = tree.insert(utxo1.commitment);
-            const path0 = tree.getPath(idx0);
-            const path1 = tree.getPath(idx1);
-            const input0 = {
-                ...utxo0,
-                pathIndex: idx0,
-                pathElements: path0.path,
-                privateKey: kp.privateKey,
-            };
-            const input1 = {
-                ...utxo1,
-                pathIndex: idx1,
-                pathElements: path1.path,
-                privateKey: kp.privateKey,
-            };
-            const out0 = (0, src_1.createOwnedZeroUTXO)(kp.privateKey, src_1.NATIVE_SOL_MINT);
-            const out1 = (0, src_1.createOwnedZeroUTXO)(kp.privateKey, src_1.NATIVE_SOL_MINT);
-            const extData = {
-                recipient: web3_js_1.Keypair.generate().publicKey,
-                relayer: web3_js_1.Keypair.generate().publicKey,
-                fee: 0n,
-                refund: 0n,
-                claimant: web3_js_1.PublicKey.default,
-            };
-            const circuitInputs = (0, src_1.prepareTransactionInputs)({
-                inputUTXOs: [input0, input1],
-                outputUTXOs: [out0, out1],
-                root: tree.root,
-                publicAmount: 0n,
-                extData,
-                mintAddress: src_1.NATIVE_SOL_MINT,
-            });
-            const formatted = (0, src_1.formatInputsForSnarkjs)(circuitInputs);
-            assert_1.strict.equal(typeof formatted.root, "string");
-            assert_1.strict.equal(typeof formatted.publicAmount, "string");
-            assert_1.strict.ok(Array.isArray(formatted.inputNullifier));
-            assert_1.strict.ok(formatted.inputNullifier.every((v) => typeof v === "string"));
-            assert_1.strict.ok(Array.isArray(formatted.inAmount));
-            assert_1.strict.ok(formatted.inAmount.every((v) => typeof v === "string"));
-        });
-    });
-});

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

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