@veilo/sdk-core 0.3.3 → 0.5.0

package/dist/cjs/proof.js

@@ -1,292 +1,18 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.computeExtDataHash = computeExtDataHash;
-exports.i64ToField = i64ToField;
-exports.prepareTransactionInputs = prepareTransactionInputs;
-exports.packProofToBytes = packProofToBytes;
-exports.encodeSnarkjsProofToTransactionProof = encodeSnarkjsProofToTransactionProof;
-exports.formatInputsForSnarkjs = formatInputsForSnarkjs;
-exports.formatSwapInputsForSnarkjs = formatSwapInputsForSnarkjs;
-exports.computeSwapParamsHash = computeSwapParamsHash;
-exports.computeSwapDataHash = computeSwapDataHash;
-const sha256_1 = require("@noble/hashes/sha256");
-const poseidon_1 = require("./poseidon");
-const utxo_1 = require("./utxo");
-// -----------------------------------------------------------------------------
-// ExtData Hash Computation
-// -----------------------------------------------------------------------------
-/**
- * Compute the external data hash.
- * Matches on-chain computation:
- *   hash1 = Poseidon(recipient, relayer)
- *   hash2 = Poseidon(fee, refund)
- *   extDataHash = Poseidon(hash1, hash2, claimant)
- */
-function computeExtDataHash(extData) {
-    const recipientField = (0, poseidon_1.pubkeyToField)(extData.recipient);
-    const relayerField = (0, poseidon_1.pubkeyToField)(extData.relayer);
-    const feeField = extData.fee % poseidon_1.BN254_FR_MODULUS;
-    const refundField = extData.refund % poseidon_1.BN254_FR_MODULUS;
-    const claimantField = (0, poseidon_1.pubkeyToField)(extData.claimant);
-    const hash1 = (0, poseidon_1.poseidon2)(recipientField, relayerField);
-    const hash2 = (0, poseidon_1.poseidon2)(feeField, refundField);
-    const finalHash = (0, poseidon_1.poseidon3)(hash1, hash2, claimantField);
-    return (0, poseidon_1.bigIntToBytesBE)(finalHash);
-}
-// -----------------------------------------------------------------------------
-// Circuit Input Preparation
-// -----------------------------------------------------------------------------
-/**
- * Convert i64 to field element (handles negative via modular arithmetic).
- * For negative values, we add the field modulus to get the equivalent positive representation.
- */
-function i64ToField(value) {
-    if (value >= 0n) {
-        return value % poseidon_1.BN254_FR_MODULUS;
-    }
-    return (poseidon_1.BN254_FR_MODULUS + value) % poseidon_1.BN254_FR_MODULUS;
-}
-/**
- * Prepare transaction circuit inputs from high-level parameters.
- * This converts the SDK types into the format expected by the circuit.
- */
-function prepareTransactionInputs(params) {
-    const { inputUTXOs, outputUTXOs, root, publicAmount, extData, mintAddress } = params;
-    const extDataHash = computeExtDataHash(extData);
-    const mintField = (0, poseidon_1.pubkeyToField)(mintAddress);
-    // Prepare input UTXO data
-    const inAmount = [
-        inputUTXOs[0].amount,
-        inputUTXOs[1].amount,
-    ];
-    const inPubkey = [
-        inputUTXOs[0].pubkey,
-        inputUTXOs[1].pubkey,
-    ];
-    const inBlinding = [
-        inputUTXOs[0].blinding,
-        inputUTXOs[1].blinding,
-    ];
-    const inPathIndex = [
-        inputUTXOs[0].pathIndex,
-        inputUTXOs[1].pathIndex,
-    ];
-    const inPathElements = [
-        inputUTXOs[0].pathElements.map((e) => (0, poseidon_1.bytesToBigIntBE)(e) % poseidon_1.BN254_FR_MODULUS),
-        inputUTXOs[1].pathElements.map((e) => (0, poseidon_1.bytesToBigIntBE)(e) % poseidon_1.BN254_FR_MODULUS),
-    ];
-    const inPrivateKey = [
-        inputUTXOs[0].privateKey,
-        inputUTXOs[1].privateKey,
-    ];
-    // Prepare output UTXO data
-    const outAmount = [
-        outputUTXOs[0].amount,
-        outputUTXOs[1].amount,
-    ];
-    const outPubkey = [
-        outputUTXOs[0].pubkey,
-        outputUTXOs[1].pubkey,
-    ];
-    const outBlinding = [
-        outputUTXOs[0].blinding,
-        outputUTXOs[1].blinding,
-    ];
-    // Derive nullifiers for input UTXOs
-    const inputNullifiers = [
-        (0, utxo_1.deriveNullifier)(inputUTXOs[0], inputUTXOs[0].pathIndex, inputUTXOs[0].privateKey),
-        (0, utxo_1.deriveNullifier)(inputUTXOs[1], inputUTXOs[1].pathIndex, inputUTXOs[1].privateKey),
-    ];
-    return {
-        root,
-        publicAmount,
-        extDataHash,
-        mintAddress,
-        inputNullifiers,
-        outputCommitments: [outputUTXOs[0].commitment, outputUTXOs[1].commitment],
-        inAmount,
-        inPubkey,
-        inBlinding,
-        inPathIndex,
-        inPathElements,
-        inPrivateKey,
-        outAmount,
-        outPubkey,
-        outBlinding,
-    };
-}
-// -----------------------------------------------------------------------------
-// Proof Packing
-// -----------------------------------------------------------------------------
-/**
- * Convert bigint to 32-byte big-endian representation.
- * The alt_bn128 Solana precompile (and ark-works via change_endianness) expect BE.
- */
-function bigintTo32BytesBE(x) {
-    const out = new Uint8Array(32);
-    let v = x;
-    for (let i = 31; i >= 0; i--) {
-        out[i] = Number(v & 0xffn);
-        v >>= 8n;
-    }
-    return out;
-}
-/**
- * Turn a snarkjs Groth16 proof into 256 bytes:
- *   A(G1) | B(G2) | C(G1)
- * where:
- *   A = (ax, ay)               -> 64 bytes
- *   B = (bx1, bx0, by1, by0)  -> 128 bytes  (swapped pairs for alt_bn128)
- *   C = (cx, cy)               -> 64 bytes
- *
- * Each field element is encoded as 32-byte BE to match the on-chain verifier.
- * We ignore the extra projective/z components snarkjs keeps.
- */
-function packProofToBytes(proof) {
-    const chunks = [];
-    const ax = BigInt(proof.pi_a[0]);
-    const ay = BigInt(proof.pi_a[1]);
-    chunks.push(bigintTo32BytesBE(ax), bigintTo32BytesBE(ay));
-    const bx = proof.pi_b[0];
-    const by = proof.pi_b[1];
-    const bx0 = BigInt(bx[0]);
-    const bx1 = BigInt(bx[1]);
-    const by0 = BigInt(by[0]);
-    const by1 = BigInt(by[1]);
-    // alt_bn128 expects the G2 pairs swapped: bx1 before bx0, by1 before by0
-    chunks.push(bigintTo32BytesBE(bx1), bigintTo32BytesBE(bx0), bigintTo32BytesBE(by1), bigintTo32BytesBE(by0));
-    const cx = BigInt(proof.pi_c[0]);
-    const cy = BigInt(proof.pi_c[1]);
-    chunks.push(bigintTo32BytesBE(cx), bigintTo32BytesBE(cy));
-    const out = new Uint8Array(32 * (2 + 4 + 2)); // 256
-    let offset = 0;
-    for (const c of chunks) {
-        out.set(c, offset);
-        offset += c.length;
+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]; } };
     }
