@silentswap/sdk 0.1.63 → 0.1.64

package/dist/bridge.js

@@ -349,7 +349,6 @@ export async function fetchDebridgeOrder(params, signal) {
  * Note: DLN does not support same-chain swaps via create-tx endpoint
  */
 async function fetchDebridgeSingleChainOrder(params, signal) {
-    console.log('fetchDebridgeSingleChainOrder');
     // Build query parameters for single-chain swap endpoint
     const queryParams = new URLSearchParams({
         chainId: params.srcChainId.toString(),
@@ -359,6 +358,16 @@ async function fetchDebridgeSingleChainOrder(params, signal) {
         tokenOutRecipient: params.dstChainTokenOutRecipient || params.account || '',
         senderAddress: params.senderAddress || params.account || '',
     });
+    // EXACT_OUTPUT support: when caller passes a concrete dstChainTokenOutAmount
+    // (and srcChainTokenInAmount === 'auto'), forward it as `tokenOutAmount`.
+    // Without this the convergence loop in solveDebridgeSingleChainUsdcAmount
+    // sends `tokenInAmount=auto` with no target → deBridge returns
+    // INTERNAL_SERVER_ERROR on every iteration after the first, so the loop
+    // never finds the optimal price and surfaces as "Failed to find optimal
+    // bridge price".
+    if (params.dstChainTokenOutAmount && params.dstChainTokenOutAmount !== 'auto') {
+        queryParams.set('tokenOutAmount', params.dstChainTokenOutAmount);
+    }
     // Add optional parameters if provided
     if (params.prependOperatingExpenses !== undefined) {
         queryParams.set('prependOperatingExpenses', String(params.prependOperatingExpenses));
@@ -520,8 +529,11 @@ async function solveRelayUsdcAmount(srcChainId, srcToken, srcAmount, userAddress
         if (impactPercent > maxImpactPercent) {
             throw new Error(`Price impact too high: ${impactPercent.toFixed(2)}%`);
         }
-        // Amount in is within our budget
-        if (amountIn <= BigInt(srcAmount)) {
+        // Amount in is within our budget — accept up to 0.5% over to absorb
+        // rounding noise from the bridge's internal pricing (otherwise the loop
+        // bounces on quotes that are e.g. 0.1% over, until convergence breaks).
+        const budgetWithTolerance = BigInt(srcAmount) * 1005n / 1000n;
+        if (amountIn <= budgetWithTolerance) {
             console.log('[SilentSwap:SolveRelay] Found optimal amount', {
                 usdcOut: amountOut.toString(),
                 amountIn: amountIn.toString(),
@@ -536,7 +548,13 @@ async function solveRelayUsdcAmount(srcChainId, srcToken, srcAmount, userAddress
             .minus(srcAmount)
             .times(yg_utoken_price)
             .div(yg_uusdc_price);
-        const sg_uusdc_target = BigNumber(quote.details.currencyOut.amount)
+        // Anchor the next target on the *current target* (what we asked for),
+        // not on `currencyOut.amount` (what the bridge's quote estimates we'd
+        // get). For some endpoints — notably deBridge single-chain —
+        // `amount > requested target` because of a built-in slippage buffer,
+        // and using it as the base produces new_target > previous_target on
+        // tight iterations, breaking convergence.
+        const sg_uusdc_target = BigNumber(targetUsdcOut.toString())
             .minus(yg_uusdc_over)
             .toFixed(0);
         console.log(`[SilentSwap:SolveRelay] Reducing target`, {
@@ -622,8 +640,10 @@ async function solveDebridgeUsdcAmount(srcChainId, srcToken, srcAmount, userAddr
             throw new Error(`Price impact too high: ${impactPercent.toFixed(2)}%`);
         }
         const amountIn = BigInt(quote.estimation.srcChainTokenIn.amount);
-        // Amount in is within our budget
-        if (amountIn <= BigInt(srcAmount)) {
+        // Amount in is within our budget — accept up to 0.5% over to absorb
+        // rounding noise from deBridge's internal pricing.
+        const budgetWithTolerance = BigInt(srcAmount) * 1005n / 1000n;
+        if (amountIn <= budgetWithTolerance) {
             // quote.tx can be undefined when DeBridge returns an estimation-only response
             // (e.g. unroutable edge cases, takers without capacity for the route, or non-EVM
             // sources like Solana/Tron where no ERC-20 allowance is needed at all).
@@ -641,7 +661,14 @@ async function solveDebridgeUsdcAmount(srcChainId, srcToken, srcAmount, userAddr
             .minus(srcAmount)
             .times(yg_utoken_price)
             .div(yg_uusdc_price);
-        const sg_uusdc_target = BigNumber(quote.estimation.dstChainTokenOut.amount)
+        // Anchor on the *requested target* (targetUsdcOut), not the bridge's
+        // estimated `amount`. deBridge's single-chain endpoint returns
+        // `amount > minAmount` (built-in slippage buffer), which makes the
+        // current iteration's `dstChainTokenOut.amount` larger than the
+        // requested target. Subtracting a small overshoot from that larger
+        // value yields a new target that's still bigger than the previous
+        // target, and the convergence guard fires.
+        const sg_uusdc_target = BigNumber(targetUsdcOut.toString())
             .minus(yg_uusdc_over)
             .toFixed(0);
         if (BigInt(sg_uusdc_target) >= targetUsdcOut) {
@@ -714,8 +741,10 @@ async function solveDebridgeSingleChainUsdcAmount(chainId, srcToken, srcAmount,
             throw new Error(`Price impact too high: ${impactPercent.toFixed(2)}%`);
         }
         const amountIn = BigInt(quote.estimation.srcChainTokenIn.amount);
-        // Amount in is within our budget
-        if (amountIn <= BigInt(srcAmount)) {
+        // Amount in is within our budget — accept up to 0.5% over to absorb
+        // rounding noise from deBridge's internal pricing.
+        const budgetWithTolerance = BigInt(srcAmount) * 1005n / 1000n;
+        if (amountIn <= budgetWithTolerance) {
             // quote.tx can be undefined when DeBridge returns an estimation-only response
             // (e.g. unroutable edge cases, takers without capacity for the route, or non-EVM
             // sources like Solana/Tron where no ERC-20 allowance is needed at all).
@@ -733,7 +762,14 @@ async function solveDebridgeSingleChainUsdcAmount(chainId, srcToken, srcAmount,
             .minus(srcAmount)
             .times(yg_utoken_price)
             .div(yg_uusdc_price);
-        const sg_uusdc_target = BigNumber(quote.estimation.dstChainTokenOut.amount)
+        // Anchor on the *requested target* (targetUsdcOut), not the bridge's
+        // estimated `amount`. deBridge's single-chain endpoint returns
+        // `amount > minAmount` (built-in slippage buffer), which makes the
+        // current iteration's `dstChainTokenOut.amount` larger than the
+        // requested target. Subtracting a small overshoot from that larger
+        // value yields a new target that's still bigger than the previous
+        // target, and the convergence guard fires.
+        const sg_uusdc_target = BigNumber(targetUsdcOut.toString())
             .minus(yg_uusdc_over)
             .toFixed(0);
         if (BigInt(sg_uusdc_target) >= targetUsdcOut) {
@@ -789,6 +825,7 @@ forceProvider) {
     const debridgeData = debridgeResult.status === 'fulfilled' ? debridgeResult.value : null;
     // Both failed — surface the most relevant inner error message
     if (!relayData && !debridgeData) {
+        debugger;
         const errors = [
             relayResult.status === 'rejected' ? relayResult.reason : null,
             debridgeResult.status === 'rejected' ? debridgeResult.reason : null,

package/dist/chain.js

@@ -31,12 +31,10 @@ export async function ensureChain(chainId, walletClient, connector, options) {
     }
     console.log('[ensureChain] currentChainId:', currentChainId, 'targetChainId:', chainId, 'needsSwitch:', currentChainId !== chainId);
     if (currentChainId !== chainId) {
-        let switchSucceeded = false;
         try {
             // Try to switch chain
             console.log('[ensureChain] attempting switchChain ...', { hasSwitchChain: !!connector.switchChain });
             await connector.switchChain?.({ chainId });
-            switchSucceeded = true;
             console.log('[ensureChain] switchChain succeeded');
         }
         catch (switchError) {
@@ -49,16 +47,17 @@ export async function ensureChain(chainId, walletClient, connector, options) {
             }
             // Non-required: chain switch failed (e.g. Trust Wallet via WalletConnect
             // doesn't support programmatic chain switching). Still recreate the
-            // walletClient from the provider so the WalletConnect transport is fresh
-            // — TrustWallet silently drops signTypedData when the client's chain scope
-            // doesn't match its active session chain.
+            // walletClient from the provider below so the WalletConnect transport
+            // is fresh — TrustWallet silently drops signTypedData when the client's
+            // chain scope doesn't match its active session chain.
         }
-        // Always recreate walletClient from the provider after a chain change attempt.
-        // Critical for WalletConnect: the old walletClient's chain scope (e.g. eip155:43114)
-        // doesn't match the active chain, so signing requests get silently dropped
-        // by the mobile wallet. This applies both after a successful switch AND a failed
-        // one — the provider's internal state may still have updated even if switchChain threw.
-        console.log('[ensureChain] recreating walletClient from provider ...', { switchSucceeded });
+        // Always rebind the walletClient if its `chain` config doesn't match the target.
+        // viem's signTypedData / sendTransaction asserts that walletClient.chain.id matches
+        // the wallet's reported eth_chainId — if the wallet was already switched to `chainId`
+        // (e.g. by an earlier ensureChain call) but the closure's walletClient was created
+        // by wagmi with a different chain, signing throws "Provided chainId X must match
+        // active chainId Y". Recreating the client here keeps the two in sync.
+        console.log('[ensureChain] rebinding walletClient to chain', chainId, '(was', walletClient.chain?.id, ')');
         const provider = await connector.getProvider();
         const chain = getChainById(chainId);
         if (!chain) {
@@ -78,7 +77,7 @@ export async function ensureChain(chainId, walletClient, connector, options) {
         });
         return newClient;
     }
-    console.log('[ensureChain] already on correct chain, returning existing walletClient');
+    console.log('[ensureChain] already on correct chain with matching client, returning existing walletClient');
     return walletClient;
 }
 /**

package/dist/order.d.ts

@@ -276,5 +276,10 @@ export declare const EIP712_DOMAIN_ORDER_DEFAULT: {
     readonly version: "1";
     readonly chainId: 1;
 };
+export declare const EIP712_DOMAIN_WALLET_GENERATION: {
+    readonly name: "SilentSwap v2";
+    readonly version: "1";
+    readonly chainId: 43114;
+};
 export declare function quoteResponseToEip712Document(quoteResponse: QuoteResponse): TypedDataDocument<typeof EIP712_DOMAIN_ORDER_DEFAULT>;
 export {};

package/dist/order.js

@@ -94,11 +94,25 @@ export const EIP712_TYPES_WALLET_GENERATION = {
         { name: 'token', type: 'string' },
     ],
 };
+// Orders must be signed with chainId === 1 (Ethereum mainnet) — the backend
+// rejects any other chainId with "eip712Domain value is invalid or not supported.
+// expected mainnet chain ID 1". Wallet-generation typed data uses a different
+// domain (EIP712_DOMAIN_WALLET_GENERATION below) and is not subject to that
+// constraint.
 export const EIP712_DOMAIN_ORDER_DEFAULT = {
     name: 'SilentSwap v2',
     version: '1',
     chainId: 1,
 };
+// Wallet-generation typed data is signed locally to derive entropy — the chainId
+// only matters for the wallet's cross-chain replay-protection check at sign time.
+// Pinned to Avalanche (43114) so the user doesn't have to leave their working
+// chain just to derive the wallet.
+export const EIP712_DOMAIN_WALLET_GENERATION = {
+    name: 'SilentSwap v2',
+    version: '1',
+    chainId: 43114,
+};
 export function quoteResponseToEip712Document(quoteResponse) {
     return {
         domain: EIP712_DOMAIN_ORDER_DEFAULT,

package/dist/sdk.d.ts

@@ -156,7 +156,7 @@ export declare function createEip712DocForWalletGeneration(scope: string, token:
     domain: {
         readonly name: "SilentSwap v2";
         readonly version: "1";
-        readonly chainId: 1;
+        readonly chainId: 43114;
     };
     primaryType: "WalletGeneration";
     message: {

package/dist/sdk.js

@@ -1,5 +1,5 @@
 import { createSiweMessage } from 'viem/siwe';
-import { EIP712_DOMAIN_ORDER_DEFAULT, EIP712_TYPES_ORDER, EIP712_TYPES_WALLET_GENERATION } from './order.js';
+import { EIP712_DOMAIN_ORDER_DEFAULT, EIP712_DOMAIN_WALLET_GENERATION, EIP712_TYPES_ORDER, EIP712_TYPES_WALLET_GENERATION } from './order.js';
 /**
  * Creates a SIWE message for authentication with SilentSwap
  * @param user - user's EVM address
@@ -49,7 +49,7 @@ export function createEip712DocForOrder(quote) {
 export function createEip712DocForWalletGeneration(scope, token) {
     return {
         types: EIP712_TYPES_WALLET_GENERATION,
-        domain: EIP712_DOMAIN_ORDER_DEFAULT,
+        domain: EIP712_DOMAIN_WALLET_GENERATION,
         primaryType: 'WalletGeneration',
         message: {
             description: 'Securely create a temporary, anonymous wallet for SilentSwap use only.',

package/package.json

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