@silentswap/sdk 0.0.67 → 0.0.69

package/dist/bridge.d.ts

@@ -202,6 +202,12 @@ export interface DeBridgeOrderParams {
     srcChainOrderAuthorityAddress?: string;
     srcChainRefundAddress?: string;
     dstChainOrderAuthorityAddress?: string;
+    referralCode?: number;
+    additionalTakerRewardBps?: number;
+    allowedTaker?: string;
+    deBridgeApp?: string;
+    ptp?: boolean;
+    srcChainPriorityLevel?: 'normal' | 'aggressive';
 }
 export interface DeBridgeOrderResponse {
     tx: {

package/dist/bridge.js

@@ -247,10 +247,29 @@ export async function fetchRelayQuote(params, signal) {
     });
     if (!response.ok) {
         const text = await response.text();
-        throw new Error(`HTTP ${response.status}: ${text}`);
+        throw parseQuoteApiErrorResponse(response.status, text);
     }
     return response.json();
 }
+/**
+ * Parse quote API error response (relay.link or deBridge) and return a user-friendly Error.
+ * Handles INSUFFICIENT_FUNDS / "No UTXOs available to spend" and other known error shapes.
+ */
+function parseQuoteApiErrorResponse(status, text) {
+    try {
+        const body = JSON.parse(text);
+        if (body.errorCode === 'INSUFFICIENT_FUNDS' || (body.message && body.message.includes('UTXO'))) {
+            return new Error('Insufficient funds');
+        }
+        if (body.message && typeof body.message === 'string') {
+            return new Error(body.message);
+        }
+    }
+    catch {
+        // not JSON or invalid
+    }
+    return new Error(`HTTP ${status}: ${text}`);
+}
 /**
  * Fetch a deBridge order with detailed response
  * Uses create-tx endpoint for cross-chain swaps
@@ -294,7 +313,7 @@ export async function fetchDebridgeOrder(params, signal) {
     const response = await fetch(`https://deswap.debridge.finance/v1.0/dln/order/create-tx?${queryParams}`, { signal });
     if (!response.ok) {
         const text = await response.text();
-        throw new Error(`HTTP ${response.status}: ${text}`);
+        throw parseQuoteApiErrorResponse(response.status, text);
     }
     return response.json();
 }
@@ -323,7 +342,7 @@ async function fetchDebridgeSingleChainOrder(params, signal) {
     const response = await fetch(`https://deswap.debridge.finance/v1.0/chain/transaction?${queryParams}`, { signal });
     if (!response.ok) {
         const text = await response.text();
-        throw new Error(`HTTP ${response.status}: ${text}`);
+        throw parseQuoteApiErrorResponse(response.status, text);
     }
     const data = await response.json();
     // Normalize single-chain response to match DeBridgeOrderResponse structure

package/dist/quote-utils.d.ts

@@ -66,21 +66,32 @@ export declare function calculateRelayMetrics(relayQuote: RelayQuoteResponse): Q
  */
 export declare function calculateDebridgeMetrics(debridgeQuote: DeBridgeOrderResponse): QuoteMetrics;
 /**
- * Select the best quote from multiple providers based on retention rate
+ * Select the best quote from multiple providers based on retention rate.
+ * A quote is viable if it has transaction data (for execution) or estimation data (for display).
+ * When both providers return estimation but no tx, we still pick the best so the app can show
+ * output and refetch on amount change instead of throwing and blocking further quotes.
+ * When both fail, uses relayRejection/debridgeRejection to throw a specific message (e.g. "Insufficient funds").
  */
-export declare function selectBestQuote(relayQuote: RelayQuoteResponse | null, debridgeQuote: DeBridgeOrderResponse | null, srcAmount: string): BridgeQuoteResult;
+export declare function selectBestQuote(relayQuote: RelayQuoteResponse | null, debridgeQuote: DeBridgeOrderResponse | null, srcAmount: string, relayRejection?: unknown, debridgeRejection?: unknown): BridgeQuoteResult;
 /**
  * Interpolate retention rate from samples
  */
 export declare function interpolateSamples(samples: EstimateSample[], usdValue: number, marginHi?: number): number;
