@silentswap/react 0.0.52 → 0.0.55

package/dist/hooks/silent/useQuoteCalculation.js

@@ -1,5 +1,5 @@
 import { useCallback, useState } from 'react';
-import { isSolanaAsset, parseEvmCaip19, S_CAIP19_USDC_AVALANCHE, getAssetByCaip19, solveOptimalUsdcAmount, N_RELAY_CHAIN_ID_SOLANA, SB58_ADDR_SOL_PROGRAM_SYSTEM, isSolanaNativeToken, parseSolanaCaip19, EVM_PHONY_ADDRESS, isValidSolanaAddress, getAddressFromCaip10, S0X_ADDR_USDC_AVALANCHE, isEvmNativeToken, caip19FungibleEvmToken, FacilitatorKeyType, createHdFacilitatorGroupFromEntropy, PublicKeyArgGroups, SB58_CHAIN_ID_SOLANA_MAINNET, caip19SplToken, DeliveryMethod, X_MAX_IMPACT_PERCENT, } from '@silentswap/sdk';
+import { isSolanaAsset, isBitcoinAsset, parseEvmCaip19, S_CAIP19_USDC_AVALANCHE, getAssetByCaip19, solveOptimalUsdcAmount, fetchRelayQuote, N_RELAY_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_BITCOIN, SB58_ADDR_SOL_PROGRAM_SYSTEM, isSolanaNativeToken, parseSolanaCaip19, EVM_PHONY_ADDRESS, isValidSolanaAddress, isValidBitcoinAddress, isValidEvmAddress, getAddressFromCaip10, S0X_ADDR_USDC_AVALANCHE, isEvmNativeToken, caip19FungibleEvmToken, FacilitatorKeyType, createHdFacilitatorGroupFromEntropy, PublicKeyArgGroups, SB58_CHAIN_ID_SOLANA_MAINNET, caip19SplToken, DeliveryMethod, X_MAX_IMPACT_PERCENT, NI_CHAIN_ID_AVALANCHE, SBTC_ADDR_BITCOIN_NATIVE, } from '@silentswap/sdk';
 import { getAddress } from 'viem';
 import { BigNumber } from 'bignumber.js';
 /**
@@ -28,6 +28,7 @@ export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddr
             }
             const isSourceUsdcAvalanche = debouncedSourceAsset === S_CAIP19_USDC_AVALANCHE;
             const isSourceSolana = isSolanaAsset(debouncedSourceAsset);
+            const isSourceBitcoin = isBitcoinAsset(debouncedSourceAsset);
             let usdcAmountOut;
             let bridgeProviderResult = 'none';
             let allowanceTargetResult = undefined;
@@ -39,8 +40,7 @@ export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddr
                 usdcAmountOut = sourceAmountBN.shiftedBy(assetInfo.decimals).toFixed(0);
             }
             else if (isSourceSolana) {
-                // Solana assets - both relay.link and deBridge support Solana
-                // solveOptimalUsdcAmount will compare both providers and choose the best rate
+                // Solana assets - use relay.link only (not deBridge)
                 const assetInfo = getAssetByCaip19(debouncedSourceAsset);
                 if (!assetInfo)
                     throw new Error(`Solana asset not found`);
@@ -69,21 +69,68 @@ export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddr
                 if (!solanaAddress) {
                     throw new Error('Solana address required for Solana swaps');
                 }
-                // Pass Solana address for user parameter, and EVM address for recipient and deposit calldata
-                // This matches Svelte behavior where s_addr_sender (Solana) is used for user, and s0x_signer (EVM) for recipient
-                const solveResult = await solveOptimalUsdcAmount(N_RELAY_CHAIN_ID_SOLANA, originCurrency, // Base58 Solana address (system program or SPL token)
-                sourceAmountInUnits, solanaAddress, // Pass Solana address for user parameter in relay quote
-                undefined, // depositCalldata will be created with EVM address
-                X_MAX_IMPACT_PERCENT, depositorAddress, // Required depositor address
-                getAddress(evmAddress));
+                // Use relay.link only for Solana (not deBridge)
+                const relayQuote = await fetchRelayQuote({
+                    user: solanaAddress, // Solana address for user parameter
+                    originChainId: N_RELAY_CHAIN_ID_SOLANA,
+                    destinationChainId: NI_CHAIN_ID_AVALANCHE,
+                    originCurrency: originCurrency, // Base58 Solana address (system program or SPL token)
+                    destinationCurrency: S0X_ADDR_USDC_AVALANCHE,
+                    amount: sourceAmountInUnits,
+                    tradeType: 'EXACT_INPUT',
+                    referrer: 'silentswap',
+                    recipient: getAddress(evmAddress), // EVM address for recipient
+                }, abortController.signal);
                 if (abortController.signal.aborted) {
                     setLoadingAmounts(false);
                     return null;
                 }
-                // solveOptimalUsdcAmount compares both relay and deBridge and returns the best provider
-                usdcAmountOut = solveResult.usdcAmountOut.toString();
-                bridgeProviderResult = solveResult.provider; // Use the provider chosen by solveOptimalUsdcAmount
-                allowanceTargetResult = solveResult.allowanceTarget; // deBridge may return allowance target
+                // Extract USDC amount from relay quote
+                usdcAmountOut = relayQuote.details.currencyOut.amount;
+                bridgeProviderResult = 'relay'; // Solana uses relay only
+                allowanceTargetResult = undefined; // Relay doesn't need allowance target
+            }
+            else if (isSourceBitcoin) {
+                // Bitcoin assets - only relay.link supports Bitcoin
+                const assetInfo = getAssetByCaip19(debouncedSourceAsset);
+                if (!assetInfo)
+                    throw new Error(`Bitcoin asset not found`);
+                const sourceAmountBN = BigNumber(debouncedSourceAmount);
+                const sourceAmountInUnits = sourceAmountBN.shiftedBy(assetInfo.decimals).toFixed(0);
+                // For Bitcoin swaps, we need:
+                // - Bitcoin address for the 'user' parameter in relay quote
+                // - EVM address for the 'recipient' parameter
+                // - EVM address for deposit calldata
+                if (!evmAddress) {
+                    throw new Error('EVM address required for Bitcoin swaps (needed for deposit calldata and recipient)');
+                }
+                // Bitcoin address should be a string that doesn't start with 0x
+                // For now, we'll use the address parameter if it's not an EVM address
+                const bitcoinAddress = typeof address === 'string' && !address.startsWith('0x') ? address : null;
+                if (!bitcoinAddress) {
+                    throw new Error('Bitcoin address required for Bitcoin swaps');
+                }
+                // Bitcoin only supports relay, not deBridge
+                // Use relay.link directly (not solveOptimalUsdcAmount which compares both providers)
+                const relayQuote = await fetchRelayQuote({
+                    user: bitcoinAddress, // Bitcoin address for user parameter
+                    originChainId: N_RELAY_CHAIN_ID_BITCOIN,
+                    destinationChainId: NI_CHAIN_ID_AVALANCHE,
+                    originCurrency: SBTC_ADDR_BITCOIN_NATIVE, // Bitcoin native token (BTC) - relay.link requires this specific address
+                    destinationCurrency: S0X_ADDR_USDC_AVALANCHE,
+                    amount: sourceAmountInUnits,
+                    tradeType: 'EXACT_INPUT',
+                    referrer: 'silentswap',
+                    recipient: getAddress(evmAddress), // EVM address for recipient
+                }, abortController.signal);
+                if (abortController.signal.aborted) {
+                    setLoadingAmounts(false);
+                    return null;
+                }
+                // Extract USDC amount from relay quote
+                usdcAmountOut = relayQuote.details.currencyOut.amount;
+                bridgeProviderResult = 'relay'; // Bitcoin only supports relay
+                allowanceTargetResult = undefined; // Bitcoin doesn't need allowance
             }
             else {
                 // EVM assets
@@ -136,8 +183,9 @@ export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddr
             });
             const outputs = destinations.map((dest, idx) => {
                 const isDestSolana = isSolanaAsset(dest.asset);
+                const isDestBitcoin = isBitcoinAsset(dest.asset);
                 let asset;
-                let recipientAddress; // Changed from `0x${string}` to string to support Solana addresses
+                let recipientAddress; // Changed from `0x${string}` to string to support Solana and Bitcoin addresses
                 if (isDestSolana) {
                     // Solana destination
                     const destParsed = parseSolanaCaip19(dest.asset);
@@ -172,33 +220,78 @@ export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddr
                         throw new Error(`Solana destination ${idx} requires a recipient address in the contact field`);
                     }
                 }
+                else if (isDestBitcoin) {
+                    // Bitcoin destination
+                    // Bitcoin assets use the asset CAIP-19 as-is (native Bitcoin only supported currently)
+                    asset = dest.asset;
+                    // Extract Bitcoin address from contact field
+                    // CRITICAL: Must be a valid Bitcoin address (bc1, 1, or 3 prefix)
+                    if (dest.contact) {
+                        // Check if contact is in CAIP10 format
+                        if (dest.contact.startsWith('caip10:bip122:')) {
+                            recipientAddress = getAddressFromCaip10(dest.contact);
+                            // Validate it's actually a Bitcoin address
+                            if (!isValidBitcoinAddress(recipientAddress)) {
+                                throw new Error(`Invalid Bitcoin address extracted from CAIP10: ${dest.contact} -> ${recipientAddress}`);
+                            }
+                        }
+                        else {
+                            // Check if contact is a valid Bitcoin address format
+                            if (isValidBitcoinAddress(dest.contact)) {
+                                recipientAddress = dest.contact;
+                            }
+                            else {
+                                throw new Error(`Invalid Bitcoin recipient address for destination ${idx}: ${dest.contact}. Expected Bitcoin address (bc1, 1, or 3 prefix) or caip10:bip122:*: format.`);
+                            }
+                        }
+                    }
+                    else {
+                        throw new Error(`Bitcoin destination ${idx} requires a recipient address in the contact field`);
+                    }
+                }
                 else {
                     // EVM destination
                     const destParsed = parseEvmCaip19(dest.asset);
-                    if (!destParsed)
-                        throw new Error(`Invalid destination asset format`);
+                    if (!destParsed) {
+                        throw new Error(`Failed to parse EVM destination CAIP-19: ${dest.asset}. Expected EVM asset format (eip155:chainId/erc20:address or eip155:chainId/slip44:cointype).`);
+                    }
                     const isNative = isEvmNativeToken(dest.asset);
                     const destChainId = destParsed.chainId;
                     asset = isNative
                         ? dest.asset
                         : caip19FungibleEvmToken(destChainId, destParsed.tokenAddress);
+                    // Extract EVM address from contact field
+                    // CRITICAL: Must be a valid EVM address (0x prefix)
                     if (dest.contact) {
-                        try {
-                            // Extract EVM address from contact (handles both CAIP10 and plain addresses)
-                            if (dest.contact.startsWith('caip10:eip155:')) {
-                                recipientAddress = getAddressFromCaip10(dest.contact);
+                        // Check if contact is in CAIP10 format
+                        if (dest.contact.startsWith('caip10:eip155:')) {
+                            recipientAddress = getAddressFromCaip10(dest.contact);
+                            // Validate it's actually an EVM address
+                            if (!isValidEvmAddress(recipientAddress)) {
+                                throw new Error(`Invalid EVM address extracted from CAIP10: ${dest.contact} -> ${recipientAddress}`);
                             }
-                            else {
-                                recipientAddress = getAddress(dest.contact);
+                            // Normalize to checksummed format
+                            try {
+                                recipientAddress = getAddress(recipientAddress);
+                            }
+                            catch (error) {
+                                throw new Error(`Invalid EVM address checksum for destination ${idx}: ${recipientAddress}. ${error instanceof Error ? error.message : String(error)}`);
                             }
                         }
-                        catch (error) {
-                            console.error('Failed to parse EVM recipient address:', {
-                                destination: idx,
-                                contact: dest.contact,
-                                error: error instanceof Error ? error.message : String(error),
-                            });
-                            throw new Error(`Invalid EVM recipient address for destination ${idx}: ${dest.contact}. ${error instanceof Error ? error.message : String(error)}`);
+                        else {
+                            // Check if contact is a valid EVM address format
+                            if (isValidEvmAddress(dest.contact)) {
+                                // Normalize to checksummed format
+                                try {
+                                    recipientAddress = getAddress(dest.contact);
+                                }
+                                catch (error) {
+                                    throw new Error(`Invalid EVM address checksum for destination ${idx}: ${dest.contact}. ${error instanceof Error ? error.message : String(error)}`);
+                                }
+                            }
+                            else {
+                                throw new Error(`Invalid EVM recipient address for destination ${idx}: ${dest.contact}. Expected 0x-prefixed EVM address or caip10:eip155:*: format.`);
+                            }
                         }
                     }
                     else {
@@ -209,12 +302,21 @@ export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddr
                 // The value field in the quote request should be USDC micro units, not the destination asset amount
                 // This matches how Svelte calculates a_amounts_out and uses it as value in the quote request
                 const outputValue = splitUsdcAmounts[idx];
-                // Final validation: Ensure Solana destinations have Solana addresses, EVM destinations have EVM addresses
+                // Final validation: Ensure addresses match their chain type
                 if (isDestSolana && !isValidSolanaAddress(recipientAddress)) {
                     throw new Error(`Invalid recipient address type for Solana destination ${idx}: ${recipientAddress}. Expected base58 Solana address.`);
                 }
-                else if (!isDestSolana && !recipientAddress.startsWith('0x')) {
-                    throw new Error(`Invalid recipient address type for EVM destination ${idx}: ${recipientAddress}. Expected 0x-prefixed EVM address.`);
+                else if (isDestBitcoin) {
+                    // Validate Bitcoin address format
+                    if (!isValidBitcoinAddress(recipientAddress)) {
+                        throw new Error(`Invalid recipient address type for Bitcoin destination ${idx}: ${recipientAddress}. Expected Bitcoin address (bc1, 1, or 3 prefix).`);
+                    }
+                }
+                else if (!isDestSolana && !isDestBitcoin) {
+                    // Validate EVM address format
+                    if (!isValidEvmAddress(recipientAddress)) {
+                        throw new Error(`Invalid recipient address type for EVM destination ${idx}: ${recipientAddress}. Expected 0x-prefixed EVM address.`);
+                    }
                 }
                 return {
                     method: DeliveryMethod.SNIP,

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

@@ -2,6 +2,7 @@ import type { SilentSwapClient, QuoteResponse, AssetInfo } from '@silentswap/sdk
 import type { WalletClient } from 'viem';
 import type { Connector } from 'wagmi';
 import type { SolanaWalletConnector, SolanaConnection } from './solana-transaction.js';
+import type { BitcoinWalletConnector, BitcoinConnection } from './bitcoin-transaction.js';
 import { type SwapTransaction } from '../useTransaction.js';
 import type { SilentSwapWallet } from './useWallet.js';
 export type { SwapTransaction };
@@ -40,6 +41,10 @@ export interface useSilentQuoteOptions {
     wallet: SilentSwapWallet | null;
     /** Whether wallet is currently being generated (to prevent swap execution before wallet is ready) */
     walletLoading?: boolean;
