@silentswap/sdk 0.1.56 → 0.1.58

package/dist/assets.d.ts

@@ -31,14 +31,18 @@ export declare function loadAssetsData(): AssetsData;
 export declare function getAllAssets(): Record<Caip19, AssetInfo>;
 export declare function getAllChains(): Record<Caip2, ChainInfo>;
 export declare function getAllAssetsArray(): AssetInfo[];
+export declare function getCommonAssets(): AssetInfo[];
 export declare const COMMON_ASSETS: AssetInfo[];
 export declare const CHAIN_NAMES: Record<string, string>;
 /**
- * Get asset by CAIP-19 identifier from the full dataset
+ * Get asset by CAIP-19 identifier from the full dataset.
+ * O(1) after first call; returns the same reference across calls
+ * so consumers can rely on referential equality.
  */
 export declare function getAssetByCaip19(caip19: Caip19): AssetInfo | undefined;
 /**
- * Get chain info by CAIP-2 identifier
+ * Get chain info by CAIP-2 identifier.
+ * Uses the underlying object as a cache; record lookup is already O(1).
  */
 export declare function getChainByCaip2(caip2: Caip2): ChainInfo | undefined;
 /**

package/dist/assets.js

@@ -1,111 +1,208 @@
 import filteredData from './data/filtered.json' with { type: 'json' };
+function getFilteredData() {
+    return filteredData;
+}
 // Load assets data from filtered.json
 export function loadAssetsData() {
-    return filteredData;
+    return getFilteredData();
 }
 // Get all assets from the filtered data
 export function getAllAssets() {
-    return filteredData.assets;
+    return getFilteredData().assets;
 }
 // Get all chains from the filtered data
 export function getAllChains() {
-    return filteredData.chains;
+    return getFilteredData().chains;
 }
+// Cached array of all assets — avoids re-mapping on every call
+let _allAssetsArray = null;
 // Get all assets as an array for easy iteration
 export function getAllAssetsArray() {
-    const assets = filteredData.assets;
-    return Object.values(assets).map(asset => ({
+    if (_allAssetsArray)
+        return _allAssetsArray;
+    const assets = getFilteredData().assets;
+    _allAssetsArray = Object.values(assets).map(asset => ({
         ...asset,
         gradient: asset.gradient.length >= 2
             ? [asset.gradient[0], asset.gradient[1]]
             : ['000000', '000000'],
         caip19: asset.caip19,
     }));
+    return _allAssetsArray;
 }
-// Common tokens list - frequently used assets for quick access
+// Common CAIP-19 identifiers for popular tokens
 // This matches the popular tokens list in the Svelte UI (PopularTokensArea.svelte)
-export const COMMON_ASSETS = getAllAssetsArray().filter(asset => {
-    // Filter to commonly used tokens (matches Svelte PopularTokensArea.svelte)
-    const commonCaip19s = [
-        'tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t', // USDT on Tron
-        'bip122:000000000019d6689c085ae165831e93/slip44:0', // BTC on Bitcoin
-        'eip155:1/slip44:60', // ETH on Ethereum
-        'eip155:1/erc20:0xdAC17F958D2ee523a2206206994597C13D831ec7', // USDT on Ethereum
-        'eip155:1/erc20:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC on Ethereum
-        'eip155:1/erc20:0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', // WETH on Ethereum
-        'eip155:1/erc20:0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599', // WBTC on Ethereum
-        'eip155:1/erc20:0xae78736Cd615f374D3085123A210448E74Fc6393', // RETH on Ethereum
-        'eip155:56/slip44:714', // BNB on BSC
-        'eip155:56/erc20:0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c', // WBNB on BSC
-        'eip155:8453/slip44:60', // ETH on Base
-        'eip155:8453/erc20:0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC on Base
-        'eip155:43114/slip44:9005', // WAVAX on Avalanche
-        'eip155:43114/erc20:0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E', // USDC on Avalanche
-        'eip155:137/slip44:966', // WMATIC/WPOL on Polygon
-        'eip155:137/erc20:0xc2132D05D31c914a87C6611C10748AEb04B58e8F', // USDT on Polygon
-        'eip155:137/erc20:0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359', // USDC on Polygon
-        'eip155:10/slip44:60', // WETH on Optimism
-        'eip155:10/erc20:0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85', // USDC on Optimism
-        'eip155:42161/slip44:60', // WETH on Arbitrum
-        'eip155:42161/erc20:0xaf88d065e77c8cC2239327C5EDb3A432268e5831', // USDC on Arbitrum
-    ];
-    return commonCaip19s.includes(asset.caip19);
+const COMMON_CAIP19S = new Set([
+    'tron:0x2b6653dc/trc20:TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t', // USDT on Tron
+    'bip122:000000000019d6689c085ae165831e93/slip44:0', // BTC on Bitcoin
+    'eip155:1/slip44:60', // ETH on Ethereum
+    'eip155:1/erc20:0xdAC17F958D2ee523a2206206994597C13D831ec7', // USDT on Ethereum
+    'eip155:1/erc20:0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC on Ethereum
+    'eip155:1/erc20:0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', // WETH on Ethereum
+    'eip155:1/erc20:0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599', // WBTC on Ethereum
+    'eip155:1/erc20:0xae78736Cd615f374D3085123A210448E74Fc6393', // RETH on Ethereum
+    'eip155:56/slip44:714', // BNB on BSC
+    'eip155:56/erc20:0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c', // WBNB on BSC
+    'eip155:8453/slip44:60', // ETH on Base
+    'eip155:8453/erc20:0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC on Base
+    'eip155:43114/slip44:9005', // WAVAX on Avalanche
+    'eip155:43114/erc20:0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E', // USDC on Avalanche
+    'eip155:137/slip44:966', // WMATIC/WPOL on Polygon
+    'eip155:137/erc20:0xc2132D05D31c914a87C6611C10748AEb04B58e8F', // USDT on Polygon
+    'eip155:137/erc20:0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359', // USDC on Polygon
+    'eip155:10/slip44:60', // WETH on Optimism
+    'eip155:10/erc20:0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85', // USDC on Optimism
+    'eip155:42161/slip44:60', // WETH on Arbitrum
+    'eip155:42161/erc20:0xaf88d065e77c8cC2239327C5EDb3A432268e5831', // USDC on Arbitrum
+]);
+// Common tokens list - frequently used assets for quick access (lazy)
+let _commonAssets = null;
+export function getCommonAssets() {
+    if (_commonAssets)
+        return _commonAssets;
+    _commonAssets = getAllAssetsArray().filter(asset => COMMON_CAIP19S.has(asset.caip19));
+    return _commonAssets;
+}
+// Keep COMMON_ASSETS as a getter for backward compatibility
+export const COMMON_ASSETS = new Proxy([], {
+    get(target, prop, receiver) {
+        const real = getCommonAssets();
+        return Reflect.get(real, prop, receiver);
+    },
+    has(_target, prop) {
+        return prop in getCommonAssets();
+    },
+    ownKeys() {
+        return Reflect.ownKeys(getCommonAssets());
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+        return Object.getOwnPropertyDescriptor(getCommonAssets(), prop);
+    },
+    set(_target, _prop, _value) {
+        throw new TypeError('COMMON_ASSETS is read-only');
+    },
+    deleteProperty(_target, _prop) {
+        throw new TypeError('COMMON_ASSETS is read-only');
+    },
 });
-// Build chain names map from filtered data
-export const CHAIN_NAMES = Object.fromEntries(Object.entries(filteredData.chains).map(([caip2, chain]) => {
-    const match = caip2.match(/^eip155:(\d+)$/);
-    if (match) {
-        return [match[1], chain.name];
-    }
-    return [];
-}).filter((entry) => entry.length > 0));
+// Build chain names map from filtered data (lazy)
+let _chainNames = null;
+function getChainNames() {
+    if (_chainNames)
+        return _chainNames;
+    _chainNames = Object.fromEntries(Object.entries(getFilteredData().chains).map(([caip2, chain]) => {
+        const match = caip2.match(/^eip155:(\d+)$/);
+        if (match) {
+            return [match[1], chain.name];
+        }
+        return [];
+    }).filter((entry) => entry.length > 0));
+    return _chainNames;
+}
+export const CHAIN_NAMES = new Proxy({}, {
+    get(_target, prop, receiver) {
+        return Reflect.get(getChainNames(), prop, receiver);
+    },
+    has(_target, prop) {
+        return prop in getChainNames();
+    },
+    ownKeys() {
+        return Reflect.ownKeys(getChainNames());
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+        return Object.getOwnPropertyDescriptor(getChainNames(), prop);
+    },
+    set(_target, _prop, _value) {
+        throw new TypeError('CHAIN_NAMES is read-only');
+    },
+    deleteProperty(_target, _prop) {
+        throw new TypeError('CHAIN_NAMES is read-only');
+    },
+});
+let _assetByCaip19Map = null;
 /**
- * Get asset by CAIP-19 identifier from the full dataset
+ * Get asset by CAIP-19 identifier from the full dataset.
+ * O(1) after first call; returns the same reference across calls
+ * so consumers can rely on referential equality.
  */
 export function getAssetByCaip19(caip19) {
-    const assets = filteredData.assets;
-    const asset = assets[caip19];
-    if (!asset)
-        return undefined;
-    return {
-        ...asset,
-        gradient: asset.gradient.length >= 2
-            ? [asset.gradient[0], asset.gradient[1]]
-            : ['000000', '000000'],
-        caip19: asset.caip19,
-    };
+    if (!_assetByCaip19Map) {
+        _assetByCaip19Map = new Map();
+        for (const asset of getAllAssetsArray()) {
+            _assetByCaip19Map.set(asset.caip19, asset);
+        }
+    }
+    return _assetByCaip19Map.get(caip19);
 }
 /**
- * Get chain info by CAIP-2 identifier
+ * Get chain info by CAIP-2 identifier.
+ * Uses the underlying object as a cache; record lookup is already O(1).
  */
 export function getChainByCaip2(caip2) {
-    const chains = filteredData.chains;
+    const chains = getFilteredData().chains;
     return chains[caip2];
 }
