@veilo/sdk-core 0.3.3 → 0.5.0

package/dist/cjs/shield/types.d.ts

@@ -0,0 +1,202 @@
+import { AddressLookupTableAccount, Connection, PublicKey, VersionedTransaction } from "@solana/web3.js";
+import type { TransactionProofBuilder, TransactionProofStruct } from "../proofs/types.js";
+import type { CompactNoteCipher } from "../compactNote.js";
+/**
+ * Who owns the resulting note. Both halves are required and neither is derived
+ * from the other:
+ *
+ *  - `veiloPublicKey` is the Poseidon field element bound into the output
+ *    commitment. It is the **spending** authority.
+ *  - `noteViewingKey` is the Ed25519 wallet key the compact cipher is encrypted
+ *    to. It is the **detection** authority.
+ *
+ * If these two belong to different people, the note is *spendable but
+ * invisible*: the owner can never find it, so the funds are effectively gone.
+ * Nothing on-chain and nothing in this type can detect that — which is why
+ * `resolveShieldOwner()` exists and why hand-constructing this requires an
+ * explicit acknowledgement.
+ *
+ * See veilo-browser-extension/.../privateStealthWallet.ts:403-415 for the
+ * production comment describing this failure mode.
+ */
+export type ShieldOwner = {
+    veiloPublicKey: bigint;
+    noteViewingKey: PublicKey;
+    /**
+     * Set automatically by {@link resolveShieldOwner}, which fetches both halves
+     * from a single relayer response and can therefore guarantee they match.
+     *
+     * Hand-built owners must set this explicitly — it is the only mechanism
+     * standing between an integration mistake and silent fund loss.
+     */
+    acknowledgeOwnerInvariant?: true;
+};
+/**
+ * Who signs and pays. Public key only — the SDK never receives a secret key.
+ *
+ * The signer is unavoidably the fee payer, the funding source, and the payer of
+ * ~0.00192 SOL of nullifier-marker rent (the program hardcodes
+ * `payer = relayer` on both marker accounts). A wallet with no SOL cannot
+ * shield through this path regardless of who submits the transaction.
+ */
+export type ShieldSigner = {
+    publicKey: PublicKey;
+    /**
+     * Source token account for SPL shields. Defaults to the signer's canonical
+     * ATA. Must be owned by `publicKey` with no delegate set.
+     */
+    tokenAccount?: PublicKey;
+};
+/** Where the target tree and its root come from. */
+export interface TreeSource {
+    getDepositTarget(mint: PublicKey): Promise<DepositTarget>;
+}
+export type DepositTarget = {
+    /** Always 0 — the tree whose root the dummy inputs nominally prove against. */
+    inputTreeId: number;
+    /** 32-byte root, read from that tree's on-chain root history. */
+    inputRoot: Uint8Array;
+    /** Tree the new commitments are appended to. */
+    outputTreeId: number;
+    /** `nextIndex` at build time. A prediction — see `predictedLeafIndex`. */
+    outputNextIndex: number;
+};
+/** Where the address lookup table comes from. */
+export interface AltSource {
+    resolve(ctx: {
+        connection: Connection;
+        mint: PublicKey;
+        outputTreeId: number;
+        programId: PublicKey;
+    }): Promise<AddressLookupTableAccount>;
+}
+/**
+ * Caching for values that are stable across builds (the ALT account, rent
+ * exemption minimums, pool config).
+ *
+ * Deliberately an interface: the three production deposit implementations
+ * differ on exactly this axis — `localStorage`, `chrome.storage`, and
+ * `AsyncStorage` — and none of them belongs in a published SDK.
+ */
+export interface ShieldCachePort {
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, ttlMs?: number): Promise<void>;
+}
+export type PreflightOptions = {
+    /** Skip the SPL token-account inspection (owner, delegate, balance). */
+    skipTokenAccount?: boolean;
+    /** Skip the signer balance check. */
+    skipBalance?: boolean;
+    /** Skip pool state checks (paused, min/max, tree capacity). */
+    skipPoolState?: boolean;
+};
+export type ShieldParams = {
+    connection: Connection;
+    /** Net amount to shield, in base units. No fee is taken on deposits. */
+    amount: bigint;
+    /** Defaults to native SOL. */
+    mint?: PublicKey;
+    owner: ShieldOwner;
+    signer: ShieldSigner;
+    /** Proof generation. `createTransactionProver(artifacts)` satisfies this. */
+    prover: TransactionProofBuilder;
+    treeSource?: TreeSource;
+    alt?: AltSource;
+    cache?: ShieldCachePort;
+    programId?: PublicKey;
+    computeUnitLimit?: number;
+    /** Set to 0 to omit the priority-fee instruction entirely. */
+    computeUnitPriceMicroLamports?: number;
+    deadlineSeconds?: number;
+    /** Supply to avoid an RPC round-trip; otherwise fetched just before compiling. */
+    blockhash?: {
+        blockhash: string;
+        lastValidBlockHeight: number;
+    };
+    preflight?: boolean | PreflightOptions;
+};
+/**
+ * The recoverable secret material for the note this shield creates.
+ *
+ * SECRET. Anyone holding this can locate the note. It must never be persisted
+ * server-side in the clear or transmitted alongside {@link ShieldProofCache},
+ * which is deliberately public.
+ */
+export type ShieldNote = {
+    commitment: Uint8Array;
+    blinding: bigint;
+    amount: bigint;
+    ownerVeiloPublicKey: bigint;
+    mint: PublicKey;
+    treeId: number;
+    compact: CompactNoteCipher;
+};
+/**
+ * Everything needed to re-assemble the transaction with a fresh blockhash.
+ *
+ * PUBLIC and JSON-serializable by construction: it carries no blinding, no
+ * private key, and no note plaintext. A platform can build server-side, ship
+ * this to a client for signature, and rebuild in a different process without
+ * ever moving a secret.
+ */
+export type ShieldProofCache = {
+    version: 1;
+    programId: string;
+    mint: string;
+    signer: string;
+    altAddress: string;
+    inputTreeId: number;
+    outputTreeId: number;
+    root: string;
+    publicAmount: string;
+    extData: {
+        recipient: string;
+        relayer: string;
+        fee: string;
+        refund: string;
+        claimant: string;
+    };
+    extDataHash: string;
+    inputNullifiers: [string, string];
+    outputCommitments: [string, string];
+    proof: TransactionProofStruct;
+    noteCiphers: {
+        note0EphemeralKey: string;
+        note0Encrypted: string;
+        note0ViewTag: number;
+        note1EphemeralKey: string;
+        note1Encrypted: string;
+        note1ViewTag: number;
+    };
+    /** Resolved instruction accounts, keyed by IDL account name. */
+    accounts: Record<string, string>;
+    computeUnitLimit: number;
+};
+export type ShieldQuote = {
+    /** Serialized size including the signature. Must be <= 1232. */
+    serializedSize: number;
+    computeUnitLimit: number;
+    computeUnitPriceMicroLamports: number;
+    estimatedFeeLamports: bigint;
+    /** Nullifier-marker rent, permanently burned by the signer. */
+    estimatedRentLamports: bigint;
+};
+export type ShieldResult = {
+    /** UNSIGNED. The caller signs and submits — this SDK never broadcasts. */
+    transaction: VersionedTransaction;
+    blockhash: string;
+    lastValidBlockHeight: number;
+    deadline: bigint;
+    note: ShieldNote;
+    /**
+     * Leaf index the output commitment is *expected* to land at.
+     *
+     * A prediction, read before submission. Under concurrent deposits into the
+     * same tree it will be wrong. Use `finalizeShield()` to read the authoritative
+     * index from the confirmed transaction's `CommitmentEvent` before persisting
+     * anything that depends on it.
+     */
+    predictedLeafIndex: number;
+    quote: ShieldQuote;
+    proofCache: ShieldProofCache;
+};

