@silentswap/react 0.0.41

package/dist/hooks/useTransaction.js

@@ -0,0 +1,353 @@
+import { useCallback, useState } from 'react';
+import { createPublicClient, http, erc20Abi } from 'viem';
+import { executeRelayBridge, executeDebridgeBridge, getBridgeStatus, createTransactionExecutor, createChainSwitcher, ensureChain, waitForTransactionConfirmation, parseTransactionRequestForViem, getChainById, } from '@silentswap/sdk';
+import { createSolanaTransactionExecutor } from './silent/solana-transaction.js';
+/**
+ * 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 function useTransaction({ walletClient, connector, solanaConnector, solanaConnection, solanaRpcUrl, setCurrentStep: externalSetCurrentStep, onStatus: externalOnStatus, }) {
+    const [isLoading, setIsLoading] = useState(false);
+    const [internalCurrentStep, setInternalCurrentStep] = useState('');
+    const [error, setError] = useState(null);
+    // Use external callbacks if provided, otherwise use internal state
+    const setCurrentStep = externalSetCurrentStep || setInternalCurrentStep;
+    const currentStep = externalSetCurrentStep ? internalCurrentStep : internalCurrentStep;
+    const onStatus = externalOnStatus;
+    /**
+     * Execute a bridge transaction
+     * Supports both EVM and Solana transactions
+     */
+    const executeTransaction = useCallback(async (quote) => {
+        // Check if quote contains Solana transactions
+        const hasSolanaTransactions = quote.txs.some((tx) => tx.instructions !== undefined);
+        if (hasSolanaTransactions) {
+            // Solana transactions require Solana connector and connection
+            if (!solanaConnector || !solanaConnection) {
+                throw new Error('Solana connector and connection are required for Solana bridge transactions. ' +
+                    'Please provide solanaConnector and solanaConnection options.');
+            }
+            // Create Solana transaction executor
+            const solanaExecutor = createSolanaTransactionExecutor(solanaConnector, solanaConnection);
+            // For Solana, we still need EVM wallet client for chain switching (if needed)
+            // But the actual transaction execution will use Solana executor
+            const executeTx = createTransactionExecutor(walletClient, connector, solanaExecutor);
+            // Create a no-op chain switcher for Solana (chain switching is handled by connector)
+            const switchChain = async (_chainId) => {
+                // Solana doesn't require chain switching
+            };
+            setIsLoading(true);
+            setError(null);
+            try {
+                // Execute based on provider
+                switch (quote.provider) {
+                    case 'relay':
+                        return await executeRelayBridge(quote, executeTx, switchChain, (step) => {
+                            setCurrentStep(step);
+                            onStatus?.(step);
+                        });
+                    case 'debridge':
+                        // DeBridge doesn't support Solana
+                        throw new Error('DeBridge does not support Solana transactions');
+                    default:
+                        throw new Error(`Unsupported bridge provider: ${quote.provider}`);
+                }
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error('Bridge execution failed');
+                console.error('Bridge execution failed:', error);
+                setError(error);
+                return null;
+            }
+            finally {
+                setIsLoading(false);
+                setCurrentStep('');
+            }
+        }
+        else {
+            // EVM transactions
+            if (!walletClient) {
+                throw new Error('Wallet client required for EVM bridge execution');
+            }
+            if (!connector) {
+                throw new Error('Connector required for EVM bridge execution');
+            }
+            setIsLoading(true);
+            setError(null);
+            try {
+                // Create wrapper functions using shared utilities
+                const executeTx = createTransactionExecutor(walletClient, connector);
+                const switchChain = createChainSwitcher(walletClient, connector);
+                // Execute based on provider
+                switch (quote.provider) {
+                    case 'relay':
+                        return await executeRelayBridge(quote, executeTx, switchChain, (step) => {
+                            setCurrentStep(step);
+                            onStatus?.(step);
+                        });
+                    case 'debridge':
+                        return await executeDebridgeBridge(quote, executeTx, switchChain, (step) => {
+                            setCurrentStep(step);
+                            onStatus?.(step);
+                        });
+                    default:
+                        throw new Error(`Unsupported bridge provider: ${quote.provider}`);
+                }
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error('Bridge execution failed');
+                console.error('Bridge execution failed:', error);
+                setError(error);
+                return null;
+            }
+            finally {
+                setIsLoading(false);
+                setCurrentStep('');
+            }
+        }
+    }, [walletClient, connector, solanaConnector, solanaConnection, solanaRpcUrl]);
+    /**
+     * Execute a deposit transaction from an OrderResponse
+     *
+     * Parses the transaction request from the order response, switches to the
+     * correct chain, sends the transaction, and waits for confirmation.
+     *
+     * @param orderResponse - Order response containing transaction details
+     * @returns Promise resolving to transaction result
+     */
+    const executeSwapTransaction = useCallback(async (orderResponse) => {
+        if (!walletClient) {
+            throw new Error('Wallet client required for transaction execution');
+        }
+        if (!connector) {
+            throw new Error('Connector required for chain switching');
+        }
+        setIsLoading(true);
+        setCurrentStep('Preparing transaction');
+        onStatus?.('Preparing transaction');
+        setError(null);
+        try {
+            const transactionParams = parseTransactionRequestForViem(orderResponse.transaction);
+            if (!transactionParams) {
+                throw new Error('Invalid transaction parameters from order response');
+            }
+            const chainId = transactionParams.chainId ?? 1;
+            // Ensure correct chain
+            const wallet = await ensureChain(chainId, walletClient, connector);
+            // Create public client for the same chain
+            // Use wallet's chain if available, otherwise look up chain by ID
+            const chain = wallet.chain || getChainById(chainId);
+            if (!chain) {
+                throw new Error(`Unsupported chain ID: ${chainId}. Please ensure the chain is supported.`);
+            }
+            const publicClient = createPublicClient({
+                chain,
+                transport: http(),
+            });
+            setCurrentStep('Sending transaction');
+            onStatus?.('Sending transaction');
+            // Execute transaction
+            const hash = await wallet.sendTransaction({
+                ...transactionParams,
+                chain: { id: chainId },
+            });
+            setCurrentStep('Waiting for confirmation');
+            onStatus?.('Waiting for confirmation');
+            // Wait for confirmation using core utility with public client
+            const result = await waitForTransactionConfirmation(hash, publicClient);
+            if (result.status !== 'success') {
+                throw new Error(`Transaction failed: ${result.transactionHash}`);
+            }
+            return {
+                hash,
+                chainId,
+                status: 'confirmed',
+                confirmations: 1,
+            };
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Transaction execution failed');
+            setError(error);
+            throw error;
+        }
+        finally {
+            setIsLoading(false);
+            setCurrentStep('');
+        }
+    }, [walletClient, connector, setCurrentStep, onStatus]);
+    /**
+     * Approve token spending for a given allowance target
+     *
+     * Checks current allowance and approves if needed. Used for ERC-20 token
+     * approvals before executing swaps or bridge transactions.
+     *
+     * @param chainId - Chain ID where the token is located
+     * @param tokenAddress - Token contract address
+     * @param allowanceTarget - Address to approve spending for
+     * @param amount - Amount to approve
+     * @param userAddress - User's address
+     * @returns Promise resolving to transaction hash if approval was needed, null otherwise
+     */
+    const approveTokenSpending = useCallback(async (chainId, tokenAddress, allowanceTarget, amount, userAddress) => {
+        if (!walletClient || !connector) {
+            throw new Error('Wallet client and connector required for token approval');
+        }
+        setIsLoading(true);
+        setCurrentStep('Approving token spending');
+        onStatus?.('Approving token spending');
+        setError(null);
+        try {
+            // Switch to source chain for approval
+            const wallet = await ensureChain(chainId, walletClient, connector);
+            // Check current allowance
+            // Use wallet's chain if available, otherwise look up chain by ID
+            const chain = wallet.chain || getChainById(chainId);
+            if (!chain) {
+                throw new Error(`Unsupported chain ID: ${chainId}. Please ensure the chain is supported.`);
+            }
+            const publicClient = createPublicClient({
+                chain,
+                transport: http(),
+            });
+            const currentAllowance = (await publicClient.readContract({
+                address: tokenAddress,
+                abi: erc20Abi,
+                functionName: 'allowance',
+                args: [userAddress, allowanceTarget],
+            }));
+            // Match Svelte behavior: approve maximum uint256 value (XG_UINT256_MAX)
+            // This allows the bridge to use tokens even if the amount needs slight adjustment
+            const XG_UINT256_MAX = (1n << 256n) - 1n;
+            const amountToCheck = BigInt(amount);
+            console.log('currentAllowance', currentAllowance);
+            console.log('amountToCheck', amountToCheck);
+            // Approve if current allowance is insufficient
+            // In Svelte: checks if allowance < amount, then approves XG_UINT256_MAX (line 948, 958)
+            if (currentAllowance < amountToCheck) {
+                const hash = await walletClient.writeContract({
+                    address: tokenAddress,
+                    abi: erc20Abi,
+                    functionName: 'approve',
+                    args: [allowanceTarget, XG_UINT256_MAX],
+                    account: walletClient.account,
+                    chain: null,
+                });
+                // Wait for approval confirmation
+                await waitForTransactionConfirmation(hash, publicClient);
+                return hash;
+            }
+            return null;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Token approval failed');
+            setError(error);
+            throw error;
+        }
+        finally {
+            setIsLoading(false);
+            setCurrentStep('');
+        }
+    }, [walletClient, connector]);
+    /**
+     * Get bridge status for a request
+     */
+    const getStatus = useCallback(async (requestId, provider) => {
+        setIsLoading(true);
+        setCurrentStep('Checking bridge status');
+        setError(null);
+        try {
+            // Use shared status function
+            return await getBridgeStatus(requestId, provider);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to get bridge status');
+            setError(error);
+            return null;
+        }
+        finally {
+            setIsLoading(false);
+            setCurrentStep('');
+        }
+    }, []);
+    return {
+        // State
+        isLoading,
+        currentStep,
+        error,
+        // Methods
+        executeTransaction,
+        executeSwapTransaction,
+        approveTokenSpending,
+        getStatus,
+    };
+}

