@silentswap/react 0.0.91 → 0.0.92

package/dist/contexts/SilentSwapContext.d.ts

@@ -65,7 +65,7 @@ export interface SilentSwapContextType {
     solanaRpcUrl?: string;
 }
 export declare function useSilentSwap(): SilentSwapContextType;
-export declare function SilentSwapProvider({ children, client, evmAddress, solAddress, connector, isConnected, solanaConnector, solanaConnection, bitcoinConnector, bitcoinConnection, environment, baseUrl, solanaRpcUrl, walletClient, bitcoinAddress, bitcoinRpcUrl, proId, requestWalletConnect, }: {
+export declare function SilentSwapProvider({ children, client, evmAddress, solAddress, connector, isConnected, solanaConnector, solanaConnection, bitcoinConnector, bitcoinConnection, environment, baseUrl, solanaRpcUrl, walletClient, bitcoinAddress, bitcoinRpcUrl, proId, requestWalletConnect, forceBridgeProvider, }: {
     children: React.ReactNode;
     client: SilentSwapClient;
     evmAddress?: string;
@@ -86,4 +86,6 @@ export declare function SilentSwapProvider({ children, client, evmAddress, solAd
     proId?: string;
     /** Optional: request wallet connection when walletClient is missing (e.g. user switched account on mobile). */
     requestWalletConnect?: () => Promise<void>;
+    /** Optional: force a single bridge provider for testing. */
+    forceBridgeProvider?: 'relay' | 'debridge';
 }): import("react/jsx-runtime").JSX.Element;

package/dist/contexts/SilentSwapContext.js

@@ -80,7 +80,7 @@ export function useSilentSwap() {
     }
     return context;
 }
-function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, bitcoinAddress, solanaConnector, solanaConnection, bitcoinConnector, bitcoinConnection, environment, config, solanaRpcUrl, connector, isConnected = false, walletClient, proId, requestWalletConnect, }) {
+function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, bitcoinAddress, solanaConnector, solanaConnection, bitcoinConnector, bitcoinConnection, environment, config, solanaRpcUrl, connector, isConnected = false, walletClient, proId, requestWalletConnect, forceBridgeProvider, }) {
     // Authentication hook - only for EVM
     const { auth, isLoading: authLoading } = useAuth({
         client,
@@ -149,6 +149,7 @@ function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, bit
         bitcoinConnection,
         getPrice,
         proId,
+        forceBridgeProvider,
     });
     const effectiveDepositAmountUsd = useMemo(() => {
         return depositAmountUsdFromEstimates > 0 ? depositAmountUsdFromEstimates : depositAmountUsdc;
@@ -257,7 +258,7 @@ function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, bit
             solanaRpcUrl,
         }, children: children });
 }