package/dist/cjs/shield/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/transactions/deposit.d.ts

@@ -0,0 +1,94 @@
+import type { Program, Idl } from "@coral-xyz/anchor";
+import { PublicKey, Transaction } from "@solana/web3.js";
+import type { ExtData, TransactionProofBuilder } from "../proofs/types.js";
+import type { SerializedUTXO } from "../notes/model.js";
+import { MerkleTree } from "../merkle.js";
+import { type NoteCiphers } from "../compactNote.js";
+/**
+ * Result of a deposit operation, produced by `DepositBuild.commit()` after the
+ * caller has successfully submitted the deposit transaction on-chain.
+ */
+export type DepositResult = {
+    /** The output UTXOs created by the deposit */
+    outputUTXOs: [SerializedUTXO, SerializedUTXO];
+    /** The leaf indices where the UTXOs were inserted */
+    leafIndices: [number, number];
+    /** The new Merkle root after insertion */
+    root: Uint8Array;
+};
+/**
+ * The return of `deposit()`. Instead of submitting the transaction itself,
+ * `deposit()` hands back an unsigned {@link Transaction} so the caller can
+ * sign it with whatever wallet they control (Solana wallet-adapter, Ledger,
+ * anchor NodeWallet, etc.) and submit it on their own terms.
+ *
+ * Usage pattern (browser / wallet-adapter):
+ *
+ *     const { transaction, commit } = await deposit({ ... });
+ *     const signed = await wallet.signTransaction(transaction);
+ *     const sig = await connection.sendRawTransaction(signed.serialize());
+ *     await connection.confirmTransaction(sig, "confirmed");
+ *     const result = commit();   // updates the local tree, returns DepositResult
+ */
+export type DepositBuild = {
+    /**
+     * Unsigned {@link Transaction} for the deposit. `feePayer` and
+     * `recentBlockhash` are already populated, so the caller only needs to sign
+     * and send.
+     */
+    transaction: Transaction;
+    /**
+     * Output UTXOs created by this deposit. Safe to read before submission —
+     * the commitment values are deterministic from the circuit inputs and do
+     * not depend on the on-chain result.
+     */
+    outputUTXOs: [SerializedUTXO, SerializedUTXO];
+    /**
+     * Inserts the two output commitments into the local {@link MerkleTree} and
+     * returns the receipt. Call this **only after** the on-chain transaction
+     * has been confirmed — deferring the insert keeps the local tree
+     * consistent with chain state if the submission fails.
+     *
+     * Calling `commit()` more than once is unsupported and will corrupt the
+     * local tree.
+     */
+    commit: () => DepositResult;
+};
+/**
+ * Build an unsigned deposit {@link Transaction} for the privacy pool.
+ *
+ * For deposits, we use zero input UTXOs (amount=0) and create output UTXOs
+ * with the deposit amount. `publicAmount` is positive. The caller is
+ * responsible for signing and submitting the returned transaction, and then
+ * calling `commit()` once it confirms.
+ *
+ * @param amount - Amount to deposit in lamports/token units
+ * @param recipientPubkey - UTXO public key that will own the deposited funds
+ * @param treeId - The tree ID to deposit into (defaults to 0)
+ */
+export declare function deposit<T extends Idl>(params: {
+    program: Program<T>;
+    /**
+     * Account that will pay for and sign the deposit transaction. Only
+     * `publicKey` is read — `deposit()` never touches a secret key. A browser
+     * wallet-adapter wallet, a Node `anchor.Wallet`, or a raw `Keypair` are all
+     * structurally acceptable.
+     */
+    depositor: {
+        publicKey: PublicKey;
+    };
+    amount: bigint;
+    mintAddress: PublicKey;
+    recipientPubkey: bigint;
+    tree: MerkleTree;
+    proofBuilder: TransactionProofBuilder;
+    treeId?: number;
+    extData?: Partial<ExtData>;
+    /** Solana wallet key used to make output note 0 recoverable from chain events. */
+    noteRecipientWallet?: PublicKey | Uint8Array;
+    /** Prebuilt recovery payload. Takes precedence over noteRecipientWallet. */
+    noteCiphers?: NoteCiphers | null;
+}): Promise<DepositBuild>;
+/**
+ * Result of a withdrawal operation.
+ */

