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

package/dist/wallet.cjs

@@ -250,7 +250,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";
     API_PREFIX = "/api";
     WALLETCONNECT_PROJECT_ID = "72ea74c400f5111d43aea638d7d83a24";
@@ -1214,7 +1214,9 @@ var init_chains = __esm({
       btc: "bitcoin",
       bitcoin: "bitcoin",
       sei: "cosmos",
-      "pacific-1": "cosmos"
+      "pacific-1": "cosmos",
+      nibiru: "cosmos",
+      "cataclysm-1": "cosmos"
     };
   }
 });
@@ -1257,16 +1259,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) {
@@ -1316,15 +1325,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." };
   }
 }
-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";
@@ -1332,6 +1338,37 @@ 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"
+    };
+  }
+});
+
+// src/errors/TrustwareError.ts
+var TrustwareError;
+var init_TrustwareError = __esm({
+  "src/errors/TrustwareError.ts"() {
+    "use strict";
+    TrustwareError = class extends Error {
+      constructor(params) {
+        super(params.message);
+        this.name = "TrustwareError";
+        this.code = params.code;
+        this.userMessage = params.userMessage;
+        this.cause = params.cause;
+      }
+      toJSON() {
+        return {
+          name: this.name,
+          code: this.code,
+          message: this.message,
+          userMessage: this.userMessage
+        };
+      }
+    };
   }
 });
 
@@ -1340,21 +1377,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
@@ -1503,8 +1547,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",
@@ -1552,8 +1598,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 ─────────────────────────────
       {
@@ -2076,7 +2124,7 @@ var init_walletconnect = __esm({
     solanaMainnet = {
       id: 900,
       chainNamespace: "solana",
-      caipNetworkId: "solana:5eykt4UsFv8P8NJdTREpY1vzqAQ3H1FQ",
+      caipNetworkId: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
       name: "Solana Mainnet",
       nativeCurrency: {
         name: "Solana",
@@ -2954,8 +3002,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",
@@ -3031,7 +3133,7 @@ function useWireDetectionIntoManager() {
 function useWalletConnectConnect(walletCfg) {
   const cfgRef = { current: walletCfg };
   return (0, import_react2.useCallback)(
-    () => walletManager.connectWalletConnect(cfgRef.current),
+    (ecosystem) => walletManager.connectWalletConnect(cfgRef.current, ecosystem),
     []
   );
 }
@@ -3051,6 +3153,7 @@ function useWalletInfo(wagmi) {
     connectedVia: snapshot.connectedVia,
     walletType: snapshot.walletType,
     status: snapshot.status,
+    detected: snapshot.detected,
     disconnect
   };
 }
@@ -3203,44 +3306,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;
@@ -3255,6 +3353,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(() => {
@@ -3464,46 +3656,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";
@@ -3522,13 +3748,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,
@@ -3541,12 +3770,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;
   }
 });
 
@@ -4121,7 +4353,9 @@ __export(wallet_exports, {
   buildDetectedWalletFromProvider: () => buildDetectedWalletFromProvider,
   connectDetectedWallet: () => connectDetectedWallet,
   createWalletConnectEntry: () => createWalletConnectEntry,
+  decodeBase64: () => decodeBase64,
   detectSolanaWallets: () => detectSolanaWallets,
+  encodeBase64: () => encodeBase64,
   formatDeepLink: () => formatDeepLink,
   formatWalletConnectDeepLink: () => formatWalletConnectDeepLink,
   formatWalletConnectDeepLinkForWallet: () => formatWalletConnectDeepLinkForWallet,
@@ -4149,7 +4383,9 @@ init_wallets2();
   buildDetectedWalletFromProvider,
   connectDetectedWallet,
   createWalletConnectEntry,
+  decodeBase64,
   detectSolanaWallets,
+  encodeBase64,
   formatDeepLink,
   formatWalletConnectDeepLink,
   formatWalletConnectDeepLinkForWallet,