package/dist/hooks/useTransactionAddress.d.ts

@@ -0,0 +1,11 @@
+import { type AssetInfo } from '@silentswap/sdk';
+/**
+ * Hook to select the correct transaction/quote address based on the input token.
+ * Returns EVM address for EVM tokens, Solana address for Solana tokens.
+ *
+ * @param tokenIn - The input token asset info
+ * @param evmAddress - The user's EVM address (0x...) or null
+ * @param solAddress - The user's Solana address (base58) or null
+ * @returns The appropriate address for the token's chain, or undefined if no token/address
+ */
+export declare function useTransactionAddress(tokenIn: AssetInfo | null | undefined, evmAddress: string | null | undefined, solAddress: string | null | undefined): `0x${string}` | string | undefined;

package/dist/hooks/useTransactionAddress.js

@@ -0,0 +1,26 @@
+import { useMemo } from 'react';
+import { isEvmAsset, isSolanaAsset } from '@silentswap/sdk';
+/**
+ * Hook to select the correct transaction/quote address based on the input token.
+ * Returns EVM address for EVM tokens, Solana address for Solana tokens.
+ *
+ * @param tokenIn - The input token asset info
+ * @param evmAddress - The user's EVM address (0x...) or null
+ * @param solAddress - The user's Solana address (base58) or null
+ * @returns The appropriate address for the token's chain, or undefined if no token/address
+ */
+export function useTransactionAddress(tokenIn, evmAddress, solAddress) {
+    return useMemo(() => {
+        if (!tokenIn) {
+            return (evmAddress ?? undefined);
+        }
+        if (isEvmAsset(tokenIn.caip19)) {
+            return (evmAddress ?? undefined);
+        }
+        if (isSolanaAsset(tokenIn.caip19)) {
+            return solAddress ?? undefined; // Return Solana address as string (not cast to 0x)
+        }
+        // Default to EVM address
+        return (evmAddress ?? undefined);
+    }, [tokenIn?.caip19, evmAddress, solAddress]);
+}

