@lendasat/lendaswap-sdk-pure 0.2.21-preview.0 → 0.2.21

package/dist/src/client.d.ts

@@ -1,760 +0,0 @@
-import { type ApiClient, type Chain, type GetSwapResponse, type QuoteResponse, type TokenInfos } from "./api/client.js";
-import { type VhtlcAmounts } from "./arkade.js";
-import { type ArkadeToEvmSwapOptions, type ArkadeToEvmSwapResult, type BitcoinToArkadeSwapOptions, type BitcoinToArkadeSwapResult, type BitcoinToEvmSwapOptions, type BitcoinToEvmSwapResult, type CreateSwapOptions, type CreateSwapResult, type EvmToArkadeSwapGenericOptions, type EvmToArkadeSwapGenericResult, type EvmToBitcoinSwapOptions, type EvmToBitcoinSwapResult, type EvmToLightningSwapGenericOptions, type EvmToLightningSwapGenericResult, type LightningToEvmSwapGenericOptions, type LightningToEvmSwapGenericResult } from "./create";
-import { type ClaimGaslessResult, type ClaimResult } from "./redeem/index.js";
-import { Signer, type SwapParams } from "./signer/index.js";
-import { type StoredSwap, type SwapStorage, type WalletStorage } from "./storage";
-export type { ArkadeToEvmSwapOptions, ArkadeToEvmSwapResult, BitcoinToArkadeSwapOptions, BitcoinToArkadeSwapResult, BitcoinToEvmSwapOptions, BitcoinToEvmSwapResponse, BitcoinToEvmSwapResult, BtcToEvmSwapOptions, CreateSwapOptions, CreateSwapResult, EvmChain, EvmToArkadeSwapGenericOptions, EvmToArkadeSwapGenericResult, EvmToArkadeSwapOptions, EvmToArkadeSwapResult, EvmToBitcoinSwapOptions, EvmToBitcoinSwapResult, EvmToLightningSwapOptions, } from "./create/index.js";
-export { buildExecuteAndCreateCalls, buildRedeemCalls, buildRedeemDigest, type CoordinatorCall, type ExecuteAndCreateCallData, type ExecuteAndCreateParams, encodeExecuteAndCreate, encodeRedeemAndExecute, encodeRefundAndExecute, encodeRefundTo, type RedeemAndExecuteCallData, type RedeemAndExecuteParams, type RedeemDigestParams, type RefundAndExecuteParams, type RefundToParams, } from "./evm/index.js";
-export type { ClaimGaslessResult, ClaimResult, CoordinatorClaimData, EthereumClaimData, } from "./redeem/index.js";
-/** Result of attempting a refund */
-export interface RefundResult {
-    /** Whether the refund was successful */
-    success: boolean;
-    /** Human-readable message about the refund status */
-    message: string;
-    /** Raw transaction hex (for on-chain refunds) */
-    txHex?: string;
-    /** Transaction ID (for on-chain refunds) */
-    txId?: string;
-    /** Amount being refunded in satoshis (after fees) */
-    refundAmount?: bigint;
-    /** Fee paid in satoshis */
-    fee?: bigint;
-    /** Whether the transaction was broadcast to the network */
-    broadcast?: boolean;
-    /** The HTLC address we computed locally (for debugging) */
-    htlcAddress?: string;
-    /** The HTLC address reported by the server (for debugging) */
-    serverHtlcAddress?: string;
-    /** EVM refund data (for evm_to_arkade and evm_to_btc swaps) */
-    evmRefundData?: {
-        /** Address to send the refund transaction to (coordinator or HTLC) */
-        to: string;
-        /** ABI-encoded calldata for the refund call */
-        data: string;
-        /** Whether the timelock has already expired (refund is available) */
-        timelockExpired: boolean;
-        /** Unix timestamp when the timelock expires */
-        timelockExpiry: number;
-    };
-}
-/** Options for on-chain refund */
-export interface OnchainRefundOptions {
-    /** Destination address to receive refunded BTC */
-    destinationAddress: string;
-    /** Fee rate in satoshis per virtual byte (default: 2) */
-    feeRateSatPerVb?: number;
-    /** If true, only build the transaction without broadcasting (default: false) */
-    dryRun?: boolean;
-}
-/** Options for Arkade (off-chain) refund */
-export interface ArkadeRefundOptions {
-    /** Destination Arkade address to receive refunded BTC */
-    destinationAddress: string;
-    /** Arkade server URL (optional, uses default based on network) */
-    arkadeServerUrl?: string;
-}
-/** Options for EVM refund via coordinator */
-export interface EvmRefundOptions {
-    /**
-     * Refund mode:
-     * - "swap-back" (default): Swap WBTC back to original token via DEX
-     * - "direct": Return WBTC directly (useful when DEX calldata is stale)
-     */
-    mode?: "swap-back" | "direct";
-}
-/** General refund options — the method picks the right variant based on swap type */
-export type RefundOptions = OnchainRefundOptions | ArkadeRefundOptions | EvmRefundOptions;
-/** Options for Arkade (off-chain) claim */
-export interface ArkadeClaimOptions {
-    /** Destination Arkade address to receive claimed BTC */
-    destinationAddress: string;
-    /** Arkade server URL (optional, uses default based on network) */
-    arkadeServerUrl?: string;
-}
-/** Options for claiming a swap */
-export interface ClaimOptions {
-    /**
-     * @deprecated For Arkade-to-EVM swaps, the destination is now set at swap creation time
-     * and stored on the server. This option is ignored for arkade_to_evm swaps.
-     */
-    destination?: string;
-    /** Bitcoin destination address for EVM-to-Bitcoin claims (required for evm_to_bitcoin direction) */
-    destinationAddress?: string;
-    /** Fee rate in sat/vB for on-chain Bitcoin claims (default: 2) */
-    feeRateSatPerVb?: number;
-}
-/** Result of getting EVM funding call data */
-export interface EvmFundingCallData {
-    /** Call data for approving token spend (ERC20 approve) */
-    approve: {
-        /** Token contract address to call */
-        to: string;
-        /** Encoded approve(spender, amount) call data */
-        data: string;
-    };
-    /** Call data for creating the swap (from server) */
-    createSwap: {
-        /** HTLC contract address to call */
-        to: string;
-        /** Encoded createSwap call data (from server) */
-        data: string;
-    };
-}
-/** Result of getting coordinator funding call data for EVM-to-BTC swaps */
-export interface CoordinatorFundingCallData {
-    /** Call data for approving source token spend to the coordinator */
-    approve: {
-        /** Source token contract address to call */
-        to: string;
-        /** Encoded approve(coordinator, amount) call data */
-        data: string;
-    };
-    /** Call data for executeAndCreate on the coordinator */
-    executeAndCreate: {
-        /** Coordinator contract address to call */
-        to: string;
-        /** Encoded executeAndCreate call data */
-        data: string;
-    };
-}
-/** Result of getting coordinator refund call data */
-export interface CoordinatorRefundCallData {
-    /** Contract address to call */
-    to: string;
-    /** Encoded refund call data */
-    data: string;
-    /** Whether the timelock has expired (refund is possible) */
-    timelockExpired: boolean;
-    /** Unix timestamp when the timelock expires */
-    timelockExpiry: number;
-    /** Refund mode used */
-    mode: "swap-back" | "direct";
-}
-/** Configuration options for the Lendaswap client. */
-export interface ClientConfig {
-    /** The base URL of the Lendaswap API. */
-    baseUrl: string;
-    /** Optional API key for authenticated requests. */
-    apiKey?: string;
-    /** Optional Esplora API URL for broadcasting Bitcoin transactions. */
-    esploraUrl?: string;
-    /** Optional Arkade server URL (e.g. "https://arkade.computer"). Falls back to network-based defaults. */
-    arkadeServerUrl?: string;
-}
-/**
- * Builder for creating a Lendaswap client with a fluent API.
- *
- * The `build()` method is async and returns a fully initialized client.
- *
- * @example
- * ```ts
- * // Create client with new wallet (generates mnemonic)
- * const client = await Client.builder()
- *   .withSignerStorage(new IdbWalletStorage())
- *   .build();
- *
- * // Create client with existing mnemonic
- * const client = await Client.builder()
- *   .withSignerStorage(new IdbWalletStorage())
- *   .withMnemonic("abandon abandon abandon ...")
- *   .build();
- *
- * // Create client without storage (stateless, generates new mnemonic)
- * const client = await Client.builder().build();
- * ```
- */
-export declare class ClientBuilder {
-    #private;
-    /**
-     * Sets the base URL for the API.
-     * @param baseUrl - The base URL of the Lendaswap API.
-     * @returns The builder instance for chaining.
-     */
-    withBaseUrl(baseUrl: string): this;
-    /**
-     * Sets the API key for authenticated requests.
-     * @param apiKey - The API key to use for authentication.
-     * @returns The builder instance for chaining.
-     */
-    withApiKey(apiKey: string): this;
-    /**
-     * Sets the Esplora API URL for broadcasting Bitcoin transactions.
-     *
-     * If not set, defaults will be used based on the network:
-     * - mainnet: https://mempool.space/api
-     * - testnet: https://mempool.space/testnet/api
-     * - signet: https://mempool.space/signet/api
-     *
-     * @param esploraUrl - The Esplora API base URL.
-     * @returns The builder instance for chaining.
-     */
-    withEsploraUrl(esploraUrl: string): this;
-    /**
-     * Sets the Arkade server URL for VHTLC operations (claim, refund, amounts).
-     *
-     * If not set, defaults are used based on the network:
-     * - bitcoin: https://arkade.computer
-     * - signet: wa
-     *
-     * @param arkadeServerUrl - The Arkade server base URL.
-     * @returns The builder instance for chaining.
-     */
-    withArkadeServerUrl(arkadeServerUrl: string): this;
-    /**
-     * Sets the storage backend for signer data (mnemonic and key index).
-     * @param storage - The storage implementation to use.
-     * @returns The builder instance for chaining.
-     */
-    withSignerStorage(storage: WalletStorage): this;
-    /**
-     * Sets the storage backend for swap data.
-     *
-     * When configured, swaps will be automatically persisted after creation.
-     *
-     * @param storage - The swap storage implementation to use.
-     * @returns The builder instance for chaining.
-     */
-    withSwapStorage(storage: SwapStorage): this;
-    /**
-     * Sets the mnemonic phrase to use for the signer.
-     *
-     * If provided, this mnemonic will be used instead of loading from storage
-     * or generating a new one. The mnemonic will be persisted to storage if
-     * storage is configured.
-     *
-     * @param mnemonic - The BIP39 mnemonic phrase (12, 15, 18, 21, or 24 words).
-     * @returns The builder instance for chaining.
-     */
-    withMnemonic(mnemonic: string): this;
-    /**
-     * Builds and returns a fully initialized Client instance.
-     *
-     * Initialization order:
-     * 1. If `withMnemonic()` was called, use that mnemonic
-     * 2. Else if storage is configured and contains a mnemonic, load it
-     * 3. Else generate a new mnemonic
-     *
-     * The mnemonic is persisted to storage if storage is configured.
-     *
-     * @returns A promise that resolves to a fully initialized Client.
-     * @throws Error if the provided mnemonic is invalid.
-     */
-    build(): Promise<Client>;
-}
-/**
- * Main client for interacting with the Lendaswap API.
- *
- * The client manages:
- * - API communication
- * - Signer (HD wallet) for key derivation
- * - Storage for persisting mnemonic and key index
- *
- * Use `Client.builder()` to create a new instance.
- *
- * @example
- * ```ts
- * const client = await Client.builder()
- *   .withSignerStorage(new IdbWalletStorage())
- *   .withApiKey("your-api-key")
- *   .build();
- *
- * // Get mnemonic (for backup)
- * const mnemonic = client.getMnemonic();
- *
- * // Derive swap parameters
- * const params = await client.deriveSwapParams();
- * ```
- */
-export declare class Client {
-    #private;
-    /**
-     * Creates a new Client instance.
-     *
-     * Use `Client.builder()` instead of calling this constructor directly.
-     *
-     * @internal
-     */
-    constructor(config: ClientConfig, signer: Signer, signerStorage?: WalletStorage, swapStorage?: SwapStorage);
-    /**
-     * Creates a new ClientBuilder for fluent configuration.
-     * @returns A new ClientBuilder instance.
-     */
-    static builder(): ClientBuilder;
-    /** The underlying typed API client for direct API access. */
-    get api(): ApiClient;
-    /** The base URL of the API. */
-    get baseUrl(): string;
-    /** The swap storage, if configured. */
-    get swapStorage(): SwapStorage | undefined;
-    /**
-     * Gets the mnemonic phrase.
-     *
-     * Store this securely - it's the only way to recover the wallet.
-     *
-     * @returns The BIP39 mnemonic phrase.
-     */
-    getMnemonic(): string;
-    /**
-     * Loads a mnemonic phrase, replacing the current signer.
-     *
-     * The new mnemonic is persisted to storage if storage is configured.
-     *
-     * @param mnemonic - The BIP39 mnemonic phrase to load.
-     * @throws Error if the mnemonic is invalid.
-     */
-    loadMnemonic(mnemonic: string): Promise<void>;
-    /**
-     * Gets the user ID extended public key for wallet recovery.
-     *
-     * This can be shared with the server for recovering swap history.
-     *
-     * @returns The hex-encoded user ID xpub.
-     */
-    getUserIdXpub(): string;
-    /**
-     * Derives swap parameters at the next available index.
-     *
-     * Automatically increments the key index in storage (if configured).
-     *
-     * @returns The derived swap parameters.
-     */
-    deriveSwapParams(): Promise<SwapParams>;
-    /**
-     * Derives swap parameters at a specific index.
-     *
-     * Does not modify the stored key index. Useful for recovery scenarios.
-     *
-     * @param index - The key index to derive.
-     * @returns The derived swap parameters.
-     */
-    deriveSwapParamsAtIndex(index: number): SwapParams;
-    /**
-     * Gets the current key index from storage.
-     * @returns The current key index, or 0 if no storage is configured.
-     */
-    getKeyIndex(): Promise<number>;
-    /**
-     * Sets the key index in storage.
-     *
-     * Useful for recovery scenarios where you need to set the index
-     * to a specific value.
-     *
-     * @param index - The new key index.
-     * @throws Error if no storage is configured.
-     */
-    setKeyIndex(index: number): Promise<void>;
-    /**
-     * Checks the health status of the API.
-     * @returns A promise that resolves to "ok" if the API is healthy.
-     * @throws Error if the health check fails.
-     */
-    healthCheck(): Promise<string>;
-    /**
-     * Gets the version information of the API.
-     * @returns A promise that resolves to the version info containing tag and commit hash.
-     * @throws Error if the request fails.
-     */
-    getVersion(): Promise<{
-        tag: string;
-        commit_hash: string;
-    }>;
-    /**
-     * Gets the current Median Time Past (MTP) and tip block height.
-     * @returns A promise that resolves to the MTP timestamp and tip height.
-     * @throws Error if the request fails or MTP is not yet available.
-     */
-    getMtp(): Promise<{
-        mtp: number;
-        tip_height: number;
-    }>;
-    /**
-     * Gets the list of supported tokens.
-     * @returns A promise that resolves to an array of token information.
-     * @throws Error if the request fails.
-     */
-    getTokens(): Promise<TokenInfos>;
-    /**
-     * Gets a quote for swapping between two tokens.
-     * @param params - Quote parameters.
-     * @param params.sourceChain - Source blockchain (e.g., "Arkade", "Polygon").
-     * @param params.sourceToken - Source token: contract address for EVM tokens, or "btc" for BTC.
-     * @param params.targetChain - Target blockchain (e.g., "Polygon", "Lightning").
-     * @param params.targetToken - Target token: contract address for EVM tokens, or "btc" for BTC.
-     * @param params.sourceAmount - Amount in smallest unit of source token (mutually exclusive with targetAmount).
-     * @param params.targetAmount - Amount in smallest unit of target token (mutually exclusive with sourceAmount).
-     * @returns A promise that resolves to the quote response with pricing details.
-     * @throws Error if the request fails.
-     */
-    getQuote(params: {
-        sourceChain: Chain;
-        sourceToken: string;
-        targetChain: Chain;
-        targetToken: string;
-        sourceAmount?: number;
-        targetAmount?: number;
-    }): Promise<QuoteResponse>;
-    /**
-     * Gets the status and details of a swap by its ID.
-     * @param id - The UUID of the swap.
-     * @param options - Optional settings.
-     * @param options.updateStorage - If true, updates the swap in storage after fetching.
-     * @returns A promise that resolves to the swap details.
-     * @throws Error if the request fails or swap is not found.
-     */
-    getSwap(id: string, options?: {
-        updateStorage?: boolean;
-    }): Promise<GetSwapResponse>;
-    /**
-     * Gets a swap from local storage without making a server request.
-     *
-     * Use this when you need swap data but don't need the latest status
-     * from the server. The stored swap includes the preimage, keys, and
-     * the last known swap response.
-     *
-     * @param id - The UUID of the swap.
-     * @returns The stored swap data, or null if not found.
-     *
-     * @example
-     * ```ts
-     * const stored = await client.getStoredSwap(swapId);
-     * if (stored) {
-     *   console.log("Target:", stored.response.target_token);
-     *   console.log("Status:", stored.response.status);
-     * }
-     * ```
-     */
-    getStoredSwap(id: string): Promise<StoredSwap | null>;
-    /**
-     * Gets all stored swaps from local storage.
-     *
-     * @returns Array of all stored swap data, or empty array if no storage is configured.
-     */
-    listAllSwaps(): Promise<StoredSwap[]>;
-    deleteSwap(id: string): Promise<void>;
-    clearSwapStorage(): Promise<void>;
-    /**
-     * Recovers all swaps associated with the current wallet from the server.
-     *
-     * Sends the user's xpub to the server, which returns all swaps belonging
-     * to that wallet. For each recovered swap, re-derives the keys using the
-     * swap's derivation index and stores it locally.
-     *
-     * After recovery, the key index is set to `highest_index + 1` so that
-     * new swaps don't reuse derivation indices.
-     *
-     * @returns The recovered swaps stored locally.
-     */
-    recoverSwaps(): Promise<StoredSwap[]>;
-    /**
-     * Gets VHTLC amounts for an Arkade swap.
-     *
-     * Queries the Arkade indexer for spendable, spent, and recoverable balances
-     * at the VHTLC address associated with a swap. Works for:
-     * - BTC → EVM swaps where the source asset is Arkade
-     * - EVM → BTC swaps where the target asset is Arkade
-     *
-     * Reads swap data from local storage (does not contact the server).
-     *
-     * @param id - The UUID of the swap.
-     * @returns The VHTLC amounts in satoshis.
-     */
-    amountsForSwap(id: string): Promise<VhtlcAmounts>;
-    /**
-     * Claims a swap by revealing the preimage.
-     *
-     * Reads swap data and preimage from local storage. The claim method
-     * depends on the swap direction and target chain:
-     * - **Arkade/Lightning-to-EVM**: Gasless claim via server
-     * - **Other EVM swaps**: Returns call data for manual claiming
-     * - **Arkade**: Claims via Arkade protocol
-     *
-     * @param id - The UUID of the swap.
-     * @param _options - Deprecated. For Arkade/Lightning-to-EVM, destination is set at swap creation.
-     * @returns A ClaimResult with the outcome.
-     *
-     * @example
-     * ```ts
-     * // Arkade-to-EVM (gasless via server, uses stored target address)
-     * const result = await client.claim(swapId);
-     *
-     * // Other swap types
-     * const result = await client.claim(swapId);
-     * if (result.success) {
-     *   console.log("Claim TX:", result.txHash);
-     * }
-     * ```
-     */
-    claim(id: string, _options?: ClaimOptions): Promise<ClaimResult>;
-    /**
-     * Claims an Arkade-to-EVM swap gaslessly via the server.
-     *
-     * The SDK builds the EIP-712 digest, signs it with the swap's internally
-     * derived EVM key, and sends the signature + secret to the server. The
-     * server submits the `coordinator.redeemAndExecute` transaction.
-     *
-     * @param id - The UUID of the swap.
-     * @param destination - The EVM address where tokens should be sent.
-     * @returns The gasless claim result with transaction hash.
-     *
-     * @example
-     * ```ts
-     * const result = await client.claimViaGasless(swapId, "0xYourAddress");
-     * console.log("Claimed! TX:", result.txHash);
-     * ```
-     */
-    claimViaGasless(id: string, destination: string, options?: {
-        slippage?: number;
-    }): Promise<ClaimGaslessResult>;
-    /**
-     * Claims an Arkade (off-chain) VHTLC swap by revealing the preimage.
-     *
-     * Automatically selects the best claim method based on VTXO status:
-     * - **spendable** VTXOs → offchain spend (submitTx/finalizeTx)
-     * - **recoverable** or **mixed** VTXOs → delegated settlement via backend
-     *
-     * This is used for EVM-to-Arkade and BTC-to-Arkade swaps where the user
-     * claims BTC on Arkade after the server has funded the VHTLC.
-     *
-     * @param id - The UUID of the swap.
-     * @param options - Claim options including destination address.
-     * @returns The claim result with transaction ID and amount.
-     *
-     * @example
-     * ```ts
-     * const result = await client.claimArkade(swapId, {
-     *   destinationAddress: "ark1q...", // Where to receive BTC
-     * });
-     * if (result.success) {
-     *   console.log("Claim TX:", result.txId);
-     *   console.log("Amount:", result.claimAmount);
-     * }
-     * ```
-     */
-    claimArkade(id: string, options: ArkadeClaimOptions): Promise<{
-        success: boolean;
-        message: string;
-        txId?: string;
-        claimAmount?: bigint;
-    }>;
-    /**
-     * Attempts to refund a swap.
-     *
-     * Refund behavior depends on the swap type:
-     * - **Lightning to EVM**: Cannot refund - Lightning swaps auto-expire if not completed.
-     *   The invoice will simply expire and no funds are locked.
-     * - **Arkade to EVM**: Off-chain refund via Arkade server
-     * - **Bitcoin (on-chain) to EVM**: Builds a signed refund transaction that the user
-     *   must broadcast to reclaim their funds after the locktime.
-     *
-     * @param id - The UUID of the swap to refund.
-     * @param options - Options for on-chain refunds (required for btc_onchain swaps).
-     * @returns A RefundResult with the transaction details (for on-chain) or status message.
-     * @throws Error if the swap cannot be found, storage is not configured, or params are invalid.
-     *
-     * @example
-     * ```ts
-     * // For on-chain swaps
-     * const result = await client.refundSwap(swapId, {
-     *   destinationAddress: "bc1q...",
-     *   feeRateSatPerVb: 5,
-     * });
-     * if (result.success) {
-     *   console.log("Broadcast this transaction:", result.txHex);
-     *   console.log("Transaction ID:", result.txId);
-     * }
-     * ```
-     */
-    refundSwap(id: string, options?: RefundOptions): Promise<RefundResult>;
-    /**
-     * Creates a swap by routing to the correct direction-specific method
-     * based on `sourceAsset.chain` and `targetAsset.chain`.
-     *
-     * Supported directions:
-     * - Arkade → EVM
-     * - Lightning → EVM
-     * - Bitcoin (on-chain) → EVM
-     * - Bitcoin (on-chain) → Arkade
-     * - EVM → Arkade
-     * - EVM → Bitcoin (on-chain)
-     * - EVM → Lightning
-     *
-     * @param options - The swap options including source/target assets, amounts, and addresses.
-     * @returns The swap result (response + swapParams).
-     * @throws Error if the swap direction is unsupported or required fields are missing.
-     */
-    createSwap(options: CreateSwapOptions): Promise<CreateSwapResult>;
-    /**
-     * Creates a new Arkade-to-EVM swap via the generic chain-agnostic endpoint.
-     *
-     * Uses the `/swap/arkade/evm` endpoint which supports any ERC-20 token
-     * reachable through 1inch aggregation. Returns coordinator address and
-     * optional 1inch calldata for the redeem-and-swap flow.
-     *
-     * @param options - The swap options.
-     * @returns The swap response and parameters for storage.
-     * @throws Error if the swap creation fails.
-     *
-     * @example
-     * ```ts
-     * const result = await client.createArkadeToEvmSwapGeneric({
-     *   targetAddress: "0x1234...",
-     *   tokenAddress: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", // USDC on Polygon
-     *   evmChainId: 137,
-     *   sourceAmount: 100000, // 100k sats
-     * });
-     * console.log("Fund:", result.response.btc_vhtlc_address);
-     * console.log("Coordinator:", result.response.evm_coordinator_address);
-     * ```
-     */
-    createArkadeToEvmSwapGeneric(options: ArkadeToEvmSwapOptions): Promise<ArkadeToEvmSwapResult>;
-    /**
-     * Creates a new Lightning to EVM swap using the generic chain-agnostic endpoint.
-     *
-     * @param options - The swap options including evmChainId and tokenAddress.
-     * @returns The swap response and parameters for storage.
-     */
-    createLightningToEvmSwapGeneric(options: LightningToEvmSwapGenericOptions): Promise<LightningToEvmSwapGenericResult>;
-    /**
-     * Creates a new Bitcoin (on-chain) to EVM swap.
-     *
-     * Automatically derives swap parameters and increments the key index.
-     *
-     * @param options - The swap options.
-     * @returns The swap response and parameters for storage.
-     * @throws Error if the swap creation fails.
-     *
-     * @example
-     * ```ts
-     * const result = await client.createBitcoinToEvmSwap({
-     *   targetAddress: "0x1234...",
-     *   tokenAddress: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", // USDC on Polygon
-     *   evmChainId: 137,
-     *   sourceAmount: 100000, // 100k sats
-     * });
-     * console.log("Send BTC to:", result.response.btc_htlc_address);
-     * ```
-     */
-    createBitcoinToEvmSwap(options: BitcoinToEvmSwapOptions): Promise<BitcoinToEvmSwapResult>;
-    /**
-     * Creates a new Bitcoin (on-chain) to Arkade swap.
-     *
-     * The user sends on-chain BTC to a Taproot HTLC address and receives
-     * Arkade VTXOs after the server funds the Arkade VHTLC.
-     *
-     * Automatically derives swap parameters and increments the key index.
-     *
-     * @param options - The swap options.
-     * @returns The swap response and parameters for storage.
-     * @throws Error if the swap creation fails.
-     *
-     * @example
-     * ```ts
-     * const result = await client.createBitcoinToArkadeSwap({
-     *   satsReceive: 100000, // 100k sats to receive on Arkade
-     *   targetAddress: "ark1q...", // Arkade address
-     * });
-     * console.log("Send BTC to:", result.response.btc_htlc_address);
-     * console.log("Amount to send:", result.response.source_amount, "sats");
-     * ```
-     */
-    createBitcoinToArkadeSwap(options: BitcoinToArkadeSwapOptions): Promise<BitcoinToArkadeSwapResult>;
-    /**
-     * Creates a new EVM-to-Arkade swap via the generic endpoint.
-     *
-     * Uses the chain-agnostic `/swap/evm/arkade` endpoint which supports any
-     * ERC-20 token reachable through 1inch aggregation.
-     *
-     * @param options - The swap options.
-     * @returns The swap response and parameters for storage.
-     * @throws Error if the swap creation fails.
-     *
-     * @example
-     * ```ts
-     * const result = await client.createEvmToArkadeSwapGeneric({
-     *   targetAddress: "ark1q...",
-     *   tokenAddress: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", // USDC on Polygon
-     *   evmChainId: 137,
-     *   userAddress: "0x1234...",
-     *   sourceAmount: 100000000, // 100 USDC (6 decimals)
-     * });
-     * console.log("HTLC:", result.response.evm_htlc_address);
-     * ```
-     */
-    createEvmToArkadeSwapGeneric(options: EvmToArkadeSwapGenericOptions): Promise<EvmToArkadeSwapGenericResult>;
-    /**
-     * Creates a new EVM-to-Bitcoin (on-chain) swap.
-     *
-     * Uses the chain-agnostic `/swap/evm/bitcoin` endpoint which supports any
-     * ERC-20 token reachable through 1inch aggregation. The user locks tokens
-     * in an EVM HTLC and receives BTC to an on-chain Taproot HTLC.
-     *
-     * @param options - The swap options.
-     * @returns The swap response and parameters for storage.
-     * @throws Error if the swap creation fails.
-     *
-     * @example
-     * ```ts
-     * const result = await client.createEvmToBitcoinSwap({
-     *   tokenAddress: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", // USDC on Polygon
-     *   evmChainId: 137,
-     *   userAddress: "0x1234...",
-     *   sourceAmount: 100000000n, // 100 USDC (6 decimals)
-     * });
-     * console.log("EVM HTLC:", result.response.evm_htlc_address);
-     * console.log("BTC HTLC:", result.response.btc_htlc_address);
-     * ```
-     */
-    createEvmToBitcoinSwap(options: EvmToBitcoinSwapOptions): Promise<EvmToBitcoinSwapResult>;
-    /**
-     * Creates a new EVM to Lightning swap using the chain-agnostic generic endpoint.
-     *
-     * This allows users to swap any ERC-20 token from any supported EVM chain
-     * to pay a Lightning invoice.
-     *
-     * @param options - The swap options including Lightning invoice, chain ID, and token address.
-     * @returns The swap response and parameters for storage.
-     * @throws Error if the swap creation fails.
-     *
-     * @example
-     * ```ts
-     * const result = await client.createEvmToLightningSwapGeneric({
-     *   lightningInvoice: "lnbc...",
-     *   evmChainId: 137, // Polygon
-     *   tokenAddress: "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6", // WBTC
-     *   userAddress: "0x1234...",
-     * });
-     * console.log("HTLC contract:", result.response.evm_htlc_address);
-     * console.log("Swap ID:", result.response.id);
-     * ```
-     */
-    createEvmToLightningSwapGeneric(options: EvmToLightningSwapGenericOptions): Promise<EvmToLightningSwapGenericResult>;
-    /**
-     * Gets call data to fund an EVM-to-BTC swap via the HTLCCoordinator.
-     *
-     * The coordinator atomically swaps source tokens (e.g. USDC) to WBTC via DEX
-     * and locks the WBTC into an HTLC in a single transaction.
-     *
-     * Fetches the coordinator calldata from the server, which builds the 1inch
-     * swap calldata and computes the refundCallsHash.
-     *
-     * @param swapId - The UUID of the swap.
-     * @param approveMax - If true, approves max uint256. If false, approves exact amount. Default: true.
-     * @returns The approve and executeAndCreate call data.
-     *
-     * @example
-     * ```ts
-     * const swap = await client.createEvmToArkadeSwap({...});
-     * const funding = await client.getCoordinatorFundingCallData(swap.response.id);
-     *
-     * // Step 1: Approve source token to coordinator
-     * await wallet.sendTransaction({ to: funding.approve.to, data: funding.approve.data });
-     *
-     * // Step 2: Execute swap + create HTLC
-     * await wallet.sendTransaction({ to: funding.executeAndCreate.to, data: funding.executeAndCreate.data });
-     * ```
-     */
-    getCoordinatorFundingCallData(swapId: string, approveMax?: boolean): Promise<CoordinatorFundingCallData>;
-}
-//# sourceMappingURL=client.d.ts.map