@silentswap/react 0.0.53 → 0.0.55

package/dist/contexts/BalancesContext.d.ts

@@ -21,6 +21,8 @@ export declare const BalancesProvider: React.FC<{
     evmAddress?: string;
     solAddress?: string;
     solanaRpcUrl?: string;
+    bitcoinAddress?: string;
+    bitcoinRpcUrl?: string;
 }>;
 /**
  * Hook to access user balances

package/dist/contexts/BalancesContext.js

@@ -8,7 +8,7 @@ import { getAssociatedTokenAddress } from '@solana/spl-token';
 import { PublicKey } from '@solana/web3.js';
 import { useAssetsContext } from './AssetsContext.js';
 import { usePrices } from '../hooks/usePrices.js';
-import { isSolanaAsset, parseSolanaCaip19, isSolanaNativeToken, isSplToken, isEvmNativeToken, SB58_CHAIN_ID_SOLANA_MAINNET, A_VIEM_CHAINS, } from '@silentswap/sdk';
+import { isSolanaAsset, parseSolanaCaip19, isSolanaNativeToken, isSplToken, isEvmNativeToken, isBitcoinAsset, SB58_CHAIN_ID_SOLANA_MAINNET, A_VIEM_CHAINS, BITCOIN_CHAIN_ID, } from '@silentswap/sdk';
 const BalancesContext = createContext(undefined);
 // Custom RPC endpoints from 0xrpc.io (fast, free, private public RPC)
 // Reference: https://0xrpc.io
@@ -68,6 +68,18 @@ const separateSolanaAssets = (solanaAssets) => {
     }
     return { a_assets_native, a_assets_tokens };
 };
+// Utility: Separate Bitcoin assets (currently only native BTC is supported)
+const separateBitcoinAssets = (bitcoinAssets) => {
+    const a_assets_native = [];
+    for (const asset of bitcoinAssets) {
+        // Bitcoin native token uses slip44:0 or similar
+        // For now, we'll treat all Bitcoin assets as native (BTC)
+        if (isBitcoinAsset(asset.caip19)) {
+            a_assets_native.push(asset);
+        }
+    }
+    return { a_assets_native };
+};
 // Utility: Fetch ERC-20 balance for a single token (fallback when multicall not available)
 const fetchSingleErc20Balance = async (y_client, s0x_account, k_asset, getUnitValueUsd) => {
     try {
@@ -354,10 +366,80 @@ const fetchSolanaBalances = async (solAddress, solanaRpcUrl, assets, getUnitValu
         return { balances: {}, error: errorMsg };
     }
 };
+// Utility: Fetch Bitcoin native balances using Mempool.space API
+const fetchBitcoinNativeBalances = async (bitcoinAddress, a_assets_native, getUnitValueUsd) => {
+    const updatedBalances = {};
+    if (a_assets_native.length === 0)
+        return updatedBalances;
+    try {
+        // Fetch balance from Mempool.space API (free, no auth required)
+        // Returns balance in satoshis (smallest unit, 1 BTC = 100,000,000 satoshis)
+        const response = await fetch(`https://mempool.space/api/address/${bitcoinAddress}`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch Bitcoin balance: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        // Mempool.space returns chain_stats with funded_txo_sum and spent_txo_sum
+        // Balance = funded - spent
+        const funded = BigInt(data.chain_stats?.funded_txo_sum || 0);
+        const spent = BigInt(data.chain_stats?.spent_txo_sum || 0);
+        const xg_balance = funded - spent;
+        await Promise.all(a_assets_native.map(async (k_asset) => {
+            let x_value_usd = 0;
+            try {
+                x_value_usd = await getUnitValueUsd(k_asset, xg_balance);
+            }
+            catch (error) {
+                // console.warn(`Failed to calculate USD value for native ${k_asset.caip19}:`, error);
+            }
+            updatedBalances[k_asset.caip19] = {
+                asset: k_asset,
+                balance: xg_balance,
+                usdValue: x_value_usd,
+            };
+        }));
+    }
+    catch (error) {
+        // Log error for debugging but don't throw - allow other operations to continue
+        if (process.env.NODE_ENV === 'development') {
+            console.warn(`Failed to fetch native BTC balance:`, error);
+        }
+    }
+    return updatedBalances;
+};
+// Utility: Fetch all Bitcoin balances using direct API calls
+const fetchBitcoinBalances = async (bitcoinAddress, bitcoinRpcUrl, // Not used currently, but kept for potential future RPC usage
+assets, getUnitValueUsd) => {
+    try {
+        const bitcoinAssets = Object.values(assets).filter((asset) => isBitcoinAsset(asset.caip19));
+        const { a_assets_native } = separateBitcoinAssets(bitcoinAssets);
+        // Fetch native Bitcoin balances using Mempool.space API
+        const nativeResult = await Promise.allSettled([
+            fetchBitcoinNativeBalances(bitcoinAddress, a_assets_native, getUnitValueUsd),
+        ]);
+        const nativeBalances = nativeResult[0]?.status === 'fulfilled' ? nativeResult[0].value : {};
+        // Collect errors if any
+        const errors = [];
+        if (nativeResult[0]?.status === 'rejected') {
+            errors.push(`Native: ${nativeResult[0].reason?.message || 'Unknown error'}`);
+        }
+        return {
+            balances: nativeBalances,
+            error: errors.length > 0 ? errors.join('; ') : undefined,
+        };
+    }
+    catch (error) {
+        const errorMsg = `Failed to fetch Bitcoin balances: ${error instanceof Error ? error.message : String(error)}`;
+        if (process.env.NODE_ENV === 'development') {
+            console.error(errorMsg, error);
+        }
+        return { balances: {}, error: errorMsg };
+    }
+};
 /**
  * Provider for user balances across all supported chains
  */
