@silentswap/react 0.0.89 → 0.0.91

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

@@ -58,6 +58,28 @@ export function createBitcoinTransactionExecutor(connector, _connection) {
             // Send signed PSBT (wallet returns base64)
             const txHash = await connector.sendPsbt(signedPsbt);
             console.log('Bitcoin transaction sent:', txHash);
+            // Validate broadcast result — some wallets (e.g. Keplr) resolve even
+            // when the mempool rejects the tx (e.g. insufficient fee / RBF error).
+            // Without this check the code would continue to bridge monitoring and
+            // show "Waiting for bridge" indefinitely.
+            if (!txHash || typeof txHash !== 'string' || txHash.trim().length === 0) {
+                throw new Error('Bitcoin transaction was not broadcast successfully. The wallet returned an empty transaction ID. Please try again.');
+            }
+            // Brief delay then verify the transaction is actually in the mempool
+            await new Promise((resolve) => setTimeout(resolve, 3000));
+            try {
+                const res = await fetch(`https://mempool.space/api/tx/${txHash}`);
+                if (!res.ok) {
+                    throw new Error('not found');
+                }
+            }
+            catch {
+                // Transaction not found — likely rejected by the mempool
+                // (e.g. RBF feerate too low, dust output, etc.)
+                throw new Error(`Bitcoin transaction ${txHash} was not accepted by the network. ` +
+                    'This usually means the fee rate is too low or there is a conflicting unconfirmed transaction. ' +
+                    'Please wait for the previous transaction to confirm and try again.');
+            }
             return txHash;
         }
         catch (error) {

package/dist/hooks/silent/useBridgeExecution.js

@@ -241,17 +241,22 @@ export function useBridgeExecution(walletClient, connector, solanaConnector, sol
             }
             // Get relay origin asset parameters
             const { originChainId, originCurrency } = getRelayOriginAssetFromCaip19(sourceAsset);
-            // CRITICAL: In Svelte, solve_uusdc_amount is called ONCE before order creation,
-            // and the result (usdcAmount) is used directly in bridge execution.
-            // We should NEVER solve again here - the usdcAmount must be provided
-            // from the initial solve in handleGetQuote (matching Svelte Form.svelte line 2535 and 2576-2584).
+            console.log('[SilentSwap:SolanaBridge] Start', {
+                sourceAsset,
+                sourceAmount,
+                usdcAmount,
+                solanaSenderAddress,
+                evmSignerAddress,
+                originChainId,
+                originCurrency,
+                depositorAddress,
+                hasDepositParams: !!depositParams,
+            });
             if (!usdcAmount) {
                 throw new Error('USDC amount is required for Solana bridge execution. ' +
                     'It should be provided from the initial solveOptimalUsdcAmount call in handleGetQuote. ' +
                     'This matches Svelte behavior where solve_uusdc_amount is called once before order creation.');
             }
-            // Use the provided usdcAmount directly (matches Svelte behavior)
-            // In Svelte: zg_amount_src_usdc is used directly without re-solving
             const bridgeUsdcAmount = usdcAmount;
             setCurrentStep('Fetching bridge quote');
             onStatus?.('Fetching bridge quote');
@@ -292,35 +297,56 @@ export function useBridgeExecution(walletClient, connector, solanaConnector, sol
                 console.warn('DepositParams not provided, using phony calldata for bridge quote');
                 depositCalldataForExecution = createPhonyDepositCalldata(evmSignerAddress);
             }
-            // Request bridge quote for Solana → USDC Avalanche using EXACT_OUTPUT (matches Svelte line 1302-1323)
-            // CRITICAL: For execution, we must use EXACT_OUTPUT with txs parameter, not getBridgeQuote
-            // getBridgeQuote uses EXACT_INPUT and doesn't support txs parameter for execution
-            const relayQuote = await fetchRelayQuote({
-                user: solanaSenderAddress, // Solana address (matches Svelte line 1303: user: sb58_pk_sender)
-                originChainId, // Matches Svelte line 1304: ...relay_origin_asset(k_asset_src)
-                originCurrency, // Matches Svelte line 1304: ...relay_origin_asset(k_asset_src)
-                destinationChainId: NI_CHAIN_ID_AVALANCHE, // Matches Svelte line 1305
-                destinationCurrency: S0X_ADDR_USDC_AVALANCHE, // Matches Svelte line 1306
-                amount: bridgeUsdcAmount, // USDC amount in micro units (EXACT_OUTPUT target) - matches Svelte line 1307
-                recipient: depositorAddress, // EVM depositor address (matches Svelte line 1308: recipient: S0X_ADDR_DEPOSITOR)
-                tradeType: 'EXACT_OUTPUT', // CRITICAL: Must use EXACT_OUTPUT for execution (matches Svelte line 1309)
-                txsGasLimit: 600_000, // Matches Svelte line 1310
+            const relayQuoteRequest = {
+                user: solanaSenderAddress,
+                originChainId,
+                originCurrency,
+                destinationChainId: NI_CHAIN_ID_AVALANCHE,
+                destinationCurrency: S0X_ADDR_USDC_AVALANCHE,
+                amount: bridgeUsdcAmount,
+                recipient: depositorAddress,
+                tradeType: 'EXACT_OUTPUT',
+                txsGasLimit: 600_000,
                 txs: [
                     {
-                        to: S0X_ADDR_USDC_AVALANCHE, // Matches Svelte line 1313
-                        value: '0', // Matches Svelte line 1314
-                        data: approveUsdcCalldata, // USDC approval calldata (matches Svelte line 1315)
+                        to: S0X_ADDR_USDC_AVALANCHE,
+                        value: '0',
+                        data: approveUsdcCalldata,
                     },
                     {
-                        to: depositorAddress, // Matches Svelte line 1318: to: S0X_ADDR_DEPOSITOR
-                        value: '0', // Matches Svelte line 1319
-                        data: depositCalldataForExecution, // Deposit calldata (matches Svelte line 1320)
+                        to: depositorAddress,
+                        value: '0',
+                        data: depositCalldataForExecution,
                     },
                 ],
+            };
+            console.log('[SilentSwap:SolanaBridge] Relay quote request (EXACT_OUTPUT)', {
+                user: relayQuoteRequest.user,
+                originChainId: relayQuoteRequest.originChainId,
+                originCurrency: relayQuoteRequest.originCurrency,
+                destinationChainId: relayQuoteRequest.destinationChainId,
+                amount: relayQuoteRequest.amount,
+                recipient: relayQuoteRequest.recipient,
+                tradeType: relayQuoteRequest.tradeType,
+                txsCount: relayQuoteRequest.txs.length,
+                depositCalldataLength: depositCalldataForExecution.length,
             });
-            // Check price impact (matches Svelte line 1343-1348)
+            const relayQuote = await fetchRelayQuote(relayQuoteRequest);
+            console.log('[SilentSwap:SolanaBridge] Relay quote response', {
+                currencyIn: relayQuote.details?.currencyIn ? {
+                    amount: relayQuote.details.currencyIn.amount,
+                    amountUsd: relayQuote.details.currencyIn.amountUsd,
+                } : 'N/A',
+                currencyOut: relayQuote.details?.currencyOut ? {
+                    amount: relayQuote.details.currencyOut.amount,
+                    amountUsd: relayQuote.details.currencyOut.amountUsd,
+                } : 'N/A',
+                totalImpact: relayQuote.details?.totalImpact,
+                stepsCount: relayQuote.steps?.length,
+                stepIds: relayQuote.steps?.map((s) => s.id),
+            });
+            // Check price impact
             const impactPercent = Number(relayQuote.details.totalImpact.percent);
-            // TODO: check negative impact
             if (impactPercent > X_MAX_IMPACT_PERCENT) {
                 throw new Error(`Price impact across bridge too high: ${impactPercent.toFixed(2)}%`);
             }
@@ -337,7 +363,14 @@ export function useBridgeExecution(walletClient, connector, solanaConnector, sol
                     throw new Error('No steps in relay quote response');
                 }
                 // Execute each step from relay.link
-                for (const step of relayQuote.steps) {
+                for (let stepIdx = 0; stepIdx < relayQuote.steps.length; stepIdx++) {
+                    const step = relayQuote.steps[stepIdx];
+                    console.log(`[SilentSwap:SolanaBridge] Step ${stepIdx + 1}/${relayQuote.steps.length}`, {
+                        id: step.id,
+                        kind: step.kind,
+                        itemsCount: step.items?.length,
+                        requestId: step.requestId,
+                    });
                     if (step.kind !== 'transaction') {
                         throw new Error(`Unsupported relay step kind: ${step.kind}`);
                     }
@@ -348,20 +381,34 @@ export function useBridgeExecution(walletClient, connector, solanaConnector, sol
                     const itemData = item.data;
                     // Solana transaction
                     if ('instructions' in itemData) {
-                        setCurrentStep(step.id === 'approve'
+                        const stepLabel = step.id === 'approve'
                             ? 'Requesting approval...'
                             : step.id === 'deposit'
                                 ? 'Requesting deposit...'
-                                : 'Requesting bridge...');
-                        onStatus?.(step.id === 'approve'
-                            ? 'Requesting approval...'
-                            : step.id === 'deposit'
-                                ? 'Requesting deposit...'
-                                : 'Requesting bridge...');
+                                : 'Requesting bridge...';
+                        setCurrentStep(stepLabel);
+                        onStatus?.(stepLabel);
+                        console.log(`[SilentSwap:SolanaBridge] Executing Solana tx: ${step.id}`, {
+                            instructionsCount: itemData.instructions?.length,
+                            feePayer: solanaSenderAddress,
+                        });
                         // Convert relay step to BridgeTransaction
                         const solanaTx = convertRelaySolanaStepToTransaction(itemData, solanaSenderAddress, N_RELAY_CHAIN_ID_SOLANA);
                         // Execute Solana transaction
-                        await solanaExecutor(solanaTx);
+                        try {
+                            await solanaExecutor(solanaTx);
+                            console.log(`[SilentSwap:SolanaBridge] Step ${step.id} succeeded`);
+                        }
+                        catch (txError) {
+                            console.error(`[SilentSwap:SolanaBridge] Step ${step.id} FAILED`, {
+                                error: txError instanceof Error ? txError.message : String(txError),
+                                stack: txError instanceof Error ? txError.stack : undefined,
+                            });
+                            throw txError;
+                        }
+                    }
+                    else {
+                        console.warn(`[SilentSwap:SolanaBridge] Step ${step.id} has no instructions, skipping`);
                     }
                 }
                 // Find request ID for status monitoring

package/dist/hooks/silent/useQuoteCalculation.js

@@ -1,5 +1,5 @@
 import { useCallback, useState } from 'react';
-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, caip19FungibleEvmToken, FacilitatorKeyType, createHdFacilitatorGroupFromEntropy, PublicKeyArgGroups, SB58_CHAIN_ID_SOLANA_MAINNET, caip19SplToken, DeliveryMethod, X_MAX_IMPACT_PERCENT, NI_CHAIN_ID_AVALANCHE, SBTC_ADDR_BITCOIN_NATIVE, isEvmAsset, } from '@silentswap/sdk';
+import { isSolanaAsset, isBitcoinAsset, parseEvmCaip19, S_CAIP19_USDC_AVALANCHE, getAssetByCaip19, solveOptimalUsdcAmount, 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, caip19FungibleEvmToken, FacilitatorKeyType, createHdFacilitatorGroupFromEntropy, PublicKeyArgGroups, SB58_CHAIN_ID_SOLANA_MAINNET, caip19SplToken, DeliveryMethod, X_MAX_IMPACT_PERCENT, SBTC_ADDR_BITCOIN_NATIVE, isEvmAsset, } from '@silentswap/sdk';
 import { getAddress } from 'viem';
 import { BigNumber } from 'bignumber.js';
 /**
@@ -34,6 +34,15 @@ export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddr
             let sourceAmountInUnitsForQuote;
             let bridgeProviderResult = 'none';
             let allowanceTargetResult = undefined;
+            console.log('[SilentSwap:QuoteCalc] Starting quote calculation', {
+                sourceAsset: debouncedSourceAsset,
+                sourceAmount: debouncedSourceAmount,
+                isSourceUsdcAvalanche,
+                isSourceSolana,
+                isSourceBitcoin,
+                destinationsCount: destinations.length,
+                splits,
+            });
             if (isSourceUsdcAvalanche) {
                 const assetInfo = getAssetByCaip19(S_CAIP19_USDC_AVALANCHE);
                 if (!assetInfo)
@@ -41,31 +50,26 @@ export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddr
                 const sourceAmountBN = BigNumber(debouncedSourceAmount);
                 sourceAmountInUnitsForQuote = sourceAmountBN.shiftedBy(assetInfo.decimals).toFixed(0);
                 usdcAmountOut = sourceAmountInUnitsForQuote;
+                console.log('[SilentSwap:QuoteCalc] Direct USDC deposit', {
+                    sourceAmountInUnits: sourceAmountInUnitsForQuote,
+                    usdcAmountOut,
+                });
             }
             else if (isSourceSolana) {
-                // Solana assets - use relay.link only (not deBridge)
                 const assetInfo = getAssetByCaip19(debouncedSourceAsset);
                 if (!assetInfo)
                     throw new Error(`Solana asset not found`);
                 const sourceAmountBN = BigNumber(debouncedSourceAmount);
                 sourceAmountInUnitsForQuote = sourceAmountBN.shiftedBy(assetInfo.decimals).toFixed(0);
-                const sourceAmountInUnits = sourceAmountInUnitsForQuote;
-                // Parse Solana CAIP-19 to get chain ID and token address
                 const solanaParsed = parseSolanaCaip19(debouncedSourceAsset);
                 if (!solanaParsed)
                     throw new Error(`Invalid Solana CAIP-19 format: ${debouncedSourceAsset}`);
-                // Determine origin currency: system program for native SOL, token address for SPL tokens
-                // This matches relay_origin_asset() from silentswap-v2-ui/src/services/relay-link.ts
                 const originCurrency = isSolanaNativeToken(debouncedSourceAsset)
                     ? SB58_ADDR_SOL_PROGRAM_SYSTEM
                     : solanaParsed.tokenAddress ||
                         (() => {
                             throw new Error(`Missing token address for Solana asset: ${debouncedSourceAsset}`);
                         })();
-                // For Solana swaps, we need:
-                // - Solana address for the 'user' parameter in relay quote (matches Svelte line 121: user: s_addr_sender)
-                // - EVM address for the 'recipient' parameter (matches Svelte line 122: recipient: s0x_signer)
-                // - EVM address for deposit calldata (matches Svelte line 156: signer: s0x_signer)
                 if (!evmAddress) {
                     throw new Error('EVM address required for Solana swaps (needed for deposit calldata and recipient)');
                 }
@@ -73,71 +77,58 @@ export function useQuoteCalculation({ address, evmAddress, wallet, depositorAddr
                 if (!solanaAddress) {
                     throw new Error('Solana address required for Solana swaps');
                 }
-                // 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);
+                console.log('[SilentSwap:QuoteCalc] Solana → solveOptimalUsdcAmount', {
+                    chainId: N_RELAY_CHAIN_ID_SOLANA,
+                    originCurrency,
+                    sourceAmountInUnits: sourceAmountInUnitsForQuote,
+                    solanaAddress,
+                    evmAddress,
+                    depositorAddress,
+                    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));
                 if (abortController.signal.aborted) {
                     setLoadingAmounts(false);
                     return null;
                 }
-                // 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
-                // sourceAmountInUnitsForQuote already set above for Solana
+                usdcAmountOut = solveResult.usdcAmountOut.toString();
+                bridgeProviderResult = solveResult.provider;
+                allowanceTargetResult = solveResult.allowanceTarget;
+                console.log('[SilentSwap:QuoteCalc] Solana solve result', {
+                    usdcAmountOut,
+                    provider: bridgeProviderResult,
+                    allowanceTarget: allowanceTargetResult,
+                });
             }
             else if (isSourceBitcoin) {
-                // Bitcoin assets - only relay.link supports Bitcoin
+                // Bitcoin assets - use solveOptimalUsdcAmount for iterative EXACT_OUTPUT fitting
+                // (same issue as Solana: naive EXACT_INPUT amount causes simulation revert
+                // when used with EXACT_OUTPUT during execution due to slippage buffer)
                 const assetInfo = getAssetByCaip19(debouncedSourceAsset);
                 if (!assetInfo)
                     throw new Error(`Bitcoin asset not found`);
                 const sourceAmountBN = BigNumber(debouncedSourceAmount);
                 sourceAmountInUnitsForQuote = sourceAmountBN.shiftedBy(assetInfo.decimals).toFixed(0);
-                const sourceAmountInUnits = sourceAmountInUnitsForQuote;
-                // 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);
+                // Use solveOptimalUsdcAmount which iteratively fits EXACT_OUTPUT amount
+                // 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));
                 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
-                // sourceAmountInUnitsForQuote already set above for Bitcoin
+                usdcAmountOut = solveResult.usdcAmountOut.toString();
+                bridgeProviderResult = solveResult.provider;
+                allowanceTargetResult = solveResult.allowanceTarget;
             }
             else {
                 // EVM assets

package/dist/hooks/silent/useSilentQuote.js

@@ -196,21 +196,32 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
             setIsSwapping(true);
             setCurrentStep('Fetching quote...');
             onStatus?.('Fetching quote...');
+            console.log('[SilentSwap:ExecuteSwap] Starting executeSwap', {
+                sourceAsset,
+                sourceAmount,
+                destinationsCount: destinations.length,
+                splits,
+                senderContactId,
+                integratorId,
+            });
             const quoteResult = await calculateQuote(sourceAsset, sourceAmount, destinations, splits);
             if (!quoteResult) {
-                // Ensure loadingAmounts is reset if handleGetQuote failed
                 throw new Error('Failed to get quote');
             }
             const { quote: quoteResponse, usdcAmount: effectiveUsdcAmount, sourceAmountInUnits, facilitatorGroup: passedFacilitatorGroup, bridgeProvider: effectiveProvider, allowanceTarget: effectiveAllowanceTarget, } = quoteResult;
+            console.log('[SilentSwap:ExecuteSwap] Quote result', {
+                usdcAmount: effectiveUsdcAmount,
+                sourceAmountInUnits,
+                provider: effectiveProvider,
+                allowanceTarget: effectiveAllowanceTarget,
+                authorizationsCount: quoteResponse.authorizations?.length,
+            });
             setCurrentStep('Executing swap...');
             onStatus?.('Executing swap...');
-            // Use the exact source amount in units from the quote result so order and deposit
-            // always match what was requested (avoids rounding/precision mismatch)
             // Determine provider for bridge swap
             const isDirectDeposit = sourceAsset === S_CAIP19_USDC_AVALANCHE;
             let providerForSwap = undefined;
             if (effectiveUsdcAmount && !isDirectDeposit) {
-                // When usdcAmount is provided and not direct deposit, we're doing a bridge swap and MUST have a provider
                 if (effectiveProvider === 'relay' || effectiveProvider === 'debridge') {
                     providerForSwap = effectiveProvider;
                 }
@@ -243,9 +254,15 @@ export function useSilentQuote({ client, address, evmAddress, solAddress, wallet
             const evmSignerAddress = getAddress(evmAddress); // Use user's wallet address, not facilitator group's viewer EVM signer
             // Handle Solana swaps
             if (isSourceSolana) {
-                const result = await executeSolanaSwap(quoteResponse, sourceAsset, sourceAmountInUnits, effectiveUsdcAmount, senderContactId, solanaConnector, evmSignerAddress, // Use EVM signer address, not normalizedAddress
-                viewingAuth, createOrder, executeSolanaBridge, resolvedGroup, // Pass resolved group for order creation
-                integratorId);
+                console.log('[SilentSwap:ExecuteSwap] Entering Solana swap path', {
+                    sourceAsset,
+                    sourceAmountInUnits,
+                    usdcAmount: effectiveUsdcAmount,
+                    evmSignerAddress,
+                    viewingAuth,
+                    provider: providerForSwap,
+                });
+                const result = await executeSolanaSwap(quoteResponse, sourceAsset, sourceAmountInUnits, effectiveUsdcAmount, senderContactId, solanaConnector, evmSignerAddress, viewingAuth, createOrder, executeSolanaBridge, resolvedGroup, integratorId);
                 setOrderId(result.orderId);
                 setViewingAuth(result.viewingAuth);
                 return result;
@@ -398,11 +415,20 @@ viewingAuth, createOrder, executeSolanaBridge, facilitatorGroup, integratorId) {
     if (!solanaSenderAddress) {
         throw new Error('Failed to get Solana sender address');
     }
+    console.log('[SilentSwap:SolanaSwap] Creating order', {
+        sourceAsset,
+        sourceAmount,
+        sourceAmountBigInt: `${BigInt(sourceAmount)}`,
+        senderContactId,
+        solanaSenderAddress,
+        evmSignerAddress,
+        usdcAmount,
+        authorizationsCount: quoteResponse.authorizations?.length,
+    });
     // Create order with empty authorizations (Solana 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 Solana
+        signature: '0x',
     })), {
         sourceAsset: {
             caip19: sourceAsset,
@@ -413,18 +439,31 @@ viewingAuth, createOrder, executeSolanaBridge, facilitatorGroup, integratorId) {
         },
         ...(integratorId && { integratorId }),
     }, facilitatorGroup);
+    console.log('[SilentSwap:SolanaSwap] Order created', {
+        orderId: orderResponse.response?.orderId,
+        hasTransaction: !!orderResponse.transaction,
+        hasMetadata: !!orderResponse.transaction?.metadata,
+        hasParams: !!orderResponse.transaction?.metadata?.params,
+    });
     // Get deposit parameters from order
     const depositParams = orderResponse.transaction.metadata?.params;
     if (!depositParams) {
         throw new Error('Missing deposit parameters in order response');
     }
+    console.log('[SilentSwap:SolanaSwap] Executing bridge', {
+        sourceAsset,
+        sourceAmount,
+        usdcAmount,
+        solanaSenderAddress,
+        evmSignerAddress,
+        depositParamsKeys: Object.keys(depositParams),
+    });
     // Execute bridge transaction
-    // Use EVM signer address for deposit calldata (matches Svelte's s0x_signer)
-    // Pass depositParams so executeSolanaBridge can encode the actual deposit calldata
-    // Use usdcAmount from solveOptimalUsdcAmount (matches Svelte: zg_amount_src_usdc is passed directly)
-    const bridgeResult = await executeSolanaBridge(sourceAsset, sourceAmount, usdcAmount, // Use amount from solveOptimalUsdcAmount (matches Svelte line 1028)
-    solanaSenderAddress, evmSignerAddress, // Use EVM signer address, not normalizedAddress
-    depositParams);
+    const bridgeResult = await executeSolanaBridge(sourceAsset, sourceAmount, usdcAmount, solanaSenderAddress, evmSignerAddress, depositParams);
+    console.log('[SilentSwap:SolanaSwap] Bridge result', {
+        depositTxHash: bridgeResult.depositTxHash,
+        provider: bridgeResult.provider,
+    });
     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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@silentswap/react",
   "type": "module",
-  "version": "0.0.89",
+  "version": "0.0.91",
   "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.89",
-    "@silentswap/ui-kit": "0.0.89",
+    "@silentswap/sdk": "0.0.91",
+    "@silentswap/ui-kit": "0.0.91",
     "@solana/codecs-strings": "^5.1.0",
     "@solana/kit": "^5.1.0",
     "@solana/rpc": "^5.1.0",