package/dist/hooks/useUsdValue.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Hook to calculate and format USD value from amount and price
+ */
+export declare function useUsdValue(amount: string, price: number | undefined): {
+    usdValue: number | null;
+    formattedUsdValue: string | null;
+};

package/dist/hooks/useUsdValue.js

@@ -0,0 +1,19 @@
+import { useMemo } from 'react';
+import { calculateUsdValue, formatUsdValue } from '../utils/formatters.js';
+/**
+ * Hook to calculate and format USD value from amount and price
+ */
+export function useUsdValue(amount, price) {
+    const usdValue = useMemo(() => {
+        return calculateUsdValue(amount, price);
+    }, [amount, price]);
+    const formattedUsdValue = useMemo(() => {
+        if (!usdValue)
+            return null;
+        return formatUsdValue(usdValue);
+    }, [usdValue]);
+    return {
+        usdValue,
+        formattedUsdValue,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+export { useSilentClient } from './hooks/silent/useSilentClient.js';
+export { PricesProvider, usePricesContext } from './contexts/PricesContext.js';
+export type { PricesContextType } from './contexts/PricesContext.js';
+export { AssetsProvider, useAssetsContext } from './contexts/AssetsContext.js';
+export type { AssetsContextType, Chain, ChainInfo } from './contexts/AssetsContext.js';
+export { BalancesProvider, useBalancesContext } from './contexts/BalancesContext.js';
+export type { BalancesContextType, UserBalance } from './contexts/BalancesContext.js';
+export { OrdersProvider, useOrdersContext, useWalletFacilitatorGroups } from './contexts/OrdersContext.js';
+export type { OrdersContextOrderMetadata, OrdersContextOrder, FacilitatorGroup, OrdersContextType } from './contexts/OrdersContext.js';
+export { SilentSwapProvider, useSilentSwap } from './contexts/SilentSwapContext.js';
+export type { SilentSwapContextType } from './contexts/SilentSwapContext.js';
+export { useSilentOrders } from './hooks/silent/useSilentOrders.js';
+export { useAuth } from './hooks/silent/useAuth.js';
+export { useWallet } from './hooks/silent/useWallet.js';
+export { useSilentQuote } from './hooks/silent/useSilentQuote.js';
+export { useOrderTracking, OutputStage, getStatusTextFromStage, getProgressFromStage, } from './hooks/silent/useOrderTracking.js';
+export { useRefund } from './hooks/silent/useRefund.js';
+export { useTransaction } from './hooks/useTransaction.js';
+export { useQuote } from './hooks/useQuote.js';
+export { useOrderEstimates } from './hooks/useOrderEstimates.js';
+export { usePrices } from './hooks/usePrices.js';
+export { useSwap, getSourceAssetCaip19, X_RANGE_SLIDER_MIN_GAP, OUTPUT_LIMIT, DEFAULT_SOURCE_ASSET, DEFAULT_DEST_ASSET, } from './hooks/useSwap.js';
+export type { Destination, SwapState } from './hooks/useSwap.js';
+export { useEgressEstimates } from './hooks/useEgressEstimates.js';
+export type { UseEgressEstimatesOptions } from './hooks/useEgressEstimates.js';
+export { useStatus } from './hooks/useStatus.js';
+export type { StatusResponse } from './hooks/useStatus.js';
+export { useHiddenSwapFees } from './hooks/useHiddenSwapFees.js';
+export type { HiddenSwapFees, UseHiddenSwapFeesOptions } from './hooks/useHiddenSwapFees.js';
+export { useSlippageUsd } from './hooks/useSlippageUsd.js';
+export type { UseSlippageUsdOptions } from './hooks/useSlippageUsd.js';
+export { useResetSwapForm } from './hooks/useResetSwapForm.js';
+export type { UseResetSwapFormOptions } from './hooks/useResetSwapForm.js';
+export { useTransactionAddress } from './hooks/useTransactionAddress.js';
+export { useSolanaAdapter } from './hooks/useSolanaAdapter.js';
+export { useContacts, AddressBookContact, AddressBookContactSource } from './hooks/useContacts.js';
+export type { AddressBookContactId, AddressBookContactInfo, AddressBookContactsQuery } from './hooks/useContacts.js';
+export { useAssetPrice } from './hooks/useAssetPrice.js';
+export { useUsdValue } from './hooks/useUsdValue.js';
+export { useOutputAssetInfo } from './hooks/useOutputAssetInfo.js';
+export * from './utils/formatters.js';
+export type { SilentSwapClientConfig, BridgeProvider, BridgeQuote, BridgeTransaction, BridgeStatus, BridgeQuoteParams, RefundEligibility, GatewayOrderStatus, } from '@silentswap/sdk';
+export { queryDepositCount, executeRelayBridge, executeDebridgeBridge, getRelayStatus, getDebridgeStatus, loadCachedAuth, saveAuth, clearAuth, getAuthStorageKey, loadWalletData, saveWalletData, clearWalletData, getWalletStorageKey, ensureChain, waitForTransactionConfirmation, DepositStatus, queryOrderStatus, checkRefundEligibility, executeRefund, checkRecoveryEligibility, orderIdToBytes32, NI_CHAIN_ID_AVALANCHE, XT_TTL_SESSION_CACHE, X_MINIMUM_INPUT_USD, X_MAX_IMPACT_PERCENT, S0X_ADDR_USDC_AVALANCHE, S_CAIP19_USDC_AVALANCHE, } from '@silentswap/sdk';
+export type { SilentSwapWallet, FacilitatorAccount, useWalletOptions, useWalletReturn, } from './hooks/silent/useWallet.js';
+export type { useAuthOptions, useAuthReturn } from './hooks/silent/useAuth.js';
+export type { SwapTransaction, SwapResult, useSilentQuoteOptions, useSilentQuoteReturn, ExecuteSwapParams, } from './hooks/silent/useSilentQuote.js';
+export type { useTransactionOptions, useTransactionReturn } from './hooks/useTransaction.js';
+export type { useQuoteOptions, useQuoteReturn } from './hooks/useQuote.js';
+export type { OrderEstimateResult, UseOrderEstimatesOptions } from './hooks/useOrderEstimates.js';
+export type { usePricesOptions, usePricesReturn, CachedPrice } from './hooks/usePrices.js';
+export type { UseOrderTrackingOptions, UseOrderTrackingReturn, OrderDeposit, OutputStatus, OrderStatus, StatusUpdate, } from './hooks/silent/useOrderTracking.js';
+export type { UseRefundOptions, UseRefundReturn } from './hooks/silent/useRefund.js';
+export { createSolanaTransactionExecutor, convertRelaySolanaStepToTransaction, } from './hooks/silent/solana-transaction.js';
+export type { SolanaWalletConnector, SolanaConnection } from './hooks/silent/solana-transaction.js';

package/dist/index.js

@@ -0,0 +1,41 @@
+export { useSilentClient } from './hooks/silent/useSilentClient.js';
+export { PricesProvider, usePricesContext } from './contexts/PricesContext.js';
+export { AssetsProvider, useAssetsContext } from './contexts/AssetsContext.js';
+export { BalancesProvider, useBalancesContext } from './contexts/BalancesContext.js';
+export { OrdersProvider, useOrdersContext, useWalletFacilitatorGroups } from './contexts/OrdersContext.js';
+export { SilentSwapProvider, useSilentSwap } from './contexts/SilentSwapContext.js';
+export { useSilentOrders } from './hooks/silent/useSilentOrders.js';
+export { useAuth } from './hooks/silent/useAuth.js';
+export { useWallet } from './hooks/silent/useWallet.js';
+export { useSilentQuote } from './hooks/silent/useSilentQuote.js';
+export { useOrderTracking, OutputStage, getStatusTextFromStage, getProgressFromStage, } from './hooks/silent/useOrderTracking.js';
+export { useRefund } from './hooks/silent/useRefund.js';
+export { useTransaction } from './hooks/useTransaction.js';
+export { useQuote } from './hooks/useQuote.js';
+export { useOrderEstimates } from './hooks/useOrderEstimates.js';
+export { usePrices } from './hooks/usePrices.js';
+export { useSwap, getSourceAssetCaip19, X_RANGE_SLIDER_MIN_GAP, OUTPUT_LIMIT, DEFAULT_SOURCE_ASSET, DEFAULT_DEST_ASSET, } from './hooks/useSwap.js';
+export { useEgressEstimates } from './hooks/useEgressEstimates.js';
+export { useStatus } from './hooks/useStatus.js';
+export { useHiddenSwapFees } from './hooks/useHiddenSwapFees.js';
+export { useSlippageUsd } from './hooks/useSlippageUsd.js';
+export { useResetSwapForm } from './hooks/useResetSwapForm.js';
+export { useTransactionAddress } from './hooks/useTransactionAddress.js';
+export { useSolanaAdapter } from './hooks/useSolanaAdapter.js';
+export { useContacts, AddressBookContact, AddressBookContactSource } from './hooks/useContacts.js';
+export { useAssetPrice } from './hooks/useAssetPrice.js';
+export { useUsdValue } from './hooks/useUsdValue.js';
+export { useOutputAssetInfo } from './hooks/useOutputAssetInfo.js';
+export * from './utils/formatters.js';
+// Re-export functions from core SDK
+export { queryDepositCount, executeRelayBridge, executeDebridgeBridge, getRelayStatus, getDebridgeStatus, 
+// Storage utilities
+loadCachedAuth, saveAuth, clearAuth, getAuthStorageKey, loadWalletData, saveWalletData, clearWalletData, getWalletStorageKey, 
+// Chain utilities
+ensureChain, waitForTransactionConfirmation, 
+// Refund utilities
+DepositStatus, queryOrderStatus, checkRefundEligibility, executeRefund, checkRecoveryEligibility, orderIdToBytes32, 
+// Constants
+NI_CHAIN_ID_AVALANCHE, XT_TTL_SESSION_CACHE, X_MINIMUM_INPUT_USD, X_MAX_IMPACT_PERCENT, S0X_ADDR_USDC_AVALANCHE, S_CAIP19_USDC_AVALANCHE, } from '@silentswap/sdk';
+// Solana transaction utilities
+export { createSolanaTransactionExecutor, convertRelaySolanaStepToTransaction, } from './hooks/silent/solana-transaction.js';

package/dist/stories/SilentSwapOverview.stories.d.ts

@@ -0,0 +1,10 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import { type SilentSwapClientConfig } from '@silentswap/sdk';
+declare function SilentSwapCompleteDemo({ config }: {
+    config: SilentSwapClientConfig;
+}): import("react/jsx-runtime").JSX.Element;
+declare const meta: Meta<typeof SilentSwapCompleteDemo>;
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const DefaultFlow: Story;
+export declare const StagingEnvironment: Story;