-export const BalancesProvider = ({ children, evmAddress, solAddress, solanaRpcUrl }) => {
+export const BalancesProvider = ({ children, evmAddress, solAddress, solanaRpcUrl, bitcoinAddress, bitcoinRpcUrl }) => {
     const { assets, loading: assetsLoading } = useAssetsContext();
     const { getUnitValueUsd } = usePrices();
     const [balances, setBalances] = useState({});
@@ -388,6 +470,15 @@ export const BalancesProvider = ({ children, evmAddress, solAddress, solanaRpcUr
                     promise: fetchSolanaBalances(solAddress, solanaRpcUrl, assets, getUnitValueUsd),
                 });
             }
+            console.log('[BalancesContext] bitcoinAddress', bitcoinAddress);
+            console.log('[BalancesContext] bitcoinRpcUrl', bitcoinRpcUrl);
+            // Process Bitcoin balances if Bitcoin address is available
+            if (bitcoinAddress && bitcoinRpcUrl) {
+                balanceTasks.push({
+                    chainId: BITCOIN_CHAIN_ID,
+                    promise: fetchBitcoinBalances(bitcoinAddress, bitcoinRpcUrl, assets, getUnitValueUsd),
+                });
+            }
             // Use Promise.allSettled to handle partial failures gracefully
             // This ensures one chain failure doesn't prevent others from updating
             const results = await Promise.allSettled(balanceTasks.map((task) => task.promise));
@@ -454,6 +545,15 @@ export const BalancesProvider = ({ children, evmAddress, solAddress, solanaRpcUr
                     promise: fetchSolanaBalances(solAddress, solanaRpcUrl, assets, getUnitValueUsd),
                 });
             }
+            // Process Bitcoin balances if requested
+            const shouldRefetchBitcoin = chainIds.includes(BITCOIN_CHAIN_ID);
+            console.log('[BalancesContext] shouldRefetchBitcoin', shouldRefetchBitcoin);
+            if (bitcoinAddress && bitcoinRpcUrl && shouldRefetchBitcoin) {
+                balanceTasks.push({
+                    chainId: BITCOIN_CHAIN_ID,
+                    promise: fetchBitcoinBalances(bitcoinAddress, bitcoinRpcUrl, assets, getUnitValueUsd),
+                });
+            }
             // Use Promise.allSettled to handle partial failures gracefully
             const results = await Promise.allSettled(balanceTasks.map((task) => task.promise));
             const newBalances = {};
@@ -500,17 +600,17 @@ export const BalancesProvider = ({ children, evmAddress, solAddress, solanaRpcUr
         finally {
             setLoading(false);
         }
-    }, [evmAddress, solAddress, solanaRpcUrl, assets, assetsLoading, getUnitValueUsd]);
+    }, [evmAddress, solAddress, solanaRpcUrl, bitcoinAddress, bitcoinRpcUrl, assets, assetsLoading, getUnitValueUsd]);
     // Calculate total USD value
     const totalUsdValue = useMemo(() => {
         return Object.values(balances).reduce((total, balance) => total + balance.usdValue, 0);
     }, [balances]);