+/**
+ * When set, only the specified provider is used for quotes (for testing).
+ */
+export type ForceBridgeProvider = 'relay' | 'debridge';
 /**
  * Get quote for cross-chain swap from multiple providers
  * This is the core logic shared between React and Vue
  * @param recipientAddress - Optional recipient address (required for Solana destinations)
+ * @param sourceAddress - Optional source chain address (if different from userAddress)
+ * @param forceProvider - Optional: use only this provider (for testing; skips the other)
  */
 export declare function getBridgeQuote(srcChainId: number, srcToken: string, srcAmount: string, dstChainId: number, dstToken: string, userAddress: `0x${string}` | string, // Can be EVM (0x) or Solana (base58) address
 signal?: AbortSignal, recipientAddress?: string, // Optional recipient address (required for Solana destinations)
-sourceAddress?: string): Promise<BridgeQuoteResult>;
+sourceAddress?: string, // Optional source chain address (if different from userAddress)
+forceProvider?: ForceBridgeProvider): Promise<BridgeQuoteResult>;
 /**
  * Convert BridgeQuoteResult to BridgeQuote with transaction data
  * Extracts transactions from the raw response based on provider

package/dist/quote-utils.js

@@ -113,18 +113,74 @@ function debridgeHasTransactionData(quote) {
     return !!(quote.tx && (quote.tx.to || quote.tx.data));
 }
 /**
- * Select the best quote from multiple providers based on retention rate
+ * Check if a relay quote has estimation data (output amount) even without tx.
+ * Allows selecting a quote for display when API returned estimation but no tx.
  */