package/dist/cjs/transactions/deposit.js

@@ -0,0 +1,234 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deposit = deposit;
+const anchor = __importStar(require("@coral-xyz/anchor"));
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const transaction_js_1 = require("../proofs/transaction.js");
+const encoding_js_1 = require("../proofs/encoding.js");
+const model_js_1 = require("../notes/model.js");
+const config_js_1 = require("../config.js");
+const poseidon_js_1 = require("../poseidon.js");
+const compactNote_js_1 = require("../compactNote.js");
+const pdas_js_1 = require("../accounts/pdas.js");
+// Anchor is CJS and does not expose BN as a detectable Node ESM named export.
+const { BN } = anchor;
+/**
+ * Build an unsigned deposit {@link Transaction} for the privacy pool.
+ *
+ * For deposits, we use zero input UTXOs (amount=0) and create output UTXOs
+ * with the deposit amount. `publicAmount` is positive. The caller is
+ * responsible for signing and submitting the returned transaction, and then
+ * calling `commit()` once it confirms.
+ *
+ * @param amount - Amount to deposit in lamports/token units
+ * @param recipientPubkey - UTXO public key that will own the deposited funds
+ * @param treeId - The tree ID to deposit into (defaults to 0)
+ */
+async function deposit(params) {
+    const { program, depositor, amount, mintAddress, recipientPubkey, tree, proofBuilder, treeId = 0, extData: partialExtData, noteRecipientWallet, noteCiphers, } = params;
+    if (amount <= 0n) {
+        throw new Error("Deposit amount must be positive");
+    }
+    // Create zero input UTXOs (for deposits, we don't spend any existing UTXOs)
+    const zeroKeypair0 = (0, model_js_1.generateKeypair)();
+    const zeroKeypair1 = (0, model_js_1.generateKeypair)();
+    const zeroInput0 = (0, model_js_1.createOwnedZeroUTXO)(zeroKeypair0.privateKey, mintAddress);
+    const zeroInput1 = (0, model_js_1.createOwnedZeroUTXO)(zeroKeypair1.privateKey, mintAddress);
+    // The circuit skips the Merkle proof check for zero-amount inputs (amount == 0
+    // causes `enabled = 0` in MerkleProofIfEnabled). So we provide a dummy path using
+    // the tree's pre-computed zero chain without inserting anything into the tree.
+    const dummyPath = tree.zeroes.slice(0, tree.depth);
+    const currentRoot = tree.root;
+    const inputUTXOs = [
+        {
+            ...zeroInput0,
+            pathIndex: 0,
+            pathElements: dummyPath,
+            privateKey: zeroKeypair0.privateKey,
+        },
+        {
+            ...zeroInput1,
+            pathIndex: 0,
+            pathElements: dummyPath,
+            privateKey: zeroKeypair1.privateKey,
+        },
+    ];
+    const outputUTXO0 = (0, model_js_1.createUTXO)({
+        amount: amount,
+        pubkey: recipientPubkey,
+        mintAddress,
+    });
+    const outputUTXO1 = (0, model_js_1.createUTXO)({
+        amount: 0n,
+        pubkey: (0, model_js_1.generateKeypair)().publicKey,
+        mintAddress,
+    });
+    const outputUTXOs = [
+        outputUTXO0,
+        outputUTXO1,
+    ];
+    const depositorPubkey = depositor.publicKey;
+    const extData = {
+        recipient: partialExtData?.recipient ?? depositorPubkey,
+        relayer: partialExtData?.relayer ?? depositorPubkey,
+        fee: partialExtData?.fee ?? 0n,
+        refund: partialExtData?.refund ?? 0n,
+        claimant: partialExtData?.claimant ?? web3_js_1.SystemProgram.programId,
+    };
+    if (!extData.relayer.equals(depositorPubkey)) {
+        throw new Error("Deposit extData.relayer must be the signing depositor");
+    }
+    if (extData.fee !== 0n || extData.refund !== 0n) {
+        throw new Error("Deposits require extData fee and refund to be zero");
+    }
+    const circuitInputs = (0, transaction_js_1.prepareTransactionInputs)({
+        inputUTXOs,
+        outputUTXOs,
+        root: currentRoot,
+        publicAmount: amount, // Positive for deposits
+        extData,
+        mintAddress,
+    });
+    const rawProof = await proofBuilder(circuitInputs);
+    const proof = (0, encoding_js_1.encodeSnarkjsProofToTransactionProof)(rawProof);
+    const depositNoteCiphers = noteCiphers !== undefined
+        ? noteCiphers
+        : noteRecipientWallet
+            ? (0, compactNote_js_1.createNoteCiphers)({
+                recipientWalletPubkey: noteRecipientWallet instanceof web3_js_1.PublicKey
+                    ? noteRecipientWallet.toBytes()
+                    : noteRecipientWallet,
+                blinding: (0, poseidon_js_1.bigIntToBytesBE)(outputUTXO0.blinding),
+                amount: outputUTXO0.amount,
+            }, null)
+            : null;
+    // -----------------------------------------------------------------------
+    // Build the transact instruction inline because deposits return an unsigned
+    // wallet-signable transaction while `transact()` submits with a Keypair.
+    //
+    // We intentionally don't reuse the `transact()` helper: it submits via
+    // anchor's `.rpc()` with `.signers([relayer])`, which assumes the caller
+    // holds a real Keypair. For deposit, we want to return an unsigned
+    // Transaction so the caller (typically a browser wallet) can sign it.
+    // -----------------------------------------------------------------------
+    const { config, vault, nullifiers } = (0, pdas_js_1.getPoolPdas)(program.programId, mintAddress);
+    const globalConfig = (0, pdas_js_1.getGlobalConfigPda)(program.programId);
+    const inputTree = (0, pdas_js_1.getNoteTreePda)(program.programId, mintAddress, treeId);
+    const outputTree = (0, pdas_js_1.getNoteTreePda)(program.programId, mintAddress, treeId);
+    const nullifierMarker0 = (0, pdas_js_1.getNullifierMarkerPda)(program.programId, mintAddress, circuitInputs.inputNullifiers[0]);
+    const nullifierMarker1 = (0, pdas_js_1.getNullifierMarkerPda)(program.programId, mintAddress, circuitInputs.inputNullifiers[1]);
+    const extDataHash = (0, transaction_js_1.computeExtDataHash)(extData);
+    const isNativeSol = mintAddress.equals(config_js_1.NATIVE_SOL_MINT);
+    let vaultTA;
+    let userTA;
+    let recipientTA;
+    let relayerTA;
+    if (!isNativeSol) {
+        vaultTA = await (0, spl_token_1.getAssociatedTokenAddress)(mintAddress, vault, true);
+        userTA = await (0, spl_token_1.getAssociatedTokenAddress)(mintAddress, depositorPubkey);
+        recipientTA = await (0, spl_token_1.getAssociatedTokenAddress)(mintAddress, extData.recipient);
+        relayerTA = await (0, spl_token_1.getAssociatedTokenAddress)(mintAddress, depositorPubkey);
+    }
+    const builtTx = await program.methods
+        .transact(Array.from(currentRoot), treeId, treeId, new BN(amount.toString()), Array.from(extDataHash), mintAddress, Array.from(circuitInputs.inputNullifiers[0]), Array.from(circuitInputs.inputNullifiers[1]), Array.from(circuitInputs.outputCommitments[0]), Array.from(circuitInputs.outputCommitments[1]), new BN(Math.floor(Date.now() / 1000) + 3600), // 1-hour window from build time
+    {
+        recipient: extData.recipient,
+        relayer: extData.relayer,
+        fee: new BN(extData.fee.toString()),
+        refund: new BN(extData.refund.toString()),
+        claimant: extData.claimant,
+    }, {
+        proofA: proof.proofA,
+        proofB: proof.proofB,
+        proofC: proof.proofC,
+    }, depositNoteCiphers
+        ? {
+            note0EphemeralKey: Array.from(depositNoteCiphers.note0EphemeralKey),
+            note0Encrypted: Array.from(depositNoteCiphers.note0Encrypted),
+            note0ViewTag: depositNoteCiphers.note0ViewTag,
+            note1EphemeralKey: Array.from(depositNoteCiphers.note1EphemeralKey),
+            note1Encrypted: Array.from(depositNoteCiphers.note1Encrypted),
+            note1ViewTag: depositNoteCiphers.note1ViewTag,
+        }
+        : null)
+        .accountsStrict({
+        config,
+        globalConfig,
+        vault,
+        inputTree,
+        outputTree,
+        nullifiers,
+        nullifierMarker0,
+        nullifierMarker1,
+        relayer: depositorPubkey,
+        recipient: extData.recipient,
+        vaultTokenAccount: vaultTA ?? depositorPubkey,
+        userTokenAccount: userTA ?? depositorPubkey,
+        recipientTokenAccount: recipientTA ?? extData.recipient,
+        relayerTokenAccount: relayerTA ?? depositorPubkey,
+        tokenProgram: isNativeSol ? web3_js_1.SystemProgram.programId : spl_token_1.TOKEN_PROGRAM_ID,
+        systemProgram: web3_js_1.SystemProgram.programId,
+    })
+        .transaction();
+    // Add compute budget instruction for higher CU limit
+    const computeBudgetIx = web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
+        units: 1000000,
+    });
+    builtTx.instructions.unshift(computeBudgetIx);
+    // Populate feePayer + recentBlockhash so the wallet only has to sign.
+    const provider = program.provider;
+    builtTx.feePayer = depositorPubkey;
+    const { blockhash } = await provider.connection.getLatestBlockhash();
+    builtTx.recentBlockhash = blockhash;
+    const commit = () => {
+        const { index: outIdx0 } = tree.insert(outputUTXOs[0].commitment);
+        const { index: outIdx1, root: newRoot } = tree.insert(outputUTXOs[1].commitment);
+        return {
+            outputUTXOs,
+            leafIndices: [outIdx0, outIdx1],
+            root: newRoot,
+        };
+    };
+    return {
+        transaction: builtTx,
+        outputUTXOs,
+        commit,
+    };
+}
+/**
+ * Result of a withdrawal operation.
+ */

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