-export function SilentSwapProvider({ children, client, evmAddress, solAddress, connector, isConnected, solanaConnector, solanaConnection, bitcoinConnector, bitcoinConnection, environment = ENVIRONMENT.STAGING, baseUrl, solanaRpcUrl, walletClient, bitcoinAddress, bitcoinRpcUrl, proId, requestWalletConnect, }) {
+export function SilentSwapProvider({ children, client, evmAddress, solAddress, connector, isConnected, solanaConnector, solanaConnection, bitcoinConnector, bitcoinConnection, environment = ENVIRONMENT.STAGING, baseUrl, solanaRpcUrl, walletClient, bitcoinAddress, bitcoinRpcUrl, proId, requestWalletConnect, forceBridgeProvider, }) {
     const config = useMemo(() => {
         const computedBaseUrl = baseUrl ?? ENVIRONMENT_CONFIGS[environment].baseUrl;
         console.log('[SilentSwapProvider] Creating config:', { environment, baseUrl, computedBaseUrl });
@@ -266,5 +267,5 @@ export function SilentSwapProvider({ children, client, evmAddress, solAddress, c
             baseUrl: computedBaseUrl,
         };
     }, [environment, baseUrl]);
-    return (_jsx(AssetsProvider, { children: _jsx(PricesProvider, { children: _jsx(BalancesProvider, { evmAddress: evmAddress, solAddress: solAddress, solanaRpcUrl: solanaRpcUrl, bitcoinAddress: bitcoinAddress, bitcoinRpcUrl: bitcoinRpcUrl, children: _jsx(OrdersProvider, { baseUrl: config.baseUrl, children: _jsx(SilentSwapInnerProvider, { client: client, connector: connector, isConnected: isConnected, evmAddress: evmAddress, solAddress: solAddress, bitcoinAddress: bitcoinAddress, solanaConnector: solanaConnector, solanaConnection: solanaConnection, bitcoinConnector: bitcoinConnector, bitcoinConnection: bitcoinConnection, environment: environment, config: config, solanaRpcUrl: solanaRpcUrl, walletClient: walletClient, proId: proId, requestWalletConnect: requestWalletConnect, children: children }) }) }) }) }));
+    return (_jsx(AssetsProvider, { children: _jsx(PricesProvider, { children: _jsx(BalancesProvider, { evmAddress: evmAddress, solAddress: solAddress, solanaRpcUrl: solanaRpcUrl, bitcoinAddress: bitcoinAddress, bitcoinRpcUrl: bitcoinRpcUrl, children: _jsx(OrdersProvider, { baseUrl: config.baseUrl, children: _jsx(SilentSwapInnerProvider, { client: client, connector: connector, isConnected: isConnected, evmAddress: evmAddress, solAddress: solAddress, bitcoinAddress: bitcoinAddress, solanaConnector: solanaConnector, solanaConnection: solanaConnection, bitcoinConnector: bitcoinConnector, bitcoinConnection: bitcoinConnection, environment: environment, config: config, solanaRpcUrl: solanaRpcUrl, walletClient: walletClient, proId: proId, requestWalletConnect: requestWalletConnect, forceBridgeProvider: forceBridgeProvider, children: children }) }) }) }) }));
 }

package/dist/hooks/silent/solana-transaction.js

@@ -1,4 +1,4 @@
-import { address, appendTransactionMessageInstructions, createTransactionMessage, setTransactionMessageFeePayer, setTransactionMessageLifetimeUsingBlockhash, compileTransaction, getBase64EncodedWireTransaction, getTransactionDecoder, getCompiledTransactionMessageDecoder, decompileTransactionMessage, pipe, AccountRole, } from '@solana/kit';
+import { address, appendTransactionMessageInstructions, createTransactionMessage, setTransactionMessageFeePayer, setTransactionMessageLifetimeUsingBlockhash, compileTransaction, getBase64EncodedWireTransaction, pipe, AccountRole, } from '@solana/kit';
 import { createSolanaRpc } from '@solana/rpc';
 import { VersionedTransaction } from '@solana/web3.js';
 /**
@@ -25,30 +25,54 @@ export function createSolanaTransactionExecutor(connector, connection) {
             });
             // Get RPC client from connection or create a default one
             const rpc = connection.rpc || createSolanaRpc('https://api.mainnet-beta.solana.com');
+            const rpcEndpoint = connection.connection?.rpcEndpoint ||
+                connection.connection?._rpcEndpoint ||
+                'https://api.mainnet-beta.solana.com';
+            console.log('[SolanaTx] Execution context:', {
+                chainId: tx.chainId,
+                hasAdapterConnection: !!connection.connection,
+                rpcEndpoint,
+            });
             let transactionMessage;
+            let versionedTransaction;
             let blockhash;
             let lastValidBlockHeight;
+            const sendSignedViaRpc = async (txToSignAndSend) => {
+                console.log('Requesting signature...');
+                const signedTransaction = await connector.signTransaction(txToSignAndSend);
+                console.log('Transaction signed');
+                const signedTransactionBytes = signedTransaction.serialize();
+                const signedTransactionBase64 = Buffer.from(signedTransactionBytes).toString('base64');
+                console.log('Sending transaction via RPC...');
+                const sig = await rpc
+                    .sendTransaction(signedTransactionBase64, {
+                    encoding: 'base64',
+                    skipPreflight: true,
+                    preflightCommitment: 'confirmed',
+                })
+                    .send();
+                console.log('Transaction sent via RPC:', sig);
+                return sig;
+            };
             // Check if transaction has serialized data (from deBridge)
             // deBridge returns Solana transactions as serialized hex strings in tx.data
             if (tx.data && !tx.instructions && !tx.to) {
-                // Deserialize transaction from hex data
-                // Remove 0x prefix if present
+                // deBridge returns a serialized v0 transaction (often with Address Lookup Tables).
+                // Do NOT decompile here: decompilation requires ALT contents and fails for unknown tables.
                 const hexData = tx.data.replace(/^0x/, '');
                 const buffer = Buffer.from(hexData, 'hex');
-                // Decode transaction using @solana/kit
-                const decoded = getTransactionDecoder().decode(new Uint8Array(buffer));
-                // Extract blockhash from decoded transaction
-                const compiledMessage = getCompiledTransactionMessageDecoder().decode(decoded.messageBytes);
-                transactionMessage = decompileTransactionMessage(compiledMessage);
-                // Get blockhash from the decoded transaction's lifetime token
-                // In @solana/kit v5, lifetime is stored as lifetimeToken (blockhash string)
-                if ('lifetimeToken' in compiledMessage) {
-                    blockhash = compiledMessage.lifetimeToken;
-                    // For deserialized transactions, we don't have lastValidBlockHeight
-                    // We'll need to fetch it from RPC
-                    const blockhashResponse = await rpc.getLatestBlockhash({ commitment: 'finalized' }).send();
-                    lastValidBlockHeight = blockhashResponse.value.lastValidBlockHeight;
-                }
+                versionedTransaction = VersionedTransaction.deserialize(buffer);
+                blockhash = versionedTransaction.message.recentBlockhash;
+                console.log('[SolanaTx] Using serialized deBridge tx:', {
+                    dataBytes: buffer.length,
+                    recentBlockhash: blockhash,
+                    signaturesCount: versionedTransaction.signatures.length,
+                    staticAccounts: versionedTransaction.message.staticAccountKeys.length,
+                    addressTableLookups: versionedTransaction.message.addressTableLookups.length,
+                });
+                // Fetch latest lastValidBlockHeight for confirmation flow.
+                const blockhashResponse = await rpc.getLatestBlockhash({ commitment: 'finalized' }).send();
+                lastValidBlockHeight = blockhashResponse.value.lastValidBlockHeight;
             }
             else if (tx.instructions) {
                 // Transaction has instructions (from relay.link)
@@ -152,56 +176,95 @@ export function createSolanaTransactionExecutor(connector, connection) {
             else {
                 throw new Error('Solana transaction must have either instructions or serialized data');
             }
-            // Compile transaction message to get wire format
-            console.log('Compiling transaction...');
-            const compiledTransaction = compileTransaction(transactionMessage);
-            // Convert to VersionedTransaction for wallet adapter signing
-            const base64WireTransaction = getBase64EncodedWireTransaction(compiledTransaction);
-            const transactionBytes = Buffer.from(base64WireTransaction, 'base64');
-            console.log('Transaction bytes length:', transactionBytes.length);
-            // Create VersionedTransaction from wire bytes
-            const versionedTransaction = VersionedTransaction.deserialize(transactionBytes);
-            console.log('Requesting signature...');
-            // Sign transaction with wallet adapter
-            const signedTransaction = await connector.signTransaction(versionedTransaction);
-            console.log('Transaction signed');
-            // Send transaction using RPC directly (matching reference implementation pattern)
-            // Convert signed transaction to base64 for RPC
-            const signedTransactionBytes = signedTransaction.serialize();
-            const signedTransactionBase64 = Buffer.from(signedTransactionBytes).toString('base64'); // Type assertion for Base64EncodedWireTransaction
-            console.log('Sending transaction via RPC...');
-            // Use RPC sendTransaction with base64 encoding (matching reference implementation)
-            const signatureResponse = await rpc
-                .sendTransaction(signedTransactionBase64, {
-                encoding: 'base64',
-                skipPreflight: true,
-                preflightCommitment: 'confirmed',
-            })
-                .send();
-            const signatureString = signatureResponse;
-            console.log('Transaction sent:', signatureString);
-            // Wait for confirmation
-            // Use the adapter's confirmTransaction method
-            // Only confirm if we have blockhash and lastValidBlockHeight
-            let result;
-            if (blockhash && lastValidBlockHeight) {
-                console.log('Waiting for confirmation...');
-                result = await connection.confirmTransaction({
-                    signature: signatureString,
-                    blockhash,
-                    lastValidBlockHeight,
-                }, 'confirmed');
-                console.log('Transaction confirmed');
+            // Build VersionedTransaction from relay instructions path.
+            if (!versionedTransaction) {
+                if (!transactionMessage) {
+                    throw new Error('Failed to build Solana transaction message');
+                }
+                console.log('Compiling transaction...');
+                const compiledTransaction = compileTransaction(transactionMessage);
+                const base64WireTransaction = getBase64EncodedWireTransaction(compiledTransaction);
+                const transactionBytes = Buffer.from(base64WireTransaction, 'base64');
+                console.log('Transaction bytes length:', transactionBytes.length);
+                versionedTransaction = VersionedTransaction.deserialize(transactionBytes);
+                console.log('[SolanaTx] Built relay v0 tx:', {
+                    recentBlockhash: versionedTransaction.message.recentBlockhash,
+                    signaturesCount: versionedTransaction.signatures.length,
+                    staticAccounts: versionedTransaction.message.staticAccountKeys.length,
+                    addressTableLookups: versionedTransaction.message.addressTableLookups.length,
+                });
+            }
+            let signatureString;
+            // Prefer wallet-adapter broadcast path (critical for wallets like MetaMask Solana).
+            if (connection.connection) {
+                try {
+                    console.log('Sending transaction via wallet adapter...');
+                    signatureString = await connector.sendTransaction(versionedTransaction, connection.connection);
+                    console.log('Transaction sent via wallet adapter:', signatureString);
+                    // MetaMask Solana can sometimes return a signature but not propagate/broadcast.
+                    // If the signature remains unknown briefly, re-broadcast via signed raw transaction.
+                    let seenByRpc = false;
+                    for (let i = 0; i < 3; i++) {
+                        const statusResp = await rpc
+                            .getSignatureStatuses([signatureString], { searchTransactionHistory: true })
+                            .send();
+                        const status = statusResp.value?.[0];
+                        console.log('[SolanaTx] Post-adapter visibility check:', { attempt: i + 1, status: status ?? null });
+                        if (status) {
+                            seenByRpc = true;
+                            break;
+                        }
+                        await new Promise((resolve) => setTimeout(resolve, 1000));
+                    }
+                    if (!seenByRpc) {
+                        console.warn('[SolanaTx] Adapter returned signature not found on RPC. Re-broadcasting via signed RPC path.');
+                        signatureString = await sendSignedViaRpc(versionedTransaction);
+                    }
+                }
+                catch (adapterSendError) {
+                    console.warn('Wallet adapter sendTransaction failed, falling back to sign+RPC send:', adapterSendError);
+                    signatureString = await sendSignedViaRpc(versionedTransaction);
+                }
             }
             else {
-                // For transactions without blockhash info, return success
-                // The transaction will be confirmed by the network
-                console.log('No blockhash/lastValidBlockHeight, skipping confirmation');
-                result = {
-                    value: {
-                        err: null,
-                    },
-                };
+                // Fallback path when adapter connection is unavailable.
+                signatureString = await sendSignedViaRpc(versionedTransaction);
+            }
+            // Immediate visibility check: if null for long time, tx likely not propagated to this RPC yet.
+            try {
+                const immediateStatus = await rpc
+                    .getSignatureStatuses([signatureString], { searchTransactionHistory: true })
+                    .send();
+                console.log('[SolanaTx] Immediate signature status:', immediateStatus.value?.[0] ?? null);
+            }
+            catch (statusErr) {
+                console.warn('[SolanaTx] Immediate signature status check failed:', statusErr);
+            }
+            // Wait for confirmation by polling signature status from RPC.
+            // This avoids false positives from single-shot checks.
+            console.log('Waiting for confirmation...');
+            const confirmationDeadline = Date.now() + 90_000;
+            let result = { value: { err: 'timeout' } };
+            let pollAttempt = 0;
+            while (Date.now() < confirmationDeadline) {
+                pollAttempt += 1;
+                const statusResp = await rpc
+                    .getSignatureStatuses([signatureString], { searchTransactionHistory: true })
+                    .send();
+                const status = statusResp.value?.[0];
+                console.log('[SolanaTx] Confirmation poll:', {
+                    attempt: pollAttempt,
+                    status: status ?? null,
+                });
+                if (status?.err) {
+                    result = { value: { err: status.err } };
+                    break;
+                }
+                if (status?.confirmationStatus === 'confirmed' || status?.confirmationStatus === 'finalized') {
+                    result = { value: { err: null } };
+                    break;
+                }
+                await new Promise((resolve) => setTimeout(resolve, 1500));
             }
             // Check for errors
             if (result.value.err) {

package/dist/hooks/silent/tron-transaction.d.ts

@@ -0,0 +1,43 @@
+import type { BridgeTransaction } from '@silentswap/sdk';
+/**
+ * Tron wallet connector interface
+ * Compatible with Tron wallet adapters (e.g., TronLink, etc.)
+ * Tron mainnet is EVM-compatible; relay may return EVM-style tx (to, value, data).
+ */
+export interface TronWalletConnector {
+    /** Send a transaction (EVM-style: to, value, data) and return tx hash */
+    sendTransaction: (tx: BridgeTransaction) => Promise<string>;
+    getAccounts: () => Promise<string[]>;
+    currentAccount?: string | null;
+}
+/**
+ * Tron connection interface
+ * Kept for consistency with Solana/Bitcoin pattern; may not be used.
+ */
+export interface TronConnection {
+}
+/**
+ * Tron transaction executor type
+ * Similar to BitcoinTransactionExecutor but for Tron (EVM-style or native).
+ */
+export type TronTransactionExecutor = (tx: BridgeTransaction) => Promise<string>;
+/**
+ * Create a Tron transaction executor.
+ * Handles Tron transactions from relay.link bridge quotes (EVM-style to/value/data).
+ *
+ * @param connector - Tron wallet connector
+ * @param _connection - Tron connection (optional, for consistency)
+ * @returns Tron transaction executor function
+ */
+export declare function createTronTransactionExecutor(connector: TronWalletConnector, _connection?: TronConnection): TronTransactionExecutor;
+/**
+ * Helper to convert relay.link Tron step data to BridgeTransaction.
+ * Relay may return EVM-style fields (chainId, to, value, data) for Tron.
+ */
+export declare function convertRelayTronStepToTransaction(stepData: {
+    chainId?: number;
+    to?: string;
+    value?: string;
+    data?: string;
+    gas?: string;
+}, chainId?: number): BridgeTransaction;

package/dist/hooks/silent/tron-transaction.js

@@ -0,0 +1,40 @@
+import { N_RELAY_CHAIN_ID_TRON } from '@silentswap/sdk';
+/**
+ * Create a Tron transaction executor.
+ * Handles Tron transactions from relay.link bridge quotes (EVM-style to/value/data).
+ *
+ * @param connector - Tron wallet connector
+ * @param _connection - Tron connection (optional, for consistency)
+ * @returns Tron transaction executor function
+ */
+export function createTronTransactionExecutor(connector, _connection) {
+    return async (tx) => {
+        if (!connector.currentAccount) {
+            const accounts = await connector.getAccounts();
+            if (!accounts || accounts.length === 0) {
+                throw new Error('Tron wallet not connected');
+            }
+        }
+        const txHash = await connector.sendTransaction(tx);
+        if (!txHash || typeof txHash !== 'string' || txHash.trim().length === 0) {
+            throw new Error('Tron transaction was not broadcast successfully. The wallet returned an empty transaction ID.');
+        }
+        return txHash;
+    };
+}
+/**
+ * Helper to convert relay.link Tron step data to BridgeTransaction.
+ * Relay may return EVM-style fields (chainId, to, value, data) for Tron.
+ */
+export function convertRelayTronStepToTransaction(stepData, chainId = N_RELAY_CHAIN_ID_TRON) {
+    if (!stepData.to || stepData.data === undefined) {
+        throw new Error('Tron transaction step must have to and data fields');
+    }
+    return {
+        chainId,
+        to: stepData.to,
+        value: stepData.value ?? '0',
+        data: stepData.data,
+        gasLimit: stepData.gas,
+    };
+}

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

@@ -32,6 +32,8 @@ export interface UseQuoteCalculationOptions {
     setDestinations: (updater: Destination[] | ((prev: Destination[]) => Destination[])) => void;
     /** Pro user ID for volume tracking (sent with quote request) */
     proId?: string;
+    /** Optional: force a single bridge provider for testing. */
+    forceBridgeProvider?: 'relay' | 'debridge';
 }
 export interface UseQuoteCalculationReturn {
     /** Calculate quote and return result */
@@ -51,4 +53,4 @@ export interface UseQuoteCalculationReturn {
  * - Quote request construction and fetching
  * - Destination amount updates
  */
-export declare function useQuoteCalculation({ address, evmAddress, wallet, depositorAddress, getQuote, getPrice, setDestinations, proId, }: UseQuoteCalculationOptions): UseQuoteCalculationReturn;
+export declare function useQuoteCalculation({ address, evmAddress, wallet, depositorAddress, getQuote, getPrice, setDestinations, proId, forceBridgeProvider, }: UseQuoteCalculationOptions): UseQuoteCalculationReturn;

package/dist/hooks/silent/useQuoteCalculation.js

@@ -13,7 +13,7 @@ import { BigNumber } from 'bignumber.js';
  * - Destination amount updates
  */
 // TODO: Simplify this hook by removing the useCallback and useState and just returning the calculateQuote function.
-export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddress, getQuote, getPrice, setDestinations, proId, }) {
+export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddress, getQuote, getPrice, setDestinations, proId, forceBridgeProvider, }) {
     const [loadingAmounts, setLoadingAmounts] = useState(false);
     const [depositAmountUsdc, setDepositAmountUsdc] = useState(0);
     const calculateQuote = useCallback(async (debouncedSourceAsset, debouncedSourceAmount, destinations, splits) => {
@@ -87,7 +87,7 @@ export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddr
                     decimals: assetInfo.decimals,
                     precision: assetInfo.precision,
                 });
-                const solveResult = await solveOptimalUsdcAmount(N_RELAY_CHAIN_ID_SOLANA, originCurrency, sourceAmountInUnitsForQuote, solanaAddress, undefined, X_MAX_IMPACT_PERCENT, depositorAddress, getAddress(evmAddress));
+                const solveResult = await solveOptimalUsdcAmount(N_RELAY_CHAIN_ID_SOLANA, originCurrency, sourceAmountInUnitsForQuote, solanaAddress, undefined, X_MAX_IMPACT_PERCENT, depositorAddress, getAddress(evmAddress), forceBridgeProvider);
                 if (abortController.signal.aborted) {
                     setLoadingAmounts(false);
                     return null;
@@ -121,7 +121,8 @@ export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddr
                 // to stay within the source balance (matches Svelte's relay_solve_uusdc_amount)
                 const solveResult = await solveOptimalUsdcAmount(N_RELAY_CHAIN_ID_BITCOIN, SBTC_ADDR_BITCOIN_NATIVE, sourceAmountInUnitsForQuote, bitcoinAddress, // Bitcoin address for relay 'user' parameter
                 undefined, // depositCalldata - will use phony
-                X_MAX_IMPACT_PERCENT, depositorAddress, getAddress(evmAddress));
+                X_MAX_IMPACT_PERCENT, depositorAddress, getAddress(evmAddress), // EVM address for deposit calldata & recipient
+                forceBridgeProvider);
                 if (abortController.signal.aborted) {
                     setLoadingAmounts(false);
                     return null;
@@ -143,7 +144,8 @@ export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddr
                 const sourceAmountBN = BigNumber(debouncedSourceAmount);
                 const sourceAmountInUnits = sourceAmountBN.shiftedBy(assetInfo.decimals).toFixed(0);
                 const solveResult = await solveOptimalUsdcAmount(srcChainId, srcToken, sourceAmountInUnits, address, undefined, // depositCalldata
-                X_MAX_IMPACT_PERCENT, depositorAddress);
+                X_MAX_IMPACT_PERCENT, depositorAddress, // Required depositor address
+                undefined, forceBridgeProvider);
                 if (abortController.signal.aborted) {
                     setLoadingAmounts(false);
                     return null;

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

@@ -64,6 +64,8 @@ export interface useSilentQuoteOptions {
     setDestinations: (updater: Destination[] | ((prev: Destination[]) => Destination[])) => void;
     /** Pro user ID for volume tracking (sent with quote request, matching Svelte's AppState.proId) */
     proId?: string;
+    /** Optional: force a single bridge provider for testing. */
+    forceBridgeProvider?: 'relay' | 'debridge';
 }
 /**
  * Return type for useSilentQuote hook
@@ -99,4 +101,4 @@ export interface ExecuteSwapParams {
     /** Optional integrator ID for tracking */
     integratorId?: string;
 }
-export declare function useSilentQuote({ client, address, evmAddress, solAddress, walletClient, connector, wallet, walletLoading, walletError, generateWallet, requestWalletConnect, onStatus, solanaConnector, solanaConnection, solanaRpcUrl, bitcoinConnector, bitcoinConnection, getPrice, setDestinations, proId, }: useSilentQuoteOptions): useSilentQuoteReturn;
+export declare function useSilentQuote({ client, address, evmAddress, solAddress, walletClient, connector, wallet, walletLoading, walletError, generateWallet, requestWalletConnect, onStatus, solanaConnector, solanaConnection, solanaRpcUrl, bitcoinConnector, bitcoinConnection, getPrice, setDestinations, proId, forceBridgeProvider, }: useSilentQuoteOptions): useSilentQuoteReturn;

package/dist/hooks/silent/useSilentQuote.js

@@ -6,7 +6,7 @@ import { useOrderSigning } from './useOrderSigning.js';
 import { APPROVE_POST_DELAY_MS, 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, walletError = null, generateWallet, requestWalletConnect, onStatus, solanaConnector, solanaConnection, solanaRpcUrl, bitcoinConnector, bitcoinConnection, getPrice, setDestinations, proId, }) {
+export function useSilentQuote({ client, address, evmAddress, solAddress, walletClient, connector, wallet, walletLoading = false, walletError = null, generateWallet, requestWalletConnect, onStatus, solanaConnector, solanaConnection, solanaRpcUrl, bitcoinConnector, bitcoinConnection, getPrice, setDestinations, proId, forceBridgeProvider, }) {
     const [isLoading, setIsLoading] = useState(false);
     const [currentStep, setCurrentStep] = useState('');
     const [quote, setQuote] = useState(null);
@@ -86,6 +86,7 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
         getPrice,
         setDestinations,
         proId,
+        forceBridgeProvider,
     });
     /**
      * Execute the complete swap flow

package/dist/hooks/useQuote.js

@@ -320,9 +320,9 @@ export function useQuote({ address, maxImpactPercent = X_MAX_IMPACT_PERCENT, for
                         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
+                        // Skip DeBridge for Bitcoin only
+                        if (isBitcoinAsset(assetCaip19)) {
+                            return null; // Skip DeBridge for Bitcoin, will use Relay.link only
                         }
                         // For reverse calculation ingress: use srcChainTokenInAmount: 'auto' and specify dstChainTokenOutAmount
                         const debridgeParams = {
@@ -330,6 +330,8 @@ export function useQuote({ address, maxImpactPercent = X_MAX_IMPACT_PERCENT, for
                             srcChainTokenIn: tokenAddress === ZERO_ADDRESS ? ZERO_ADDRESS : tokenAddress,
                             dstChainId: NI_CHAIN_ID_AVALANCHE,
                             dstChainTokenOut: S0X_ADDR_USDC_AVALANCHE,
+                            prependOperatingExpenses: true,
+                            additionalTakerRewardBps: 0,
                         };
                         if (isReverseCalculation && direction === 'ingress' && targetAmount) {
                             // For reverse ingress: specify destination amount, let DeBridge calculate source
@@ -349,6 +351,15 @@ export function useQuote({ address, maxImpactPercent = X_MAX_IMPACT_PERCENT, for
                             debridgeParams.srcChainTokenInAmount = tokenAmount;
                             debridgeParams.dstChainTokenOutAmount = 'auto';
                         }
+                        // Solana source requires Solana-format authority fields and estimate disabled.
+                        if (isSolanaChain) {
+                            debridgeParams.enableEstimate = false;
+                            debridgeParams.account = normalizedAddress;
+                            debridgeParams.srcChainOrderAuthorityAddress = normalizedAddress;
+                            debridgeParams.srcChainRefundAddress = normalizedAddress;
+                            debridgeParams.dstChainTokenOutRecipient = EVM_PHONY_ADDRESS;
+                            debridgeParams.dstChainOrderAuthorityAddress = EVM_PHONY_ADDRESS;
+                        }
                         const quote = await fetchDebridgeOrder(debridgeParams, signal);
                         return quote;
                     }

package/dist/hooks/useTransaction.js

@@ -3,6 +3,7 @@ import { erc20Abi } from 'viem';
 import { executeRelayBridge, executeDebridgeBridge, getBridgeStatus, createTransactionExecutor, createChainSwitcher, ensureChain, waitForTransactionConfirmation, parseTransactionRequestForViem, createPublicClientWithRpc, getChainById, } from '@silentswap/sdk';
 import { createSolanaTransactionExecutor } from './silent/solana-transaction.js';
 import { createBitcoinTransactionExecutor, convertRelayBitcoinStepToTransaction } from './silent/bitcoin-transaction.js';
+import { N_DEBRIDGE_CHAIN_ID_SOLANA } from '@silentswap/sdk';
 import { N_RELAY_CHAIN_ID_BITCOIN } from '@silentswap/sdk';
 /**
  * React hook for executing transactions
@@ -105,8 +106,8 @@ export function useTransaction({ walletClient, connector, solanaConnector, solan
             return false;
         });
         const hasBitcoinTransactions = hasBitcoinInTxs || hasBitcoinInRoute;
-        // Check if quote contains Solana transactions
-        const hasSolanaTransactions = quote.txs.some((tx) => tx.instructions !== undefined);
+        // Check if quote contains Solana transactions (relay instructions or deBridge serialized tx)
+        const hasSolanaTransactions = quote.txs.some((tx) => tx.instructions !== undefined || tx.chainId === N_DEBRIDGE_CHAIN_ID_SOLANA);
         if (hasBitcoinTransactions) {
             // Bitcoin transactions require Bitcoin connector
             if (!bitcoinConnector) {
@@ -218,8 +219,10 @@ export function useTransaction({ walletClient, connector, solanaConnector, solan
                             onStatus?.(step);
                         });
                     case 'debridge':
-                        // DeBridge doesn't support Solana
-                        throw new Error('DeBridge does not support Solana transactions');
+                        return await executeDebridgeBridge(quote, executeTx, switchChain, (step) => {
+                            setCurrentStep(step);
+                            onStatus?.(step);
+                        });
                     default:
                         throw new Error(`Unsupported bridge provider: ${quote.provider}`);
                 }
@@ -421,7 +424,7 @@ export function useTransaction({ walletClient, connector, solanaConnector, solan
         catch (err) {
             const error = err instanceof Error ? err : new Error('Failed to get bridge status');
             setError(error);
-            return null;
+            throw error;
         }
         finally {
             setIsLoading(false);

package/dist/isTronAssetCaip19.d.ts

@@ -0,0 +1 @@
+export declare function isTronAssetCaip19(caip19: string): boolean;

package/dist/isTronAssetCaip19.js

@@ -0,0 +1,3 @@
+export function isTronAssetCaip19(caip19) {
+    return caip19.startsWith('tron:');
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@silentswap/react",
   "type": "module",
-  "version": "0.0.91",
+  "version": "0.0.92",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,8 +24,8 @@
   "dependencies": {
     "@bigmi/core": "^0.6.5",
     "@ensdomains/ensjs": "^4.2.0",
-    "@silentswap/sdk": "0.0.91",
-    "@silentswap/ui-kit": "0.0.91",
+    "@silentswap/sdk": "0.0.92",
+    "@silentswap/ui-kit": "0.0.92",
     "@solana/codecs-strings": "^5.1.0",
     "@solana/kit": "^5.1.0",
     "@solana/rpc": "^5.1.0",