+    /** Wallet generation error (if previous generation failed) */
+    walletError?: Error | null;
+    /** Function to generate wallet (for retry on swap execution) */
+    generateWallet?: () => Promise<void>;
     /** Facilitator group for the swap, or a function that resolves it */
     /** Status update callback */
     onStatus?: (status: string) => void;
@@ -49,6 +54,10 @@ export interface useSilentQuoteOptions {
     solanaConnection?: SolanaConnection;
     /** Solana RPC URL (optional, will create connection if not provided) */
     solanaRpcUrl?: string;
+    /** Bitcoin wallet connector (required for Bitcoin swaps) */
+    bitcoinConnector?: BitcoinWalletConnector;
+    /** Bitcoin connection (optional, for consistency) */
+    bitcoinConnection?: BitcoinConnection;
     /** Get price function */
     getPrice: (asset: AssetInfo) => Promise<number>;
     setDestinations: (updater: Destination[] | ((prev: Destination[]) => Destination[])) => void;
@@ -87,4 +96,4 @@ export interface ExecuteSwapParams {
     /** Optional integrator ID for tracking */
     integratorId?: string;
 }
-export declare function useSilentQuote({ client, address, evmAddress, solAddress, walletClient, connector, wallet, walletLoading, onStatus, solanaConnector, solanaConnection, solanaRpcUrl, getPrice, setDestinations, }: useSilentQuoteOptions): useSilentQuoteReturn;
+export declare function useSilentQuote({ client, address, evmAddress, solAddress, walletClient, connector, wallet, walletLoading, walletError, generateWallet, onStatus, solanaConnector, solanaConnection, solanaRpcUrl, bitcoinConnector, bitcoinConnection, getPrice, setDestinations, }: useSilentQuoteOptions): useSilentQuoteReturn;

package/dist/hooks/silent/useSilentQuote.js

@@ -1,5 +1,5 @@
-import { useCallback, useMemo, useState } from 'react';
-import { hexToBase58, isSolanaAsset, parseEvmCaip19, S_CAIP19_USDC_AVALANCHE, NI_CHAIN_ID_AVALANCHE, getAssetByCaip19, } from '@silentswap/sdk';
+import { useCallback, useMemo, useState, useRef, useEffect } from 'react';
+import { hexToBase58, isSolanaAsset, isBitcoinAsset, parseEvmCaip19, S_CAIP19_USDC_AVALANCHE, NI_CHAIN_ID_AVALANCHE, getAssetByCaip19, } from '@silentswap/sdk';
 import { getAddress } from 'viem';
 import { BigNumber } from 'bignumber.js';
 import { useQuoteFetching } from './useQuoteFetching.js';
@@ -7,7 +7,7 @@ import { useOrderSigning } from './useOrderSigning.js';
 import { useBridgeExecution } from './useBridgeExecution.js';
 import { useTransaction } from '../useTransaction.js';
 import { useQuoteCalculation } from './useQuoteCalculation.js';
-export function useSilentQuote({ client, address, evmAddress, solAddress, walletClient, connector, wallet, walletLoading = false, onStatus, solanaConnector, solanaConnection, solanaRpcUrl, getPrice, setDestinations, }) {
+export function useSilentQuote({ client, address, evmAddress, solAddress, walletClient, connector, wallet, walletLoading = false, walletError = null, generateWallet, onStatus, solanaConnector, solanaConnection, solanaRpcUrl, bitcoinConnector, bitcoinConnection, getPrice, setDestinations, }) {
     const [isLoading, setIsLoading] = useState(false);
     const [currentStep, setCurrentStep] = useState('');
     const [quote, setQuote] = useState(null);
@@ -15,6 +15,18 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
     const [orderId, setOrderId] = useState(null);
     const [viewingAuth, setViewingAuth] = useState(null);
     const [isSwapping, setIsSwapping] = useState(false);
+    // Use refs to track current wallet state (to avoid stale closure values)
+    const walletRef = useRef(wallet);
+    const walletLoadingRef = useRef(walletLoading);
+    const walletErrorRef = useRef(walletError);
+    const generateWalletRef = useRef(generateWallet);
+    // Update refs when wallet state changes
+    useEffect(() => {
+        walletRef.current = wallet;
+        walletLoadingRef.current = walletLoading;
+        walletErrorRef.current = walletError;
+        generateWalletRef.current = generateWallet;
+    }, [wallet, walletLoading, walletError, generateWallet]);
     // Normalize address - only normalize EVM addresses
     // Note: For Solana swaps, we still need an EVM address for facilitator operations
     // The address parameter should be EVM for facilitator operations, but can be Solana for quote requests
@@ -42,7 +54,7 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
     // Initialize specialized hooks
     const { getQuote: getQuoteInternal } = useQuoteFetching(client, rawAddress, setIsLoading, setCurrentStep, setError, onStatus);
     const { signAuthorizations, createOrder } = useOrderSigning(walletClient, connector, client, setCurrentStep, onStatus);
-    const { executeSolanaBridge, executeEvmBridge } = useBridgeExecution(walletClient, connector, solanaConnector, solanaConnection, solanaRpcUrl, setCurrentStep, depositorAddress, onStatus);
+    const { executeSolanaBridge, executeBitcoinBridge, executeEvmBridge } = useBridgeExecution(walletClient, connector, solanaConnector, solanaConnection, solanaRpcUrl, setCurrentStep, depositorAddress, onStatus, bitcoinConnector, bitcoinConnection);
     const { executeSwapTransaction, approveTokenSpending } = useTransaction({
         address: normalizedAddress || '0x0000000000000000000000000000000000000000',
         walletClient,
@@ -93,9 +105,49 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
         if (!walletClient) {
             throw new Error('Wallet client required for swap execution');
         }
-        // Check if wallet is being generated - wait a bit and check again
-        if (walletLoading) {
-            throw new Error('Wallet is being generated. Please wait for wallet generation to complete before executing swap.');
+        // Check if wallet generation previously failed - retry if so
+        if (!walletRef.current && walletErrorRef.current && generateWalletRef.current && !walletLoadingRef.current) {
+            setCurrentStep('Retrying wallet generation...');
+            onStatus?.('Retrying wallet generation...');
+            try {
+                await generateWalletRef.current();
+                // Wait for wallet to be ready after retry (with timeout)
+                const maxWaitTime = 30000; // 30 seconds
+                const checkInterval = 100; // Check every 100ms
+                const startTime = Date.now();
+                while (!walletRef.current && Date.now() - startTime < maxWaitTime) {
+                    await new Promise((resolve) => setTimeout(resolve, checkInterval));
+                }
+                // If wallet is still not ready after retry, throw error
+                if (!walletRef.current) {
+                    throw new Error('Wallet generation retry completed but wallet is still not available. Please try again.');
+                }
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error('Failed to generate wallet');
+                throw new Error(`Wallet generation failed: ${error.message}. Please try again or ensure wallet is connected and authenticated.`);
+            }
+        }
+        // Wait for wallet to be ready if it's being generated
+        // Use refs to check current state (avoid stale closure values)
+        if (!walletRef.current && walletLoadingRef.current) {
+            setCurrentStep('Waiting for wallet generation...');
+            onStatus?.('Waiting for wallet generation...');
+            // Wait for wallet generation to complete (with timeout)
+            const maxWaitTime = 30000; // 30 seconds
+            const checkInterval = 100; // Check every 100ms
+            const startTime = Date.now();
+            while (!walletRef.current && walletLoadingRef.current && Date.now() - startTime < maxWaitTime) {
+                await new Promise((resolve) => setTimeout(resolve, checkInterval));
+            }
+            // If wallet is still not ready after waiting, throw error
+            if (!walletRef.current) {
+                throw new Error('Wallet is being generated. Please wait for wallet generation to complete before executing swap.');
+            }
+        }
+        // Final check: wallet must exist for swap execution
+        if (!walletRef.current) {
+            throw new Error('Wallet is required for swap execution. Please ensure wallet is connected and authenticated.');
         }
         setIsLoading(true);
         setError(null);
@@ -140,8 +192,9 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
             }
             // Check swap type
             const isSourceSolana = isSolanaAsset(sourceAsset);
+            const isSourceBitcoin = isBitcoinAsset(sourceAsset);
             const isDepositingDirectly = sourceAsset === S_CAIP19_USDC_AVALANCHE;
-            const isSourceEvm = !isSourceSolana && !isDepositingDirectly && sourceAsset.startsWith('eip155:');
+            const isSourceEvm = !isSourceSolana && !isSourceBitcoin && !isDepositingDirectly && sourceAsset.startsWith('eip155:');
             // Generate viewing authorization
             const viewer = await resolvedGroup.viewer();
             const evmSigner = await viewer.evmSigner();
@@ -163,6 +216,15 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
                 setViewingAuth(result.viewingAuth);
                 return result;
             }
+            // Handle Bitcoin swaps
+            if (isSourceBitcoin) {
+                const result = await executeBitcoinSwap(quoteResponse, sourceAsset, sourceAmountInUnits, effectiveUsdcAmount, senderContactId, bitcoinConnector, evmSignerAddress, // Use EVM signer address, not normalizedAddress
+                viewingAuth, createOrder, executeBitcoinBridge, resolvedGroup, // Pass resolved group for order creation
+                integratorId);
+                setOrderId(result.orderId);
+                setViewingAuth(result.viewingAuth);
+                return result;
+            }
             // Sign authorizations (for EVM swaps)
             const signedAuths = await signAuthorizations(quoteResponse.authorizations, isDepositingDirectly);
             // Create order with resolved facilitator group
@@ -233,7 +295,10 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
         evmAddress,
         walletClient,
         walletLoading,
+        walletError,
+        generateWallet,
         solanaConnector,
+        bitcoinConnector,
         signAuthorizations,
         createOrder,
         approveTokenSpending,
@@ -331,6 +396,67 @@ viewingAuth, createOrder, executeSolanaBridge, facilitatorGroup, integratorId) {
         },
     };
 }
+/**
+ * Execute Bitcoin swap flow
+ *
+ * Handles the complete flow for Bitcoin-based swaps:
+ * 1. Validates Bitcoin connection
+ * 2. Creates order (with empty authorizations for Bitcoin)
+ * 3. Executes bridge transaction
+ * 4. Returns swap result
+ */
+async function executeBitcoinSwap(quoteResponse, sourceAsset, sourceAmount, usdcAmount, senderContactId, bitcoinConnector, evmSignerAddress, // EVM signer address (matches Svelte's s0x_signer)
+viewingAuth, createOrder, executeBitcoinBridge, facilitatorGroup, integratorId) {
+    if (!bitcoinConnector) {
+        throw new Error('Bitcoin connector required for Bitcoin swaps');
+    }
+    // Get Bitcoin sender address
+    const accounts = await bitcoinConnector.getAccounts();
+    const bitcoinSenderAddress = bitcoinConnector.currentAccount || accounts[0] || '';
+    if (!bitcoinSenderAddress) {
+        throw new Error('Failed to get Bitcoin sender address');
+    }
+    // Create order with empty authorizations (Bitcoin doesn't use EIP-3009)
+    // Pass resolved facilitator group (matches Svelte behavior)
+    const orderResponse = await createOrder(quoteResponse, quoteResponse.authorizations.map((auth) => ({
+        ...auth,
+        signature: '0x', // No EIP-3009 deposit for Bitcoin
+    })), {
+        sourceAsset: {
+            caip19: sourceAsset,
+            amount: `${BigInt(sourceAmount)}`,
+        },
+        sourceSender: {
+            contactId: senderContactId,
+        },
+        ...(integratorId && { integratorId }),
+    }, facilitatorGroup);
+    // Get deposit parameters from order
+    const depositParams = orderResponse.transaction.metadata?.params;
+    if (!depositParams) {
+        throw new Error('Missing deposit parameters in order response');
+    }
+    // Execute bridge transaction
+    // Use EVM signer address for deposit calldata (matches Svelte's s0x_signer)
+    // Pass depositParams so executeBitcoinBridge can encode the actual deposit calldata
+    // Use usdcAmount from solveOptimalUsdcAmount (matches Svelte: zg_amount_src_usdc is passed directly)
+    const bridgeResult = await executeBitcoinBridge(sourceAsset, sourceAmount, usdcAmount, // Use amount from solveOptimalUsdcAmount (matches Svelte line 1028)
+    bitcoinSenderAddress, evmSignerAddress, // Use EVM signer address, not normalizedAddress
+    depositParams);
+    const resultOrderId = orderResponse.response.orderId;
+    // Note: setOrderId is not available in this function scope,
+    // but the orderId will be set by the calling executeSwap function
+    return {
+        orderId: resultOrderId,
+        viewingAuth,
+        depositTransaction: {
+            hash: bridgeResult.depositTxHash,
+            chainId: NI_CHAIN_ID_AVALANCHE,
+            status: 'confirmed',
+            confirmations: 1,
+        },
+    };
+}
 /**
  * Execute EVM swap flow
  *

package/dist/hooks/useOrderEstimates.js

@@ -1,6 +1,6 @@
 import { useCallback, useRef, useState, useMemo } from 'react';
 import BigNumber from 'bignumber.js';
-import { parseEvmCaip19, parseSolanaCaip19, isEvmNativeToken, isSolanaNativeToken, isSolanaAsset, EVM_PHONY_ADDRESS, SB58_ADDR_SOL_PROGRAM_SYSTEM, CALCULATION_DIRECTION_INPUT_TO_OUTPUT, CALCULATION_DIRECTION_OUTPUT_TO_INPUT, } from '@silentswap/sdk';
+import { parseEvmCaip19, parseSolanaCaip19, isEvmNativeToken, isSolanaNativeToken, isSolanaAsset, isBitcoinAsset, EVM_PHONY_ADDRESS, SB58_ADDR_SOL_PROGRAM_SYSTEM, CALCULATION_DIRECTION_INPUT_TO_OUTPUT, CALCULATION_DIRECTION_OUTPUT_TO_INPUT, } from '@silentswap/sdk';
 import { useQuote } from './useQuote.js';
 /**
  * Hook for fetching both ingress and egress estimates in parallel
@@ -27,6 +27,11 @@ export function useOrderEstimates({ evmAddress, solAddress, sourceAsset, maxImpa
             if (sourceAsset.caip19.includes('solana')) {
                 return solAddress || SB58_ADDR_SOL_PROGRAM_SYSTEM;
             }
+            else if (sourceAsset.caip19.includes('bip122')) {
+                // Bitcoin source - Bitcoin address not available in this hook, return undefined
+                // Note: Bitcoin addresses would need to be passed as a parameter to this hook
+                return undefined;
+            }
             else {
                 return evmAddress || EVM_PHONY_ADDRESS;
             }
@@ -114,7 +119,8 @@ export function useOrderEstimates({ evmAddress, solAddress, sourceAsset, maxImpa
                 // Parse source asset to get chain ID and token address from CAIP-19
                 console.log('[OrderEstimates] Step 3: Parsing source asset CAIP-19');
                 const isSourceSolana = isSolanaAsset(sourceAsset.caip19);
-                const sourceEvmParsed = !isSourceSolana ? parseEvmCaip19(sourceAsset.caip19) : null;
+                const isSourceBitcoin = isBitcoinAsset(sourceAsset.caip19);
+                const sourceEvmParsed = !isSourceSolana && !isSourceBitcoin ? parseEvmCaip19(sourceAsset.caip19) : null;
                 const sourceSolanaParsed = isSourceSolana ? parseSolanaCaip19(sourceAsset.caip19) : null;
                 const sourceChainId = sourceEvmParsed?.chainId ?? sourceSolanaParsed?.chainId ?? 0;
                 const sourceTokenAddress = isEvmNativeToken(sourceAsset.caip19)
@@ -122,7 +128,7 @@ export function useOrderEstimates({ evmAddress, solAddress, sourceAsset, maxImpa
                     : isSolanaNativeToken(sourceAsset.caip19)
                         ? '11111111111111111111111111111111'
                         : (sourceEvmParsed?.tokenAddress ?? sourceSolanaParsed?.tokenAddress ?? '');
-                console.log('[OrderEstimates] Step 3: Source asset parsed', { sourceChainId, sourceTokenAddress, isSourceSolana });
+                console.log('[OrderEstimates] Step 3: Source asset parsed', { sourceChainId, sourceTokenAddress, isSourceSolana, isSourceBitcoin });
                 // For reverse calculation, calculate total output USD value first
                 let totalOutputUsd = 0;
                 let calculatedInputAmount = undefined;
@@ -173,7 +179,8 @@ export function useOrderEstimates({ evmAddress, solAddress, sourceAsset, maxImpa
                     Promise.all(destinationAssets.map((destAsset, idx) => {
                         // Parse destination asset to get chain ID and token address from CAIP-19
                         const isDestSolana = isSolanaAsset(destAsset.caip19);
-                        const destEvmParsed = !isDestSolana ? parseEvmCaip19(destAsset.caip19) : null;
+                        const isDestBitcoin = isBitcoinAsset(destAsset.caip19);
+                        const destEvmParsed = !isDestSolana && !isDestBitcoin ? parseEvmCaip19(destAsset.caip19) : null;
                         const destSolanaParsed = isDestSolana ? parseSolanaCaip19(destAsset.caip19) : null;
                         const destChainId = destEvmParsed?.chainId ?? destSolanaParsed?.chainId ?? 0;
                         const destTokenAddress = isEvmNativeToken(destAsset.caip19)
@@ -182,8 +189,9 @@ export function useOrderEstimates({ evmAddress, solAddress, sourceAsset, maxImpa
                                 ? '11111111111111111111111111111111'
                                 : (destEvmParsed?.tokenAddress ?? destSolanaParsed?.tokenAddress ?? '');
                         // Determine recipient address based on destination chain
-                        // For Solana destinations, use Solana address; for EVM, use EVM address
-                        const recipientAddress = isDestSolana ? solAddress : evmAddress;
+                        // For Solana destinations, use Solana address; for Bitcoin, use empty string (Bitcoin address not available in this hook); for EVM, use EVM address
+                        // Note: Bitcoin addresses would need to be passed as a parameter to this hook if Bitcoin destinations are used
+                        const recipientAddress = isDestSolana ? solAddress : isDestBitcoin ? '' : evmAddress;
                         // For reverse calculation, use output amount directly with EXACT_OUTPUT
                         if (calculationDirection === CALCULATION_DIRECTION_OUTPUT_TO_INPUT && outputAmounts && outputAmounts[idx]) {
                             const outputAmount = parseFloat(outputAmounts[idx]);

package/dist/hooks/useQuote.js

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
 import BigNumber from 'bignumber.js';
-import { NI_CHAIN_ID_AVALANCHE, S0X_ADDR_USDC_AVALANCHE, S_CAIP19_USDC_AVALANCHE, X_MAX_IMPACT_PERCENT, getBridgeQuote as sdkGetBridgeQuote, interpolateSamples as sdkInterpolateSamples, fetchRelayQuote, fetchDebridgeOrder, normalizeAddress, getAssetByCaip19, N_DEBRIDGE_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_SOLANA, SB58_ADDR_SOL_PROGRAM_SYSTEM, S0X_ADDR_EVM_RELAY_LINK_DEAD, SB58_ADDR_SOL_RELAY_LINK_RECIPIENT, isSolanaAsset, EVM_PHONY_ADDRESS, } from '@silentswap/sdk';
+import { NI_CHAIN_ID_AVALANCHE, S0X_ADDR_USDC_AVALANCHE, S_CAIP19_USDC_AVALANCHE, X_MAX_IMPACT_PERCENT, getBridgeQuote as sdkGetBridgeQuote, interpolateSamples as sdkInterpolateSamples, fetchRelayQuote, fetchDebridgeOrder, normalizeAddress, getAssetByCaip19, N_DEBRIDGE_CHAIN_ID_SOLANA, N_RELAY_CHAIN_ID_SOLANA, SB58_ADDR_SOL_PROGRAM_SYSTEM, S0X_ADDR_EVM_RELAY_LINK_DEAD, SB58_ADDR_SOL_RELAY_LINK_RECIPIENT, isSolanaAsset, isBitcoinAsset, EVM_PHONY_ADDRESS, } from '@silentswap/sdk';
 // Constants for estimateLive
 const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
 /**
@@ -316,6 +316,10 @@ export function useQuote({ address, maxImpactPercent = X_MAX_IMPACT_PERCENT } =
                         if (direction === 'egress') {
                             return null; // Skip DeBridge for egress, will use Relay.link only
                         }
+                        // Skip DeBridge for Solana and Bitcoin - use relay only
+                        if (isSolanaChain || isBitcoinAsset(assetCaip19)) {
+                            return null; // Skip DeBridge for Solana and Bitcoin, will use Relay.link only
+                        }
                         // For reverse calculation ingress: use srcChainTokenInAmount: 'auto' and specify dstChainTokenOutAmount
                         const debridgeParams = {
                             srcChainId: debridgeChainId,

package/dist/hooks/useSwap.js

@@ -13,7 +13,7 @@ export const DEFAULT_OUTPUT_ASSET = 'eip155:8453/erc20:0x833589fCD6eDb6E08f4c7C3
 export const getSourceAssetCaip19 = (tokenIn) => {
     return tokenIn?.caip19 || DEFAULT_SOURCE_ASSET;
 };
-export const useSwap = create()(persist((set, get) => ({
+const useSwapStore = create()(persist((set, get) => ({
     // Regular swap state
     isAutoSlippage: true,
     tokenIn: getAssetByCaip19(DEFAULT_SOURCE_ASSET) ?? null,
@@ -283,3 +283,9 @@ export const useSwap = create()(persist((set, get) => ({
         };
     },
 }));
+// Cache server snapshot for SSR compatibility
+// This prevents the "getServerSnapshot should be cached" error in Next.js
+if (typeof window === 'undefined') {
+    useSwapStore.getState(); // Cache the snapshot on server
+}
+export const useSwap = useSwapStore;

package/dist/hooks/useTransaction.d.ts

@@ -2,6 +2,7 @@ import type { Hex, WalletClient } from 'viem';
 import type { Connector } from 'wagmi';
 import type { BridgeProvider, BridgeQuote, BridgeStatus, OrderResponse } from '@silentswap/sdk';
 import type { SolanaWalletConnector, SolanaConnection } from './silent/solana-transaction.js';
+import type { BitcoinWalletConnector, BitcoinConnection } from './silent/bitcoin-transaction.js';
 export interface useTransactionOptions {
     /** User's EVM address */
     address: `0x${string}`;
@@ -15,6 +16,10 @@ export interface useTransactionOptions {
     solanaConnection?: SolanaConnection;
     /** Solana RPC URL (optional, will create connection if not provided) */
     solanaRpcUrl?: string;
+    /** Bitcoin wallet connector (required for Bitcoin transactions) */
+    bitcoinConnector?: BitcoinWalletConnector;
+    /** Bitcoin connection (optional, for consistency with Solana pattern) */
+    bitcoinConnection?: BitcoinConnection;
     /** Optional callback to set current step (for external state management) */
     setCurrentStep?: (step: string) => void;
     /** Optional status update callback */
@@ -116,4 +121,4 @@ export interface useTransactionReturn {
  * }
  * ```
  */
-export declare function useTransaction({ walletClient, connector, solanaConnector, solanaConnection, solanaRpcUrl, setCurrentStep: externalSetCurrentStep, onStatus: externalOnStatus, }: useTransactionOptions): useTransactionReturn;
+export declare function useTransaction({ walletClient, connector, solanaConnector, solanaConnection, solanaRpcUrl, bitcoinConnector, bitcoinConnection, setCurrentStep: externalSetCurrentStep, onStatus: externalOnStatus, }: useTransactionOptions): useTransactionReturn;