@silentswap/react 0.0.41

package/dist/hooks/useSolanaAdapter.js

@@ -0,0 +1,55 @@
+import { useMemo } from 'react';
+import { useWallet as useSolanaWallet, useConnection } from '@solana/wallet-adapter-react';
+import { createSolanaRpc } from '@solana/rpc';
+/**
+ * Reusable hook for Solana wallet adapter setup
+ * Returns the Solana connector and connection adapter for use with SilentSwap hooks
+ */
+export function useSolanaAdapter() {
+    const solanaWallet = useSolanaWallet();
+    const solanaConnection = useConnection();
+    // Prepare Solana connector if wallet is connected
+    const solanaConnector = useMemo(() => {
+        if (!solanaWallet.publicKey || !solanaWallet.signTransaction || !solanaWallet.sendTransaction) {
+            return undefined;
+        }
+        return {
+            signTransaction: solanaWallet.signTransaction.bind(solanaWallet),
+            sendTransaction: solanaWallet.sendTransaction.bind(solanaWallet),
+            publicKey: solanaWallet.publicKey,
+        };
+    }, [solanaWallet.publicKey, solanaWallet.signTransaction, solanaWallet.sendTransaction]);
+    // Prepare Solana connection
+    const solanaConnectionAdapter = useMemo(() => {
+        if (!solanaConnection.connection) {
+            return undefined;
+        }
+        const rpc = createSolanaRpc(solanaConnection.connection.rpcEndpoint);
+        return {
+            rpc,
+            // Include the actual connection object for wallet adapter compatibility
+            connection: solanaConnection.connection,
+            getLatestBlockhash: async (commitment) => {
+                const result = await rpc.getLatestBlockhash({ commitment: commitment }).send();
+                return {
+                    blockhash: result.value.blockhash,
+                    lastValidBlockHeight: BigInt(result.value.lastValidBlockHeight),
+                };
+            },
+            confirmTransaction: async (config, commitment) => {
+                // Note: @solana/rpc doesn't have a direct confirmTransaction method
+                // We'll use getSignatureStatuses instead
+                const result = await rpc.getSignatureStatuses([config.signature], { searchTransactionHistory: true }).send();
+                return {
+                    value: {
+                        err: result.value?.[0]?.err || null,
+                    },
+                };
+            },
+        };
+    }, [solanaConnection.connection]);
+    return {
+        solanaConnector,
+        solanaConnectionAdapter,
+    };
+}

package/dist/hooks/useStatus.d.ts

@@ -0,0 +1,25 @@
+export interface StatusResponse {
+    serviceFeeRate?: number;
+    overheadUsd?: string;
+    minimumDepositUusdc?: string;
+    maximumDepositUusdc?: string;
+    platformHealth?: 'UNKNOWN' | 'ON' | 'OFF' | 'PAUSED' | 'ONLINE' | 'DEPOSITS_PAUSED' | 'MAINTENANCE';
+    outputLimit?: number;
+    volume?: number;
+    liquidity?: number;
+    identity?: string;
+}
+/**
+ * Hook to fetch the current platform status, fee rates, and limits
+ */
+export declare function useStatus(): {
+    status: StatusResponse;
+    isLoading: boolean;
+    error: Error | null;
+    serviceFeeRate: number;
+    overheadUsd: number;
+    minimumDepositUusdc: string | undefined;
+    maximumDepositUusdc: string | undefined;
+    platformHealth: "UNKNOWN" | "ON" | "OFF" | "PAUSED" | "ONLINE" | "DEPOSITS_PAUSED" | "MAINTENANCE" | undefined;
+    outputLimit: number | undefined;
+};

package/dist/hooks/useStatus.js