-    return out;
-}
-/**
- * Encode a snarkjs proof into the TransactionProofStruct format expected by the on-chain program.
- */
-function encodeSnarkjsProofToTransactionProof(proof) {
-    const full = packProofToBytes(proof);
-    if (full.length !== 256) {
-        throw new Error(`Expected 256 proof bytes, got ${full.length}`);
-    }
-    const proofA = full.slice(0, 64);
-    const proofB = full.slice(64, 192);
-    const proofC = full.slice(192, 256);
-    return {
-        proofA: Array.from(proofA),
-        proofB: Array.from(proofB),
-        proofC: Array.from(proofC),
-    };
-}
-// -----------------------------------------------------------------------------
-// Snarkjs Input Formatting
-// -----------------------------------------------------------------------------
-/**
- * Convert TransactionCircuitInputs to the format expected by snarkjs.groth16.fullProve().
- * All values are converted to strings (snarkjs expects string inputs for field elements).
- */
-function formatInputsForSnarkjs(inputs) {
-    return {
-        // Public inputs
-        root: (0, poseidon_1.bytesToBigIntBE)(inputs.root).toString(),
-        publicAmount: i64ToField(inputs.publicAmount).toString(),
-        extDataHash: (0, poseidon_1.bytesToBigIntBE)(inputs.extDataHash).toString(),
-        mintAddress: (0, poseidon_1.pubkeyToField)(inputs.mintAddress).toString(),
-        inputNullifier: inputs.inputNullifiers.map((n) => (0, poseidon_1.bytesToBigIntBE)(n).toString()),
-        outputCommitment: inputs.outputCommitments.map((c) => (0, poseidon_1.bytesToBigIntBE)(c).toString()),
-        // Private inputs - Input UTXOs
-        inAmount: inputs.inAmount.map((a) => a.toString()),
-        inPubkey: inputs.inPubkey.map((p) => p.toString()),
-        inBlinding: inputs.inBlinding.map((b) => b.toString()),
-        inPathIndex: inputs.inPathIndex.map((i) => i.toString()),
-        inPathElements: inputs.inPathElements.map((path) => path.map((e) => e.toString())),
-        inPrivateKey: inputs.inPrivateKey.map((k) => k.toString()),
-        // Private inputs - Output UTXOs
-        outAmount: inputs.outAmount.map((a) => a.toString()),
-        outPubkey: inputs.outPubkey.map((p) => p.toString()),
-        outBlinding: inputs.outBlinding.map((b) => b.toString()),
-    };
-}
-/**
- * Convert SwapCircuitInputs into the shape expected by
- * snarkjs.groth16.fullProve() for swap.circom. Every value is emitted as a
- * decimal string (or string array) because snarkjs only accepts field
- * elements as strings.
- *
- * Mirrors `generateSwapProof` in
- * relayer-server/src/controllers/swap.helpers.ts so SDK-side swap proofs
- * verify against the same circuit the relayer uses.
- */
-function formatSwapInputsForSnarkjs(inputs) {
-    return {
-        // Public inputs
-        sourceRoot: (0, poseidon_1.bytesToBigIntBE)(inputs.sourceRoot).toString(),
-        swapParamsHash: (0, poseidon_1.bytesToBigIntBE)(inputs.swapParamsHash).toString(),
-        extDataHash: (0, poseidon_1.bytesToBigIntBE)(inputs.extDataHash).toString(),
-        sourceMint: (0, poseidon_1.pubkeyToField)(inputs.sourceMint).toString(),
-        destMint: (0, poseidon_1.pubkeyToField)(inputs.destMint).toString(),
-        inputNullifier: inputs.inputNullifiers.map((n) => (0, poseidon_1.bytesToBigIntBE)(n).toString()),
-        changeCommitment: (0, poseidon_1.bytesToBigIntBE)(inputs.changeCommitment).toString(),
-        destCommitment: (0, poseidon_1.bytesToBigIntBE)(inputs.destCommitment).toString(),
-        swapAmount: inputs.swapAmount.toString(),
-        // Private inputs - Input UTXOs
-        inAmount: inputs.inAmount.map((a) => a.toString()),
-        inPubkey: inputs.inPubkey.map((p) => p.toString()),
-        inBlinding: inputs.inBlinding.map((b) => b.toString()),
-        inPathIndex: inputs.inPathIndex.map((i) => i.toString()),
-        inPathElements: inputs.inPathElements.map((path) => path.map((e) => e.toString())),
-        inPrivateKey: inputs.inPrivateKey.map((k) => k.toString()),
-        // Private inputs - Change UTXO
-        changeAmount: inputs.changeAmount.toString(),
-        changePubkey: inputs.changePubkey.toString(),
-        changeBlinding: inputs.changeBlinding.toString(),
-        // Private inputs - Destination UTXO
-        destAmount: inputs.destAmount.toString(),
-        destPubkey: inputs.destPubkey.toString(),
-        destBlinding: inputs.destBlinding.toString(),
-        // Swap params
-        minAmountOut: inputs.minAmountOut.toString(),
-        deadline: inputs.deadline.toString(),
-    };
-}
-// -----------------------------------------------------------------------------
-// Swap Parameter Hashing
-// -----------------------------------------------------------------------------
-/**
- * Compute the swap params hash that the swap circuit and on-chain program verify.
- * Mirrors relayer-server/src/controllers/swap.helpers.ts `computeSwapParamsHash`.
- *
- * Circuit formula (swap.circom lines 293-307):
- *   mintPairHash   = Poseidon(sourceMint, destMint)
- *   swapTermsHash  = Poseidon(minAmountOut, deadline, destAmount)
- *   swapParamsHash = Poseidon(mintPairHash, swapTermsHash)
- *
- * @param sourceMint   Source pool mint
- * @param destMint     Destination pool mint
- * @param minAmountOut Minimum accepted output amount (slippage protected)
- * @param deadline     Unix timestamp deadline (i64, 0 = no deadline)
- * @param destAmount   Actual amount committed to destination UTXO (≥ minAmountOut -
- *                     relayerFee). If omitted, defaults to minAmountOut.
- */
-function computeSwapParamsHash(sourceMint, destMint, minAmountOut, deadline, destAmount) {
-    const srcField = (0, poseidon_1.pubkeyToField)(sourceMint);
-    const dstField = (0, poseidon_1.pubkeyToField)(destMint);
-    const mintPairHash = (0, poseidon_1.poseidon2)(srcField, dstField);
-    const dest = destAmount ?? minAmountOut;
-    const swapTermsHash = (0, poseidon_1.poseidon3)(minAmountOut, deadline, dest);
-    const paramsHash = (0, poseidon_1.poseidon2)(mintPairHash, swapTermsHash);
-    return (0, poseidon_1.bigIntToBytesBE)(paramsHash);
-}
-/**
- * Compute the swap data hash committed on-chain for Jupiter instruction integrity.
- * SHA-256 of the raw Jupiter swap instruction data bytes.
- * Mirrors relayer-server/src/controllers/swap.helpers.ts `computeSwapDataHash`.
- */
-function computeSwapDataHash(swapData) {
-    return (0, sha256_1.sha256)(swapData instanceof Buffer ? new Uint8Array(swapData) : swapData);
-}
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Backward-compatible entry point. Proof responsibilities live in src/proofs.
+__exportStar(require("./proofs/index.js"), exports);

