@trustware/sdk-staging 1.0.16-staging.13 → 1.0.17-staging.14

package/dist/index.mjs

@@ -1,5 +1,6 @@
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -7,6 +8,7 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/config/defaults.ts
 var DEFAULT_SLIPPAGE, DEFAULT_AUTO_DETECT_PROVIDER, DEFAULT_THEME, DEFAULT_MESSAGES;
@@ -52,7 +54,7 @@ var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
     SDK_NAME = "@trustware/sdk";
-    SDK_VERSION = "1.0.16-staging.13";
+    SDK_VERSION = "1.0.17-staging.14";
     API_ROOT = "https://bv-staging-api.trustware.io";
     API_PREFIX = "/api";
     ASSETS_BASE_URL = "https://app.trustware.io";
@@ -247,6 +249,75 @@ var init_store = __esm({
   }
 });
 
+// src/utils/chains.ts
+function inferChainTypeFromValue(normalized) {
+  if (!normalized) return void 0;
+  const aliased = CHAIN_TYPE_ALIASES[normalized];
+  if (aliased) return aliased;
+  if (normalized === "evm" || normalized === "solana" || normalized === "cosmos" || normalized === "bitcoin") {
+    return normalized;
+  }
+  if (/^eip155:\d+$/.test(normalized) || /^\d+$/.test(normalized)) {
+    return "evm";
+  }
+  if (normalized.startsWith("solana:") || normalized.includes("solana")) {
+    return "solana";
+  }
+  if (normalized.startsWith("cosmos:") || normalized.startsWith("sei:") || normalized === "sei-evm") {
+    return "cosmos";
+  }
+  return void 0;
+}
+function normalizeChainKey(value) {
+  if (value === void 0 || value === null) return "";
+  return String(value).trim().toLowerCase();
+}
+function normalizeChainType(chain) {
+  if (!chain) return void 0;
+  const raw = typeof chain === "string" ? chain : chain.type ?? chain.chainType ?? chain.networkIdentifier ?? chain.chainId ?? chain.id ?? chain.networkName ?? chain.axelarChainName;
+  if (!raw) return void 0;
+  const normalized = String(raw).trim().toLowerCase();
+  return inferChainTypeFromValue(normalized) ?? normalized;
+}
+function getNativeTokenAddress(chainType) {
+  return normalizeChainType(chainType) === "solana" ? NATIVE_SOLANA : NATIVE_EVM;
+}
+function isSolanaNativeTokenAlias(address) {
+  if (!address) return false;
+  const trimmed = address.trim();
+  if (!trimmed) return false;
+  return trimmed === NATIVE_SOLANA || trimmed.toLowerCase() === NATIVE_EVM;
+}
+function normalizeAddress(address, chainType) {
+  const trimmed = address.trim();
+  if (normalizeChainType(chainType) === "solana") {
+    if (isSolanaNativeTokenAlias(trimmed)) {
+      return NATIVE_SOLANA;
+    }
+    return trimmed;
+  }
+  return trimmed.toLowerCase();
+}
+function isZeroAddressLike(address, chainType) {
+  if (!address) return true;
+  const normalized = normalizeAddress(address, chainType);
+  return normalized === normalizeAddress(getNativeTokenAddress(chainType), chainType) || normalized === "0x0000000000000000000000000000000000000000";
+}
+var NATIVE_EVM, NATIVE_SOLANA, CHAIN_TYPE_ALIASES;
+var init_chains = __esm({
+  "src/utils/chains.ts"() {
+    "use strict";
+    NATIVE_EVM = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+    NATIVE_SOLANA = "So11111111111111111111111111111111111111111";
+    CHAIN_TYPE_ALIASES = {
+      btc: "bitcoin",
+      bitcoin: "bitcoin",
+      sei: "cosmos",
+      "pacific-1": "cosmos"
+    };
+  }
+});
+
 // src/config/index.ts
 var init_config2 = __esm({
   "src/config/index.ts"() {
@@ -401,16 +472,28 @@ __export(registry_exports, {
   NATIVE: () => NATIVE,
   Registry: () => Registry
 });
+function getChainAliases(chain) {
+  const values = [
+    chain.chainId,
+    chain.id,
+    chain.networkIdentifier,
+    chain.axelarChainName,
+    chain.networkName
+  ];
+  return values.map((value) => normalizeChainKey(value)).filter(Boolean);
+}
 var NATIVE, Registry;
 var init_registry = __esm({
   "src/registry.ts"() {
     "use strict";
     init_store();
+    init_chains();
     NATIVE = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
     Registry = class {
       constructor(baseURL) {
         this.baseURL = baseURL;
         this._chainsById = /* @__PURE__ */ new Map();
+        this._chainAliases = /* @__PURE__ */ new Map();
         this._tokensByChain = /* @__PURE__ */ new Map();
         this._loaded = false;
         this._loadingPromise = null;
@@ -428,13 +511,18 @@ var init_registry = __esm({
           this._loadingPromise = null;
         }
       }
+      storeToken(chainKey, token) {
+        const list = this._tokensByChain.get(chainKey) ?? [];
+        list.push(token);
+        this._tokensByChain.set(chainKey, list);
+      }
       async load() {
         const cfg = TrustwareConfigStore.get();
         const [chainsRes, tokensRes] = await Promise.all([
-          fetch(`${this.baseURL}/squid/chains`, {
+          fetch(`${this.baseURL}/v1/routes/chains`, {
             headers: { Accept: "application/json", "X-API-Key": cfg.apiKey }
           }),
-          fetch(`${this.baseURL}/squid/tokens`, {
+          fetch(`${this.baseURL}/v1/routes/tokens`, {
             headers: { Accept: "application/json", "X-API-Key": cfg.apiKey }
           })
         ]);
@@ -443,58 +531,80 @@ var init_registry = __esm({
         const chains = await chainsRes.json();
         const tokens = await tokensRes.json();
         const chainsArr = Array.isArray(chains) ? chains : chains.data ?? [];
-        for (const c of chainsArr) {
-          const canonical = c?.chainId ?? c?.id;
+        for (const chain of chainsArr) {
+          const canonical = chain?.chainId ?? chain?.id;
           if (canonical == null) continue;
-          const chainId = c.chainId ?? canonical;
           const normalized = {
-            ...c,
-            id: c.id ?? canonical,
-            chainId
+            ...chain,
+            id: chain.id ?? canonical,
+            chainId: chain.chainId ?? canonical
           };
-          this._chainsById.set(String(canonical), normalized);
+          const canonicalKey = normalizeChainKey(canonical);
+          this._chainsById.set(canonicalKey, normalized);
+          for (const alias of getChainAliases(normalized)) {
+            this._chainAliases.set(alias, canonicalKey);
+          }
         }
         const tokensArr = Array.isArray(tokens) ? tokens : tokens.data ?? [];
-        for (const t of tokensArr) {
-          const canonical = t?.chainId;
-          if (canonical == null) continue;
-          const id = String(canonical);
+        for (const token of tokensArr) {
+          const chainRef = token?.chainId;
+          if (chainRef == null) continue;
           const normalized = {
-            ...t,
-            chainId: t.chainId ?? canonical
+            ...token,
+            chainId: token.chainId ?? chainRef
           };
-          if (!this._tokensByChain.has(id)) this._tokensByChain.set(id, []);
-          this._tokensByChain.get(id).push(normalized);
+          const resolvedChain = this.chain(chainRef);
+          const aliases = resolvedChain ? getChainAliases(resolvedChain) : [normalizeChainKey(chainRef)];
+          for (const alias of aliases) {
+            this.storeToken(alias, normalized);
+          }
         }
         this._loaded = true;
       }
       chains() {
         return Array.from(this._chainsById.values());
       }
-      chain(chainId) {
-        return this._chainsById.get(String(chainId));
+      chain(chainRef) {
+        const normalized = normalizeChainKey(chainRef);
+        const canonicalKey = this._chainAliases.get(normalized) ?? normalized;
+        return this._chainsById.get(canonicalKey);
       }
       allTokens() {
-        const all = [];
+        const unique = /* @__PURE__ */ new Map();
         for (const list of this._tokensByChain.values()) {
-          all.push(...list);
+          for (const token of list) {
+            unique.set(`${token.chainId}:${token.address}`, token);
+          }
         }
-        return all;
+        return Array.from(unique.values());
       }
-      tokens(chainId) {
-        return this._tokensByChain.get(String(chainId)) ?? [];
+      tokens(chainRef) {
+        return this._tokensByChain.get(normalizeChainKey(chainRef)) ?? [];
       }
-      resolveToken(chainId, input) {
+      findToken(chainRef, address) {
+        const chain = this.chain(chainRef);
+        const chainType = normalizeChainType(chain);
+        const normalizedAddress = normalizeAddress(address, chainType);
+        return this.tokens(chainRef).find((token) => {
+          return normalizeAddress(token.address, chainType) === normalizedAddress;
+        });
+      }
+      resolveToken(chainRef, input) {
         if (!input) return void 0;
         const s = String(input).trim();
+        const chain = this.chain(chainRef);
+        const chainType = normalizeChainType(chain);
         if (/^0x[0-9a-fA-F]{40}$/.test(s)) return s;
-        const chain = this.chain(chainId);
-        const nativeSym = chain?.nativeCurrency?.symbol?.toUpperCase?.();
-        if (nativeSym && s.toUpperCase() === nativeSym) return NATIVE;
-        if (["ETH", "MATIC", "AVAX", "BNB", "NATIVE"].includes(s.toUpperCase()))
-          return NATIVE;
-        const list = this.tokens(chainId);
-        const hit = list.find((t) => t.symbol?.toUpperCase?.() === s.toUpperCase());
+        if (chainType === "solana" && s.length > 20) return s;
+        const nativeAddress = getNativeTokenAddress(chainType);
+        const nativeSymbol = chain?.nativeCurrency?.symbol?.toUpperCase?.();
+        if (nativeSymbol && s.toUpperCase() === nativeSymbol || ["ETH", "MATIC", "AVAX", "BNB", "SOL", "NATIVE"].includes(s.toUpperCase())) {
+          return chainType === "solana" ? nativeAddress : NATIVE;
+        }
+        const hit = this.tokens(chainRef).find((token) => {
+          if (!token.symbol) return false;
+          return token.symbol.toUpperCase() === s.toUpperCase();
+        });
         if (hit) return hit.address;
         return s;
       }
@@ -640,6 +750,7 @@ function useEIP1193(eth) {
   if (!eth?.request) throw new Error("useEIP1193: invalid provider");
   let switching = false;
   return {
+    ecosystem: "evm",
     type: "eip1193",
     async getAddress() {
       const [a] = await eth.request({
@@ -661,12 +772,12 @@ function useEIP1193(eth) {
           method: "wallet_switchEthereumChain",
           params: [{ chainId: hex }]
         });
-      } catch (e) {
-        if (e?.code === 4902) {
+      } catch (e2) {
+        if (e2?.code === 4902) {
           await addThenSwitch(eth, chainId);
-        } else if (e?.code === 4001) {
+        } else if (e2?.code === 4001) {
         } else {
-          throw e;
+          throw e2;
         }
       } finally {
         switching = false;
@@ -711,11 +822,11 @@ function useWagmi(client) {
           method: "wallet_switchEthereumChain",
           params: [{ chainId: hex }]
         });
-      } catch (e) {
-        if (e?.code === 4902) await addThenSwitch(eth, target);
-        else if (e?.code === 4001)
+      } catch (e2) {
+        if (e2?.code === 4902) await addThenSwitch(eth, target);
+        else if (e2?.code === 4001)
           ;
-        else throw e;
+        else throw e2;
       }
     } finally {
       switching = false;
@@ -747,6 +858,7 @@ function useWagmi(client) {
     }
   }
   return {
+    ecosystem: "evm",
     type: "wagmi",
     getAddress,
     getChainId,
@@ -755,9 +867,123 @@ function useWagmi(client) {
   };
 }
 
+// src/wallets/solana.ts
+import { Connection, Transaction, VersionedTransaction } from "@solana/web3.js";
+var SOLANA_WALLET_IDS = [
+  "phantom-solana",
+  "solflare",
+  "backpack"
+];
+function getPublicKeyString(provider) {
+  const publicKey = provider?.publicKey;
+  if (!publicKey) return null;
+  const text = publicKey.toString().trim();
+  return text || null;
+}
+function decodeBase64(serializedTransaction) {
+  const trimmed = serializedTransaction.trim();
+  if (typeof Buffer !== "undefined") {
+    return Uint8Array.from(Buffer.from(trimmed, "base64"));
+  }
+  const binary = globalThis.atob(trimmed);
+  return Uint8Array.from(binary, (char) => char.charCodeAt(0));
+}
+function decodeBase64Transaction(serializedTransaction) {
+  const bytes = decodeBase64(serializedTransaction);
+  try {
+    return VersionedTransaction.deserialize(bytes);
+  } catch {
+    return Transaction.from(bytes);
+  }
+}
+function getSolanaProviders() {
+  if (typeof window === "undefined") return {};
+  const win = window;
+  const providers = {};
+  const phantom = win.phantom?.solana ?? (win.solana?.isPhantom ? win.solana : void 0);
+  const solflare = win.solflare ?? (win.solana?.isSolflare ? win.solana : void 0);
+  const backpack = win.backpack?.solana ?? (win.solana?.isBackpack ? win.solana : void 0);
+  if (phantom) providers["phantom-solana"] = phantom;
+  if (solflare) providers.solflare = solflare;
+  if (backpack) providers.backpack = backpack;
+  return providers;
+}
+function detectSolanaWallets(wallets) {
+  const providers = getSolanaProviders();
+  return SOLANA_WALLET_IDS.flatMap((walletId) => {
+    const provider = providers[walletId];
+    const meta = wallets.find((item) => item.id === walletId);
+    if (!provider || !meta) return [];
+    return [{ meta, provider, via: "solana-window" }];
+  });
+}
+function bindSolanaProviderEvents(provider, handlers) {
+  const onConnect = () => handlers.onConnect?.();
+  const onAccountChanged = () => handlers.onAccountChanged?.();
+  const onDisconnect = () => handlers.onDisconnect?.();
+  provider.on?.("connect", onConnect);
+  provider.on?.("accountChanged", onAccountChanged);
+  provider.on?.("disconnect", onDisconnect);
+  return () => {
+    provider.off?.("connect", onConnect);
+    provider.off?.("accountChanged", onAccountChanged);
+    provider.off?.("disconnect", onDisconnect);
+    provider.removeListener?.("connect", onConnect);
+    provider.removeListener?.("accountChanged", onAccountChanged);
+    provider.removeListener?.("disconnect", onDisconnect);
+  };
+}
+function toSolanaWalletInterface(provider) {
+  return {
+    ecosystem: "solana",
+    type: "solana",
+    async getAddress() {
+      const current = getPublicKeyString(provider);
+      if (current) return current;
+      if (!provider.connect) {
+        throw new Error("Selected Solana wallet cannot connect");
+      }
+      await provider.connect();
+      const next = getPublicKeyString(provider);
+      if (!next) throw new Error("No connected Solana address");
+      return next;
+    },
+    async disconnect() {
+      await provider.disconnect?.();
+    },
+    async getChainKey() {
+      return "solana-mainnet-beta";
+    },
+    async sendSerializedTransaction(serializedTransactionBase64, rpcUrl) {
+      const transaction = decodeBase64Transaction(serializedTransactionBase64);
+      if (provider.signAndSendTransaction) {
+        const result = await provider.signAndSendTransaction(transaction, {
+          preflightCommitment: "confirmed"
+        });
+        if (typeof result === "string") return result;
+        if (result?.signature) return result.signature;
+      }
+      if (!provider.signTransaction) {
+        throw new Error("Connected Solana wallet cannot sign transactions");
+      }
+      const signed = await provider.signTransaction(transaction);
+      const connection = new Connection(
+        rpcUrl?.trim() || "https://api.mainnet-beta.solana.com",
+        "confirmed"
+      );
+      const signature = await connection.sendRawTransaction(signed.serialize());
+      await connection.confirmTransaction(signature, "confirmed");
+      return signature;
+    }
+  };
+}
+
 // src/wallets/adapters.ts
 function toWalletInterfaceFromDetected(dw) {
   if (!dw?.provider) throw new Error("No provider on detected wallet");
+  if (dw.via === "solana-window" || dw.meta.ecosystem === "solana") {
+    return toSolanaWalletInterface(dw.provider);
+  }
   const eth = dw.provider;
   return useEIP1193(eth);
 }
@@ -785,6 +1011,11 @@ async function connectDetectedWallet(dw, opts) {
     }
     throw new Error("WalletConnect connection failed. Please try again.");
   }
+  if (dw.via === "solana-window" || dw.meta.ecosystem === "solana") {
+    const api2 = toWalletInterfaceFromDetected(dw);
+    if (touchAddress) await api2.getAddress();
+    return { via: "eip1193", api: api2 };
+  }
   if (wagmi) {
     const conn = pickWagmiConnector(
       wagmi,
@@ -827,6 +1058,7 @@ var WALLETS = [
     id: "metamask",
     name: "MetaMask",
     category: "injected",
+    ecosystem: "evm",
     logo: `${ASSETS_BASE_URL}/assets/wallets/metamask.svg`,
     emoji: "\u{1F98A}",
     homepage: "https://metamask.io/",
@@ -834,20 +1066,11 @@ var WALLETS = [
     detectFlags: ["isMetaMask"],
     deepLink: (url) => formatDeepLink("metamask", url) ?? ""
   },
-  {
-    id: "rabby",
-    name: "Rabby",
-    category: "injected",
-    logo: `${ASSETS_BASE_URL}/assets/wallets/rabby.svg`,
-    emoji: "\u{1F430}",
-    homepage: "https://rabby.io/",
-    chromeWebStore: "https://chromewebstore.google.com/detail/rabby/acmacodkjbdgmoleebolmdjonilkdbch",
-    detectFlags: ["isRabby"]
-  },
   {
     id: "coinbase",
     name: "Coinbase Wallet",
     category: "app",
+    ecosystem: "evm",
     logo: `${ASSETS_BASE_URL}/assets/wallets/coinbase.svg`,
     emoji: "\u{1F7E6}",
     homepage: "https://www.coinbase.com/wallet",
@@ -858,6 +1081,7 @@ var WALLETS = [
     id: "walletconnect",
     name: "WalletConnect",
     category: "walletconnect",
+    ecosystem: "multi",
     logo: `${ASSETS_BASE_URL}/assets/wallets/walletconnect.svg`,
     emoji: "\u{1FA9D}",
     homepage: "https://walletconnect.com/"
@@ -866,6 +1090,7 @@ var WALLETS = [
     id: "rainbow",
     name: "Rainbow",
     category: "app",
+    ecosystem: "evm",
     logo: `${ASSETS_BASE_URL}/assets/wallets/rainbow.svg`,
     emoji: "\u{1F308}",
     homepage: "https://rainbow.me/",
@@ -873,27 +1098,82 @@ var WALLETS = [
     detectFlags: ["isRainbow"]
   },
   {
-    id: "okx",
-    name: "OKX",
+    id: "phantom-evm",
+    name: "Phantom (EVM)",
     category: "injected",
-    logo: `${ASSETS_BASE_URL}/assets/wallets/okx.svg`,
-    emoji: "\u2B1B",
-    homepage: "https://www.okx.com/web3",
-    detectFlags: ["isOkxWallet"]
+    ecosystem: "evm",
+    logo: `${ASSETS_BASE_URL}/assets/wallets/phantom.svg`,
+    emoji: "\u{1F47B}",
+    homepage: "https://phantom.app/",
+    detectFlags: ["isPhantom"]
+  },
+  {
+    id: "phantom-solana",
+    name: "Phantom (Solana)",
+    category: "injected",
+    ecosystem: "solana",
+    logo: `${ASSETS_BASE_URL}/assets/wallets/phantom.svg`,
+    emoji: "\u{1F47B}",
+    homepage: "https://phantom.app/",
+    android: "https://play.google.com/store/apps/details?id=app.phantom",
+    ios: "https://apps.apple.com/app/phantom-crypto-wallet/id1598432977",
+    deepLink: (url) => `phantom://browse/${encodeURIComponent(url)}`
+  },
+  {
+    id: "solflare",
+    name: "Solflare",
+    category: "injected",
+    ecosystem: "solana",
+    logo: `${ASSETS_BASE_URL}/assets/wallets/solflare-logo.svg`,
+    emoji: "\u2600\uFE0F",
+    homepage: "https://solflare.com/",
+    deepLink: (url) => `solflare://ul/v1/browse/${encodeURIComponent(url)}`
+  },
+  {
+    id: "backpack",
+    name: "Backpack",
+    category: "injected",
+    ecosystem: "solana",
+    logo: `${ASSETS_BASE_URL}/assets/wallets/backpack-logo.svg`,
+    emoji: "\u{1F392}",
+    homepage: "https://backpack.app/"
+  },
+  {
+    id: "rabby",
+    name: "Rabby",
+    category: "injected",
+    ecosystem: "evm",
+    logo: `${ASSETS_BASE_URL}/assets/wallets/rabby.svg`,
+    emoji: "\u{1F430}",
+    homepage: "https://rabby.io/",
+    chromeWebStore: "https://chromewebstore.google.com/detail/rabby/acmacodkjbdgmoleebolmdjonilkdbch",
+    detectFlags: ["isRabby"]
   },
   {
     id: "brave",
     name: "Brave Wallet",
     category: "injected",
+    ecosystem: "evm",
     logo: `${ASSETS_BASE_URL}/assets/wallets/brave.svg`,
     emoji: "\u{1F981}",
     homepage: "https://brave.com/wallet/",
     detectFlags: ["isBraveWallet"]
   },
+  {
+    id: "okx",
+    name: "OKX",
+    category: "injected",
+    ecosystem: "evm",
+    logo: `${ASSETS_BASE_URL}/assets/wallets/okx.svg`,
+    emoji: "\u2B1B",
+    homepage: "https://www.okx.com/web3",
+    detectFlags: ["isOkxWallet"]
+  },
   {
     id: "zerion",
     name: "Zerion",
     category: "app",
+    ecosystem: "evm",
     logo: `${ASSETS_BASE_URL}/assets/wallets/zerion.png`,
     emoji: "\u{1F9FF}",
     homepage: "https://zerion.io/wallet/"
@@ -902,6 +1182,7 @@ var WALLETS = [
     id: "taho",
     name: "Taho",
     category: "injected",
+    ecosystem: "evm",
     logo: `${ASSETS_BASE_URL}/assets/wallets/taho.png`,
     emoji: "\u{1F7EA}",
     homepage: "https://taho.xyz/",
@@ -911,6 +1192,7 @@ var WALLETS = [
     id: "trust",
     name: "Trust Wallet",
     category: "app",
+    ecosystem: "multi",
     logo: `${ASSETS_BASE_URL}/assets/wallets/trust.svg`,
     emoji: "\u{1F6E1}\uFE0F",
     homepage: "https://trustwallet.com/",
@@ -920,24 +1202,17 @@ var WALLETS = [
     id: "bitget",
     name: "Bitget Wallet",
     category: "injected",
+    ecosystem: "evm",
     logo: `${ASSETS_BASE_URL}/assets/wallets/bitget.svg`,
     emoji: "\u{1F7E9}",
     homepage: "https://web3.bitget.com/",
     detectFlags: ["isBitGetWallet"]
   },
-  {
-    id: "phantom-evm",
-    name: "Phantom (EVM)",
-    category: "injected",
-    logo: `${ASSETS_BASE_URL}/assets/wallets/phantom.svg`,
-    emoji: "\u{1F47B}",
-    homepage: "https://phantom.app/",
-    detectFlags: ["isPhantom"]
-  },
   {
     id: "safe",
     name: "Safe",
     category: "app",
+    ecosystem: "evm",
     logo: `${ASSETS_BASE_URL}/assets/wallets/safe.svg`,
     emoji: "\u{1F7E9}",
     homepage: "https://safe.global/"
@@ -946,6 +1221,7 @@ var WALLETS = [
     id: "kucoin",
     name: "KuCoin Wallet",
     category: "app",
+    ecosystem: "evm",
     logo: `${ASSETS_BASE_URL}/assets/wallets/kucoin.svg`,
     emoji: "\u{1F7E6}",
     homepage: "https://www.kucoin.com/"
@@ -1026,6 +1302,7 @@ function createGenericWalletMeta(name) {
     id: rawId,
     name,
     category: "injected",
+    ecosystem: "evm",
     logo: "",
     emoji: "\u{1F45B}"
   };
@@ -1096,8 +1373,8 @@ function useWalletDetection(timeoutMs = 400) {
     const w = window;
     const announced = [];
     const providerDetailMap = /* @__PURE__ */ new Map();
-    const onAnnounce = (e) => {
-      const ce = e;
+    const onAnnounce = (e2) => {
+      const ce = e2;
       if (ce?.detail?.provider?.request) {
         const detail = {
           info: ce.detail.info,
@@ -1139,6 +1416,11 @@ function useWalletDetection(timeoutMs = 400) {
           out.push(wallet);
         }
       }
+      for (const wallet of detectSolanaWallets(WALLETS)) {
+        if (seenIds.has(wallet.meta.id)) continue;
+        seenIds.add(wallet.meta.id);
+        out.push(wallet);
+      }
       setDetected(rankDetected(out));
       w.removeEventListener?.("eip6963:announceProvider", onAnnounce);
       done = true;
@@ -1155,6 +1437,1114 @@ function useWalletDetection(timeoutMs = 400) {
   return { detected, detectedIds };
 }
 
+// src/validation/address.ts
+import { isAddress as isEvmAddress } from "viem";
+
+// node_modules/@solana/errors/dist/index.node.mjs
+var SOLANA_ERROR__BLOCK_HEIGHT_EXCEEDED = 1;
+var SOLANA_ERROR__INVALID_NONCE = 2;
+var SOLANA_ERROR__NONCE_ACCOUNT_NOT_FOUND = 3;
+var SOLANA_ERROR__BLOCKHASH_STRING_LENGTH_OUT_OF_RANGE = 4;
+var SOLANA_ERROR__INVALID_BLOCKHASH_BYTE_LENGTH = 5;
+var SOLANA_ERROR__LAMPORTS_OUT_OF_RANGE = 6;
+var SOLANA_ERROR__MALFORMED_BIGINT_STRING = 7;
+var SOLANA_ERROR__MALFORMED_NUMBER_STRING = 8;
+var SOLANA_ERROR__TIMESTAMP_OUT_OF_RANGE = 9;
+var SOLANA_ERROR__MALFORMED_JSON_RPC_ERROR = 10;
+var SOLANA_ERROR__JSON_RPC__PARSE_ERROR = -32700;
+var SOLANA_ERROR__JSON_RPC__INTERNAL_ERROR = -32603;
+var SOLANA_ERROR__JSON_RPC__INVALID_PARAMS = -32602;
+var SOLANA_ERROR__JSON_RPC__METHOD_NOT_FOUND = -32601;
+var SOLANA_ERROR__JSON_RPC__INVALID_REQUEST = -32600;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_LONG_TERM_STORAGE_UNREACHABLE = -32019;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SLOT_NOT_EPOCH_BOUNDARY = -32018;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_EPOCH_REWARDS_PERIOD_ACTIVE = -32017;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_MIN_CONTEXT_SLOT_NOT_REACHED = -32016;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_UNSUPPORTED_TRANSACTION_VERSION = -32015;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_BLOCK_STATUS_NOT_AVAILABLE_YET = -32014;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_SIGNATURE_LEN_MISMATCH = -32013;
+var SOLANA_ERROR__JSON_RPC__SCAN_ERROR = -32012;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_HISTORY_NOT_AVAILABLE = -32011;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_KEY_EXCLUDED_FROM_SECONDARY_INDEX = -32010;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_LONG_TERM_STORAGE_SLOT_SKIPPED = -32009;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_NO_SNAPSHOT = -32008;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SLOT_SKIPPED = -32007;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_PRECOMPILE_VERIFICATION_FAILURE = -32006;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_NODE_UNHEALTHY = -32005;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_BLOCK_NOT_AVAILABLE = -32004;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_SIGNATURE_VERIFICATION_FAILURE = -32003;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE = -32002;
+var SOLANA_ERROR__JSON_RPC__SERVER_ERROR_BLOCK_CLEANED_UP = -32001;
+var SOLANA_ERROR__ADDRESSES__INVALID_BYTE_LENGTH = 28e5;
+var SOLANA_ERROR__ADDRESSES__STRING_LENGTH_OUT_OF_RANGE = 2800001;
+var SOLANA_ERROR__ADDRESSES__INVALID_BASE58_ENCODED_ADDRESS = 2800002;
+var SOLANA_ERROR__ADDRESSES__INVALID_ED25519_PUBLIC_KEY = 2800003;
+var SOLANA_ERROR__ADDRESSES__MALFORMED_PDA = 2800004;
+var SOLANA_ERROR__ADDRESSES__PDA_BUMP_SEED_OUT_OF_RANGE = 2800005;
+var SOLANA_ERROR__ADDRESSES__MAX_NUMBER_OF_PDA_SEEDS_EXCEEDED = 2800006;
+var SOLANA_ERROR__ADDRESSES__MAX_PDA_SEED_LENGTH_EXCEEDED = 2800007;
+var SOLANA_ERROR__ADDRESSES__INVALID_SEEDS_POINT_ON_CURVE = 2800008;
+var SOLANA_ERROR__ADDRESSES__FAILED_TO_FIND_VIABLE_PDA_BUMP_SEED = 2800009;
+var SOLANA_ERROR__ADDRESSES__PDA_ENDS_WITH_PDA_MARKER = 2800010;
+var SOLANA_ERROR__ADDRESSES__INVALID_OFF_CURVE_ADDRESS = 2800011;
+var SOLANA_ERROR__ACCOUNTS__ACCOUNT_NOT_FOUND = 323e4;
+var SOLANA_ERROR__ACCOUNTS__ONE_OR_MORE_ACCOUNTS_NOT_FOUND = 32300001;
+var SOLANA_ERROR__ACCOUNTS__FAILED_TO_DECODE_ACCOUNT = 3230002;
+var SOLANA_ERROR__ACCOUNTS__EXPECTED_DECODED_ACCOUNT = 3230003;
+var SOLANA_ERROR__ACCOUNTS__EXPECTED_ALL_ACCOUNTS_TO_BE_DECODED = 3230004;
+var SOLANA_ERROR__SUBTLE_CRYPTO__DISALLOWED_IN_INSECURE_CONTEXT = 361e4;
+var SOLANA_ERROR__SUBTLE_CRYPTO__DIGEST_UNIMPLEMENTED = 3610001;
+var SOLANA_ERROR__SUBTLE_CRYPTO__ED25519_ALGORITHM_UNIMPLEMENTED = 3610002;
+var SOLANA_ERROR__SUBTLE_CRYPTO__EXPORT_FUNCTION_UNIMPLEMENTED = 3610003;
+var SOLANA_ERROR__SUBTLE_CRYPTO__GENERATE_FUNCTION_UNIMPLEMENTED = 3610004;
+var SOLANA_ERROR__SUBTLE_CRYPTO__SIGN_FUNCTION_UNIMPLEMENTED = 3610005;
+var SOLANA_ERROR__SUBTLE_CRYPTO__VERIFY_FUNCTION_UNIMPLEMENTED = 3610006;
+var SOLANA_ERROR__SUBTLE_CRYPTO__CANNOT_EXPORT_NON_EXTRACTABLE_KEY = 3610007;
+var SOLANA_ERROR__CRYPTO__RANDOM_VALUES_FUNCTION_UNIMPLEMENTED = 3611e3;
+var SOLANA_ERROR__KEYS__INVALID_KEY_PAIR_BYTE_LENGTH = 3704e3;
+var SOLANA_ERROR__KEYS__INVALID_PRIVATE_KEY_BYTE_LENGTH = 3704001;
+var SOLANA_ERROR__KEYS__INVALID_SIGNATURE_BYTE_LENGTH = 3704002;
+var SOLANA_ERROR__KEYS__SIGNATURE_STRING_LENGTH_OUT_OF_RANGE = 3704003;
+var SOLANA_ERROR__KEYS__PUBLIC_KEY_MUST_MATCH_PRIVATE_KEY = 3704004;
+var SOLANA_ERROR__INSTRUCTION__EXPECTED_TO_HAVE_ACCOUNTS = 4128e3;
+var SOLANA_ERROR__INSTRUCTION__EXPECTED_TO_HAVE_DATA = 4128001;
+var SOLANA_ERROR__INSTRUCTION__PROGRAM_ID_MISMATCH = 4128002;
+var SOLANA_ERROR__INSTRUCTION_ERROR__UNKNOWN = 4615e3;
+var SOLANA_ERROR__INSTRUCTION_ERROR__GENERIC_ERROR = 4615001;
+var SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_ARGUMENT = 4615002;
+var SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_INSTRUCTION_DATA = 4615003;
+var SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_ACCOUNT_DATA = 4615004;
+var SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_DATA_TOO_SMALL = 4615005;
+var SOLANA_ERROR__INSTRUCTION_ERROR__INSUFFICIENT_FUNDS = 4615006;
+var SOLANA_ERROR__INSTRUCTION_ERROR__INCORRECT_PROGRAM_ID = 4615007;
+var SOLANA_ERROR__INSTRUCTION_ERROR__MISSING_REQUIRED_SIGNATURE = 4615008;
+var SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_ALREADY_INITIALIZED = 4615009;
+var SOLANA_ERROR__INSTRUCTION_ERROR__UNINITIALIZED_ACCOUNT = 4615010;
+var SOLANA_ERROR__INSTRUCTION_ERROR__UNBALANCED_INSTRUCTION = 4615011;
+var SOLANA_ERROR__INSTRUCTION_ERROR__MODIFIED_PROGRAM_ID = 4615012;
+var SOLANA_ERROR__INSTRUCTION_ERROR__EXTERNAL_ACCOUNT_LAMPORT_SPEND = 4615013;
+var SOLANA_ERROR__INSTRUCTION_ERROR__EXTERNAL_ACCOUNT_DATA_MODIFIED = 4615014;
+var SOLANA_ERROR__INSTRUCTION_ERROR__READONLY_LAMPORT_CHANGE = 4615015;
+var SOLANA_ERROR__INSTRUCTION_ERROR__READONLY_DATA_MODIFIED = 4615016;
+var SOLANA_ERROR__INSTRUCTION_ERROR__DUPLICATE_ACCOUNT_INDEX = 4615017;
+var SOLANA_ERROR__INSTRUCTION_ERROR__EXECUTABLE_MODIFIED = 4615018;
+var SOLANA_ERROR__INSTRUCTION_ERROR__RENT_EPOCH_MODIFIED = 4615019;
+var SOLANA_ERROR__INSTRUCTION_ERROR__NOT_ENOUGH_ACCOUNT_KEYS = 4615020;
+var SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_DATA_SIZE_CHANGED = 4615021;
+var SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_NOT_EXECUTABLE = 4615022;
+var SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_BORROW_FAILED = 4615023;
+var SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_BORROW_OUTSTANDING = 4615024;
+var SOLANA_ERROR__INSTRUCTION_ERROR__DUPLICATE_ACCOUNT_OUT_OF_SYNC = 4615025;
+var SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM = 4615026;
+var SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_ERROR = 4615027;
+var SOLANA_ERROR__INSTRUCTION_ERROR__EXECUTABLE_DATA_MODIFIED = 4615028;
+var SOLANA_ERROR__INSTRUCTION_ERROR__EXECUTABLE_LAMPORT_CHANGE = 4615029;
+var SOLANA_ERROR__INSTRUCTION_ERROR__EXECUTABLE_ACCOUNT_NOT_RENT_EXEMPT = 4615030;
+var SOLANA_ERROR__INSTRUCTION_ERROR__UNSUPPORTED_PROGRAM_ID = 4615031;
+var SOLANA_ERROR__INSTRUCTION_ERROR__CALL_DEPTH = 4615032;
+var SOLANA_ERROR__INSTRUCTION_ERROR__MISSING_ACCOUNT = 4615033;
+var SOLANA_ERROR__INSTRUCTION_ERROR__REENTRANCY_NOT_ALLOWED = 4615034;
+var SOLANA_ERROR__INSTRUCTION_ERROR__MAX_SEED_LENGTH_EXCEEDED = 4615035;
+var SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_SEEDS = 4615036;
+var SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_REALLOC = 4615037;
+var SOLANA_ERROR__INSTRUCTION_ERROR__COMPUTATIONAL_BUDGET_EXCEEDED = 4615038;
+var SOLANA_ERROR__INSTRUCTION_ERROR__PRIVILEGE_ESCALATION = 4615039;
+var SOLANA_ERROR__INSTRUCTION_ERROR__PROGRAM_ENVIRONMENT_SETUP_FAILURE = 4615040;
+var SOLANA_ERROR__INSTRUCTION_ERROR__PROGRAM_FAILED_TO_COMPLETE = 4615041;
+var SOLANA_ERROR__INSTRUCTION_ERROR__PROGRAM_FAILED_TO_COMPILE = 4615042;
+var SOLANA_ERROR__INSTRUCTION_ERROR__IMMUTABLE = 4615043;
+var SOLANA_ERROR__INSTRUCTION_ERROR__INCORRECT_AUTHORITY = 4615044;
+var SOLANA_ERROR__INSTRUCTION_ERROR__BORSH_IO_ERROR = 4615045;
+var SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_NOT_RENT_EXEMPT = 4615046;
+var SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_ACCOUNT_OWNER = 4615047;
+var SOLANA_ERROR__INSTRUCTION_ERROR__ARITHMETIC_OVERFLOW = 4615048;
+var SOLANA_ERROR__INSTRUCTION_ERROR__UNSUPPORTED_SYSVAR = 4615049;
+var SOLANA_ERROR__INSTRUCTION_ERROR__ILLEGAL_OWNER = 4615050;
+var SOLANA_ERROR__INSTRUCTION_ERROR__MAX_ACCOUNTS_DATA_ALLOCATIONS_EXCEEDED = 4615051;
+var SOLANA_ERROR__INSTRUCTION_ERROR__MAX_ACCOUNTS_EXCEEDED = 4615052;
+var SOLANA_ERROR__INSTRUCTION_ERROR__MAX_INSTRUCTION_TRACE_LENGTH_EXCEEDED = 4615053;
+var SOLANA_ERROR__INSTRUCTION_ERROR__BUILTIN_PROGRAMS_MUST_CONSUME_COMPUTE_UNITS = 4615054;
+var SOLANA_ERROR__SIGNER__ADDRESS_CANNOT_HAVE_MULTIPLE_SIGNERS = 5508e3;
+var SOLANA_ERROR__SIGNER__EXPECTED_KEY_PAIR_SIGNER = 5508001;
+var SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_SIGNER = 5508002;
+var SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_MODIFYING_SIGNER = 5508003;
+var SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_PARTIAL_SIGNER = 5508004;
+var SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SIGNER = 5508005;
+var SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_MODIFYING_SIGNER = 5508006;
+var SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_PARTIAL_SIGNER = 5508007;
+var SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SENDING_SIGNER = 5508008;
+var SOLANA_ERROR__SIGNER__TRANSACTION_CANNOT_HAVE_MULTIPLE_SENDING_SIGNERS = 5508009;
+var SOLANA_ERROR__SIGNER__TRANSACTION_SENDING_SIGNER_MISSING = 5508010;
+var SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED = 5508011;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__MAXIMUM_LENGTH_EXCEEDED = 5607e3;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__RESTRICTED_ASCII_BODY_CHARACTER_OUT_OF_RANGE = 5607001;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__APPLICATION_DOMAIN_STRING_LENGTH_OUT_OF_RANGE = 5607002;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__INVALID_APPLICATION_DOMAIN_BYTE_LENGTH = 5607003;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_SIGNATURES_MISMATCH = 5607004;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_REQUIRED_SIGNERS_CANNOT_BE_ZERO = 5607005;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__VERSION_NUMBER_NOT_SUPPORTED = 5607006;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_FORMAT_MISMATCH = 5607007;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_LENGTH_MISMATCH = 5607008;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_MUST_BE_NON_EMPTY = 5607009;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_ENVELOPE_SIGNATURES_CANNOT_BE_ZERO = 5607010;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURES_MISSING = 5607011;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__ENVELOPE_SIGNERS_MISMATCH = 5607012;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__ADDRESSES_CANNOT_SIGN_OFFCHAIN_MESSAGE = 5607013;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__UNEXPECTED_VERSION = 5607014;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_SORTED = 5607015;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_UNIQUE = 5607016;
+var SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURE_VERIFICATION_FAILURE = 5607017;
+var SOLANA_ERROR__TRANSACTION__INVOKED_PROGRAMS_CANNOT_PAY_FEES = 5663e3;
+var SOLANA_ERROR__TRANSACTION__INVOKED_PROGRAMS_MUST_NOT_BE_WRITABLE = 5663001;
+var SOLANA_ERROR__TRANSACTION__EXPECTED_BLOCKHASH_LIFETIME = 5663002;
+var SOLANA_ERROR__TRANSACTION__EXPECTED_NONCE_LIFETIME = 5663003;
+var SOLANA_ERROR__TRANSACTION__VERSION_NUMBER_OUT_OF_RANGE = 5663004;
+var SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_ADDRESS_LOOKUP_TABLE_CONTENTS_MISSING = 5663005;
+var SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_ADDRESS_LOOKUP_TABLE_INDEX_OUT_OF_RANGE = 5663006;
+var SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_INSTRUCTION_PROGRAM_ADDRESS_NOT_FOUND = 5663007;
+var SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_FEE_PAYER_MISSING = 5663008;
+var SOLANA_ERROR__TRANSACTION__SIGNATURES_MISSING = 5663009;
+var SOLANA_ERROR__TRANSACTION__ADDRESS_MISSING = 5663010;
+var SOLANA_ERROR__TRANSACTION__FEE_PAYER_MISSING = 5663011;
+var SOLANA_ERROR__TRANSACTION__FEE_PAYER_SIGNATURE_MISSING = 5663012;
+var SOLANA_ERROR__TRANSACTION__INVALID_NONCE_TRANSACTION_INSTRUCTIONS_MISSING = 5663013;
+var SOLANA_ERROR__TRANSACTION__INVALID_NONCE_TRANSACTION_FIRST_INSTRUCTION_MUST_BE_ADVANCE_NONCE = 5663014;
+var SOLANA_ERROR__TRANSACTION__ADDRESSES_CANNOT_SIGN_TRANSACTION = 5663015;
+var SOLANA_ERROR__TRANSACTION__CANNOT_ENCODE_WITH_EMPTY_SIGNATURES = 5663016;
+var SOLANA_ERROR__TRANSACTION__MESSAGE_SIGNATURES_MISMATCH = 5663017;
+var SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT = 5663018;
+var SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT = 5663019;
+var SOLANA_ERROR__TRANSACTION__EXCEEDS_SIZE_LIMIT = 5663020;
+var SOLANA_ERROR__TRANSACTION__VERSION_NUMBER_NOT_SUPPORTED = 5663021;
+var SOLANA_ERROR__TRANSACTION__NONCE_ACCOUNT_CANNOT_BE_IN_LOOKUP_TABLE = 5663022;
+var SOLANA_ERROR__TRANSACTION_ERROR__UNKNOWN = 705e4;
+var SOLANA_ERROR__TRANSACTION_ERROR__ACCOUNT_IN_USE = 7050001;
+var SOLANA_ERROR__TRANSACTION_ERROR__ACCOUNT_LOADED_TWICE = 7050002;
+var SOLANA_ERROR__TRANSACTION_ERROR__ACCOUNT_NOT_FOUND = 7050003;
+var SOLANA_ERROR__TRANSACTION_ERROR__PROGRAM_ACCOUNT_NOT_FOUND = 7050004;
+var SOLANA_ERROR__TRANSACTION_ERROR__INSUFFICIENT_FUNDS_FOR_FEE = 7050005;
+var SOLANA_ERROR__TRANSACTION_ERROR__INVALID_ACCOUNT_FOR_FEE = 7050006;
+var SOLANA_ERROR__TRANSACTION_ERROR__ALREADY_PROCESSED = 7050007;
+var SOLANA_ERROR__TRANSACTION_ERROR__BLOCKHASH_NOT_FOUND = 7050008;
+var SOLANA_ERROR__TRANSACTION_ERROR__CALL_CHAIN_TOO_DEEP = 7050009;
+var SOLANA_ERROR__TRANSACTION_ERROR__MISSING_SIGNATURE_FOR_FEE = 7050010;
+var SOLANA_ERROR__TRANSACTION_ERROR__INVALID_ACCOUNT_INDEX = 7050011;
+var SOLANA_ERROR__TRANSACTION_ERROR__SIGNATURE_FAILURE = 7050012;
+var SOLANA_ERROR__TRANSACTION_ERROR__INVALID_PROGRAM_FOR_EXECUTION = 7050013;
+var SOLANA_ERROR__TRANSACTION_ERROR__SANITIZE_FAILURE = 7050014;
+var SOLANA_ERROR__TRANSACTION_ERROR__CLUSTER_MAINTENANCE = 7050015;
+var SOLANA_ERROR__TRANSACTION_ERROR__ACCOUNT_BORROW_OUTSTANDING = 7050016;
+var SOLANA_ERROR__TRANSACTION_ERROR__WOULD_EXCEED_MAX_BLOCK_COST_LIMIT = 7050017;
+var SOLANA_ERROR__TRANSACTION_ERROR__UNSUPPORTED_VERSION = 7050018;
+var SOLANA_ERROR__TRANSACTION_ERROR__INVALID_WRITABLE_ACCOUNT = 7050019;
+var SOLANA_ERROR__TRANSACTION_ERROR__WOULD_EXCEED_MAX_ACCOUNT_COST_LIMIT = 7050020;
+var SOLANA_ERROR__TRANSACTION_ERROR__WOULD_EXCEED_ACCOUNT_DATA_BLOCK_LIMIT = 7050021;
+var SOLANA_ERROR__TRANSACTION_ERROR__TOO_MANY_ACCOUNT_LOCKS = 7050022;
+var SOLANA_ERROR__TRANSACTION_ERROR__ADDRESS_LOOKUP_TABLE_NOT_FOUND = 7050023;
+var SOLANA_ERROR__TRANSACTION_ERROR__INVALID_ADDRESS_LOOKUP_TABLE_OWNER = 7050024;
+var SOLANA_ERROR__TRANSACTION_ERROR__INVALID_ADDRESS_LOOKUP_TABLE_DATA = 7050025;
+var SOLANA_ERROR__TRANSACTION_ERROR__INVALID_ADDRESS_LOOKUP_TABLE_INDEX = 7050026;
+var SOLANA_ERROR__TRANSACTION_ERROR__INVALID_RENT_PAYING_ACCOUNT = 7050027;
+var SOLANA_ERROR__TRANSACTION_ERROR__WOULD_EXCEED_MAX_VOTE_COST_LIMIT = 7050028;
+var SOLANA_ERROR__TRANSACTION_ERROR__WOULD_EXCEED_ACCOUNT_DATA_TOTAL_LIMIT = 7050029;
+var SOLANA_ERROR__TRANSACTION_ERROR__DUPLICATE_INSTRUCTION = 7050030;
+var SOLANA_ERROR__TRANSACTION_ERROR__INSUFFICIENT_FUNDS_FOR_RENT = 7050031;
+var SOLANA_ERROR__TRANSACTION_ERROR__MAX_LOADED_ACCOUNTS_DATA_SIZE_EXCEEDED = 7050032;
+var SOLANA_ERROR__TRANSACTION_ERROR__INVALID_LOADED_ACCOUNTS_DATA_SIZE_LIMIT = 7050033;
+var SOLANA_ERROR__TRANSACTION_ERROR__RESANITIZATION_NEEDED = 7050034;
+var SOLANA_ERROR__TRANSACTION_ERROR__PROGRAM_EXECUTION_TEMPORARILY_RESTRICTED = 7050035;
+var SOLANA_ERROR__TRANSACTION_ERROR__UNBALANCED_TRANSACTION = 7050036;
+var SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN = 7618e3;
+var SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_PACKER_ALREADY_COMPLETE = 7618001;
+var SOLANA_ERROR__INSTRUCTION_PLANS__EMPTY_INSTRUCTION_PLAN = 7618002;
+var SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN = 7618003;
+var SOLANA_ERROR__INSTRUCTION_PLANS__NON_DIVISIBLE_TRANSACTION_PLANS_NOT_SUPPORTED = 7618004;
+var SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_SINGLE_TRANSACTION_PLAN_RESULT_NOT_FOUND = 7618005;
+var SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_INSTRUCTION_PLAN = 7618006;
+var SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN = 7618007;
+var SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT = 7618008;
+var SOLANA_ERROR__INSTRUCTION_PLANS__EXPECTED_SUCCESSFUL_TRANSACTION_PLAN_RESULT = 7618009;
+var SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY = 8078e3;
+var SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH = 8078001;
+var SOLANA_ERROR__CODECS__EXPECTED_FIXED_LENGTH = 8078002;
+var SOLANA_ERROR__CODECS__EXPECTED_VARIABLE_LENGTH = 8078003;
+var SOLANA_ERROR__CODECS__ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH = 8078004;
+var SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH = 8078005;
+var SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH = 8078006;
+var SOLANA_ERROR__CODECS__INVALID_NUMBER_OF_ITEMS = 8078007;
+var SOLANA_ERROR__CODECS__ENUM_DISCRIMINATOR_OUT_OF_RANGE = 8078008;
+var SOLANA_ERROR__CODECS__INVALID_DISCRIMINATED_UNION_VARIANT = 8078009;
+var SOLANA_ERROR__CODECS__INVALID_ENUM_VARIANT = 8078010;
+var SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE = 8078011;
+var SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE = 8078012;
+var SOLANA_ERROR__CODECS__EXPECTED_POSITIVE_BYTE_LENGTH = 8078013;
+var SOLANA_ERROR__CODECS__OFFSET_OUT_OF_RANGE = 8078014;
+var SOLANA_ERROR__CODECS__INVALID_LITERAL_UNION_VARIANT = 8078015;
+var SOLANA_ERROR__CODECS__LITERAL_UNION_DISCRIMINATOR_OUT_OF_RANGE = 8078016;
+var SOLANA_ERROR__CODECS__UNION_VARIANT_OUT_OF_RANGE = 8078017;
+var SOLANA_ERROR__CODECS__INVALID_CONSTANT = 8078018;
+var SOLANA_ERROR__CODECS__EXPECTED_ZERO_VALUE_TO_MATCH_ITEM_FIXED_SIZE = 8078019;
+var SOLANA_ERROR__CODECS__ENCODED_BYTES_MUST_NOT_INCLUDE_SENTINEL = 8078020;
+var SOLANA_ERROR__CODECS__SENTINEL_MISSING_IN_DECODED_BYTES = 8078021;
+var SOLANA_ERROR__CODECS__CANNOT_USE_LEXICAL_VALUES_AS_ENUM_DISCRIMINATORS = 8078022;
+var SOLANA_ERROR__CODECS__EXPECTED_DECODER_TO_CONSUME_ENTIRE_BYTE_ARRAY = 8078023;
+var SOLANA_ERROR__RPC__INTEGER_OVERFLOW = 81e5;
+var SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN = 8100001;
+var SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR = 8100002;
+var SOLANA_ERROR__RPC__API_PLAN_MISSING_FOR_RPC_METHOD = 8100003;
+var SOLANA_ERROR__RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_PLAN = 819e4;
+var SOLANA_ERROR__RPC_SUBSCRIPTIONS__EXPECTED_SERVER_SUBSCRIPTION_ID = 8190001;
+var SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CLOSED_BEFORE_MESSAGE_BUFFERED = 8190002;
+var SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CONNECTION_CLOSED = 8190003;
+var SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_FAILED_TO_CONNECT = 8190004;
+var SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_STATE_MISSING = 99e5;
+var SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE = 9900001;
+var SOLANA_ERROR__INVARIANT_VIOLATION__CACHED_ABORTABLE_ITERABLE_CACHE_ENTRY_MISSING = 9900002;
+var SOLANA_ERROR__INVARIANT_VIOLATION__SWITCH_MUST_BE_EXHAUSTIVE = 9900003;
+var SOLANA_ERROR__INVARIANT_VIOLATION__DATA_PUBLISHER_CHANNEL_UNIMPLEMENTED = 9900004;
+var SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_INSTRUCTION_PLAN_KIND = 9900005;
+var SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_TRANSACTION_PLAN_KIND = 9900006;
+function encodeValue(value) {
+  if (Array.isArray(value)) {
+    const commaSeparatedValues = value.map(encodeValue).join(
+      "%2C%20"
+      /* ", " */
+    );
+    return "%5B" + commaSeparatedValues + /* "]" */
+    "%5D";
+  } else if (typeof value === "bigint") {
+    return `${value}n`;
+  } else {
+    return encodeURIComponent(
+      String(
+        value != null && Object.getPrototypeOf(value) === null ? (
+          // Plain objects with no prototype don't have a `toString` method.
+          // Convert them before stringifying them.
+          { ...value }
+        ) : value
+      )
+    );
+  }
+}
+function encodeObjectContextEntry([key, value]) {
+  return `${key}=${encodeValue(value)}`;
+}
+function encodeContextObject(context) {
+  const searchParamsString = Object.entries(context).map(encodeObjectContextEntry).join("&");
+  return Buffer.from(searchParamsString, "utf8").toString("base64");
+}
+var SolanaErrorMessages = {
+  [SOLANA_ERROR__ACCOUNTS__ACCOUNT_NOT_FOUND]: "Account not found at address: $address",
+  [SOLANA_ERROR__ACCOUNTS__EXPECTED_ALL_ACCOUNTS_TO_BE_DECODED]: "Not all accounts were decoded. Encoded accounts found at addresses: $addresses.",
+  [SOLANA_ERROR__ACCOUNTS__EXPECTED_DECODED_ACCOUNT]: "Expected decoded account at address: $address",
+  [SOLANA_ERROR__ACCOUNTS__FAILED_TO_DECODE_ACCOUNT]: "Failed to decode account data at address: $address",
+  [SOLANA_ERROR__ACCOUNTS__ONE_OR_MORE_ACCOUNTS_NOT_FOUND]: "Accounts not found at addresses: $addresses",
+  [SOLANA_ERROR__ADDRESSES__FAILED_TO_FIND_VIABLE_PDA_BUMP_SEED]: "Unable to find a viable program address bump seed.",
+  [SOLANA_ERROR__ADDRESSES__INVALID_BASE58_ENCODED_ADDRESS]: "$putativeAddress is not a base58-encoded address.",
+  [SOLANA_ERROR__ADDRESSES__INVALID_BYTE_LENGTH]: "Expected base58 encoded address to decode to a byte array of length 32. Actual length: $actualLength.",
+  [SOLANA_ERROR__ADDRESSES__INVALID_ED25519_PUBLIC_KEY]: "The `CryptoKey` must be an `Ed25519` public key.",
+  [SOLANA_ERROR__ADDRESSES__INVALID_OFF_CURVE_ADDRESS]: "$putativeOffCurveAddress is not a base58-encoded off-curve address.",
+  [SOLANA_ERROR__ADDRESSES__INVALID_SEEDS_POINT_ON_CURVE]: "Invalid seeds; point must fall off the Ed25519 curve.",
+  [SOLANA_ERROR__ADDRESSES__MALFORMED_PDA]: "Expected given program derived address to have the following format: [Address, ProgramDerivedAddressBump].",
+  [SOLANA_ERROR__ADDRESSES__MAX_NUMBER_OF_PDA_SEEDS_EXCEEDED]: "A maximum of $maxSeeds seeds, including the bump seed, may be supplied when creating an address. Received: $actual.",
+  [SOLANA_ERROR__ADDRESSES__MAX_PDA_SEED_LENGTH_EXCEEDED]: "The seed at index $index with length $actual exceeds the maximum length of $maxSeedLength bytes.",
+  [SOLANA_ERROR__ADDRESSES__PDA_BUMP_SEED_OUT_OF_RANGE]: "Expected program derived address bump to be in the range [0, 255], got: $bump.",
+  [SOLANA_ERROR__ADDRESSES__PDA_ENDS_WITH_PDA_MARKER]: "Program address cannot end with PDA marker.",
+  [SOLANA_ERROR__ADDRESSES__STRING_LENGTH_OUT_OF_RANGE]: "Expected base58-encoded address string of length in the range [32, 44]. Actual length: $actualLength.",
+  [SOLANA_ERROR__BLOCKHASH_STRING_LENGTH_OUT_OF_RANGE]: "Expected base58-encoded blockash string of length in the range [32, 44]. Actual length: $actualLength.",
+  [SOLANA_ERROR__BLOCK_HEIGHT_EXCEEDED]: "The network has progressed past the last block for which this transaction could have been committed.",
+  [SOLANA_ERROR__CODECS__CANNOT_DECODE_EMPTY_BYTE_ARRAY]: "Codec [$codecDescription] cannot decode empty byte arrays.",
+  [SOLANA_ERROR__CODECS__CANNOT_USE_LEXICAL_VALUES_AS_ENUM_DISCRIMINATORS]: "Enum codec cannot use lexical values [$stringValues] as discriminators. Either remove all lexical values or set `useValuesAsDiscriminators` to `false`.",
+  [SOLANA_ERROR__CODECS__ENCODED_BYTES_MUST_NOT_INCLUDE_SENTINEL]: "Sentinel [$hexSentinel] must not be present in encoded bytes [$hexEncodedBytes].",
+  [SOLANA_ERROR__CODECS__ENCODER_DECODER_FIXED_SIZE_MISMATCH]: "Encoder and decoder must have the same fixed size, got [$encoderFixedSize] and [$decoderFixedSize].",
+  [SOLANA_ERROR__CODECS__ENCODER_DECODER_MAX_SIZE_MISMATCH]: "Encoder and decoder must have the same max size, got [$encoderMaxSize] and [$decoderMaxSize].",
+  [SOLANA_ERROR__CODECS__ENCODER_DECODER_SIZE_COMPATIBILITY_MISMATCH]: "Encoder and decoder must either both be fixed-size or variable-size.",
+  [SOLANA_ERROR__CODECS__ENUM_DISCRIMINATOR_OUT_OF_RANGE]: "Enum discriminator out of range. Expected a number in [$formattedValidDiscriminators], got $discriminator.",
+  [SOLANA_ERROR__CODECS__EXPECTED_FIXED_LENGTH]: "Expected a fixed-size codec, got a variable-size one.",
+  [SOLANA_ERROR__CODECS__EXPECTED_POSITIVE_BYTE_LENGTH]: "Codec [$codecDescription] expected a positive byte length, got $bytesLength.",
+  [SOLANA_ERROR__CODECS__EXPECTED_VARIABLE_LENGTH]: "Expected a variable-size codec, got a fixed-size one.",
+  [SOLANA_ERROR__CODECS__EXPECTED_ZERO_VALUE_TO_MATCH_ITEM_FIXED_SIZE]: "Codec [$codecDescription] expected zero-value [$hexZeroValue] to have the same size as the provided fixed-size item [$expectedSize bytes].",
+  [SOLANA_ERROR__CODECS__INVALID_BYTE_LENGTH]: "Codec [$codecDescription] expected $expected bytes, got $bytesLength.",
+  [SOLANA_ERROR__CODECS__INVALID_CONSTANT]: "Expected byte array constant [$hexConstant] to be present in data [$hexData] at offset [$offset].",
+  [SOLANA_ERROR__CODECS__INVALID_DISCRIMINATED_UNION_VARIANT]: "Invalid discriminated union variant. Expected one of [$variants], got $value.",
+  [SOLANA_ERROR__CODECS__INVALID_ENUM_VARIANT]: "Invalid enum variant. Expected one of [$stringValues] or a number in [$formattedNumericalValues], got $variant.",
+  [SOLANA_ERROR__CODECS__INVALID_LITERAL_UNION_VARIANT]: "Invalid literal union variant. Expected one of [$variants], got $value.",
+  [SOLANA_ERROR__CODECS__INVALID_NUMBER_OF_ITEMS]: "Expected [$codecDescription] to have $expected items, got $actual.",
+  [SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE]: "Invalid value $value for base $base with alphabet $alphabet.",
+  [SOLANA_ERROR__CODECS__LITERAL_UNION_DISCRIMINATOR_OUT_OF_RANGE]: "Literal union discriminator out of range. Expected a number between $minRange and $maxRange, got $discriminator.",
+  [SOLANA_ERROR__CODECS__NUMBER_OUT_OF_RANGE]: "Codec [$codecDescription] expected number to be in the range [$min, $max], got $value.",
+  [SOLANA_ERROR__CODECS__OFFSET_OUT_OF_RANGE]: "Codec [$codecDescription] expected offset to be in the range [0, $bytesLength], got $offset.",
+  [SOLANA_ERROR__CODECS__SENTINEL_MISSING_IN_DECODED_BYTES]: "Expected sentinel [$hexSentinel] to be present in decoded bytes [$hexDecodedBytes].",
+  [SOLANA_ERROR__CODECS__UNION_VARIANT_OUT_OF_RANGE]: "Union variant out of range. Expected an index between $minRange and $maxRange, got $variant.",
+  [SOLANA_ERROR__CODECS__EXPECTED_DECODER_TO_CONSUME_ENTIRE_BYTE_ARRAY]: "This decoder expected a byte array of exactly $expectedLength bytes, but $numExcessBytes unexpected excess bytes remained after decoding. Are you sure that you have chosen the correct decoder for this data?",
+  [SOLANA_ERROR__CRYPTO__RANDOM_VALUES_FUNCTION_UNIMPLEMENTED]: "No random values implementation could be found.",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_ALREADY_INITIALIZED]: "instruction requires an uninitialized account",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_BORROW_FAILED]: "instruction tries to borrow reference for an account which is already borrowed",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_BORROW_OUTSTANDING]: "instruction left account with an outstanding borrowed reference",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_DATA_SIZE_CHANGED]: "program other than the account's owner changed the size of the account data",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_DATA_TOO_SMALL]: "account data too small for instruction",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_NOT_EXECUTABLE]: "instruction expected an executable account",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__ACCOUNT_NOT_RENT_EXEMPT]: "An account does not have enough lamports to be rent-exempt",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__ARITHMETIC_OVERFLOW]: "Program arithmetic overflowed",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__BORSH_IO_ERROR]: "Failed to serialize or deserialize account data: $encodedData",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__BUILTIN_PROGRAMS_MUST_CONSUME_COMPUTE_UNITS]: "Builtin programs must consume compute units",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__CALL_DEPTH]: "Cross-program invocation call depth too deep",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__COMPUTATIONAL_BUDGET_EXCEEDED]: "Computational budget exceeded",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM]: "custom program error: #$code",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__DUPLICATE_ACCOUNT_INDEX]: "instruction contains duplicate accounts",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__DUPLICATE_ACCOUNT_OUT_OF_SYNC]: "instruction modifications of multiply-passed account differ",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__EXECUTABLE_ACCOUNT_NOT_RENT_EXEMPT]: "executable accounts must be rent exempt",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__EXECUTABLE_DATA_MODIFIED]: "instruction changed executable accounts data",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__EXECUTABLE_LAMPORT_CHANGE]: "instruction changed the balance of an executable account",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__EXECUTABLE_MODIFIED]: "instruction changed executable bit of an account",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__EXTERNAL_ACCOUNT_DATA_MODIFIED]: "instruction modified data of an account it does not own",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__EXTERNAL_ACCOUNT_LAMPORT_SPEND]: "instruction spent from the balance of an account it does not own",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__GENERIC_ERROR]: "generic instruction error",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__ILLEGAL_OWNER]: "Provided owner is not allowed",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__IMMUTABLE]: "Account is immutable",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__INCORRECT_AUTHORITY]: "Incorrect authority provided",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__INCORRECT_PROGRAM_ID]: "incorrect program id for instruction",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__INSUFFICIENT_FUNDS]: "insufficient funds for instruction",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_ACCOUNT_DATA]: "invalid account data for instruction",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_ACCOUNT_OWNER]: "Invalid account owner",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_ARGUMENT]: "invalid program argument",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_ERROR]: "program returned invalid error code",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_INSTRUCTION_DATA]: "invalid instruction data",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_REALLOC]: "Failed to reallocate account data",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__INVALID_SEEDS]: "Provided seeds do not result in a valid address",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__MAX_ACCOUNTS_DATA_ALLOCATIONS_EXCEEDED]: "Accounts data allocations exceeded the maximum allowed per transaction",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__MAX_ACCOUNTS_EXCEEDED]: "Max accounts exceeded",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__MAX_INSTRUCTION_TRACE_LENGTH_EXCEEDED]: "Max instruction trace length exceeded",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__MAX_SEED_LENGTH_EXCEEDED]: "Length of the seed is too long for address generation",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__MISSING_ACCOUNT]: "An account required by the instruction is missing",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__MISSING_REQUIRED_SIGNATURE]: "missing required signature for instruction",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__MODIFIED_PROGRAM_ID]: "instruction illegally modified the program id of an account",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__NOT_ENOUGH_ACCOUNT_KEYS]: "insufficient account keys for instruction",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__PRIVILEGE_ESCALATION]: "Cross-program invocation with unauthorized signer or writable account",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__PROGRAM_ENVIRONMENT_SETUP_FAILURE]: "Failed to create program execution environment",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__PROGRAM_FAILED_TO_COMPILE]: "Program failed to compile",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__PROGRAM_FAILED_TO_COMPLETE]: "Program failed to complete",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__READONLY_DATA_MODIFIED]: "instruction modified data of a read-only account",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__READONLY_LAMPORT_CHANGE]: "instruction changed the balance of a read-only account",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__REENTRANCY_NOT_ALLOWED]: "Cross-program invocation reentrancy not allowed for this instruction",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__RENT_EPOCH_MODIFIED]: "instruction modified rent epoch of an account",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__UNBALANCED_INSTRUCTION]: "sum of account balances before and after instruction do not match",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__UNINITIALIZED_ACCOUNT]: "instruction requires an initialized account",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__UNKNOWN]: "",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__UNSUPPORTED_PROGRAM_ID]: "Unsupported program id",
+  [SOLANA_ERROR__INSTRUCTION_ERROR__UNSUPPORTED_SYSVAR]: "Unsupported sysvar",
+  [SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_INSTRUCTION_PLAN_KIND]: "Invalid instruction plan kind: $kind.",
+  [SOLANA_ERROR__INSTRUCTION_PLANS__EMPTY_INSTRUCTION_PLAN]: "The provided instruction plan is empty.",
+  [SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_SINGLE_TRANSACTION_PLAN_RESULT_NOT_FOUND]: "No failed transaction plan result was found in the provided transaction plan result.",
+  [SOLANA_ERROR__INSTRUCTION_PLANS__NON_DIVISIBLE_TRANSACTION_PLANS_NOT_SUPPORTED]: "This transaction plan executor does not support non-divisible sequential plans. To support them, you may create your own executor such that multi-transaction atomicity is preserved \u2014 e.g. by targetting RPCs that support transaction bundles.",
+  [SOLANA_ERROR__INSTRUCTION_PLANS__FAILED_TO_EXECUTE_TRANSACTION_PLAN]: "The provided transaction plan failed to execute. See the `transactionPlanResult` attribute for more details. Note that the `cause` property is deprecated, and a future version will not set it.",
+  [SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN]: "The provided message has insufficient capacity to accommodate the next instruction(s) in this plan. Expected at least $numBytesRequired free byte(s), got $numFreeBytes byte(s).",
+  [SOLANA_ERROR__INVARIANT_VIOLATION__INVALID_TRANSACTION_PLAN_KIND]: "Invalid transaction plan kind: $kind.",
+  [SOLANA_ERROR__INSTRUCTION_PLANS__MESSAGE_PACKER_ALREADY_COMPLETE]: "No more instructions to pack; the message packer has completed the instruction plan.",
+  [SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_INSTRUCTION_PLAN]: "Unexpected instruction plan. Expected $expectedKind plan, got $actualKind plan.",
+  [SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN]: "Unexpected transaction plan. Expected $expectedKind plan, got $actualKind plan.",
+  [SOLANA_ERROR__INSTRUCTION_PLANS__UNEXPECTED_TRANSACTION_PLAN_RESULT]: "Unexpected transaction plan result. Expected $expectedKind plan, got $actualKind plan.",
+  [SOLANA_ERROR__INSTRUCTION_PLANS__EXPECTED_SUCCESSFUL_TRANSACTION_PLAN_RESULT]: "Expected a successful transaction plan result. I.e. there is at least one failed or cancelled transaction in the plan.",
+  [SOLANA_ERROR__INSTRUCTION__EXPECTED_TO_HAVE_ACCOUNTS]: "The instruction does not have any accounts.",
+  [SOLANA_ERROR__INSTRUCTION__EXPECTED_TO_HAVE_DATA]: "The instruction does not have any data.",
+  [SOLANA_ERROR__INSTRUCTION__PROGRAM_ID_MISMATCH]: "Expected instruction to have progress address $expectedProgramAddress, got $actualProgramAddress.",
+  [SOLANA_ERROR__INVALID_BLOCKHASH_BYTE_LENGTH]: "Expected base58 encoded blockhash to decode to a byte array of length 32. Actual length: $actualLength.",
+  [SOLANA_ERROR__INVALID_NONCE]: "The nonce `$expectedNonceValue` is no longer valid. It has advanced to `$actualNonceValue`",
+  [SOLANA_ERROR__INVARIANT_VIOLATION__CACHED_ABORTABLE_ITERABLE_CACHE_ENTRY_MISSING]: "Invariant violation: Found no abortable iterable cache entry for key `$cacheKey`. It should be impossible to hit this error; please file an issue at https://sola.na/web3invariant",
+  [SOLANA_ERROR__INVARIANT_VIOLATION__DATA_PUBLISHER_CHANNEL_UNIMPLEMENTED]: "Invariant violation: This data publisher does not publish to the channel named `$channelName`. Supported channels include $supportedChannelNames.",
+  [SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_MUST_NOT_POLL_BEFORE_RESOLVING_EXISTING_MESSAGE_PROMISE]: "Invariant violation: WebSocket message iterator state is corrupt; iterated without first resolving existing message promise. It should be impossible to hit this error; please file an issue at https://sola.na/web3invariant",
+  [SOLANA_ERROR__INVARIANT_VIOLATION__SUBSCRIPTION_ITERATOR_STATE_MISSING]: "Invariant violation: WebSocket message iterator is missing state storage. It should be impossible to hit this error; please file an issue at https://sola.na/web3invariant",
+  [SOLANA_ERROR__INVARIANT_VIOLATION__SWITCH_MUST_BE_EXHAUSTIVE]: "Invariant violation: Switch statement non-exhaustive. Received unexpected value `$unexpectedValue`. It should be impossible to hit this error; please file an issue at https://sola.na/web3invariant",
+  [SOLANA_ERROR__JSON_RPC__INTERNAL_ERROR]: "JSON-RPC error: Internal JSON-RPC error ($__serverMessage)",
+  [SOLANA_ERROR__JSON_RPC__INVALID_PARAMS]: "JSON-RPC error: Invalid method parameter(s) ($__serverMessage)",
+  [SOLANA_ERROR__JSON_RPC__INVALID_REQUEST]: "JSON-RPC error: The JSON sent is not a valid `Request` object ($__serverMessage)",
+  [SOLANA_ERROR__JSON_RPC__METHOD_NOT_FOUND]: "JSON-RPC error: The method does not exist / is not available ($__serverMessage)",
+  [SOLANA_ERROR__JSON_RPC__PARSE_ERROR]: "JSON-RPC error: An error occurred on the server while parsing the JSON text ($__serverMessage)",
+  [SOLANA_ERROR__JSON_RPC__SCAN_ERROR]: "$__serverMessage",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_BLOCK_CLEANED_UP]: "$__serverMessage",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_BLOCK_NOT_AVAILABLE]: "$__serverMessage",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_BLOCK_STATUS_NOT_AVAILABLE_YET]: "$__serverMessage",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_EPOCH_REWARDS_PERIOD_ACTIVE]: "Epoch rewards period still active at slot $slot",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_KEY_EXCLUDED_FROM_SECONDARY_INDEX]: "$__serverMessage",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_LONG_TERM_STORAGE_SLOT_SKIPPED]: "$__serverMessage",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_LONG_TERM_STORAGE_UNREACHABLE]: "Failed to query long-term storage; please try again",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_MIN_CONTEXT_SLOT_NOT_REACHED]: "Minimum context slot has not been reached",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_NODE_UNHEALTHY]: "Node is unhealthy; behind by $numSlotsBehind slots",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_NO_SNAPSHOT]: "No snapshot",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE]: "Transaction simulation failed",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SLOT_NOT_EPOCH_BOUNDARY]: "Rewards cannot be found because slot $slot is not the epoch boundary. This may be due to gap in the queried node's local ledger or long-term storage",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SLOT_SKIPPED]: "$__serverMessage",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_HISTORY_NOT_AVAILABLE]: "Transaction history is not available from this node",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_PRECOMPILE_VERIFICATION_FAILURE]: "$__serverMessage",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_SIGNATURE_LEN_MISMATCH]: "Transaction signature length mismatch",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_TRANSACTION_SIGNATURE_VERIFICATION_FAILURE]: "Transaction signature verification failure",
+  [SOLANA_ERROR__JSON_RPC__SERVER_ERROR_UNSUPPORTED_TRANSACTION_VERSION]: "$__serverMessage",
+  [SOLANA_ERROR__KEYS__INVALID_KEY_PAIR_BYTE_LENGTH]: "Key pair bytes must be of length 64, got $byteLength.",
+  [SOLANA_ERROR__KEYS__INVALID_PRIVATE_KEY_BYTE_LENGTH]: "Expected private key bytes with length 32. Actual length: $actualLength.",
+  [SOLANA_ERROR__KEYS__INVALID_SIGNATURE_BYTE_LENGTH]: "Expected base58-encoded signature to decode to a byte array of length 64. Actual length: $actualLength.",
+  [SOLANA_ERROR__KEYS__PUBLIC_KEY_MUST_MATCH_PRIVATE_KEY]: "The provided private key does not match the provided public key.",
+  [SOLANA_ERROR__KEYS__SIGNATURE_STRING_LENGTH_OUT_OF_RANGE]: "Expected base58-encoded signature string of length in the range [64, 88]. Actual length: $actualLength.",
+  [SOLANA_ERROR__LAMPORTS_OUT_OF_RANGE]: "Lamports value must be in the range [0, 2e64-1]",
+  [SOLANA_ERROR__MALFORMED_BIGINT_STRING]: "`$value` cannot be parsed as a `BigInt`",
+  [SOLANA_ERROR__MALFORMED_JSON_RPC_ERROR]: "$message",
+  [SOLANA_ERROR__MALFORMED_NUMBER_STRING]: "`$value` cannot be parsed as a `Number`",
+  [SOLANA_ERROR__NONCE_ACCOUNT_NOT_FOUND]: "No nonce account could be found at address `$nonceAccountAddress`",
+  [SOLANA_ERROR__OFFCHAIN_MESSAGE__INVALID_APPLICATION_DOMAIN_BYTE_LENGTH]: "Expected base58 encoded application domain to decode to a byte array of length 32. Actual length: $actualLength.",
+  [SOLANA_ERROR__OFFCHAIN_MESSAGE__ADDRESSES_CANNOT_SIGN_OFFCHAIN_MESSAGE]: "Attempted to sign an offchain message with an address that is not a signer for it",
+  [SOLANA_ERROR__OFFCHAIN_MESSAGE__APPLICATION_DOMAIN_STRING_LENGTH_OUT_OF_RANGE]: "Expected base58-encoded application domain string of length in the range [32, 44]. Actual length: $actualLength.",
+  [SOLANA_ERROR__OFFCHAIN_MESSAGE__ENVELOPE_SIGNERS_MISMATCH]: "The signer addresses in this offchain message envelope do not match the list of required signers in the message preamble. These unexpected signers were present in the envelope: `[$unexpectedSigners]`. These required signers were missing from the envelope `[$missingSigners]`.",
+  [SOLANA_ERROR__OFFCHAIN_MESSAGE__MAXIMUM_LENGTH_EXCEEDED]: "The message body provided has a byte-length of $actualBytes. The maximum allowable byte-length is $maxBytes",
+  [SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_FORMAT_MISMATCH]: "Expected message format $expectedMessageFormat, got $actualMessageFormat",
+  [SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_LENGTH_MISMATCH]: "The message length specified in the message preamble is $specifiedLength bytes. The actual length of the message is $actualLength bytes.",
+  [SOLANA_ERROR__OFFCHAIN_MESSAGE__MESSAGE_MUST_BE_NON_EMPTY]: "Offchain message content must be non-empty",
+  [SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_REQUIRED_SIGNERS_CANNOT_BE_ZERO]: "Offchain message must specify the address of at least one required signer",
+  [SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_ENVELOPE_SIGNATURES_CANNOT_BE_ZERO]: "Offchain message envelope must reserve space for at least one signature",
+  [SOLANA_ERROR__OFFCHAIN_MESSAGE__NUM_SIGNATURES_MISMATCH]: "The offchain message preamble specifies $numRequiredSignatures required signature(s), got $signaturesLength.",
+  [SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_SORTED]: "The signatories of this offchain message must be listed in lexicographical order",
+  [SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATORIES_MUST_BE_UNIQUE]: "An address must be listed no more than once among the signatories of an offchain message",
+  [SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURES_MISSING]: "Offchain message is missing signatures for addresses: $addresses.",
+  [SOLANA_ERROR__OFFCHAIN_MESSAGE__SIGNATURE_VERIFICATION_FAILURE]: "Offchain message signature verification failed. Signature mismatch for required signatories [$signatoriesWithInvalidSignatures]. Missing signatures for signatories [$signatoriesWithMissingSignatures]",
+  [SOLANA_ERROR__OFFCHAIN_MESSAGE__RESTRICTED_ASCII_BODY_CHARACTER_OUT_OF_RANGE]: "The message body provided contains characters whose codes fall outside the allowed range. In order to ensure clear-signing compatiblity with hardware wallets, the message may only contain line feeds and characters in the range [\\x20-\\x7e].",
+  [SOLANA_ERROR__OFFCHAIN_MESSAGE__UNEXPECTED_VERSION]: "Expected offchain message version $expectedVersion. Got $actualVersion.",
+  [SOLANA_ERROR__OFFCHAIN_MESSAGE__VERSION_NUMBER_NOT_SUPPORTED]: "This version of Kit does not support decoding offchain messages with version $unsupportedVersion. The current max supported version is 0.",
+  [SOLANA_ERROR__RPC_SUBSCRIPTIONS__CANNOT_CREATE_SUBSCRIPTION_PLAN]: "The notification name must end in 'Notifications' and the API must supply a subscription plan creator function for the notification '$notificationName'.",
+  [SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CLOSED_BEFORE_MESSAGE_BUFFERED]: "WebSocket was closed before payload could be added to the send buffer",
+  [SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_CONNECTION_CLOSED]: "WebSocket connection closed",
+  [SOLANA_ERROR__RPC_SUBSCRIPTIONS__CHANNEL_FAILED_TO_CONNECT]: "WebSocket failed to connect",
+  [SOLANA_ERROR__RPC_SUBSCRIPTIONS__EXPECTED_SERVER_SUBSCRIPTION_ID]: "Failed to obtain a subscription id from the server",
+  [SOLANA_ERROR__RPC__API_PLAN_MISSING_FOR_RPC_METHOD]: "Could not find an API plan for RPC method: `$method`",
+  [SOLANA_ERROR__RPC__INTEGER_OVERFLOW]: "The $argumentLabel argument to the `$methodName` RPC method$optionalPathLabel was `$value`. This number is unsafe for use with the Solana JSON-RPC because it exceeds `Number.MAX_SAFE_INTEGER`.",
+  [SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR]: "HTTP error ($statusCode): $message",
+  [SOLANA_ERROR__RPC__TRANSPORT_HTTP_HEADER_FORBIDDEN]: "HTTP header(s) forbidden: $headers. Learn more at https://developer.mozilla.org/en-US/docs/Glossary/Forbidden_header_name.",
+  [SOLANA_ERROR__SIGNER__ADDRESS_CANNOT_HAVE_MULTIPLE_SIGNERS]: "Multiple distinct signers were identified for address `$address`. Please ensure that you are using the same signer instance for each address.",
+  [SOLANA_ERROR__SIGNER__EXPECTED_KEY_PAIR_SIGNER]: "The provided value does not implement the `KeyPairSigner` interface",
+  [SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_MODIFYING_SIGNER]: "The provided value does not implement the `MessageModifyingSigner` interface",
+  [SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_PARTIAL_SIGNER]: "The provided value does not implement the `MessagePartialSigner` interface",
+  [SOLANA_ERROR__SIGNER__EXPECTED_MESSAGE_SIGNER]: "The provided value does not implement any of the `MessageSigner` interfaces",
+  [SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_MODIFYING_SIGNER]: "The provided value does not implement the `TransactionModifyingSigner` interface",
+  [SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_PARTIAL_SIGNER]: "The provided value does not implement the `TransactionPartialSigner` interface",
+  [SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SENDING_SIGNER]: "The provided value does not implement the `TransactionSendingSigner` interface",
+  [SOLANA_ERROR__SIGNER__EXPECTED_TRANSACTION_SIGNER]: "The provided value does not implement any of the `TransactionSigner` interfaces",
+  [SOLANA_ERROR__SIGNER__TRANSACTION_CANNOT_HAVE_MULTIPLE_SENDING_SIGNERS]: "More than one `TransactionSendingSigner` was identified.",
+  [SOLANA_ERROR__SIGNER__TRANSACTION_SENDING_SIGNER_MISSING]: "No `TransactionSendingSigner` was identified. Please provide a valid `TransactionWithSingleSendingSigner` transaction.",
+  [SOLANA_ERROR__SIGNER__WALLET_MULTISIGN_UNIMPLEMENTED]: "Wallet account signers do not support signing multiple messages/transactions in a single operation",
+  [SOLANA_ERROR__SUBTLE_CRYPTO__CANNOT_EXPORT_NON_EXTRACTABLE_KEY]: "Cannot export a non-extractable key.",
+  [SOLANA_ERROR__SUBTLE_CRYPTO__DIGEST_UNIMPLEMENTED]: "No digest implementation could be found.",
+  [SOLANA_ERROR__SUBTLE_CRYPTO__DISALLOWED_IN_INSECURE_CONTEXT]: "Cryptographic operations are only allowed in secure browser contexts. Read more here: https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts.",
+  [SOLANA_ERROR__SUBTLE_CRYPTO__ED25519_ALGORITHM_UNIMPLEMENTED]: "This runtime does not support the generation of Ed25519 key pairs.\n\nInstall @solana/webcrypto-ed25519-polyfill and call its `install` function before generating keys in environments that do not support Ed25519.\n\nFor a list of runtimes that currently support Ed25519 operations, visit https://github.com/WICG/webcrypto-secure-curves/issues/20.",
+  [SOLANA_ERROR__SUBTLE_CRYPTO__EXPORT_FUNCTION_UNIMPLEMENTED]: "No signature verification implementation could be found.",
+  [SOLANA_ERROR__SUBTLE_CRYPTO__GENERATE_FUNCTION_UNIMPLEMENTED]: "No key generation implementation could be found.",
+  [SOLANA_ERROR__SUBTLE_CRYPTO__SIGN_FUNCTION_UNIMPLEMENTED]: "No signing implementation could be found.",
+  [SOLANA_ERROR__SUBTLE_CRYPTO__VERIFY_FUNCTION_UNIMPLEMENTED]: "No key export implementation could be found.",
+  [SOLANA_ERROR__TIMESTAMP_OUT_OF_RANGE]: "Timestamp value must be in the range [-(2n ** 63n), (2n ** 63n) - 1]. `$value` given",
+  [SOLANA_ERROR__TRANSACTION_ERROR__ACCOUNT_BORROW_OUTSTANDING]: "Transaction processing left an account with an outstanding borrowed reference",
+  [SOLANA_ERROR__TRANSACTION_ERROR__ACCOUNT_IN_USE]: "Account in use",
+  [SOLANA_ERROR__TRANSACTION_ERROR__ACCOUNT_LOADED_TWICE]: "Account loaded twice",
+  [SOLANA_ERROR__TRANSACTION_ERROR__ACCOUNT_NOT_FOUND]: "Attempt to debit an account but found no record of a prior credit.",
+  [SOLANA_ERROR__TRANSACTION_ERROR__ADDRESS_LOOKUP_TABLE_NOT_FOUND]: "Transaction loads an address table account that doesn't exist",
+  [SOLANA_ERROR__TRANSACTION_ERROR__ALREADY_PROCESSED]: "This transaction has already been processed",
+  [SOLANA_ERROR__TRANSACTION_ERROR__BLOCKHASH_NOT_FOUND]: "Blockhash not found",
+  [SOLANA_ERROR__TRANSACTION_ERROR__CALL_CHAIN_TOO_DEEP]: "Loader call chain is too deep",
+  [SOLANA_ERROR__TRANSACTION_ERROR__CLUSTER_MAINTENANCE]: "Transactions are currently disabled due to cluster maintenance",
+  [SOLANA_ERROR__TRANSACTION_ERROR__DUPLICATE_INSTRUCTION]: "Transaction contains a duplicate instruction ($index) that is not allowed",
+  [SOLANA_ERROR__TRANSACTION_ERROR__INSUFFICIENT_FUNDS_FOR_FEE]: "Insufficient funds for fee",
+  [SOLANA_ERROR__TRANSACTION_ERROR__INSUFFICIENT_FUNDS_FOR_RENT]: "Transaction results in an account ($accountIndex) with insufficient funds for rent",
+  [SOLANA_ERROR__TRANSACTION_ERROR__INVALID_ACCOUNT_FOR_FEE]: "This account may not be used to pay transaction fees",
+  [SOLANA_ERROR__TRANSACTION_ERROR__INVALID_ACCOUNT_INDEX]: "Transaction contains an invalid account reference",
+  [SOLANA_ERROR__TRANSACTION_ERROR__INVALID_ADDRESS_LOOKUP_TABLE_DATA]: "Transaction loads an address table account with invalid data",
+  [SOLANA_ERROR__TRANSACTION_ERROR__INVALID_ADDRESS_LOOKUP_TABLE_INDEX]: "Transaction address table lookup uses an invalid index",
+  [SOLANA_ERROR__TRANSACTION_ERROR__INVALID_ADDRESS_LOOKUP_TABLE_OWNER]: "Transaction loads an address table account with an invalid owner",
+  [SOLANA_ERROR__TRANSACTION_ERROR__INVALID_LOADED_ACCOUNTS_DATA_SIZE_LIMIT]: "LoadedAccountsDataSizeLimit set for transaction must be greater than 0.",
+  [SOLANA_ERROR__TRANSACTION_ERROR__INVALID_PROGRAM_FOR_EXECUTION]: "This program may not be used for executing instructions",
+  [SOLANA_ERROR__TRANSACTION_ERROR__INVALID_RENT_PAYING_ACCOUNT]: "Transaction leaves an account with a lower balance than rent-exempt minimum",
+  [SOLANA_ERROR__TRANSACTION_ERROR__INVALID_WRITABLE_ACCOUNT]: "Transaction loads a writable account that cannot be written",
+  [SOLANA_ERROR__TRANSACTION_ERROR__MAX_LOADED_ACCOUNTS_DATA_SIZE_EXCEEDED]: "Transaction exceeded max loaded accounts data size cap",
+  [SOLANA_ERROR__TRANSACTION_ERROR__MISSING_SIGNATURE_FOR_FEE]: "Transaction requires a fee but has no signature present",
+  [SOLANA_ERROR__TRANSACTION_ERROR__PROGRAM_ACCOUNT_NOT_FOUND]: "Attempt to load a program that does not exist",
+  [SOLANA_ERROR__TRANSACTION_ERROR__PROGRAM_EXECUTION_TEMPORARILY_RESTRICTED]: "Execution of the program referenced by account at index $accountIndex is temporarily restricted.",
+  [SOLANA_ERROR__TRANSACTION_ERROR__RESANITIZATION_NEEDED]: "ResanitizationNeeded",
+  [SOLANA_ERROR__TRANSACTION_ERROR__SANITIZE_FAILURE]: "Transaction failed to sanitize accounts offsets correctly",
+  [SOLANA_ERROR__TRANSACTION_ERROR__SIGNATURE_FAILURE]: "Transaction did not pass signature verification",
+  [SOLANA_ERROR__TRANSACTION_ERROR__TOO_MANY_ACCOUNT_LOCKS]: "Transaction locked too many accounts",
+  [SOLANA_ERROR__TRANSACTION_ERROR__UNBALANCED_TRANSACTION]: "Sum of account balances before and after transaction do not match",
+  [SOLANA_ERROR__TRANSACTION_ERROR__UNKNOWN]: "The transaction failed with the error `$errorName`",
+  [SOLANA_ERROR__TRANSACTION_ERROR__UNSUPPORTED_VERSION]: "Transaction version is unsupported",
+  [SOLANA_ERROR__TRANSACTION_ERROR__WOULD_EXCEED_ACCOUNT_DATA_BLOCK_LIMIT]: "Transaction would exceed account data limit within the block",
+  [SOLANA_ERROR__TRANSACTION_ERROR__WOULD_EXCEED_ACCOUNT_DATA_TOTAL_LIMIT]: "Transaction would exceed total account data limit",
+  [SOLANA_ERROR__TRANSACTION_ERROR__WOULD_EXCEED_MAX_ACCOUNT_COST_LIMIT]: "Transaction would exceed max account limit within the block",
+  [SOLANA_ERROR__TRANSACTION_ERROR__WOULD_EXCEED_MAX_BLOCK_COST_LIMIT]: "Transaction would exceed max Block Cost Limit",
+  [SOLANA_ERROR__TRANSACTION_ERROR__WOULD_EXCEED_MAX_VOTE_COST_LIMIT]: "Transaction would exceed max Vote Cost Limit",
+  [SOLANA_ERROR__TRANSACTION__ADDRESSES_CANNOT_SIGN_TRANSACTION]: "Attempted to sign a transaction with an address that is not a signer for it",
+  [SOLANA_ERROR__TRANSACTION__ADDRESS_MISSING]: "Transaction is missing an address at index: $index.",
+  [SOLANA_ERROR__TRANSACTION__CANNOT_ENCODE_WITH_EMPTY_SIGNATURES]: "Transaction has no expected signers therefore it cannot be encoded",
+  [SOLANA_ERROR__TRANSACTION__EXCEEDS_SIZE_LIMIT]: "Transaction size $transactionSize exceeds limit of $transactionSizeLimit bytes",
+  [SOLANA_ERROR__TRANSACTION__EXPECTED_BLOCKHASH_LIFETIME]: "Transaction does not have a blockhash lifetime",
+  [SOLANA_ERROR__TRANSACTION__EXPECTED_NONCE_LIFETIME]: "Transaction is not a durable nonce transaction",
+  [SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_ADDRESS_LOOKUP_TABLE_CONTENTS_MISSING]: "Contents of these address lookup tables unknown: $lookupTableAddresses",
+  [SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_ADDRESS_LOOKUP_TABLE_INDEX_OUT_OF_RANGE]: "Lookup of address at index $highestRequestedIndex failed for lookup table `$lookupTableAddress`. Highest known index is $highestKnownIndex. The lookup table may have been extended since its contents were retrieved",
+  [SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_FEE_PAYER_MISSING]: "No fee payer set in CompiledTransaction",
+  [SOLANA_ERROR__TRANSACTION__FAILED_TO_DECOMPILE_INSTRUCTION_PROGRAM_ADDRESS_NOT_FOUND]: "Could not find program address at index $index",
+  [SOLANA_ERROR__TRANSACTION__FAILED_TO_ESTIMATE_COMPUTE_LIMIT]: "Failed to estimate the compute unit consumption for this transaction message. This is likely because simulating the transaction failed. Inspect the `cause` property of this error to learn more",
+  [SOLANA_ERROR__TRANSACTION__FAILED_WHEN_SIMULATING_TO_ESTIMATE_COMPUTE_LIMIT]: "Transaction failed when it was simulated in order to estimate the compute unit consumption. The compute unit estimate provided is for a transaction that failed when simulated and may not be representative of the compute units this transaction would consume if successful. Inspect the `cause` property of this error to learn more",
+  [SOLANA_ERROR__TRANSACTION__FEE_PAYER_MISSING]: "Transaction is missing a fee payer.",
+  [SOLANA_ERROR__TRANSACTION__FEE_PAYER_SIGNATURE_MISSING]: "Could not determine this transaction's signature. Make sure that the transaction has been signed by its fee payer.",
+  [SOLANA_ERROR__TRANSACTION__INVALID_NONCE_TRANSACTION_FIRST_INSTRUCTION_MUST_BE_ADVANCE_NONCE]: "Transaction first instruction is not advance nonce account instruction.",
+  [SOLANA_ERROR__TRANSACTION__INVALID_NONCE_TRANSACTION_INSTRUCTIONS_MISSING]: "Transaction with no instructions cannot be durable nonce transaction.",
+  [SOLANA_ERROR__TRANSACTION__INVOKED_PROGRAMS_CANNOT_PAY_FEES]: "This transaction includes an address (`$programAddress`) which is both invoked and set as the fee payer. Program addresses may not pay fees",
+  [SOLANA_ERROR__TRANSACTION__INVOKED_PROGRAMS_MUST_NOT_BE_WRITABLE]: "This transaction includes an address (`$programAddress`) which is both invoked and marked writable. Program addresses may not be writable",
+  [SOLANA_ERROR__TRANSACTION__MESSAGE_SIGNATURES_MISMATCH]: "The transaction message expected the transaction to have $numRequiredSignatures signatures, got $signaturesLength.",
+  [SOLANA_ERROR__TRANSACTION__SIGNATURES_MISSING]: "Transaction is missing signatures for addresses: $addresses.",
+  [SOLANA_ERROR__TRANSACTION__VERSION_NUMBER_OUT_OF_RANGE]: "Transaction version must be in the range [0, 127]. `$actualVersion` given",
+  [SOLANA_ERROR__TRANSACTION__VERSION_NUMBER_NOT_SUPPORTED]: "This version of Kit does not support decoding transactions with version $unsupportedVersion. The current max supported version is 0.",
+  [SOLANA_ERROR__TRANSACTION__NONCE_ACCOUNT_CANNOT_BE_IN_LOOKUP_TABLE]: "The transaction has a durable nonce lifetime (with nonce `$nonce`), but the nonce account address is in a lookup table. The lifetime constraint cannot be constructed without fetching the lookup tables for the transaction."
+};
+var START_INDEX = "i";
+var TYPE = "t";
+function getHumanReadableErrorMessage(code, context = {}) {
+  const messageFormatString = SolanaErrorMessages[code];
+  if (messageFormatString.length === 0) {
+    return "";
+  }
+  let state;
+  function commitStateUpTo(endIndex) {
+    if (state[TYPE] === 2) {
+      const variableName = messageFormatString.slice(state[START_INDEX] + 1, endIndex);
+      fragments.push(
+        variableName in context ? (
+          // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+          `${context[variableName]}`
+        ) : `$${variableName}`
+      );
+    } else if (state[TYPE] === 1) {
+      fragments.push(messageFormatString.slice(state[START_INDEX], endIndex));
+    }
+  }
+  const fragments = [];
+  messageFormatString.split("").forEach((char, ii) => {
+    if (ii === 0) {
+      state = {
+        [START_INDEX]: 0,
+        [TYPE]: messageFormatString[0] === "\\" ? 0 : messageFormatString[0] === "$" ? 2 : 1
+        /* Text */
+      };
+      return;
+    }
+    let nextState;
+    switch (state[TYPE]) {
+      case 0:
+        nextState = {
+          [START_INDEX]: ii,
+          [TYPE]: 1
+          /* Text */
+        };
+        break;
+      case 1:
+        if (char === "\\") {
+          nextState = {
+            [START_INDEX]: ii,
+            [TYPE]: 0
+            /* EscapeSequence */
+          };
+        } else if (char === "$") {
+          nextState = {
+            [START_INDEX]: ii,
+            [TYPE]: 2
+            /* Variable */
+          };
+        }
+        break;
+      case 2:
+        if (char === "\\") {
+          nextState = {
+            [START_INDEX]: ii,
+            [TYPE]: 0
+            /* EscapeSequence */
+          };
+        } else if (char === "$") {
+          nextState = {
+            [START_INDEX]: ii,
+            [TYPE]: 2
+            /* Variable */
+          };
+        } else if (!char.match(/\w/)) {
+          nextState = {
+            [START_INDEX]: ii,
+            [TYPE]: 1
+            /* Text */
+          };
+        }
+        break;
+    }
+    if (nextState) {
+      if (state !== nextState) {
+        commitStateUpTo(ii);
+      }
+      state = nextState;
+    }
+  });
+  commitStateUpTo();
+  return fragments.join("");
+}
+function getErrorMessage(code, context = {}) {
+  if (process.env.NODE_ENV !== "production") {
+    return getHumanReadableErrorMessage(code, context);
+  } else {
+    let decodingAdviceMessage = `Solana error #${code}; Decode this error by running \`npx @solana/errors decode -- ${code}`;
+    if (Object.keys(context).length) {
+      decodingAdviceMessage += ` '${encodeContextObject(context)}'`;
+    }
+    return `${decodingAdviceMessage}\``;
+  }
+}
+var SolanaError = class extends Error {
+  constructor(...[code, contextAndErrorOptions]) {
+    let context;
+    let errorOptions;
+    if (contextAndErrorOptions) {
+      Object.entries(Object.getOwnPropertyDescriptors(contextAndErrorOptions)).forEach(([name, descriptor]) => {
+        if (name === "cause") {
+          errorOptions = { cause: descriptor.value };
+        } else {
+          if (context === void 0) {
+            context = {
+              __code: code
+            };
+          }
+          Object.defineProperty(context, name, descriptor);
+        }
+      });
+    }
+    const message = getErrorMessage(code, context);
+    super(message, errorOptions);
+    /**
+     * Indicates the root cause of this {@link SolanaError}, if any.
+     *
+     * For example, a transaction error might have an instruction error as its root cause. In this
+     * case, you will be able to access the instruction error on the transaction error as `cause`.
+     */
+    __publicField(this, "cause", this.cause);
+    /**
+     * Contains context that can assist in understanding or recovering from a {@link SolanaError}.
+     */
+    __publicField(this, "context");
+    this.context = Object.freeze(
+      context === void 0 ? {
+        __code: code
+      } : context
+    );
+    this.name = "SolanaError";
+  }
+};
+
+// node_modules/@solana/codecs-core/dist/index.node.mjs
+function getEncodedSize(value, encoder) {
+  return "fixedSize" in encoder ? encoder.fixedSize : encoder.getSizeFromValue(value);
+}
+function createEncoder(encoder) {
+  return Object.freeze({
+    ...encoder,
+    encode: (value) => {
+      const bytes = new Uint8Array(getEncodedSize(value, encoder));
+      encoder.write(value, bytes, 0);
+      return bytes;
+    }
+  });
+}
+
+// node_modules/@solana/codecs-strings/dist/index.node.mjs
+function assertValidBaseString(alphabet4, testValue, givenValue = testValue) {
+  if (!testValue.match(new RegExp(`^[${alphabet4}]*$`))) {
+    throw new SolanaError(SOLANA_ERROR__CODECS__INVALID_STRING_FOR_BASE, {
+      alphabet: alphabet4,
+      base: alphabet4.length,
+      value: givenValue
+    });
+  }
+}
+var getBaseXEncoder = (alphabet4) => {
+  return createEncoder({
+    getSizeFromValue: (value) => {
+      const [leadingZeroes, tailChars] = partitionLeadingZeroes(value, alphabet4[0]);
+      if (!tailChars) return value.length;
+      const base10Number = getBigIntFromBaseX(tailChars, alphabet4);
+      return leadingZeroes.length + Math.ceil(base10Number.toString(16).length / 2);
+    },
+    write(value, bytes, offset) {
+      assertValidBaseString(alphabet4, value);
+      if (value === "") return offset;
+      const [leadingZeroes, tailChars] = partitionLeadingZeroes(value, alphabet4[0]);
+      if (!tailChars) {
+        bytes.set(new Uint8Array(leadingZeroes.length).fill(0), offset);
+        return offset + leadingZeroes.length;
+      }
+      let base10Number = getBigIntFromBaseX(tailChars, alphabet4);
+      const tailBytes = [];
+      while (base10Number > 0n) {
+        tailBytes.unshift(Number(base10Number % 256n));
+        base10Number /= 256n;
+      }
+      const bytesToAdd = [...Array(leadingZeroes.length).fill(0), ...tailBytes];
+      bytes.set(bytesToAdd, offset);
+      return offset + bytesToAdd.length;
+    }
+  });
+};
+function partitionLeadingZeroes(value, zeroCharacter) {
+  const [leadingZeros, tailChars] = value.split(new RegExp(`((?!${zeroCharacter}).*)`));
+  return [leadingZeros, tailChars];
+}
+function getBigIntFromBaseX(value, alphabet4) {
+  const base = BigInt(alphabet4.length);
+  let sum = 0n;
+  for (const char of value) {
+    sum *= base;
+    sum += BigInt(alphabet4.indexOf(char));
+  }
+  return sum;
+}
+var alphabet2 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var getBase58Encoder = () => getBaseXEncoder(alphabet2);
+var e = globalThis.TextDecoder;
+var o = globalThis.TextEncoder;
+
+// node_modules/@solana/addresses/dist/index.node.mjs
+var memoizedBase58Encoder;
+function getMemoizedBase58Encoder() {
+  if (!memoizedBase58Encoder) memoizedBase58Encoder = getBase58Encoder();
+  return memoizedBase58Encoder;
+}
+function isAddress(putativeAddress) {
+  if (
+    // Lowest address (32 bytes of zeroes)
+    putativeAddress.length < 32 || // Highest address (32 bytes of 255)
+    putativeAddress.length > 44
+  ) {
+    return false;
+  }
+  const base58Encoder = getMemoizedBase58Encoder();
+  try {
+    return base58Encoder.encode(putativeAddress).byteLength === 32;
+  } catch {
+    return false;
+  }
+}
+
+// src/validation/address.ts
+init_chains();
+var BECH32_CHARSET = /^[023456789acdefghjklmnpqrstuvwxyz]+$/i;
+function hasMixedCase(value) {
+  return value !== value.toLowerCase() && value !== value.toUpperCase();
+}
+function validateBech32LikeAddress(address, prefix) {
+  const trimmed = address.trim();
+  if (!trimmed) {
+    return { isValid: false, error: "Address is required." };
+  }
+  if (hasMixedCase(trimmed)) {
+    return { isValid: false, error: "Bech32 addresses cannot mix case." };
+  }
+  const lower = trimmed.toLowerCase();
+  const expectedPrefix = `${prefix.toLowerCase()}1`;
+  if (!lower.startsWith(expectedPrefix)) {
+    return {
+      isValid: false,
+      error: `Address must start with ${expectedPrefix}.`
+    };
+  }
+  const dataPart = lower.slice(expectedPrefix.length);
+  if (dataPart.length < 6 || !BECH32_CHARSET.test(dataPart)) {
+    return {
+      isValid: false,
+      error: "Bech32 address format is invalid."
+    };
+  }
+  return { isValid: true };
+}
+function validateEvmAddress(address) {
+  if (!isEvmAddress(address.trim())) {
+    return {
+      isValid: false,
+      error: "EVM addresses must be 0x-prefixed 20-byte hex strings."
+    };
+  }
+  return { isValid: true };
+}
+function validateSeiAddress(address) {
+  const trimmed = address.trim();
+  if (isEvmAddress(trimmed)) {
+    return { isValid: true };
+  }
+  const result = validateBech32LikeAddress(trimmed, "sei");
+  if (result.isValid) return result;
+  return {
+    isValid: false,
+    error: "SEI addresses must be 0x-prefixed EVM or sei1 bech32 strings."
+  };
+}
+function validateSolanaAddress(address) {
+  const trimmed = address.trim();
+  if (trimmed.startsWith("0x") || isEvmAddress(trimmed)) {
+    return {
+      isValid: false,
+      error: "Solana addresses must be base58-encoded strings."
+    };
+  }
+  if (trimmed.toLowerCase().startsWith("bc1") || trimmed.toLowerCase().startsWith("sei1")) {
+    return {
+      isValid: false,
+      error: "Solana addresses cannot be bech32 strings."
+    };
+  }
+  if (!isAddress(trimmed)) {
+    return {
+      isValid: false,
+      error: "Solana addresses must be base58-encoded strings."
+    };
+  }
+  return { isValid: true };
+}
+function validateBtcAddress(address) {
+  const trimmed = address.trim();
+  if (hasMixedCase(trimmed)) {
+    return { isValid: false, error: "Bitcoin addresses cannot mix case." };
+  }
+  const result = validateBech32LikeAddress(trimmed, "bc");
+  if (result.isValid) return result;
+  return {
+    isValid: false,
+    error: "Bitcoin addresses must use native SegWit (bc1...) format."
+  };
+}
+function validateAddressForChain(address, chain) {
+  const trimmed = address.trim();
+  if (!trimmed) return { isValid: true };
+  const chainType = normalizeChainType(chain);
+  const chainDef = typeof chain === "object" && chain ? chain : void 0;
+  switch (chainType) {
+    case "evm":
+      return validateEvmAddress(trimmed);
+    case "solana":
+      return validateSolanaAddress(trimmed);
+    case "bitcoin":
+      return validateBtcAddress(trimmed);
+    case "cosmos":
+      if (chainDef?.networkIdentifier?.toLowerCase() === "sei") {
+        return validateSeiAddress(trimmed);
+      }
+      return validateBech32LikeAddress(trimmed, "sei");
+    default:
+      return { isValid: false, error: "Unsupported or unknown chain type." };
+  }
+}
+function validateAddressForRouteChain(address, chainType) {
+  switch (normalizeChainType(chainType)) {
+    case "evm":
+      return validateEvmAddress(address);
+    case "solana":
+      return validateSolanaAddress(address);
+    case "bitcoin":
+      return validateBtcAddress(address);
+    case "cosmos":
+      return validateSeiAddress(address);
+    default:
+      return { isValid: false, error: "Unsupported chain type." };
+  }
+}
+function validateRouteAddresses(params) {
+  const fromType = normalizeChainType(params.fromChain);
+  const toType = normalizeChainType(params.toChain);
+  if (!fromType || !toType) {
+    return {
+      isValid: false,
+      error: "Missing chain types for route validation."
+    };
+  }
+  const fromAddress = params.fromAddress.trim();
+  const toAddress = params.toAddress.trim();
+  if (!fromAddress || !toAddress) {
+    return { isValid: false, error: "Route addresses are required." };
+  }
+  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);
+    if (!fromResult2.isValid) {
+      return {
+        isValid: false,
+        error: `From address: ${fromResult2.error ?? "Invalid address."}`
+      };
+    }
+    const toResult2 = toType === "cosmos" ? validateSeiAddress(toAddress) : validateEvmAddress(toAddress);
+    if (!toResult2.isValid) {
+      return {
+        isValid: false,
+        error: `To address: ${toResult2.error ?? "Invalid address."}`
+      };
+    }
+    if (fromType === "bitcoin") {
+      const refundAddress = params.refundAddress?.trim();
+      if (!refundAddress) {
+        return {
+          isValid: false,
+          error: "Refund address is required for BTC deposit routes."
+        };
+      }
+      const refundResult = validateBtcAddress(refundAddress);
+      if (!refundResult.isValid) {
+        return {
+          isValid: false,
+          error: `Refund address: ${refundResult.error ?? "Invalid address."}`
+        };
+      }
+    }
+    return { isValid: true };
+  }
+  const fromResult = validateAddressForRouteChain(fromAddress, fromType);
+  if (!fromResult.isValid) {
+    return {
+      isValid: false,
+      error: `From address: ${fromResult.error ?? "Invalid address."}`
+    };
+  }
+  const toResult = validateAddressForRouteChain(toAddress, toType);
+  if (!toResult.isValid) {
+    return {
+      isValid: false,
+      error: `To address: ${toResult.error ?? "Invalid address."}`
+    };
+  }
+  return { isValid: true };
+}
+
+// src/identity/index.ts
+init_chains();
+function normalizeIdentityChainId(chain) {
+  if (!chain || typeof chain === "string") return void 0;
+  const raw = chain.chainId ?? chain.id;
+  if (raw === void 0 || raw === null) return void 0;
+  const normalized = String(raw).trim();
+  return normalized || void 0;
+}
+function identityEntryMatchesChain(entry, chainType, chainKey, chainId) {
+  if (chainKey && entry.chainKey && entry.chainKey === chainKey) return true;
+  if (chainId && entry.chainId && entry.chainId === chainId) return true;
+  if (chainType && entry.chainType === chainType) return true;
+  return false;
+}
+function createWalletIdentity(addresses = []) {
+  return { addresses };
+}
+function upsertWalletIdentityAddress(identity, next) {
+  const normalizedAddress = next.address.trim();
+  const normalizedChainKey = next.chainKey ? normalizeChainKey(next.chainKey) : void 0;
+  const normalizedChainId = next.chainId?.trim() || void 0;
+  const addresses = identity.addresses.filter((entry) => {
+    if (entry.chainType !== next.chainType) return true;
+    if (normalizedChainKey && entry.chainKey === normalizedChainKey)
+      return false;
+    if (normalizedChainId && entry.chainId === normalizedChainId) return false;
+    if (!normalizedChainKey && !normalizedChainId) return false;
+    return true;
+  });
+  if (!normalizedAddress) return createWalletIdentity(addresses);
+  return createWalletIdentity([
+    ...addresses,
+    {
+      ...next,
+      address: normalizedAddress,
+      chainKey: normalizedChainKey,
+      chainId: normalizedChainId
+    }
+  ]);
+}
+function resolveWalletAddressForChain(identity, chain) {
+  const chainType = normalizeChainType(chain);
+  const chainDef = typeof chain === "object" && chain ? chain : void 0;
+  const chainKey = chainDef ? normalizeChainKey(
+    chainDef.networkIdentifier ?? chainDef.chainId ?? chainDef.id
+  ) : typeof chain === "string" ? normalizeChainKey(chain) : void 0;
+  const chainId = normalizeIdentityChainId(chain);
+  if (!chainType) {
+    return {
+      status: "missing",
+      reason: "unknown_chain_type",
+      chainKey,
+      chainId
+    };
+  }
+  const match = identity.addresses.find(
+    (entry) => identityEntryMatchesChain(entry, chainType, chainKey, chainId)
+  );
+  if (!match) {
+    return {
+      status: "missing",
+      reason: "missing_chain_address",
+      chainType,
+      chainKey,
+      chainId
+    };
+  }
+  const validation = validateAddressForChain(
+    match.address,
+    chainDef ?? chainType
+  );
+  if (!validation.isValid) {
+    return {
+      status: "invalid",
+      reason: validation.error ?? "invalid_chain_address",
+      address: match.address,
+      source: match.source,
+      chainType,
+      chainKey,
+      chainId
+    };
+  }
+  return {
+    status: "resolved",
+    address: match.address.trim(),
+    source: match.source,
+    chainType,
+    chainKey,
+    chainId
+  };
+}
+function buildWalletIdentityAddress(params) {
+  const chainType = normalizeChainType(params.chain);
+  if (!chainType) return null;
+  const address = params.address.trim();
+  const chainId = normalizeIdentityChainId(params.chain);
+  const chainDef = typeof params.chain === "object" && params.chain ? params.chain : void 0;
+  const chainKey = chainDef ? normalizeChainKey(
+    chainDef.networkIdentifier ?? chainDef.chainId ?? chainDef.id
+  ) : void 0;
+  return {
+    address,
+    chainType,
+    chainId,
+    chainKey,
+    providerId: params.providerId,
+    source: params.source
+  };
+}
+var IdentityStore = class {
+  constructor() {
+    this._identity = createWalletIdentity();
+  }
+  get snapshot() {
+    return this._identity;
+  }
+  reset() {
+    this._identity = createWalletIdentity();
+  }
+  upsert(next) {
+    this._identity = upsertWalletIdentityAddress(this._identity, next);
+    return this._identity;
+  }
+  resolve(chain) {
+    return resolveWalletAddressForChain(this._identity, chain);
+  }
+};
+
 // src/wallets/manager.ts
 import { useEffect as useEffect2 } from "react";
 var WalletManager = class {
@@ -1163,6 +2553,9 @@ var WalletManager = class {
     this._wallet = null;
     this._detected = [];
     this._listeners = /* @__PURE__ */ new Set();
+    this._identity = new IdentityStore();
+    this._providerCleanup = null;
+    this._connectedWalletId = null;
   }
   get status() {
     return this._status;
@@ -1178,8 +2571,14 @@ var WalletManager = class {
   }
   get simple() {
     if (!this._wallet) return null;
-    const { getAddress, getChainId, switchChain } = this._wallet;
-    return { getAddress, getChainId, switchChain };
+    const { getAddress, disconnect } = this._wallet;
+    return { getAddress, disconnect };
+  }
+  get identity() {
+    return this._identity.snapshot;
+  }
+  get connectedWalletId() {
+    return this._connectedWalletId;
   }
   onChange(fn) {
     this._listeners.add(fn);
@@ -1200,17 +2599,28 @@ var WalletManager = class {
     await this.connectDetected(target, opts);
   }
   async connectDetected(target, opts) {
+    if (this._status === "connected" && this._connectedWalletId === target.meta.id && this._wallet) {
+      this.emit();
+      return;
+    }
     this._status = "connecting";
+    this.clearConnectedWalletState();
     this.emit();
     try {
       const { api } = await connectDetectedWallet(target, {
         wagmi: opts?.wagmi
       });
-      if (api) this._wallet = api;
+      if (api) {
+        this._wallet = api;
+        this._connectedWalletId = target.meta.id;
+        this.bindProviderEvents(target);
+        await this.syncIdentityFromWallet(target.meta.id);
+      }
       this._status = "connected";
-    } catch (e) {
-      this._error = e;
+    } catch (e2) {
+      this._error = e2;
       this._status = "error";
+      this.clearConnectedWalletState();
     } finally {
       this.emit();
     }
@@ -1218,14 +2628,21 @@ var WalletManager = class {
   async disconnect(wagmi) {
     if (wagmi) await wagmi.disconnect().catch(() => {
     });
-    this._wallet = null;
+    if (this._wallet?.disconnect) {
+      await this._wallet.disconnect().catch(() => {
+      });
+    }
+    this.clearConnectedWalletState();
     this._status = "idle";
     this.emit();
   }
   /** Directly attach a pre-provided wallet interface (from old provider prop). */
   attachWallet(api) {
+    this.clearConnectedWalletState();
     this._wallet = api;
+    this._connectedWalletId = null;
     this._status = "connected";
+    void this.syncIdentityFromWallet();
     this.emit();
   }
   /** Optional helper to set explicit status (e.g., "initializing" UX). */
@@ -1233,6 +2650,90 @@ var WalletManager = class {
     this._status = s;
     this.emit();
   }
+  addIdentityAddress(address) {
+    this._identity.upsert(address);
+  }
+  resolveAddressForChain(chain) {
+    return this._identity.resolve(chain);
+  }
+  clearProviderCleanup() {
+    this._providerCleanup?.();
+    this._providerCleanup = null;
+  }
+  clearConnectedWalletState() {
+    this.clearProviderCleanup();
+    this._wallet = null;
+    this._connectedWalletId = null;
+  }
+  bindProviderEvents(target) {
+    if (!target.provider) return;
+    if (target.via === "solana-window") {
+      this._providerCleanup = bindSolanaProviderEvents(target.provider, {
+        onConnect: () => {
+          this._status = "connected";
+          void this.syncIdentityFromWallet(target.meta.id);
+          this.emit();
+        },
+        onAccountChanged: () => {
+          void this.syncIdentityFromWallet(target.meta.id);
+          this.emit();
+        },
+        onDisconnect: () => {
+          this.clearConnectedWalletState();
+          this._status = "idle";
+          this.emit();
+        }
+      });
+      return;
+    }
+    const provider = target.provider;
+    const onAccountsChanged = (accounts) => {
+      const nextAccounts = Array.isArray(accounts) ? accounts : [];
+      if (nextAccounts.length === 0) {
+        this.clearConnectedWalletState();
+        this._status = "idle";
+        this.emit();
+        return;
+      }
+      this._status = "connected";
+      void this.syncIdentityFromWallet(target.meta.id);
+      this.emit();
+    };
+    const onDisconnect = () => {
+      this.clearConnectedWalletState();
+      this._status = "idle";
+      this.emit();
+    };
+    provider.on?.("accountsChanged", onAccountsChanged);
+    provider.on?.("disconnect", onDisconnect);
+    this._providerCleanup = () => {
+      provider.off?.("accountsChanged", onAccountsChanged);
+      provider.off?.("disconnect", onDisconnect);
+      provider.removeListener?.("accountsChanged", onAccountsChanged);
+      provider.removeListener?.("disconnect", onDisconnect);
+    };
+  }
+  async syncIdentityFromWallet(providerId) {
+    if (!this._wallet) return;
+    try {
+      const address = await this._wallet.getAddress();
+      const chain = this._wallet.ecosystem === "evm" ? { chainId: String(await this._wallet.getChainId()), type: "evm" } : {
+        chainId: "solana-mainnet-beta",
+        networkIdentifier: "solana-mainnet-beta",
+        type: "solana"
+      };
+      const identityAddress = buildWalletIdentityAddress({
+        address,
+        chain,
+        source: "provider",
+        providerId
+      });
+      if (identityAddress) {
+        this._identity.upsert(identityAddress);
+      }
+    } catch {
+    }
+  }
 };
 var walletManager = new WalletManager();
 function useWireDetectionIntoManager() {
@@ -1245,13 +2746,30 @@ function useWireDetectionIntoManager() {
 // src/core/routes.ts
 init_http();
 init_store();
+function isEvmTxRequest(txReq) {
+  return Boolean(txReq?.data && (txReq.to || txReq.target));
+}
+function isSerializedSolanaTxRequest(txReq) {
+  return Boolean(txReq?.data && !txReq?.to && !txReq?.target);
+}
 async function buildRoute(body, signal) {
+  const addressValidation = validateRouteAddresses({
+    fromChain: body.fromChain,
+    toChain: body.toChain,
+    fromAddress: body.fromAddress,
+    toAddress: body.toAddress,
+    refundAddress: body.refundAddress,
+    direction: body.direction
+  });
+  if (!addressValidation.isValid) {
+    throw new Error(addressValidation.error || "Invalid route addresses.");
+  }
   const cfg = TrustwareConfigStore.get();
-  const url = `${apiBase()}/routes/route`;
+  const url = `${apiBase()}/v1/routes/route`;
   const payload = {
     ...body,
-    slippageBps: body.slippage === void 0 ? void 0 : Math.round(body.slippage * 100),
-    fromAmountUSD: body.fromAmountUsd
+    slippageBps: body.slippageBps ?? (body.slippage === void 0 ? void 0 : Math.round(body.slippage * 100)),
+    fromAmountUSD: body.fromAmountUSD ?? body.fromAmountUsd
   };
   const r = await rateLimitedFetch(url, {
     method: "POST",
@@ -1275,16 +2793,58 @@ async function buildRoute(body, signal) {
   const estimate = route?.estimate ?? {};
   const finalExchangeRate = {
     fromAmountUSD: estimate.fromAmountUsd,
-    toAmountMinUSD: estimate?.toAmountUsd
+    toAmountMinUSD: estimate?.toAmountMinUsd ?? estimate?.toAmountUsd
   };
-  if (!txReq?.data || !(txReq?.to || txReq?.target)) {
-    throw new Error("Invalid route: missing transactionRequest target/data");
+  if (!txReq?.data) {
+    throw new Error("Invalid route: missing transaction data");
   }
   return { intentId, txReq, actions, finalExchangeRate, route };
 }
+async function buildDepositAddress(body, signal) {
+  const cfg = TrustwareConfigStore.get();
+  const url = `${apiBase()}/v1/routes/deposit-address`;
+  const payload = {
+    ...body,
+    slippageBps: body.slippageBps ?? (body.slippage === void 0 ? void 0 : Math.round(body.slippage * 100)),
+    fromAmountUSD: body.fromAmountUSD ?? body.fromAmountUsd
+  };
+  const r = await rateLimitedFetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "X-API-Key": cfg.apiKey },
+    body: JSON.stringify(payload),
+    signal
+  });
+  let json = {};
+  try {
+    json = await r.json();
+  } catch {
+  }
+  if (!r.ok) {
+    const msg = json?.error || json?.message || "Failed to build deposit address";
+    throw new Error(msg);
+  }
+  const intentId = json?.data?.intentId ?? json?.intentId ?? "";
+  const route = json?.data?.route ?? json?.route;
+  const depositAddress = json?.data?.depositAddress?.address ?? json?.depositAddress?.address ?? "";
+  const actions = Array.isArray(route?.steps) ? route.steps : [];
+  const estimate = route?.estimate ?? {};
+  if (!depositAddress) {
+    throw new Error("Invalid route: missing deposit address");
+  }
+  return {
+    intentId,
+    depositAddress,
+    actions,
+    finalExchangeRate: {
+      fromAmountUSD: estimate.fromAmountUsd,
+      toAmountMinUSD: estimate?.toAmountMinUsd ?? estimate?.toAmountUsd
+    },
+    route
+  };
+}
 async function submitReceipt(intentId, txHash) {
   const r = await rateLimitedFetch(
-    `${apiBase()}/route-intent/${intentId}/receipt`,
+    `${apiBase()}/v1/route-intent/${intentId}/receipt`,
     {
       method: "POST",
       headers: jsonHeaders({ "Idempotency-Key": txHash }),
@@ -1297,7 +2857,7 @@ async function submitReceipt(intentId, txHash) {
 }
 async function getStatus(intentId) {
   const r = await rateLimitedFetch(
-    `${apiBase()}/route-intent/${intentId}/status`,
+    `${apiBase()}/v1/route-intent/${intentId}/status`,
     {
       headers: jsonHeaders()
     }
@@ -1319,20 +2879,125 @@ async function pollStatus(intentId, { intervalMs = 2e3, timeoutMs = 5 * 6e4 } =
 // src/core/balances.ts
 init_http();
 init_registry();
-async function getBalances(chainId, address) {
+init_chains();
+var balanceCache = /* @__PURE__ */ new Map();
+function toStringOrUndefined(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function toNumberOrUndefined(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : void 0;
+  }
+  if (typeof value === "string") {
+    const parsed = Number(value.trim());
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+function fallbackTokenSymbol(address, chainType) {
+  if (chainType?.toLowerCase() === "solana") {
+    return "SPL";
+  }
+  return `TOKEN-${address.slice(0, 6)}`;
+}
+function normalizeRows(rows, chain, address, registry) {
+  const chainKey = chain.networkIdentifier ?? String(chain.chainId ?? chain.id);
+  const chainType = normalizeChainType(chain);
+  const nativeAddress = getNativeTokenAddress(chainType);
+  const map = /* @__PURE__ */ new Map();
+  for (const item of rows) {
+    const category = toStringOrUndefined(item.category)?.toLowerCase();
+    const addressRaw = item.contract ?? item.token_address ?? item.address ?? item.addr;
+    const tokenAddress = typeof addressRaw === "string" ? addressRaw.trim() : void 0;
+    const symbol = toStringOrUndefined(item.symbol ?? item.sym);
+    const name = toStringOrUndefined(item.name ?? item.token_name ?? item.token) ?? symbol;
+    const decimals = toNumberOrUndefined(item.decimals ?? item.dec);
+    const balance = String(item.balance ?? item.bal ?? "0");
+    const explicitNative = Boolean(item.native ?? item.is_native);
+    const nativeFlag = explicitNative || category === "native" || isZeroAddressLike(tokenAddress, chainType);
+    if (nativeFlag) {
+      const nativeRow = {
+        chain_key: chainKey,
+        category: "native",
+        contract: nativeAddress,
+        address: nativeAddress,
+        symbol: symbol ?? chain.nativeCurrency?.symbol ?? "NATIVE",
+        name: name ?? chain.nativeCurrency?.name ?? symbol,
+        decimals: decimals ?? chain.nativeCurrency?.decimals ?? 18,
+        balance
+      };
+      map.set(`${chainKey}:${nativeAddress}`, nativeRow);
+      continue;
+    }
+    if (!tokenAddress || decimals === void 0) continue;
+    const metadata = registry.findToken(chain.chainId, tokenAddress);
+    const displaySymbol = symbol ?? metadata?.symbol ?? fallbackTokenSymbol(tokenAddress, chainType);
+    const displayName = name ?? metadata?.name ?? displaySymbol;
+    const normalizedAddress = metadata?.address ?? tokenAddress;
+    map.set(`${chainKey}:${normalizedAddress}`, {
+      chain_key: chainKey,
+      category: category ?? (chainType === "solana" ? "spl" : "erc20"),
+      contract: normalizedAddress,
+      address: normalizedAddress,
+      symbol: displaySymbol,
+      name: displayName,
+      decimals: metadata?.decimals ?? decimals,
+      balance,
+      logoURI: metadata?.logoURI,
+      usdPrice: metadata?.usdPrice
+    });
+  }
+  if (!Array.from(map.values()).some((row) => row.category === "native")) {
+    map.set(`${chainKey}:${nativeAddress}`, {
+      chain_key: chainKey,
+      category: "native",
+      contract: nativeAddress,
+      address: nativeAddress,
+      symbol: chain.nativeCurrency?.symbol ?? "NATIVE",
+      name: chain.nativeCurrency?.name ?? chain.nativeCurrency?.symbol,
+      decimals: chain.nativeCurrency?.decimals ?? 18,
+      balance: "0"
+    });
+  }
+  return Array.from(map.values()).sort((a, b) => {
+    try {
+      return Number(BigInt(b.balance) - BigInt(a.balance));
+    } catch {
+      return 0;
+    }
+  });
+}
+async function getBalances(chainRef, address) {
   const reg = await ensureRegistry();
-  const meta = reg.chain(chainId);
-  const chainKey = meta?.networkIdentifier || String(chainId);
-  const url = `${apiBase()}/data/wallets/${encodeURIComponent(chainKey)}/${address}/balances`;
-  const r = await fetch(url, {
+  const chain = reg.chain(chainRef);
+  if (!chain) return [];
+  const trimmedAddress = address.trim();
+  const validation = validateAddressForChain(trimmedAddress, chain);
+  if (!validation.isValid) return [];
+  const chainKey = chain.networkIdentifier ?? String(chain.chainId ?? chain.id);
+  const cacheKey = [
+    chainKey,
+    trimmedAddress,
+    chain.nativeCurrency?.symbol ?? "",
+    chain.nativeCurrency?.decimals ?? "",
+    normalizeChainType(chain) ?? ""
+  ].join(":");
+  const cached = balanceCache.get(cacheKey);
+  if (cached) return cached;
+  const url = `${apiBase()}/v1/data/wallets/${encodeURIComponent(chainKey)}/${trimmedAddress}/balances`;
+  const response = await fetch(url, {
     method: "GET",
     credentials: "omit",
     headers: jsonHeaders()
   });
-  if (!r.ok) throw new Error(`balances: HTTP ${r.status}`);
-  const j = await r.json();
-  const rows = Array.isArray(j) ? j : j.data ?? [];
-  return rows;
+  if (!response.ok) throw new Error(`balances: HTTP ${response.status}`);
+  const json = await response.json();
+  const rows = Array.isArray(json) ? json : json.data ?? [];
+  const normalized = normalizeRows(rows, chain, trimmedAddress, reg);
+  balanceCache.set(cacheKey, normalized);
+  return normalized;
 }
 async function getBalancesByAddress(address) {
   const url = `${apiBase()}/data/balances/${address}`;
@@ -1343,8 +3008,7 @@ async function getBalancesByAddress(address) {
   });
   if (!r.ok) throw new Error(`balances: HTTP ${r.status}`);
   const j = await r.json();
-  const rows = Array.isArray(j) ? j : j.results ?? [];
-  return rows;
+  return Array.isArray(j) ? j : j.results ?? [];
 }
 var _registry;
 async function ensureRegistry() {
@@ -1356,71 +3020,100 @@ async function ensureRegistry() {
 }
 
 // src/core/tx.ts
-function isUserRejected(e) {
-  const code = e?.code ?? e?.data?.code;
+function isUserRejected(e2) {
+  const code = e2?.code ?? e2?.data?.code;
   if (code === 4001) return true;
-  const msg = String(e?.message || e)?.toLowerCase?.() || "";
+  const msg = String(e2?.message || e2)?.toLowerCase?.() || "";
   return msg.includes("user rejected") || msg.includes("user denied");
 }
 async function sendRouteTransaction(b, fallbackChainId) {
   const w = walletManager.wallet;
   if (!w) throw new Error("Trustware.wallet not configured");
-  const tr = b?.txReq;
-  const to = tr.to;
-  const data = tr.data;
-  const value = tr.value ? BigInt(tr.value) : 0n;
-  const target = Number(tr.chainId ?? fallbackChainId);
-  if (Number.isFinite(target)) {
-    const current = await w.getChainId();
-    if (current !== target) {
-      try {
-        await w.switchChain(target);
-      } catch {
+  const txReq = b.txReq;
+  if (isEvmTxRequest(txReq)) {
+    if (w.ecosystem !== "evm") {
+      throw new Error("An EVM wallet is required for this route");
+    }
+    const to = txReq.to ?? txReq.target;
+    const data = txReq.data;
+    const value = txReq.value ? BigInt(txReq.value) : 0n;
+    const target = Number(txReq.chainId ?? fallbackChainId);
+    if (Number.isFinite(target)) {
+      const current = await w.getChainId();
+      if (current !== target) {
+        try {
+          await w.switchChain(target);
+        } catch {
+        }
       }
     }
-  }
-  if (w.type === "eip1193") {
-    const from = await w.getAddress();
-    const hexValue = value ? `0x${value.toString(16)}` : "0x0";
-    const params = { from, to, data, value: hexValue };
-    if (Number.isFinite(target)) params.chainId = `0x${target.toString(16)}`;
-    const hash = await w.request({
-      method: "eth_sendTransaction",
-      params: [params]
-    });
-    return hash;
-  } else {
-    const resp = await w.sendTransaction({
+    if (w.type === "eip1193") {
+      const from = await w.getAddress();
+      const hexValue = value ? `0x${value.toString(16)}` : "0x0";
+      const params = {
+        from,
+        to,
+        data,
+        value: hexValue
+      };
+      if (Number.isFinite(target)) {
+        params.chainId = `0x${target.toString(16)}`;
+      }
+      const hash = await w.request({
+        method: "eth_sendTransaction",
+        params: [params]
+      });
+      return hash;
+    }
+    const response = await w.sendTransaction({
       to,
       data,
       value,
       chainId: Number.isFinite(target) ? target : void 0
     });
-    return resp.hash;
+    return response.hash;
+  }
+  if (isSerializedSolanaTxRequest(txReq)) {
+    if (w.ecosystem !== "solana") {
+      throw new Error("A Solana wallet is required for this route");
+    }
+    const { Registry: Registry2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+    const { apiBase: apiBase2 } = await Promise.resolve().then(() => (init_http(), http_exports));
+    const registry = new Registry2(apiBase2());
+    await registry.ensureLoaded();
+    const chain = registry.chain(
+      String(fallbackChainId ?? txReq.chainId ?? "")
+    );
+    const rpcUrl = chain?.rpc ?? chain?.rpcList?.[0];
+    return w.sendSerializedTransaction(txReq.data, rpcUrl);
   }
+  throw new Error("Invalid route transaction payload");
 }
 async function runTopUp(params) {
   const w = walletManager.wallet;
   if (!w) throw new Error("Trustware.wallet not configured");
-  const { Registry: Registry2, NATIVE: NATIVE2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+  const { Registry: Registry2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
   const { apiBase: apiBase2 } = await Promise.resolve().then(() => (init_http(), http_exports));
   const reg = new Registry2(apiBase2());
   await reg.ensureLoaded();
   const fromAddress = await w.getAddress();
-  const currentChainId = await w.getChainId();
-  const originalChain = currentChainId;
-  const fromChain = params.fromChain ?? String(currentChainId);
+  const currentChainRef = w.ecosystem === "evm" ? String(await w.getChainId()) : await w.getChainKey?.() ?? "solana-mainnet-beta";
+  const originalChain = w.ecosystem === "evm" ? await w.getChainId() : void 0;
+  const fromChain = params.fromChain ?? currentChainRef;
   const { TrustwareConfigStore: TrustwareConfigStore2 } = await Promise.resolve().then(() => (init_store(), store_exports));
   const cfg = TrustwareConfigStore2.get();
   const toChain = params.toChain ?? String(cfg.routes.toChain);
   const fromToken = reg.resolveToken(
     fromChain,
     params.fromToken ?? cfg.routes.fromToken ?? void 0
-  ) ?? NATIVE2;
+  ) ?? params.fromToken;
   const toToken = reg.resolveToken(
     toChain,
     params.toToken ?? cfg.routes.toToken ?? void 0
-  ) ?? NATIVE2;
+  ) ?? params.toToken;
+  if (!fromToken || !toToken) {
+    throw new Error("Unable to resolve route tokens");
+  }
   try {
     const build = await buildRoute({
       fromChain,
@@ -1432,16 +3125,15 @@ async function runTopUp(params) {
       toAddress: params.toAddress ?? cfg.routes.toAddress ?? cfg.routes.fromAddress ?? fromAddress,
       slippage: cfg.routes.defaultSlippage
     });
-    const hash = await sendRouteTransaction(build, Number(fromChain));
+    const hash = await sendRouteTransaction(build, fromChain);
     await submitReceipt(build.intentId, hash);
-    const tx = await pollStatus(build.intentId);
-    return tx;
-  } catch (e) {
-    if (isUserRejected(e)) throw new Error("Transaction cancelled by user");
-    throw e;
+    return await pollStatus(build.intentId);
+  } catch (e2) {
+    if (isUserRejected(e2)) throw new Error("Transaction cancelled by user");
+    throw e2;
   } finally {
     try {
-      if (originalChain && originalChain !== Number(fromChain)) {
+      if (w.ecosystem === "evm" && originalChain && originalChain !== Number(fromChain)) {
         await w.switchChain(originalChain);
       }
     } catch {
@@ -1477,40 +3169,64 @@ function getSharedRegistry() {
 }
 
 // src/widget/helpers/chainHelpers.ts
-function normalizeChainKey(id) {
+function normalizeChainKey2(id) {
   if (id === void 0 || id === null) return "";
   return String(id).trim().toLowerCase();
 }
-var NATIVE_EVM = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
-var NATIVE_SOLANA = "So11111111111111111111111111111111111111111";
-function getNativeTokenAddress(chainType) {
+var NATIVE_EVM2 = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+var NATIVE_SOLANA2 = "So11111111111111111111111111111111111111111";
+function getNativeTokenAddress2(chainType) {
   const normalized = chainType?.toLowerCase?.();
-  return normalized === "solana" ? NATIVE_SOLANA : NATIVE_EVM;
+  return normalized === "solana" ? NATIVE_SOLANA2 : NATIVE_EVM2;
 }
-var CHAIN_TYPE_ALIASES = {
+function isSolanaNativeTokenAlias2(address) {
+  if (!address) return false;
+  const trimmed = address.trim();
+  if (!trimmed) return false;
+  return trimmed === NATIVE_SOLANA2 || trimmed.toLowerCase() === NATIVE_EVM2;
+}
+var CHAIN_TYPE_ALIASES2 = {
   btc: "bitcoin",
   bitcoin: "bitcoin",
   sei: "cosmos",
   "pacific-1": "cosmos"
 };
-function normalizeChainType(chain) {
+function inferChainTypeFromValue2(normalized) {
+  if (!normalized) return void 0;
+  const aliased = CHAIN_TYPE_ALIASES2[normalized];
+  if (aliased) return aliased;
+  if (normalized === "evm" || normalized === "solana" || normalized === "cosmos" || normalized === "bitcoin") {
+    return normalized;
+  }
+  if (/^eip155:\d+$/.test(normalized) || /^\d+$/.test(normalized)) {
+    return "evm";
+  }
+  if (normalized.startsWith("solana:") || normalized.includes("solana")) {
+    return "solana";
+  }
+  if (normalized.startsWith("cosmos:") || normalized.startsWith("sei:") || normalized === "sei-evm") {
+    return "cosmos";
+  }
+  return void 0;
+}
+function normalizeChainType2(chain) {
   if (!chain) return void 0;
   const raw = typeof chain === "string" ? chain : chain.type ?? chain.chainType ?? chain.networkIdentifier ?? chain.chainId ?? chain.id ?? chain.networkName ?? chain.axelarChainName;
   if (!raw) return void 0;
   const normalized = String(raw).trim().toLowerCase();
-  return CHAIN_TYPE_ALIASES[normalized] ?? normalized;
+  return inferChainTypeFromValue2(normalized) ?? normalized;
 }
 function canonicalChainKeyForLink(chain) {
   const seiKey = canonicalSeiChainKey(chain.chainId ?? chain.id);
   if (seiKey) return seiKey;
-  return normalizeChainKey(
+  return normalizeChainKey2(
     chain.networkIdentifier ?? chain.axelarChainName ?? chain.id ?? chain.chainId ?? chain.networkName
   );
 }
 var SEI_EVM_CHAIN_ID = "1329";
 var SEI_COSMOS_CHAIN_ID = "pacific-1";
 function canonicalSeiChainKey(chainId) {
-  const normalized = normalizeChainKey(chainId);
+  const normalized = normalizeChainKey2(chainId);
   if (!normalized) return null;
   if (normalized === SEI_EVM_CHAIN_ID) return "sei-evm";
   if (normalized === SEI_COSMOS_CHAIN_ID) return "sei";
@@ -1519,40 +3235,43 @@ function canonicalSeiChainKey(chainId) {
 function isZeroAddrLike(a, chainType) {
   if (!a) return true;
   if (!chainType) return false;
-  const s = normalizeAddress(a, chainType);
-  return s === normalizeAddress(getNativeTokenAddress(chainType), chainType) || s === "0x0000000000000000000000000000000000000000";
+  const s = normalizeAddress2(a, chainType);
+  return s === normalizeAddress2(getNativeTokenAddress2(chainType), chainType) || s === "0x0000000000000000000000000000000000000000";
 }
-function normalizeAddress(address, chainType) {
+function normalizeAddress2(address, chainType) {
   if (chainType?.toLowerCase?.() === "solana") {
     const trimmed = address.trim();
-    return trimmed.startsWith("0x") ? trimmed.toLowerCase() : trimmed;
+    if (isSolanaNativeTokenAlias2(trimmed)) {
+      return NATIVE_SOLANA2;
+    }
+    return trimmed;
   }
   return address.toLowerCase();
 }
 function isNativeTokenAddress(address, chainType) {
   if (!address) return false;
   if (!chainType) return false;
-  return normalizeAddress(address, chainType) === normalizeAddress(getNativeTokenAddress(chainType), chainType);
+  return normalizeAddress2(address, chainType) === normalizeAddress2(getNativeTokenAddress2(chainType), chainType);
 }
 function canonicalTokenAddressForChain(chain, address, chainTokens = []) {
-  const chainType = normalizeChainType(chain);
+  const chainType = normalizeChainType2(chain);
   const rawAddress = (address ?? "").trim();
-  if (chainType === "solana") return rawAddress;
+  if (chainType === "solana") return normalizeAddress2(rawAddress, "solana");
   if (chainType === "cosmos") {
-    const chainIdKey = normalizeChainKey(chain.chainId ?? chain.id ?? "");
+    const chainIdKey = normalizeChainKey2(chain.chainId ?? chain.id ?? "");
     const nativeSymbol = chain.nativeCurrency?.symbol?.toUpperCase?.();
     const nativeFromRegistry = chainTokens.find(
-      (token) => normalizeChainKey(token.chainId) === chainIdKey && token.symbol?.toUpperCase?.() === nativeSymbol
+      (token) => normalizeChainKey2(token.chainId) === chainIdKey && token.symbol?.toUpperCase?.() === nativeSymbol
     );
     const nativeDenom = (nativeFromRegistry?.address ?? "usei").toLowerCase();
-    if (rawAddress.toLowerCase() === NATIVE_EVM) {
+    if (rawAddress.toLowerCase() === NATIVE_EVM2) {
       return nativeDenom;
     }
     return rawAddress.toLowerCase();
   }
   const lowerAddress = rawAddress.toLowerCase();
   if (lowerAddress === "0x0000000000000000000000000000000000000000") {
-    return NATIVE_EVM;
+    return NATIVE_EVM2;
   }
   return lowerAddress;
 }
@@ -1569,7 +3288,7 @@ var POPULAR_CHAIN_IDS = /* @__PURE__ */ new Set([
 function filterSupportedChains(chains) {
   const supportedChainTypes = /* @__PURE__ */ new Set(["evm", "solana", "cosmos", "bitcoin"]);
   return chains.filter((chain) => {
-    const chainType = normalizeChainType(chain);
+    const chainType = normalizeChainType2(chain);
     if (!chainType) return false;
     if (!supportedChainTypes.has(chainType)) {
       return false;
@@ -1727,7 +3446,7 @@ function getChainPopularityRank(chain) {
     chain.axelarChainName
   ];
   for (const alias of aliases) {
-    const key = normalizeChainKey(alias ?? null);
+    const key = normalizeChainKey2(alias ?? null);
     if (!key) continue;
     const rank = popularityByKey[key];
     if (typeof rank === "number") {
@@ -1780,7 +3499,7 @@ var POPULAR_TOKEN_CONTRACTS = /* @__PURE__ */ new Set([
 function normalizeSymbol(symbol) {
   return (symbol ?? "").trim().toUpperCase();
 }
-function normalizeAddress2(address) {
+function normalizeAddress3(address) {
   return (address ?? "").trim().toLowerCase();
 }
 function hasPositiveBalance(balance) {
@@ -1808,7 +3527,7 @@ function hasPositiveBalance(balance) {
 }
 function isPopularToken(token) {
   const normalizedSymbol = normalizeSymbol(token.symbol);
-  const normalizedAddress = normalizeAddress2(token.address);
+  const normalizedAddress = normalizeAddress3(token.address);
   return POPULAR_TOKEN_SYMBOLS.has(normalizedSymbol) || POPULAR_TOKEN_CONTRACTS.has(normalizedAddress);
 }
 function compareText(a, b) {
@@ -2002,6 +3721,16 @@ var Trustware = {
   getWallet() {
     return walletManager.wallet;
   },
+  getIdentity() {
+    return walletManager.identity;
+  },
+  resolveAddressForChain(chain) {
+    return walletManager.resolveAddressForChain(chain);
+  },
+  addIdentityAddress(address) {
+    walletManager.addIdentityAddress(address);
+    return Trustware;
+  },
   /** Simple helpers */
   async getAddress() {
     const w = walletManager.wallet;
@@ -2010,6 +3739,7 @@ var Trustware = {
   },
   // ---- REST methods (re-export) ----
   buildRoute,
+  buildDepositAddress,
   submitReceipt,
   getStatus,
   pollStatus,
@@ -2017,6 +3747,8 @@ var Trustware = {
   getBalancesByAddress,
   useChains,
   useTokens,
+  validateAddressForChain,
+  validateRouteAddresses,
   // ---- Tx helpers ----
   sendRouteTransaction,
   runTopUp
@@ -2595,7 +4327,7 @@ function useRouteBuilder({
   const hasFromChainId = fromChainId !== void 0 && fromChainId !== null && String(fromChainId).trim() !== "";
   const hasToChainId = toChainId !== void 0 && toChainId !== null && String(toChainId).trim() !== "";
   useEffect5(() => {
-    if (!fromChain || !toChain || !hasFromChainId || !hasToChainId || !fromToken || !toToken || !fromAmountWei || !fromAddress || !toAddress)
+    if (!fromChain || !hasFromChainId || !hasToChainId || !fromToken || !toToken || !fromAmountWei || !fromAddress || !toAddress)
       return;
     abortRef.current?.abort();
     if (!routeKey) {
@@ -2640,6 +4372,9 @@ function useRouteBuilder({
         });
         if (ac.signal.aborted) return;
         const estimate = result?.route?.estimate;
+        if (!result?.txReq?.data || !isEvmTxRequest(result.txReq) && !isSerializedSolanaTxRequest(result.txReq)) {
+          throw new Error("Invalid route response");
+        }
         const fees = estimate?.fees;
         let networkFeesUSD = null;
         if (estimate?.fromAmountUsd && estimate?.toAmountMinUsd) {
@@ -3085,9 +4820,9 @@ function TrustwareProvider({
   const revalidate = useCallback2(async () => {
     try {
       await initialize();
-    } catch (e) {
+    } catch (e2) {
       setStatus("error");
-      setErrors(e instanceof Error ? e.message : String(e));
+      setErrors(e2 instanceof Error ? e2.message : String(e2));
     }
   }, [initialize]);
   useEffect7(() => {
@@ -3095,16 +4830,16 @@ function TrustwareProvider({
     const setStatusSafe = (s) => {
       if (!cancelled) setStatus(s);
     };
-    const setErrorsSafe = (e) => {
-      if (!cancelled) setErrors(e);
+    const setErrorsSafe = (e2) => {
+      if (!cancelled) setErrors(e2);
     };
     (async () => {
       try {
         await initialize(setStatusSafe, setErrorsSafe);
-      } catch (e) {
+      } catch (e2) {
         if (!cancelled) {
           setStatus("error");
-          setErrors(e instanceof Error ? e.message : String(e));
+          setErrors(e2 instanceof Error ? e2.message : String(e2));
         }
       }
     })();
@@ -3469,7 +5204,7 @@ function DepositProvider({
         const tokensByCanonicalKey = /* @__PURE__ */ new Map();
         for (const token of tokens) {
           const tokenChain = chains.find(
-            (chain) => normalizeChainKey(chain.chainId) === normalizeChainKey(token.chainId)
+            (chain) => normalizeChainKey2(chain.chainId) === normalizeChainKey2(token.chainId)
           );
           if (!tokenChain) continue;
           const canonicalAddress = canonicalTokenAddressForChain(
@@ -3477,12 +5212,12 @@ function DepositProvider({
             token.address,
             tokens
           );
-          const key = `${normalizeChainKey(token.chainId)}:${canonicalAddress}`;
+          const key = `${normalizeChainKey2(token.chainId)}:${canonicalAddress}`;
           tokensByCanonicalKey.set(key, token);
         }
         const updatedArr = flatenedTokenWithBalancesArr.flatMap((balanceRow) => {
           const chain = chains.find(
-            (c) => normalizeChainKey(c.chainId) === normalizeChainKey(balanceRow.chain_id)
+            (c) => normalizeChainKey2(c.chainId) === normalizeChainKey2(balanceRow.chain_id)
           );
           if (!chain) return [];
           const balanceAddress = balanceRow.contract ?? balanceRow.address;
@@ -3491,17 +5226,17 @@ function DepositProvider({
             balanceAddress,
             tokens
           );
-          const canonicalKey = `${normalizeChainKey(balanceRow.chain_id)}:${canonicalBalanceAddress}`;
+          const canonicalKey = `${normalizeChainKey2(balanceRow.chain_id)}:${canonicalBalanceAddress}`;
           let foundToken = tokensByCanonicalKey.get(canonicalKey);
           if (!foundToken) {
             const isNativeCategory = balanceRow.category === "native";
             if (isNativeCategory) {
               const nativeAddress = canonicalTokenAddressForChain(
                 chain,
-                getNativeTokenAddress(chain.type),
+                getNativeTokenAddress2(chain.type),
                 tokens
               );
-              const nativeKey = `${normalizeChainKey(balanceRow.chain_id)}:${nativeAddress}`;
+              const nativeKey = `${normalizeChainKey2(balanceRow.chain_id)}:${nativeAddress}`;
               foundToken = tokensByCanonicalKey.get(nativeKey);
             }
           }
@@ -3517,11 +5252,9 @@ function DepositProvider({
               iconUrl: foundToken.iconUrl ?? foundToken.logoURI ?? "",
               chainId: balanceRow.chain_id,
               usdPrice: foundToken.usdPrice,
-              address: canonicalTokenAddressForChain(
-                chain,
-                foundToken.address,
-                tokens
-              ),
+              // Preserve the registry/backend token identifier for downstream
+              // route payloads; canonicalization is only for comparisons.
+              address: foundToken.address,
               chainIconURI: chain?.chainIconURI || "",
               chainData: chain
             }
@@ -3787,8 +5520,8 @@ function AmountSlider({
   }, [max, min, value]);
   const percentage = useMemo8(() => getPercentage(), [getPercentage]);
   const handleChange = useCallback5(
-    (e) => {
-      const newValue = Math.min(Math.max(Number(e.target.value), min), max);
+    (e2) => {
+      const newValue = Math.min(Math.max(Number(e2.target.value), min), max);
       onChange(newValue);
     },
     [onChange, min, max]
@@ -4124,7 +5857,7 @@ function AmountInputDisplay({
                       type: "text",
                       inputMode: "decimal",
                       value: amount,
-                      onChange: (e) => onAmountChange(e.target.value),
+                      onChange: (e2) => onAmountChange(e2.target.value),
                       onBlur: () => setIsEditing(false),
                       readOnly: isFixedAmount,
                       style: {
@@ -4283,9 +6016,9 @@ var Dialog = ({
   const firstButtonRef = useRef5(null);
   const lastButtonRef = useRef5(null);
   useEffect11(() => {
-    const handleEscape = (e) => {
-      if (e.key === "Escape" && open) {
-        e.preventDefault();
+    const handleEscape = (e2) => {
+      if (e2.key === "Escape" && open) {
+        e2.preventDefault();
         onCancel();
       }
     };
@@ -4297,17 +6030,17 @@ var Dialog = ({
     };
   }, [open, onCancel]);
   useEffect11(() => {
-    const handleTabKey = (e) => {
+    const handleTabKey = (e2) => {
       if (!open) return;
-      if (e.key === "Tab") {
-        if (e.shiftKey) {
+      if (e2.key === "Tab") {
+        if (e2.shiftKey) {
           if (document.activeElement === firstButtonRef.current) {
-            e.preventDefault();
+            e2.preventDefault();
             lastButtonRef.current?.focus();
           }
         } else {
           if (document.activeElement === lastButtonRef.current) {
-            e.preventDefault();
+            e2.preventDefault();
             firstButtonRef.current?.focus();
           }
         }
@@ -4333,50 +6066,50 @@ var Dialog = ({
       };
     }
   }, [open]);
-  const handleOverlayClick = (e) => {
-    if (e.target === e.currentTarget) {
+  const handleOverlayClick = (e2) => {
+    if (e2.target === e2.currentTarget) {
       onCancel();
     }
   };
-  const handleCancelKeyDown = (e) => {
-    if (e.key === "Enter" && !e.shiftKey) {
-      e.preventDefault();
+  const handleCancelKeyDown = (e2) => {
+    if (e2.key === "Enter" && !e2.shiftKey) {
+      e2.preventDefault();
       onCancel();
     }
   };
-  const handleConfirmKeyDown = (e) => {
-    if (e.key === "Enter" && !e.shiftKey) {
-      e.preventDefault();
+  const handleConfirmKeyDown = (e2) => {
+    if (e2.key === "Enter" && !e2.shiftKey) {
+      e2.preventDefault();
       onConfirm();
     }
   };
-  const handleCancelMouseEnter = (e) => {
-    e.currentTarget.style.backgroundColor = "var(--cancel-hover, #e5e7eb)";
+  const handleCancelMouseEnter = (e2) => {
+    e2.currentTarget.style.backgroundColor = "var(--cancel-hover, #e5e7eb)";
   };
-  const handleCancelMouseLeave = (e) => {
-    e.currentTarget.style.backgroundColor = "var(--cancel-bg, #f3f4f6)";
+  const handleCancelMouseLeave = (e2) => {
+    e2.currentTarget.style.backgroundColor = "var(--cancel-bg, #f3f4f6)";
   };
-  const handleConfirmMouseEnter = (e) => {
-    e.currentTarget.style.backgroundColor = "var(--confirm-hover, #dc2626)";
+  const handleConfirmMouseEnter = (e2) => {
+    e2.currentTarget.style.backgroundColor = "var(--confirm-hover, #dc2626)";
   };
-  const handleConfirmMouseLeave = (e) => {
-    e.currentTarget.style.backgroundColor = "var(--confirm-bg, #ef4444)";
+  const handleConfirmMouseLeave = (e2) => {
+    e2.currentTarget.style.backgroundColor = "var(--confirm-bg, #ef4444)";
   };
-  const handleCancelFocus = (e) => {
-    e.currentTarget.style.boxShadow = "0 0 0 3px rgba(59, 130, 246, 0.5)";
-    e.currentTarget.style.borderColor = "#3b82f6";
+  const handleCancelFocus = (e2) => {
+    e2.currentTarget.style.boxShadow = "0 0 0 3px rgba(59, 130, 246, 0.5)";
+    e2.currentTarget.style.borderColor = "#3b82f6";
   };
-  const handleCancelBlur = (e) => {
-    e.currentTarget.style.boxShadow = "";
-    e.currentTarget.style.borderColor = "var(--cancel-border, #d1d5db)";
+  const handleCancelBlur = (e2) => {
+    e2.currentTarget.style.boxShadow = "";
+    e2.currentTarget.style.borderColor = "var(--cancel-border, #d1d5db)";
   };
-  const handleConfirmFocus = (e) => {
-    e.currentTarget.style.boxShadow = "0 0 0 3px rgba(239, 68, 68, 0.5)";
-    e.currentTarget.style.borderColor = "#ef4444";
+  const handleConfirmFocus = (e2) => {
+    e2.currentTarget.style.boxShadow = "0 0 0 3px rgba(239, 68, 68, 0.5)";
+    e2.currentTarget.style.borderColor = "#ef4444";
   };
-  const handleConfirmBlur = (e) => {
-    e.currentTarget.style.boxShadow = "";
-    e.currentTarget.style.borderColor = "transparent";
+  const handleConfirmBlur = (e2) => {
+    e2.currentTarget.style.boxShadow = "";
+    e2.currentTarget.style.borderColor = "transparent";
   };
   if (!open) return null;
   return /* @__PURE__ */ jsx7(Fragment, { children: /* @__PURE__ */ jsx7(
@@ -4627,19 +6360,19 @@ function SwipeToConfirmTokens({
     longPressAnimationRef.current = requestAnimationFrame(animateProgress);
   }, [disabled, isComplete, isDragging, triggerConfirmation, cancelLongPress]);
   const handleKeyDown = useCallback6(
-    (e) => {
+    (e2) => {
       if (disabled || isComplete) return;
-      if (e.key === "Enter" || e.key === " ") {
-        e.preventDefault();
+      if (e2.key === "Enter" || e2.key === " ") {
+        e2.preventDefault();
         startLongPress();
       }
     },
     [disabled, isComplete, startLongPress]
   );
   const handleKeyUp = useCallback6(
-    (e) => {
-      if (e.key === "Enter" || e.key === " ") {
-        e.preventDefault();
+    (e2) => {
+      if (e2.key === "Enter" || e2.key === " ") {
+        e2.preventDefault();
         cancelLongPress();
       }
     },
@@ -4652,17 +6385,17 @@ function SwipeToConfirmTokens({
         cancelAnimationFrame(longPressAnimationRef.current);
     };
   }, []);
-  const handleMouseDown = (e) => {
-    e.preventDefault();
+  const handleMouseDown = (e2) => {
+    e2.preventDefault();
     handleDragStart();
   };
   const handleMouseMove = useCallback6(
-    (e) => handleDragMove(e.clientX),
+    (e2) => handleDragMove(e2.clientX),
     [handleDragMove]
   );
   const handleMouseUp = useCallback6(() => handleDragEnd(), [handleDragEnd]);
   const handleTouchStart = () => handleDragStart();
-  const handleTouchMove = (e) => handleDragMove(e.touches[0].clientX);
+  const handleTouchMove = (e2) => handleDragMove(e2.touches[0].clientX);
   const handleTouchEnd = () => handleDragEnd();
   useEffect12(() => {
     if (isDragging) {
@@ -5419,7 +7152,13 @@ function TokenSwipePill({
   const startXRef = useRef7(0);
   const containerRef = useRef7(null);
   const currentIndex = tokens.findIndex(
-    (t) => t.address === selectedToken.address && t.symbol === selectedToken.symbol
+    (t) => normalizeAddress2(
+      t.address,
+      t.chainData?.type ?? t.chainData?.chainType
+    ) === normalizeAddress2(
+      selectedToken.address,
+      selectedToken.chainData?.type ?? selectedToken.chainData?.chainType
+    ) && t.symbol === selectedToken.symbol
   );
   const swipeThreshold = 30;
   const hasMultipleTokens = tokens.length > 1;
@@ -5457,27 +7196,27 @@ function TokenSwipePill({
     }
     setDragOffset(0);
   }, [isDragging, dragOffset, currentIndex, tokens, onTokenChange]);
-  const handleMouseDown = (e) => {
+  const handleMouseDown = (e2) => {
     if (!hasMultipleTokens) return;
-    e.preventDefault();
-    handleDragStart(e.clientX);
+    e2.preventDefault();
+    handleDragStart(e2.clientX);
   };
   const handleMouseMove = useCallback8(
-    (e) => {
-      handleDragMove(e.clientX);
+    (e2) => {
+      handleDragMove(e2.clientX);
     },
     [handleDragMove]
   );
   const handleMouseUp = useCallback8(() => {
     handleDragEnd();
   }, [handleDragEnd]);
-  const handleTouchStart = (e) => {
+  const handleTouchStart = (e2) => {
     if (!hasMultipleTokens) return;
-    handleDragStart(e.touches[0].clientX);
+    handleDragStart(e2.touches[0].clientX);
   };
-  const handleTouchMove = (e) => {
+  const handleTouchMove = (e2) => {
     if (!hasMultipleTokens) return;
-    handleDragMove(e.touches[0].clientX);
+    handleDragMove(e2.touches[0].clientX);
   };
   const handleTouchEnd = () => {
     handleDragEnd();
@@ -5724,8 +7463,8 @@ function TokenSwipePill({
                       return tokens.map((token, index) => /* @__PURE__ */ jsx11(
                         "div",
                         {
-                          onClick: (e) => {
-                            e.stopPropagation();
+                          onClick: (e2) => {
+                            e2.stopPropagation();
                             onTokenChange(token);
                           },
                           style: {
@@ -5779,8 +7518,8 @@ function TokenSwipePill({
                         /* @__PURE__ */ jsx11(
                           "div",
                           {
-                            onClick: (e) => {
-                              e.stopPropagation();
+                            onClick: (e2) => {
+                              e2.stopPropagation();
                               onTokenChange(token);
                             },
                             style: {
@@ -5883,8 +7622,8 @@ function TokenSwipePill({
               cursor: "pointer",
               backgroundColor: "transparent"
             },
-            onClick: (e) => {
-              e.stopPropagation();
+            onClick: (e2) => {
+              e2.stopPropagation();
               onExpandClick?.();
             },
             children: [
@@ -6166,8 +7905,8 @@ function WidgetContainer({
     if (theme === "system") {
       const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
       setResolvedTheme(mediaQuery.matches ? "dark" : "light");
-      const handler = (e) => {
-        setResolvedTheme(e.matches ? "dark" : "light");
+      const handler = (e2) => {
+        setResolvedTheme(e2.matches ? "dark" : "light");
       };
       mediaQuery.addEventListener("change", handler);
       return () => mediaQuery.removeEventListener("change", handler);
@@ -6451,7 +8190,6 @@ function Home({ style: _style }) {
     amount,
     setAmount,
     setCurrentStep,
-    walletAddress,
     connectWallet,
     amountInputMode,
     setAmountInputMode,
@@ -6511,10 +8249,6 @@ function Home({ style: _style }) {
   })();
   const handleWalletSelect = async (wallet) => {
     setIsCryptoDropdownOpen(false);
-    if (walletAddress) {
-      setCurrentStep("crypto-pay");
-      return;
-    }
     try {
       await connectWallet(wallet);
       setCurrentStep("crypto-pay");
@@ -7513,6 +9247,7 @@ function SelectToken({ style }) {
   const handleChainSelect = (chain) => {
     const chainId = Number(chain.chainId ?? chain.id);
     setSelectedChain({
+      ...chain,
       chainId,
       name: resolveChainLabel(chain),
       shortName: chain.nativeCurrency?.symbol ?? resolveChainLabel(chain).slice(0, 3).toUpperCase(),
@@ -7528,8 +9263,9 @@ function SelectToken({ style }) {
       selectedChain?.chainId,
       walletAddress
     );
+    const chainType = normalizeChainType2(selectedChain);
     const match = balance.find(
-      (b) => b.contract?.toLowerCase() === token.address.toLowerCase()
+      (b) => normalizeAddress2(b.contract ?? b.address ?? "", chainType) === normalizeAddress2(token.address, chainType)
     );
     const tokenWithBalance = {
       ...token,
@@ -8102,7 +9838,7 @@ function SelectToken({ style }) {
                                     type: "text",
                                     placeholder: "Search tokens...",
                                     value: searchQuery,
-                                    onChange: (e) => setSearchQuery(e.target.value),
+                                    onChange: (e2) => setSearchQuery(e2.target.value),
                                     style: {
                                       width: "100%",
                                       paddingLeft: spacing[8],
@@ -8695,8 +10431,8 @@ function SelectToken({ style }) {
                                             objectFit: "cover",
                                             flexShrink: 0
                                           },
-                                          onError: (e) => {
-                                            const target = e.target;
+                                          onError: (e2) => {
+                                            const target = e2.target;
                                             target.style.display = "none";
                                             if (target.nextElementSibling) {
                                               target.nextElementSibling.style.display = "flex";
@@ -9112,18 +10848,18 @@ function CryptoPay({ style }) {
   const amountWei = amountValidationError ? 0n : amountComputation.fromAmountWei ?? 0n;
   const routeConfig = useMemo12(() => {
     const toChainId = config.routes.toChain;
-    const toChainKey = normalizeChainKey(toChainId);
+    const toChainKey = normalizeChainKey2(toChainId);
     const toChain = toChainKey ? chains.find(
-      (chain) => normalizeChainKey(chain.chainId ?? chain.id) === toChainKey
+      (chain) => normalizeChainKey2(chain.chainId ?? chain.id) === toChainKey
     ) ?? null : null;
     const object = {
       fromChain: selectedChain?.chainId ?? selectedChain?.id ?? "",
       fromChainId: selectedChain?.chainId ?? selectedChain?.id,
-      toChain,
+      toChain: toChain ?? toChainId,
       toChainId,
       toToken: config.routes.toToken,
       toAddress: config.routes.toAddress || walletAddress || void 0,
-      fromToken: selectedToken?.address ?? getNativeTokenAddress(selectedChain?.type ?? selectedChain?.chainType),
+      fromToken: selectedToken?.address ?? getNativeTokenAddress2(selectedChain?.type ?? selectedChain?.chainType),
       fromAmountWei: amountWei ?? 0n,
       fromAmountUsd: amountComputation.usdAmount || void 0,
       fromAddress: walletAddress || void 0,
@@ -9178,7 +10914,7 @@ function CryptoPay({ style }) {
     selectedToken,
     walletAddress
   ]);
-  const routeError = routeBuilderError && "No successful provider response";
+  const routeError = routeBuilderError ?? null;
   const actionErrorMessage = routePrerequisiteError || routeError || null;
   const { emitError } = useTrustware();
   useEffect17(() => {
@@ -9243,7 +10979,7 @@ function CryptoPay({ style }) {
     const address = selectedToken?.address;
     return isNativeTokenAddress(address, chainType) || isZeroAddrLike(address, chainType) || normalizeTokenAddressForCompare(selectedChain, address) === normalizeTokenAddressForCompare(
       selectedChain,
-      getNativeTokenAddress(chainType)
+      getNativeTokenAddress2(chainType)
     );
   }, [chainType, selectedChain, selectedToken?.address]);
   const spender = useMemo12(() => {
@@ -9290,7 +11026,7 @@ function CryptoPay({ style }) {
       return;
     }
     const wallet = Trustware.getWallet();
-    if (!wallet) {
+    if (!wallet || wallet.ecosystem !== "evm") {
       return;
     }
     setIsApproving(true);
@@ -9509,8 +11245,12 @@ function CryptoPay({ style }) {
     await handleConfirm();
   }, [handleApproveExact, handleConfirm, needsApproval]);
   const orderedTokens = useMemo12(() => {
+    const selectedTokenChainType = selectedToken?.chainData?.type ?? selectedToken?.chainData?.chainType;
     const index = yourWalletTokens.findIndex(
-      (t) => t.address?.toLowerCase() === selectedToken?.address?.toLowerCase()
+      (t) => normalizeAddress2(
+        t.address,
+        t.chainData?.type ?? t.chainData?.chainType
+      ) === normalizeAddress2(selectedToken?.address ?? "", selectedTokenChainType)
     );
     let _tok = [];
     if (index === -1) {
@@ -9570,7 +11310,10 @@ function CryptoPay({ style }) {
   const isWalletConnected = walletStatus === "connected";
   const canSwipe = parsedAmount > 0 && selectedToken && isWalletConnected && !isLoadingRoute && !isSubmitting && !!routeResult && !actionErrorMessage && !isApproving && !isReadingAllowance;
   const swipeResetKey = useMemo12(() => {
-    const tokenAddress = selectedToken?.address?.toLowerCase() ?? "no-token";
+    const tokenAddress = selectedToken ? normalizeAddress2(
+      selectedToken.address,
+      selectedToken?.chainData?.type ?? selectedToken?.chainData?.chainType
+    ) : "no-token";
     const chainId = selectedToken?.chainData?.chainId ?? selectedChain?.chainId ?? "no-chain";
     return [
       tokenAddress,
@@ -11922,6 +13665,7 @@ export {
   DEFAULT_RETRY_CONFIG,
   DEFAULT_SLIPPAGE2 as DEFAULT_SLIPPAGE,
   DEFAULT_THEME2 as DEFAULT_THEME,
+  IdentityStore,
   RateLimitError,
   SDK_NAME,
   SDK_VERSION,
@@ -11930,12 +13674,22 @@ export {
   TrustwareProvider,
   TrustwareWidgetV2 as TrustwareWidget,
   WALLETCONNECT_PROJECT_ID,
+  buildWalletIdentityAddress,
   connectDetectedWallet,
+  createWalletIdentity,
+  resolveWalletAddressForChain,
   toWalletInterfaceFromDetected,
+  upsertWalletIdentityAddress,
   useEIP1193,
   useTrustware,
   useWagmi,
   useWalletDetection,
-  useWireDetectionIntoManager
+  useWireDetectionIntoManager,
+  validateAddressForChain,
+  validateBtcAddress,
+  validateEvmAddress,
+  validateRouteAddresses,
+  validateSeiAddress,
+  validateSolanaAddress
 };
 //# sourceMappingURL=index.mjs.map