@silentswap/react 0.0.88 → 0.0.90

package/dist/contexts/SilentSwapContext.js

@@ -110,7 +110,7 @@ function SilentSwapInnerProvider({ children, client, evmAddress, solAddress, bit
     const transactionAddress = useTransactionAddress(tokenIn, evmAddress, solAddress, bitcoinAddress);
     const effectiveQuoteAddress = transactionAddress;
     const { getPrice } = usePrices();
-    const { serviceFeeRate, overheadUsd, platformHealth: statusPlatformHealth, minimumDepositUusdc, maximumDepositUusdc, outputLimit, identity, volume, liquidity, storage, isLoading: statusLoading, } = useStatus(proId ? { proId } : undefined);
+    const { serviceFeeRate, overheadUsd, platformHealth: statusPlatformHealth, minimumDepositUusdc, maximumDepositUusdc, outputLimit, identity, volume, liquidity, storage, isLoading: statusLoading, } = useStatus({ baseUrl: config.baseUrl ?? '', environment: config.environment, proId });
     const { fetchEstimates, isLoading: egressEstimatesLoading, egressQuotes: egressQuotesFromEstimates, ingressQuote: ingressQuoteFromEstimates, depositAmountUsd: depositAmountUsdFromEstimates, bridgeProviderFromQuote, usdcPrice: usdcPriceFromEstimates, } = useEgressEstimates({
         evmAddress,
         solAddress,

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/dist/hooks/useStatus.d.ts

@@ -12,14 +12,20 @@ export interface StatusResponse {
     storage?: Record<string, string>;
 }
 export interface UseStatusOptions {
+    /** Base URL for the status endpoint (e.g. https://api.silentswap.io) */
+    baseUrl: string;
+    /** Environment name, used to re-fetch when environment changes */
+    environment: string;
     /** Pro user ID for volume tracking (from ?pro= URL or localStorage) */
     proId?: string;
 }
 /**
- * Hook to fetch the current platform status, fee rates, and limits
- * When proId is provided, fetches with ?pro= for pro user volume tracking and returns identity/volume/liquidity.
+ * Hook to fetch the current platform status, fee rates, and limits.
+ * Requires baseUrl and environment to be passed directly (since this hook
+ * is called inside SilentSwapInnerProvider before the context is available).
+ * When proId is provided, fetches with ?pro= for pro user volume tracking.
  */
-export declare function useStatus(options?: UseStatusOptions): {
+export declare function useStatus(options: UseStatusOptions): {
     status: StatusResponse;
     isLoading: boolean;
     error: Error | null;

package/dist/hooks/useStatus.js

@@ -1,72 +1,62 @@
 import { useState, useEffect } from 'react';
-import { useSilentSwap } from '../contexts/SilentSwapContext.js';
+// Module-level cache: survives component unmount/remount and Strict Mode cycles.
+// Keyed by fetch params so a new fetch only happens when params actually change.
+let statusCache = null;
 /**
- * Hook to fetch the current platform status, fee rates, and limits
- * When proId is provided, fetches with ?pro= for pro user volume tracking and returns identity/volume/liquidity.
+ * Hook to fetch the current platform status, fee rates, and limits.
+ * Requires baseUrl and environment to be passed directly (since this hook
+ * is called inside SilentSwapInnerProvider before the context is available).
+ * When proId is provided, fetches with ?pro= for pro user volume tracking.
  */
 export function useStatus(options) {
-    const { config, client } = useSilentSwap();
-    const baseUrl = config.baseUrl;
-    const proId = options?.proId;
-    const [status, setStatus] = useState({});
-    const [isLoading, setIsLoading] = useState(true);
+    const { baseUrl, environment, proId } = options;
+    const fetchKey = `${baseUrl}|${environment}|${proId ?? ''}`;
+    const [status, setStatus] = useState(() => statusCache?.key === fetchKey && statusCache.data ? statusCache.data : {});
+    const [isLoading, setIsLoading] = useState(() => !(statusCache?.key === fetchKey && statusCache.data && Object.keys(statusCache.data).length > 0));
     const [error, setError] = useState(null);
     useEffect(() => {
-        // Skip if baseUrl is not yet available (shouldn't happen, but safety check)
-        if (!baseUrl) {
-            console.warn('[useStatus] baseUrl is not available yet');
+        if (!baseUrl)
             return;
-        }
-        // Skip if we're using the default/placeholder context
-        // The DEFAULT_CONTEXT has client: {} as SilentSwapClient (empty object placeholder)
-        // Real SilentSwapClient instances are class instances, not plain objects
-        // Check if client is the placeholder by verifying it's a plain empty object
-        const isPlaceholderClient = client &&
-            typeof client === 'object' &&
-            Object.getPrototypeOf(client) === Object.prototype &&
-            Object.keys(client).length === 0;
-        if (isPlaceholderClient) {
-            console.warn('[useStatus] Context not yet initialized (placeholder client detected), skipping fetch until real context is available');
-            setIsLoading(false);
-            return;
-        }
-        let isMounted = true;
-        const fetchStatus = async () => {
-            try {
-                setIsLoading(true);
-                const search = proId ? `?${new URLSearchParams({ pro: proId }).toString()}` : '';
-                const statusUrl = `${baseUrl}/status${search}`;
-                console.log('[useStatus] Fetching status from:', statusUrl, 'environment:', config.environment);
-                const response = await fetch(statusUrl);
-                if (!response.ok) {
-                    throw new Error(`Failed to fetch status: ${response.statusText}`);
-                }
-                const data = await response.json();
-                if (isMounted) {
-                    console.log('[useStatus] Status fetched successfully from:', statusUrl);
+        // Already fetched or in-flight for this exact param set — skip
+        if (statusCache?.key === fetchKey) {
+            if (statusCache.promise) {
+                // In-flight from another mount — wait for it and apply
+                statusCache.promise.then((data) => {
                     setStatus(data);
-                    setError(null);
-                }
-            }
-            catch (err) {
-                if (isMounted) {
-                    console.error('[useStatus] Failed to fetch status from:', baseUrl, err);
-                    setError(err instanceof Error ? err : new Error('Failed to fetch status'));
-                    // Use defaults on error
-                    setStatus({});
-                }
-            }
-            finally {
-                if (isMounted) {
                     setIsLoading(false);
-                }
+                });
             }
-        };
-        fetchStatus();
-        return () => {
-            isMounted = false;
-        };
-    }, [baseUrl, config.environment, proId]);
+            return;
+        }
+        const search = proId ? `?${new URLSearchParams({ pro: proId }).toString()}` : '';
+        const statusUrl = `${baseUrl}/status${search}`;
+        console.log('[useStatus] Fetching status from:', statusUrl, 'environment:', environment);
+        const promise = fetch(statusUrl)
+            .then((response) => {
+            if (!response.ok)
+                throw new Error(`Failed to fetch status: ${response.statusText}`);
+            return response.json();
+        })
+            .then((data) => {
+            console.log('[useStatus] Status fetched successfully from:', statusUrl);
+            statusCache = { key: fetchKey, data };
+            setStatus(data);
+            setError(null);
+            return data;
+        })
+            .catch((err) => {
+            console.error('[useStatus] Failed to fetch status from:', baseUrl, err);
+            setError(err instanceof Error ? err : new Error('Failed to fetch status'));
+            setStatus({});
+            statusCache = null; // Allow retry
+            return {};
+        })
+            .finally(() => {
+            setIsLoading(false);
+        });
+        // Claim the slot immediately so no other mount starts a duplicate
+        statusCache = { key: fetchKey, data: {}, promise };
+    }, [baseUrl, environment, proId, fetchKey]);
     // Convert overheadUsd from string to number
     const overheadUsd = status.overheadUsd ? parseFloat(status.overheadUsd) : 0;
     // serviceFeeRate is a Decimal (0.01 = 1%), convert to number

package/package.json

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