veilix-sdk 0.0.1

package/README.md

@@ -0,0 +1,275 @@
+# veilix-sdk
+
+TypeScript SDK for interacting with the Veilix privacy protocol on Solana — deposits, withdrawals, private transfers, and fee quotes.
+
+**Third-party partners** integrating Private Send into their own website or app (quote → wallet sign → deposit → `/submit`): see [`docs/partner-private-send.md`](./docs/partner-private-send.md).
+
+## Installation
+
+```bash
+npm install veilix-sdk
+```
+
+Peer dependencies (optional, for React):
+
+```bash
+npm install @solana/wallet-adapter-react react
+```
+
+## Prerequisites
+
+- A Solana wallet (`Keypair` for backend/scripts, or a wallet adapter with `signMessage` / `signAllTransactions` for frontend)
+- A [Range API key](https://range.org) (`rangeApiKey`)
+- An RPC endpoint or existing `@solana/web3.js` `Connection`
+
+Supported networks: `mainnet` and `devnet` (inferred from the RPC URL, or set explicitly via `network`).
+
+---
+
+## Creating a `VeilixSDK` instance
+
+Create one SDK instance per configuration (network, RPC, wallet, rangeApiKey). Initialization loads active relayers for the target network.
+
+```ts, tsx
+import { VeilixSDK  } from "veilix-sdk";
+
+VeilixSDK.create({
+  rangeApiKey: RANGE_API_KEY,
+  rpcEndpoint: RPC_URL,
+  wallet,
+  network: NETWORK,
+})
+.then((sdk) => {
+  ...
+})
+```
+
+### Init options
+
+| Option | Required | Description |
+|--------|----------|-------------|
+| `rangeApiKey` | yes | Range API key for risk/oracle features |
+| `wallet` | yes | Anchor-compatible wallet (`Keypair` or wallet adapter) |
+| `rpcEndpoint` | yes | Solana JSON-RPC URL |
+| `network` | yes | `"mainnet"` or `"devnet"` — override when the RPC URL has no cluster hint |
+
+After creation, inspect runtime config via `sdk.config` or helpers like `sdk.getNetwork()`, `sdk.relayers`, and `sdk.getTokenMints()`.
+
+---
+
+## `getEncryptionKey`
+
+Derives a note-encryption key from a wallet signature and stores it on the SDK instance (`sdk.encryptKey`). **Required before any deposit that uses on-chain note backup** (`onChainBackup: true`, including `veilixTransfer`).
+
+The wallet signs the message `veilix:notes:v1`. Accepts a backend `Keypair` or a frontend wallet adapter with `signMessage`.
+
+```ts
+await sdk.getEncryptionKey(wallet);
+// sdk.encryptKey is now set
+```
+
+The key is used to encrypt secret notes before they are stored on-chain via `backupNotes`, so you can recover notes later from the same wallet.
+
+---
+
+## `buildDepositTx`
+
+Builds an unsigned deposit transaction for a pre-generated secret note.
+
+### 1. Generate deposit parameters
+
+```ts
+// 1 SOL deposit (lamports)
+const { note } = sdk.generateDepositParams(1_000_000_000n, null);
+
+// SPL token deposit — pass the token mint
+const usdcMint = sdk.getTokenMint("USDC");
+const { note: usdcNote } = sdk.generateDepositParams(1_000_000n, usdcMint);
+```
+
+Deposit amounts must match [supported pool denominations](#supported-deposit-denominations) for each token.
+
+### 2. Build the transaction
+
+```ts
+await sdk.getEncryptionKey(wallet); // required when onChainBackup is true
+
+const { tx, note } = await sdk.buildDepositTx({
+  senderPublicKey: wallet.publicKey,
+  note,
+  onChainBackup: true,       // encrypt and store note on-chain (recommended)
+  computeUnitPrice: 50_000,  // optional priority fee
+  tempSigner: tempSignerPublicKey // to prevent ix assertion in browser
+});
+```
+
+Sign and send the returned `tx` with your wallet. **Save the returned `note`** — it is required to withdraw later.
+
+| Parameter | Description |
+|-----------|-------------|
+| `senderPublicKey` | Depositor's public key |
+| `note` | Secret note from `generateDepositParams` |
+| `onChainBackup` | When `true`, encrypts the note and adds a `backupNotes` instruction (requires `getEncryptionKey`) |
+| `computeUnitPrice` | Priority fee in micro-lamports (default `50000`) |
+
+---
+
+## `withdraw`
+
+Withdraws funds from the privacy pool to a recipient using a secret note from a prior deposit. The SDK:
+
+1. Validates the recipient against the risk API
+2. Fetches Merkle commitments from the indexer
+3. Generates a ZK withdraw proof
+4. Submits the proof to a relayer (chosen at random, or by index)
+5. Polls until the relayer confirms the on-chain transaction
+
+```ts
+const result = await sdk.withdraw({
+    note: "veilix-1-...",           // secret note from deposit
+    recipient: "RecipientPubkey...", // withdrawal destination
+  },
+  relayerIdx: -1,                   // optional — random relayer when omitted
+);
+
+console.log(result.txHash);  // on-chain transaction signature
+console.log(result.status);  // "success" | "failed"
+```
+
+| Parameter | Description |
+|-----------|-------------|
+| `note` | Secret note from the original deposit |
+| `recipient` | Recipient public key (`PublicKey` or base58 string) |
+| `relayerIdx` | Optional index into `sdk.relayers` |
+
+Withdraw fees are calculated automatically from the relayer fee and on-chain platform fee.
+
+---
+
+## `veilixTransfer`
+
+End-to-end private transfer: deposit into the pool (split across supported denominations), then withdraw each successful note to the recipient. Handles signing, sending, and settlement automatically.
+
+**Requires keep open the window till get response for correct work**
+
+```ts
+import { PublicKey } from "@solana/web3.js";
+
+const result = await sdk.veilixTransfer(
+  [
+    {
+      mint: new PublicKey(sdk.getTokenMint("USDC")),
+      amount: "25",                              // human-readable amount
+      recipient: new PublicKey("RecipientPubkey..."),
+    },
+    {
+      mint: new PublicKey(sdk.getTokenMints().Solana),
+      amount: "1.5",
+      recipient: new PublicKey("AnotherRecipient..."),
+    },
+  ],
+);
+
+if (result.error) {
+  console.log("Deposit failures:", result.depositFailed);
+  console.log("Withdraw failures:", result.withdrawFailed);
+}
+```
+
+| Field | Description |
+|-------|-------------|
+| `items[].mint` | Token mint to transfer |
+| `items[].amount` | Human-readable amount (e.g. `"1.5"` SOL) |
+| `items[].recipient` | Withdrawal destination for that transfer |
+
+The SDK splits each amount into the nearest supported deposit denominations, builds and sends deposit transactions, waits for settlement, then withdraws each note to its recipient. Partial failures are reported in `depositFailed` and `withdrawFailed` without throwing.
+
+---
+
+## `getQuote`
+
+Fetches a withdraw fee quote from the Veilix indexer before executing a withdrawal. Returns estimated relayer fees, recipient amount, ETA, and how the amount splits across denominations.
+
+```ts
+const { quote } = await sdk.getQuote({
+  amount: 1.5,                    // human-readable amount
+  amountLamports: 1_500_000_000,  // same amount in smallest units
+  recipient: "RecipientPubkey...",
+  asset: "SOL",                   // optional — default "SOL"
+});
+
+console.log(quote.recipientAmount);  // amount recipient receives after fees
+console.log(quote.totalRelayerFee);
+console.log(quote.etaSeconds);
+console.log(quote.splits);           // per-denomination breakdown
+console.log(quote.platformFee);      // platform fee (added by SDK)
+```
+
+| Parameter | Description |
+|-----------|-------------|
+| `amount` | Human-readable transfer/withdraw amount |
+| `amountLamports` | Amount in smallest token units |
+| `recipient` | Intended withdrawal recipient |
+| `asset` | Indexer asset label (default `"SOL"`) |
+| `network` | Optional cluster override |
+
+`getQuote` is also exported as a standalone function but requires an initialized SDK context.
+
+---
+
+## Typical flows
+
+### Deposit and withdraw
+
+```ts
+const sdk = await VeilixSDK.create({ rangeApiKey, rpcEndpoint, wallet });
+
+await sdk.getEncryptionKey(wallet);
+
+const { note } = sdk.generateDepositParams(1_000_000_000n, null);
+const { tx } = await sdk.buildDepositTx({
+  senderPublicKey: wallet.publicKey,
+  note,
+  onChainBackup: true,
+});
+
+// sign and send tx...
+
+const { txHash } = await sdk.withdraw({
+  note,
+  recipient: "RecipientPubkey...",
+});
+```
+
+### Quote before withdraw
+
+```ts
+const { quote } = await sdk.getQuote({
+  amount: 1,
+  amountLamports: 1_000_000_000,
+  recipient: "RecipientPubkey...",
+});
+
+console.log(`Recipient receives ~${quote.recipientAmount} SOL`);
+
+await sdk.withdraw({ note, recipient: "RecipientPubkey..." });
+```
+
+---
+
+## Supported deposit denominations
+
+Amounts must decompose exactly into these pool denominations:
+
+| Token | Denominations | Mint Address (mainnet) |
+|-------|---------------|---------------|
+| SOL | 0.1, 1, 5, 10, 50, 100, 500 | |
+| USDC | 1, 10, 50, 100, 1000, 10000, 100000, 1000000 | EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v |
+| Veilix | 10000,50000,100000,500000,1000000,10000000 |  |
+| Bitcoin | 0.01, 0.05, 0.1, 0.5, 1, 5 | 3NZ9JMVBmGAqocybic2c7LQCJScmgsAZ6vQqTDzcqmJh |
+| Ethereum (coming soon) | 0.1, 1, 10, 50, 100, 500 | 7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs |
+
+Use `sdk.getDepositAmounts("Solana")` (or another symbol) to retrieve the list programmatically.
+
+---
+

package/dist/VeilixSDK-BNEMLchN.d.cts

@@ -0,0 +1,390 @@
+import { PublicKey, Keypair, Connection, TransactionInstruction, Transaction } from '@solana/web3.js';
+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-9OPXLj27.cjs';
+
+type IndexerAsset = string | {
+    mint?: string;
+    asset?: string;
+} | null;
+
+/** Frontend wallet adapter or backend {@link Keypair}. */
+type EncryptKeyWallet = Keypair | {
+    signMessage: (message: Uint8Array) => Promise<Uint8Array> | Uint8Array;
+};
+type BuildDepositTxParams = {
+    senderPublicKey: PublicKey | string;
+    /** Pre-generated secret note from {@link generateDepositParams}. */
+    note: string;
+    onChainBackup?: boolean;
+    computeUnitPrice?: number;
+    tempSigner?: PublicKey | string;
+};
+type FetchWalletBalanceOptions = {
+    includeDeposits?: boolean;
+    indexerAsset?: IndexerAsset;
+};
+type BuildRelayPayloadParams = {
+    args: unknown[];
+    proofHex: string;
+    denomination: number | bigint | string;
+    withdrawAddress: unknown;
+    relayerPubkey: unknown;
+    mint?: unknown;
+};
+type RelayPayload = Record<string, unknown>;
+
+type DepositParams = {
+    nullifier: string;
+    secret: string;
+    amount: string;
+    commitment: string;
+    nullifierHash: string;
+    mint: string | null;
+};
+type GenerateDepositParamsResult = {
+    params: DepositParams;
+    note: string;
+};
+type PreparedCircuitArtifacts = {
+    wasmPath: string;
+    zkeyPath: string;
+    /** Revokes the browser object URLs. `null` outside the browser. */
+    cleanup: (() => void) | null;
+};
+type GenerateWithdrawProofOptions = {
+    /** Override WASM path/URL (for bundled frontends, use a Vite `?url` import). */
+    circuitWasmPath?: string;
+    /** Override zkey path/URL (for bundled frontends, use a Vite `?url` import). */
+    circuitZkeyPath?: string;
+    /**
+     * Artifacts already fetched and verified by {@link prepareCircuitArtifacts}.
+     * Skips the download and takes precedence over the path overrides; the caller
+     * stays responsible for calling `cleanup`.
+     */
+    circuitArtifacts?: PreparedCircuitArtifacts;
+};
+/**
+ * Fetch and integrity-check the withdraw circuit artifacts once so that several
+ * proofs can share them. Call `cleanup` after the last proof has settled.
+ */
+declare const prepareCircuitArtifacts: (circuitWasmPath?: string, circuitZkeyPath?: string) => Promise<PreparedCircuitArtifacts>;
+
+type Network = "mainnet" | "devnet";
+declare const MAINNET_TOKEN_MINTS: {
+    readonly Veilix: "3jSL5nnnYcRLmTqFmwvY1Mikh42fQsT7p7NvXPYzanon";
+    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;
+/** Supported deposit denominations per token (same on mainnet and devnet). */
+declare const DEPOSIT_AMOUNTS: {
+    readonly Solana: readonly [0.1, 1, 5, 10, 50, 100, 500];
+    readonly Veilix: readonly [10000, 50000, 100000, 500000, 1000000, 10000000];
+    readonly Bitcoin: readonly [0.01, 0.05, 0.1, 0.5, 1, 5];
+    readonly Ethereum: readonly [0.1, 1, 10, 50, 100, 500];
+    readonly USDC: readonly [1, 10, 50, 100, 1000, 10000, 100000, 1000000];
+};
+type DepositTokenSymbol = keyof typeof DEPOSIT_AMOUNTS;
+
+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 {
+    /** Range API key (frontend: VITE_RANGE_API_KEY). */
+    rangeApiKey: string;
+    /** 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;
+}
+interface VeilixSdkRuntimeConfig {
+    rangeApiKey: string;
+    rpcEndpoint: string;
+    /** Cluster inferred from {@link rpcEndpoint}. */
+    network: Network;
+    programId: 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 from the original deposit. */
+    note: string;
+    /** Withdrawal recipient public key. */
+    recipient: PublicKey | string;
+    /** Mode for normal withdraw or veilix transfer. */
+    veilixTransferMode?: boolean;
+};
+type WithdrawStatus = "success" | "failed";
+type WithdrawResult = {
+    txHash: string;
+    status: WithdrawStatus;
+};
+
+type QuoteRelayer = {
+    url: string;
+    [key: string]: unknown;
+};
+type QuoteTransaction = Record<string, unknown>;
+type QuoteSplit = {
+    denomination: number;
+    totalRelayerFee: number;
+    relayer: QuoteRelayer;
+    transaction: QuoteTransaction;
+};
+type Quote = {
+    amount: number;
+    transactionCount: number;
+    recipientAmount: number;
+    totalRelayerFee: number;
+    etaSeconds: number;
+    splits: QuoteSplit[];
+    platformFee?: number;
+};
+type GetQuoteResponse = {
+    success: boolean;
+    quote: Quote;
+};
+type GetQuoteParams = {
+    amount: number | string;
+    amountLamports: number | string | bigint;
+    recipient: PublicKey | string;
+    /** Indexer asset label (default `SOL`). */
+    asset?: string;
+    /** Cluster for the quote (default active SDK network). */
+    network?: Network;
+};
+/** Fetch a withdraw quote from the indexer. Requires SDK init or an active instance context. */
+declare function getQuote(params: GetQuoteParams): Promise<GetQuoteResponse>;
+
+type ResolvedNoteAsset = {
+    key: string;
+    tokenName: TokenDecimalsSymbol;
+    unit: string;
+    multiplier: bigint;
+    mint: string | null;
+    poolAmounts: readonly number[];
+    decimals: number;
+};
+
+type VeilixTransferItem = {
+    mint: PublicKey;
+    /** Human-readable token amount (e.g. `"1.5"` SOL). */
+    amount: string;
+    recipient: PublicKey;
+};
+type VeilixTransferDepositFailure = {
+    amount: string;
+    mint: string;
+    recipient: string;
+};
+type VeilixTransferWithdrawFailure = {
+    note: string;
+    recipient: string;
+};
+type VeilixTransferResult = {
+    error: boolean;
+    depositFailed: VeilixTransferDepositFailure[];
+    withdrawFailed: VeilixTransferWithdrawFailure[];
+    depositSuccess: string[];
+};
+type VeilixTransferOptions = {
+    /** When true, all withdraws use the same randomly selected relayer. */
+    uniqueRelayer?: boolean;
+};
+
+/**
+ * Veilix SDK client. Create one instance per configuration (network, RPC, API keys).
+ *
+ * @example
+ * ```js
+ * const { VeilixSDK } = require('veilix-sdk');
+ * const sdk = await VeilixSDK.create({
+ *   rangeApiKey: process.env.RANGE_API_KEY,
+ *   rpcEndpoint: 'https://api.devnet.solana.com',
+ *   wallet,
+ * });
+ * console.log(sdk.config.relayers);
+ * ```
+ *
+ * @example React (wallet-adapter)
+ * ```tsx
+ * import { useVeilixSdk } from 'veilix-sdk/react';
+ *
+ * function MyComponent() {
+ *   const sdk = useVeilixSdk({ rangeApiKey: import.meta.env.VITE_RANGE_API_KEY });
+ *   if (!sdk) return null;
+ *   // ...
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { VeilixSDK } from 'veilix-sdk';
+ * const sdk = await VeilixSDK.create({ rangeApiKey, rpcEndpoint, wallet });
+ * await sdk.getEncryptionKey(wallet);
+ * const { note } = sdk.generateDepositParams(1_000_000_000n, null);
+ * await sdk.buildDepositTx({ senderPublicKey: wallet.publicKey, note, onChainBackup: true });
+ * ```
+ */
+declare class VeilixSDK {
+    static readonly VERSION = "0.0.1";
+    readonly config: VeilixSdkRuntimeConfig;
+    private constructor();
+    /** Create an SDK instance (loads relayers for the inferred network). */
+    static create(options: VeilixSdkInitOptions): Promise<VeilixSDK>;
+    private run;
+    private runAsync;
+    getConfig(): VeilixSdkRuntimeConfig;
+    getRangeApiKey(): string;
+    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: "3jSL5nnnYcRLmTqFmwvY1Mikh42fQsT7p7NvXPYzanon" | "ARCxcL6oX2pd4bKmUxhdoARaaHdKU6TJrTTthPANPQtQ";
+        Bitcoin: "" | "3NZ9JMVBmGAqocybic2c7LQCJScmgsAZ6vQqTDzcqmJh";
+        Ethereum: "" | "7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs";
+        USDC: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v" | "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU";
+    };
+    getVeilixTokenMint(): string;
+    getTokenMint(symbol: TokenSymbol): string;
+    getDepositAmounts(symbol: DepositTokenSymbol): readonly number[];
+    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;
+    getPoolPDA(denominationLamports: number | bigint): [PublicKey, number];
+    getTokenPoolPDA(mint: PublicKey | string, denominationSmallestUnits: number | bigint): [PublicKey, number];
+    getTreasuryPDA(): [PublicKey, number];
+    getCommitmentPDA(commitmentBigInt: bigint | number | string): [PublicKey, number];
+    getNullifierPDA(nullifierHashBigInt: bigint | number | string): [PublicKey, number];
+    getNetworkStatePDA(): [PublicKey, number];
+    buildDepositTx(params: BuildDepositTxParams): Promise<{
+        tx: Transaction;
+        note: string;
+    }>;
+    /**
+     * Withdraw to `recipient` using a secret `note`.
+     * Relayer is chosen at random from {@link config.relayers}, or by {@link WithdrawParams.relayerIdx}.
+     */
+    withdraw(params: WithdrawParams, relayerIdx?: number): Promise<WithdrawResult>;
+    /**
+     * Private transfer: deposit into the pool (split by supported denominations),
+     * then withdraw each successful note to the recipient.
+     *
+     * Requires {@link getEncryptionKey} before calling (deposits use on-chain backup).
+     *
+     * @param tempKeypair Ephemeral keypair co-signed on deposit instructions.
+     */
+    veilixTransfer(items: VeilixTransferItem[], tempKeypair: Keypair): Promise<VeilixTransferResult>;
+    /** Validate a withdraw recipient against the risk API. */
+    assertWithdrawRecipientAllowed(address: string): Promise<void>;
+    /** Resolve the token asset encoded in a secret note. */
+    resolveNoteAsset(amount: string, mint?: string | null, tokenNameHint?: TokenDecimalsSymbol): ResolvedNoteAsset;
+    fetchPlatformFee(): Promise<string>;
+    /** Fetch a withdraw quote from the indexer. */
+    getQuote(params: GetQuoteParams): Promise<GetQuoteResponse>;
+    fetchCommitments(denomination: number | bigint | string, indexerAsset?: IndexerAsset): Promise<unknown>;
+    validateNullifier(nullifierHash: string, indexerAsset?: IndexerAsset): Promise<unknown>;
+    fetchTxStatus(commitmentHex: string, nullifierHashHex: string, indexerAsset?: IndexerAsset): Promise<unknown>;
+    fetchDepositCountByCommitment(commitment: string, denomination: number | bigint | string, indexerAsset?: IndexerAsset): Promise<unknown>;
+    fetchWalletBalance(wallet: string, options?: FetchWalletBalanceOptions): Promise<unknown>;
+    /** Re-fetch relayers from the indexer and update {@link config.relayers}. */
+    fetchRelayers(): Promise<Relayer[]>;
+    fetchLatestTransactions(type?: string, indexerAsset?: IndexerAsset): Promise<unknown>;
+    fetchTxCounts(type?: string, indexerAsset?: IndexerAsset): Promise<unknown>;
+    normalizePubkeyString(value: unknown): string;
+    buildRelayPayload(params: BuildRelayPayloadParams): RelayPayload;
+    submitToRelayer(relayerUrl: string, payload: RelayPayload): Promise<unknown>;
+    pollRelayerJob(relayerUrl: string, jobId: string, maxWaitMs?: number): Promise<unknown>;
+    /**
+     * Derives the note encryption key from a wallet signature and stores it on
+     * {@link config.encryptKey}. Required before {@link buildDepositTx} with
+     * `onChainBackup: true`.
+     *
+     * Accepts a frontend wallet adapter (`signMessage`) or a backend {@link Keypair}.
+     */
+    getEncryptionKey(wallet: EncryptKeyWallet): Promise<Uint8Array>;
+    encryptData(key: Uint8Array, plaintext: string): Uint8Array<ArrayBufferLike>;
+    decryptData(key: Uint8Array, combined: Uint8Array): string;
+    generateRandomFieldElement(): bigint;
+    createCommitment(nullifier: bigint | number | string, secret: bigint | number | string): bigint;
+    createNullifierHash(nullifier: bigint | number | string): bigint;
+    generateDepositParams(amountLamports: bigint | number | string, mint?: string | null): GenerateDepositParamsResult;
+    parseSecretNote(note: string): Record<string, string>;
+    publicKeyToFieldElement(publicKeyBytes: Uint8Array | number[]): bigint;
+    amountToFieldElement(amount: bigint | number | string): bigint;
+    generateMerkleProof(depositParams: Record<string, unknown>, leaves: unknown[]): unknown;
+    generateWithdrawProof(depositParams: Record<string, unknown>, leaves: unknown[], recipient: PublicKey | string, relayer: PublicKey | string, fee: bigint | number | string, refund: bigint | number | string, options?: GenerateWithdrawProofOptions): Promise<unknown>;
+    convertProofToBytes(proof: unknown): Promise<number[] | Uint8Array<ArrayBufferLike>>;
+    to32ByteBuffer(bigInt: bigint | number | string): Uint8Array<ArrayBufferLike>;
+    toFixedHex(value: bigint | number | string, length?: number): string;
+    toFieldElementHex(value: bigint | number | string): string;
+    formatNoteForDisplay(note: string, segmentLen?: number): string;
+    appendIndexerAsset(params: URLSearchParams, indexerAsset?: IndexerAsset): void;
+    /** Program ID for a cluster without an SDK instance. */
+    static getProgramIdForNetwork(network: Network): string;
+}
+
+export { type BuildDepositTxParams as B, type DepositTokenSymbol as D, type EncryptKeyWallet as E, type FetchWalletBalanceOptions as F, type GenerateDepositParamsResult as G, type IndexerAsset as I, type Network as N, type PreparedCircuitArtifacts as P, type Quote as Q, type RelayPayload as R, type TokenDecimalsSymbol as T, VeilixSDK as V, type WithdrawParams as W, type BuildRelayPayloadParams as a, type GenerateWithdrawProofOptions as b, type GetQuoteParams as c, type GetQuoteResponse as d, type QuoteRelayer as e, type QuoteSplit as f, type QuoteTransaction as g, type Relayer as h, type ResolvedNoteAsset as i, type TokenSymbol as j, type VeilixSdkInitOptions as k, type VeilixSdkRuntimeConfig as l, type VeilixTransferDepositFailure as m, type VeilixTransferItem as n, type VeilixTransferOptions as o, type VeilixTransferResult as p, type VeilixTransferWithdrawFailure as q, type WithdrawResult as r, type WithdrawStatus as s, getQuote as t, prepareCircuitArtifacts as u };