@@ -0,0 +1,7 @@
+export * from "./transact.js";
+export * from "./deposit.js";
+export * from "./withdraw.js";
+export * from "./transfer.js";
+export * from "./swap.js";
+export { buildTransactInstruction as buildRawTransactInstruction, TRANSACT_ACCOUNT_NAMES, } from "../shield/ix.js";
+export type { TransactAccounts as RawTransactAccounts, TransactArgs as RawTransactArgs, } from "../shield/ix.js";

package/dist/cjs/transactions/index.js

@@ -0,0 +1,26 @@
+"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 });
+exports.TRANSACT_ACCOUNT_NAMES = exports.buildRawTransactInstruction = void 0;
+__exportStar(require("./transact.js"), exports);
+__exportStar(require("./deposit.js"), exports);
+__exportStar(require("./withdraw.js"), exports);
+__exportStar(require("./transfer.js"), exports);
+__exportStar(require("./swap.js"), exports);
+// Raw IDL-correct builder for custom v0/ALT transaction composition.
+var ix_js_1 = require("../shield/ix.js");
+Object.defineProperty(exports, "buildRawTransactInstruction", { enumerable: true, get: function () { return ix_js_1.buildTransactInstruction; } });
+Object.defineProperty(exports, "TRANSACT_ACCOUNT_NAMES", { enumerable: true, get: function () { return ix_js_1.TRANSACT_ACCOUNT_NAMES; } });

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

