veilix-sdk 0.0.10 → 0.2.0

package/dist/VeilixSDK-D1hKisoi.d.ts

@@ -0,0 +1,781 @@
+import { PublicKey, Keypair, Connection, TransactionInstruction, VersionedTransaction, Transaction } from '@solana/web3.js';
+import { Buffer as Buffer$1 } from 'buffer';
+import { MerkleTree } from 'fixed-merkle-tree';
+import { OracleJob } from '@switchboard-xyz/common';
+import { Program } from '@coral-xyz/anchor';
+import { Wallet } from '@coral-xyz/anchor/dist/cjs/provider';
+import { C as CircuitPaths } from './constants-C-u6nmCv.js';
+
+type VeilixMerkleTree = MerkleTree;
+/** Rebuild an asset tree from its leaves (commitments in index order). */
+declare function buildMerkleTree(leaves: Array<bigint | string>): VeilixMerkleTree;
+
+/**
+ * Shielded (note-owning) keypair. Not a Solana keypair:
+ *   privKey: random field element, pubKey = Poseidon(privKey)
+ * The private key is only needed to spend notes (it derives the nullifier inside the proof).
+ */
+declare class VeilixKeypair {
+    readonly privKey: bigint;
+    readonly pubKey: bigint;
+    private constructor();
+    static fromPrivateKey(privKey: bigint | string): VeilixKeypair;
+    static random(): VeilixKeypair;
+    /** Deterministic keypair from a wallet signature over a fixed message. */
+    static fromSignature(signature: Uint8Array): Promise<VeilixKeypair>;
+    sign(commitment: bigint, leafIndex: number): bigint;
+}
+
+/** Circuit encoding of a mint: 0 for SOL, first 31 bytes of the mint pubkey otherwise. */
+declare function mintToField(mint: PublicKey | null): bigint;
+/**
+ * A shielded note (UTXO).
+ *   commitment = Poseidon(amount, pubKey, blinding, mint)
+ *   nullifier  = Poseidon(commitment, index, Poseidon(privKey, commitment, index))
+ * `index` is the leaf index in the asset tree, known once the note has been inserted.
+ * `mint` is `null` for SOL.
+ */
+declare class Utxo {
+    readonly amount: bigint;
+    readonly blinding: bigint;
+    readonly keypair: VeilixKeypair;
+    readonly mint: PublicKey | null;
+    index: number | null;
+    constructor({ amount, keypair, blinding, mint, index, }?: {
+        amount?: bigint | number | string;
+        keypair?: VeilixKeypair;
+        blinding?: bigint;
+        mint?: PublicKey | null;
+        index?: number | null;
+    });
+    /** Zero-amount note used to fill unused input/output slots. */
+    static zero(mint: PublicKey | null): Utxo;
+    commitment(): bigint;
+    /** Requires {@link index}; zero-amount padding inputs use index 0. */
+    nullifier(): bigint;
+}
+
+/** Matches `TransactionProof` in the program. */
+type TransactionProof = {
+    proof: number[];
+    root: number[];
+    inputNullifiers: number[][];
+    outputCommitments: number[][];
+};
+/** Data bound to the proof through `extDataHash`; mirrors `ExtData` in the program. */
+type ExtData = {
+    /** `null` for SOL. */
+    mint: PublicKey | null;
+    recipient: PublicKey;
+    relayer: PublicKey;
+    /** Positive for deposits, negative for withdrawals. */
+    extAmount: bigint;
+    fee: bigint;
+    encryptedOutput1: Uint8Array;
+    encryptedOutput2: Uint8Array;
+};
+type CircuitArtifactPaths = {
+    wasmPath: string;
+    zkeyPath: string;
+};
+type ProvedTransaction = {
+    proof: TransactionProof;
+    /** Padded to 2 inputs / 2 outputs; outputs carry their optimistic leaf index. */
+    inputs: Utxo[];
+    outputs: Utxo[];
+    /** Public signal values (decimal strings) in circuit order. */
+    publicSignals: string[];
+};
+/** sha256(borsh(ExtData)) with the first byte zeroed, as computed on-chain. */
+declare function extDataHash(ext: ExtData): Promise<bigint>;
+/**
+ * Build and prove a 2-in / 2-out transaction.
+ *
+ * Deposit:  extAmount = +amount, fee = 0, recipient = relayer = depositor, zero-amount inputs.
+ * Withdraw: extAmount = -amount, recipient receives amount - fee, relayer = relayer rewardAccount.
+ *
+ * `tree` is required when spending notes; deposits only need a `root` from the
+ * on-chain root history.
+ */
+declare function proveTransaction({ tree, root, nextIndex, inputs, outputs, ext, circuit, }: {
+    tree?: VeilixMerkleTree;
+    root?: bigint;
+    /** Leaf index the first output will get (defaults to the tree size). */
+    nextIndex?: number;
+    inputs?: Utxo[];
+    outputs?: Utxo[];
+    ext: ExtData;
+    circuit: CircuitArtifactPaths;
+}): Promise<ProvedTransaction>;
+
+/** Prefix of secret notes for the UTXO pool. */
+declare const NOTE_PREFIX = "vx2";
+type ParsedNote = {
+    /** Base units (lamports / token smallest units), decimal string. */
+    amount: string;
+    /** Token mint, `null` for SOL. */
+    mint: string | null;
+    /** Poseidon commitment (decimal string); independent of the leaf index. */
+    commitment: string;
+    /** `0x`-prefixed 32-byte commitment (indexer format). */
+    commitmentHex: string;
+    privKey: string;
+    pubKey: string;
+    blinding: string;
+};
+/** Secret note: `vx2-<amountHex>-<privKeyHex>-<blindingHex>[-<mint>]`. */
+declare function encodeNote(utxo: Utxo): string;
+declare function isLegacyNote(note: string): boolean;
+/** Note string → UTXO. The leaf index is unknown until looked up in the tree. */
+declare function decodeNote(note: string): Utxo;
+declare function parseSecretNote(note: string): ParsedNote;
+/**
+ * `encryptedOutput` for the program: the note secret sealed with the wallet
+ * encryption key, so the owner can rediscover the note by scanning the tree.
+ * The mint is implied by the tree the output is appended to.
+ */
+declare function encryptNoteOutput(key: Uint8Array, utxo: Utxo): Uint8Array;
+/** Returns the note if `encryptedOutput` was sealed with `key`, otherwise `null`. */
+declare function decryptNoteOutput(key: Uint8Array, encryptedOutput: Uint8Array, mint: PublicKey | null, index: number): Utxo | null;
+/** Truncate each note segment for display. */
+declare function formatNoteForDisplay(note: string, segmentLen?: number): string;
+
+type PreparedCircuitArtifacts = {
+    wasmPath: string;
+    zkeyPath: string;
+    /** Revokes the browser object URLs. `null` outside the browser. */
+    cleanup: (() => void) | null;
+};
+type GenerateDepositParamsResult = {
+    params: ParsedNote;
+    note: string;
+};
+/**
+ * Fetch and integrity-check the transaction circuit artifacts once so that
+ * several proofs can share them. Call `cleanup` after the last proof has settled.
+ */
+declare function prepareCircuitArtifacts(circuitWasmPath?: string, circuitZkeyPath?: string): Promise<PreparedCircuitArtifacts>;
+
+type TreeAccountState = {
+    address: PublicKey;
+    /** `null` for SOL. */
+    mint: PublicKey | null;
+    nextIndex: number;
+    maxDepositAmount: bigint;
+    /** Current root (big-endian field element). */
+    root: bigint;
+    /** Root history accepted by the program (most recent first). */
+    roots: bigint[];
+};
+type PlatformFeeWallet = {
+    address: string;
+    /** Basis points of the withdrawn amount. */
+    feeSplit: number;
+};
+type BuildDepositTxParams = {
+    senderPublicKey: PublicKey | string;
+    /** Note from {@link generateDepositParams}. */
+    note: string;
+    /**
+     * Seal the note into the deposit's on-chain encrypted output with the wallet
+     * encryption key (see `getEncryptionKey`), so it can be recovered by scanning.
+     */
+    onChainBackup?: boolean;
+    /** Priority fee in micro-lamports per compute unit. */
+    computeUnitPrice?: number;
+    computeUnitLimit?: number;
+    /** Shared, already verified circuit artifacts (see `prepareCircuitArtifacts`). */
+    circuitArtifacts?: PreparedCircuitArtifacts;
+};
+/** Body of the relayer `POST /relay` (also one item of indexer `POST /submit`). */
+type RelayPayload = {
+    proof: string;
+    root: string;
+    inputNullifiers: [string, string];
+    outputCommitments: [string, string];
+    amount: string;
+    fee: string;
+    recipient: string;
+    relayer: string;
+    encryptedOutput1: string;
+    encryptedOutput2: string;
+    mint?: string;
+};
+type BuildRelayPayloadParams = {
+    proof: TransactionProof;
+    /** Withdrawn amount (base units), before fees. */
+    amount: bigint;
+    fee: bigint;
+    recipient: PublicKey | string;
+    /** Relayer `rewardAccount`. */
+    relayer: PublicKey | string;
+    encryptedOutput1: Uint8Array;
+    encryptedOutput2: Uint8Array;
+    mint?: PublicKey | string | null;
+};
+type RelayerJob = {
+    id: string;
+    status: "QUEUED" | "ACCEPTED" | "SENT" | "MINED" | "CONFIRMED" | "FAILED" | string;
+    txHash?: string;
+    failedReason?: string;
+    [key: string]: unknown;
+};
+/** Frontend wallet adapter or backend {@link Keypair}. */
+type EncryptKeyWallet = Keypair | {
+    signMessage: (message: Uint8Array) => Promise<Uint8Array> | Uint8Array;
+};
+declare function encryptData(key: Uint8Array, plaintext: string): Buffer$1;
+declare function decryptData(key: Uint8Array, combined: Uint8Array): string;
+
+/**
+ * Indexer asset selector: an asset label (`"SOL"`, `"VEILIX"`, ...), a mint
+ * address, or `{ mint }` / `{ asset }`. Defaults to SOL.
+ */
+type IndexerAsset = string | {
+    mint?: string | null;
+    asset?: string;
+} | null;
+
+type IndexedLeaf = {
+    index: number;
+    /** `0x`-prefixed 32-byte commitment. */
+    commitment: string;
+    /** `0x`-prefixed hex (may be `"0x"` when empty). Present when requested. */
+    encryptedOutput?: string;
+};
+type TreeState = {
+    asset: string;
+    mint: string | null;
+    address: string;
+    exists: boolean;
+    nextIndex: number;
+    root: string;
+    maxDepositAmountRaw: string;
+    maxDepositAmount: number;
+    decimals: number;
+    indexedLeafCount: number;
+    synced: boolean;
+};
+type SpentIn = {
+    kind: "Deposit" | "Withdraw";
+    signature: string;
+    asset?: string;
+    [key: string]: unknown;
+};
+type NullifierStatus = {
+    nullifier: string;
+    hexNullifier: string;
+    exists: boolean;
+    spentIn: SpentIn | null;
+};
+type CommitmentStatus = {
+    commitment: string;
+    hexCommitment: string;
+    asset: string;
+    exists: boolean;
+    valid: boolean;
+    index: number | null;
+    kind: "Deposit" | "Withdraw" | null;
+    signature: string | null;
+};
+type PoolTransaction = {
+    signature: string;
+    mint?: string | null;
+    amount?: string | number;
+    fee?: string | number;
+    recipient?: string;
+    signer?: string;
+    inputNullifiers: string[];
+    commitments: string[];
+    timestamp?: number | string;
+    [key: string]: unknown;
+};
+type TxStatus = {
+    asset: string;
+    commitment: string | null;
+    normalizedCommitment: string | null;
+    nullifier: string | null;
+    normalizedNullifier: string | null;
+    isDeposited: boolean;
+    leaf: {
+        index: number;
+        commitment: string;
+        kind?: string;
+        signature?: string;
+        [key: string]: unknown;
+    } | null;
+    isSpent: boolean;
+    spendingTransaction: PoolTransaction | null;
+};
+type SubmissionItem = {
+    index: number;
+    asset: string | null;
+    mint: string | null;
+    recipient: string;
+    amount: string;
+    fee: string;
+    inputNullifiers: string[];
+    status: "queued" | "processing" | "completed" | "failed";
+    relayerUrl: string | null;
+    relayer: string | null;
+    relayerJobId: string | null;
+    withdrawTxId: string | null;
+    error: string | null;
+    attempts: number;
+};
+type Submission = {
+    success: boolean;
+    partialSuccess: boolean;
+    submissionId: string;
+    requestId: string | null;
+    status: "queued" | "processing" | "completed" | "partial" | "failed";
+    asset: string;
+    network: string;
+    recipient: string;
+    proofCount: number;
+    items: SubmissionItem[];
+    message?: string;
+};
+type FetchWalletBalanceOptions = {
+    includeDeposits?: boolean;
+    indexerAsset?: IndexerAsset;
+};
+
+type NoteStatus = {
+    note: string;
+    /** Base units, decimal string. */
+    amount: string;
+    /** `null` for SOL. */
+    mint: string | null;
+    /** Indexer asset of the note's tree. */
+    asset: string;
+    commitment: string;
+    /** Inserted in the tree (indexed). */
+    deposited: boolean;
+    index: number | null;
+    /** Known once the note is in the tree. */
+    nullifier: string | null;
+    spent: boolean;
+    spentIn: SpentIn | null;
+    /** Deposit / withdraw signature that inserted the note. */
+    signature: string | null;
+};
+type ScanOwnedNotesOptions = {
+    /** Tree mints to scan (`null` = SOL). Defaults to SOL and every configured token. */
+    mints?: Array<string | null>;
+    /** Include spent notes (default `false`). */
+    includeSpent?: boolean;
+};
+
+type Network = "mainnet" | "devnet";
+declare const MAINNET_TOKEN_MINTS: {
+    readonly Veilix: "GAFN64LvtCBoc5BHncVn3JEJGpq42rUzQjPmvMK2UhZH";
+    readonly Bitcoin: "3NZ9JMVBmGAqocybic2c7LQCJScmgsAZ6vQqTDzcqmJh";
+    readonly Ethereum: "7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs";
+    readonly USDC: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+};
+type TokenSymbol = keyof typeof MAINNET_TOKEN_MINTS;
+declare const TOKEN_DECIMALS: {
+    readonly Solana: 9;
+    readonly Veilix: 9;
+    readonly Ethereum: 8;
+    readonly Bitcoin: 8;
+    readonly USDC: 6;
+};
+type TokenDecimalsSymbol = keyof typeof TOKEN_DECIMALS;
+
+type Relayer = {
+    isValid: true;
+    label: string;
+    url: string;
+    key: number;
+    value: string;
+    fee: unknown;
+    recentActivities: unknown;
+    userPubkey: unknown;
+    workers: unknown;
+    totalFeeEarningsSol: unknown;
+    totalWithdrawCount: unknown;
+    stakedAmount: unknown;
+    volume24hSol: unknown;
+    volume7dSol: unknown;
+};
+
+interface VeilixSdkInitOptions {
+    /** Wallet for Anchor provider transactions. */
+    wallet: Wallet;
+    /**
+     * Solana JSON-RPC endpoint (Node/scripts). Omit when passing {@link connection}
+     * from `@solana/wallet-adapter-react` (`useConnection()`).
+     */
+    rpcEndpoint?: string;
+    /** Existing connection (e.g. `useConnection()` in React). */
+    connection?: Connection;
+    /**
+     * Cluster override when the RPC URL does not contain `devnet` / `mainnet` hints
+     * (common with private RPC providers).
+     */
+    network: Network;
+    /**
+     * Base URL/path for withdraw circuit artifacts in the browser.
+     * Defaults to `/node_modules/<pkg>/dist/circuits/` on localhost and the
+     * pinned, SHA-256-verified jsDelivr CDN in production (domain-independent).
+     * Set this to self-host instead, e.g. `"/circuits/"` (verified, with CDN fallback)
+     * or `"https://cdn.example.com/veilix/circuits/"`.
+     */
+    circuitPathsBase?: string;
+    /** Indexer base URL override (defaults to the Veilix indexer of {@link network}). */
+    indexerUrl?: string;
+    /** Address-risk API base URL override. */
+    riskApiUrl?: string;
+}
+interface VeilixSdkRuntimeConfig {
+    rpcEndpoint: string;
+    /** Cluster inferred from {@link rpcEndpoint}. */
+    network: Network;
+    programId: string;
+    indexerUrl: string;
+    riskApiUrl: string;
+    /** Active relayers for {@link network}, loaded at SDK initialization. */
+    relayers: Relayer[];
+    connection: Connection;
+    wallet: Wallet;
+    program: Program;
+    /** Set by {@link VeilixSDK.getEncryptionKey}; required for on-chain note backup. */
+    encryptKey?: Uint8Array;
+    /** Resolved withdraw circuit wasm/zkey URLs for browser proof generation. */
+    circuitPaths?: CircuitPaths;
+}
+
+type WithdrawParams = {
+    /** Secret note to spend. */
+    note: string;
+    /** Withdrawal recipient public key. */
+    recipient: PublicKey | string;
+    /**
+     * Amount to withdraw in base units (before fees). Defaults to the full note.
+     * A partial withdrawal returns the rest as {@link WithdrawResult.changeNote}.
+     */
+    amount?: bigint | number | string;
+    /** Use this relayer instead of a random / indexed one. */
+    relayerUrl?: string;
+    /** Skip the recipient risk check (already done by the caller). */
+    skipRiskCheck?: boolean;
+};
+type WithdrawStatus = "success" | "failed";
+type WithdrawResult = {
+    txHash: string;
+    status: WithdrawStatus;
+    /** Relayer failure reason when `status` is `"failed"`. */
+    error?: string;
+    /** Remaining balance of a partial withdrawal (save it like any other note). */
+    changeNote: string | null;
+    amount: string;
+    fee: string;
+};
+type WithdrawRelayBundle = {
+    payload: RelayPayload;
+    relayerUrl: string;
+    amount: bigint;
+    fee: bigint;
+    changeNote: string | null;
+    /** Input nullifiers (`0x` hex) spent by this withdrawal. */
+    nullifiers: string[];
+};
+type BuildWithdrawPayloadOptions = {
+    relayerIdx?: number;
+    circuitArtifacts?: PreparedCircuitArtifacts;
+    /** Reuse a tree already built for this asset (several withdrawals at once). */
+    tree?: VeilixMerkleTree;
+    platformWallets?: PlatformFeeWallet[];
+};
+
+type QuoteRelayer = {
+    url: string;
+    /** Pubkey to put in the proof's `relayer` field. */
+    rewardAccount: string;
+    userPubkey: string | null;
+    network: string | null;
+    currentQueue: number;
+};
+type QuoteTransaction = {
+    kind: "withdraw";
+    programId: string;
+    instruction: "withdraw" | "tokenWithdraw";
+    unsigned: boolean;
+};
+/** Fee quote for one withdrawal. `*Raw` fields are base-unit decimal strings. */
+type Quote = {
+    asset: string;
+    mint: string | null;
+    decimals: number;
+    network: string | null;
+    recipient: string | null;
+    amount: string;
+    amountRaw: string;
+    fee: string;
+    feeRaw: string;
+    relayerFee: string;
+    relayerFeeRaw: string;
+    platformFee: string;
+    platformFeeRaw: string;
+    recipientAmount: string;
+    recipientAmountRaw: string;
+    relayerFeeBps: number;
+    platformFeeBps: number;
+    etaSeconds: number;
+    quotedAt: string;
+    expiresAt: string;
+    relayer: QuoteRelayer;
+    tree: {
+        address: string;
+        nextIndex: number;
+        root: string;
+    };
+    transaction: QuoteTransaction;
+};
+type GetQuoteResponse = {
+    success: boolean;
+    quote: Quote;
+};
+type GetQuoteParams = {
+    /** Human-readable amount (e.g. `"1.5"`). Ignored when {@link amountRaw} is set. */
+    amount?: number | string;
+    /** Amount in base units (lamports / token smallest units). */
+    amountRaw?: number | string | bigint;
+    recipient?: PublicKey | string;
+    /** Indexer asset label or mint (default `SOL`). */
+    asset?: IndexerAsset;
+    /** Cluster for the quote (default: active SDK network). */
+    network?: Network;
+    /** Quote a specific relayer. */
+    relayerUrl?: string;
+};
+/** Fetch a withdraw quote (relayer + platform fees) from the indexer. */
+declare function getQuote(params: GetQuoteParams): Promise<GetQuoteResponse>;
+
+type ResolvedNoteAsset = {
+    key: string;
+    tokenName: TokenDecimalsSymbol;
+    unit: string;
+    multiplier: bigint;
+    /** `null` for SOL. */
+    mint: string | null;
+    decimals: number;
+    /** Indexer `asset` parameter for this tree. */
+    indexerAsset: string;
+};
+
+type VeilixTransferItem = {
+    /** Token mint (wrapped SOL mint for SOL). */
+    mint: PublicKey;
+    /** Human-readable token amount (e.g. `"1.5"` SOL). */
+    amount: string;
+    recipient: PublicKey;
+};
+type VeilixTransferDepositFailure = {
+    amount: string;
+    mint: string;
+    recipient: string;
+    error?: string;
+};
+type VeilixTransferWithdrawFailure = {
+    /** Deposited note that was not withdrawn; the funds stay spendable with it. */
+    note: string;
+    recipient: string;
+    error?: string;
+};
+type VeilixTransferResult = {
+    error: boolean;
+    depositFailed: VeilixTransferDepositFailure[];
+    withdrawFailed: VeilixTransferWithdrawFailure[];
+    /** Deposit transaction signatures. */
+    depositSuccess: string[];
+    /** Withdraw transaction signatures. */
+    withdrawSuccess: string[];
+    /** Every note created by this transfer. */
+    notes: string[];
+};
+type VeilixTransferOptions = {
+    /** When true, all withdraws use the same randomly selected relayer. */
+    uniqueRelayer?: boolean;
+    /**
+     * Seal each note into its deposit's encrypted output (requires
+     * `getEncryptionKey`). Defaults to `true` when an encryption key is set.
+     */
+    onChainBackup?: boolean;
+    /** Download the notes as CSV before sending the deposits (default `true`). */
+    downloadNotes?: boolean;
+};
+
+/**
+ * Veilix SDK client. Create one instance per configuration (network, RPC, wallet).
+ *
+ * @example
+ * ```ts
+ * import { VeilixSDK } from "veilix-sdk";
+ * const sdk = await VeilixSDK.create({ connection, wallet, network: "devnet" });
+ * await sdk.getEncryptionKey(wallet);
+ * const { note } = sdk.generateDepositParams(1_500_000_000n, null); // 1.5 SOL
+ * const tx = await sdk.buildDepositTx({ senderPublicKey: wallet.publicKey, note, onChainBackup: true });
+ * // sign + send `tx`, then later:
+ * const { txHash } = await sdk.withdraw({ note, recipient });
+ * ```
+ */
+declare class VeilixSDK {
+    static readonly VERSION: string;
+    readonly config: VeilixSdkRuntimeConfig;
+    private constructor();
+    /** Create an SDK instance (loads relayers for the network). */
+    static create(options: VeilixSdkInitOptions): Promise<VeilixSDK>;
+    private run;
+    private runAsync;
+    getConfig(): VeilixSdkRuntimeConfig;
+    getRpcEndpoint(): string;
+    getNetwork(): Network;
+    getProgramIdString(): string;
+    /** Encryption key derived by {@link getEncryptionKey}; undefined until set. */
+    get encryptKey(): Uint8Array | undefined;
+    /** Relayers loaded at initialization; use {@link fetchRelayers} to refresh. */
+    get relayers(): Relayer[];
+    getIndexerUrl(): string;
+    getRiskApiUrl(): string;
+    getTokenMints(): {
+        Solana: string;
+        Veilix: "GAFN64LvtCBoc5BHncVn3JEJGpq42rUzQjPmvMK2UhZH";
+        Bitcoin: "" | "3NZ9JMVBmGAqocybic2c7LQCJScmgsAZ6vQqTDzcqmJh";
+        Ethereum: "" | "7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs";
+        USDC: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v" | "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU";
+    };
+    getVeilixTokenMint(): string;
+    getTokenMint(symbol: TokenSymbol): string;
+    getTokenDecimals(symbol: TokenDecimalsSymbol): number;
+    resolveCircuitPaths(base?: string): Promise<CircuitPaths>;
+    getRangeRiskScoreJob(address: string): OracleJob;
+    getOracleQuote(payer: Keypair | PublicKey, addressToCheck: string): Promise<{
+        queueAccount: PublicKey;
+        sigVerifyIx: TransactionInstruction;
+    }>;
+    getProgramId(): PublicKey;
+    /** Asset tree PDA (`null` = SOL). */
+    getTreePDA(mint?: PublicKey | string | null): [PublicKey, number];
+    getTreasuryPDA(): [PublicKey, number];
+    getNullifierPDA(nullifier: bigint | number | string | Uint8Array | number[]): [PublicKey, number];
+    getNetworkStatePDA(): [PublicKey, number];
+    getNotesPDA(user: PublicKey | string): [PublicKey, number];
+    /** On-chain tree state (root, next leaf index, deposit limit); `null` if missing. */
+    fetchTreeAccount(mint?: PublicKey | string | null): Promise<TreeAccountState | null>;
+    /** Total platform fee in percent, e.g. `"0.3"`. */
+    fetchPlatformFee(): Promise<string>;
+    fetchPlatformFeeWallets(): Promise<PlatformFeeWallet[]>;
+    /** Withdraw fee as enforced on-chain for `amount` base units. */
+    computeWithdrawFee(amount: bigint, relayerFeePercent: number | string, platformWallets: PlatformFeeWallet[]): {
+        fee: bigint;
+        relayerFee: bigint;
+        platformFee: bigint;
+    };
+    /** New note for `amount` base units of `mint` (`null` = SOL). */
+    generateDepositParams(amount: bigint | number | string, mint?: string | null): GenerateDepositParamsResult;
+    /**
+     * Proves and builds the unsigned deposit transaction for `note`
+     * (sign with the sender wallet and send).
+     */
+    buildDepositTx(params: BuildDepositTxParams): Promise<VersionedTransaction>;
+    /** Transaction storing encrypted notes in the wallet's `notes_v2` backup account. */
+    buildBackupNotesTx(senderPublicKey: PublicKey | string, notes: string[]): Promise<Transaction>;
+    /**
+     * Withdraw a note to `recipient` through a relayer (random, or `relayerIdx`
+     * into {@link relayers}). Fees are deducted from the withdrawn amount.
+     */
+    withdraw(params: WithdrawParams, relayerIdx?: number): Promise<WithdrawResult>;
+    /** Prove a withdrawal without submitting it (see {@link submitWithdrawPayload}). */
+    buildWithdrawPayload(params: WithdrawParams, options?: BuildWithdrawPayloadOptions): Promise<WithdrawRelayBundle>;
+    submitWithdrawPayload(bundle: WithdrawRelayBundle): Promise<WithdrawResult>;
+    /**
+     * Private transfer: deposit one note per item, then withdraw each note in full
+     * to its recipient through the indexer submission queue.
+     */
+    veilixTransfer(items: VeilixTransferItem[], options?: VeilixTransferOptions): Promise<VeilixTransferResult>;
+    /** Validate a withdraw recipient against the risk API. */
+    assertWithdrawRecipientAllowed(address: string): Promise<void>;
+    /** Fetch a withdraw quote from the indexer. */
+    getQuote(params: GetQuoteParams): Promise<GetQuoteResponse>;
+    parseSecretNote(note: string): ParsedNote;
+    /** `true` for notes of the retired fixed-denomination pools. */
+    isLegacyNote(note: string): boolean;
+    formatNoteForDisplay(note: string, segmentLen?: number): string;
+    /** Asset (token, decimals, indexer asset) of a note mint (`null` = SOL). */
+    resolveNoteAsset(mint?: string | null): ResolvedNoteAsset;
+    /** Deposit / spent status of a note. */
+    getNoteStatus(note: string): Promise<NoteStatus>;
+    getNotesStatus(notes: string[]): Promise<NoteStatus[]>;
+    /**
+     * Recover notes sealed with the wallet encryption key (deposits with
+     * `onChainBackup` and change notes). Requires {@link getEncryptionKey}.
+     */
+    scanOwnedNotes(options?: ScanOwnedNotesOptions): Promise<NoteStatus[]>;
+    fetchCommitments(indexerAsset: IndexerAsset, options?: {
+        fromIndex?: number;
+        includeEncrypted?: boolean;
+    }): Promise<IndexedLeaf[]>;
+    fetchTreeState(indexerAsset: IndexerAsset): Promise<TreeState>;
+    validateNullifier(nullifier: string | bigint): Promise<NullifierStatus>;
+    validateNullifiers(nullifiers: Array<string | bigint>): Promise<NullifierStatus[]>;
+    validateCommitment(commitment: string | bigint, indexerAsset: IndexerAsset): Promise<CommitmentStatus>;
+    fetchTxStatus(params: {
+        commitment?: string | bigint;
+        nullifier?: string | bigint;
+        indexerAsset?: IndexerAsset;
+    }): Promise<TxStatus>;
+    fetchDepositCountByCommitment(commitment: string | bigint, indexerAsset: IndexerAsset): Promise<{
+        index: number | null;
+        leafCountAfterMine: number;
+        depositCountAfterMine: number;
+    }>;
+    fetchWalletBalance(wallet: string, options?: FetchWalletBalanceOptions): Promise<{
+        wallet: string;
+        asset: string;
+        totalDeposited: string | number;
+        totalDeposits: number;
+        deposits: PoolTransaction[];
+    }>;
+    /** Re-fetch relayers from the indexer and update {@link config.relayers}. */
+    fetchRelayers(): Promise<Relayer[]>;
+    fetchLatestTransactions(type?: "Deposit" | "Withdraw", indexerAsset?: IndexerAsset): Promise<PoolTransaction[]>;
+    fetchTxCounts(type?: "Deposit" | "Withdraw", indexerAsset?: IndexerAsset): Promise<{
+        count: number;
+        amount: string | number;
+    }>;
+    fetchPoolActivity(): Promise<{
+        data: unknown[];
+        updatedAt: string;
+    }>;
+    fetchSubmission(submissionId: string): Promise<Submission>;
+    normalizePubkeyString(value: unknown): string;
+    buildRelayPayload(params: BuildRelayPayloadParams): RelayPayload;
+    submitToRelayer(relayerUrl: string, payload: RelayPayload): Promise<{
+        id: string;
+    }>;
+    pollRelayerJob(relayerUrl: string, jobId: string, maxWaitMs?: number): Promise<RelayerJob>;
+    /**
+     * Derives the note encryption key from a wallet signature and stores it on
+     * {@link config.encryptKey}. Required for `onChainBackup`, change-note
+     * recovery and {@link scanOwnedNotes}.
+     *
+     * Accepts a frontend wallet adapter (`signMessage`) or a backend {@link Keypair}.
+     */
+    getEncryptionKey(wallet: EncryptKeyWallet): Promise<Uint8Array>;
+    encryptData(key: Uint8Array, plaintext: string): Buffer<ArrayBufferLike>;
+    decryptData(key: Uint8Array, combined: Uint8Array): string;
+    parseAmountToBaseUnits(amount: string | number, decimals: number): bigint;
+    formatBaseUnits(value: bigint | string | number, decimals: number): string;
+    convertProofToBytes(proof: unknown): Promise<number[]>;
+    to32ByteBuffer(value: bigint | number | string): Uint8Array<ArrayBufferLike>;
+    toFixedHex(value: bigint | number | string, length?: number): string;
+    toFieldElementHex(value: bigint | number | string): string;
+    appendIndexerAsset(params: URLSearchParams, indexerAsset?: IndexerAsset): void;
+    /** Program ID for a cluster without an SDK instance. */
+    static getProgramIdForNetwork(network: Network): string;
+}
+
+export { decodeNote as $, VeilixSDK as A, type BuildDepositTxParams as B, type CommitmentStatus as C, type VeilixSdkInitOptions as D, type EncryptKeyWallet as E, type FetchWalletBalanceOptions as F, type GenerateDepositParamsResult as G, type VeilixSdkRuntimeConfig as H, type IndexedLeaf as I, type VeilixTransferDepositFailure as J, type VeilixTransferItem as K, type VeilixTransferOptions as L, type VeilixTransferResult as M, NOTE_PREFIX as N, type VeilixTransferWithdrawFailure as O, type ParsedNote as P, type Quote as Q, type RelayPayload as R, type ScanOwnedNotesOptions as S, type TokenDecimalsSymbol as T, Utxo as U, VeilixKeypair as V, type WithdrawParams as W, type WithdrawRelayBundle as X, type WithdrawResult as Y, type WithdrawStatus as Z, buildMerkleTree as _, type BuildRelayPayloadParams as a, decryptData as a0, decryptNoteOutput as a1, encodeNote as a2, encryptData as a3, encryptNoteOutput as a4, extDataHash as a5, formatNoteForDisplay as a6, getQuote as a7, isLegacyNote as a8, mintToField as a9, parseSecretNote as aa, prepareCircuitArtifacts as ab, proveTransaction as ac, type BuildWithdrawPayloadOptions as b, type ExtData as c, type GetQuoteParams as d, type GetQuoteResponse as e, type IndexerAsset as f, type Network as g, type NoteStatus as h, type NullifierStatus as i, type PlatformFeeWallet as j, type PoolTransaction as k, type PreparedCircuitArtifacts as l, type ProvedTransaction as m, type QuoteRelayer as n, type QuoteTransaction as o, type Relayer as p, type RelayerJob as q, type ResolvedNoteAsset as r, type Submission as s, type SubmissionItem as t, type TokenSymbol as u, type TransactionProof as v, type TreeAccountState as w, type TreeState as x, type TxStatus as y, type VeilixMerkleTree as z };