+// Pre-indexed map of EVM chain ID → assets. Built lazily on first `getAssetsByChain`
+// call; avoids re-scanning the full asset array (~thousands of entries) per call.
+const EIP155_CHAIN_ID_REGEX = /^eip155:(\d+)\//;
+let _assetsByEvmChainCache = null;
 /**
  * Get all assets filtered by chain ID (for ingress/egress)
  */
 export function getAssetsByChain(chainId, ingress = true) {
-    return getAllAssetsArray().filter(asset => {
-        const match = asset.caip19.match(/^eip155:(\d+)\//);
-        if (!match)
-            return false;
-        return match[1] === chainId;
-    });
+    if (!_assetsByEvmChainCache) {
+        const cache = new Map();
+        for (const asset of getAllAssetsArray()) {
+            const match = EIP155_CHAIN_ID_REGEX.exec(asset.caip19);
+            if (!match)
+                continue;
+            const key = match[1];
+            let bucket = cache.get(key);
+            if (!bucket) {
+                bucket = [];
+                cache.set(key, bucket);
+            }
+            bucket.push(asset);
+        }
+        _assetsByEvmChainCache = cache;
+    }
+    return _assetsByEvmChainCache.get(chainId) ?? [];
 }
 /**
  * Get chain name from chain ID
  */
 export function getChainName(chainId) {
     const chainInfo = getChainByCaip2(`eip155:${chainId}`);
-    return chainInfo?.name || CHAIN_NAMES[chainId] || `Chain ${chainId}`;
+    // Call getChainNames() directly — skips the Proxy trap on the public CHAIN_NAMES export.
+    return chainInfo?.name || getChainNames()[chainId] || `Chain ${chainId}`;
 }
+let _lowerSearchIndex = null;
 /**
  * Search assets by symbol, name, or CAIP-19
  */
 export function searchAssets(query) {
     const lowerQuery = query.toLowerCase();
-    return getAllAssetsArray().filter(asset => asset.symbol.toLowerCase().includes(lowerQuery) ||
-        asset.name.toLowerCase().includes(lowerQuery) ||
-        asset.caip19.toLowerCase().includes(lowerQuery));
+    if (!_lowerSearchIndex) {
+        const all = getAllAssetsArray();
+        const index = new Array(all.length);
+        for (let i = 0; i < all.length; i++) {
+            const a = all[i];
+            index[i] = {
+                asset: a,
+                lowerSymbol: a.symbol.toLowerCase(),
+                lowerName: a.name.toLowerCase(),
+                lowerCaip19: a.caip19.toLowerCase(),
+            };
+        }
+        _lowerSearchIndex = index;
+    }
+    const result = [];
+    for (const entry of _lowerSearchIndex) {
+        if (entry.lowerSymbol.includes(lowerQuery) ||
+            entry.lowerName.includes(lowerQuery) ||
+            entry.lowerCaip19.includes(lowerQuery)) {
+            result.push(entry.asset);
+        }
+    }
+    return result;
 }

package/dist/bridge.js

@@ -610,9 +610,14 @@ async function solveDebridgeUsdcAmount(srcChainId, srcToken, srcAmount, userAddr
             }),
         });
         // Calculate price impact