-    // Auto-update balances when address, solAddress, or assets change
+    // Auto-update balances when address, solAddress, bitcoinAddress, or assets change
     useEffect(() => {
-        if ((evmAddress || solAddress) && !assetsLoading) {
+        if ((evmAddress || solAddress || bitcoinAddress) && !assetsLoading) {
             updateBalances();
         }
-    }, [evmAddress, solAddress, solanaRpcUrl, assetsLoading, updateBalances]);
+    }, [evmAddress, solAddress, solanaRpcUrl, bitcoinAddress, bitcoinRpcUrl, assetsLoading, updateBalances]);
     const value = useMemo(() => ({
         balances,
         loading: loading || assetsLoading,

package/dist/contexts/SilentSwapContext.d.ts

@@ -5,6 +5,7 @@ import { ENVIRONMENT, type SilentSwapClient, type SilentSwapClientConfig, type A
 import { type ExecuteSwapParams, type SwapResult } from '../hooks/silent/useSilentQuote.js';
 import { type OutputStatus } from '../hooks/silent/useOrderTracking.js';
 import { type SolanaWalletConnector, type SolanaConnection } from '../hooks/silent/solana-transaction.js';
+import { type BitcoinWalletConnector, type BitcoinConnection } from '../hooks/silent/bitcoin-transaction.js';
 import { type SilentSwapWallet } from '../hooks/silent/useWallet.js';
 export interface SilentSwapContextType {
     client: SilentSwapClient;
@@ -42,7 +43,7 @@ export interface SilentSwapContextType {
     solanaRpcUrl?: string;
 }
 export declare function useSilentSwap(): SilentSwapContextType;
-export declare function SilentSwapProvider({ children, client, evmAddress, solAddress, connector, isConnected, solanaConnector, solanaConnection, environment, baseUrl, solanaRpcUrl, walletClient, }: {
+export declare function SilentSwapProvider({ children, client, evmAddress, solAddress, connector, isConnected, solanaConnector, solanaConnection, bitcoinConnector, bitcoinConnection, environment, baseUrl, solanaRpcUrl, walletClient, bitcoinAddress, bitcoinRpcUrl, }: {
     children: React.ReactNode;
     client: SilentSwapClient;
     evmAddress?: string;
@@ -52,7 +53,11 @@ export declare function SilentSwapProvider({ children, client, evmAddress, solAd
     walletClient?: WalletClient;
     solanaConnector?: SolanaWalletConnector;
     solanaConnection?: SolanaConnection;
+    bitcoinConnector?: BitcoinWalletConnector;
+    bitcoinConnection?: BitcoinConnection;
     environment?: ENVIRONMENT;
     baseUrl?: string;
     solanaRpcUrl?: string;
+    bitcoinAddress?: string;
+    bitcoinRpcUrl?: string;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/contexts/SilentSwapContext.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useEffect, useMemo } from 'react';
+import { createContext, useContext, useEffect, useMemo, useState, useCallback } from 'react';
 import { useAuth } from '../hooks/silent/useAuth.js';
 import { useWallet } from '../hooks/silent/useWallet.js';
 import { useSilentQuote } from '../hooks/silent/useSilentQuote.js';
@@ -63,7 +63,7 @@ export function useSilentSwap() {
     }
     return context;
 }
-function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, solanaConnector, solanaConnection, environment, config, solanaRpcUrl, connector, isConnected = false, walletClient, }) {
+function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, bitcoinAddress, solanaConnector, solanaConnection, bitcoinConnector, bitcoinConnection, environment, config, solanaRpcUrl, connector, isConnected = false, walletClient, }) {
     // Authentication hook - only for EVM
     const { auth, isLoading: authLoading } = useAuth({
         client,
@@ -90,7 +90,7 @@ function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, sol
     const setDestinations = useSwap((state) => state.setDestinations);
     const updateDestinationAmount = useSwap((state) => state.updateDestinationAmount);
     const splits = useSwap((state) => state.splits);
-    const transactionAddress = useTransactionAddress(tokenIn, evmAddress, solAddress);
+    const transactionAddress = useTransactionAddress(tokenIn, evmAddress, solAddress, bitcoinAddress);
     const effectiveQuoteAddress = transactionAddress;
     const { getPrice } = usePrices();
     const { serviceFeeRate, overheadUsd } = useStatus();
@@ -127,19 +127,28 @@ function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, sol
         connector,
         solanaConnector,
         solanaConnection,
+        bitcoinConnector,
+        bitcoinConnection,
         getPrice,
     });
-    const { handleNewSwap } = useResetSwapForm({
+    const effectiveDepositAmountUsd = useMemo(() => {
+        return depositAmountUsdFromEstimates > 0 ? depositAmountUsdFromEstimates : depositAmountUsdc;
+    }, [depositAmountUsdFromEstimates, depositAmountUsdc]);
+    const usdcPrice = usdcPriceFromEstimates || 1;
+    // Preserve last calculated fees to persist across component unmounts (e.g., when navigating to order tracking)
+    const [preservedFees, setPreservedFees] = useState(null);
+    const { handleNewSwap: handleNewSwapBase } = useResetSwapForm({
         clearQuote,
         isConnected,
         wallet,
         setFacilitatorGroups,
         refreshWallet,
     });
-    const effectiveDepositAmountUsd = useMemo(() => {
-        return depositAmountUsdFromEstimates > 0 ? depositAmountUsdFromEstimates : depositAmountUsdc;
-    }, [depositAmountUsdFromEstimates, depositAmountUsdc]);
-    const usdcPrice = usdcPriceFromEstimates || 1;
+    // Wrap handleNewSwap to also clear preserved fees
+    const handleNewSwap = useCallback(() => {
+        setPreservedFees(null);
+        handleNewSwapBase();
+    }, [handleNewSwapBase]);
     const { serviceFeeUsd, bridgeFeeIngressUsd, bridgeFeeEgressUsd } = useHiddenSwapFees({
         depositAmountUsdc: effectiveDepositAmountUsd,
         bridgeProvider: bridgeProviderFromQuote,
@@ -150,6 +159,21 @@ function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, sol
         ingressQuote: ingressQuoteFromEstimates,
         egressQuotes: egressQuotesFromEstimates,
     });
+    // Preserve fees when they're calculated (non-zero values indicate valid fees)
+    useEffect(() => {
+        if (serviceFeeUsd > 0 || bridgeFeeIngressUsd > 0 || bridgeFeeEgressUsd > 0) {
+            setPreservedFees({
+                serviceFeeUsd,
+                bridgeFeeIngressUsd,
+                bridgeFeeEgressUsd,
+                depositAmountUsdc: effectiveDepositAmountUsd,
+            });
+        }
+    }, [serviceFeeUsd, bridgeFeeIngressUsd, bridgeFeeEgressUsd, effectiveDepositAmountUsd]);
+    // Use preserved fees if current fees are zero (component was unmounted/remounted)
+    const effectiveServiceFeeUsd = serviceFeeUsd > 0 ? serviceFeeUsd : (preservedFees?.serviceFeeUsd ?? 0);
+    const effectiveBridgeFeeIngressUsd = bridgeFeeIngressUsd > 0 ? bridgeFeeIngressUsd : (preservedFees?.bridgeFeeIngressUsd ?? 0);
+    const effectiveBridgeFeeEgressUsd = bridgeFeeEgressUsd > 0 ? bridgeFeeEgressUsd : (preservedFees?.bridgeFeeEgressUsd ?? 0);
     const slippageUsd = useSlippageUsd({
         inputUsdValue: effectiveDepositAmountUsd,
         slippage,
@@ -185,9 +209,9 @@ function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, sol
             orderComplete,
             orderTrackingError,
             orderOutputs,
-            serviceFeeUsd,
-            bridgeFeeIngressUsd,
-            bridgeFeeEgressUsd,
+            serviceFeeUsd: effectiveServiceFeeUsd,
+            bridgeFeeIngressUsd: effectiveBridgeFeeIngressUsd,
+            bridgeFeeEgressUsd: effectiveBridgeFeeEgressUsd,
             slippageUsd,
             serviceFeeRate,
             overheadUsd,
@@ -197,7 +221,7 @@ function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, sol
             solanaRpcUrl,
         }, children: children });
 }
-export function SilentSwapProvider({ children, client, evmAddress, solAddress, connector, isConnected, solanaConnector, solanaConnection, environment = ENVIRONMENT.STAGING, baseUrl, solanaRpcUrl, walletClient, }) {
+export function SilentSwapProvider({ children, client, evmAddress, solAddress, connector, isConnected, solanaConnector, solanaConnection, bitcoinConnector, bitcoinConnection, environment = ENVIRONMENT.STAGING, baseUrl, solanaRpcUrl, walletClient, bitcoinAddress, bitcoinRpcUrl, }) {
     const config = useMemo(() => {
         const computedBaseUrl = baseUrl ?? ENVIRONMENT_CONFIGS[environment].baseUrl;
         console.log('[SilentSwapProvider] Creating config:', { environment, baseUrl, computedBaseUrl });
@@ -206,5 +230,5 @@ export function SilentSwapProvider({ children, client, evmAddress, solAddress, c
             baseUrl: computedBaseUrl,
         };
     }, [environment, baseUrl]);
-    return (_jsx(AssetsProvider, { children: _jsx(PricesProvider, { children: _jsx(BalancesProvider, { evmAddress: evmAddress, solAddress: solAddress, solanaRpcUrl: solanaRpcUrl, children: _jsx(OrdersProvider, { baseUrl: config.baseUrl, children: _jsx(SilentSwapInnerProvider, { client: client, connector: connector, isConnected: isConnected, evmAddress: evmAddress, solAddress: solAddress, solanaConnector: solanaConnector, solanaConnection: solanaConnection, environment: environment, config: config, solanaRpcUrl: solanaRpcUrl, walletClient: walletClient, children: children }) }) }) }) }));
+    return (_jsx(AssetsProvider, { children: _jsx(PricesProvider, { children: _jsx(BalancesProvider, { evmAddress: evmAddress, solAddress: solAddress, solanaRpcUrl: solanaRpcUrl, bitcoinAddress: bitcoinAddress, bitcoinRpcUrl: bitcoinRpcUrl, children: _jsx(OrdersProvider, { baseUrl: config.baseUrl, children: _jsx(SilentSwapInnerProvider, { client: client, connector: connector, isConnected: isConnected, evmAddress: evmAddress, solAddress: solAddress, bitcoinAddress: bitcoinAddress, solanaConnector: solanaConnector, solanaConnection: solanaConnection, bitcoinConnector: bitcoinConnector, bitcoinConnection: bitcoinConnection, environment: environment, config: config, solanaRpcUrl: solanaRpcUrl, walletClient: walletClient, children: children }) }) }) }) }));
 }

package/dist/hooks/silent/useBridgeExecution.d.ts

@@ -2,6 +2,7 @@ import type { Hex, WalletClient } from 'viem';
 import type { Connector } from 'wagmi';
 import type { DepositParams } from '@silentswap/sdk';
 import type { SolanaWalletConnector, SolanaConnection } from './solana-transaction.js';
+import type { BitcoinWalletConnector, BitcoinConnection } from './bitcoin-transaction.js';
 /**
  * Result from executing a bridge transaction
  */
@@ -29,11 +30,14 @@ export interface BridgeExecutionResult {
  * @param solanaConnector - Solana wallet connector (required for Solana swaps)
  * @param solanaConnection - Solana RPC connection (required for Solana swaps)
  * @param solanaRpcUrl - Optional Solana RPC URL
+ * @param bitcoinConnector - Bitcoin wallet connector (required for Bitcoin swaps)
+ * @param bitcoinConnection - Bitcoin connection (optional, for consistency)
  * @param setCurrentStep - Callback to set current step message
  * @param onStatus - Optional status update callback
  * @returns Functions for executing bridge transactions
  */
-export declare function useBridgeExecution(walletClient: WalletClient | undefined, connector: Connector | undefined, solanaConnector: SolanaWalletConnector | undefined, solanaConnection: SolanaConnection | undefined, solanaRpcUrl: string | undefined, setCurrentStep: (step: string) => void, depositorAddress: Hex, onStatus?: (status: string) => void): {
+export declare function useBridgeExecution(walletClient: WalletClient | undefined, connector: Connector | undefined, solanaConnector: SolanaWalletConnector | undefined, solanaConnection: SolanaConnection | undefined, solanaRpcUrl: string | undefined, setCurrentStep: (step: string) => void, depositorAddress: Hex, onStatus?: (status: string) => void, bitcoinConnector?: BitcoinWalletConnector, bitcoinConnection?: BitcoinConnection): {
     executeSolanaBridge: (sourceAsset: string, sourceAmount: string, usdcAmount: string | undefined, solanaSenderAddress: string, evmSignerAddress: `0x${string}`, depositParams?: DepositParams<`${bigint}`>) => Promise<BridgeExecutionResult>;
+    executeBitcoinBridge: (sourceAsset: string, sourceAmount: string, usdcAmount: string | undefined, bitcoinSenderAddress: string, evmSignerAddress: `0x${string}`, depositParams?: DepositParams<`${bigint}`>) => Promise<BridgeExecutionResult>;
     executeEvmBridge: (sourceChainId: number, sourceTokenAddress: string, sourceAmount: string, usdcAmount: string | undefined, depositParams: DepositParams<`${bigint}`>, evmSignerAddress: `0x${string}`, evmSenderAddress?: `0x${string}`, provider?: "relay" | "debridge") => Promise<BridgeExecutionResult>;
 };

package/dist/hooks/silent/useBridgeExecution.js

@@ -1,7 +1,8 @@
 import { useCallback } from 'react';
 import { encodeFunctionData, erc20Abi, getAddress } from 'viem';
-import { ensureChain, waitForTransactionConfirmation, createPublicClientWithRpc, NI_CHAIN_ID_AVALANCHE, S0X_ADDR_USDC_AVALANCHE, X_MAX_IMPACT_PERCENT, getRelayStatus, getDebridgeStatus, fetchDebridgeOrder, fetchRelayQuote, createPhonyDepositCalldata, isSolanaAsset, parseSolanaCaip19, isSolanaNativeToken, isSplToken, N_RELAY_CHAIN_ID_SOLANA, SB58_ADDR_SOL_PROGRAM_SYSTEM, getChainById, } from '@silentswap/sdk';
+import { ensureChain, waitForTransactionConfirmation, createPublicClientWithRpc, NI_CHAIN_ID_AVALANCHE, S0X_ADDR_USDC_AVALANCHE, X_MAX_IMPACT_PERCENT, getRelayStatus, getDebridgeStatus, fetchDebridgeOrder, fetchRelayQuote, createPhonyDepositCalldata, isSolanaAsset, isBitcoinAsset, parseSolanaCaip19, isSolanaNativeToken, isSplToken, N_RELAY_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_BITCOIN, SB58_ADDR_SOL_PROGRAM_SYSTEM, getChainById, SBTC_ADDR_BITCOIN_NATIVE, } from '@silentswap/sdk';
 import { createSolanaTransactionExecutor, convertRelaySolanaStepToTransaction } from './solana-transaction.js';
+import { createBitcoinTransactionExecutor, convertRelayBitcoinStepToTransaction } from './bitcoin-transaction.js';
 const S0X_ADDR_EVM_ZERO = '0x0000000000000000000000000000000000000000';
 const XG_UINT256_MAX = (1n << 256n) - 1n;
 /**
@@ -124,29 +125,40 @@ async function sendTransactionAndWait(walletClient, connector, chainId, transact
 }
 /**
  * Get relay.link origin asset parameters from CAIP-19
+ * Supports both Solana and Bitcoin assets
  */
-function getRelayOriginAsset(caip19) {
-    if (!isSolanaAsset(caip19)) {
-        throw new Error('Only Solana assets are supported by this helper');
+function getRelayOriginAssetFromCaip19(caip19) {
+    if (isSolanaAsset(caip19)) {
+        const parsed = parseSolanaCaip19(caip19);
+        if (!parsed) {
+            throw new Error(`Invalid Solana CAIP-19: ${caip19}`);
+        }
+        const originCurrency = isSolanaNativeToken(caip19)
+            ? SB58_ADDR_SOL_PROGRAM_SYSTEM
+            : isSplToken(caip19)
+                ? parsed.tokenAddress ||
+                    (() => {
+                        throw new Error(`Missing token address in Solana CAIP-19: ${caip19}`);
+                    })()
+                : (() => {
+                    throw new Error(`Unsupported Solana asset type: ${caip19}`);
+                })();
+        return {
+            originChainId: N_RELAY_CHAIN_ID_SOLANA,
+            originCurrency,
+        };
     }
-    const parsed = parseSolanaCaip19(caip19);
-    if (!parsed) {
-        throw new Error(`Invalid Solana CAIP-19: ${caip19}`);
+    if (isBitcoinAsset(caip19)) {
+        // For Bitcoin, use the relay chain ID and pass the asset reference as currency
+        // Bitcoin CAIP-19 format: bip122:chainId/slip44:0 (for native BTC)
+        // For Bitcoin, we typically only support native BTC
+        // relay.link requires SBTC_ADDR_BITCOIN_NATIVE for native Bitcoin token
+        return {
+            originChainId: N_RELAY_CHAIN_ID_BITCOIN,
+            originCurrency: SBTC_ADDR_BITCOIN_NATIVE, // Bitcoin native token (BTC) - relay.link requires this specific address
+        };
     }
-    const originCurrency = isSolanaNativeToken(caip19)
-        ? SB58_ADDR_SOL_PROGRAM_SYSTEM
-        : isSplToken(caip19)
-            ? parsed.tokenAddress ||
-                (() => {
-                    throw new Error(`Missing token address in Solana CAIP-19: ${caip19}`);
-                })()
-            : (() => {
-                throw new Error(`Unsupported Solana asset type: ${caip19}`);
-            })();
-    return {
-        originChainId: N_RELAY_CHAIN_ID_SOLANA,
-        originCurrency,
-    };
+    throw new Error(`Unsupported asset type: ${caip19}`);
 }
 // Depositor ABI for encoding deposit calldata
 const DEPOSITOR_ABI = [
@@ -195,11 +207,13 @@ const DEPOSITOR_ABI = [
  * @param solanaConnector - Solana wallet connector (required for Solana swaps)
  * @param solanaConnection - Solana RPC connection (required for Solana swaps)
  * @param solanaRpcUrl - Optional Solana RPC URL
+ * @param bitcoinConnector - Bitcoin wallet connector (required for Bitcoin swaps)
+ * @param bitcoinConnection - Bitcoin connection (optional, for consistency)
  * @param setCurrentStep - Callback to set current step message
  * @param onStatus - Optional status update callback
  * @returns Functions for executing bridge transactions
  */
-export function useBridgeExecution(walletClient, connector, solanaConnector, solanaConnection, solanaRpcUrl, setCurrentStep, depositorAddress, onStatus) {
+export function useBridgeExecution(walletClient, connector, solanaConnector, solanaConnection, solanaRpcUrl, setCurrentStep, depositorAddress, onStatus, bitcoinConnector, bitcoinConnection) {
     /**
      * Execute Solana bridge transaction
      *
@@ -224,7 +238,7 @@ export function useBridgeExecution(walletClient, connector, solanaConnector, sol
                 throw new Error('Solana connector and connection are required for Solana swaps');
             }
             // Get relay origin asset parameters
-            const { originChainId, originCurrency } = getRelayOriginAsset(sourceAsset);
+            const { originChainId, originCurrency } = getRelayOriginAssetFromCaip19(sourceAsset);
             // CRITICAL: In Svelte, solve_uusdc_amount is called ONCE before order creation,
             // and the result (usdcAmount) is used directly in bridge execution.
             // We should NEVER solve again here - the usdcAmount must be provided
@@ -381,6 +395,171 @@ export function useBridgeExecution(walletClient, connector, solanaConnector, sol
             throw error;
         }
     }, [solanaConnector, solanaConnection, solanaRpcUrl, setCurrentStep, onStatus, depositorAddress]);
+    /**
+     * Execute Bitcoin bridge transaction
+     *
+     * Handles bridge execution for Bitcoin source assets:
+     * 1. Solves for optimal USDC amount (if not provided)
+     * 2. Gets quotes from relay.link (Bitcoin only supports relay)
+     * 3. Executes Bitcoin transactions
+     * 4. Monitors bridge status
+     *
+     * @param sourceAsset - Source asset CAIP-19 (Bitcoin)
+     * @param sourceAmount - Source amount in token units
+     * @param usdcAmount - Optional USDC amount (will be solved if not provided)
+     * @param depositParams - Deposit parameters from order response
+     * @param bitcoinSenderAddress - Bitcoin sender address
+     * @param evmSignerAddress - EVM signer address for deposit operations
+     * @returns Promise resolving to bridge execution result
+     */
+    const executeBitcoinBridge = useCallback(async (sourceAsset, sourceAmount, usdcAmount, bitcoinSenderAddress, evmSignerAddress, depositParams) => {
+        try {
+            if (!bitcoinConnector) {
+                throw new Error('Bitcoin connector required for Bitcoin swaps');
+            }
+            // Get relay origin asset parameters
+            const { originChainId, originCurrency } = getRelayOriginAssetFromCaip19(sourceAsset);
+            // CRITICAL: In Svelte, solve_uusdc_amount is called ONCE before order creation,
+            // and the result (usdcAmount) is used directly in bridge execution.
+            // We should NEVER solve again here - the usdcAmount must be provided
+            // from the initial solve in handleGetQuote (matching Svelte Form.svelte line 2535 and 2576-2584).
+            if (!usdcAmount) {
+                throw new Error('USDC amount is required for Bitcoin bridge execution. ' +
+                    'It should be provided from the initial solveOptimalUsdcAmount call in handleGetQuote. ' +
+                    'This matches Svelte behavior where solve_uusdc_amount is called once before order creation.');
+            }
+            // Use the provided usdcAmount directly (matches Svelte behavior)
+            const bridgeUsdcAmount = usdcAmount;
+            setCurrentStep('Fetching bridge quote');
+            onStatus?.('Fetching bridge quote');
+            // Encode USDC on Avalanche approval calldata
+            const approveUsdcCalldata = encodeFunctionData({
+                abi: erc20Abi,
+                functionName: 'approve',
+                args: [depositorAddress, XG_UINT256_MAX],
+            });
+            // Encode depositProxy2 calldata from depositParams
+            let depositCalldataForExecution;
+            if (depositParams) {
+                const checksummedSigner = getAddress(evmSignerAddress);
+                const finalDepositParams = {
+                    ...depositParams,
+                    signer: checksummedSigner,
+                    approvalExpiration: typeof depositParams.approvalExpiration === 'bigint'
+                        ? depositParams.approvalExpiration
+                        : BigInt(String(depositParams.approvalExpiration)),
+                    duration: typeof depositParams.duration === 'bigint'
+                        ? depositParams.duration
+                        : BigInt(String(depositParams.duration)),
+                };
+                depositCalldataForExecution = encodeFunctionData({
+                    abi: DEPOSITOR_ABI,
+                    functionName: 'depositProxy2',
+                    args: [finalDepositParams],
+                });
+            }
+            else {
+                console.warn('DepositParams not provided, using phony calldata for bridge quote');
+                depositCalldataForExecution = createPhonyDepositCalldata(evmSignerAddress);
+            }
+            // Request bridge quote for Bitcoin → USDC Avalanche using EXACT_OUTPUT
+            const relayQuote = await fetchRelayQuote({
+                user: bitcoinSenderAddress, // Bitcoin address
+                originChainId, // Bitcoin relay chain ID
+                originCurrency, // Bitcoin currency (SBTC_ADDR_BITCOIN_NATIVE for native BTC)
+                destinationChainId: NI_CHAIN_ID_AVALANCHE,
+                destinationCurrency: S0X_ADDR_USDC_AVALANCHE,
+                amount: bridgeUsdcAmount, // USDC amount in micro units (EXACT_OUTPUT target)
+                recipient: depositorAddress, // EVM depositor address
+                tradeType: 'EXACT_OUTPUT', // CRITICAL: Must use EXACT_OUTPUT for execution
+                txsGasLimit: 600_000,
+                txs: [
+                    {
+                        to: S0X_ADDR_USDC_AVALANCHE,
+                        value: '0',
+                        data: approveUsdcCalldata, // USDC approval calldata
+                    },
+                    {
+                        to: depositorAddress,
+                        value: '0',
+                        data: depositCalldataForExecution, // Deposit calldata
+                    },
+                ],
+            });
+            // Check price impact
+            const impactPercent = Number(relayQuote.details.totalImpact.percent);
+            if (impactPercent > X_MAX_IMPACT_PERCENT) {
+                throw new Error(`Price impact across bridge too high: ${impactPercent.toFixed(2)}%`);
+            }
+            const rawResponse = relayQuote;
+            const selectedProvider = 'relay'; // Bitcoin only supports relay
+            // Create Bitcoin transaction executor
+            const bitcoinExecutor = createBitcoinTransactionExecutor(bitcoinConnector, bitcoinConnection);
+            setCurrentStep('Executing bridge transaction');
+            onStatus?.('Executing bridge transaction');
+            // Execute transactions
+            if (selectedProvider === 'relay') {
+                const relayQuote = rawResponse;
+                if (!relayQuote.steps) {
+                    throw new Error('No steps in relay quote response');
+                }
+                // Execute each step from relay.link
+                for (const step of relayQuote.steps) {
+                    if (step.kind !== 'transaction') {
+                        throw new Error(`Unsupported relay step kind: ${step.kind}`);
+                    }
+                    if (step.items.length > 1) {
+                        throw new Error('Multiple items in transaction step not implemented');
+                    }
+                    const item = step.items[0];
+                    const itemData = item.data;
+                    // Bitcoin transaction (PSBT)
+                    if ('psbt' in itemData || 'hex' in itemData || 'data' in itemData) {
+                        setCurrentStep(step.id === 'approve'
+                            ? 'Requesting approval...'
+                            : step.id === 'deposit'
+                                ? 'Requesting deposit...'
+                                : 'Requesting bridge...');
+                        onStatus?.(step.id === 'approve'
+                            ? 'Requesting approval...'
+                            : step.id === 'deposit'
+                                ? 'Requesting deposit...'
+                                : 'Requesting bridge...');
+                        // Convert relay step to BridgeTransaction
+                        const bitcoinTx = convertRelayBitcoinStepToTransaction(itemData, N_RELAY_CHAIN_ID_BITCOIN);
+                        // Execute Bitcoin transaction
+                        await bitcoinExecutor(bitcoinTx);
+                    }
+                }
+                // Find request ID for status monitoring
+                const requestId = relayQuote.steps.find((s) => s.requestId)?.requestId;
+                if (!requestId) {
+                    throw new Error('Missing relay.link request ID');
+                }
+                // Monitor bridge status
+                const depositTxHash = await monitorRelayBridgeStatus(requestId, setCurrentStep, onStatus);
+                return {
+                    depositTxHash: depositTxHash,
+                    provider: 'relay',
+                };
+            }
+            else {
+                throw new Error(`Unsupported bridge provider: ${selectedProvider}`);
+            }
+        }
+        catch (error) {
+            console.error('Bitcoin bridge execution failed:', {
+                sourceAsset,
+                sourceAmount,
+                usdcAmount,
+                bitcoinSenderAddress,
+                evmSignerAddress,
+                error: error instanceof Error ? error.message : String(error),
+                stack: error instanceof Error ? error.stack : undefined,
+            });
+            throw error;
+        }
+    }, [bitcoinConnector, bitcoinConnection, setCurrentStep, onStatus, depositorAddress]);
     /**
      * Execute EVM bridge transaction
      *
@@ -508,6 +687,7 @@ export function useBridgeExecution(walletClient, connector, solanaConnector, sol
     }, [walletClient, connector, setCurrentStep, onStatus, depositorAddress]);
     return {
         executeSolanaBridge,
+        executeBitcoinBridge,
         executeEvmBridge,
     };
 }