@@ -0,0 +1,71 @@
+import type { Idl, Program } from "@coral-xyz/anchor";
+import { Keypair, PublicKey, type AccountMeta, type TransactionInstruction } from "@solana/web3.js";
+import type { ExtData, TransactionProofStruct } from "../proofs/types.js";
+import type { NoteCiphers } from "../compactNote.js";
+/** Seeds: ["swap_executor", source_mint, dest_mint, nullifier_0, relayer]. */
+export declare function getSwapExecutorPda(programId: PublicKey, sourceMint: PublicKey, destMint: PublicKey, inputNullifier0: Uint8Array, relayer: PublicKey): PublicKey;
+/** Build `fund_native_source`. It must immediately precede `transact_swap`. */
+export declare function fundNativeSource<T extends Idl>(params: {
+    program: Program<T>;
+    relayer: {
+        publicKey: PublicKey;
+    };
+    sourceMint: PublicKey;
+    destMint: PublicKey;
+    inputNullifier0: Uint8Array;
+    swapAmount: bigint;
+    /** Wrapped-native mint used by the DEX. Defaults to canonical WSOL. */
+    sourceMintAccount?: PublicKey;
+}): Promise<TransactionInstruction>;
+export type SwapProofStruct = TransactionProofStruct;
+/** Fields in the current IDL's `SwapParams` struct. */
+export type SwapParams = {
+    minAmountOut: bigint;
+    deadline: bigint;
+    destAmount: bigint;
+    /** SHA-256 of the exact DEX instruction bytes passed as `swapData`. */
+    swapDataHash: Uint8Array;
+};
+export type TransactSwapParams<T extends Idl = Idl> = {
+    program: Program<T>;
+    relayer: {
+        publicKey: PublicKey;
+    };
+    sourceMint: PublicKey;
+    destMint: PublicKey;
+    sourceRoot: Uint8Array;
+    sourceTreeId: number;
+    destTreeId: number;
+    inputNullifiers: [Uint8Array, Uint8Array];
+    /** Output 0 is source-mint change; output 1 is the destination note. */
+    outputCommitments: [Uint8Array, Uint8Array];
+    proof: SwapProofStruct;
+    swapParams: SwapParams;
+    swapAmount: bigint;
+    /** Exact raw data from the DEX/Jupiter instruction. */
+    swapData: Uint8Array | Buffer;
+    extData: ExtData;
+    noteCiphers?: NoteCiphers | null;
+    sourceVaultTokenAccount: PublicKey;
+    /** Actual DEX source mint (WSOL for the native-SOL pool sentinel). */
+    sourceMintAccount: PublicKey;
+    destVaultTokenAccount: PublicKey;
+    /** Actual DEX destination mint (WSOL for the native-SOL pool sentinel). */
+    destMintAccount: PublicKey;
+    relayerTokenAccount: PublicKey;
+    swapProgram: PublicKey;
+    jupiterEventAuthority: PublicKey;
+    /** Preserve the DEX instruction's account order and duplicates exactly. */
+    remainingAccounts?: AccountMeta[];
+};
+/** Build the current IDL's `transact_swap` instruction without submitting it. */
+export declare function buildTransactSwapInstruction<T extends Idl>(params: TransactSwapParams<T>): Promise<TransactionInstruction>;
+/** Build the atomic instruction sequence, including native-source funding. */
+export declare function buildPrivateSwapInstructions<T extends Idl>(params: TransactSwapParams<T>): Promise<TransactionInstruction[]>;
+/**
+ * Submit the parity-correct instructions as a legacy transaction. For Jupiter
+ * routes, prefer `buildPrivateSwapInstructions` and compile v0 with route ALTs.
+ */
+export declare function transactSwap<T extends Idl>(params: TransactSwapParams<T> & {
+    relayer: Keypair;
+}): Promise<string>;