+        // Use originApproximateUsdValue when available to exclude prepended operating expenses
+        // from the impact calculation. When prependOperatingExpenses=true, approximateUsdValue
+        // includes opex which inflates the apparent impact (e.g. 5.2% vs real 0.9%).
+        const usdInForImpact = quote.estimation.srcChainTokenIn.originApproximateUsdValue
+            ?? quote.estimation.srcChainTokenIn.approximateUsdValue;
         const usdIn = quote.estimation.srcChainTokenIn.approximateUsdValue;
         const usdOut = quote.estimation.dstChainTokenOut.approximateUsdValue;
-        const impactPercent = 100 * (1 - usdOut / usdIn);
+        const impactPercent = 100 * (1 - usdOut / usdInForImpact);
         if (impactPercent > maxImpactPercent) {
             throw new Error(`Price impact too high: ${impactPercent.toFixed(2)}%`);
         }
@@ -696,9 +701,12 @@ async function solveDebridgeSingleChainUsdcAmount(chainId, srcToken, srcAmount,
             }),
         });
         // Calculate price impact
+        // Use originApproximateUsdValue when available to exclude prepended operating expenses
+        const usdInForImpact = quote.estimation.srcChainTokenIn.originApproximateUsdValue
+            ?? quote.estimation.srcChainTokenIn.approximateUsdValue;
         const usdIn = quote.estimation.srcChainTokenIn.approximateUsdValue;
         const usdOut = quote.estimation.dstChainTokenOut.approximateUsdValue;
