@cloak.dev/sdk 0.1.4 → 0.1.6

package/dist/index.d.cts

@@ -1,375 +1,4 @@
-import { PublicKey, Transaction, Connection, TransactionInstruction, Keypair, SendOptions, AddressLookupTableAccount, VersionedTransaction } from '@solana/web3.js';
-
-type ComplianceTxType = "deposit" | "withdraw" | "send" | "swap";
-interface TransactionMetadata {
-    amount: number;
-    recipient: string;
-    timestamp: number;
-    txType: ComplianceTxType;
-    commitment: string;
-    signature?: string;
-    outputMint?: string;
-}
-interface EncryptedMetadataBundle {
-    encrypted_user: string;
-    encrypted_compliance: string;
-    user_pubkey: string;
-    commitment: string;
-    timestamp: number;
-    tx_type?: ComplianceTxType;
-    wallet_signature?: string;
-    viewing_key?: string;
-}
-
-/**
- * Supported Solana networks
- */
-type Network = "localnet" | "devnet" | "mainnet" | "testnet";
-/**
- * Minimal wallet adapter interface
- * Compatible with @solana/wallet-adapter-base
- */
-interface WalletAdapter {
-    publicKey: PublicKey | null;
-    signTransaction?<T extends Transaction>(transaction: T): Promise<T>;
-    signAllTransactions?<T extends Transaction>(transactions: T[]): Promise<T[]>;
-    sendTransaction?(transaction: Transaction, connection: any, options?: any): Promise<string>;
-}
-/**
- * Cloak-specific error with categorization
- */
-declare class CloakError extends Error {
-    category: "network" | "indexer" | "prover" | "relay" | "validation" | "wallet" | "environment" | "service";
-    retryable: boolean;
-    originalError?: Error | undefined;
-    constructor(message: string, category: "network" | "indexer" | "prover" | "relay" | "validation" | "wallet" | "environment" | "service", retryable?: boolean, originalError?: Error | undefined);
-}
-/**
- * Cloak Note - Represents a private transaction commitment
- *
- * A note contains all the information needed to withdraw funds from the Cloak protocol.
- * Keep this safe and secret - anyone with access to this note can withdraw the funds!
- */
-interface CloakNote {
-    /** Protocol version */
-    version: string;
-    /** Amount in lamports */
-    amount: number;
-    /** Commitment hash (hex) */
-    commitment: string;
-    /** Spending secret key (hex, 64 chars) */
-    sk_spend: string;
-    /** Randomness value (hex, 64 chars) */
-    r: string;
-    /** Transaction signature from deposit (optional until deposited) */
-    depositSignature?: string;
-    /** Solana slot when deposited (optional until deposited) */
-    depositSlot?: number;
-    /** Index in the Merkle tree (optional until deposited) */
-    leafIndex?: number;
-    /** Historical Merkle root at time of deposit (optional until deposited) */
-    root?: string;
-    /** Merkle proof at time of deposit (optional until deposited) */
-    merkleProof?: MerkleProof;
-    /** Creation timestamp */
-    timestamp: number;
-    /** Network where this note was created */
-    network: Network;
-}
-/**
- * Merkle proof for a leaf in the commitment tree
- */
-interface MerkleProof {
-    /** Sibling hashes along the path (hex strings) */
-    pathElements: string[];
-    /** Path directions (0 = left, 1 = right) */
-    pathIndices: number[];
-    /** Optional root for backward compatibility */
-    root?: string;
-}
-/**
- * Transfer recipient - used in privateTransfer
- */
-interface Transfer {
-    /** Recipient's Solana public key */
-    recipient: PublicKey;
-    /** Amount to send in lamports */
-    amount: number;
-}
-/**
- * Type-safe array with maximum length constraint
- * Used to enforce 1-5 recipients in privateTransfer
- */
-type MaxLengthArray<T, Max extends number, A extends T[] = []> = A['length'] extends Max ? A : A | MaxLengthArray<T, Max, [T, ...A]>;
-/**
- * Result from a private transfer
- */
-interface TransferResult {
-    /** Solana transaction signature */
-    signature: string;
-    /** Recipients and amounts that were sent */
-    outputs: Array<{
-        recipient: string;
-        amount: number;
-    }>;
-    /** Nullifier used (prevents double-spending) */
-    nullifier: string;
-    /** Merkle root that was proven against */
-    root: string;
-}
-/**
- * Result from a deposit operation
- */
-interface DepositResult {
-    /** The created note (save this securely!) */
-    note: CloakNote;
-    /** Solana transaction signature */
-    signature: string;
-    /** Leaf index in the Merkle tree */
-    leafIndex: number;
-    /** Current Merkle root */
-    root: string;
-}
-/**
- * Configuration for the Cloak SDK
- */
-interface CloakConfig {
-    /** Solana network */
-    network?: Network;
-    /**
-     * Keypair bytes for signing (deprecated - use wallet instead)
-     * @deprecated Use wallet parameter for better integration
-     */
-    keypairBytes?: Uint8Array;
-    /**
-     * Wallet adapter for signing transactions
-     * Required unless using keypairBytes
-     */
-    wallet?: WalletAdapter;
-    /**
-     * Cloak key pair for v2.0 features (note scanning, encryption)
-     * Optional but recommended for full functionality
-     */
-    cloakKeys?: any;
-    /** Optional: Proof generation timeout in milliseconds (default: 5 minutes) */
-    proofTimeout?: number;
-    /** Optional: Program ID (defaults to Cloak mainnet program) */
-    programId?: PublicKey;
-    /** Optional: Pool account address (auto-derived from program ID if not provided) */
-    poolAddress?: PublicKey;
-    /** Optional: Merkle tree account address (auto-derived if not provided) */
-    merkleTreeAddress?: PublicKey;
-    /** Optional: Treasury account address (auto-derived if not provided) */
-    treasuryAddress?: PublicKey;
-    /**
-     * Enable debug logging with structured output similar to Rust tracing.
-     *
-     * When enabled, logs SDK operations with timestamps, module paths,
-     * and key-value pairs for context:
-     *
-     * ```
-     * 2026-01-23T00:51:46.489000Z  INFO cloak::sdk: 📥 Deposit completed signature=42XB... leaf_index=757
-     * ```
-     *
-     * Can also be enabled via environment variable:
-     * - `CLOAK_DEBUG=1`
-     * - `DEBUG=cloak:*`
-     *
-     * Default: false
-     */
-    debug?: boolean;
-}
-/**
- * Deposit progress status
- */
-type DepositStatus = "generating_note" | "awaiting_note_acknowledgment" | "note_saved" | "creating_transaction" | "simulating" | "sending" | "confirming" | "submitting_to_indexer" | "fetching_proof" | "complete";
-/**
- * Options for deposit operation
- */
-interface DepositOptions {
-    /** Optional callback for progress updates with detailed status */
-    onProgress?: (status: DepositStatus | string, details?: {
-        message?: string;
-        step?: number;
-        totalSteps?: number;
-        retryAttempt?: number;
-    }) => void;
-    /** Callback when transaction is sent (before confirmation) */
-    onTransactionSent?: (signature: string) => void;
-    /** Callback when transaction is confirmed */
-    onConfirmed?: (signature: string, slot: number) => void;
-    /**
-     * CRITICAL: Callback when note is generated, BEFORE any on-chain transaction.
-     *
-     * This is your chance to safely persist the note. If you don't save the note
-     * and the deposit succeeds but the browser crashes, your funds could be lost!
-     *
-     * The callback receives the note with all secrets needed for withdrawal.
-     * The deposit will NOT proceed until this callback completes.
-     *
-     * @example
-     * ```typescript
-     * onNoteGenerated: async (note) => {
-     *   // Save to secure storage BEFORE deposit proceeds
-     *   await localStorage.setItem(`pending_note_${note.commitment}`, JSON.stringify(note));
-     *   // Or show user a modal to copy/download the note
-     * }
-     * ```
-     */
-    onNoteGenerated?: (note: CloakNote) => Promise<void> | void;
-    /**
-     * If true, require user to acknowledge the note before proceeding with deposit.
-     * When enabled with onNoteGenerated, the deposit will wait for the callback to complete.
-     * Default: true when onNoteGenerated is provided
-     */
-    requireNoteAcknowledgment?: boolean;
-    /** Skip simulation (default: false) */
-    skipPreflight?: boolean;
-    /**
-     * Compute units to request.
-     * - If `optimizeCU` is true, this is ignored and CU is determined via simulation
-     * - Otherwise defaults to 40,000 (suitable for typical deposits)
-     */
-    computeUnits?: number;
-    /**
-     * Enable simulation-based CU optimization.
-     * When true, simulates the transaction first to determine actual CU usage,
-     * then sets an optimal limit (simulated + 20% buffer).
-     *
-     * **Note: Only works in keypair mode (Node.js/scripts).**
-     * In wallet/browser mode, this is ignored because simulation would require
-     * the user to sign twice (simulation + actual tx) which is bad UX.
-     *
-     * Trade-offs:
-     * - ✅ Optimal block scheduling priority
-     * - ❌ Adds ~200-500ms latency (extra RPC call)
-     * - ❌ Only available in keypair mode
-     *
-     * Default: false (uses fixed 40K CU which is ~75% efficient for typical deposits)
-     */
-    optimizeCU?: boolean;
-    /** Priority fee in micro-lamports (default: 10,000) */
-    priorityFee?: number;
-    /**
-     * Loaded accounts data size limit in bytes.
-     *
-     * Without this, Solana defaults to 64MB which incurs CU overhead
-     * (charged at 8 CU per 32KB). Setting a lower limit improves priority.
-     *
-     * **Note for Cloak deposits:**
-     * The Shield Pool program is ~104KB, so the minimum practical limit is ~128KB.
-     *
-     * Default: 256 * 1024 (256KB) - provides safety margin above program size.
-     * Set to 0 to disable (use Solana 64MB default).
-     *
-     * @see https://www.anza.xyz/blog/cu-optimization-with-setloadedaccountsdatasizelimit
-     */
-    loadedAccountsDataSizeLimit?: number;
-    /**
-     * Optional: Encrypt output for specific recipient's view key
-     * If not provided, encrypts for the wallet's own view key (for self-scanning)
-     */
-    recipientViewKey?: string;
-    /**
-     * Skip privacy warning on testnet (default: false)
-     * Warning: Only skip if you understand the privacy limitations
-     */
-    skipPrivacyWarning?: boolean;
-}
-/**
- * Options for private transfer/withdraw operation
- */
-interface TransferOptions {
-    /**
-     * Optional callback for progress updates
-     * Note: relayFeeBps is automatically calculated from protocol fees
-     */
-    onProgress?: (status: string) => void;
-    /** Optional callback for proof generation progress (0-100) */
-    onProofProgress?: (percent: number) => void;
-    /**
-     * Metadata bundle for compliance tracking.
-     * On first transaction, should include viewing_key for compliance registration.
-     */
-    metadataBundle?: {
-        encrypted_user: string;
-        encrypted_compliance: string;
-        user_pubkey: string;
-        commitment: string;
-        timestamp: number;
-        tx_type?: ComplianceTxType;
-        viewing_key?: string;
-    };
-}
-/**
- * Options for withdrawal (convenience method with single recipient)
- */
-interface WithdrawOptions extends TransferOptions {
-    /** Whether to withdraw full amount minus fees (default: true) */
-    withdrawAll?: boolean;
-    /** Specific amount to withdraw in lamports (if not withdrawing all) */
-    amount?: number;
-}
-/**
- * Merkle root response from indexer
- */
-interface MerkleRootResponse {
-    root: string;
-    next_index: number;
-}
-/**
- * Transaction status from relay service
- */
-interface TxStatus {
-    status: "pending" | "processing" | "completed" | "failed";
-    txId?: string;
-    error?: string;
-}
-/**
- * Swap parameters for token swaps
- */
-interface SwapParams {
-    /** Output token mint address */
-    output_mint: string;
-    /** Slippage tolerance in basis points (e.g., 100 = 1%) */
-    slippage_bps: number;
-    /** Minimum output amount in token's smallest unit */
-    min_output_amount: number;
-}
-/**
- * Options for swap operation
- */
-interface SwapOptions extends TransferOptions {
-    /** Output token mint address */
-    outputMint: string;
-    /** Slippage tolerance in basis points (default: 100 = 1%) */
-    slippageBps?: number;
-    /** Minimum output amount (will be calculated from quote if not provided) */
-    minOutputAmount?: number;
-    /** Optional callback to get swap quote */
-    getQuote?: (amountLamports: number, outputMint: string, slippageBps: number) => Promise<{
-        outAmount: number;
-        minOutputAmount: number;
-    }>;
-    /**
-     * Recipient's associated token account for the output token.
-     * If not provided, will be computed automatically (requires @solana/spl-token).
-     * For browser environments, it's recommended to compute this in the frontend
-     * where @solana/spl-token is properly bundled.
-     */
-    recipientAta?: string;
-}
-/**
- * Result from a swap operation
- */
-interface SwapResult extends TransferResult {
-    /** Output token mint address */
-    outputMint: string;
-    /** Minimum output amount that was guaranteed */
-    minOutputAmount: number;
-    /** Actual output amount received (may be higher than min) */
-    actualOutputAmount?: number;
-}
+import { PublicKey, Transaction, Connection, AddressLookupTableAccount, TransactionInstruction, Keypair, SendOptions, VersionedTransaction } from '@solana/web3.js';
 
 /**
  * Cloak Key Hierarchy (v2.0)
@@ -455,681 +84,350 @@ declare function exportKeys(keys: CloakKeyPair): string;
 declare function importKeys(exported: string): CloakKeyPair;
 
 /**
- * Storage Interface
- *
- * Defines a pluggable storage interface for notes and keys.
- * Applications can implement their own storage (localStorage, IndexedDB, file system, etc.)
+ * Supported Solana networks.
  */
-
+type Network = "localnet" | "devnet" | "mainnet" | "testnet";
 /**
- * Storage adapter interface
- *
- * Implement this interface to provide custom storage for notes and keys.
- * The SDK will use this adapter for all persistence operations.
+ * Minimal wallet adapter interface — compatible with `@solana/wallet-adapter-base`.
  */