package/dist/cjs/proofs/encoding.d.ts

@@ -0,0 +1,17 @@
+import type { RawProof, TransactionProofStruct } from "./types.js";
+/**
+ * Turn a snarkjs Groth16 proof into 256 bytes:
+ *   A(G1) | B(G2) | C(G1)
+ * where:
+ *   A = (ax, ay)               -> 64 bytes
+ *   B = (bx1, bx0, by1, by0)  -> 128 bytes  (swapped pairs for alt_bn128)
+ *   C = (cx, cy)               -> 64 bytes
+ *
+ * Each field element is encoded as 32-byte BE to match the on-chain verifier.
+ * We ignore the extra projective/z components snarkjs keeps.
+ */
+export declare function packProofToBytes(proof: RawProof): Uint8Array;
+/**
+ * Encode a snarkjs proof into the TransactionProofStruct format expected by the on-chain program.
+ */
+export declare function encodeSnarkjsProofToTransactionProof(proof: RawProof): TransactionProofStruct;

package/dist/cjs/proofs/encoding.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packProofToBytes = packProofToBytes;
+exports.encodeSnarkjsProofToTransactionProof = encodeSnarkjsProofToTransactionProof;
+// -----------------------------------------------------------------------------
+// Proof Packing
+// -----------------------------------------------------------------------------
+/**
+ * Convert bigint to 32-byte big-endian representation.
+ * The alt_bn128 Solana precompile (and ark-works via change_endianness) expect BE.
+ */
+function bigintTo32BytesBE(x) {
+    const out = new Uint8Array(32);
+    let v = x;
+    for (let i = 31; i >= 0; i--) {
+        out[i] = Number(v & 0xffn);
+        v >>= 8n;
+    }
+    return out;
+}
+/**
+ * Turn a snarkjs Groth16 proof into 256 bytes:
+ *   A(G1) | B(G2) | C(G1)
+ * where:
+ *   A = (ax, ay)               -> 64 bytes
+ *   B = (bx1, bx0, by1, by0)  -> 128 bytes  (swapped pairs for alt_bn128)
+ *   C = (cx, cy)               -> 64 bytes
+ *
+ * Each field element is encoded as 32-byte BE to match the on-chain verifier.
+ * We ignore the extra projective/z components snarkjs keeps.
+ */
+function packProofToBytes(proof) {
+    const chunks = [];
+    const ax = BigInt(proof.pi_a[0]);
+    const ay = BigInt(proof.pi_a[1]);
+    chunks.push(bigintTo32BytesBE(ax), bigintTo32BytesBE(ay));
+    const bx = proof.pi_b[0];
+    const by = proof.pi_b[1];
+    const bx0 = BigInt(bx[0]);
+    const bx1 = BigInt(bx[1]);
+    const by0 = BigInt(by[0]);
+    const by1 = BigInt(by[1]);
+    // alt_bn128 expects the G2 pairs swapped: bx1 before bx0, by1 before by0
+    chunks.push(bigintTo32BytesBE(bx1), bigintTo32BytesBE(bx0), bigintTo32BytesBE(by1), bigintTo32BytesBE(by0));
+    const cx = BigInt(proof.pi_c[0]);
+    const cy = BigInt(proof.pi_c[1]);
+    chunks.push(bigintTo32BytesBE(cx), bigintTo32BytesBE(cy));
+    const out = new Uint8Array(32 * (2 + 4 + 2)); // 256
+    let offset = 0;
+    for (const c of chunks) {
+        out.set(c, offset);
+        offset += c.length;
+    }
+    return out;
+}
+/**
+ * Encode a snarkjs proof into the TransactionProofStruct format expected by the on-chain program.
+ */
+function encodeSnarkjsProofToTransactionProof(proof) {
+    const full = packProofToBytes(proof);
+    if (full.length !== 256) {
+        throw new Error(`Expected 256 proof bytes, got ${full.length}`);
+    }
+    const proofA = full.slice(0, 64);
+    const proofB = full.slice(64, 192);
+    const proofC = full.slice(192, 256);
+    return {
+        proofA: Array.from(proofA),
+        proofB: Array.from(proofB),
+        proofC: Array.from(proofC),
+    };
+}