-        const impactPercent = 100 * (1 - usdOut / usdIn);
+        const impactPercent = 100 * (1 - usdOut / usdInForImpact);
         if (impactPercent > maxImpactPercent) {
             throw new Error(`Price impact too high: ${impactPercent.toFixed(2)}%`);
         }

package/dist/caip19.d.ts

@@ -73,7 +73,8 @@ export interface ParsedTronCaip19 {
     tokenAddress: string | null;
 }
 /**
- * Parse a CAIP-19 string into its components
+ * Parse a CAIP-19 string into its components.
+ * Memoized — subsequent calls with the same input return the cached result.
  * @param caip19 - CAIP-19 formatted string
  * @returns Parsed components or null if invalid
  * @example
@@ -82,7 +83,6 @@ export interface ParsedTronCaip19 {
  * parseCaip19('solana:1/token:0x0000000000000000000000000000000000000000') // { chainNamespace: 'solana', chainId: '1', assetNamespace: 'token', assetReference: '0x0000000000000000000000000000000000000000' }
  * parseCaip19('solana:1/slip44:501') // { chainNamespace: 'solana', chainId: '1', assetNamespace: 'slip44', assetReference: '501' }
  * parseCaip19('bip122:0/bip44:60') // { chainNamespace: 'bip122', chainId: '0', assetNamespace: 'bip44', assetReference: '60' }
- * parseCaip19('bip122:0/bip44:60') // { chainNamespace: 'bip122', chainId: '0', assetNamespace: 'bip44', assetReference: '60' }
  */
 export declare function parseCaip19(caip19: string): ParsedCaip19 | null;
 /**

package/dist/caip19.js

@@ -40,8 +40,13 @@ export var Caip19Namespace;
 // ============================================================================
 // Parsing Functions
 // ============================================================================
+// Memoized parse results. Asset catalog is bounded (few thousand), so the Map
+// stays small in practice; invalid inputs are cached as `null` to avoid re-running
+// the regex on repeated bad inputs (e.g. empty strings during render-time guards).
+const _parseCaip19Cache = new Map();
 /**
- * Parse a CAIP-19 string into its components
+ * Parse a CAIP-19 string into its components.
+ * Memoized — subsequent calls with the same input return the cached result.
  * @param caip19 - CAIP-19 formatted string
  * @returns Parsed components or null if invalid
  * @example
@@ -50,19 +55,25 @@ export var Caip19Namespace;
  * parseCaip19('solana:1/token:0x0000000000000000000000000000000000000000') // { chainNamespace: 'solana', chainId: '1', assetNamespace: 'token', assetReference: '0x0000000000000000000000000000000000000000' }
  * parseCaip19('solana:1/slip44:501') // { chainNamespace: 'solana', chainId: '1', assetNamespace: 'slip44', assetReference: '501' }
  * parseCaip19('bip122:0/bip44:60') // { chainNamespace: 'bip122', chainId: '0', assetNamespace: 'bip44', assetReference: '60' }
- * parseCaip19('bip122:0/bip44:60') // { chainNamespace: 'bip122', chainId: '0', assetNamespace: 'bip44', assetReference: '60' }
  */
 export function parseCaip19(caip19) {
+    const cached = _parseCaip19Cache.get(caip19);
+    if (cached !== undefined)
+        return cached;
     // Spec: 'namespace:chainId/assetNamespace:assetReference'
     const match = CAIP19_REGEX.exec(caip19);
-    if (!match)
+    if (!match) {
+        _parseCaip19Cache.set(caip19, null);
         return null;
-    return {
+    }
+    const result = {
         chainNamespace: match[1],
         chainId: match[2],
         assetNamespace: match[3],
         assetReference: match[4],
     };
+    _parseCaip19Cache.set(caip19, result);
+    return result;
 }
 /**
  * Parse an EVM CAIP-19 string (eip155:chainId/erc20:address or eip155:chainId/slip44:cointype)

package/dist/chain.js

@@ -61,6 +61,12 @@ export async function ensureChain(chainId, walletClient, connector, options) {
         console.log('[ensureChain] recreating walletClient from provider ...', { switchSucceeded });
         const provider = await connector.getProvider();
         const chain = getChainById(chainId);
+        if (!chain) {
+            throw new Error(`Unsupported chain ID: ${chainId}. Please ensure the chain is supported.`);
+        }
+        if (!walletClient.account) {
+            throw new Error('walletClient.account is undefined. A connected account is required to sign transactions.');
+        }
         const newClient = createWalletClient({
             account: walletClient.account,
             chain,

package/dist/quote-utils.js

@@ -94,13 +94,14 @@ function normalizeTokenAddressForQuote(chainId, token) {
  * Calculate metrics from a Relay.link quote response
  */
 export function calculateRelayMetrics(relayQuote) {
-    const usdIn = relayQuote.details.currencyIn.amountUsd;
-    const usdOut = relayQuote.details.currencyOut.amountUsd;
+    const { details, fees } = relayQuote;
+    const usdIn = details.currencyIn.amountUsd;
+    const usdOut = details.currencyOut.amountUsd;
     return {
         retention: BigNumber(usdOut).div(usdIn).toNumber(),
-        feeUsd: Number(relayQuote.fees.relayerGas?.amountUsd || relayQuote.fees.gas?.amountUsd || '0'),
-        slippage: Number(relayQuote.details.totalImpact?.percent || '0') * 100,
-        time: relayQuote.details.timeEstimate || 300,
+        feeUsd: Number(fees.relayerGas?.amountUsd || fees.gas?.amountUsd || '0'),
+        slippage: Number(details.totalImpact?.percent || '0') * 100,
+        time: details.timeEstimate || 300,
         txCount: relayQuote.steps?.length || 1,
     };
 }

package/dist/swap-executor.js

@@ -94,11 +94,10 @@ async function authenticate(client, signer, siweDomain, onStatus) {
     return { entropy, secretToken: authResponse.secretToken };
 }
 // ============================================================================
-// Step 2: Calculate Bridge Amount & Get Quote
+// Step 2a: Calculate Bridge Amount (independent — can run in parallel with auth)
 // ============================================================================
-async function calculateBridgeAndQuote(client, evmAddress, solanaAddress, sourceAmountUnits, destinationAsset, recipientAddress, facilitatorGroup, maxImpactPercent, onStatus) {
+async function calculateBridgeAmount(client, evmAddress, solanaAddress, sourceAmountUnits, maxImpactPercent, onStatus) {
     onStatus?.({ type: 'info', message: 'Calculating optimal bridge amount...' });
-    // Create phony deposit calldata for relay quote
     const depositorAddress = client.s0xDepositorAddress;
     const phonyCalldata = createPhonyDepositCalldata(evmAddress);
     const bridgeResult = await solveOptimalUsdcAmount(N_RELAY_CHAIN_ID_SOLANA, SB58_ADDR_SOL_PROGRAM_SYSTEM, sourceAmountUnits, solanaAddress, phonyCalldata, maxImpactPercent, depositorAddress, evmAddress);
@@ -108,11 +107,19 @@ async function calculateBridgeAndQuote(client, evmAddress, solanaAddress, source
         message: `Bridge will provide ${usdcHuman} USDC`,
         data: { provider: bridgeResult.provider, usdcAmount: bridgeResult.usdcAmountOut.toString() },
     });
+    return bridgeResult;
+}
+// ============================================================================
+// Step 2b: Request Quote (needs facilitatorGroup + bridgeResult)
+// ============================================================================
+async function requestQuote(client, evmAddress, destinationAsset, recipientAddress, facilitatorGroup, bridgeResult, onStatus) {
     onStatus?.({ type: 'info', message: 'Requesting quote from SilentSwap...' });
-    // Export facilitator group keys
-    const viewer = await facilitatorGroup.viewer();
+    // Export facilitator group keys — viewer() and exportPublicKeys() are independent RPCs.
+    const [viewer, groupPublicKeys] = await Promise.all([
+        facilitatorGroup.viewer(),
+        facilitatorGroup.exportPublicKeys(1, [...PublicKeyArgGroups.GENERIC]),
+    ]);
     const { publicKeyBytes: pk65_viewer } = viewer.exportPublicKey('*', FacilitatorKeyType.SECP256K1);
-    const groupPublicKeys = await facilitatorGroup.exportPublicKeys(1, [...PublicKeyArgGroups.GENERIC]);
     // Build quote request
     const [quoteError, quoteResponse] = await client.quote({
         signer: evmAddress,
@@ -135,7 +142,7 @@ async function calculateBridgeAndQuote(client, evmAddress, solanaAddress, source
         message: 'Quote received',
         data: { quoteId: quoteResponse.quoteId, deposit: quoteResponse.quote?.deposit },
     });
-    return { quoteResponse, bridgeResult };
+    return quoteResponse;
 }
 // ============================================================================
 // Step 3: Place Order
@@ -335,14 +342,17 @@ async function executeDeposit(solanaAccount, solanaConnection, evmAddress, order
  * Poll relay.link bridge status until completion or timeout
  */
 async function pollBridgeStatus(requestId, onStatus) {
-    let attempts = 0;
-    const maxAttempts = 180; // ~6 minutes at 2s intervals
-    while (attempts < maxAttempts) {
+    const maxDurationMs = 6 * 60 * 1000; // 6 minutes total timeout
+    const startTime = Date.now();
+    let delay = 2000; // Start at 2s
+    let attempt = 0;
+    while (Date.now() - startTime < maxDurationMs) {
         const status = await getRelayStatus(requestId);
+        attempt++;
         onStatus?.({
             type: 'info',
             message: `Bridge status: ${status.status}`,
-            data: { requestId, status: status.status, attempt: attempts + 1 },
+            data: { requestId, status: status.status, attempt },
         });
         if (status.status === 'success') {
             return;
@@ -350,10 +360,11 @@ async function pollBridgeStatus(requestId, onStatus) {
         if (status.status === 'failed' || status.status === 'refund') {
             throw new Error(`Bridge failed with status: ${status.status}${status.details ? ` - ${status.details}` : ''}`);
         }
-        await new Promise((r) => setTimeout(r, 2000));
-        attempts++;
+        await new Promise((r) => setTimeout(r, delay));
+        // Exponential backoff: 2s → 4s → 8s, capped at 15s
+        delay = Math.min(delay * 2, 15_000);
     }
-    throw new Error(`Bridge status polling timeout after ${maxAttempts} attempts`);
+    throw new Error(`Bridge status polling timeout after ${Math.round((Date.now() - startTime) / 1000)}s`);
 }
 // ============================================================================
 // Depositor ABI (depositProxy2)
@@ -460,14 +471,21 @@ export async function executeSolanaSwap(config) {
     // Create EVM signer adapter
     const evmSigner = createEvmSignerFromAccount(accounts.evm);
     onStatus?.({ type: 'info', message: 'Starting Solana swap...' });
-    // Step 1: Authenticate
-    const { entropy } = await authenticate(client, evmSigner, siweDomain, onStatus);
-    // Step 2: Create facilitator group
+    // Steps 2a, 2b run in parallel first — they are cheap/automatic and can fail
+    // without user interaction. Only after they succeed do we prompt the user for
+    // the SIWE signature, so we never ask the user to sign for a doomed operation.
+    const [depositCount, bridgeResult] = await Promise.all([
+        queryDepositCount(accounts.evm.address, client.s0xGatewayAddress),
+        calculateBridgeAmount(client, accounts.evm.address, accounts.solana.publicKey, sourceAmountUnits, maxImpactPercent, onStatus),
+    ]);
+    // Step 1: Authenticate (prompts user for SIWE signature) — sequenced after
+    // the above so a failing RPC/quote doesn't waste a user signature.
+    const authResult = await authenticate(client, evmSigner, siweDomain, onStatus);
+    // Step 2c: Create facilitator group (needs entropy + depositCount from above)
     onStatus?.({ type: 'info', message: 'Creating facilitator group...' });
-    const depositCount = await queryDepositCount(accounts.evm.address, client.s0xGatewayAddress);
-    const facilitatorGroup = await createHdFacilitatorGroupFromEntropy(hexToBytes(entropy), depositCount);
-    // Step 3: Calculate bridge and get quote
-    const { quoteResponse, bridgeResult } = await calculateBridgeAndQuote(client, accounts.evm.address, accounts.solana.publicKey, sourceAmountUnits, destinationAsset, recipientAddress, facilitatorGroup, maxImpactPercent, onStatus);
+    const facilitatorGroup = await createHdFacilitatorGroupFromEntropy(hexToBytes(authResult.entropy), depositCount);
+    // Step 3: Request quote (needs facilitatorGroup + bridgeResult from above)
+    const quoteResponse = await requestQuote(client, accounts.evm.address, destinationAsset, recipientAddress, facilitatorGroup, bridgeResult, onStatus);
     // Create encrypt args for facilitator key export
     const encryptArgs = {
         proxyPublicKey: client.proxyPublicKey,
@@ -500,19 +518,22 @@ export async function executeSolanaSwap(config) {
             });
         }
     }
-    // Derive viewing auth (viewer EVM address as Base58) for tracking, refund, and recovery
-    const viewer = await facilitatorGroup.viewer();
+    // Derive viewing auth + recovery data in parallel — viewer(), exportPublicKeys(),
+    // and exportSecretMnemonicFromEntropy() are independent once authResult is ready.
+    const [viewer, groupPublicKeysForRecovery, mnemonicResult] = await Promise.all([
+        facilitatorGroup.viewer(),
+        facilitatorGroup.exportPublicKeys(1, [...PublicKeyArgGroups.GENERIC]),
+        exportSecretMnemonicFromEntropy(hexToBytes(authResult.entropy)),
+    ]);
     const viewerEvmSigner = await viewer.evmSigner();
     const viewingAuth = hexToBase58(viewerEvmSigner.address);
-    // Build recovery data (mnemonic + paths) for refund/recovery
-    const groupPublicKeysForRecovery = await facilitatorGroup.exportPublicKeys(1, [...PublicKeyArgGroups.GENERIC]);
     const recoveryPaths = [];
     for (const pk of groupPublicKeysForRecovery[0] ?? []) {
         if (pk.coinType === '*')
             continue;
         recoveryPaths.push(`m/44'/${pk.coinType}'/${depositCount}'/0/0`);
     }
-    const mnemonic = (await exportSecretMnemonicFromEntropy(hexToBytes(entropy))).toString();
+    const mnemonic = mnemonicResult.toString();
     const recoveryData = { mnemonic, recoveryPaths };
     return {
         orderId,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@silentswap/sdk",
   "type": "module",
-  "version": "0.1.56",
+  "version": "0.1.58",
   "license": "MIT",
   "main": "dist/index.js",
   "files": [