@trustware/sdk-staging 1.1.9-staging.5 → 1.1.9-staging.7

package/dist/widget.cjs

@@ -585,7 +585,7 @@ var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
     SDK_NAME = "@trustware/sdk";
-    SDK_VERSION = "1.1.9-staging.5";
+    SDK_VERSION = "1.1.9-staging.7";
     API_ROOT = "https://bv-staging-api.trustware.io";
     GTM_ID = "GTM-TZDGNCXB";
     API_PREFIX = "/api";
@@ -796,7 +796,9 @@ var init_chains = __esm({
       btc: "bitcoin",
       bitcoin: "bitcoin",
       sei: "cosmos",
-      "pacific-1": "cosmos"
+      "pacific-1": "cosmos",
+      nibiru: "cosmos",
+      "cataclysm-1": "cosmos"
     };
   }
 });
@@ -1992,16 +1994,23 @@ function validateEvmAddress(address) {
   }
   return { isValid: true };
 }
-function validateSeiAddress(address) {
+function resolveCosmosBech32Prefix(chain) {
+  const chainDef = typeof chain === "object" && chain ? chain : void 0;
+  const identifier = chainDef?.networkIdentifier ?? chainDef?.chainId ?? chainDef?.id ?? (typeof chain === "string" ? chain : void 0);
+  const normalized = String(identifier ?? "").trim().toLowerCase();
+  return COSMOS_BECH32_PREFIX_BY_CHAIN_ID[normalized] ?? "sei";
+}
+function validateCosmosAddress(address, chain) {
   const trimmed = address.trim();
-  if ((0, import_viem.isAddress)(trimmed)) {
+  const prefix = resolveCosmosBech32Prefix(chain);
+  if (prefix === "sei" && (0, import_viem.isAddress)(trimmed)) {
     return { isValid: true };
   }
-  const result = validateBech32LikeAddress(trimmed, "sei");
+  const result = validateBech32LikeAddress(trimmed, prefix);
   if (result.isValid) return result;
   return {
     isValid: false,
-    error: "SEI addresses must be 0x-prefixed EVM or sei1 bech32 strings."
+    error: prefix === "sei" ? "SEI addresses must be 0x-prefixed EVM or sei1 bech32 strings." : `Address must be a valid ${prefix}1 bech32 string.`
   };
 }
 function validateSolanaAddress(address) {
@@ -2051,15 +2060,12 @@ function validateAddressForChain(address, chain) {
     case "bitcoin":
       return validateBtcAddress(trimmed);
     case "cosmos":
-      if (chainDef?.networkIdentifier?.toLowerCase() === "sei") {
-        return validateSeiAddress(trimmed);
-      }
-      return validateBech32LikeAddress(trimmed, "sei");
+      return validateCosmosAddress(trimmed, chainDef ?? chain);
     default:
       return { isValid: false, error: "Unsupported or unknown chain type." };
   }
 }
-function validateAddressForRouteChain(address, chainType) {
+function validateAddressForRouteChain(address, chainType, chainRef) {
   switch (normalizeChainType(chainType)) {
     case "evm":
       return validateEvmAddress(address);
@@ -2068,7 +2074,7 @@ function validateAddressForRouteChain(address, chainType) {
     case "bitcoin":
       return validateBtcAddress(address);
     case "cosmos":
-      return validateSeiAddress(address);
+      return validateCosmosAddress(address, chainRef ?? chainType);
     default:
       return { isValid: false, error: "Unsupported chain type." };
   }
@@ -2090,14 +2096,18 @@ function validateRouteAddresses(params) {
   const normalizedDirection = params.direction?.trim().toLowerCase();
   const isDepositFlow = normalizedDirection === "deposit" || (toType === "evm" || toType === "cosmos") && (fromType === "bitcoin" || fromType === "solana");
   if (isDepositFlow) {
-    const fromResult2 = validateAddressForRouteChain(fromAddress, fromType);
+    const fromResult2 = validateAddressForRouteChain(
+      fromAddress,
+      fromType,
+      params.fromChain
+    );
     if (!fromResult2.isValid) {
       return {
         isValid: false,
         error: `From address: ${fromResult2.error ?? "Invalid address."}`
       };
     }
-    const toResult2 = toType === "cosmos" ? validateSeiAddress(toAddress) : validateEvmAddress(toAddress);
+    const toResult2 = toType === "cosmos" ? validateCosmosAddress(toAddress, params.toChain) : validateEvmAddress(toAddress);
     if (!toResult2.isValid) {
       return {
         isValid: false,
@@ -2122,14 +2132,22 @@ function validateRouteAddresses(params) {
     }
     return { isValid: true };
   }
-  const fromResult = validateAddressForRouteChain(fromAddress, fromType);
+  const fromResult = validateAddressForRouteChain(
+    fromAddress,
+    fromType,
+    params.fromChain
+  );
   if (!fromResult.isValid) {
     return {
       isValid: false,
       error: `From address: ${fromResult.error ?? "Invalid address."}`
     };
   }
-  const toResult = validateAddressForRouteChain(toAddress, toType);
+  const toResult = validateAddressForRouteChain(
+    toAddress,
+    toType,
+    params.toChain
+  );
   if (!toResult.isValid) {
     return {
       isValid: false,
@@ -2138,7 +2156,7 @@ function validateRouteAddresses(params) {
   }
   return { isValid: true };
 }
-var import_viem, BECH32_CHARSET;
+var import_viem, BECH32_CHARSET, COSMOS_BECH32_PREFIX_BY_CHAIN_ID;
 var init_address = __esm({
   "src/validation/address.ts"() {
     "use strict";
@@ -2146,6 +2164,12 @@ var init_address = __esm({
     init_index_node4();
     init_chains();
     BECH32_CHARSET = /^[023456789acdefghjklmnpqrstuvwxyz]+$/i;
+    COSMOS_BECH32_PREFIX_BY_CHAIN_ID = {
+      "pacific-1": "sei",
+      sei: "sei",
+      "cataclysm-1": "nibi",
+      nibiru: "nibi"
+    };
   }
 });
 
@@ -2537,7 +2561,7 @@ async function buildDepositAddress(body, signal) {
     route
   };
 }
-async function submitReceipt(intentId, txHash, sponsorshipRequestId) {
+async function submitReceipt(intentId, txHash, sponsorshipRequestId, eoaAddress) {
   const r = await rateLimitedFetch(
     `${apiBase()}/v1/route-intent/${intentId}/receipt`,
     {
@@ -2545,7 +2569,8 @@ async function submitReceipt(intentId, txHash, sponsorshipRequestId) {
       headers: jsonHeaders({ "Idempotency-Key": txHash }),
       body: JSON.stringify({
         txHash,
-        ...sponsorshipRequestId ? { sponsorshipRequestId } : {}
+        ...sponsorshipRequestId ? { sponsorshipRequestId } : {},
+        ...eoaAddress ? { eoaAddress } : {}
       })
     }
   );
@@ -2855,6 +2880,7 @@ function useTrustwareConfig() {
     } catch {
       return {
         apiKey: "",
+        mode: "deposit",
         routes: {
           toChain: "",
           toToken: "",
@@ -3120,7 +3146,9 @@ var init_chainHelpers = __esm({
       btc: "bitcoin",
       bitcoin: "bitcoin",
       sei: "cosmos",
-      "pacific-1": "cosmos"
+      "pacific-1": "cosmos",
+      nibiru: "cosmos",
+      "cataclysm-1": "cosmos"
     };
     SEI_EVM_CHAIN_ID = "1329";
     SEI_COSMOS_CHAIN_ID = "pacific-1";
@@ -3335,7 +3363,8 @@ function filterSupportedChains(chains) {
     }
     if (chainType === "cosmos") {
       const seiKey = canonicalSeiChainKey(chain.chainId ?? chain.id);
-      if (seiKey !== "sei" && seiKey !== "pacific-1") {
+      const isNibiru = normalizeChainKey2(chain.chainId ?? chain.id) === NIBIRU_COSMOS_CHAIN_ID;
+      if (seiKey !== "sei" && !isNibiru) {
         return false;
       }
     }
@@ -3435,7 +3464,7 @@ function useChains() {
     error
   };
 }
-var import_react4, POPULAR_CHAINS_BY_TVL, POPULAR_LIMIT;
+var import_react4, POPULAR_CHAINS_BY_TVL, POPULAR_LIMIT, NIBIRU_COSMOS_CHAIN_ID;
 var init_useChains = __esm({
   "src/core/useChains.ts"() {
     "use strict";
@@ -3446,6 +3475,7 @@ var init_useChains = __esm({
     init_popularChains();
     POPULAR_CHAINS_BY_TVL = popularChains_default.byTvl;
     POPULAR_LIMIT = popularChains_default.popularLimit;
+    NIBIRU_COSMOS_CHAIN_ID = "cataclysm-1";
   }
 });
 
@@ -6240,21 +6270,28 @@ function formatDeepLink(id, currentUrl) {
   const enc = encodeURIComponent(currentUrl);
   switch (id) {
     // EVM
+    // MetaMask's dapp browser also exposes its Wallet Standard Solana
+    // provider in the same session, so "metamask-solana" reuses this link.
     case "metamask":
+    case "metamask-solana":
       return `metamask://dapp/${currentUrl}`;
     case "coinbase":
       return `coinbase://wallet/dapp?url=${enc}`;
     case "rainbow":
-      return `rainbow://connect?uri=${enc}`;
+      return `https://rainbow.me/dapp?url=${enc}`;
     case "trust":
       return `https://link.trustwallet.com/open_url?coin_id=60&url=${enc}`;
     case "okx":
       return `okx://wallet/dapp/url?dappUrl=${enc}`;
     // Solana
+    // Phantom is one app with one in-app browser — browsing there injects
+    // both window.ethereum and window.phantom.solana, so "phantom-evm"
+    // reuses the same browse link as "phantom-solana".
     case "phantom-solana":
-      return `phantom://browse/${enc}`;
+    case "phantom-evm":
+      return `https://phantom.app/ul/browse/${enc}?ref=${enc}`;
     case "solflare":
-      return `solflare://ul/v1/browse/${enc}`;
+      return `https://solflare.com/ul/v1/browse/${enc}?ref=${enc}`;
     case "backpack":
       return `https://backpack.app/ul/v1/browse/${enc}?ref=${enc}`;
     // No confirmed deep link scheme
@@ -6364,8 +6401,10 @@ var init_metadata = __esm({
         homepage: "https://phantom.app/",
         ios: "https://apps.apple.com/app/phantom-crypto-wallet/id1598432977",
         android: "https://play.google.com/store/apps/details?id=app.phantom",
-        detectFlags: ["isPhantom"]
-        // No EVM dapp browser deep link — falls back to app store
+        detectFlags: ["isPhantom"],
+        // Same app/in-app browser as "phantom-solana" — browsing there injects
+        // window.ethereum too.
+        deepLink: (url) => formatDeepLink("phantom-evm", url) ?? ""
       },
       {
         id: "phantom-solana",
@@ -6413,8 +6452,10 @@ var init_metadata = __esm({
         emoji: "\u{1F98A}",
         homepage: "https://metamask.io/",
         ios: "https://apps.apple.com/app/metamask/id1438144202",
-        android: "https://play.google.com/store/apps/details?id=io.metamask"
-        // No Solana-specific deep link for MetaMask
+        android: "https://play.google.com/store/apps/details?id=io.metamask",
+        // Same app/in-app browser as "metamask" — its Wallet Standard Solana
+        // provider is exposed in that same browse session.
+        deepLink: (url) => formatDeepLink("metamask-solana", url) ?? ""
       },
       // ── Extension/desktop only — hidden on mobile ─────────────────────────────
       {
@@ -6925,7 +6966,7 @@ var init_walletconnect = __esm({
     solanaMainnet = {
       id: 900,
       chainNamespace: "solana",
-      caipNetworkId: "solana:5eykt4UsFv8P8NJdTREpY1vzqAQ3H1FQ",
+      caipNetworkId: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
       name: "Solana Mainnet",
       nativeCurrency: {
         name: "Solana",
@@ -7803,8 +7844,62 @@ function getChainMeta(chainId) {
     rpcUrls: chain.rpcUrls.default.http
   };
 }
-async function buildWalletConnectAPI(walletCfg) {
+function extractSolanaAddress(connector) {
+  const caipAccount = connector.provider.session?.namespaces?.solana?.accounts?.[0];
+  if (!caipAccount) return null;
+  return caipAccount.split(":")[2] ?? null;
+}
+function buildWalletConnectSolanaProvider(connector) {
+  return {
+    get publicKey() {
+      const address = extractSolanaAddress(connector);
+      return address ? { toString: () => address } : void 0;
+    },
+    async connect() {
+      const address = extractSolanaAddress(connector);
+      if (!address) {
+        throw new Error(
+          "This wallet did not approve a Solana account over WalletConnect."
+        );
+      }
+      return { publicKey: { toString: () => address } };
+    },
+    async disconnect() {
+    },
+    async signTransaction(transaction) {
+      const tx = transaction;
+      const rawBytes = "version" in tx ? tx.serialize() : tx.serialize({
+        requireAllSignatures: false,
+        verifySignatures: false
+      });
+      const result = await connector.provider.request(
+        {
+          method: "solana_signTransaction",
+          params: { transaction: encodeBase64(rawBytes) }
+        },
+        solanaMainnet.caipNetworkId
+      );
+      if (!result.transaction) {
+        throw new Error(
+          "WalletConnect wallet did not return a signed Solana transaction."
+        );
+      }
+      const signedBytes = decodeBase64(result.transaction);
+      return { serialize: () => signedBytes };
+    },
+    on() {
+    },
+    off() {
+    },
+    removeListener() {
+    }
+  };
+}
+async function buildWalletConnectAPI(walletCfg, ecosystem = "evm") {
   const connector = await getUniversalConnector(walletCfg);
+  if (ecosystem === "solana") {
+    return toSolanaWalletInterface(buildWalletConnectSolanaProvider(connector));
+  }
   const provider = connector.provider;
   const api = {
     ecosystem: "evm",
@@ -7874,7 +7969,7 @@ function bindWalletConnectEvents(provider, callbacks) {
 function useWalletConnectConnect(walletCfg) {
   const cfgRef = { current: walletCfg };
   return (0, import_react10.useCallback)(
-    () => walletManager.connectWalletConnect(cfgRef.current),
+    (ecosystem) => walletManager.connectWalletConnect(cfgRef.current, ecosystem),
     []
   );
 }
@@ -7894,6 +7989,7 @@ function useWalletInfo(wagmi) {
     connectedVia: snapshot.connectedVia,
     walletType: snapshot.walletType,
     status: snapshot.status,
+    detected: snapshot.detected,
     disconnect
   };
 }
@@ -8045,44 +8141,39 @@ var init_manager = __esm({
           this.emit();
         }
       }
-      async connectWalletConnect(walletCfg) {
-        if (this._status === "connected" && this._connectedVia === "walletconnect" && this._wallet) {
+      async connectWalletConnect(walletCfg, ecosystem = "evm") {
+        if (this._status === "connected" && this._connectedVia === "walletconnect" && this._wallet && this._wallet.ecosystem === ecosystem) {
           this.emit();
           return { error: null, api: this._wallet };
         }
+        if (this._connectedVia === "walletconnect" && this._wallet) {
+          await this._wallet.disconnect?.().catch(() => {
+          });
+          resetUniversalConnector();
+        }
         this._status = "connecting";
         this.clearConnectedState();
         this.emit();
         try {
           const connector = await getUniversalConnector(walletCfg);
           await connector.connect();
-          const api = await buildWalletConnectAPI(walletCfg);
+          const api = await buildWalletConnectAPI(walletCfg, ecosystem);
+          try {
+            await api.getAddress();
+          } catch {
+            await api.disconnect?.().catch(() => {
+            });
+            resetUniversalConnector();
+            throw new Error(
+              `This wallet did not approve a${ecosystem === "evm" ? "n" : ""} ${ecosystem === "evm" ? "EVM" : "Solana"} account over WalletConnect.`
+            );
+          }
           this._wallet = api;
           this._connectedVia = "walletconnect";
           this._connectedWalletId = "walletconnect";
-          const provider = connector.provider;
-          this._providerCleanup = bindWalletConnectEvents(provider, {
-            onAccountsChanged: (accounts) => {
-              if (accounts.length === 0) {
-                this.fullReset();
-                this.triggerExternalDisconnect();
-                this.emit();
-                return;
-              }
-              void this.syncIdentityFromWallet("walletconnect");
-              this.emit();
-            },
-            onChainChanged: () => {
-              void this.syncIdentityFromWallet("walletconnect");
-              this.emit();
-            },
-            onDisconnect: () => {
-              this.fullReset();
-              resetUniversalConnector();
-              this.triggerExternalDisconnect();
-              this.emit();
-            }
-          });
+          this._providerCleanup = this.bindWalletConnectProviderEvents(
+            connector.provider
+          );
           await this.syncIdentityFromWallet("walletconnect");
           this._status = "connected";
           this._error = null;
@@ -8097,6 +8188,100 @@ var init_manager = __esm({
           return { error: message, api: null };
         }
       }
+      bindWalletConnectProviderEvents(provider) {
+        return bindWalletConnectEvents(provider, {
+          onAccountsChanged: (accounts) => {
+            if (accounts.length === 0) {
+              this.fullReset();
+              this.triggerExternalDisconnect();
+              this.emit();
+              return;
+            }
+            void this.syncIdentityFromWallet("walletconnect");
+            this.emit();
+          },
+          onChainChanged: () => {
+            void this.syncIdentityFromWallet("walletconnect");
+            this.emit();
+          },
+          onDisconnect: () => {
+            this.fullReset();
+            resetUniversalConnector();
+            this.triggerExternalDisconnect();
+            this.emit();
+          }
+        });
+      }
+      // WalletConnect's own SignClient auto-restores the last persisted session
+      // from storage on every init — including after a fresh page load — but
+      // that restoration happens silently inside the library. Nothing calls back
+      // into our code for it. On mobile, backgrounding the tab to approve in a
+      // wallet app can cause the OS to reload the page before the original
+      // connect() promise ever resolves, so the connect flow that triggered the
+      // approval never gets to record it as "connected" here — even though
+      // WalletConnect itself already has a live, approved session sitting in
+      // storage. Call this on mount to pick that back up.
+      async restoreWalletConnectSession(walletCfg) {
+        if (this._status === "connected" && this._connectedVia === "walletconnect") {
+          return this._wallet?.ecosystem === "solana" ? "solana" : "evm";
+        }
+        if (typeof window === "undefined") return null;
+        try {
+          if (!Object.keys(window.localStorage).some((key) => key.startsWith("wc@2"))) {
+            return null;
+          }
+        } catch {
+        }
+        let connector;
+        try {
+          connector = await getUniversalConnector(walletCfg);
+        } catch (e2) {
+          console.warn(
+            "[Trustware SDK] Failed to restore WalletConnect session:",
+            e2
+          );
+          return null;
+        }
+        const session = connector.provider.session;
+        if (!session) return null;
+        const ecosystem = session.namespaces?.solana?.accounts?.length ? "solana" : session.namespaces?.eip155?.accounts?.length ? "evm" : null;
+        if (!ecosystem) return null;
+        try {
+          const api = await buildWalletConnectAPI(walletCfg, ecosystem);
+          this._wallet = api;
+          this._connectedVia = "walletconnect";
+          this._connectedWalletId = "walletconnect";
+          this._providerCleanup = this.bindWalletConnectProviderEvents(
+            connector.provider
+          );
+          await this.syncIdentityFromWallet("walletconnect");
+          this._status = "connected";
+          this._error = null;
+          this.emit();
+          return ecosystem;
+        } catch {
+          return null;
+        }
+      }
+      // Forcibly abandon an in-progress connect() call the caller has decided is
+      // stuck (e.g. the UI's own connect timeout elapsed with no response).
+      // There's no clean way to cancel a pending WalletConnect pairing proposal
+      // from this side, so this tears down the whole connector — the next
+      // connect attempt starts against a brand new SignClient/pairing instead of
+      // racing the abandoned one, which would otherwise risk reproducing the
+      // "No matching key. proposal" class of error a real retry needs to avoid.
+      cancelWalletConnectAttempt() {
+        if (this._connectedVia === "walletconnect" && this._status === "connected") {
+          return;
+        }
+        resetUniversalConnector();
+        if (this._status === "connecting") {
+          this.clearConnectedState();
+          this._status = "idle";
+          this._error = null;
+          this.emit();
+        }
+      }
       async disconnect(wagmi) {
         if (wagmi && this._connectedVia === "extension") {
           await wagmi.disconnect().catch(() => {
@@ -8628,46 +8813,80 @@ function normalizeSlippage(v) {
   if (n > 5) return 5;
   return n;
 }
+function warnDeprecatedSwapModeFlag() {
+  if (hasWarnedDeprecatedSwapModeFlag) return;
+  hasWarnedDeprecatedSwapModeFlag = true;
+  console.warn(
+    '[Trustware SDK] `features.swapMode` is deprecated \u2014 use `mode: "swap"` on the top-level config instead.'
+  );
+}
+function resolveMode(input) {
+  if (input.mode === "swap") return "swap";
+  if (input.mode === "deposit") return "deposit";
+  if (input.features?.swapMode) {
+    warnDeprecatedSwapModeFlag();
+    return "swap";
+  }
+  return "deposit";
+}
 function resolveConfig(input) {
   if (!input?.apiKey) {
-    throw new Error("TrustwareConfig: 'apiKey' is required.");
+    throw new TrustwareError({
+      code: "INVALID_CONFIG" /* INVALID_CONFIG */,
+      message: "TrustwareConfig: 'apiKey' is required.",
+      userMessage: "Missing required API key configuration."
+    });
   }
-  if (!input.routes?.toChain || !input.routes?.toToken) {
-    throw new Error(
-      "TrustwareConfig: 'routes.toChain' and 'routes.toToken' are required."
-    );
+  const mode = resolveMode(input);
+  if (mode === "deposit" && (!input.routes?.toChain || !input.routes?.toToken)) {
+    throw new TrustwareError({
+      code: "INVALID_CONFIG" /* INVALID_CONFIG */,
+      message: "TrustwareConfig: 'routes.toChain' and 'routes.toToken' are required in deposit mode.",
+      userMessage: "Missing required destination chain/token configuration."
+    });
   }
-  const toChain = input.routes.toChain;
-  if (input.routes.toAddress) {
+  const toChain = input.routes?.toChain;
+  if (input.routes?.toAddress && toChain) {
     const result = validateAddressForChain(input.routes.toAddress, toChain);
     if (!result.isValid) {
       console.error(`[Trustware SDK] Invalid toAddress: ${result.error}`);
-      throw new Error(`Invalid toAddress: ${result.error}`);
+      throw new TrustwareError({
+        code: "INVALID_CONFIG" /* INVALID_CONFIG */,
+        message: `Invalid toAddress: ${result.error}`,
+        userMessage: "The configured destination address is invalid."
+      });
     }
   }
-  if (input.routes.fromAddress) {
-    const result = validateAddressForChain(
-      input.routes.fromAddress,
-      input.routes.fromChain ?? toChain
-    );
-    if (!result.isValid) {
-      console.error(`[Trustware SDK] Invalid fromAddress: ${result.error}`);
-      throw new Error(`Invalid fromAddress: ${result.error}`);
+  if (input.routes?.fromAddress) {
+    const fromChain = input.routes.fromChain ?? toChain;
+    if (fromChain) {
+      const result = validateAddressForChain(
+        input.routes.fromAddress,
+        fromChain
+      );
+      if (!result.isValid) {
+        console.error(`[Trustware SDK] Invalid fromAddress: ${result.error}`);
+        throw new TrustwareError({
+          code: "INVALID_CONFIG" /* INVALID_CONFIG */,
+          message: `Invalid fromAddress: ${result.error}`,
+          userMessage: "The configured source address is invalid."
+        });
+      }
     }
   }
   const autoDetectProvider = typeof input.autoDetectProvider === "boolean" ? input.autoDetectProvider : DEFAULT_AUTO_DETECT_PROVIDER;
   const routes = {
-    toChain: input.routes.toChain,
-    toToken: input.routes.toToken,
-    fromToken: input.routes.fromToken,
-    fromAddress: input.routes.fromAddress,
-    fromChain: input.routes.fromChain,
-    toAddress: input.routes.toAddress,
+    toChain: input.routes?.toChain ?? "",
+    toToken: input.routes?.toToken ?? "",
+    fromToken: input.routes?.fromToken,
+    fromAddress: input.routes?.fromAddress,
+    fromChain: input.routes?.fromChain,
+    toAddress: input.routes?.toAddress,
     defaultSlippage: normalizeSlippage(
-      input.routes.defaultSlippage ?? DEFAULT_SLIPPAGE
+      input.routes?.defaultSlippage ?? DEFAULT_SLIPPAGE
     ),
     options: {
-      ...input.routes.options
+      ...input.routes?.options
     }
   };
   const theme = input.theme ?? "system";
@@ -8686,13 +8905,16 @@ function resolveConfig(input) {
     tokensPagination: input.features?.tokensPagination ?? DEFAULT_FEATURE_FLAGS.tokensPagination,
     balanceStreaming: input.features?.balanceStreaming ?? DEFAULT_FEATURE_FLAGS.balanceStreaming,
     shouldAllowGA4: input.features?.shouldAllowGA4 ?? DEFAULT_FEATURE_FLAGS.shouldAllowGA4,
-    swapMode: input.features?.swapMode ?? DEFAULT_FEATURE_FLAGS.swapMode,
+    // Always mirrors the canonical `mode`, however the caller set it (new `mode` field
+    // or the deprecated `features.swapMode` flag).
+    swapMode: mode === "swap",
     swapDefaultDestToken: input.features?.swapDefaultDestToken ?? DEFAULT_FEATURE_FLAGS.swapDefaultDestToken,
     swapLockDestToken: input.features?.swapLockDestToken ?? DEFAULT_FEATURE_FLAGS.swapLockDestToken,
     swapAllowedDestTokens: input.features?.swapAllowedDestTokens ?? DEFAULT_FEATURE_FLAGS.swapAllowedDestTokens
   };
   return {
     apiKey: input.apiKey,
+    mode,
     routes,
     autoDetectProvider,
     theme,
@@ -8705,12 +8927,15 @@ function resolveConfig(input) {
     onEvent: input.onEvent
   };
 }
+var hasWarnedDeprecatedSwapModeFlag;
 var init_merge = __esm({
   "src/config/merge.ts"() {
     "use strict";
     init_defaults();
     init_config();
     init_index();
+    init_TrustwareError();
+    hasWarnedDeprecatedSwapModeFlag = false;
   }
 });
 
@@ -9296,12 +9521,71 @@ var init_useWalletSessionState = __esm({
 // src/widget/state/deposit/useWalletConnect.ts
 function useWalletConnect({
   setWalletType,
-  setCurrentStep
+  setCurrentStep,
+  selectedNamespace,
+  setSelectedNamespace
 }) {
   const walletConnectCfg = TrustwareConfigStore.peek()?.walletConnect;
   const connectWC = useWalletConnectConnect(walletConnectCfg);
+  const ecosystem = selectedNamespace.trim().toLowerCase() === "solana" ? "solana" : "evm";
+  const [wcStatus, setWcStatus] = (0, import_react16.useState)("idle");
+  const [wcErrorMessage, setWcErrorMessage] = (0, import_react16.useState)(null);
+  const wcTimeoutRef = (0, import_react16.useRef)(null);
+  const clearWcTimeout = (0, import_react16.useCallback)(() => {
+    if (wcTimeoutRef.current !== null) {
+      clearTimeout(wcTimeoutRef.current);
+      wcTimeoutRef.current = null;
+    }
+  }, []);
+  const beginWcAttempt = (0, import_react16.useCallback)(() => {
+    setWcStatus("connecting");
+    setWcErrorMessage(null);
+    clearWcTimeout();
+    wcTimeoutRef.current = setTimeout(() => {
+      wcTimeoutRef.current = null;
+      setWcStatus((prev) => prev === "connecting" ? "timedOut" : prev);
+    }, WC_CONNECT_TIMEOUT_MS);
+  }, [clearWcTimeout]);
+  const resolveWcAttempt = (0, import_react16.useCallback)(() => {
+    clearWcTimeout();
+    setWcStatus("idle");
+    setWcErrorMessage(null);
+  }, [clearWcTimeout]);
+  const failWcAttempt = (0, import_react16.useCallback)(
+    (message) => {
+      clearWcTimeout();
+      setWcStatus("failed");
+      setWcErrorMessage(message);
+    },
+    [clearWcTimeout]
+  );
+  const dismissWcStatus = (0, import_react16.useCallback)(() => {
+    clearWcTimeout();
+    setWcStatus("idle");
+    setWcErrorMessage(null);
+  }, [clearWcTimeout]);
+  (0, import_react16.useEffect)(() => clearWcTimeout, [clearWcTimeout]);
+  (0, import_react16.useEffect)(() => {
+    let cancelled = false;
+    beginWcAttempt();
+    void (async () => {
+      const restoredEcosystem = await walletManager.restoreWalletConnectSession(walletConnectCfg);
+      if (cancelled) return;
+      resolveWcAttempt();
+      if (!restoredEcosystem) return;
+      setWalletType("walletconnect");
+      if (restoredEcosystem === "solana") {
+        setSelectedNamespace("Solana");
+      }
+      const address = walletManager.identity?.addresses[0]?.address ?? null;
+      if (address) setCurrentStep("crypto-pay");
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
   const WalletConnect = (0, import_react16.useCallback)(async () => {
-    if (walletManager.status === "connected" && walletManager.connectedVia === "walletconnect") {
+    if (walletManager.status === "connected" && walletManager.connectedVia === "walletconnect" && walletManager.wallet?.ecosystem === ecosystem) {
       const address = walletManager.identity?.addresses[0]?.address ?? null;
       if (address) {
         setWalletType("walletconnect");
@@ -9310,35 +9594,60 @@ function useWalletConnect({
       }
     }
     setWalletType("walletconnect");
-    const { error } = await connectWC();
+    beginWcAttempt();
+    const { error } = await connectWC(ecosystem);
     if (!error) {
       const address = walletManager.identity?.addresses[0]?.address ?? null;
       if (address) {
+        resolveWcAttempt();
         setCurrentStep("crypto-pay");
+      } else {
+        const message = `WalletConnect session established but no address resolved for ecosystem "${ecosystem}".`;
+        console.error(`[Trustware SDK] ${message}`);
+        failWcAttempt(message);
       }
     } else {
+      console.error("[Trustware SDK] WalletConnect connection failed:", error);
+      failWcAttempt(error);
       setWalletType("other");
     }
-  }, [connectWC, setCurrentStep, setWalletType]);
+  }, [
+    beginWcAttempt,
+    connectWC,
+    ecosystem,
+    failWcAttempt,
+    resolveWcAttempt,
+    setCurrentStep,
+    setWalletType
+  ]);
+  const retryWalletConnect = (0, import_react16.useCallback)(() => {
+    walletManager.cancelWalletConnectAttempt();
+    void WalletConnect();
+  }, [WalletConnect]);
   const disconnectWalletConnect = (0, import_react16.useCallback)(async () => {
     await walletManager.disconnect();
     setWalletType("other");
     setCurrentStep("home");
   }, [setCurrentStep, setWalletType]);
-  const walletConnectAddress = walletManager.status === "connected" && walletManager.connectedVia === "walletconnect" ? walletManager.wallet?.ecosystem === "evm" ? walletManager.identity?.addresses[0]?.address ?? null : null : null;
+  const walletConnectAddress = walletManager.status === "connected" && walletManager.connectedVia === "walletconnect" ? walletManager.identity?.addresses[0]?.address ?? null : null;
   return {
     walletConnectAddress,
     WalletConnect,
-    disconnectWalletConnect
+    disconnectWalletConnect,
+    wcStatus,
+    wcErrorMessage,
+    retryWalletConnect,
+    dismissWcStatus
   };
 }
-var import_react16;
+var import_react16, WC_CONNECT_TIMEOUT_MS;
 var init_useWalletConnect = __esm({
   "src/widget/state/deposit/useWalletConnect.ts"() {
     "use strict";
     import_react16 = require("react");
     init_config2();
     init_wallets();
+    WC_CONNECT_TIMEOUT_MS = 3e4;
   }
 });
 
@@ -9372,14 +9681,24 @@ function DepositProvider({
   const [walletType, setWalletType] = (0, import_react17.useState)(
     "other"
   );
-  const { walletConnectAddress, WalletConnect, disconnectWalletConnect } = useWalletConnect({
+  const [selectedNamespace, setSelectedNamespace] = (0, import_react17.useState)("evm");
+  const {
+    walletConnectAddress,
+    WalletConnect,
+    disconnectWalletConnect,
+    wcStatus,
+    wcErrorMessage,
+    retryWalletConnect,
+    dismissWcStatus
+  } = useWalletConnect({
     setWalletType,
-    setCurrentStep
+    setCurrentStep,
+    selectedNamespace,
+    setSelectedNamespace
   });
   const [selectedToken, setSelectedToken] = (0, import_react17.useState)(null);
   const [selectedChain, setSelectedChain] = (0, import_react17.useState)(null);
   const [amount, setAmount] = (0, import_react17.useState)("");
-  const [selectedNamespace, setSelectedNamespace] = (0, import_react17.useState)("evm");
   const walletAddress = (0, import_react17.useMemo)(
     () => walletType === "walletconnect" ? walletConnectAddress : otherWalletAddress,
     [walletType, walletConnectAddress, otherWalletAddress]
@@ -9451,7 +9770,11 @@ function DepositProvider({
       setWalletType,
       walletType,
       selectedNamespace,
-      setSelectedNamespace
+      setSelectedNamespace,
+      wcStatus,
+      wcErrorMessage,
+      retryWalletConnect,
+      dismissWcStatus
     }),
     [
       WalletConnect,
@@ -9467,7 +9790,11 @@ function DepositProvider({
       yourWalletTokens,
       yourWalletTokensLoading,
       selectedNamespace,
-      setSelectedNamespace
+      setSelectedNamespace,
+      wcStatus,
+      wcErrorMessage,
+      retryWalletConnect,
+      dismissWcStatus
     ]
   );
   const formValue = (0, import_react17.useMemo)(
@@ -16089,6 +16416,18 @@ var init_WalletNamespaceTabs = __esm({
 });
 
 // src/widget/features/wallet/components/CryptoWalletDropdownContent.tsx
+function ecosystemToNamespace(ecosystem) {
+  switch (ecosystem.trim().toLowerCase()) {
+    case "evm":
+      return "evm";
+    case "solana":
+      return "Solana";
+    case "bitcoin":
+      return "bitcoin";
+    default:
+      return null;
+  }
+}
 function DesktopWalletDropdownContent({
   browserWallets,
   handleWalletConnect,
@@ -16154,11 +16493,13 @@ function DesktopWalletDropdownContent({
   );
 }
 function MobileWalletDropdownContent({
-  handleWalletConnect
+  browserWallets,
+  handleWalletConnect,
+  handleWalletSelect: connectDetectedWallet2
 }) {
   const { setCurrentStep } = useDepositNavigation();
-  const { selectedNamespace } = useDepositWallet();
-  const { walletMetaId, isConnected, status } = useWalletInfo();
+  const { selectedNamespace, setSelectedNamespace } = useDepositWallet();
+  const { walletMetaId, isConnected, status, detected } = useWalletInfo();
   const [hoveredId, setHoveredId] = (0, import_react34.useState)(null);
   const storeFallbackTimeoutRef = (0, import_react34.useRef)(
     null
@@ -16170,22 +16511,52 @@ function MobileWalletDropdownContent({
       }
     };
   }, []);
+  (0, import_react34.useEffect)(() => {
+    if (browserWallets.length > 0) return;
+    const otherEcosystemWallet = detected.find((d) => {
+      if (d.meta.id === "walletconnect") return false;
+      const ecosystem = d.meta.ecosystem.trim().toLowerCase();
+      return ecosystem !== "multi" && ecosystem !== selectedNamespace.trim().toLowerCase();
+    });
+    if (!otherEcosystemWallet) return;
+    const nextNamespace = ecosystemToNamespace(
+      otherEcosystemWallet.meta.ecosystem
+    );
+    if (nextNamespace) setSelectedNamespace(nextNamespace);
+  }, [browserWallets, detected, selectedNamespace, setSelectedNamespace]);
   const connectedWalletId = isConnected ? walletMetaId : null;
   const currentUrl = window.location.href;
-  const mobileWallets = (0, import_react34.useMemo)(
-    () => WALLETS.filter((w) => {
-      if (w.id === "walletconnect") return true;
+  const mobileWallets = (0, import_react34.useMemo)(() => {
+    const entries = WALLETS.filter((w) => {
+      if (w.id === "walletconnect") {
+        return selectedNamespace.trim().toLowerCase() === "evm";
+      }
+      const isDetected = browserWallets.some((d) => d.meta.id === w.id);
       const hasMobileLink = Boolean(w.deepLink);
-      if (!hasMobileLink) return false;
+      if (!hasMobileLink && !isDetected) return false;
       return w.ecosystem.trim().toLowerCase() === "multi" || w.ecosystem.trim().toLowerCase() === selectedNamespace.trim().toLowerCase();
-    }),
-    [selectedNamespace]
-  );
-  const handleWalletSelect = (wallet) => {
+    }).map((meta) => ({
+      meta,
+      detectedWallet: browserWallets.find((d) => d.meta.id === meta.id) ?? null
+    }));
+    const listedIds = new Set(entries.map((e2) => e2.meta.id));
+    for (const detected2 of browserWallets) {
+      if (!listedIds.has(detected2.meta.id)) {
+        entries.push({ meta: detected2.meta, detectedWallet: detected2 });
+      }
+    }
+    return entries;
+  }, [browserWallets, selectedNamespace]);
+  const handleWalletSelect = (entry) => {
+    const { meta: wallet, detectedWallet } = entry;
     if (wallet.id === "walletconnect") {
       handleWalletConnect();
       return;
     }
+    if (detectedWallet) {
+      void connectDetectedWallet2(detectedWallet);
+      return;
+    }
     if (wallet.deepLink) {
       const deepLinkUrl = wallet.deepLink(currentUrl);
       if (deepLinkUrl) {
@@ -16255,15 +16626,16 @@ function MobileWalletDropdownContent({
               scrollbarWidth: "thin",
               scrollbarColor: `${colors.muted} transparent`
             },
-            children: mobileWallets.map((wallet) => {
+            children: mobileWallets.map((entry) => {
+              const wallet = entry.meta;
               const isConnectedWallet = wallet.id === connectedWalletId;
-              const isDisabled = isConnected && !isConnectedWallet;
+              const isDisabled = isConnected && !isConnectedWallet && !entry.detectedWallet;
               const isHovered = hoveredId === wallet.id;
               return /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)(
                 "button",
                 {
                   type: "button",
-                  onClick: () => !isDisabled && handleWalletSelect(wallet),
+                  onClick: () => !isDisabled && handleWalletSelect(entry),
                   onMouseEnter: () => !isDisabled && setHoveredId(wallet.id),
                   onMouseLeave: () => setHoveredId(null),
                   style: {
@@ -16339,7 +16711,7 @@ function MobileWalletDropdownContent({
                               }
                             }
                           ),
-                          /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("span", { style: { fontSize: fontSize.xs, color: "#22c55e" }, children: "Connected" })
+                          /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("span", { style: { fontSize: fontSize.xs, color: "#22c55e" }, children: "Continue" })
                         ]
                       }
                     )
@@ -16404,7 +16776,9 @@ function CryptoWalletDropdownContent({
     isMobile && /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(
       MobileWalletDropdownContent,
       {
-        handleWalletConnect
+        browserWallets,
+        handleWalletConnect,
+        handleWalletSelect
       }
     )
   ] });
@@ -16946,9 +17320,11 @@ function useHomeWalletActions({
   const { selectedNamespace } = useDepositWallet();
   const browserWallets = (0, import_react35.useMemo)(() => {
     if (!detectedWallets?.length) return [];
-    return detectedWallets.filter(
-      (wallet) => wallet?.meta?.id !== "walletconnect" && wallet?.meta?.ecosystem.trim().toLowerCase() === selectedNamespace.trim().toLowerCase()
-    );
+    return detectedWallets.filter((wallet) => {
+      if (wallet?.meta?.id === "walletconnect") return false;
+      const ecosystem = wallet?.meta?.ecosystem.trim().toLowerCase();
+      return ecosystem === "multi" || ecosystem === selectedNamespace.trim().toLowerCase();
+    });
   }, [detectedWallets, selectedNamespace]);
   return {
     browserWallets,
@@ -16984,10 +17360,113 @@ var init_wallet = __esm({
 });
 
 // src/widget/pages/Home.tsx
+function WalletConnectStatusBanner({
+  status,
+  errorMessage,
+  onRetry,
+  onDismiss
+}) {
+  const isDone = status !== "connecting";
+  const isFailed = status === "failed";
+  const { text, icon } = wcBannerCopy[status];
+  return /* @__PURE__ */ (0, import_jsx_runtime44.jsxs)(
+    "div",
+    {
+      style: {
+        display: "flex",
+        alignItems: "center",
+        gap: spacing[2],
+        width: "100%",
+        padding: `${spacing[2.5]} ${spacing[3]}`,
+        marginBottom: spacing[4],
+        borderRadius: borderRadius.lg,
+        backgroundColor: isFailed ? "rgba(239,68,68,0.1)" : isDone ? "rgba(234,179,8,0.1)" : colors.muted,
+        border: isFailed ? "1px solid rgba(239,68,68,0.4)" : isDone ? "1px solid rgba(234,179,8,0.4)" : `1px solid ${colors.border}`
+      },
+      children: [
+        icon === "spinner" ? /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(
+          "div",
+          {
+            style: {
+              width: "0.875rem",
+              height: "0.875rem",
+              border: `2px solid ${colors.mutedForeground}`,
+              borderTopColor: "transparent",
+              borderRadius: "9999px",
+              animation: "tw-spin 1s linear infinite",
+              flexShrink: 0
+            }
+          }
+        ) : /* @__PURE__ */ (0, import_jsx_runtime44.jsx)("span", { style: { fontSize: fontSize.sm, flexShrink: 0 }, "aria-hidden": true, children: icon }),
+        /* @__PURE__ */ (0, import_jsx_runtime44.jsxs)(
+          "p",
+          {
+            style: {
+              flex: 1,
+              fontSize: fontSize.xs,
+              color: isDone ? colors.foreground : colors.mutedForeground,
+              margin: 0
+            },
+            children: [
+              text,
+              isFailed && errorMessage ? ` ${errorMessage}` : ""
+            ]
+          }
+        ),
+        isDone && /* @__PURE__ */ (0, import_jsx_runtime44.jsxs)(import_jsx_runtime44.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(
+            "button",
+            {
+              type: "button",
+              onClick: onRetry,
+              style: {
+                fontSize: fontSize.xs,
+                fontWeight: fontWeight.semibold,
+                color: colors.primary,
+                backgroundColor: "transparent",
+                border: 0,
+                cursor: "pointer",
+                flexShrink: 0
+              },
+              children: "Retry"
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(
+            "button",
+            {
+              type: "button",
+              onClick: onDismiss,
+              "aria-label": "Dismiss",
+              style: {
+                fontSize: fontSize.xs,
+                color: colors.mutedForeground,
+                backgroundColor: "transparent",
+                border: 0,
+                cursor: "pointer",
+                flexShrink: 0,
+                padding: 0,
+                lineHeight: 1
+              },
+              children: "\xD7"
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
 function Home({ style: _style }) {
   const { amount, setAmount, amountInputMode, setAmountInputMode } = useDepositForm();
   const { setCurrentStep, setCurrentStepInternal } = useDepositNavigation();
-  const { connectWallet, WalletConnect, setWalletType } = useDepositWallet();
+  const {
+    connectWallet,
+    WalletConnect,
+    setWalletType,
+    wcStatus,
+    wcErrorMessage,
+    retryWalletConnect,
+    dismissWcStatus
+  } = useDepositWallet();
   const { resolvedTheme } = useDepositUi();
   const { fixedFromAmountString, isFixedAmount, minAmountUsd, maxAmountUsd } = useAmountConstraints();
   const { detected: detectedWallets } = useWalletDetection();
@@ -17069,6 +17548,15 @@ function Home({ style: _style }) {
               position: "relative"
             },
             children: [
+              wcStatus !== "idle" && /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(
+                WalletConnectStatusBanner,
+                {
+                  status: wcStatus,
+                  errorMessage: wcErrorMessage,
+                  onRetry: retryWalletConnect,
+                  onDismiss: dismissWcStatus
+                }
+              ),
               /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(
                 "p",
                 {
@@ -17144,7 +17632,7 @@ function Home({ style: _style }) {
     }
   );
 }
-var import_jsx_runtime44;
+var import_jsx_runtime44, wcBannerCopy;
 var init_Home = __esm({
   "src/widget/pages/Home.tsx"() {
     "use strict";
@@ -17155,6 +17643,20 @@ var init_Home = __esm({
     init_wallets();
     init_wallet();
     import_jsx_runtime44 = require("react/jsx-runtime");
+    wcBannerCopy = {
+      connecting: {
+        text: "Waiting for wallet approval via WalletConnect\u2026",
+        icon: "spinner"
+      },
+      timedOut: {
+        text: "Still waiting on WalletConnect \u2014 this is taking longer than expected.",
+        icon: "\u26A0\uFE0F"
+      },
+      failed: {
+        text: "WalletConnect connection failed.",
+        icon: "\u2715"
+      }
+    };
   }
 });
 
@@ -30964,7 +31466,7 @@ async function sendRouteAsUserOperation(params) {
     );
   }
   console.debug("[send] UserOp included", { userOpHash, txHash });
-  await submitReceipt(intentId, txHash, getSponsorshipRequestId());
+  await submitReceipt(intentId, txHash, getSponsorshipRequestId(), eoaAddress);
   return { userOpHash, txHash, intentId };
 }
 var NATIVE_ADDRS;
@@ -33861,6 +34363,7 @@ function SwapWalletSelectorMobile({
                     const { meta } = entry;
                     const isWalletConnected = managerConnected && walletMetaId === meta.id;
                     const isConnecting = connectingId === meta.id && walletStatus === "connecting";
+                    const isRowDisabled = managerConnected && !isWalletConnected && !entry.detectedWallet;
                     return /* @__PURE__ */ (0, import_jsx_runtime56.jsxs)(
                       "div",
                       {
@@ -33878,7 +34381,8 @@ function SwapWalletSelectorMobile({
                           isWalletConnected && {
                             boxShadow: `0 0 0 2px ${colors.primary}`,
                             border: `1px solid ${colors.primary}`
-                          }
+                          },
+                          isRowDisabled && { opacity: 0.4 }
                         ),
                         children: [
                           /* @__PURE__ */ (0, import_jsx_runtime56.jsx)(
@@ -33969,7 +34473,7 @@ function SwapWalletSelectorMobile({
                             "button",
                             {
                               onClick: () => void handleClick(entry),
-                              disabled: walletStatus === "connecting",
+                              disabled: walletStatus === "connecting" || isRowDisabled,
                               style: mergeStyles(
                                 {
                                   padding: `${spacing[1.5]} ${spacing[3]}`,
@@ -33982,7 +34486,7 @@ function SwapWalletSelectorMobile({
                                   cursor: "pointer",
                                   flexShrink: 0
                                 },
-                                walletStatus === "connecting" && {
+                                (walletStatus === "connecting" || isRowDisabled) && {
                                   opacity: 0.5,
                                   cursor: "not-allowed"
                                 }
@@ -34010,6 +34514,7 @@ function SwapWalletSelectorMobile({
                 ),
                 (() => {
                   const wcConnected = managerConnected && connectedVia === "walletconnect";
+                  const wcRowDisabled = managerConnected && !wcConnected;
                   return /* @__PURE__ */ (0, import_jsx_runtime56.jsxs)(
                     "div",
                     {
@@ -34028,9 +34533,10 @@ function SwapWalletSelectorMobile({
                         wcConnected && {
                           boxShadow: `0 0 0 2px ${colors.primary}`,
                           border: `1px solid ${colors.primary}`
-                        }
+                        },
+                        wcRowDisabled && { opacity: 0.4, cursor: "not-allowed" }
                       ),
-                      onClick: !wcConnected ? () => void handleWalletConnect() : void 0,
+                      onClick: !wcConnected && !wcRowDisabled ? () => void handleWalletConnect() : void 0,
                       children: [
                         /* @__PURE__ */ (0, import_jsx_runtime56.jsx)(
                           "div",
@@ -34126,18 +34632,24 @@ function SwapWalletSelectorMobile({
                               e2.stopPropagation();
                               void handleWalletConnect();
                             },
-                            disabled: wcConnecting,
-                            style: {
-                              padding: `${spacing[1.5]} ${spacing[3]}`,
-                              borderRadius: "9999px",
-                              backgroundColor: "rgba(59,130,246,0.1)",
-                              color: colors.primary,
-                              fontSize: fontSize.xs,
-                              fontWeight: fontWeight.medium,
-                              border: 0,
-                              cursor: "pointer",
-                              flexShrink: 0
-                            },
+                            disabled: wcConnecting || wcRowDisabled,
+                            style: mergeStyles(
+                              {
+                                padding: `${spacing[1.5]} ${spacing[3]}`,
+                                borderRadius: "9999px",
+                                backgroundColor: "rgba(59,130,246,0.1)",
+                                color: colors.primary,
+                                fontSize: fontSize.xs,
+                                fontWeight: fontWeight.medium,
+                                border: 0,
+                                cursor: "pointer",
+                                flexShrink: 0
+                              },
+                              (wcConnecting || wcRowDisabled) && {
+                                opacity: 0.5,
+                                cursor: "not-allowed"
+                              }
+                            ),
                             children: "Connect"
                           }
                         )
@@ -35045,7 +35557,7 @@ function SwapMode({
     }).catch(() => {
     });
   }, [defaultDestRef, allChains]);
-  const { walletAddress, walletStatus, connectWallet, disconnectWallet } = useWalletSessionState();
+  const { walletAddress, walletStatus, connectWallet } = useWalletSessionState();
   const setFromTokenStable = (0, import_react50.useCallback)(
     (t) => setFromToken(t),
     []
@@ -37123,7 +37635,7 @@ function SwapMode({
                     walletAddress ? /* @__PURE__ */ (0, import_jsx_runtime59.jsxs)(
                       "button",
                       {
-                        onClick: () => void disconnectWallet(),
+                        onClick: handleConnectAndReview,
                         style: {
                           fontSize: fontSize.xs,
                           color: colors.mutedForeground,
@@ -37134,8 +37646,7 @@ function SwapMode({
                         children: [
                           walletAddress.slice(0, 6),
                           "...",
-                          walletAddress.slice(-4),
-                          " \xD7"
+                          walletAddress.slice(-4)
                         ]
                       }
                     ) : /* @__PURE__ */ (0, import_jsx_runtime59.jsx)(
@@ -39235,7 +39746,7 @@ var init_TrustwareWidgetV2 = __esm({
       if (!isOpen) {
         return null;
       }
-      if (config.features.swapMode) {
+      if (config.mode === "swap") {
         return /* @__PURE__ */ (0, import_jsx_runtime60.jsx)(SwapMode, { theme, style });
       }
       return /* @__PURE__ */ (0, import_jsx_runtime60.jsx)(DepositProvider, { initialStep: effectiveInitialStep, children: /* @__PURE__ */ (0, import_jsx_runtime60.jsx)(