package/dist/cjs/proofs/formatting.d.ts

@@ -0,0 +1,6 @@
+import type { TransactionCircuitInputs } from "./types.js";
+/**
+ * Convert TransactionCircuitInputs to the format expected by snarkjs.groth16.fullProve().
+ * All values are converted to strings (snarkjs expects string inputs for field elements).
+ */
+export declare function formatInputsForSnarkjs(inputs: TransactionCircuitInputs): Record<string, any>;

package/dist/cjs/proofs/formatting.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatInputsForSnarkjs = formatInputsForSnarkjs;
+const poseidon_js_1 = require("../poseidon.js");
+const transaction_js_1 = require("./transaction.js");
+// -----------------------------------------------------------------------------
+// Snarkjs Input Formatting
+// -----------------------------------------------------------------------------
+/**
+ * Convert TransactionCircuitInputs to the format expected by snarkjs.groth16.fullProve().
+ * All values are converted to strings (snarkjs expects string inputs for field elements).
+ */
+function formatInputsForSnarkjs(inputs) {
+    return {
+        // Public inputs
+        root: (0, poseidon_js_1.bytesToBigIntBE)(inputs.root).toString(),
+        publicAmount: (0, transaction_js_1.i64ToField)(inputs.publicAmount).toString(),
+        extDataHash: (0, poseidon_js_1.bytesToBigIntBE)(inputs.extDataHash).toString(),
+        mintAddress: (0, poseidon_js_1.pubkeyToField)(inputs.mintAddress).toString(),
+        inputNullifier: inputs.inputNullifiers.map((n) => (0, poseidon_js_1.bytesToBigIntBE)(n).toString()),
+        outputCommitment: inputs.outputCommitments.map((c) => (0, poseidon_js_1.bytesToBigIntBE)(c).toString()),
+        // Private inputs - Input UTXOs
+        inAmount: inputs.inAmount.map((a) => a.toString()),
+        inPubkey: inputs.inPubkey.map((p) => p.toString()),
+        inBlinding: inputs.inBlinding.map((b) => b.toString()),
+        inPathIndex: inputs.inPathIndex.map((i) => i.toString()),
+        inPathElements: inputs.inPathElements.map((path) => path.map((e) => e.toString())),
+        inPrivateKey: inputs.inPrivateKey.map((k) => k.toString()),
+        // Private inputs - Output UTXOs
+        outAmount: inputs.outAmount.map((a) => a.toString()),
+        outPubkey: inputs.outPubkey.map((p) => p.toString()),
+        outBlinding: inputs.outBlinding.map((b) => b.toString()),
+    };
+}