-interface StorageAdapter {
-    /**
-     * Save a note
-     */
-    saveNote(note: CloakNote): Promise<void> | void;
-    /**
-     * Load all notes
-     */
-    loadAllNotes(): Promise<CloakNote[]> | CloakNote[];
-    /**
-     * Update a note
-     */
-    updateNote(commitment: string, updates: Partial<CloakNote>): Promise<void> | void;
-    /**
-     * Delete a note
-     */
-    deleteNote(commitment: string): Promise<void> | void;
-    /**
-     * Clear all notes
-     */
-    clearAllNotes(): Promise<void> | void;
-    /**
-     * Save wallet keys
-     */
-    saveKeys(keys: CloakKeyPair): Promise<void> | void;
-    /**
-     * Load wallet keys
-     */
-    loadKeys(): Promise<CloakKeyPair | null> | CloakKeyPair | null;
-    /**
-     * Delete wallet keys
-     */
-    deleteKeys(): Promise<void> | void;
+interface WalletAdapter {
+    publicKey: PublicKey | null;
+    signTransaction?<T extends Transaction>(transaction: T): Promise<T>;
+    signAllTransactions?<T extends Transaction>(transactions: T[]): Promise<T[]>;
+    sendTransaction?(transaction: Transaction, connection: any, options?: any): Promise<string>;
 }
 /**
- * In-memory storage adapter (default, no persistence)
- *
- * Useful for testing or when storage is handled externally
+ * Cloak-specific error with categorization.
  */
-declare class MemoryStorageAdapter implements StorageAdapter {
-    private notes;
-    private keys;
-    saveNote(note: CloakNote): void;
-    loadAllNotes(): CloakNote[];
-    updateNote(commitment: string, updates: Partial<CloakNote>): void;
-    deleteNote(commitment: string): void;
-    clearAllNotes(): void;
-    saveKeys(keys: CloakKeyPair): void;
-    loadKeys(): CloakKeyPair | null;
-    deleteKeys(): void;
+declare class CloakError extends Error {
+    category: "network" | "indexer" | "prover" | "relay" | "validation" | "wallet" | "environment" | "service";
+    retryable: boolean;
+    originalError?: Error | undefined;
+    constructor(message: string, category: "network" | "indexer" | "prover" | "relay" | "validation" | "wallet" | "environment" | "service", retryable?: boolean, originalError?: Error | undefined);
 }
 /**
- * Browser localStorage adapter (optional, for browser environments)
- *
- * Only use this if you're in a browser environment and want localStorage persistence.
- * Import from a separate browser-specific module.
+ * Merkle proof for a leaf in the commitment tree.
  */
-declare class LocalStorageAdapter implements StorageAdapter {
-    private notesKey;
-    private keysKey;
-    constructor(notesKey?: string, keysKey?: string);
-    private getStorage;
-    saveNote(note: CloakNote): void;
-    loadAllNotes(): CloakNote[];
-    updateNote(commitment: string, updates: Partial<CloakNote>): void;
-    deleteNote(commitment: string): void;
-    clearAllNotes(): void;
-    saveKeys(keys: CloakKeyPair): void;
-    loadKeys(): CloakKeyPair | null;
-    deleteKeys(): void;
+interface MerkleProof {
+    /** Sibling hashes along the path (hex strings) */
+    pathElements: string[];
+    /** Path directions (0 = left, 1 = right) */
+    pathIndices: number[];
+    /** Optional root for backward compatibility */
+    root?: string;
 }
-
-/** Default Cloak Program ID on Solana */
-declare const CLOAK_PROGRAM_ID: PublicKey;
 /**
- * Main Cloak SDK
+ * Snapshot of the active SDK configuration, returned by `CloakSDK.getConfig()`.
  *
- * Provides high-level API for interacting with the Cloak protocol,
- * including deposits, withdrawals, and private transfers.
+ * This type is intentionally narrower than the constructor input
+ * (`CloakSDKOptions` in `core/CloakSDK.ts`): it omits `keypairBytes`,
+ * `wallet`, and `storage` because those are consumed into private SDK
+ * state (`this.keypair`, `this.wallet`, `this.storage`) at construction
+ * time and are never persisted on the config object. The type system
+ * therefore enforces the same invariant exercised at runtime by
+ * `cloak-sdk.test.ts`.
  *
- * Supports two modes:
- * 1. Node.js mode with keypairBytes - for scripts and backend services
- * 2. Wallet adapter mode - for browser applications with wallet integration
+ * If you're configuring the SDK at construction, use `CloakSDKOptions`.
  */
-declare class CloakSDK {
-    private config;
-    private keypair?;
-    private wallet?;
-    private cloakKeys?;
-    private relay;
-    private storage;
-    /**
-    * Create a new Cloak SDK client
-     *
-     * @param config - Client configuration
-     *
-     * @example Node.js mode (with keypair)
-     * ```typescript
-     * const sdk = new CloakSDK({
-     *   keypairBytes: keypair.secretKey,
-     *   network: "devnet"
-     * });
-     * ```
-     *
-     * @example Browser mode (with wallet adapter)
-     * ```typescript
-     * const sdk = new CloakSDK({
-     *   wallet: walletAdapter,
-     *   network: "devnet"
-     * });
-     * ```
-     */
-    constructor(config: {
-        /** Keypair bytes for signing (Node.js mode) */
-        keypairBytes?: Uint8Array;
-        /** Wallet adapter for signing (Browser mode) */
-        wallet?: WalletAdapter;
-        network?: Network;
-        cloakKeys?: CloakKeyPair;
-        storage?: StorageAdapter;
-        programId?: PublicKey;
-        relayUrl?: string;
-        /** Enable debug logging with structured output */
-        debug?: boolean;
-    });
-    /**
-     * Get the public key for deposits (from keypair or wallet)
-     */
-    getPublicKey(): PublicKey;
-    /**
-     * Check if the SDK is using a wallet adapter
-     */
-    isWalletMode(): boolean;
-    /**
-     * Deposit SOL into the Cloak protocol
-     *
-     * Creates a new note (or uses a provided one), submits a deposit transaction,
-     * and registers with the indexer.
-     *
-     * @param connection - Solana connection
-     * @param payer - Payer wallet with sendTransaction method
-     * @param amountOrNote - Amount in lamports OR an existing note to deposit
-     * @param options - Optional configuration
-     * @returns Deposit result with note and transaction info
-     *
-     * @example
-     * ```typescript
-     * // Generate and deposit in one step
-     * const result = await client.deposit(
-     *   connection,
-     *   wallet,
-     *   1_000_000_000,
-     *   {
-     *     onProgress: (status) => console.log(status)
-     *   }
-     * );
-     *
-     * // Or deposit a pre-generated note
-     * const note = client.generateNote(1_000_000_000);
-     * const result = await client.deposit(connection, wallet, note);
-     * ```
-     */
-    deposit(connection: Connection, amountOrNote: number | CloakNote, options?: DepositOptions): Promise<DepositResult>;
-    /**
-     * Private transfer with up to 5 recipients
-     *
-     * Handles the complete private transfer flow:
-     * 1. If note is not deposited, deposits it first and waits for confirmation
-     * 2. Generates a zero-knowledge proof
-     * 3. Submits the withdrawal via relay service to recipients
-     *
-     * This is the main method for performing private transfers - it handles everything!
-     *
-     * @param connection - Solana connection (required for deposit if not already deposited)
-     * @param payer - Payer wallet (required for deposit if not already deposited)
-     * @param note - Note to spend (can be deposited or not)
-     * @param recipients - Array of 1-5 recipients with amounts
-     * @param options - Optional configuration
-     * @returns Transfer result with signature and outputs
-     *
-     * @example
-     * ```typescript
-     * // Create a note (not deposited yet)
-     * const note = client.generateNote(1_000_000_000);
-     *
-     * // privateTransfer handles the full flow: deposit + withdraw
-     * const result = await client.privateTransfer(
-     *   connection,
-     *   wallet,
-     *   note,
-     *   [
-     *     { recipient: new PublicKey("..."), amount: 500_000_000 },
-     *     { recipient: new PublicKey("..."), amount: 492_500_000 }
-     *   ],
-     *   {
-     *     relayFeeBps: 50, // 0.5%
-     *     onProgress: (status) => console.log(status),
-     *     onProofProgress: (pct) => console.log(`Proof: ${pct}%`)
-     *   }
-     * );
-     * console.log(`Success! TX: ${result.signature}`);
-     * ```
-     */
-    privateTransfer(connection: Connection, note: CloakNote, recipients: MaxLengthArray<Transfer, 5>, options?: TransferOptions): Promise<TransferResult>;
+interface CloakConfig {
+    /** Network the SDK was constructed for. Defaults to `"mainnet"`. */
+    network?: Network;
+    /** Cloak key pair for note scanning / encryption (when provided). */
+    cloakKeys?: CloakKeyPair;
+    /** Resolved program ID (defaults to the mainnet shield-pool). */
+    programId?: PublicKey;
+    /** Pool PDA derived from `programId` + native SOL mint. */
+    poolAddress?: PublicKey;
+    /** Merkle-tree PDA. */
+    merkleTreeAddress?: PublicKey;
+    /** Treasury PDA. */
+    treasuryAddress?: PublicKey;
     /**
-     * Withdraw to a single recipient
+     * Whether structured debug logging was enabled at construction.
      *
-     * Convenience method for withdrawing to one address.
-     * Handles the complete flow: deposits if needed, then withdraws.
-     *
-     * @param connection - Solana connection
-     * @param payer - Payer wallet
-     * @param note - Note to spend
-     * @param recipient - Recipient address
-     * @param options - Optional configuration
-     * @returns Transfer result
-     *
-     * @example
-     * ```typescript
-     * const note = client.generateNote(1_000_000_000);
-     * const result = await client.withdraw(
-     *   connection,
-     *   wallet,
-     *   note,
-     *   new PublicKey("..."),
-     *   { withdrawAll: true }
-     * );
-     * ```
+     * Can also be enabled via env: `CLOAK_DEBUG=1` or `DEBUG=cloak:*`.
      */
-    withdraw(connection: Connection, note: CloakNote, recipient: PublicKey, options?: WithdrawOptions): Promise<TransferResult>;
+    debug?: boolean;
+}
+/**
+ * Merkle root response from the relay/indexer.
+ */
+interface MerkleRootResponse {
+    root: string;
+    next_index: number;
+}
+/**
+ * Transaction status returned by the relay.
+ */
+interface TxStatus {
+    status: "pending" | "processing" | "completed" | "failed";
+    txId?: string;
+    error?: string;
+}
+
+/**
+ * Storage Interface
+ *
+ * Pluggable storage for Cloak wallet keys (master seed / spend / view keys).
+ *
+ * As of `0.1.6`, note persistence is the consumer's responsibility: the OLD
+ * `CloakNote` model was retired (see `CloakSDK` jsdoc), and UTXO persistence
+ * in the new flow is owned by callers.
+ */
+
+interface StorageAdapter {
+    /** Save wallet keys. */
+    saveKeys(keys: CloakKeyPair): Promise<void> | void;
+    /** Load wallet keys (`null` when none stored). */
+    loadKeys(): Promise<CloakKeyPair | null> | CloakKeyPair | null;
+    /** Delete wallet keys. */
+    deleteKeys(): Promise<void> | void;
+}
+/**
+ * In-memory storage adapter (default; no persistence). Useful for tests or
+ * when storage is handled externally.
+ */
+declare class MemoryStorageAdapter implements StorageAdapter {
+    private keys;
+    saveKeys(keys: CloakKeyPair): void;
+    loadKeys(): CloakKeyPair | null;
+    deleteKeys(): void;
+}
+/**
+ * Browser `localStorage` adapter — only safe in browser environments.
+ *
+ * **Auto-purge on construction:** the first time any `LocalStorageAdapter`
+ * is constructed in a given browser, it removes the legacy `cloak_notes`
+ * localStorage entry (pre-0.1.6 plaintext `r` + `sk_spend` blob) and writes
+ * a sentinel under {@link LEGACY_PURGE_SENTINEL_KEY} so subsequent
+ * constructions skip the work. This closes the upgrade-time security gap
+ * without requiring every consumer to explicitly call
+ * {@link LocalStorageAdapter.purgeLegacyNoteStorage}. Consumers using a
+ * non-default legacy key can still call the static helper with their own
+ * key name.
+ */
+declare class LocalStorageAdapter implements StorageAdapter {
+    private keysKey;
+    constructor(keysKey?: string);
+    private getStorage;
+    saveKeys(keys: CloakKeyPair): void;
+    loadKeys(): CloakKeyPair | null;
+    deleteKeys(): void;
     /**
-     * Send SOL privately to multiple recipients
-     *
-     * Convenience method that wraps privateTransfer with a simpler API.
-     * Handles the complete flow: deposits if needed, then sends to recipients.
-     *
-     * @param connection - Solana connection
-     * @param note - Note to spend
-     * @param recipients - Array of 1-5 recipients with amounts
-     * @param options - Optional configuration
-     * @returns Transfer result
-     *
-     * @example
-     * ```typescript
-     * const note = client.generateNote(1_000_000_000);
-     * const result = await client.send(
-     *   connection,
-     *   note,
-     *   [
-     *     { recipient: new PublicKey("..."), amount: 500_000_000 },
-     *     { recipient: new PublicKey("..."), amount: 492_500_000 }
-     *   ]
-     * );
-     * ```
+     * Sentinel key set after the auto-purge runs. Persists across browser
+     * sessions so the purge never re-runs on the same origin.
      */
-    send(connection: Connection, note: CloakNote, recipients: MaxLengthArray<Transfer, 5>, options?: TransferOptions): Promise<TransferResult>;
+    static readonly LEGACY_PURGE_SENTINEL_KEY = "cloak_purged_v0_1_5";
     /**
-     * Swap SOL for tokens privately
-     *
-     * Withdraws SOL from a note and swaps it for tokens via the relay service.
-     * Handles the complete flow: deposits if needed, generates proof, and submits swap.
-     *
-     * @param connection - Solana connection
-     * @param note - Note to spend
-     * @param recipient - Recipient address (will receive tokens)
-     * @param options - Swap configuration
-     * @returns Swap result with transaction signature
-     *
-     * @example
-     * ```typescript
-     * const note = client.generateNote(1_000_000_000);
-     * const result = await client.swap(
-     *   connection,
-     *   note,
-     *   new PublicKey("..."), // recipient
-     *   {
-     *     outputMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC
-     *     slippageBps: 100, // 1%
-     *     getQuote: async (amount, mint, slippage) => {
-     *       // Fetch quote from your swap API
-     *       const quote = await fetchSwapQuote(amount, mint, slippage);
-     *       return {
-     *         outAmount: quote.outAmount,
-     *         minOutputAmount: quote.minOutputAmount
-     *       };
-     *     }
-     *   }
-     * );
-     * ```
+     * Default localStorage key the legacy `<= 0.1.5` SDK used for the
+     * plaintext `CloakNote[]` blob.
      */
-    swap(connection: Connection, note: CloakNote, recipient: PublicKey, options: SwapOptions): Promise<SwapResult>;
+    static readonly LEGACY_NOTES_KEY = "cloak_notes";
     /**
-     * Generate a new note without depositing
-     *
-     * @param amountLamports - Amount for the note
-     * @param useWalletKeys - Whether to use wallet keys (v2.0 recommended)
-     * @returns New note (not yet deposited)
+     * Runs the legacy-purge exactly once per browser origin. Invoked
+     * automatically by the constructor; exposed as a static for tests and
+     * for callers who want to force the check before the first adapter
+     * instantiation.
      */
-    generateNote(amountLamports: number, useWalletKeys?: boolean): Promise<CloakNote>;
+    static runLegacyPurgeOnce(): void;
     /**
-     * Parse a note from JSON string
+     * Manual cleanup helper for callers that stored notes under a non-default
+     * key. The auto-purge in the constructor only handles the canonical
+     * `cloak_notes` slot; pass the custom key here.
      *
-     * @param jsonString - JSON representation
-     * @returns Parsed note
-     */
-    parseNote(jsonString: string): CloakNote;
-    /**
-     * Export a note to JSON string
+     * Pre-0.1.6 versions stored the user's `CloakNote[]` (including
+     * `r` randomness and `sk_spend` secret-key hex) as JSON plaintext.
+     * Those notes are no longer usable (the OLD `withdraw_regular.circom`
+     * flow is incompatible with the deployed UTXO program) but the plaintext
+     * would otherwise linger indefinitely.
      *
-     * @param note - Note to export
-     * @param pretty - Format with indentation
-     * @returns JSON string
-     */
-    exportNote(note: CloakNote, pretty?: boolean): string;
-    /**
-     * Check if a note is ready for withdrawal
+     * Idempotent; safe to call when the key doesn't exist or when running
+     * outside a browser (no-op). Does NOT update the auto-purge sentinel.
      *
-     * @param note - Note to check
-     * @returns True if withdrawable
+     * @param notesKey - localStorage key to remove (default `"cloak_notes"`,
+     *   matching the pre-0.1.6 default).
      */
-    isWithdrawable(note: CloakNote): boolean;
+    static purgeLegacyNoteStorage(notesKey?: string): void;
+}
+
+/** Default Cloak Program ID on Solana mainnet. */
+declare const CLOAK_PROGRAM_ID: PublicKey;
+/**
+ * Constructor options for {@link CloakSDK}.
+ *
+ * Contains *all* the settings a caller can supply at construction time —
+ * including the secret-bearing fields (`keypairBytes`, `wallet`, `cloakKeys`).
+ * Those secrets are consumed into private SDK state and are NOT persisted on
+ * the snapshot returned by {@link CloakSDK.getConfig}; see
+ * {@link CloakConfig} for the (narrower) snapshot shape.
+ */
+interface CloakSDKOptions {
+    /** Keypair bytes for signing (Node.js mode). Consumed into a `Keypair`; not retained. */
+    keypairBytes?: Uint8Array;
+    /** Wallet adapter for signing (browser mode). */
+    wallet?: WalletAdapter;
+    /** Network the SDK targets. Defaults to `"mainnet"`. */
+    network?: Network;
+    /** Cloak key pair for note scanning / encryption. */
+    cloakKeys?: CloakKeyPair;
+    /** Storage adapter for wallet keys (defaults to in-memory). */
+    storage?: StorageAdapter;
+    /** Program ID override (defaults to the mainnet shield-pool). */
+    programId?: PublicKey;
+    /** Relay URL override (defaults to `https://api.cloak.ag`). */
+    relayUrl?: string;
+    /** Enable structured debug logging. Also via env `CLOAK_DEBUG=1` / `DEBUG=cloak:*`. */
+    debug?: boolean;
+}
+/**
+ * Lightweight Cloak client.
+ *
+ * Holds program/relay/storage configuration and exposes a small set of
+ * read-only chain helpers. **All transaction-emitting methods (deposit,
+ * privateTransfer, withdraw, send, swap) were removed in 0.1.6** — they
+ * shipped a legacy `[discriminator: 1, amount: u64, commitment: 32]` deposit
+ * instruction (`createDepositInstruction`) that the on-chain program no
+ * longer understands. Tag `1` is now `TransactSwap`, not `Deposit`, so every
+ * call hit `0x1063 MissingAccounts`. The OLD note model
+ * (3-input `Poseidon(amount, r0, r1, pk_spend)` for `withdraw_regular.circom`)
+ * is also incompatible with the deployed `transaction.circom` UTXO circuit.
+ *
+ * The supported flow is the functional UTXO API:
+ *
+ * ```ts
+ * import {
+ *   transact,
+ *   createUtxo,
+ *   createZeroUtxo,
+ *   generateUtxoKeypair,
+ *   CLOAK_PROGRAM_ID,
+ *   NATIVE_SOL_MINT,
+ * } from "@cloak.dev/sdk";
+ *
+ * const outputKeypair = await generateUtxoKeypair();
+ * const outputUtxo = await createUtxo(amountLamports, outputKeypair);
+ * const result = await transact(
+ *   {
+ *     inputUtxos: [await createZeroUtxo(), await createZeroUtxo()],
+ *     outputUtxos: [outputUtxo, await createZeroUtxo()],
+ *     externalAmount: amountLamports, // positive = deposit
+ *     depositor: payer.publicKey,
+ *   },
+ *   {
+ *     connection,
+ *     programId: CLOAK_PROGRAM_ID,
+ *     relayUrl: "https://api.cloak.ag",
+ *     depositorKeypair: payer,
+ *   },
+ * );
+ * ```
+ *
+ * See `transfer`, `partialWithdraw`, `fullWithdraw`, `swapUtxo` for the
+ * non-deposit flows.
+ */
+declare class CloakSDK {
+    private config;
+    private keypair?;
+    private wallet?;
+    private cloakKeys?;
+    private relay;
+    private storage;
+    constructor(config: CloakSDKOptions);
+    /** Public key of the configured signer (keypair or wallet). */
+    getPublicKey(): PublicKey;
+    /** True when the SDK was constructed with a wallet adapter (browser). */
+    isWalletMode(): boolean;
     /**
-     * Get Merkle proof for a leaf index directly from on-chain state
-     *
-     * @param connection - Solana connection
-     * @param leafIndex - Leaf index in tree
-     * @returns Merkle proof computed from on-chain data
+     * Compute a Merkle proof for `leafIndex` from on-chain state. No relay /
+     * indexer round-trip required.
      */
     getMerkleProof(connection: Connection, leafIndex: number): Promise<MerkleProof>;
-    /**
-     * Get current Merkle root directly from on-chain state
-     *
-     * @param connection - Solana connection
-     * @returns Current root hash from on-chain tree
-     */
+    /** Read the current SOL-pool Merkle root from on-chain state. */
     getCurrentRoot(connection: Connection): Promise<string>;
-    /**
-     * Get transaction status from relay service
-     *
-     * @param requestId - Request ID from previous submission
-     * @returns Current status
-     */
+    /** Poll relay for the status of a previously-submitted request. */
     getTransactionStatus(requestId: string): Promise<TxStatus>;
-    /**
-     * Fetch and decrypt this user's transaction metadata history.
-     * DEPRECATED: This functionality is no longer supported
-     */
-    getTransactionMetadata(_options?: {
-        _after?: number;
-        _before?: number;
-    }): Promise<TransactionMetadata[]>;
-    /**
-     * Load all notes from storage
-     *
-     * @returns Array of saved notes
-     */
-    loadNotes(): Promise<CloakNote[]>;
-    /**
-     * Save a note to storage
-     *
-     * @param note - Note to save
-     */
-    saveNote(note: CloakNote): Promise<void>;
-    /**
-     * Find a note by its commitment
-     *
-     * @param commitment - Commitment hash
-     * @returns Note if found
-     */
-    findNote(commitment: string): Promise<CloakNote | undefined>;
-    /**
-     * Import wallet keys from JSON
-     *
-     * @param keysJson - JSON string containing keys
-     */
+    /** Import wallet keys from JSON; persists to the configured storage adapter. */
     importWalletKeys(keysJson: string): Promise<void>;
     /**
-     * Export wallet keys to JSON
-     *
-     * WARNING: This exports secret keys! Store securely.
+     * Export wallet keys to JSON.
      *
-     * @returns JSON string with keys
+     * WARNING: this exports secret keys. Store securely.
      */
     exportWalletKeys(): string;
     /**
-     * Get the configuration
-     */
-    getConfig(): CloakConfig;
-    /**
-     * Wrap errors with better categorization and user-friendly messages
+     * Snapshot of the active SDK configuration.
      *
-     * @private
+     * The return type ({@link CloakConfig}) is structurally narrower than the
+     * constructor input ({@link CloakSDKOptions}): `keypairBytes`, `wallet`,
+     * and `storage` are intentionally absent from the snapshot. The secrets
+     * are consumed into private SDK state at construction time and are not
+     * re-exposable through this method — the type system enforces it. To
+     * sign, pass a `Keypair` / `WalletAdapter` directly to the standalone
+     * `transact` / `partialWithdraw` / `fullWithdraw` / `swapUtxo` helpers.
      */
-    private wrapError;
+    getConfig(): CloakConfig;
+}
+
+type ComplianceTxType = "deposit" | "withdraw" | "send" | "swap";
+interface TransactionMetadata {
+    amount: number;
+    recipient: string;
+    timestamp: number;
+    txType: ComplianceTxType;
+    commitment: string;
+    signature?: string;
+    outputMint?: string;
+}
+interface EncryptedMetadataBundle {
+    encrypted_user: string;
+    encrypted_compliance: string;
+    user_pubkey: string;
+    commitment: string;
+    timestamp: number;
+    tx_type?: ComplianceTxType;
+    wallet_signature?: string;
+    viewing_key?: string;
 }
 
+interface ViewingKeyPair {
+    privateKey: Uint8Array;
+    publicKey: Uint8Array;
+}
+/** Zcash-style expanded spend key: ask (auth), nsk (nullifier/nk), ovk (outgoing view) */
+interface ExpandedSpendKey {
+    ask: Uint8Array;
+    nsk: Uint8Array;
+    ovk: Uint8Array;
+}
 /**
- * Serialize a note to JSON string
- *
- * @param note - Note to serialize
- * @param pretty - Whether to format with indentation (default: false)
- * @returns JSON string
- *
- * @example
- * ```typescript
- * const json = serializeNote(note, true);
- * console.log(json);
- * // Or save to file, copy to clipboard, etc.
- * ```
+ * Expand spend key into (ask, nsk, ovk) — Zcash-style.
+ * - ask: spend authorization (future)
+ * - nsk: base for incoming viewing (nk) — chain note decryption
+ * - ovk: outgoing viewing (future)
  */
-declare function serializeNote(note: CloakNote, pretty?: boolean): string;
+declare function expandSpendKey(skSpend: Uint8Array): ExpandedSpendKey;
 /**
- * Export note as downloadable JSON (browser only)
+ * Derive chain note viewing key from nk (Zcash-style IVK component).
+ * Used for trial-decrypting incoming chain notes.
  *
- * @param note - Note to export
- * @param filename - Optional custom filename
+ * @param nk 32-byte nk (from expandSpendKey(...).nsk — the incoming view base)
  */
-declare function downloadNote(note: CloakNote, filename?: string): void;
+declare function deriveViewingKeyFromNk(nk: Uint8Array): ViewingKeyPair;
 /**
- * Copy note to clipboard as JSON (browser only)
- *
- * @param note - Note to copy
- * @returns Promise that resolves when copied
+ * Derive diversifier for per-output chain note encryption (Phase 3).
+ * d = BLAKE3("cloak_div_v1" || nk || commitmentHex || outputIndex)[0:11]
  */
-declare function copyNoteToClipboard(note: CloakNote): Promise<void>;
-
+declare function deriveDiversifier(nk: Uint8Array, commitmentHex: string, outputIndex: number): Uint8Array;
 /**
- * Fee calculation utilities for Cloak Protocol
- *
- * The protocol charges a fixed fee plus a variable percentage fee
- * to prevent sybil attacks and cover operational costs.
- *
- * IMPORTANT: These constants are the single source of truth for fee calculations.
- * When updating fees, only change these values - all other code should import from here.
+ * Derive per-output viewing key pair from nk + diversifier (Phase 3).
+ * sk_d = BLAKE3("cloak_sk_d_v1" || nk || d) → clamp → X25519 keypair
  */
-/** Lamports per SOL */
-declare const LAMPORTS_PER_SOL = 1000000000;
-/** Fixed fee: 0.005 SOL (5M lamports) */
-declare const FIXED_FEE_LAMPORTS = 5000000;
-/** Variable fee numerator (3 = 0.3%) */
-declare const VARIABLE_FEE_NUMERATOR = 3;
-/** Variable fee denominator (1000 = divide by 1000) */
-declare const VARIABLE_FEE_DENOMINATOR = 1000;
-/** Variable fee rate as decimal: 0.3% = 0.003 */
-declare const VARIABLE_FEE_RATE: number;
-/** Minimum deposit amount to prevent dust/UX footguns (0.01 SOL). */
-declare const MIN_DEPOSIT_LAMPORTS = 10000000;
+declare function deriveDiversifiedViewingKey(nk: Uint8Array, diversifier: Uint8Array): ViewingKeyPair;
 /**
- * Calculate the total protocol fee for a given amount
- *
- * Formula: FIXED_FEE + floor((amount * VARIABLE_FEE_NUMERATOR) / VARIABLE_FEE_DENOMINATOR)
- *
- * @param amountLamports - Amount in lamports
- * @returns Total fee in lamports
- *
- * @example
- * ```typescript
- * const fee = calculateFee(1_000_000_000); // 1 SOL
- * // Returns: 5_000_000 (fixed) + 3_000_000 (0.3%) = 8_000_000 lamports
- * ```
+ * Derive chain note viewing key from spend key (Zcash-style).
+ * Expands to (ask, nsk, ovk) and uses nsk (nk) for chain note decryption.
  */
-declare function calculateFee(amountLamports: number): number;
-/**
- * Bigint version of calculateFee (for UTXO flows that use bigint lamports).
- */
-declare function calculateFeeBigint(amountLamports: bigint): bigint;
-/**
- * Returns true if a withdrawal amount can pay fees and still leave >0 lamports.
- * (On-chain uses the same integer math and enforces this as well.)
- */
-declare function isWithdrawAmountSufficient(amountLamports: bigint): boolean;
-/**
- * Calculate the distributable amount after protocol fees
- *
- * This is the amount available to send to recipients.
- *
- * @param amountLamports - Total note amount in lamports
- * @returns Amount available for recipients in lamports
- *
- * @example
- * ```typescript
- * const distributable = getDistributableAmount(1_000_000_000);
- * // Returns: 1_000_000_000 - 7_500_000 = 992_500_000 lamports
- * ```
- */
-declare function getDistributableAmount(amountLamports: number): number;
-/**
- * Format lamports as SOL string
- *
- * @param lamports - Amount in lamports
- * @param decimals - Number of decimal places (default: 9)
- * @returns Formatted string (e.g., "1.000000000")
- *
- * @example
- * ```typescript
- * formatAmount(1_000_000_000); // "1.000000000"
- * formatAmount(1_500_000_000); // "1.500000000"
- * formatAmount(123_456_789, 4); // "0.1235"
- * ```
- */
-declare function formatAmount(lamports: number, decimals?: number): string;
-/**
- * Parse SOL string to lamports
- *
- * @param sol - SOL amount as string (e.g., "1.5")
- * @returns Amount in lamports
- * @throws Error if invalid format
- *
- * @example
- * ```typescript
- * parseAmount("1.5"); // 1_500_000_000
- * parseAmount("0.001"); // 1_000_000
- * ```
- */
-declare function parseAmount(sol: string): number;
-/**
- * Validate that outputs sum equals expected amount
- *
- * @param outputs - Array of output amounts
- * @param expectedTotal - Expected total amount
- * @returns True if amounts match
- */
-declare function validateOutputsSum(outputs: Array<{
-    amount: number;
-}>, expectedTotal: number): boolean;
-/**
- * Calculate relay fee from basis points
- *
- * @param amountLamports - Amount in lamports
- * @param feeBps - Fee in basis points (100 bps = 1%)
- * @returns Relay fee in lamports
- *
- * @example
- * ```typescript
- * calculateRelayFee(1_000_000_000, 50); // 0.5% = 5_000_000 lamports
- * ```
- */
-declare function calculateRelayFee(amountLamports: number, feeBps: number): number;
-
-/**
- * Note Manager
- *
- * Standalone note management - no browser dependencies.
- * Storage is handled externally via StorageAdapter.
- *
- * Core functionality:
- * - Generate notes (v1.0 and v2.0)
- * - Parse and validate notes
- * - Note utilities (formatting, fees, etc.)
- * - Key management (without storage)
- */
-
-/**
- * Generate a new note without wallet keys (legacy v1.0)
- * Uses Poseidon hashing to match circuit implementation
- * @deprecated Use generateNoteFromWallet instead for enhanced security
- */
-declare function generateNote(amountLamports: number, network?: Network): Promise<CloakNote>;
-/**
- * Generate a note using wallet's spend key (v2.0 recommended)
- * Uses Poseidon hashing to match circuit implementation
- */
-declare function generateNoteFromWallet(amountLamports: number, keys: CloakKeyPair, network?: Network): Promise<CloakNote>;
-/**
- * Parse and validate a note from JSON string
- */
-declare function parseNote(jsonString: string): CloakNote;
-/**
- * Export note to JSON string
- */
-declare function exportNote(note: CloakNote, pretty?: boolean): string;
-/**
- * Check if a note is withdrawable (has been deposited)
- * Note: merkleProof is optional - it may be fetched lazily at withdrawal time
- */
-declare function isWithdrawable(note: CloakNote): boolean;
-/**
- * Update note with deposit information
- * Returns a new note object with deposit info added
- */
-declare function updateNoteWithDeposit(note: CloakNote, depositInfo: {
-    signature: string;
-    slot: number;
-    leafIndex: number;
-    root: string;
-    merkleProof?: {
-        pathElements: string[];
-        pathIndices: number[];
-    };
-}): CloakNote;
-/**
- * Find note by commitment from an array
- */
-declare function findNoteByCommitment(notes: CloakNote[], commitment: string): CloakNote | undefined;
-/**
- * Filter notes by network
- */
-declare function filterNotesByNetwork(notes: CloakNote[], network: Network): CloakNote[];
-/**
- * Filter notes that can be withdrawn
- */
-declare function filterWithdrawableNotes(notes: CloakNote[]): CloakNote[];
-/**
- * Export keys to JSON string
- * WARNING: This exports secret keys! Store securely.
- */
-declare function exportWalletKeys(keys: CloakKeyPair): string;
-/**
- * Import keys from JSON string
- */
-declare function importWalletKeys(keysJson: string): CloakKeyPair;
-/**
- * Get public view key from keys
- */
-declare function getPublicViewKey(keys: CloakKeyPair): string;
-/**
- * Get view key from keys
- */
-declare function getViewKey(keys: CloakKeyPair): ViewKey;
-/**
- * Get recipient amount after fees
- */
-declare function getRecipientAmount(amountLamports: number): number;
-
-interface ViewingKeyPair {
-    privateKey: Uint8Array;
-    publicKey: Uint8Array;
-}
-/** Zcash-style expanded spend key: ask (auth), nsk (nullifier/nk), ovk (outgoing view) */
-interface ExpandedSpendKey {
-    ask: Uint8Array;
-    nsk: Uint8Array;
-    ovk: Uint8Array;
-}
-/**
- * Expand spend key into (ask, nsk, ovk) — Zcash-style.
- * - ask: spend authorization (future)
- * - nsk: base for incoming viewing (nk) — chain note decryption
- * - ovk: outgoing viewing (future)
- */
-declare function expandSpendKey(skSpend: Uint8Array): ExpandedSpendKey;
-/**
- * Derive chain note viewing key from nk (Zcash-style IVK component).
- * Used for trial-decrypting incoming chain notes.
- *
- * @param nk 32-byte nk (from expandSpendKey(...).nsk — the incoming view base)
- */
-declare function deriveViewingKeyFromNk(nk: Uint8Array): ViewingKeyPair;
-/**
- * Derive diversifier for per-output chain note encryption (Phase 3).
- * d = BLAKE3("cloak_div_v1" || nk || commitmentHex || outputIndex)[0:11]
- */
-declare function deriveDiversifier(nk: Uint8Array, commitmentHex: string, outputIndex: number): Uint8Array;
-/**
- * Derive per-output viewing key pair from nk + diversifier (Phase 3).
- * sk_d = BLAKE3("cloak_sk_d_v1" || nk || d) → clamp → X25519 keypair
- */
-declare function deriveDiversifiedViewingKey(nk: Uint8Array, diversifier: Uint8Array): ViewingKeyPair;
-/**
- * Derive chain note viewing key from spend key (Zcash-style).
- * Expands to (ask, nsk, ovk) and uses nsk (nk) for chain note decryption.
- */
-declare function deriveViewingKeyFromSpendKey(skSpend: Uint8Array): ViewingKeyPair;
+declare function deriveViewingKeyFromSpendKey(skSpend: Uint8Array): ViewingKeyPair;
 /**
  * Derive chain note viewing key from UTXO private key (Zcash-style).
  * New UTXO (new keypair) => new viewing key.
@@ -1243,137 +541,6 @@ declare function computeMerkleRoot(leaf: bigint, pathElements: bigint[], pathInd
  * Convert hex string to bigint
  */
 declare function hexToBigint$1(hex: string): bigint;
-/**
- * Compute commitment = Poseidon(amount, r0, r1, pk_spend)
- * where pk_spend = Poseidon(sk0, sk1)
- * (matching withdraw_regular.circom)
- *
- * This is the test-style function that takes bigints directly
- *
- * @param amount - Amount as bigint
- * @param r - Randomness as bigint
- * @param sk_spend - Spending secret key as bigint
- * @returns Commitment hash as bigint
- */
-declare function computeCommitment$1(amount: bigint, r: bigint, sk_spend: bigint): Promise<bigint>;
-/**
- * Generate a Poseidon commitment for a note
- *
- * Formula: Poseidon(amount, r0, r1, pk_spend)
- * where pk_spend = Poseidon(sk0, sk1)
- *
- * This matches the withdraw_regular.circom circuit
- *
- * @param amountLamports - Amount in lamports
- * @param r - Randomness bytes (32 bytes)
- * @param skSpend - Spending secret key bytes (32 bytes)
- * @returns Commitment hash as bigint
- */
-declare function generateCommitmentAsync(amountLamports: number, r: Uint8Array, skSpend: Uint8Array): Promise<bigint>;
-/**
- * Generate a Poseidon commitment for a note (sync wrapper)
- * Returns bytes instead of bigint for backward compatibility
- *
- * @deprecated Use generateCommitmentAsync instead
- */
-declare function generateCommitment(_amountLamports: number, _r: Uint8Array, _skSpend: Uint8Array): Uint8Array;
-/**
- * Compute nullifier = Poseidon(sk0, sk1, leaf_index)
- * (matching withdraw_regular.circom)
- *
- * This is the test-style function that takes bigint directly
- *
- * @param sk_spend - Spending secret key as bigint
- * @param leafIndex - Index in the Merkle tree as bigint
- * @returns Nullifier as bigint
- */
-declare function computeNullifier$1(sk_spend: bigint, leafIndex: bigint): Promise<bigint>;
-/**
- * Compute nullifier from spending key and leaf index
- *
- * Formula: Poseidon(sk0, sk1, leaf_index)
- *
- * This matches the circuit's nullifier computation
- *
- * @param skSpend - Spending secret key bytes (32 bytes) or hex string
- * @param leafIndex - Index in the Merkle tree
- * @returns Nullifier as bigint
- */
-declare function computeNullifierAsync(skSpend: Uint8Array | string, leafIndex: number): Promise<bigint>;
-/**
- * Compute nullifier (sync wrapper for backward compatibility)
- * @deprecated Use computeNullifierAsync instead
- */
-declare function computeNullifierSync(_skSpend: Uint8Array, _leafIndex: number): Uint8Array;
-/**
- * Compute outputs hash from recipients and amounts
- *
- * Formula: Chain of Poseidon(prev_hash, addr_lo, addr_hi, amount) for each active output
- *
- * This matches the withdraw_regular.circom circuit's outputs hash computation
- *
- * @param outputs - Array of {recipient: PublicKey, amount: number}
- * @returns Outputs hash as bigint
- */
-declare function computeOutputsHashAsync(outputs: Array<{
-    recipient: PublicKey;
-    amount: number;
-}>): Promise<bigint>;
-/**
- * Compute outputs hash for withdraw_regular circuit
- * outputs_hash = chain of Poseidon(prev_hash, addr_lo, addr_hi, amount) for each active output
- *
- * This is the test-style function that takes raw limbs
- *
- * @param outAddr - Array of [lo, hi] limb pairs for each address (5x2 array)
- * @param outAmount - Array of amounts as bigints (5 elements)
- * @param outFlags - Array of flags (1 = active, 0 = inactive) (5 elements)
- * @returns Outputs hash as bigint
- */
-declare function computeOutputsHash(outAddr: bigint[][], outAmount: bigint[], outFlags: number[]): Promise<bigint>;
-/**
- * Compute outputs hash (sync wrapper for backward compatibility)
- * @deprecated Use computeOutputsHashAsync instead
- */
-declare function computeOutputsHashSync(_outputs: Array<{
-    recipient: PublicKey;
-    amount: number;
-}>): Uint8Array;
-/**
- * Compute outputs hash for withdraw_swap circuit
- * outputs_hash = Poseidon(input_mint limbs, output_mint limbs, recipient_ata limbs, min_output_amount, public_amount)
- *
- * This is the test-style function that takes raw limbs
- *
- * @param inputMintLimbs - Input mint address as [lo, hi] limbs
- * @param outputMintLimbs - Output mint address as [lo, hi] limbs
- * @param recipientAtaLimbs - Recipient ATA as [lo, hi] limbs
- * @param minOutputAmount - Minimum output amount as bigint
- * @param publicAmount - Public amount as bigint
- * @returns Outputs hash as bigint
- */
-declare function computeSwapOutputsHash(inputMintLimbs: [bigint, bigint], outputMintLimbs: [bigint, bigint], recipientAtaLimbs: [bigint, bigint], minOutputAmount: bigint, publicAmount: bigint): Promise<bigint>;
-/**
- * Compute outputs hash for swap transactions
- *
- * Formula: Poseidon(input_mint_lo, input_mint_hi, output_mint_lo, output_mint_hi,
- *                   recipient_ata_lo, recipient_ata_hi, min_output_amount, public_amount)
- *
- * This matches the withdraw_swap.circom circuit
- *
- * @param inputMint - Input token mint address (SOL = SystemProgram)
- * @param outputMint - Output token mint address
- * @param recipientAta - Recipient's associated token account
- * @param minOutputAmount - Minimum output amount in token's smallest unit
- * @param amount - Note amount in lamports (public_amount)
- * @returns Outputs hash as bigint
- */
-declare function computeSwapOutputsHashAsync(inputMint: PublicKey, outputMint: PublicKey, recipientAta: PublicKey, minOutputAmount: number, amount: number): Promise<bigint>;
-/**
- * Compute swap outputs hash (sync wrapper for backward compatibility)
- * @deprecated Use computeSwapOutputsHashAsync instead
- */
-declare function computeSwapOutputsHashSync(_outputMint: PublicKey, _recipientAta: PublicKey, _minOutputAmount: number, _amount: number): Uint8Array;
 /**
  * Convert bigint to 32-byte big-endian Uint8Array
  */
@@ -1436,57 +603,145 @@ declare function proofToBytes(proof: Groth16Proof): Uint8Array;
 declare function buildPublicInputsBytes(root: bigint, nullifier: bigint, outputsHash: bigint, publicAmount: bigint): Uint8Array;
 
 /**
- * Validate a Solana public key
+ * Fee calculation utilities for Cloak Protocol
  *
- * @param address - Address string to validate
- * @returns True if valid Solana address
- */
-declare function isValidSolanaAddress(address: string): boolean;
-/**
- * Validate a Cloak note structure
+ * The protocol charges a fixed fee plus a variable percentage fee
+ * to prevent sybil attacks and cover operational costs.
  *
- * @param note - Note object to validate
- * @throws Error if invalid
+ * IMPORTANT: These constants are the single source of truth for fee calculations.
+ * When updating fees, only change these values - all other code should import from here.
  */
-declare function validateNote(note: any): asserts note is CloakNote;
+/** Lamports per SOL */
+declare const LAMPORTS_PER_SOL = 1000000000;
+/** Fixed fee: 0.005 SOL (5M lamports) */
+declare const FIXED_FEE_LAMPORTS = 5000000;
+/** Variable fee numerator (3 = 0.3%) */
+declare const VARIABLE_FEE_NUMERATOR = 3;
+/** Variable fee denominator (1000 = divide by 1000) */
+declare const VARIABLE_FEE_DENOMINATOR = 1000;
+/** Variable fee rate as decimal: 0.3% = 0.003 */
+declare const VARIABLE_FEE_RATE: number;
+/** Minimum deposit amount to prevent dust/UX footguns (0.01 SOL). */
+declare const MIN_DEPOSIT_LAMPORTS = 10000000;
 /**
- * Validate that a note is ready for withdrawal
+ * Calculate the total protocol fee for a given amount
  *
- * @param note - Note to validate
- * @throws Error if note cannot be used for withdrawal
- */
-declare function validateWithdrawableNote(note: CloakNote): void;
-/**
- * Validate transfer recipients
+ * Formula: FIXED_FEE + floor((amount * VARIABLE_FEE_NUMERATOR) / VARIABLE_FEE_DENOMINATOR)
  *
- * @param recipients - Array of transfers to validate
- * @param totalAmount - Total amount available
- * @throws Error if invalid
- */
-declare function validateTransfers(recipients: Array<{
-    recipient: PublicKey;
-    amount: number;
-}>, totalAmount: number): void;
-
-/**
- * Network Utilities
+ * @param amountLamports - Amount in lamports
+ * @returns Total fee in lamports
  *
- * Helper functions for network detection and configuration
+ * @example
+ * ```typescript
+ * const fee = calculateFee(1_000_000_000); // 1 SOL
+ * // Returns: 5_000_000 (fixed) + 3_000_000 (0.3%) = 8_000_000 lamports
+ * ```
  */
-
+declare function calculateFee(amountLamports: number): number;
 /**
- * Detect network from RPC URL
- *
- * Attempts to detect the Solana network from common RPC URL patterns.
- * Falls back to devnet if unable to detect.
+ * Bigint version of calculateFee (for UTXO flows that use bigint lamports).
  */
-declare function detectNetworkFromRpcUrl(rpcUrl?: string): Network;
+declare function calculateFeeBigint(amountLamports: bigint): bigint;
 /**
- * Get the standard RPC URL for a network
+ * Returns true if a withdrawal amount can pay fees and still leave >0 lamports.
+ * (On-chain uses the same integer math and enforces this as well.)
  */
-declare function getRpcUrlForNetwork(network: Network): string;
+declare function isWithdrawAmountSufficient(amountLamports: bigint): boolean;
 /**
- * Validate RPC URL format
+ * Calculate the distributable amount after protocol fees
+ *
+ * This is the amount available to send to recipients.
+ *
+ * @param amountLamports - Total note amount in lamports
+ * @returns Amount available for recipients in lamports
+ *
+ * @example
+ * ```typescript
+ * const distributable = getDistributableAmount(1_000_000_000);
+ * // Returns: 1_000_000_000 - 7_500_000 = 992_500_000 lamports
+ * ```
+ */
+declare function getDistributableAmount(amountLamports: number): number;
+/**
+ * Format lamports as SOL string
+ *
+ * @param lamports - Amount in lamports
+ * @param decimals - Number of decimal places (default: 9)
+ * @returns Formatted string (e.g., "1.000000000")
+ *
+ * @example
+ * ```typescript
+ * formatAmount(1_000_000_000); // "1.000000000"
+ * formatAmount(1_500_000_000); // "1.500000000"
+ * formatAmount(123_456_789, 4); // "0.1235"
+ * ```
+ */
+declare function formatAmount(lamports: number, decimals?: number): string;
+/**
+ * Parse SOL string to lamports
+ *
+ * @param sol - SOL amount as string (e.g., "1.5")
+ * @returns Amount in lamports
+ * @throws Error if invalid format
+ *
+ * @example
+ * ```typescript
+ * parseAmount("1.5"); // 1_500_000_000
+ * parseAmount("0.001"); // 1_000_000
+ * ```
+ */
+declare function parseAmount(sol: string): number;
+/**
+ * Validate that outputs sum equals expected amount
+ *
+ * @param outputs - Array of output amounts
+ * @param expectedTotal - Expected total amount
+ * @returns True if amounts match
+ */
+declare function validateOutputsSum(outputs: Array<{
+    amount: number;
+}>, expectedTotal: number): boolean;
+/**
+ * Calculate relay fee from basis points
+ *
+ * @param amountLamports - Amount in lamports
+ * @param feeBps - Fee in basis points (100 bps = 1%)
+ * @returns Relay fee in lamports
+ *
+ * @example
+ * ```typescript
+ * calculateRelayFee(1_000_000_000, 50); // 0.5% = 5_000_000 lamports
+ * ```
+ */
+declare function calculateRelayFee(amountLamports: number, feeBps: number): number;
+
+/**
+ * Validate that a string is a valid Solana public key.
+ *
+ * @param address - Address string to validate
+ * @returns True if valid Solana address
+ */
+declare function isValidSolanaAddress(address: string): boolean;
+
+/**
+ * Network Utilities
+ *
+ * Helper functions for network detection and configuration
+ */
+
+/**
+ * Detect network from RPC URL
+ *
+ * Attempts to detect the Solana network from common RPC URL patterns.
+ * Falls back to devnet if unable to detect.
+ */
+declare function detectNetworkFromRpcUrl(rpcUrl?: string): Network;
+/**
+ * Get the standard RPC URL for a network
+ */
+declare function getRpcUrlForNetwork(network: Network): string;
+/**
+ * Validate RPC URL format
  */
 declare function isValidRpcUrl(url: string): boolean;
 /**
@@ -1498,6 +753,85 @@ declare function getExplorerUrl(signature: string, network?: Network): string;
  */
 declare function getAddressExplorerUrl(address: string, network?: Network): string;
 
+/**
+ * Merkle Tree implementation for computing proofs
+ *
+ * This tree stores all leaves and can compute the correct Merkle path
+ * for any leaf index.
+ */
+declare const MERKLE_TREE_HEIGHT = 32;
+/**
+ * Merkle Tree class that stores all leaves and computes proofs
+ */
+declare class MerkleTree {
+    private levels;
+    private capacity;
+    private layers;
+    private zeros;
+    private poseidon;
+    /**
+     * Create a new Merkle tree
+     * @param levels Number of levels in the tree (height)
+     * @param leaves Initial leaves to insert
+     * @param zeros Precomputed zero values for each level
+     * @param poseidon Pre-initialized Poseidon instance (avoids async in constructor)
+     */
+    constructor(levels: number, leaves: bigint[], zeros: bigint[], poseidon: any);
+    /**
+     * Create a new MerkleTree with async initialization
+     */
+    static create(levels?: number, leaves?: bigint[]): Promise<MerkleTree>;
+    /**
+     * Rebuild the tree from the leaves (synchronous — poseidon must be initialized)
+     */
+    private _rebuildSync;
+    /**
+     * Get the tree root
+     */
+    root(): bigint;
+    /**
+     * Get the number of leaves in the tree
+     */
+    get length(): number;
+    /**
+     * Insert a new leaf into the tree
+     */
+    insert(leaf: bigint): void;
+    /**
+     * Insert multiple leaves
+     */
+    bulkInsert(leaves: bigint[]): void;
+    /**
+     * Update the path from a leaf to the root
+     */
+    private _updatePath;
+    /**
+     * Get the Merkle path for a leaf at the given index
+     * @param index Leaf index
+     * @returns pathElements and pathIndices for the proof
+     */
+    path(index: number): {
+        pathElements: bigint[];
+        pathIndices: number;
+    };
+    /**
+     * Find the index of a leaf in the tree
+     * @param leaf Leaf value to find
+     * @returns Index if found, -1 otherwise
+     */
+    indexOf(leaf: bigint): number;
+    /**
+     * Get all leaves
+     */
+    leaves(): bigint[];
+}
+/**
+ * Build a MerkleTree from commitment values
+ * @param commitments Array of commitment bigints
+ * @param height Tree height (default: 32)
+ */
+declare function buildMerkleTree(commitments: bigint[], height?: number): Promise<MerkleTree>;
+
 /**
  * Error Utilities
  *
@@ -1529,6 +863,79 @@ declare function parseRelayErrorResponse(responseText: string): {
     isRootNotFound: boolean;
     currentRoot?: string;
 };
+/**
+ * Raised when a spend attempt hits 0x1020 DoubleSpend on-chain — the input
+ * UTXO's nullifier PDA already exists, meaning the UTXO was spent earlier
+ * (often via another device / session the user forgot about).
+ *
+ * Recovery path: the SDK's pre-flight nullifier check catches this BEFORE
+ * proof generation via `verifyUtxos()`. If thrown after submission (unlikely
+ * once pre-flight is wired in), the caller should call `verifyUtxos()` to
+ * reconcile local state with chain.
+ */
+declare class UtxoAlreadySpentError extends Error {
+    readonly spentUtxoCommitments: string[];
+    constructor(message: string, spentUtxoCommitments?: string[]);
+}
+/**
+ * Base class for Range / sanctions-quote mismatches from the on-chain
+ * program. The relay signs quotes; the program verifies them. When they
+ * don't line up we hit one of three errors:
+ *
+ *   0x10B0 = QuoteExpired  — quote's expiry_ts < on-chain clock
+ *   0x10B2 = WalletMismatch — quote wallet != expected_wallet
+ *   0x10B3 = MissingEd25519 — no withdraw-auth / range-quote ix at all
+ *
+ * These are structural mismatches the caller can't fix on their own —
+ * they indicate a relay / program version skew or a config drift
+ * (e.g. pool not initialized with the expected range_signer).
+ */
+declare class SanctionsQuoteError extends Error {
+    readonly onChainCode: number;
+    readonly subKind: "expired" | "wallet_mismatch" | "missing_ix";
+    constructor(message: string, onChainCode: number, subKind: "expired" | "wallet_mismatch" | "missing_ix");
+}
+/**
+ * Generic catch-all for relay 500s that don't map to any structured class.
+ * Preserves the raw relay error text in `relayMessage` so the caller can
+ * log it without having to string-match.
+ */
+declare class RelayInternalError extends Error {
+    readonly relayMessage?: string | undefined;
+    readonly httpStatus?: number | undefined;
+    /**
+     * Optional pre-built merkle tree rebuilt from chain (Node only).
+     * Populated by the chain-replay fallback in `transact()` when the
+     * relay-tree path fails after all retries. Callers can retry the
+     * spend with `options.cachedMerkleTree = err.cachedTreeFromChain`
+     * without paying the chain-replay cost a second time.
+     *
+     * Typed via `import type` so there's no runtime coupling between
+     * this module and the MerkleTree implementation.
+     */
+    readonly cachedTreeFromChain?: MerkleTree | undefined;
+    constructor(message: string, relayMessage?: string | undefined, httpStatus?: number | undefined, 
+    /**
+     * Optional pre-built merkle tree rebuilt from chain (Node only).
+     * Populated by the chain-replay fallback in `transact()` when the
+     * relay-tree path fails after all retries. Callers can retry the
+     * spend with `options.cachedMerkleTree = err.cachedTreeFromChain`
+     * without paying the chain-replay cost a second time.
+     *
+     * Typed via `import type` so there's no runtime coupling between
+     * this module and the MerkleTree implementation.
+     */
+    cachedTreeFromChain?: MerkleTree | undefined);
+}
+/**
+ * Classify a relay error (response body text + HTTP status) into one of the
+ * structured error types above, or fall back to RelayInternalError.
+ *
+ * Order matters — more specific first. RootNotFoundError is handled by the
+ * caller separately (existing code path) since it carries `current_root` in
+ * the response body.
+ */
+declare function classifyRelayError(responseText: string, httpStatus?: number): Error;
 /**
  * Shield Pool Program Error Codes
  *
@@ -1578,1228 +985,871 @@ declare function createCloakError(error: unknown, _context: string): CloakError;
 declare function formatErrorForLogging(error: unknown): string;
 
 /**
- * Structured Logger for Cloak SDK
- *
- * Provides structured logging similar to Rust tracing format:
- * 2026-01-23T00:51:46.489317Z  INFO cloak::module: 📥 Message key=value
+ * UTXO (Unspent Transaction Output) Model
  *
- * Enable via:
- * - SDK config: new CloakSDK({ debug: true })
- * - Environment: CLOAK_DEBUG=1 or DEBUG=cloak:*
- */
-type LogLevel = "DEBUG" | "INFO" | "WARN" | "ERROR";
-/**
- * Enable or disable debug logging globally
- */
-declare function setDebugMode(enabled: boolean): void;
-/**
- * Check if debug mode is enabled
+ * This module implements the UTXO model for the Cloak privacy protocol.
+ * UTXOs allow for:
+ * - Shield-to-shield transfers (privacy preserved)
+ * - Partial withdrawals (change stays shielded)
+ * - Combining multiple small deposits
+ * - Multi-token support (SOL + any SPL token)
  */
-declare function isDebugEnabled(): boolean;
+
+declare const NATIVE_SOL_MINT: PublicKey;
 /**
- * Logger interface
+ * UTXO Keypair for ownership verification
+ *
+ * Uses Poseidon hash for key derivation:
+ * - privateKey: random field element (kept secret)
+ * - publicKey: Poseidon(privateKey, 0) - can be shared
  */
-interface Logger {
-    debug: (message: string, kvPairs?: Record<string, unknown>) => void;
-    info: (message: string, kvPairs?: Record<string, unknown>) => void;
-    warn: (message: string, kvPairs?: Record<string, unknown>) => void;
-    error: (message: string, kvPairs?: Record<string, unknown>) => void;
+interface UtxoKeypair {
+    /** Private key (random 252-bit field element) */
+    privateKey: bigint;
+    /** Public key derived as Poseidon(privateKey, 0) */
+    publicKey: bigint;
 }
 /**
- * Create a logger for a specific module
- *
- * @param module - Module name (e.g., "cloak::sdk", "cloak::indexer")
- * @returns Logger instance with debug, info, warn, error methods
+ * UTXO represents an unspent transaction output
  *
- * @example
- * ```typescript
- * const log = createLogger("cloak::deposit");
- * log.info("Depositing", { amount: 100000000 });
- * // Output: 2026-01-23T00:51:46.489000Z  INFO cloak::deposit: Depositing amount=100000000
- * ```
+ * Contains all information needed to spend the UTXO:
+ * - amount: Value in the smallest unit (lamports for SOL)
+ * - keypair: Ownership keys
+ * - blinding: Randomness for hiding
+ * - mintAddress: Token type (SOL or SPL token)
+ * - index: Leaf index in Merkle tree (set after deposit/creation)
  */
-declare function createLogger(module: string): Logger;
-/**
- * Measure and return duration of an async operation
- *
- * @param _logger - Logger instance (reserved for future debug logging)
- * @param _operation - Operation name (reserved for future debug logging)
- * @param fn - Async function to measure
- * @returns Result and duration in milliseconds
- */
-declare function withTiming<T>(_logger: Logger, _operation: string, fn: () => Promise<T>): Promise<{
-    result: T;
-    durationMs: number;
-}>;
-/**
- * Format lamports as SOL with proper decimals
- */
-declare function formatSol(lamports: number | bigint): string;
-/**
- * Truncate a string (useful for signatures, hashes)
- */
-declare function truncate(str: string, len?: number): string;
+interface Utxo {
+    /** Amount in the smallest unit (lamports for SOL, token units for SPL) */
+    amount: bigint;
+    /** Keypair for ownership */
+    keypair: UtxoKeypair;
+    /** Random blinding factor */
+    blinding: bigint;
+    /** Token mint address (NATIVE_SOL_MINT for SOL) */
+    mintAddress: PublicKey;
+    /** Leaf index in Merkle tree (set after the UTXO is in the tree) */
+    index?: number;
+    /** Commitment hash (computed from amount, pubkey, blinding, mint) */
+    commitment?: bigint;
+    /** Nullifier hash (computed when spending) */
+    nullifier?: bigint;
+    /**
+     * Sibling commitment at level 0 of the Merkle tree.
+     * Required for Merkle proofs since siblings aren't stored on-chain.
+     * This is the commitment of the other output in the same transaction.
+     */
+    siblingCommitment?: bigint;
+}
 /**
- * Default SDK logger instance
+ * Encrypted UTXO note for recipient discovery
+ *
+ * When creating an output UTXO for someone else, the data is encrypted
+ * so only the recipient can discover and spend it.
  */
-declare const sdkLogger: Logger;
-
+interface EncryptedNote {
+    /** Encrypted UTXO data (ECIES/ChaCha20 encrypted) */
+    ciphertext: Uint8Array;
+    /** Ephemeral public key for ECDH */
+    ephemeralPubkey: Uint8Array;
+    /** MAC for integrity verification */
+    mac: Uint8Array;
+}
 /**
- * Result from submitting a withdrawal that includes the request ID
- * for potential recovery/resume scenarios
+ * Transaction parameters for a UTXO transaction
  */
-interface WithdrawSubmissionResult {
-    /** The relay request ID - persist this for recovery */
-    requestId: string;
-    /** The final transaction signature */
-    signature: string;
+interface TransactParams {
+    /** Input UTXOs to spend (max 2) */
+    inputUtxos: Utxo[];
+    /** Output UTXOs to create (max 2) */
+    outputUtxos: Utxo[];
+    /** External recipient for withdrawal (optional) */
+    recipient?: PublicKey;
+    /** Net external amount: positive = deposit, negative = withdraw */
+    externalAmount?: bigint;
+    /** Depositor address (for deposits, the source of funds) */
+    depositor?: PublicKey;
 }
 /**
- * Relay Service Client
- *
- * Handles submission of withdrawal transactions through a relay service
- * that pays for transaction fees and submits the transaction on-chain.
+ * Result from a UTXO transaction
  */
-declare class RelayService {
-    private baseUrl;
-    /**
-     * Create a new Relay Service client
-     *
-     * @param baseUrl - Relay service base URL
-     */
-    constructor(baseUrl: string);
-    /**
-     * Submit a withdrawal transaction via relay
-     *
-     * The relay service will validate the proof, pay for transaction fees,
-     * and submit the transaction on-chain.
-     *
-     * @param params - Withdrawal parameters
-     * @param onStatusUpdate - Optional callback for status updates
-     * @param onRequestId - CRITICAL: Callback when request_id is received.
-     *                      Persist this ID to recover if browser crashes during polling.
-     * @returns Transaction signature when completed
-     *
-     * @example
-     * ```typescript
-     * const signature = await relay.submitWithdraw({
-     *   proof: proofHex,
-     *   publicInputs: { root, nf, outputs_hash, amount },
-     *   outputs: [{ recipient: addr, amount: lamports }],
-     *   feeBps: 50
-     * }, (status) => console.log(`Status: ${status}`),
-     *    (requestId) => localStorage.setItem('pending_withdraw', requestId));
-     * console.log(`Transaction: ${signature}`);
-     * ```
-     */
-    submitWithdraw(params: {
-        proof: string;
-        publicInputs: {
-            root: string;
-            nf: string;
-            outputs_hash: string;
-            amount: number;
-        };
-        outputs: Array<{
-            recipient: string;
-            amount: number;
-        }>;
-        feeBps: number;
-        metadataBundle?: EncryptedMetadataBundle;
-    }, onStatusUpdate?: (status: string) => void, onRequestId?: (requestId: string) => void): Promise<string>;
-    /**
-     * Resume polling for a withdrawal that was previously started
-     *
-     * Use this after page reload to check status of a pending withdrawal.
-     * The requestId should have been persisted via the onRequestId callback.
-     *
-     * @param requestId - Request ID from a previous submitWithdraw call
-     * @param onStatusUpdate - Optional callback for status updates
-     * @returns Transaction signature if completed, null if still pending/failed
-     *
-     * @example
-     * ```typescript
-     * // On page load, check for pending withdrawal
-     * const pendingId = localStorage.getItem('pending_withdraw');
-     * if (pendingId) {
-     *   const result = await relay.resumeWithdraw(pendingId);
-     *   if (result.status === 'completed') {
-     *     console.log('Withdrawal completed:', result.signature);
-     *     localStorage.removeItem('pending_withdraw');
-     *   }
-     * }
-     * ```
-     */
-    resumeWithdraw(requestId: string, onStatusUpdate?: (status: string) => void): Promise<{
-        status: 'completed' | 'failed' | 'pending';
-        signature?: string;
-        error?: string;
-    }>;
-    /**
-     * Poll for withdrawal completion
-     *
-     * @param requestId - Request ID from relay service
-     * @param onStatusUpdate - Optional callback for status updates
-     * @returns Transaction signature when completed
-     */
-    private pollForCompletion;
+interface TransactResult {
+    /** Transaction signature */
+    signature: string;
+    /** Nullifiers of spent inputs */
+    inputNullifiers: bigint[];
+    /** Commitments of created outputs */
+    outputCommitments: bigint[];
+    /** New Merkle root after the transaction */
+    newRoot: string;
+    /** Merkle tree indices where output commitments were inserted */
+    commitmentIndices: [number, number];
     /**
-     * Submit a swap transaction via relay
-     *
-     * Similar to submitWithdraw but includes swap parameters for token swaps.
-     * The relay service will validate the proof, execute the swap, pay for fees,
-     * and submit the transaction on-chain.
-     *
-     * @param params - Swap parameters
-     * @param onStatusUpdate - Optional callback for status updates
-     * @returns Transaction signature when completed
-     *
-     * @example
-     * ```typescript
-     * const signature = await relay.submitSwap({
-     *   proof: proofHex,
-     *   publicInputs: { root, nf, outputs_hash, amount },
-     *   outputs: [{ recipient: addr, amount: lamports }],
-     *   feeBps: 50,
-     *   swap: {
-     *     output_mint: tokenMint.toBase58(),
-     *     slippage_bps: 100,
-     *     min_output_amount: minAmount
-     *   }
-     * }, (status) => console.log(`Status: ${status}`));
-     * console.log(`Transaction: ${signature}`);
-     * ```
+     * Sibling commitments for each output.
+     * For output[0], sibling is output[1] and vice versa.
+     * These are needed for Merkle proofs since siblings aren't stored on-chain.
      */
-    submitSwap(params: {
-        proof: string;
-        publicInputs: {
-            root: string;
-            nf: string;
-            outputs_hash: string;
-            amount: number;
-        };
-        outputs: Array<{
-            recipient: string;
-            amount: number;
-        }>;
-        feeBps: number;
-        swap: {
-            output_mint: string;
-            slippage_bps: number;
-            min_output_amount: number;
-        };
-        metadataBundle?: EncryptedMetadataBundle;
-    }, onStatusUpdate?: (status: string) => void, onRequestId?: (requestId: string) => void): Promise<string>;
+    siblingCommitments: [bigint, bigint];
     /**
-     * Get transaction status
-     *
-     * @param requestId - Request ID from previous submission
-     * @returns Current status
-     *
-     * @example
-     * ```typescript
-     * const status = await relay.getStatus(requestId);
-     * console.log(`Status: ${status.status}`);
-     * if (status.status === 'completed') {
-     *   console.log(`TX: ${status.txId}`);
-     * }
-     * ```
+     * Left sibling from before the transaction (for odd-index handling).
+     * When the first output ends up at an odd index due to concurrent access,
+     * its sibling at index-1 comes from a previous transaction.
+     * This value captures subtrees[0] before our transaction to enable
+     * correct Merkle proof computation for odd indices.
      */
-    getStatus(requestId: string): Promise<TxStatus>;
+    preTransactionLeftSibling?: bigint;
     /**
-     * Register viewing key with relay for compliance decryption.
-     * This is a one-time operation - the viewing key is stored by the relay.
-     *
-     * The user must sign a one-time relay challenge proving wallet ownership.
-     *
-     * @param userPubkey - User's wallet public key (base58)
-     * @param viewingKey - Viewing key private key (32 bytes, hex encoded)
-     * @param signMessage - Function to sign challenge message bytes
-     *
-     * @example
-     * ```typescript
-     * await relay.registerViewingKey(
-     *   userPublicKey.toBase58(),
-     *   viewingKeyHex,
-     *   signatureBase64
-     * );
-     * ```
+     * The actual output UTXOs created by this transaction.
+     * These have all the data needed to spend them later (keypair, blinding, etc).
+     * The UTXOs are already updated with their indices and sibling commitments.
      */
-    registerViewingKey(userPubkey: string, viewingKey: string, signMessage: (message: Uint8Array) => Promise<Uint8Array>): Promise<boolean>;
+    outputUtxos: Utxo[];
     /**
-     * Fetch relay compliance master public key.
-     * DEPRECATED: This endpoint is no longer used
+     * Whether the viewing key was registered with the relay for compliance.
+     * True on first transaction when metadataBundle includes viewing_key.
+     * Once registered, subsequent transactions don't need to send metadataBundle.
      */
-    getCompliancePublicKey(): Promise<Uint8Array>;
+    viewingKeyRegistered?: boolean;
     /**
-     * Convert bytes to base64 string
+     * The Merkle tree used/built for this transaction, with output commitments inserted.
+     * Pass this as `cachedMerkleTree` in the next transaction to skip relay fetching
+     * and avoid needing `waitForCommitmentIndex`.
      */
-    private bytesToBase64;
+    merkleTree?: MerkleTree;
     /**
-     * Sleep utility
+     * Address lookup table used for v0 transaction (when chain notes or risk oracle require it).
+     * Pass this as `addressLookupTableAccounts` in the next deposit to avoid creating a new ALT.
      */
-    private sleep;
-    private computeViewingKeyIdentifier;
+    addressLookupTableAccounts?: AddressLookupTableAccount[];
 }
-
-/**
- * Risk Oracle Service
- *
- * Self-contained module for fetching Switchboard risk quote instructions
- * using the Range Risk API. Eliminates the need for an external web endpoint
- * (e.g. `/api/risk-quote`) by calling Switchboard directly from the SDK.
- *
- * Uses dynamic imports for @switchboard-xyz packages so they are only loaded
- * when fetchRiskQuoteIx is actually called — not at SDK import time. This
- * prevents the heavy Node.js-only Switchboard code from being bundled into
- * browser builds (Next.js, etc.).
- *
- * Usage:
- *   const { instruction, queue } = await fetchRiskQuoteIx(connection, wallet, rangeApiKey);
- */
-
-/**
- * Fetch a Switchboard risk quote instruction directly from Range + Switchboard.
- *
- * This removes the need for an external `/api/risk-quote` endpoint. The SDK
- * calls Switchboard's crossbar oracle network directly with the Range API key.
- *
- * @param connection - Solana RPC connection
- * @param wallet - Depositor's public key (the wallet being risk-scored)
- * @param rangeApiKey - Range.org API key for the risk score lookup
- * @returns The Ed25519 sig-verify instruction to prepend at index 0, plus the queue pubkey
- */
-declare function fetchRiskQuoteIx(connection: Connection, wallet: PublicKey, rangeApiKey: string): Promise<{
-    instruction: TransactionInstruction;
-    queue: PublicKey;
-}>;
-
-/**
- * Encrypted Output Helpers
- *
- * Functions for creating encrypted outputs that enable note scanning
- */
-
-/**
- * Prepare encrypted output for scanning by wallet owner
- *
- * @param note - Note to encrypt
- * @param cloakKeys - Wallet's Cloak keys (for self-encryption)
- * @returns Base64-encoded encrypted output
- */
-declare function prepareEncryptedOutput(note: CloakNote, cloakKeys: CloakKeyPair): string;
-/**
- * Prepare encrypted output for a specific recipient
- *
- * @param note - Note to encrypt
- * @param recipientPvkHex - Recipient's public view key (hex)
- * @returns Base64-encoded encrypted output
- */
-declare function prepareEncryptedOutputForRecipient(note: CloakNote, recipientPvkHex: string): string;
-/**
- * Simple base64 encoding for v1.0 notes (no encryption)
- *
- * @param note - Note to encode
- * @returns Base64-encoded note data
- */
-declare function encodeNoteSimple(note: CloakNote): string;
-
-/**
- * Wallet Integration Helpers
- *
- * Helper functions for working with Solana Wallet Adapters
- */
-
-/**
- * Validate wallet is connected and has public key
- */
-declare function validateWalletConnected(wallet: WalletAdapter | Keypair): void;
-/**
- * Get public key from wallet or keypair
- */
-declare function getPublicKey(wallet: WalletAdapter | Keypair): PublicKey;
-/**
- * Send transaction using wallet adapter or keypair
- */
-declare function sendTransaction(transaction: Transaction, wallet: WalletAdapter | Keypair, connection: Connection, options?: SendOptions): Promise<string>;
-/**
- * Sign transaction using wallet adapter or keypair
- */
-declare function signTransaction<T extends Transaction>(transaction: T, wallet: WalletAdapter | Keypair): Promise<T>;
-/**
- * Create a keypair adapter for testing
- */
-declare function keypairToAdapter(keypair: Keypair): WalletAdapter;
-
-/**
- * Create a deposit instruction
- *
- * Deposits SOL into the Cloak protocol by creating a commitment.
- *
- * Instruction format:
- * - Byte 0: Discriminant (0x01 for Deposit, per ShieldPoolInstruction enum)
- * - Bytes 1-8: Amount (u64, little-endian)
- * - Bytes 9-40: Commitment (32 bytes)
- *
- * @param params - Deposit parameters
- * @returns Transaction instruction
- *
- * @example
- * ```typescript
- * const instruction = createDepositInstruction({
- *   programId: CLOAK_PROGRAM_ID,
- *   payer: wallet.publicKey,
- *   pool: POOL_ADDRESS,
- *   commitments: COMMITMENTS_ADDRESS,
- *   amount: 1_000_000_000, // 1 SOL
- *   commitment: commitmentBytes
- * });
- * ```
- */
-declare function createDepositInstruction(params: {
-    programId: PublicKey;
-    payer: PublicKey;
-    pool: PublicKey;
-    merkleTree: PublicKey;
-    amount: number;
-    commitment: Uint8Array;
-}): TransactionInstruction;
 /**
- * Deposit instruction parameters for type safety
+ * Generate a random field element suitable for BN254
  */
-interface DepositInstructionParams {
-    programId: PublicKey;
-    payer: PublicKey;
-    pool: PublicKey;
-    merkleTree: PublicKey;
-    amount: number;
-    commitment: Uint8Array;
-}
+declare function randomFieldElement(): bigint;
 /**
- * Validate deposit instruction parameters
+ * Generate a new UTXO keypair
  *
- * @param params - Parameters to validate
- * @throws Error if invalid
+ * @returns A new keypair with random private key and derived public key
  */
-declare function validateDepositParams(params: DepositInstructionParams): void;
-
+declare function generateUtxoKeypair(): Promise<UtxoKeypair>;
 /**
- * Program Derived Address (PDA) utilities for Shield Pool
+ * Derive a deterministic UTXO keypair from a wallet's spend key.
+ * Use this for deposits and change outputs so all chain notes use the same nk,
+ * enabling the compliance scan (scanTransactions + toComplianceReport) to decrypt them.
  *
- * These functions derive deterministic addresses from the program ID and seeds.
- * This matches the behavior in tooling/test/src/shared.rs::get_pda_addresses()
+ * @param skSpend - 32-byte spend key (from wallet key derivation)
+ * @returns UtxoKeypair with deterministic private/public keys
  */
-
-interface ShieldPoolPDAs {
-    pool: PublicKey;
-    merkleTree: PublicKey;
-    vaultAuthority: PublicKey;
-    treasury: PublicKey;
-}
+declare function deriveUtxoKeypairFromSpendKey(skSpend: Uint8Array): Promise<UtxoKeypair>;
 /**
- * Derive all Shield Pool PDAs from program ID + pool mint
- *
- * Seeds match the on-chain mint-scoped program:
- * - pool: [b"pool", mint]
- * - merkle_tree: [b"merkle_tree", mint]
- * - treasury: [b"treasury", mint]
- * - vault_authority: [b"vault_authority", mint]
+ * Derive public key from private key
  *
- * @param programId - Optional program ID (defaults to CLOAK_PROGRAM_ID)
- * @param mint - Pool mint (defaults to NATIVE_SOL_MINT / WSOL sentinel)
+ * @param privateKey The private key
+ * @returns The corresponding public key
  */
-declare function getShieldPoolPDAs(programId?: PublicKey, mint?: PublicKey): ShieldPoolPDAs;
+declare function derivePublicKey(privateKey: bigint): Promise<bigint>;
 /**
- * Derive the nullifier PDA for a specific pool + nullifier hash.
- *
- * With the new PDA-per-nullifier design, each nullifier has its own PDA
- * instead of being stored in a shared shard. The PDA is created when
- * the nullifier is used during withdrawal.
- *
- * Seeds: ["nullifier", pool_pubkey, nullifier_hash]
+ * Create a new UTXO
  *
- * @param poolPubkey - Pool PDA that scopes nullifier domain
- * @param nullifier - 32-byte nullifier hash
- * @param programId - Optional program ID (defaults to CLOAK_PROGRAM_ID)
- * @returns [PublicKey, bump] - The nullifier PDA and its bump seed
+ * @param amount Amount in smallest unit
+ * @param keypair Owner's keypair
+ * @param mintAddress Token mint (defaults to native SOL)
+ * @returns A new UTXO (commitment will be computed)
  */
-declare function getNullifierPDA(poolPubkey: PublicKey, nullifier: Uint8Array | Buffer, programId?: PublicKey): [PublicKey, number];
+declare function createUtxo(amount: bigint, keypair: UtxoKeypair, mintAddress?: PublicKey): Promise<Utxo>;
 /**
- * Derive the swap state PDA for a given pool + nullifier.
+ * Create a zero/padding UTXO
  *
- * Seeds: ["swap_state", pool_pubkey, nullifier_hash]
+ * Zero UTXOs are used as padding when we need fewer than 2 inputs/outputs.
+ * They have zero amount and don't require valid Merkle proofs.
+ * Uses salt-based keypair (privateKey = salt) with blinding=0 to match the circuit
+ * test. By default, salt is random to avoid cross-process collisions under concurrency.
+ * Callers can pass an explicit salt for deterministic behavior.
  *
- * @param poolPubkey - Pool PDA used for swap state domain separation
- * @param nullifier - 32-byte nullifier hash
- * @param programId - Optional program ID (defaults to CLOAK_PROGRAM_ID)
- * @returns [PublicKey, bump] - The swap state PDA and its bump seed
+ * @param mintAddress Token mint (defaults to native SOL)
+ * @param salt Optional salt; if omitted, uses timestamp+counter for uniqueness
  */
-declare function getSwapStatePDA(poolPubkey: PublicKey, nullifier: Uint8Array | Buffer, programId?: PublicKey): [PublicKey, number];
-
+declare function createZeroUtxo(mintAddress?: PublicKey, salt?: bigint): Promise<Utxo>;
 /**
- * On-chain Merkle proof computation
+ * Convert PublicKey to field element for circuit
  *
- * Computes Merkle proofs directly from on-chain tree state,
- * eliminating the need for an indexer for proof generation.
+ * @param pubkey Solana PublicKey
+ * @returns Field element representation
  */
-
+declare function pubkeyToFieldElement(pubkey: PublicKey): bigint;
 /**
- * Merkle proof result
+ * Compute the commitment for a UTXO
+ *
+ * commitment = Poseidon(amount, pubkey, blinding, mintAddress)
+ *
+ * @param utxo The UTXO to compute commitment for
+ * @returns The commitment as a bigint
  */
-interface OnchainMerkleProof {
-    pathElements: string[];
-    pathIndices: number[];
-    root: string;
-}
-interface MerkleTreeState {
-    nextIndex: number;
-    root: string;
-    subtrees: string[];
-}
+declare function computeCommitment(utxo: Utxo): Promise<bigint>;
 /**
- * Read the Merkle tree state from on-chain account
- * @param forceConfirmed - If true, forces "confirmed" commitment level for fresh data
- * @param relayUrl - Optional relay URL to query for current root (bypasses RPC caching)
- * @param mint - Optional pool mint used when querying relay /merkle-root
+ * Compute the signature for nullifier derivation
+ *
+ * signature = Poseidon(privateKey, commitment, pathIndex)
+ *
+ * @param privateKey Owner's private key
+ * @param commitment The UTXO commitment
+ * @param pathIndex Merkle tree path index
+ * @returns The signature
  */
-declare function readMerkleTreeState(connection: Connection, merkleTreePDA: PublicKey, forceConfirmed?: boolean, relayUrl?: string, 
-/** When true, skip relay root and use chain directly (avoids stale relay root causing ProofInvalid) */
-skipRelayRoot?: boolean, mint?: PublicKey): Promise<MerkleTreeState>;
+declare function computeSignature(privateKey: bigint, commitment: bigint, pathIndex: bigint): Promise<bigint>;
 /**
- * Compute Merkle proof for a leaf at a given index using on-chain state
+ * Compute the nullifier for a UTXO
  *
- * This works by:
- * 1. Reading the subtrees (frontier) from the on-chain account
- * 2. For each level, determining the sibling:
- *    - If index is odd: sibling is the stored subtree (left sibling)
- *    - If index is even: sibling is either a subsequent subtree or zero value
+ * nullifier = Poseidon(commitment, pathIndex, signature)
  *
- * Note: This works best for recent leaves where siblings are zero values.
- * For older leaves with non-zero siblings that aren't stored in subtrees,
- * an indexer may still be needed.
+ * The nullifier is a unique identifier that gets recorded on-chain
+ * to prevent double-spending.
  *
- * @param connection - Solana connection
- * @param merkleTreePDA - PDA of the merkle tree account
- * @param leafIndex - Index of the leaf to compute proof for
- * @param forceConfirmed - If true, forces "confirmed" commitment level for fresh data
- * @returns Merkle proof with path elements and indices
+ * @param utxo The UTXO being spent
+ * @returns The nullifier
  */
-declare function computeProofFromChain(connection: Connection, merkleTreePDA: PublicKey, leafIndex: number, forceConfirmed?: boolean): Promise<OnchainMerkleProof>;
+declare function computeNullifier(utxo: Utxo): Promise<bigint>;
 /**
- * Compute proof for the most recently inserted leaf
- *
- * This is the most reliable case - immediately after your deposit,
- * all siblings to the right are zero values, and siblings to the left
- * are stored in the subtrees.
+ * Serialize a UTXO to bytes for encryption
  */
-declare function computeProofForLatestDeposit(connection: Connection, merkleTreePDA: PublicKey): Promise<OnchainMerkleProof & {
-    leafIndex: number;
-}>;
-
+declare function serializeUtxo(utxo: Utxo): Uint8Array;
 /**
- * Merkle Tree implementation for computing proofs
- *
- * This tree stores all leaves and can compute the correct Merkle path
- * for any leaf index.
+ * Deserialize a UTXO from bytes
  */
-declare const MERKLE_TREE_HEIGHT = 32;
+declare function deserializeUtxo(bytes: Uint8Array): Promise<Utxo>;
 /**
- * Merkle Tree class that stores all leaves and computes proofs
+ * Convert bigint to hex string (64 chars, padded)
  */
-declare class MerkleTree {
-    private levels;
-    private capacity;
-    private layers;
-    private zeros;
-    private poseidon;
-    /**
-     * Create a new Merkle tree
-     * @param levels Number of levels in the tree (height)
-     * @param leaves Initial leaves to insert
-     * @param zeros Precomputed zero values for each level
-     * @param poseidon Pre-initialized Poseidon instance (avoids async in constructor)
-     */
-    constructor(levels: number, leaves: bigint[], zeros: bigint[], poseidon: any);
-    /**
-     * Create a new MerkleTree with async initialization
-     */
-    static create(levels?: number, leaves?: bigint[]): Promise<MerkleTree>;
-    /**
-     * Rebuild the tree from the leaves (synchronous — poseidon must be initialized)
-     */
-    private _rebuildSync;
-    /**
-     * Get the tree root
-     */
-    root(): bigint;
-    /**
-     * Get the number of leaves in the tree
-     */
-    get length(): number;
-    /**
-     * Insert a new leaf into the tree
-     */
-    insert(leaf: bigint): void;
-    /**
-     * Insert multiple leaves
-     */
-    bulkInsert(leaves: bigint[]): void;
-    /**
-     * Update the path from a leaf to the root
-     */
-    private _updatePath;
-    /**
-     * Get the Merkle path for a leaf at the given index
-     * @param index Leaf index
-     * @returns pathElements and pathIndices for the proof
-     */
-    path(index: number): {
-        pathElements: bigint[];
-        pathIndices: number;
-    };
-    /**
-     * Find the index of a leaf in the tree
-     * @param leaf Leaf value to find
-     * @returns Index if found, -1 otherwise
-     */
-    indexOf(leaf: bigint): number;
-    /**
-     * Get all leaves
-     */
-    leaves(): bigint[];
-}
+declare function bigintToHex(value: bigint): string;
 /**
- * Build a MerkleTree from commitment values
- * @param commitments Array of commitment bigints
- * @param height Tree height (default: 32)
+ * Convert hex string to bigint
  */
-declare function buildMerkleTree(commitments: bigint[], height?: number): Promise<MerkleTree>;
-
+declare function hexToBigint(hex: string): bigint;
 /**
- * Relay client utilities for fetching data from the relay service
+ * Convert bigint to 32-byte array (big-endian for circuits)
  */
-
-interface CommitmentEntry {
-    index: number;
-    commitment: string;
-}
-interface CommitmentsResponse {
-    commitments: CommitmentEntry[];
-    count: number;
-    target_reached?: boolean;
-    canonical?: boolean;
-    canonical_reason?: string | null;
-}
-interface FetchCommitmentsOptions {
-    mint?: PublicKey;
-    timeoutMs?: number;
-    maxRetries?: number;
-    sync?: boolean;
-    repair?: boolean;
-    requireTarget?: boolean;
-    requireCanonical?: boolean;
-    fromIndex?: number;
-    limit?: number;
-    waitForIndex?: number;
-}
+declare function bigintToBytes32(value: bigint): Uint8Array;
 /**
- * Fetch all commitments from the relay
- * @param relayUrl Base URL of the relay service (may include cache-busting query params)
- * @param options Timeout and retry options
- * @returns Array of commitment entries
+ * Check if two UTXOs are equal (same commitment)
  */
-declare function fetchCommitments(relayUrl: string, options?: FetchCommitmentsOptions): Promise<CommitmentEntry[]>;
+declare function utxoEquals(a: Utxo, b: Utxo): Promise<boolean>;
 /**
- * Build a Merkle tree from relay commitments
- * @param relayUrl Base URL of the relay service
- * @param options When sync is true, triggers on-demand sync on relay before fetching (for freshness when relay is behind chain)
- * @returns MerkleTree instance with all commitments loaded
- *
- * Supports sparse indices by zero-filling missing leaves, including missing prefixes.
- * Non-contiguous gaps (e.g. 0,1,2,3,22,23,30,31,32,33) are reconstructed with
- * zero leaves to match the on-chain Merkle tree structure.
+ * Calculate total amount from an array of UTXOs
  */
-declare function buildMerkleTreeFromRelay(relayUrl: string, options?: {
-    mint?: PublicKey;
-    sync?: boolean;
-    repair?: boolean;
-    requireTarget?: boolean;
-    requireCanonical?: boolean;
-    timeoutMs?: number;
-    maxRetries?: number;
-    waitForIndex?: number;
-}): Promise<MerkleTree>;
-declare function buildMerkleTreeFromChain(connection: Connection, programId: PublicKey, merkleTree: PublicKey, onProgress?: (message: string) => void): Promise<MerkleTree>;
+declare function sumUtxoAmounts(utxos: Utxo[]): bigint;
 /**
- * Pre-flight root validation
- *
- * Validates that a Merkle root is still valid before generating a proof.
- * This prevents wasted time generating proofs that will fail on-chain.
+ * Select UTXOs to cover a target amount
  *
- * @param relayUrl Relay service URL
- * @param rootHex Root to validate (hex string, with or without 0x prefix)
- * @returns Validation result with status and helpful message
+ * @param available Available UTXOs (sorted by amount descending)
+ * @param targetAmount Target amount to cover
+ * @returns Selected UTXOs that cover the target, or null if insufficient
  */
-declare function validateRoot(relayUrl: string, rootHex: string): Promise<{
-    valid: boolean;
-    currentRoot?: string;
-    message: string;
-    isRecent: boolean;
-}>;
+declare function selectUtxos(available: Utxo[], targetAmount: bigint): Utxo[] | null;
+
 /**
- * Wait for root to be valid
+ * UTXO verification — reconcile local UTXO state with on-chain nullifier state.
  *
- * Polls the relay until the given root is accepted or timeout.
- * Useful when you know a transaction is being processed but root hasn't updated yet.
+ * Shipped in 0.1.5 as the structured building block for self-repair flows.
+ * The web app previously composed this out of lower-level SDK primitives
+ * (`computeNullifier` + `getNullifierPDA` + `getMultipleAccountsInfo`); now
+ * it's a first-class SDK export so callers don't re-implement the same
+ * ~40 lines across tools.
  *
- * @param relayUrl Relay service URL
- * @param rootHex Root to wait for
- * @param timeoutMs Maximum time to wait (default: 30000ms)
- * @param pollIntervalMs Polling interval (default: 1000ms)
- * @returns Whether root became valid in time
+ * Two entry points:
+ *
+ *   1. `verifyUtxos(utxos, conn, programId)` — pure function. Takes a UTXO
+ *      set, does a single batched on-chain lookup of the derived nullifier
+ *      PDAs, returns `{ spent, unspent }`. Caller decides what to do.
+ *
+ *   2. `preflightNullifiers(utxos, conn, programId)` — thin wrapper that
+ *      throws `UtxoAlreadySpentError` if ANY input is already spent.
+ *      Intended for use at the top of spend entry points (transact,
+ *      fullWithdraw, swap) so the SDK fails fast with a structured error
+ *      instead of burning proof-gen + relay retries on a doomed tx.
+ *
+ * Root-caused from a production incident 2026-04-24: a user's cloak.ag
+ * backup contained a UTXO that had been spent via another session. The
+ * recovery tool generated a valid proof against the correct merkle tree
+ * and submitted it; relay's simulation returned 0x1020 DoubleSpend after
+ * 6 retries over ~60s. Pre-flight catches this class in ~200ms.
  */
-declare function waitForRoot(relayUrl: string, rootHex: string, timeoutMs?: number, pollIntervalMs?: number): Promise<{
-    success: boolean;
-    currentRoot?: string;
-    waitedMs: number;
-}>;
+
+/** Result of a batch verification — disjoint partition of the input set. */
+interface VerifyUtxosResult {
+    /** Inputs whose nullifier PDA exists on-chain (already spent). */
+    spent: Utxo[];
+    /** Inputs whose nullifier PDA is absent on-chain (safe to spend). */
+    unspent: Utxo[];
+    /** Inputs we couldn't check — missing commitment / index / mint. */
+    skipped: Utxo[];
+}
 /**
- * Smart pre-flight check with automatic retry suggestion
+ * Check the on-chain nullifier PDA for each UTXO and partition by state.
  *
- * Checks root validity and provides actionable guidance:
- * - If root is current: proceed
- * - If root is old: suggest fetching fresh Merkle proofs
- * - If root is very old: suggest full tree rebuild
+ * Only UTXOs with `commitment`, `mintAddress`, AND a non-null keypair can
+ * be verified — the nullifier derivation needs all three. UTXOs lacking any
+ * of these go into `skipped` and the caller must decide how to treat them.
+ * (In practice a missing `commitment` means the UTXO hasn't landed on-chain
+ * yet — those can't be spent anyway.)
  *
- * @param relayUrl Relay service URL
- * @param rootHex Root to check
- * @returns Action recommendation
+ * Uses a single batched `getMultipleAccountsInfo` call for efficiency —
+ * one round-trip regardless of UTXO count (up to Solana's 100-key cap,
+ * beyond which we page).
+ *
+ * Typical latency: ~150-300ms on a healthy RPC.
  */
-declare function preflightCheck(relayUrl: string, rootHex: string): Promise<{
-    shouldProceed: boolean;
-    action: "proceed" | "refresh_proofs" | "rebuild_tree" | "wait";
-    message: string;
-    estimatedWaitMs?: number;
-}>;
+declare function verifyUtxos(utxos: Utxo[], connection: Connection, programId: PublicKey, commitment?: "processed" | "confirmed" | "finalized"): Promise<VerifyUtxosResult>;
+/**
+ * Pre-flight gate: throw `UtxoAlreadySpentError` if any input is already
+ * spent on-chain. Called at the top of spend entry points in core/transact.
+ *
+ * Browser-safe: uses one batched RPC call.
+ */
+declare function preflightNullifiers(utxos: Utxo[], connection: Connection, programId: PublicKey, commitment?: "processed" | "confirmed" | "finalized"): Promise<void>;
 
 /**
- * Direct Circom WASM Proof Generation
+ * Structured Logger for Cloak SDK
  *
- * This module provides direct proof generation using snarkjs and Circom WASM,
- * matching the approach used in services-new/tests/src/proof.ts
+ * Provides structured logging similar to Rust tracing format:
+ * 2026-01-23T00:51:46.489317Z  INFO cloak::module: 📥 Message key=value
  *
- * This uses pinned S3-hosted circuit artifacts and does not require
- * a backend prover service.
+ * Enable via:
+ * - SDK config: new CloakSDK({ debug: true })
+ * - Environment: CLOAK_DEBUG=1 or DEBUG=cloak:*
  */
-
+type LogLevel = "DEBUG" | "INFO" | "WARN" | "ERROR";
 /**
- * Default URL for fetching circuit artifacts
- * Hosted in S3 and versioned by build.
+ * Enable or disable debug logging globally
  */
-declare const DEFAULT_CIRCUITS_URL = "https://cloak-circuits.s3.us-east-1.amazonaws.com/circuits/0.1.0";
-interface WithdrawRegularInputs {
-    root: bigint;
-    nullifier: bigint;
-    outputs_hash: bigint;
-    public_amount: bigint;
-    amount: bigint;
-    leaf_index: bigint;
-    sk: [bigint, bigint];
-    r: [bigint, bigint];
-    pathElements: bigint[];
-    pathIndices: number[];
-    num_outputs: number;
-    out_addr: bigint[][];
-    out_amount: bigint[];
-    out_flags: number[];
-    var_fee: bigint;
-    rem: bigint;
-}
-interface WithdrawSwapInputs {
-    sk_spend: bigint;
-    r: bigint;
-    amount: bigint;
-    leaf_index: bigint;
-    path_elements: bigint[];
-    path_indices: number[];
-    root: bigint;
-    nullifier: bigint;
-    outputs_hash: bigint;
-    public_amount: bigint;
-    input_mint: bigint[];
-    output_mint: bigint[];
-    recipient_ata: bigint[];
-    min_output_amount: bigint;
-    var_fee: bigint;
-    rem: bigint;
-}
-interface ProofResult {
-    proof: Groth16Proof;
-    publicSignals: string[];
-    proofBytes: Uint8Array;
-    publicInputsBytes: Uint8Array;
+declare function setDebugMode(enabled: boolean): void;
+/**
+ * Check if debug mode is enabled
+ */
+declare function isDebugEnabled(): boolean;
+/**
+ * Logger interface
+ */
+interface Logger {
+    debug: (message: string, kvPairs?: Record<string, unknown>) => void;
+    info: (message: string, kvPairs?: Record<string, unknown>) => void;
+    warn: (message: string, kvPairs?: Record<string, unknown>) => void;
+    error: (message: string, kvPairs?: Record<string, unknown>) => void;
 }
 /**
- * Generate Groth16 proof for regular withdrawal using Circom WASM
+ * Create a logger for a specific module
  *
- * This matches the approach in services-new/tests/src/proof.ts
+ * @param module - Module name (e.g., "cloak::sdk", "cloak::indexer")
+ * @returns Logger instance with debug, info, warn, error methods
  *
- * @param inputs - Circuit inputs
- * @param circuitsPath - Ignored. Proof generation always uses pinned S3 circuits.
+ * @example
+ * ```typescript
+ * const log = createLogger("cloak::deposit");
+ * log.info("Depositing", { amount: 100000000 });
+ * // Output: 2026-01-23T00:51:46.489000Z  INFO cloak::deposit: Depositing amount=100000000
+ * ```
  */
-declare function generateWithdrawRegularProof(inputs: WithdrawRegularInputs, circuitsPath: string): Promise<ProofResult>;
+declare function createLogger(module: string): Logger;
 /**
- * Generate Groth16 proof for swap withdrawal using Circom WASM
- *
- * This matches the approach in services-new/tests/src/proof.ts
+ * Measure and return duration of an async operation
  *
- * @param inputs - Circuit inputs
- * @param circuitsPath - Ignored. Proof generation always uses pinned S3 circuits.
+ * @param _logger - Logger instance (reserved for future debug logging)
+ * @param _operation - Operation name (reserved for future debug logging)
+ * @param fn - Async function to measure
+ * @returns Result and duration in milliseconds
  */
-declare function generateWithdrawSwapProof(inputs: WithdrawSwapInputs, circuitsPath: string): Promise<ProofResult>;
+declare function withTiming<T>(_logger: Logger, _operation: string, fn: () => Promise<T>): Promise<{
+    result: T;
+    durationMs: number;
+}>;
 /**
- * Check if circuits are available from the pinned S3 source.
+ * Format lamports as SOL with proper decimals
  */
-declare function areCircuitsAvailable(circuitsPath: string): Promise<boolean>;
+declare function formatSol(lamports: number | bigint): string;
 /**
- * Get default circuits URL.
+ * Truncate a string (useful for signatures, hashes)
  */
-declare function getDefaultCircuitsPath(): Promise<string>;
+declare function truncate(str: string, len?: number): string;
 /**
- * Pinned circuit artifact hashes (SHA-256).
- *
- * These hashes must be updated whenever the trusted circuit artifacts change.
+ * Default SDK logger instance
  */
-declare const EXPECTED_CIRCUIT_HASHES: {
-    withdraw_regular_wasm: string;
-    withdraw_regular_zkey: string;
-    withdraw_swap_wasm: string;
-    withdraw_swap_zkey: string;
-};
+declare const sdkLogger: Logger;
+
 /**
- * Circuit verification result
+ * Result from submitting a withdrawal that includes the request ID
+ * for potential recovery/resume scenarios
  */
-interface CircuitVerificationResult {
-    /** Whether verification passed */
-    valid: boolean;
-    /** Which circuit was checked */
-    circuit: 'withdraw_regular' | 'withdraw_swap';
-    /** Error message if verification failed */
-    error?: string;
-    computed?: {
-        wasm: string;
-        zkey: string;
-    };
-    expected?: {
-        wasm: string;
-        zkey: string;
-    };
+interface WithdrawSubmissionResult {
+    /** The relay request ID - persist this for recovery */
+    requestId: string;
+    /** The final transaction signature */
+    signature: string;
+}
+/**
+ * Relay Service Client
+ *
+ * Handles submission of withdrawal transactions through a relay service
+ * that pays for transaction fees and submits the transaction on-chain.
+ */
+declare class RelayService {
+    private baseUrl;
+    /**
+     * Create a new Relay Service client
+     *
+     * @param baseUrl - Relay service base URL
+     */
+    constructor(baseUrl: string);
+    /**
+     * Submit a withdrawal transaction via relay
+     *
+     * The relay service will validate the proof, pay for transaction fees,
+     * and submit the transaction on-chain.
+     *
+     * @param params - Withdrawal parameters
+     * @param onStatusUpdate - Optional callback for status updates
+     * @param onRequestId - CRITICAL: Callback when request_id is received.
+     *                      Persist this ID to recover if browser crashes during polling.
+     * @returns Transaction signature when completed
+     *
+     * @example
+     * ```typescript
+     * const signature = await relay.submitWithdraw({
+     *   proof: proofHex,
+     *   publicInputs: { root, nf, outputs_hash, amount },
+     *   outputs: [{ recipient: addr, amount: lamports }],
+     *   feeBps: 50
+     * }, (status) => console.log(`Status: ${status}`),
+     *    (requestId) => localStorage.setItem('pending_withdraw', requestId));
+     * console.log(`Transaction: ${signature}`);
+     * ```
+     */
+    submitWithdraw(params: {
+        proof: string;
+        publicInputs: {
+            root: string;
+            nf: string;
+            outputs_hash: string;
+            amount: number;
+        };
+        outputs: Array<{
+            recipient: string;
+            amount: number;
+        }>;
+        feeBps: number;
+        metadataBundle?: EncryptedMetadataBundle;
+    }, onStatusUpdate?: (status: string) => void, onRequestId?: (requestId: string) => void): Promise<string>;
+    /**
+     * Resume polling for a withdrawal that was previously started
+     *
+     * Use this after page reload to check status of a pending withdrawal.
+     * The requestId should have been persisted via the onRequestId callback.
+     *
+     * @param requestId - Request ID from a previous submitWithdraw call
+     * @param onStatusUpdate - Optional callback for status updates
+     * @returns Transaction signature if completed, null if still pending/failed
+     *
+     * @example
+     * ```typescript
+     * // On page load, check for pending withdrawal
+     * const pendingId = localStorage.getItem('pending_withdraw');
+     * if (pendingId) {
+     *   const result = await relay.resumeWithdraw(pendingId);
+     *   if (result.status === 'completed') {
+     *     console.log('Withdrawal completed:', result.signature);
+     *     localStorage.removeItem('pending_withdraw');
+     *   }
+     * }
+     * ```
+     */
+    resumeWithdraw(requestId: string, onStatusUpdate?: (status: string) => void): Promise<{
+        status: 'completed' | 'failed' | 'pending';
+        signature?: string;
+        error?: string;
+    }>;
+    /**
+     * Poll for withdrawal completion
+     *
+     * @param requestId - Request ID from relay service
+     * @param onStatusUpdate - Optional callback for status updates
+     * @returns Transaction signature when completed
+     */
+    private pollForCompletion;
+    /**
+     * Submit a swap transaction via relay
+     *
+     * Similar to submitWithdraw but includes swap parameters for token swaps.
+     * The relay service will validate the proof, execute the swap, pay for fees,
+     * and submit the transaction on-chain.
+     *
+     * @param params - Swap parameters
+     * @param onStatusUpdate - Optional callback for status updates
+     * @returns Transaction signature when completed
+     *
+     * @example
+     * ```typescript
+     * const signature = await relay.submitSwap({
+     *   proof: proofHex,
+     *   publicInputs: { root, nf, outputs_hash, amount },
+     *   outputs: [{ recipient: addr, amount: lamports }],
+     *   feeBps: 50,
+     *   swap: {
+     *     output_mint: tokenMint.toBase58(),
+     *     slippage_bps: 100,
+     *     min_output_amount: minAmount
+     *   }
+     * }, (status) => console.log(`Status: ${status}`));
+     * console.log(`Transaction: ${signature}`);
+     * ```
+     */
+    submitSwap(params: {
+        proof: string;
+        publicInputs: {
+            root: string;
+            nf: string;
+            outputs_hash: string;
+            amount: number;
+        };
+        outputs: Array<{
+            recipient: string;
+            amount: number;
+        }>;
+        feeBps: number;
+        swap: {
+            output_mint: string;
+            slippage_bps: number;
+            min_output_amount: number;
+        };
+        metadataBundle?: EncryptedMetadataBundle;
+    }, onStatusUpdate?: (status: string) => void, onRequestId?: (requestId: string) => void): Promise<string>;
+    /**
+     * Get transaction status
+     *
+     * @param requestId - Request ID from previous submission
+     * @returns Current status
+     *
+     * @example
+     * ```typescript
+     * const status = await relay.getStatus(requestId);
+     * console.log(`Status: ${status.status}`);
+     * if (status.status === 'completed') {
+     *   console.log(`TX: ${status.txId}`);
+     * }
+     * ```
+     */
+    getStatus(requestId: string): Promise<TxStatus>;
+    /**
+     * Register viewing key with relay for compliance decryption.
+     * This is a one-time operation - the viewing key is stored by the relay.
+     *
+     * The user must sign a one-time relay challenge proving wallet ownership.
+     *
+     * @param userPubkey - User's wallet public key (base58)
+     * @param viewingKey - Viewing key private key (32 bytes, hex encoded)
+     * @param signMessage - Function to sign challenge message bytes
+     *
+     * @example
+     * ```typescript
+     * await relay.registerViewingKey(
+     *   userPublicKey.toBase58(),
+     *   viewingKeyHex,
+     *   signatureBase64
+     * );
+     * ```
+     */
+    registerViewingKey(userPubkey: string, viewingKey: string, signMessage: (message: Uint8Array) => Promise<Uint8Array>): Promise<boolean>;
+    /**
+     * Fetch relay compliance master public key.
+     * DEPRECATED: This endpoint is no longer used
+     */
+    getCompliancePublicKey(): Promise<Uint8Array>;
+    /**
+     * Convert bytes to base64 string
+     */
+    private bytesToBase64;
+    /**
+     * Sleep utility
+     */
+    private sleep;
+    private computeViewingKeyIdentifier;
 }
+
 /**
- * Verify circuit integrity by checking verification key hashes
- *
- * This function fetches the verification key and computes its hash,
- * then compares against the expected hash embedded in the SDK.
- *
- * IMPORTANT: If the hashes don't match, the circuit may produce proofs
- * that will be rejected by the on-chain verifier!
- *
- * @param circuitsPath - Ignored. Verification always uses pinned S3 circuits.
- * @param circuit - Which circuit to verify ('withdraw_regular' or 'withdraw_swap')
- * @returns Verification result
+ * Risk Oracle Service
  *
- * @example
- * ```typescript
- * const result = await verifyCircuitIntegrity('https://cloak-circuits.s3.us-east-1.amazonaws.com/circuits/0.1.0', 'withdraw_regular');
- * if (!result.valid) {
- *   console.error('Circuit verification failed:', result.error);
- *   // Don't proceed with proof generation!
- * }
- * ```
- */
-declare function verifyCircuitIntegrity(circuitsPath: string, circuit: 'withdraw_regular' | 'withdraw_swap'): Promise<CircuitVerificationResult>;
-/**
- * Verify all circuits before use
+ * Self-contained module for fetching Switchboard risk quote instructions
+ * using the Range Risk API. Eliminates the need for an external web endpoint
+ * (e.g. `/api/risk-quote`) by calling Switchboard directly from the SDK.
  *
- * Call this at SDK initialization to ensure circuits are valid.
+ * Uses dynamic imports for @switchboard-xyz packages so they are only loaded
+ * when fetchRiskQuoteIx is actually called — not at SDK import time. This
+ * prevents the heavy Node.js-only Switchboard code from being bundled into
+ * browser builds (Next.js, etc.).
  *
- * @param circuitsPath - Ignored. Verification always uses pinned S3 circuits.
- * @returns Array of verification results (one per circuit)
+ * Usage:
+ *   const { instruction, queue } = await fetchRiskQuoteIx(connection, wallet, rangeApiKey);
  */
-declare function verifyAllCircuits(circuitsPath: string): Promise<CircuitVerificationResult[]>;
 
 /**
- * Pending Operations Manager
- *
- * Utility for persisting pending deposit/withdrawal operations in browser storage.
- * This enables recovery if the browser crashes or user navigates away mid-operation.
+ * Fetch a Switchboard risk quote instruction directly from Range + Switchboard.
  *
- * IMPORTANT: This uses localStorage by default which has security implications.
- * Notes contain sensitive spending keys - consider using more secure storage
- * in production (e.g., encrypted IndexedDB, secure enclave).
- */
-
-/**
- * Pending deposit record
- */
-interface PendingDeposit {
-    /** The note (contains spending secrets!) */
-    note: CloakNote;
-    /** When the deposit was initiated */
-    startedAt: number;
-    /** Transaction signature if available */
-    txSignature?: string;
-    /** Status of the deposit */
-    status: "pending" | "tx_sent" | "confirmed" | "failed";
-    /** Error message if failed */
-    error?: string;
-}
-/**
- * Pending withdrawal record
- */
-interface PendingWithdrawal {
-    /** The relay request ID (for resumption) */
-    requestId: string;
-    /** The note commitment being withdrawn */
-    commitment: string;
-    /** The nullifier being used */
-    nullifier: string;
-    /** When the withdrawal was initiated */
-    startedAt: number;
-    /** Status of the withdrawal */
-    status: "pending" | "processing" | "completed" | "failed";
-    /** Transaction signature if completed */
-    txSignature?: string;
-    /** Error message if failed */
-    error?: string;
-}
-/**
- * Save a pending deposit
- * Call this BEFORE sending the on-chain transaction to ensure note is persisted
- */
-declare function savePendingDeposit(deposit: PendingDeposit): void;
-/**
- * Load all pending deposits
- */
-declare function loadPendingDeposits(): PendingDeposit[];
-/**
- * Update a pending deposit status
- */
-declare function updatePendingDeposit(commitment: string, updates: Partial<PendingDeposit>): void;
-/**
- * Remove a pending deposit (e.g., after successful confirmation)
- */
-declare function removePendingDeposit(commitment: string): void;
-/**
- * Clear all pending deposits
- */
-declare function clearPendingDeposits(): void;
-/**
- * Save a pending withdrawal
- * Call this when you receive the request_id from the relay
- */
-declare function savePendingWithdrawal(withdrawal: PendingWithdrawal): void;
-/**
- * Load all pending withdrawals
- */
-declare function loadPendingWithdrawals(): PendingWithdrawal[];
-/**
- * Update a pending withdrawal status
- */
-declare function updatePendingWithdrawal(requestId: string, updates: Partial<PendingWithdrawal>): void;
-/**
- * Remove a pending withdrawal (e.g., after successful completion)
- */
-declare function removePendingWithdrawal(requestId: string): void;
-/**
- * Clear all pending withdrawals
- */
-declare function clearPendingWithdrawals(): void;
-/**
- * Check if there are any pending operations that need recovery
- * Call this on page load to determine if recovery UI should be shown
- */
-declare function hasPendingOperations(): boolean;
-/**
- * Get summary of pending operations for recovery UI
- */
-declare function getPendingOperationsSummary(): {
-    deposits: PendingDeposit[];
-    withdrawals: PendingWithdrawal[];
-    totalPending: number;
-};
-/**
- * Clean up stale pending operations
- * Call this periodically to remove old failed/completed operations
+ * This removes the need for an external `/api/risk-quote` endpoint. The SDK
+ * calls Switchboard's crossbar oracle network directly with the Range API key.
  *
- * @param maxAgeMs Maximum age in milliseconds before an operation is removed (default: 24 hours)
+ * @param connection - Solana RPC connection
+ * @param wallet - Depositor's public key (the wallet being risk-scored)
+ * @param rangeApiKey - Range.org API key for the risk score lookup
+ * @returns The Ed25519 sig-verify instruction to prepend at index 0, plus the queue pubkey
  */
-declare function cleanupStalePendingOperations(maxAgeMs?: number): {
-    removedDeposits: number;
-    removedWithdrawals: number;
-};
+declare function fetchRiskQuoteIx(connection: Connection, wallet: PublicKey, rangeApiKey: string): Promise<{
+    instruction: TransactionInstruction;
+    queue: PublicKey;
+}>;
 
 /**
- * UTXO (Unspent Transaction Output) Model
+ * Wallet Integration Helpers
  *
- * This module implements the UTXO model for the Cloak privacy protocol.
- * UTXOs allow for:
- * - Shield-to-shield transfers (privacy preserved)
- * - Partial withdrawals (change stays shielded)
- * - Combining multiple small deposits
- * - Multi-token support (SOL + any SPL token)
+ * Helper functions for working with Solana Wallet Adapters
  */
 
-declare const NATIVE_SOL_MINT: PublicKey;
-/**
- * UTXO Keypair for ownership verification
- *
- * Uses Poseidon hash for key derivation:
- * - privateKey: random field element (kept secret)
- * - publicKey: Poseidon(privateKey, 0) - can be shared
- */
-interface UtxoKeypair {
-    /** Private key (random 252-bit field element) */
-    privateKey: bigint;
-    /** Public key derived as Poseidon(privateKey, 0) */
-    publicKey: bigint;
-}
-/**
- * UTXO represents an unspent transaction output
- *
- * Contains all information needed to spend the UTXO:
- * - amount: Value in the smallest unit (lamports for SOL)
- * - keypair: Ownership keys
- * - blinding: Randomness for hiding
- * - mintAddress: Token type (SOL or SPL token)
- * - index: Leaf index in Merkle tree (set after deposit/creation)
- */
-interface Utxo {
-    /** Amount in the smallest unit (lamports for SOL, token units for SPL) */
-    amount: bigint;
-    /** Keypair for ownership */
-    keypair: UtxoKeypair;
-    /** Random blinding factor */
-    blinding: bigint;
-    /** Token mint address (NATIVE_SOL_MINT for SOL) */
-    mintAddress: PublicKey;
-    /** Leaf index in Merkle tree (set after the UTXO is in the tree) */
-    index?: number;
-    /** Commitment hash (computed from amount, pubkey, blinding, mint) */
-    commitment?: bigint;
-    /** Nullifier hash (computed when spending) */
-    nullifier?: bigint;
-    /**
-     * Sibling commitment at level 0 of the Merkle tree.
-     * Required for Merkle proofs since siblings aren't stored on-chain.
-     * This is the commitment of the other output in the same transaction.
-     */
-    siblingCommitment?: bigint;
-}
-/**
- * Encrypted UTXO note for recipient discovery
- *
- * When creating an output UTXO for someone else, the data is encrypted
- * so only the recipient can discover and spend it.
- */
-interface EncryptedNote {
-    /** Encrypted UTXO data (ECIES/ChaCha20 encrypted) */
-    ciphertext: Uint8Array;
-    /** Ephemeral public key for ECDH */
-    ephemeralPubkey: Uint8Array;
-    /** MAC for integrity verification */
-    mac: Uint8Array;
-}
-/**
- * Transaction parameters for a UTXO transaction
- */
-interface TransactParams {
-    /** Input UTXOs to spend (max 2) */
-    inputUtxos: Utxo[];
-    /** Output UTXOs to create (max 2) */
-    outputUtxos: Utxo[];
-    /** External recipient for withdrawal (optional) */
-    recipient?: PublicKey;
-    /** Net external amount: positive = deposit, negative = withdraw */
-    externalAmount?: bigint;
-    /** Depositor address (for deposits, the source of funds) */
-    depositor?: PublicKey;
-}
 /**
- * Result from a UTXO transaction
+ * Validate wallet is connected and has public key
  */
-interface TransactResult {
-    /** Transaction signature */
-    signature: string;
-    /** Nullifiers of spent inputs */
-    inputNullifiers: bigint[];
-    /** Commitments of created outputs */
-    outputCommitments: bigint[];
-    /** New Merkle root after the transaction */
-    newRoot: string;
-    /** Merkle tree indices where output commitments were inserted */
-    commitmentIndices: [number, number];
-    /**
-     * Sibling commitments for each output.
-     * For output[0], sibling is output[1] and vice versa.
-     * These are needed for Merkle proofs since siblings aren't stored on-chain.
-     */
-    siblingCommitments: [bigint, bigint];
-    /**
-     * Left sibling from before the transaction (for odd-index handling).
-     * When the first output ends up at an odd index due to concurrent access,
-     * its sibling at index-1 comes from a previous transaction.
-     * This value captures subtrees[0] before our transaction to enable
-     * correct Merkle proof computation for odd indices.
-     */
-    preTransactionLeftSibling?: bigint;
-    /**
-     * The actual output UTXOs created by this transaction.
-     * These have all the data needed to spend them later (keypair, blinding, etc).
-     * The UTXOs are already updated with their indices and sibling commitments.
-     */
-    outputUtxos: Utxo[];
-    /**
-     * Whether the viewing key was registered with the relay for compliance.
-     * True on first transaction when metadataBundle includes viewing_key.
-     * Once registered, subsequent transactions don't need to send metadataBundle.
-     */
-    viewingKeyRegistered?: boolean;
-    /**
-     * The Merkle tree used/built for this transaction, with output commitments inserted.
-     * Pass this as `cachedMerkleTree` in the next transaction to skip relay fetching
-     * and avoid needing `waitForCommitmentIndex`.
-     */
-    merkleTree?: MerkleTree;
-    /**
-     * Address lookup table used for v0 transaction (when chain notes or risk oracle require it).
-     * Pass this as `addressLookupTableAccounts` in the next deposit to avoid creating a new ALT.
-     */
-    addressLookupTableAccounts?: AddressLookupTableAccount[];
-}
+declare function validateWalletConnected(wallet: WalletAdapter | Keypair): void;
 /**
- * Generate a random field element suitable for BN254
+ * Get public key from wallet or keypair
  */
-declare function randomFieldElement(): bigint;
+declare function getPublicKey(wallet: WalletAdapter | Keypair): PublicKey;
 /**
- * Generate a new UTXO keypair
- *
- * @returns A new keypair with random private key and derived public key
+ * Send transaction using wallet adapter or keypair
  */
-declare function generateUtxoKeypair(): Promise<UtxoKeypair>;
+declare function sendTransaction(transaction: Transaction, wallet: WalletAdapter | Keypair, connection: Connection, options?: SendOptions): Promise<string>;
 /**
- * Derive a deterministic UTXO keypair from a wallet's spend key.
- * Use this for deposits and change outputs so all chain notes use the same nk,
- * enabling the compliance scan (scanTransactions + toComplianceReport) to decrypt them.
- *
- * @param skSpend - 32-byte spend key (from wallet key derivation)
- * @returns UtxoKeypair with deterministic private/public keys
+ * Sign transaction using wallet adapter or keypair
  */
-declare function deriveUtxoKeypairFromSpendKey(skSpend: Uint8Array): Promise<UtxoKeypair>;
+declare function signTransaction<T extends Transaction>(transaction: T, wallet: WalletAdapter | Keypair): Promise<T>;
 /**
- * Derive public key from private key
- *
- * @param privateKey The private key
- * @returns The corresponding public key
+ * Create a keypair adapter for testing
  */
-declare function derivePublicKey(privateKey: bigint): Promise<bigint>;
+declare function keypairToAdapter(keypair: Keypair): WalletAdapter;
+
 /**
- * Create a new UTXO
+ * Program Derived Address (PDA) utilities for Shield Pool
  *
- * @param amount Amount in smallest unit
- * @param keypair Owner's keypair
- * @param mintAddress Token mint (defaults to native SOL)
- * @returns A new UTXO (commitment will be computed)
+ * These functions derive deterministic addresses from the program ID and seeds.
+ * This matches the behavior in tooling/test/src/shared.rs::get_pda_addresses()
  */
-declare function createUtxo(amount: bigint, keypair: UtxoKeypair, mintAddress?: PublicKey): Promise<Utxo>;
+
+interface ShieldPoolPDAs {
+    pool: PublicKey;
+    merkleTree: PublicKey;
+    vaultAuthority: PublicKey;
+    treasury: PublicKey;
+}
 /**
- * Create a zero/padding UTXO
+ * Derive all Shield Pool PDAs from program ID + pool mint
  *
- * Zero UTXOs are used as padding when we need fewer than 2 inputs/outputs.
- * They have zero amount and don't require valid Merkle proofs.
- * Uses salt-based keypair (privateKey = salt) with blinding=0 to match the circuit
- * test. By default, salt is random to avoid cross-process collisions under concurrency.
- * Callers can pass an explicit salt for deterministic behavior.
+ * Seeds match the on-chain mint-scoped program:
+ * - pool: [b"pool", mint]
+ * - merkle_tree: [b"merkle_tree", mint]
+ * - treasury: [b"treasury", mint]
+ * - vault_authority: [b"vault_authority", mint]
  *
- * @param mintAddress Token mint (defaults to native SOL)
- * @param salt Optional salt; if omitted, uses timestamp+counter for uniqueness
+ * @param programId - Optional program ID (defaults to CLOAK_PROGRAM_ID)
+ * @param mint - Pool mint (defaults to NATIVE_SOL_MINT / WSOL sentinel)
  */
-declare function createZeroUtxo(mintAddress?: PublicKey, salt?: bigint): Promise<Utxo>;
+declare function getShieldPoolPDAs(programId?: PublicKey, mint?: PublicKey): ShieldPoolPDAs;
 /**
- * Convert PublicKey to field element for circuit
+ * Derive the nullifier PDA for a specific pool + nullifier hash.
  *
- * @param pubkey Solana PublicKey
- * @returns Field element representation
+ * With the new PDA-per-nullifier design, each nullifier has its own PDA
+ * instead of being stored in a shared shard. The PDA is created when
+ * the nullifier is used during withdrawal.
+ *
+ * Seeds: ["nullifier", pool_pubkey, nullifier_hash]
+ *
+ * @param poolPubkey - Pool PDA that scopes nullifier domain
+ * @param nullifier - 32-byte nullifier hash
+ * @param programId - Optional program ID (defaults to CLOAK_PROGRAM_ID)
+ * @returns [PublicKey, bump] - The nullifier PDA and its bump seed
  */
-declare function pubkeyToFieldElement(pubkey: PublicKey): bigint;
+declare function getNullifierPDA(poolPubkey: PublicKey, nullifier: Uint8Array | Buffer, programId?: PublicKey): [PublicKey, number];
 /**
- * Compute the commitment for a UTXO
+ * Derive the swap state PDA for a given pool + nullifier.
  *
- * commitment = Poseidon(amount, pubkey, blinding, mintAddress)
+ * Seeds: ["swap_state", pool_pubkey, nullifier_hash]
  *
- * @param utxo The UTXO to compute commitment for
- * @returns The commitment as a bigint
+ * @param poolPubkey - Pool PDA used for swap state domain separation
+ * @param nullifier - 32-byte nullifier hash
+ * @param programId - Optional program ID (defaults to CLOAK_PROGRAM_ID)
+ * @returns [PublicKey, bump] - The swap state PDA and its bump seed
  */
-declare function computeCommitment(utxo: Utxo): Promise<bigint>;
+declare function getSwapStatePDA(poolPubkey: PublicKey, nullifier: Uint8Array | Buffer, programId?: PublicKey): [PublicKey, number];
+
 /**
- * Compute the signature for nullifier derivation
- *
- * signature = Poseidon(privateKey, commitment, pathIndex)
+ * On-chain Merkle proof computation
  *
- * @param privateKey Owner's private key
- * @param commitment The UTXO commitment
- * @param pathIndex Merkle tree path index
- * @returns The signature
+ * Computes Merkle proofs directly from on-chain tree state,
+ * eliminating the need for an indexer for proof generation.
  */
-declare function computeSignature(privateKey: bigint, commitment: bigint, pathIndex: bigint): Promise<bigint>;
+
 /**
- * Compute the nullifier for a UTXO
+ * Merkle proof result
+ */
+interface OnchainMerkleProof {
+    pathElements: string[];
+    pathIndices: number[];
+    root: string;
+}
+interface MerkleTreeState {
+    nextIndex: number;
+    root: string;
+    subtrees: string[];
+}
+/**
+ * Read the Merkle tree state from on-chain account
+ * @param forceConfirmed - If true, forces "confirmed" commitment level for fresh data
+ * @param relayUrl - Optional relay URL to query for current root (bypasses RPC caching)
+ * @param mint - Optional pool mint used when querying relay /merkle-root
+ */
+declare function readMerkleTreeState(connection: Connection, merkleTreePDA: PublicKey, forceConfirmed?: boolean, relayUrl?: string, 
+/** When true, skip relay root and use chain directly (avoids stale relay root causing ProofInvalid) */
+skipRelayRoot?: boolean, mint?: PublicKey): Promise<MerkleTreeState>;
+/**
+ * Compute Merkle proof for a leaf at a given index using on-chain state
  *
- * nullifier = Poseidon(commitment, pathIndex, signature)
+ * This works by:
+ * 1. Reading the subtrees (frontier) from the on-chain account
+ * 2. For each level, determining the sibling:
+ *    - If index is odd: sibling is the stored subtree (left sibling)
+ *    - If index is even: sibling is either a subsequent subtree or zero value
  *
- * The nullifier is a unique identifier that gets recorded on-chain
- * to prevent double-spending.
+ * Note: This works best for recent leaves where siblings are zero values.
+ * For older leaves with non-zero siblings that aren't stored in subtrees,
+ * an indexer may still be needed.
  *
- * @param utxo The UTXO being spent
- * @returns The nullifier
- */
-declare function computeNullifier(utxo: Utxo): Promise<bigint>;
-/**
- * Serialize a UTXO to bytes for encryption
+ * @param connection - Solana connection
+ * @param merkleTreePDA - PDA of the merkle tree account
+ * @param leafIndex - Index of the leaf to compute proof for
+ * @param forceConfirmed - If true, forces "confirmed" commitment level for fresh data
+ * @returns Merkle proof with path elements and indices
  */
-declare function serializeUtxo(utxo: Utxo): Uint8Array;
+declare function computeProofFromChain(connection: Connection, merkleTreePDA: PublicKey, leafIndex: number, forceConfirmed?: boolean): Promise<OnchainMerkleProof>;
 /**
- * Deserialize a UTXO from bytes
+ * Compute proof for the most recently inserted leaf
+ *
+ * This is the most reliable case - immediately after your deposit,
+ * all siblings to the right are zero values, and siblings to the left
+ * are stored in the subtrees.
  */
-declare function deserializeUtxo(bytes: Uint8Array): Promise<Utxo>;
+declare function computeProofForLatestDeposit(connection: Connection, merkleTreePDA: PublicKey): Promise<OnchainMerkleProof & {
+    leafIndex: number;
+}>;
+
 /**
- * Convert bigint to hex string (64 chars, padded)
+ * Relay client utilities for fetching data from the relay service
  */
-declare function bigintToHex(value: bigint): string;
+
+interface CommitmentEntry {
+    index: number;
+    commitment: string;
+}
+interface CommitmentsResponse {
+    commitments: CommitmentEntry[];
+    count: number;
+    target_reached?: boolean;
+    canonical?: boolean;
+    canonical_reason?: string | null;
+}
+interface FetchCommitmentsOptions {
+    mint?: PublicKey;
+    timeoutMs?: number;
+    maxRetries?: number;
+    sync?: boolean;
+    repair?: boolean;
+    requireTarget?: boolean;
+    requireCanonical?: boolean;
+    fromIndex?: number;
+    limit?: number;
+    waitForIndex?: number;
+}
 /**
- * Convert hex string to bigint
+ * Fetch all commitments from the relay
+ * @param relayUrl Base URL of the relay service (may include cache-busting query params)
+ * @param options Timeout and retry options
+ * @returns Array of commitment entries
  */
-declare function hexToBigint(hex: string): bigint;
+declare function fetchCommitments(relayUrl: string, options?: FetchCommitmentsOptions): Promise<CommitmentEntry[]>;
 /**
- * Convert bigint to 32-byte array (big-endian for circuits)
+ * Build a Merkle tree from relay commitments
+ * @param relayUrl Base URL of the relay service
+ * @param options When sync is true, triggers on-demand sync on relay before fetching (for freshness when relay is behind chain)
+ * @returns MerkleTree instance with all commitments loaded
+ *
+ * Supports sparse indices by zero-filling missing leaves, including missing prefixes.
+ * Non-contiguous gaps (e.g. 0,1,2,3,22,23,30,31,32,33) are reconstructed with
+ * zero leaves to match the on-chain Merkle tree structure.
  */
-declare function bigintToBytes32(value: bigint): Uint8Array;
+declare function buildMerkleTreeFromRelay(relayUrl: string, options?: {
+    mint?: PublicKey;
+    sync?: boolean;
+    repair?: boolean;
+    requireTarget?: boolean;
+    requireCanonical?: boolean;
+    timeoutMs?: number;
+    maxRetries?: number;
+    waitForIndex?: number;
+}): Promise<MerkleTree>;
+declare function buildMerkleTreeFromChain(connection: Connection, programId: PublicKey, merkleTree: PublicKey, onProgress?: (message: string) => void): Promise<MerkleTree>;
 /**
- * Check if two UTXOs are equal (same commitment)
+ * Pre-flight root validation
+ *
+ * Validates that a Merkle root is still valid before generating a proof.
+ * This prevents wasted time generating proofs that will fail on-chain.
+ *
+ * @param relayUrl Relay service URL
+ * @param rootHex Root to validate (hex string, with or without 0x prefix)
+ * @returns Validation result with status and helpful message
  */
-declare function utxoEquals(a: Utxo, b: Utxo): Promise<boolean>;
+declare function validateRoot(relayUrl: string, rootHex: string): Promise<{
+    valid: boolean;
+    currentRoot?: string;
+    message: string;
+    isRecent: boolean;
+}>;
 /**
- * Calculate total amount from an array of UTXOs
+ * Wait for root to be valid
+ *
+ * Polls the relay until the given root is accepted or timeout.
+ * Useful when you know a transaction is being processed but root hasn't updated yet.
+ *
+ * @param relayUrl Relay service URL
+ * @param rootHex Root to wait for
+ * @param timeoutMs Maximum time to wait (default: 30000ms)
+ * @param pollIntervalMs Polling interval (default: 1000ms)
+ * @returns Whether root became valid in time
  */
-declare function sumUtxoAmounts(utxos: Utxo[]): bigint;
+declare function waitForRoot(relayUrl: string, rootHex: string, timeoutMs?: number, pollIntervalMs?: number): Promise<{
+    success: boolean;
+    currentRoot?: string;
+    waitedMs: number;
+}>;
 /**
- * Select UTXOs to cover a target amount
+ * Smart pre-flight check with automatic retry suggestion
  *
- * @param available Available UTXOs (sorted by amount descending)
- * @param targetAmount Target amount to cover
- * @returns Selected UTXOs that cover the target, or null if insufficient
+ * Checks root validity and provides actionable guidance:
+ * - If root is current: proceed
+ * - If root is old: suggest fetching fresh Merkle proofs
+ * - If root is very old: suggest full tree rebuild
+ *
+ * @param relayUrl Relay service URL
+ * @param rootHex Root to check
+ * @returns Action recommendation
  */
-declare function selectUtxos(available: Utxo[], targetAmount: bigint): Utxo[] | null;
+declare function preflightCheck(relayUrl: string, rootHex: string): Promise<{
+    shouldProceed: boolean;
+    action: "proceed" | "refresh_proofs" | "rebuild_tree" | "wait";
+    message: string;
+    estimatedWaitMs?: number;
+}>;
 
 /**
  * UTXO Transaction Methods
@@ -3424,10 +2474,25 @@ declare class SimpleWallet {
  * Cloak SDK - TypeScript SDK for Private Transactions on Solana
  *
  * @packageDocumentation
+ *
+ * # 0.1.6 — breaking changes
+ *
+ * The legacy `CloakNote` API (`CloakSDK.deposit/privateTransfer/withdraw/
+ * send/swap`, `createDepositInstruction`, `generateNote`, `withdraw_regular`
+ * proofs, etc.) was removed because every code path eventually emitted a
+ * legacy `[discriminator: 1, amount: u64, commitment: 32]` instruction that
+ * the deployed shield-pool program no longer accepts (tag `1` is now
+ * `TransactSwap`, not `Deposit`). The OLD 3-input commitment scheme is
+ * also incompatible with the deployed `transaction.circom` UTXO circuit.
+ *
+ * Use the functional UTXO API instead — `transact`, `transfer`,
+ * `partialWithdraw`, `fullWithdraw`, `swapUtxo`, `createUtxo`,
+ * `createZeroUtxo`, `generateUtxoKeypair`. The `CloakSDK` class is kept as
+ * a thin config + read-only chain helper.
  */
 
-declare const VERSION = "1.0.0";
-/** True when scanner supports TransactSwap (tag 1). Check this to verify the correct SDK bundle is loaded. */
+declare const VERSION = "0.1.6";
+/** True when scanner supports TransactSwap (tag 1). */
 declare const SCANNER_SUPPORTS_TRANSACT_SWAP = true;
 
-export { CLOAK_PROGRAM_ID, type ChainNoteTxType, type CircuitVerificationResult, type CloakConfig, CloakError, type CloakKeyPair, type CloakNote, CloakSDK, type CommitmentEntry, type CommitmentsResponse, type CompactChainNote, type ComplianceReport, type ComplianceTxType, DEFAULT_CIRCUITS_URL, DEFAULT_TRANSACTION_CIRCUITS_URL, type DepositInstructionParams, type DepositOptions, type DepositResult, type DepositStatus, EXPECTED_CIRCUIT_HASHES, type EncryptedMetadataBundle, type EncryptedNote$1 as EncryptedNote, type ErrorCategory, type ExpandedSpendKey, FIXED_FEE_LAMPORTS, type Groth16Proof, LAMPORTS_PER_SOL, LocalStorageAdapter, type LogLevel, type Logger, MERKLE_TREE_HEIGHT, MIN_DEPOSIT_LAMPORTS, type MasterKey, type MaxLengthArray, MemoryStorageAdapter, type MerkleProof, type MerkleRootResponse, MerkleTree, NATIVE_SOL_MINT, type Network, type NoteData, type OnchainMerkleProof, type PendingDeposit, type PendingWithdrawal, type ProofResult, RelayService, type RiskQuoteInstructionResponse, RootNotFoundError, SCANNER_SUPPORTS_TRANSACT_SWAP, SIGN_IN_MESSAGE, type ScanOptions, type ScanResult, type ScanSummary, type ScannedTransaction, ShieldPoolErrors, type ShieldPoolPDAs, SimpleWallet, type SpendKey, type StorageAdapter, type SwapOptions, type SwapParams, type SwapResult, type TransactOptions, type TransactParams, type TransactResult, type TransactionMetadata, type Transfer, type TransferOptions, type TransferResult, type TxStatus, type UserFriendlyError, type Utxo, type EncryptedNote as UtxoEncryptedNote, type UtxoKeypair, type UtxoSwapParams, type UtxoSwapResult, UtxoWallet, VARIABLE_FEE_DENOMINATOR, VARIABLE_FEE_NUMERATOR, VARIABLE_FEE_RATE, VERSION, type ViewKey, type ViewingKeyPair, type WalletAdapter, type WalletUtxo, type WithdrawOptions, type WithdrawRegularInputs, type WithdrawSubmissionResult, type WithdrawSwapInputs, areCircuitsAvailable, bigintToBytes32$1 as bigintToBytes32, bigintToHex, buildMerkleTree, buildMerkleTreeFromChain, buildMerkleTreeFromRelay, buildPublicInputsBytes, bytesToHex, calculateFee, calculateFeeBigint, calculateRelayFee, chainNoteFromBase64, chainNoteToBase64, cleanupStalePendingOperations, clearPendingDeposits, clearPendingWithdrawals, computeChainNoteHash, computeCommitment$1 as computeCommitment, computeExtDataHash, computeMerkleRoot, computeNullifier$1 as computeNullifier, computeNullifierAsync, computeNullifierSync, computeOutputsHash, computeOutputsHashAsync, computeOutputsHashSync, computeProofForLatestDeposit, computeProofFromChain, computeSignature, computeSwapOutputsHash, computeSwapOutputsHashAsync, computeSwapOutputsHashSync, computeCommitment as computeUtxoCommitment, computeNullifier as computeUtxoNullifier, copyNoteToClipboard, createCloakError, createDepositInstruction, createLogger, createUtxo, createZeroUtxo, decryptCompactChainNote, decryptComplianceMetadataWithMasterKey, decryptTransactionMetadata, deriveDiversifiedViewingKey, deriveDiversifier, derivePublicKey, deriveSpendKey, deriveUserCompliancePublicKey, deriveUserComplianceScalar, deriveUtxoKeypairFromSpendKey, deriveViewKey, deriveViewingKeyFromNk, deriveViewingKeyFromSpendKey, deriveViewingKeyFromUtxoPrivateKey, deserializeUtxo, detectNetworkFromRpcUrl, downloadNote, encodeNoteSimple, encryptCompactChainNote, encryptNoteForRecipient, encryptTransactionMetadata, encryptTransactionMetadataBundle, expandSpendKey, exportKeys, exportNote, exportWalletKeys, fetchCommitments, fetchRiskQuoteInstruction, fetchRiskQuoteIx, filterNotesByNetwork, filterWithdrawableNotes, findNoteByCommitment, formatAmount, formatComplianceCsv, formatErrorForLogging, formatSol, fullWithdraw, generateCloakKeys, generateCommitment, generateCommitmentAsync, generateMasterSeed, generateNote, generateNoteFromWallet, generateUtxoKeypair, generateViewingKeyPair, generateWithdrawRegularProof, generateWithdrawSwapProof, getAddressExplorerUrl, getCircuitsPath, getDefaultCircuitsPath, getDistributableAmount, getExplorerUrl, getNkFromUtxoPrivateKey, getNullifierPDA, getPendingOperationsSummary, getPublicKey, getPublicViewKey, getRecipientAmount, getRpcUrlForNetwork, getShieldPoolPDAs, getSwapStatePDA, getViewKey, hasPendingOperations, hexToBigint$1 as hexToBigint, hexToBytes, importKeys, importWalletKeys, isDebugEnabled, isRootNotFoundError, isValidHex, isValidRpcUrl, isValidSolanaAddress, isWithdrawAmountSufficient, isWithdrawable, keypairToAdapter, loadPendingDeposits, loadPendingWithdrawals, parseAmount, parseError, parseNote, parseRelayErrorResponse, parseTransactionError, partialWithdraw, poseidonHash, preflightCheck, prepareEncryptedOutput, prepareEncryptedOutputForRecipient, proofToBytes, pubkeyToFieldElement, pubkeyToLimbs, randomBytes, randomFieldElement, readMerkleTreeState, registerViewingKey, removePendingDeposit, removePendingWithdrawal, savePendingDeposit, savePendingWithdrawal, scanNotesForWallet, scanTransactions, sdkLogger, selectUtxos, sendTransaction, serializeNote, serializeUtxo, setCircuitsPath, setDebugMode, signTransaction, splitTo2Limbs, sumUtxoAmounts, swapUtxo, swapWithChange, toComplianceReport, transact, transfer, truncate, tryDecryptNote, updateNoteWithDeposit, updatePendingDeposit, updatePendingWithdrawal, bigintToBytes32 as utxoBigintToBytes32, utxoEquals, hexToBigint as utxoHexToBigint, validateDepositParams, validateNote, validateOutputsSum, validateRoot, validateTransfers, validateWalletConnected, validateWithdrawableNote, verifyAllCircuits, verifyCircuitIntegrity, waitForRoot, withTiming };
+export { CLOAK_PROGRAM_ID, type ChainNoteTxType, type CloakConfig, CloakError, type CloakKeyPair, CloakSDK, type CloakSDKOptions, type CommitmentEntry, type CommitmentsResponse, type CompactChainNote, type ComplianceReport, type ComplianceTxType, DEFAULT_TRANSACTION_CIRCUITS_URL, type EncryptedMetadataBundle, type EncryptedNote$1 as EncryptedNote, type ErrorCategory, type ExpandedSpendKey, FIXED_FEE_LAMPORTS, type Groth16Proof, LAMPORTS_PER_SOL, LocalStorageAdapter, type LogLevel, type Logger, MERKLE_TREE_HEIGHT, MIN_DEPOSIT_LAMPORTS, type MasterKey, MemoryStorageAdapter, type MerkleProof, type MerkleRootResponse, MerkleTree, NATIVE_SOL_MINT, type Network, type NoteData, type OnchainMerkleProof, RelayInternalError, RelayService, type RiskQuoteInstructionResponse, RootNotFoundError, SCANNER_SUPPORTS_TRANSACT_SWAP, SIGN_IN_MESSAGE, SanctionsQuoteError, type ScanOptions, type ScanResult, type ScanSummary, type ScannedTransaction, ShieldPoolErrors, type ShieldPoolPDAs, SimpleWallet, type SpendKey, type StorageAdapter, type TransactOptions, type TransactParams, type TransactResult, type TransactionMetadata, type TxStatus, type UserFriendlyError, type Utxo, UtxoAlreadySpentError, type EncryptedNote as UtxoEncryptedNote, type UtxoKeypair, type UtxoSwapParams, type UtxoSwapResult, UtxoWallet, VARIABLE_FEE_DENOMINATOR, VARIABLE_FEE_NUMERATOR, VARIABLE_FEE_RATE, VERSION, type VerifyUtxosResult, type ViewKey, type ViewingKeyPair, type WalletAdapter, type WalletUtxo, type WithdrawSubmissionResult, bigintToBytes32$1 as bigintToBytes32, bigintToHex, buildMerkleTree, buildMerkleTreeFromChain, buildMerkleTreeFromRelay, buildPublicInputsBytes, bytesToHex, calculateFee, calculateFeeBigint, calculateRelayFee, chainNoteFromBase64, chainNoteToBase64, classifyRelayError, computeChainNoteHash, computeExtDataHash, computeMerkleRoot, computeProofForLatestDeposit, computeProofFromChain, computeSignature, computeCommitment as computeUtxoCommitment, computeNullifier as computeUtxoNullifier, createCloakError, createLogger, createUtxo, createZeroUtxo, decryptCompactChainNote, decryptComplianceMetadataWithMasterKey, decryptTransactionMetadata, deriveDiversifiedViewingKey, deriveDiversifier, derivePublicKey, deriveSpendKey, deriveUserCompliancePublicKey, deriveUserComplianceScalar, deriveUtxoKeypairFromSpendKey, deriveViewKey, deriveViewingKeyFromNk, deriveViewingKeyFromSpendKey, deriveViewingKeyFromUtxoPrivateKey, deserializeUtxo, detectNetworkFromRpcUrl, encryptCompactChainNote, encryptNoteForRecipient, encryptTransactionMetadata, encryptTransactionMetadataBundle, expandSpendKey, exportKeys, fetchCommitments, fetchRiskQuoteInstruction, fetchRiskQuoteIx, formatAmount, formatComplianceCsv, formatErrorForLogging, formatSol, fullWithdraw, generateCloakKeys, generateMasterSeed, generateUtxoKeypair, generateViewingKeyPair, getAddressExplorerUrl, getCircuitsPath, getDistributableAmount, getExplorerUrl, getNkFromUtxoPrivateKey, getNullifierPDA, getPublicKey, getRpcUrlForNetwork, getShieldPoolPDAs, getSwapStatePDA, hexToBigint$1 as hexToBigint, hexToBytes, importKeys, isDebugEnabled, isRootNotFoundError, isValidHex, isValidRpcUrl, isValidSolanaAddress, isWithdrawAmountSufficient, keypairToAdapter, parseAmount, parseError, parseRelayErrorResponse, parseTransactionError, partialWithdraw, poseidonHash, preflightCheck, preflightNullifiers, proofToBytes, pubkeyToFieldElement, pubkeyToLimbs, randomBytes, randomFieldElement, readMerkleTreeState, registerViewingKey, scanNotesForWallet, scanTransactions, sdkLogger, selectUtxos, sendTransaction, serializeUtxo, setCircuitsPath, setDebugMode, signTransaction, splitTo2Limbs, sumUtxoAmounts, swapUtxo, swapWithChange, toComplianceReport, transact, transfer, truncate, tryDecryptNote, bigintToBytes32 as utxoBigintToBytes32, utxoEquals, hexToBigint as utxoHexToBigint, validateOutputsSum, validateRoot, validateWalletConnected, verifyUtxos, waitForRoot, withTiming };