@@ -0,0 +1,60 @@
+import { useState, useEffect } from 'react';
+import { useSilentSwap } from '../contexts/SilentSwapContext.js';
+/**
+ * Hook to fetch the current platform status, fee rates, and limits
+ */
+export function useStatus() {
+    const { config } = useSilentSwap();
+    const baseUrl = config.baseUrl;
+    const [status, setStatus] = useState({});
+    const [isLoading, setIsLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        let isMounted = true;
+        const fetchStatus = async () => {
+            try {
+                setIsLoading(true);
+                const response = await fetch(`${baseUrl}/status`);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch status: ${response.statusText}`);
+                }
+                const data = await response.json();
+                if (isMounted) {
+                    setStatus(data);
+                    setError(null);
+                }
+            }
+            catch (err) {
+                if (isMounted) {
+                    setError(err instanceof Error ? err : new Error('Failed to fetch status'));
+                    // Use defaults on error
+                    setStatus({});
+                }
+            }
+            finally {
+                if (isMounted) {
+                    setIsLoading(false);
+                }
+            }
+        };
+        fetchStatus();
+        return () => {
+            isMounted = false;
+        };
+    }, [baseUrl]);
+    // Convert overheadUsd from string to number
+    const overheadUsd = status.overheadUsd ? parseFloat(status.overheadUsd) : 0;
+    // serviceFeeRate is a Decimal (0.01 = 1%), convert to number
+    const serviceFeeRate = status.serviceFeeRate ?? 0.01; // Default 1%
+    return {
+        status,
+        isLoading,
+        error,
+        serviceFeeRate,
+        overheadUsd,
+        minimumDepositUusdc: status.minimumDepositUusdc,
+        maximumDepositUusdc: status.maximumDepositUusdc,
+        platformHealth: status.platformHealth,
+        outputLimit: status.outputLimit,
+    };
+}

package/dist/hooks/useSwap.d.ts

@@ -0,0 +1,67 @@
+import { type AssetInfo } from '@silentswap/sdk';
+export declare const X_RANGE_SLIDER_MIN_GAP = 0.01;
+export declare const OUTPUT_LIMIT = 5;
+export declare const DEFAULT_SOURCE_ASSET = "eip155:1/slip44:60";
+export declare const DEFAULT_DEST_ASSET = "eip155:1/erc20:0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599";
+export declare const DEFAULT_OUTPUT_ASSET = "eip155:8453/erc20:0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+export declare const getSourceAssetCaip19: (tokenIn: AssetInfo | null) => string;
+export interface Destination {
+    asset: string;
+    contact: string;
+    amount: string;
+    priceUsd?: number;
+}
+export interface SwapState {
+    tokenIn: AssetInfo | null;
+    inputAmount: string;
+    isSwapLoading: boolean;
+    isMultiSwapLoading: boolean;
+    srcChain: number;
+    dstChain: number;
+    slippage: number;
+    isAutoSlippage: boolean;
+    latestSuggestedAutoSlippageValue: number;
+    recipientAddress: string;
+    privacyEnabled: boolean;
+    usdInputMode: boolean;
+    destinations: Destination[];
+    splits: number[];
+    isDraggingSlider: boolean;
+    setTokenIn: (token: AssetInfo) => void;
+    setSrcChain: (chainId: number) => void;
+    setDstChain: (chainId: number) => void;
+    setInputAmount: (amount: string) => void;
+    setRecipientAddress: (recipientAddress: string) => void;
+    setSwapLoading: (value: boolean) => void;
+    swapTokens: (amount: string) => void;
+    setSlippage: (amount: number) => void;
+    setIsAutoSlippage: (value: boolean) => void;
+    setLatestSuggestedAutoSlippageValue: (value: number) => void;
+    setPrivacyEnabled: (enabled: boolean) => void;
+    setUsdInputMode: (enabled: boolean) => void;
+    toggleUsdInputMode: () => void;
+    setDestinations: (updater: Destination[] | ((prev: Destination[]) => Destination[])) => void;
+    setSplits: (updater: number[] | ((prev: number[]) => number[])) => void;
+    handleAddOutput: (caip19Asset?: string, defaultAddress?: string) => void;
+    handleDeleteOutput: (index: number) => void;
+    propagateRange: (i_split: number, x_value: number, b_hi: boolean, b_whole: boolean) => boolean;
+    updateDestinationAsset: (index: number, asset: string) => void;
+    updateDestinationContact: (index: number, contact: string) => void;
+    updateDestinationAmount: (index: number, amount: string) => void;
+    setIsDraggingSlider: (isDragging: boolean) => void;
+    getCanAddOutput: () => boolean;
+    getHasMultipleOutputs: () => boolean;
+}
+export declare const useSwap: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<SwapState>, "setState" | "persist"> & {
+    setState(partial: SwapState | Partial<SwapState> | ((state: SwapState) => SwapState | Partial<SwapState>), replace?: false | undefined): unknown;
+    setState(state: SwapState | ((state: SwapState) => SwapState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<SwapState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: SwapState) => void) => () => void;
+        onFinishHydration: (fn: (state: SwapState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<SwapState, unknown, unknown>>;
+    };
+}>;

package/dist/hooks/useSwap.js

@@ -0,0 +1,285 @@
+import { create } from 'zustand';
+import { persist, createJSONStorage } from 'zustand/middleware';
+import { getAssetByCaip19 } from '@silentswap/sdk';
+const DEFAULT_SLIPPAGE = 1;
+// Constants matching Svelte app
+export const X_RANGE_SLIDER_MIN_GAP = 0.01;
+export const OUTPUT_LIMIT = 5;
+// Default assets
+export const DEFAULT_SOURCE_ASSET = 'eip155:1/slip44:60'; // ETH on Ethereum
+export const DEFAULT_DEST_ASSET = 'eip155:1/erc20:0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599'; // WBTC on Ethereum
+export const DEFAULT_OUTPUT_ASSET = 'eip155:8453/erc20:0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'; // USDC on Base
+// Helper to get source asset CAIP19 from tokenIn
+export const getSourceAssetCaip19 = (tokenIn) => {
+    return tokenIn?.caip19 || DEFAULT_SOURCE_ASSET;
+};
+export const useSwap = create()(persist((set, get) => ({
+    // Regular swap state
+    isAutoSlippage: true,
+    tokenIn: getAssetByCaip19(DEFAULT_SOURCE_ASSET) ?? null,
+    srcChain: 1,
+    dstChain: 1,
+    inputAmount: '',
+    isSwapLoading: false,
+    isMultiSwapLoading: false,
+    latestSuggestedAutoSlippageValue: 0,
+    slippage: DEFAULT_SLIPPAGE,
+    recipientAddress: '',
+    // Privacy/UI state
+    privacyEnabled: true,
+    usdInputMode: false,
+    // Hidden swap state (uses tokenIn and inputAmount)
+    // For regular swaps, destinations[0] represents the output token and recipient
+    destinations: [{ asset: DEFAULT_DEST_ASSET, contact: '', amount: '' }],
+    splits: [1],
+    isDraggingSlider: false,
+    // Regular swap setters
+    setTokenIn: (token) => {
+        set({ tokenIn: token });
+    },
+    setSrcChain: (chainId) => set({ srcChain: chainId }),
+    setDstChain: (chainId) => set({ dstChain: chainId }),
+    setInputAmount: (amount) => set({ inputAmount: amount }),
+    setRecipientAddress: (recipientAddress) => set({ recipientAddress }),
+    setSwapLoading: (value) => set({ isSwapLoading: value }),
+    swapTokens: (amount) => set((state) => {
+        if (!state.tokenIn || state.destinations.length === 0 || !state.destinations[0]?.asset) {
+            return state;
+        }
+        // Remove any commas or special characters and ensure the string is valid
+        const sanitizedAmount = amount.replace(/[',]/g, '');
+        // Check if the sanitized amount is a valid number
+        const number = !isNaN(parseFloat(sanitizedAmount)) ? parseFloat(sanitizedAmount) : null;
+        // Get current destination asset
+        const currentDestAsset = state.destinations[0]?.asset;
+        const currentDestContact = state.destinations[0]?.contact || '';
+        // Swap tokenIn with destination asset
+        const newTokenIn = getAssetByCaip19(currentDestAsset);
+        if (!newTokenIn)
+            return state;
+        // Only add inputAmount if the number is valid
+        return {
+            ...state,
+            ...(number !== null && { inputAmount: number.toString() }), // Only include inputAmount if number is valid
+            tokenIn: newTokenIn,
+            destinations: [{ asset: state.tokenIn.caip19, contact: currentDestContact, amount: '' }],
+            recipientAddress: '',
+        };
+    }),
+    setSlippage: (value) => {
+        return set({ slippage: value, isAutoSlippage: false });
+    },
+    setIsAutoSlippage: (value) => {
+        return set({ isAutoSlippage: value });
+    },
+    setLatestSuggestedAutoSlippageValue: (value) => {
+        return set({ latestSuggestedAutoSlippageValue: value });
+    },
+    setPrivacyEnabled: (enabled) => {
+        return set({ privacyEnabled: enabled });
+    },
+    setUsdInputMode: (enabled) => {
+        return set({ usdInputMode: enabled });
+    },
+    toggleUsdInputMode: () => {
+        return set((state) => ({ usdInputMode: !state.usdInputMode }));
+    },
+    // Hidden swap setters
+    setDestinations: (updater) => {
+        const current = get().destinations;
+        const next = typeof updater === 'function' ? updater(current) : updater;
+        set({ destinations: next });
+    },
+    setSplits: (updater) => {
+        const current = get().splits;
+        const next = typeof updater === 'function' ? updater(current) : updater;
+        set({ splits: next });
+    },
+    // Hidden swap actions
+    handleAddOutput: (_, defaultAddress) => {
+        const state = get();
+        const newAsset = DEFAULT_OUTPUT_ASSET;
+        const numOutputs = state.splits.length + 1;
+        const newSplits = Array.from({ length: numOutputs }, (_, i) => (i + 1) / numOutputs);
+        const newDestination = {
+            asset: newAsset,
+            contact: defaultAddress || '',
+            amount: '',
+        };
+        set((prev) => ({
+            destinations: [...prev.destinations, newDestination],
+            splits: newSplits,
+        }));
+    },
+    handleDeleteOutput: (index) => {
+        const state = get();
+        // Only allow deletion if there are multiple outputs
+        if (state.splits.length <= 1)
+            return;
+        set((prev) => {
+            const newDestinations = [...prev.destinations];
+            const newSplits = [...prev.splits];
+            // Update primary destination if deleting index 0
+            if (index === 0) {
+                newDestinations[0] = {
+                    contact: newDestinations[0]?.contact ?? '',
+                    asset: newDestinations[0]?.asset ?? '',
+                    amount: newDestinations[0]?.amount ?? '',
+                    priceUsd: newDestinations[0]?.priceUsd,
+                };
+            }
+            // If deleting the last split, remove the split at index-1
+            if (index === newSplits.length - 1) {
+                newSplits.splice(index - 1, 1);
+            }
+            // Otherwise, remove the split at index
+            else {
+                newSplits.splice(index, 1);
+            }
+            // Remove destination at index if destinations length > splits length
+            if (newDestinations.length > newSplits.length) {
+                newDestinations.splice(index, 1);
+            }
+            return {
+                destinations: newDestinations,
+                splits: newSplits,
+            };
+        });
+    },
+    propagateRange: (i_split, x_value, b_hi, b_whole) => {
+        const state = get();
+        const newSplits = [...state.splits];
+        if (b_hi) {
+            const x_max_safe = 1 - X_RANGE_SLIDER_MIN_GAP * (state.splits.length - i_split - 1);
+            if (x_value > x_max_safe)
+                return true;
+            const x_scale = (1 - x_value) / (1 - state.splits[i_split]);
+            for (let i_each = state.splits.length - 1; i_each > i_split; i_each--) {
+                const x_new = 1 - x_scale * (1 - state.splits[i_each]);
+                if ((state.splits[i_each + 1] ?? 1) - x_new < X_RANGE_SLIDER_MIN_GAP) {
+                    newSplits[i_each] = (state.splits[i_each + 1] ?? 1) - X_RANGE_SLIDER_MIN_GAP;
+                }
+                else {
+                    newSplits[i_each] = x_new;
+                }
+            }
+        }
+        else {
+            if (x_value < X_RANGE_SLIDER_MIN_GAP * i_split)
+                return true;
+            const x_scale = x_value / (state.splits[i_split - 1] ?? 0);
+            for (let i_each = 0; i_each < i_split - 1; i_each++) {
+                const x_new = state.splits[i_each] * x_scale;
+                if (x_new - (i_each < 1 ? 0 : state.splits[i_each - 1]) < X_RANGE_SLIDER_MIN_GAP) {
+                    newSplits[i_each] = X_RANGE_SLIDER_MIN_GAP;
+                }
+                else {
+                    newSplits[i_each] = x_new;
+                }
+            }
+        }
+        if (b_whole) {
+            for (let i_each = 0; i_each < state.splits.length - 1; i_each++) {
+                newSplits[i_each] = Math.round(newSplits[i_each] * 100) / 100;
+            }
+        }
+        if (b_hi) {
+            newSplits[i_split] = x_value;
+        }
+        else if (i_split > 0) {
+            newSplits[i_split - 1] = x_value;
+        }
+        newSplits[newSplits.length - 1] = 1.0;
+        set({ splits: newSplits });
+        return false;
+    },
+    updateDestinationAsset: (index, asset) => {
+        set((state) => {
+            return {
+                destinations: state.destinations.map((dest, idx) => idx === index
+                    ? {
+                        asset: String(asset),
+                        contact: String(dest.contact),
+                        amount: '',
+                        priceUsd: dest.priceUsd,
+                    }
+                    : {
+                        asset: String(dest.asset),
+                        contact: String(dest.contact),
+                        amount: String(dest.amount),
+                        priceUsd: dest.priceUsd,
+                    }),
+            };
+        });
+    },
+    updateDestinationContact: (index, contact) => {
+        set((state) => ({
+            destinations: state.destinations.map((dest, idx) => idx === index
+                ? {
+                    asset: String(dest.asset),
+                    contact: String(contact),
+                    amount: String(dest.amount),
+                    priceUsd: dest.priceUsd,
+                }
+                : {
+                    asset: String(dest.asset),
+                    contact: String(dest.contact),
+                    amount: String(dest.amount),
+                    priceUsd: dest.priceUsd,
+                }),
+        }));
+    },
+    updateDestinationAmount: (index, amount) => {
+        set((state) => ({
+            destinations: state.destinations.map((dest, idx) => idx === index
+                ? {
+                    asset: String(dest.asset),
+                    contact: String(dest.contact),
+                    amount: String(amount),
+                    priceUsd: dest.priceUsd,
+                }
+                : {
+                    asset: String(dest.asset),
+                    contact: String(dest.contact),
+                    amount: String(dest.amount),
+                    priceUsd: dest.priceUsd,
+                }),
+        }));
+    },
+    setIsDraggingSlider: (isDragging) => set({ isDraggingSlider: isDragging }),
+    // Computed functions
+    getCanAddOutput: () => {
+        return get().splits.length < OUTPUT_LIMIT;
+    },
+    getHasMultipleOutputs: () => {
+        return get().splits.length > 1;
+    },
+}), {
+    name: 'swap-store',
+    storage: createJSONStorage(() => localStorage),
+    // Persist privacy mode, tokenIn, and inputAmount
+    partialize: (state) => ({
+        privacyEnabled: state.privacyEnabled,
+        tokenInCaip19: state.tokenIn ? state.tokenIn.caip19 : null,
+        inputAmount: state.inputAmount,
+        usdInputMode: state.usdInputMode,
+    }),
+    merge: (persistedState, currentState) => {
+        // Helper to restore AssetInfo from CAIP19
+        const restoreAsset = (caip19) => {
+            if (!caip19)
+                return null;
+            return getAssetByCaip19(caip19) || null;
+        };
+        return {
+            ...currentState,
+            // Restore persisted fields
+            usdInputMode: persistedState?.usdInputMode ?? currentState.usdInputMode,
+            privacyEnabled: persistedState?.privacyEnabled ?? currentState.privacyEnabled,
+            tokenIn: persistedState?.tokenInCaip19
+                ? restoreAsset(persistedState.tokenInCaip19) || currentState.tokenIn
+                : currentState.tokenIn,
+            inputAmount: persistedState?.inputAmount ?? currentState.inputAmount,
+        };
+    },
+}));

package/dist/hooks/useTransaction.d.ts

@@ -0,0 +1,119 @@
+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';
+export interface useTransactionOptions {
+    /** User's EVM address */
+    address: `0x${string}`;
+    /** Wallet client for signing operations */
+    walletClient?: WalletClient;
+    /** Wagmi connector */
+    connector?: Connector;
+    /** Solana wallet connector (required for Solana transactions) */
+    solanaConnector?: SolanaWalletConnector;
+    /** Solana RPC connection (required for Solana transactions) */
+    solanaConnection?: SolanaConnection;
+    /** Solana RPC URL (optional, will create connection if not provided) */
+    solanaRpcUrl?: string;
+    /** Optional callback to set current step (for external state management) */
+    setCurrentStep?: (step: string) => void;
+    /** Optional status update callback */
+    onStatus?: (status: string) => void;
+}
+/**
+ * Transaction execution result for OrderResponse transactions
+ */
+export interface SwapTransaction {
+    hash: Hex;
+    chainId: number;
+    status: 'pending' | 'confirmed' | 'failed';
+    confirmations?: number;
+}
+export interface useTransactionReturn {
+    isLoading: boolean;
+    currentStep: string;
+    error: Error | null;
+    /** Execute a bridge transaction from a BridgeQuote */
+    executeTransaction: (quote: BridgeQuote) => Promise<BridgeStatus | null>;
+    /** Execute a deposit transaction from an OrderResponse */
+    executeSwapTransaction: (orderResponse: OrderResponse) => Promise<SwapTransaction>;
+    /** Approve token spending for a given allowance target */
+    approveTokenSpending: (chainId: number, tokenAddress: `0x${string}`, allowanceTarget: `0x${string}`, amount: string, userAddress: `0x${string}`) => Promise<Hex | null>;
+    /** Get bridge status for a request */
+    getStatus: (requestId: string, provider: BridgeProvider) => Promise<BridgeStatus | null>;
+}
+/**
+ * React hook for executing transactions
+ *
+ * This hook provides transaction execution for:
+ * - Bridge quotes from any provider (relay.link, deBridge)
+ * - SilentSwap deposit transactions (OrderResponse)
+ * - Token approvals for ERC-20 tokens
+ *
+ * It handles chain switching and transaction sending automatically for all transaction types.
+ *
+ * @param options - Configuration options for transaction execution
+ * @returns Object with transaction execution state and methods
+ *
+ * @example
+ * ```typescript
+ * import { useTransaction, useQuote } from '@silentswap/react';
+ * import { useWalletClient, useAccount } from 'wagmi';
+ *
+ * function BridgeComponent() {
+ *   const { address, connector } = useAccount();
+ *   const { data: walletClient } = useWalletClient();
+ *
+ *   // Get the best quote from all providers
+ *   const { getQuote: getBestQuote } = useQuote({ address });
+ *
+ *   // Execute the transaction
+ *   const {
+ *     executeTransaction,
+ *     getStatus,
+ *     isLoading,
+ *     currentStep,
+ *     error
+ *   } = useTransaction({
+ *     address: address!,
+ *     walletClient,
+ *     connector,
+ *   });
+ *
+ *   const handleBridge = async () => {
+ *     // Get the best quote from all providers
+ *     const quote = await getBestQuote({
+ *       srcChainId: 1, // Ethereum
+ *       dstChainId: 43114, // Avalanche
+ *       srcToken: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
+ *       dstToken: '0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E', // USDC.e
+ *       amount: '1000000', // 1 USDC
+ *       recipient: address!,
+ *     });
+ *
+ *     if (quote) {
+ *       // Execute the bridge transaction
+ *       const result = await executeTransaction(quote);
+ *       console.log('Bridge completed:', result);
+ *
+ *       // Check status if needed
+ *       if (result?.requestId) {
+ *         const status = await getStatus(result.requestId, quote.provider);
+ *         console.log('Bridge status:', status);
+ *       }
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       {isLoading && <div>{currentStep}...</div>}
+ *       {error && <div>Error: {error.message}</div>}
+ *       <button onClick={handleBridge} disabled={isLoading}>
+ *         Bridge Assets
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useTransaction({ walletClient, connector, solanaConnector, solanaConnection, solanaRpcUrl, setCurrentStep: externalSetCurrentStep, onStatus: externalOnStatus, }: useTransactionOptions): useTransactionReturn;