-export function selectBestQuote(relayQuote, debridgeQuote, srcAmount) {
-    // Only consider providers that have executable transaction data
-    const viableRelay = relayQuote && relayHasTransactionData(relayQuote) ? relayQuote : null;
-    const viableDebridge = debridgeQuote && debridgeHasTransactionData(debridgeQuote) ? debridgeQuote : null;
+function relayHasEstimationData(quote) {
+    return !!(quote.details?.currencyOut?.amount != null && quote.details?.currencyOut?.amount !== '');
+}
+/**
+ * Check if a deBridge quote has estimation data (output amount) even without tx.
+ */
+function debridgeHasEstimationData(quote) {
+    return !!(quote.estimation?.dstChainTokenOut?.amount != null &&
+        quote.estimation.dstChainTokenOut.amount !== '');
+}
+/**
+ * Derive a user-facing message from quote provider rejection reasons.
+ * When any provider returns INSUFFICIENT_FUNDS / "No UTXOs available to spend", return "Insufficient funds".
+ */
+function getQuoteProviderErrorMessage(relayRejection, debridgeRejection) {
+    const check = (reason) => {
+        if (reason instanceof Error) {
+            const msg = reason.message;
+            if (msg.includes('Insufficient funds') ||
+                msg.includes('INSUFFICIENT_FUNDS') ||
+                msg.includes('No UTXOs available to spend')) {
+                return true;
+            }
+            // Parse JSON from "HTTP 400: {...}" style message
+            const jsonMatch = msg.match(/\{[\s\S]*\}/);
+            if (jsonMatch) {
+                try {
+                    const body = JSON.parse(jsonMatch[0]);
+                    if (body.errorCode === 'INSUFFICIENT_FUNDS' || (body.message && body.message.includes('UTXO'))) {
+                        return true;
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        return false;
+    };
+    if (check(relayRejection) || check(debridgeRejection)) {
+        return 'Insufficient funds';
+    }
+    return 'All quote providers failed';
+}
+/**
+ * Select the best quote from multiple providers based on retention rate.
+ * A quote is viable if it has transaction data (for execution) or estimation data (for display).
+ * When both providers return estimation but no tx, we still pick the best so the app can show
+ * output and refetch on amount change instead of throwing and blocking further quotes.
+ * When both fail, uses relayRejection/debridgeRejection to throw a specific message (e.g. "Insufficient funds").
+ */
+export function selectBestQuote(relayQuote, debridgeQuote, srcAmount, relayRejection, debridgeRejection) {
+    const hasRelayTx = relayQuote && relayHasTransactionData(relayQuote);
+    const hasRelayEst = relayQuote && relayHasEstimationData(relayQuote);
+    const hasDebridgeTx = debridgeQuote && debridgeHasTransactionData(debridgeQuote);
+    const hasDebridgeEst = debridgeQuote && debridgeHasEstimationData(debridgeQuote);
+    const viableRelay = (hasRelayTx || hasRelayEst) ? relayQuote : null;
+    const viableDebridge = (hasDebridgeTx || hasDebridgeEst) ? debridgeQuote : null;
     // Calculate metrics only for viable providers
     const relayMetrics = viableRelay ? calculateRelayMetrics(viableRelay) : null;
     const debridgeMetrics = viableDebridge ? calculateDebridgeMetrics(viableDebridge) : null;
-    // Both providers failed or have no executable transactions
+    // Both providers failed or have no usable response (no tx and no estimation)
     if (!viableRelay && !viableDebridge) {
-        throw new Error('All quote providers failed');
+        const message = getQuoteProviderErrorMessage(relayRejection, debridgeRejection);
+        throw new Error(message);
     }
     // Determine best provider based on retention rate
     let bestProvider;
@@ -221,14 +277,13 @@ export function interpolateSamples(samples, usdValue, marginHi = Infinity) {
  * Get quote for cross-chain swap from multiple providers
  * This is the core logic shared between React and Vue
  * @param recipientAddress - Optional recipient address (required for Solana destinations)
+ * @param sourceAddress - Optional source chain address (if different from userAddress)
+ * @param forceProvider - Optional: use only this provider (for testing; skips the other)
  */
 export async function getBridgeQuote(srcChainId, srcToken, srcAmount, dstChainId, dstToken, userAddress, // Can be EVM (0x) or Solana (base58) address
 signal, recipientAddress, // Optional recipient address (required for Solana destinations)
-sourceAddress // Optional source chain address (if different from userAddress)
-) {
-    console.log('recipientAddress', recipientAddress);
-    console.log('sourceAddress', sourceAddress);
-    console.log('userAddress', userAddress);
+sourceAddress, // Optional source chain address (if different from userAddress)
+forceProvider) {
     // Normalize token addresses for bridge API (handles both EVM and Solana)
     const srcTokenNorm = normalizeTokenAddressForQuote(srcChainId, srcToken);
     const dstTokenNorm = normalizeTokenAddressForQuote(dstChainId, dstToken);
@@ -300,10 +355,14 @@ sourceAddress // Optional source chain address (if different from userAddress)
             relayUserAddress = DEAD_ADDRESS;
         }
     }
-    // Fetch quotes from both providers in parallel
+    // Fetch quotes from both providers in parallel (skip one if forceProvider is set)
+    const useRelay = forceProvider !== 'debridge';
+    const useDebridge = forceProvider !== 'relay';
     const [relayResult, debridgeResult] = await Promise.allSettled([
-        // Relay.link quote
+        // Relay.link quote (skipped when forceProvider === 'debridge')
         (async () => {
+            if (!useRelay)
+                return null;
             try {
                 // Map chain IDs to Relay chain IDs if needed
                 // For Solana, Relay.link uses N_RELAY_CHAIN_ID_SOLANA (792703809)
@@ -406,11 +465,14 @@ sourceAddress // Optional source chain address (if different from userAddress)
                 if (err instanceof Error && err.name !== 'AbortError') {
                     console.warn('Relay quote failed:', err);
                 }
-                return null;
+                // Rethrow so Promise.allSettled captures the reason (e.g. "Insufficient funds")
+                throw err;
             }
         })(),
-        // deBridge quote
+        // deBridge quote (skipped when forceProvider === 'relay')
         (async () => {
+            if (!useDebridge)
+                return null;
             try {
                 // Skip deBridge for Bitcoin - Bitcoin only supports relay
                 if (isSrcBitcoin || isDestBitcoin) {
@@ -462,9 +524,22 @@ sourceAddress // Optional source chain address (if different from userAddress)
                     }
                 }
                 else {
-                    // Both source and destination are EVM, use EXACT_OUTPUT mode with auto
+                    // Both source and destination are EVM
+                    // API requires dstChainTokenOutRecipient, srcChainOrderAuthorityAddress, dstChainOrderAuthorityAddress for transaction construction
+                    debridgeParams.dstChainTokenOutRecipient = userAddress;
+                    debridgeParams.srcChainOrderAuthorityAddress = userAddress;
+                    debridgeParams.dstChainOrderAuthorityAddress = userAddress;
+                    debridgeParams.srcChainRefundAddress = userAddress;
+                    debridgeParams.senderAddress = userAddress;
                     debridgeParams.dstChainTokenOutAmount = 'auto';
                     debridgeParams.enableEstimate = true;
+                    // Optional params matching deSwap app for consistent API behavior
+                    debridgeParams.additionalTakerRewardBps = 0;
+                    debridgeParams.deBridgeApp = 'DESWAP';
+                    debridgeParams.ptp = false;
+                    debridgeParams.srcChainPriorityLevel = 'normal';
+                    // Use standard API param names (senderAddress, dstChainTokenOutRecipient); omit account
+                    // delete debridgeParams.account;
                 }
                 const quote = await fetchDebridgeOrder(debridgeParams, signal);
                 return quote;
@@ -473,15 +548,16 @@ sourceAddress // Optional source chain address (if different from userAddress)
                 if (err instanceof Error && err.name !== 'AbortError') {
                     console.warn('DeBridge quote failed:', err);
                 }
-                return null;
+                // Rethrow so Promise.allSettled captures the reason (e.g. "Insufficient funds")
+                throw err;
             }
         })(),
     ]);
     const relayQuote = relayResult.status === 'fulfilled' ? relayResult.value : null;
     const debridgeQuote = debridgeResult.status === 'fulfilled' ? debridgeResult.value : null;
-    // Select best quote
-    const result = selectBestQuote(relayQuote, debridgeQuote, srcAmount);
-    return result;
+    const relayRejection = relayResult.status === 'rejected' ? relayResult.reason : undefined;
+    const debridgeRejection = debridgeResult.status === 'rejected' ? debridgeResult.reason : undefined;
+    return selectBestQuote(relayQuote, debridgeQuote, srcAmount, relayRejection, debridgeRejection);
 }
 /**
  * Convert BridgeQuoteResult to BridgeQuote with transaction data

package/package.json

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