package/dist/cjs/proofs/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./types.js";
+export * from "./transaction.js";
+export * from "./encoding.js";
+export * from "./formatting.js";
+export * from "./swap.js";

package/dist/cjs/proofs/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./transaction.js"), exports);
+__exportStar(require("./encoding.js"), exports);
+__exportStar(require("./formatting.js"), exports);
+__exportStar(require("./swap.js"), exports);

package/dist/cjs/proofs/swap.d.ts

@@ -0,0 +1,87 @@
+import { PublicKey } from "@solana/web3.js";
+import type { InputUTXO, SerializedUTXO } from "../notes/model.js";
+import type { ExtData, RawProof } from "./types.js";
+/**
+ * Swap circuit inputs. Matches the signal shape declared by swap.circom's
+ * main component (see zk-circuits/swap.circom lines 208-238). Unlike the
+ * transaction circuit, the swap circuit distinguishes a "change" output
+ * (same mint as source) from a "dest" output (dest mint) and takes a
+ * swap-specific params hash and swapAmount alongside the usual inputs.
+ */
+export type SwapCircuitInputs = {
+    sourceRoot: Uint8Array;
+    swapParamsHash: Uint8Array;
+    extDataHash: Uint8Array;
+    sourceMint: PublicKey;
+    destMint: PublicKey;
+    inputNullifiers: [Uint8Array, Uint8Array];
+    changeCommitment: Uint8Array;
+    destCommitment: Uint8Array;
+    swapAmount: bigint;
+    inAmount: [bigint, bigint];
+    inPubkey: [bigint, bigint];
+    inBlinding: [bigint, bigint];
+    inPathIndex: [number, number];
+    inPathElements: [bigint[], bigint[]];
+    inPrivateKey: [bigint, bigint];
+    changeAmount: bigint;
+    changePubkey: bigint;
+    changeBlinding: bigint;
+    destAmount: bigint;
+    destPubkey: bigint;
+    destBlinding: bigint;
+    minAmountOut: bigint;
+    deadline: bigint;
+};
+/** Proof builder accepted by SDK-side private swap flows. */
+export type SwapProofBuilder = (inputs: SwapCircuitInputs) => Promise<RawProof>;
+/**
+ * Prepare the exact witness/public inputs used by the relayer's swap circuit.
+ * Output 0 must be source-mint change and output 1 the destination-mint note.
+ */
+export declare function prepareSwapInputs(params: {
+    inputUTXOs: [InputUTXO, InputUTXO];
+    changeUTXO: SerializedUTXO;
+    destUTXO: SerializedUTXO;
+    sourceRoot: Uint8Array;
+    sourceMint: PublicKey;
+    destMint: PublicKey;
+    swapAmount: bigint;
+    minAmountOut: bigint;
+    deadline: bigint;
+    extData: ExtData;
+}): SwapCircuitInputs;
+/**
+ * Convert SwapCircuitInputs into the shape expected by
+ * snarkjs.groth16.fullProve() for swap.circom. Every value is emitted as a
+ * decimal string (or string array) because snarkjs only accepts field
+ * elements as strings.
+ *
+ * Mirrors `generateSwapProof` in
+ * relayer-server/src/controllers/swap.helpers.ts so SDK-side swap proofs
+ * verify against the same circuit the relayer uses.
+ */
+export declare function formatSwapInputsForSnarkjs(inputs: SwapCircuitInputs): Record<string, any>;
+/**
+ * Compute the swap params hash that the swap circuit and on-chain program verify.
+ * Mirrors relayer-server/src/controllers/swap.helpers.ts `computeSwapParamsHash`.
+ *
+ * Circuit formula (swap.circom lines 293-307):
+ *   mintPairHash   = Poseidon(sourceMint, destMint)
+ *   swapTermsHash  = Poseidon(minAmountOut, deadline, destAmount)
+ *   swapParamsHash = Poseidon(mintPairHash, swapTermsHash)
+ *
+ * @param sourceMint   Source pool mint
+ * @param destMint     Destination pool mint
+ * @param minAmountOut Minimum accepted output amount (slippage protected)
+ * @param deadline     Positive Unix timestamp deadline (the program rejects 0)
+ * @param destAmount   Actual amount committed to destination UTXO (≥ minAmountOut -
+ *                     relayerFee). If omitted, defaults to minAmountOut.
+ */
+export declare function computeSwapParamsHash(sourceMint: PublicKey, destMint: PublicKey, minAmountOut: bigint, deadline: bigint, destAmount?: bigint): Uint8Array;
+/**
+ * Compute the swap data hash committed on-chain for Jupiter instruction integrity.
+ * SHA-256 of the raw Jupiter swap instruction data bytes.
+ * Mirrors relayer-server/src/controllers/swap.helpers.ts `computeSwapDataHash`.
+ */
+export declare function computeSwapDataHash(swapData: Uint8Array | Buffer): Uint8Array;