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

package/dist/core.cjs

@@ -0,0 +1,3107 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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;
+var init_defaults = __esm({
+  "src/config/defaults.ts"() {
+    "use strict";
+    DEFAULT_SLIPPAGE = 1;
+    DEFAULT_AUTO_DETECT_PROVIDER = false;
+    DEFAULT_THEME = {
+      primaryColor: "#4F46E5",
+      secondaryColor: "#6366F1",
+      backgroundColor: "#FFFFFF",
+      textColor: "#111827",
+      borderColor: "#E5E7EB",
+      radius: 8
+    };
+    DEFAULT_MESSAGES = {
+      title: "Trustware SDK",
+      description: "Seamlessly bridge assets across chains with Trustware."
+    };
+  }
+});
+
+// src/types/config.ts
+var DEFAULT_RETRY_CONFIG;
+var init_config = __esm({
+  "src/types/config.ts"() {
+    "use strict";
+    DEFAULT_RETRY_CONFIG = {
+      autoRetry: true,
+      maxRetries: 3,
+      baseDelayMs: 1e3,
+      approachingThreshold: 5
+    };
+  }
+});
+
+// src/constants.ts
+var SDK_NAME, SDK_VERSION, API_ROOT, API_PREFIX, WALLETCONNECT_PROJECT_ID;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    SDK_NAME = "@trustware/sdk";
+    SDK_VERSION = "1.0.17-staging.15";
+    API_ROOT = "https://bv-staging-api.trustware.io";
+    API_PREFIX = "/api";
+    WALLETCONNECT_PROJECT_ID = "4ead125c-63be-4b1a-a835-cef2dce67b84";
+  }
+});
+
+// src/config/merge.ts
+function resolveWalletConnectConfig(input) {
+  if (input?.disabled) return void 0;
+  const projectId = input?.projectId ?? WALLETCONNECT_PROJECT_ID;
+  return {
+    projectId,
+    chains: input?.chains ?? [1],
+    // Default to Ethereum mainnet
+    optionalChains: input?.optionalChains ?? [
+      1,
+      10,
+      56,
+      137,
+      8453,
+      42161,
+      43114
+    ],
+    // ETH, OP, BSC, Polygon, Base, Arbitrum, Avalanche
+    metadata: {
+      name: input?.metadata?.name ?? "Trustware",
+      description: input?.metadata?.description ?? "Cross-chain bridge & top-up",
+      url: input?.metadata?.url ?? "https://trustware.io",
+      icons: input?.metadata?.icons ?? ["https://app.trustware.io/icon.png"]
+    },
+    relayUrl: input?.relayUrl,
+    showQrModal: input?.showQrModal ?? true
+  };
+}
+function deepMerge(base, patch) {
+  if (!patch) return { ...base };
+  const out = Array.isArray(base) ? [...base] : { ...base };
+  for (const [k, v] of Object.entries(patch)) {
+    if (v && typeof v === "object" && !Array.isArray(v)) {
+      out[k] = deepMerge(base[k] ?? {}, v);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function normalizeSlippage(v) {
+  const n = Number(v);
+  if (!Number.isFinite(n)) return DEFAULT_SLIPPAGE;
+  if (n <= 0) return DEFAULT_SLIPPAGE;
+  if (n > 5) return 5;
+  return n;
+}
+function resolveConfig(input) {
+  if (!input?.apiKey) {
+    throw new Error("TrustwareConfig: 'apiKey' is required.");
+  }
+  if (!input.routes?.toChain || !input.routes?.toToken) {
+    throw new Error(
+      "TrustwareConfig: 'routes.toChain' and 'routes.toToken' are required."
+    );
+  }
+  const autoDetectProvider = typeof input.autoDetectProvider === "boolean" ? input.autoDetectProvider : DEFAULT_AUTO_DETECT_PROVIDER;
+  const routes = {
+    toChain: input.routes.toChain,
+    toToken: input.routes.toToken,
+    fromToken: input.routes.fromToken,
+    fromAddress: input.routes.fromAddress,
+    toAddress: input.routes.toAddress,
+    defaultSlippage: normalizeSlippage(
+      input.routes.defaultSlippage ?? DEFAULT_SLIPPAGE
+    ),
+    routeType: input.routes.routeType ?? "swap",
+    options: {
+      ...input.routes.options
+    }
+  };
+  const theme = deepMerge(DEFAULT_THEME, input.theme);
+  const messages = deepMerge(DEFAULT_MESSAGES, input.messages);
+  const retry = {
+    autoRetry: input.retry?.autoRetry ?? DEFAULT_RETRY_CONFIG.autoRetry,
+    maxRetries: input.retry?.maxRetries ?? DEFAULT_RETRY_CONFIG.maxRetries,
+    baseDelayMs: input.retry?.baseDelayMs ?? DEFAULT_RETRY_CONFIG.baseDelayMs,
+    approachingThreshold: input.retry?.approachingThreshold ?? DEFAULT_RETRY_CONFIG.approachingThreshold,
+    onRateLimitInfo: input.retry?.onRateLimitInfo,
+    onRateLimited: input.retry?.onRateLimited,
+    onRateLimitApproaching: input.retry?.onRateLimitApproaching
+  };
+  const walletConnect = resolveWalletConnectConfig(input.walletConnect);
+  return {
+    apiKey: input.apiKey,
+    routes,
+    autoDetectProvider,
+    theme,
+    messages,
+    retry,
+    walletConnect,
+    onError: input.onError,
+    onSuccess: input.onSuccess,
+    onEvent: input.onEvent
+  };
+}
+var init_merge = __esm({
+  "src/config/merge.ts"() {
+    "use strict";
+    init_defaults();
+    init_config();
+    init_constants();
+  }
+});
+
+// src/config/store.ts
+var store_exports = {};
+__export(store_exports, {
+  TrustwareConfig: () => TrustwareConfig,
+  TrustwareConfigStore: () => TrustwareConfigStore
+});
+var ConfigStore, TrustwareConfigStore, TrustwareConfig;
+var init_store = __esm({
+  "src/config/store.ts"() {
+    "use strict";
+    init_merge();
+    ConfigStore = class {
+      constructor() {
+        this._cfg = null;
+        this._listeners = /* @__PURE__ */ new Set();
+      }
+      isInitialized() {
+        return this._cfg != null;
+      }
+      peek() {
+        return this._cfg;
+      }
+      /** Initialize or replace the config */
+      init(opts) {
+        this._cfg = resolveConfig(opts);
+        this.emit();
+      }
+      /** Partially update by re-resolving from last + patch */
+      update(patch) {
+        if (!this._cfg) throw new Error("TrustwareConfig: call init() first.");
+        const next = resolveConfig({
+          ...this._cfg,
+          ...patch,
+          routes: { ...this._cfg.routes, ...patch.routes ?? {} },
+          theme: {
+            ...this._cfg.theme,
+            ...patch.theme ?? {}
+          },
+          messages: {
+            ...this._cfg.messages,
+            ...patch.messages ?? {}
+          },
+          retry: { ...this._cfg.retry, ...patch.retry ?? {} },
+          walletConnect: patch.walletConnect ? { ...this._cfg.walletConnect, ...patch.walletConnect } : this._cfg.walletConnect
+        });
+        this._cfg = next;
+        this.emit();
+      }
+      get() {
+        if (!this._cfg) throw new Error("TrustwareConfig: not initialized.");
+        return this._cfg;
+      }
+      getTheme() {
+        return this.get().theme;
+      }
+      getMessages() {
+        return this.get().messages;
+      }
+      subscribe(fn) {
+        this._listeners.add(fn);
+        if (this._cfg) fn(this._cfg);
+        return () => {
+          this._listeners.delete(fn);
+        };
+      }
+      emit() {
+        if (!this._cfg) return;
+        for (const fn of this._listeners) fn(this._cfg);
+      }
+    };
+    TrustwareConfigStore = new ConfigStore();
+    TrustwareConfig = {
+      init: (opts) => TrustwareConfigStore.init(opts),
+      update: (patch) => TrustwareConfigStore.update(patch),
+      get: () => TrustwareConfigStore.get(),
+      getTheme: () => TrustwareConfigStore.get().theme,
+      getMessages: () => TrustwareConfigStore.get().messages,
+      subscribe: (fn) => TrustwareConfigStore.subscribe(fn)
+    };
+  }
+});
+
+// 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"() {
+    "use strict";
+    init_defaults();
+    init_merge();
+    init_store();
+  }
+});
+
+// src/core/http.ts
+var http_exports = {};
+__export(http_exports, {
+  RateLimitError: () => RateLimitError,
+  apiBase: () => apiBase,
+  assertOK: () => assertOK,
+  jsonHeaders: () => jsonHeaders,
+  parseRateLimitHeaders: () => parseRateLimitHeaders,
+  rateLimitedFetch: () => rateLimitedFetch,
+  validateSdkAccess: () => validateSdkAccess
+});
+function apiBase() {
+  return `${API_ROOT}${API_PREFIX}`;
+}
+function jsonHeaders(extra) {
+  const cfg = TrustwareConfigStore.get();
+  const h = {
+    "Content-Type": "application/json",
+    "X-API-Key": cfg.apiKey,
+    "X-SDK-Name": SDK_NAME,
+    "X-SDK-Version": SDK_VERSION,
+    "X-API-Version": "2025-10-01"
+  };
+  return { ...h, ...extra || {} };
+}
+async function assertOK(r) {
+  if (r.ok) return;
+  let msg = r.statusText;
+  try {
+    const j = await r.json();
+    if (j?.error) msg = j.error;
+  } catch {
+  }
+  throw new Error(`HTTP ${r.status}: ${msg}`);
+}
+async function validateSdkAccess() {
+  const r = await fetch(`${apiBase()}/sdk/validate`, {
+    method: "GET",
+    headers: jsonHeaders()
+  });
+  await assertOK(r);
+  const j = await r.json();
+  return j.data;
+}
+function parseRateLimitHeaders(r) {
+  const limit = r.headers.get("X-RateLimit-Limit");
+  const remaining = r.headers.get("X-RateLimit-Remaining");
+  const reset = r.headers.get("X-RateLimit-Reset");
+  if (!limit || !remaining || !reset) {
+    return null;
+  }
+  const info = {
+    limit: parseInt(limit, 10),
+    remaining: parseInt(remaining, 10),
+    reset: parseInt(reset, 10)
+  };
+  const retryAfter = r.headers.get("Retry-After");
+  if (retryAfter) {
+    info.retryAfter = parseInt(retryAfter, 10);
+  }
+  return info;
+}
+function notifyRateLimitCallbacks(info, isRateLimited, retryCount) {
+  const cfg = TrustwareConfigStore.get();
+  const { retry } = cfg;
+  if (retry.onRateLimitInfo) {
+    retry.onRateLimitInfo(info);
+  }
+  if (isRateLimited && retry.onRateLimited) {
+    retry.onRateLimited(info, retryCount);
+  }
+  if (!isRateLimited && retry.onRateLimitApproaching && info.remaining <= retry.approachingThreshold) {
+    retry.onRateLimitApproaching(info, retry.approachingThreshold);
+  }
+}
+function calculateBackoffDelay(baseDelayMs, retryCount, retryAfter) {
+  if (retryAfter && retryAfter > 0) {
+    return retryAfter * 1e3;
+  }
+  return baseDelayMs * Math.pow(2, retryCount);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function rateLimitedFetch(url, options = {}) {
+  const { skipRateLimit, ...fetchOptions } = options;
+  const cfg = TrustwareConfigStore.get();
+  if (!cfg.retry.autoRetry || skipRateLimit) {
+    return fetch(url, fetchOptions);
+  }
+  const { maxRetries, baseDelayMs } = cfg.retry;
+  let retryCount = 0;
+  while (true) {
+    const response = await fetch(url, fetchOptions);
+    const rateLimitInfo = parseRateLimitHeaders(response);
+    if (response.status === 429) {
+      if (rateLimitInfo) {
+        notifyRateLimitCallbacks(rateLimitInfo, true, retryCount);
+      }
+      if (retryCount >= maxRetries) {
+        throw new RateLimitError(
+          rateLimitInfo || { limit: 0, remaining: 0, reset: 0 },
+          true
+        );
+      }
+      const delay = calculateBackoffDelay(
+        baseDelayMs,
+        retryCount,
+        rateLimitInfo?.retryAfter
+      );
+      await sleep(delay);
+      retryCount++;
+      continue;
+    }
+    if (rateLimitInfo) {
+      notifyRateLimitCallbacks(rateLimitInfo, false, 0);
+    }
+    return response;
+  }
+}
+var RateLimitError;
+var init_http = __esm({
+  "src/core/http.ts"() {
+    "use strict";
+    init_constants();
+    init_config2();
+    RateLimitError = class extends Error {
+      constructor(info, retriesExhausted) {
+        const message = retriesExhausted ? `Rate limit exceeded after max retries. Try again in ${info.retryAfter ?? Math.ceil((info.reset * 1e3 - Date.now()) / 1e3)} seconds.` : `Rate limit exceeded. Try again in ${info.retryAfter} seconds.`;
+        super(message);
+        this.name = "RateLimitError";
+        this.rateLimitInfo = info;
+        this.retriesExhausted = retriesExhausted;
+      }
+    };
+  }
+});
+
+// src/registry.ts
+var registry_exports = {};
+__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;
+      }
+      async ensureLoaded() {
+        if (this._loaded) return;
+        if (this._loadingPromise) {
+          await this._loadingPromise;
+          return;
+        }
+        this._loadingPromise = this.load();
+        try {
+          await this._loadingPromise;
+        } finally {
+          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}/v1/routes/chains`, {
+            headers: { Accept: "application/json", "X-API-Key": cfg.apiKey }
+          }),
+          fetch(`${this.baseURL}/v1/routes/tokens`, {
+            headers: { Accept: "application/json", "X-API-Key": cfg.apiKey }
+          })
+        ]);
+        if (!chainsRes.ok) throw new Error(`chains: HTTP ${chainsRes.status}`);
+        if (!tokensRes.ok) throw new Error(`tokens: HTTP ${tokensRes.status}`);
+        const chains = await chainsRes.json();
+        const tokens = await tokensRes.json();
+        const chainsArr = Array.isArray(chains) ? chains : chains.data ?? [];
+        for (const chain of chainsArr) {
+          const canonical = chain?.chainId ?? chain?.id;
+          if (canonical == null) continue;
+          const normalized = {
+            ...chain,
+            id: chain.id ?? canonical,
+            chainId: chain.chainId ?? canonical
+          };
+          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 token of tokensArr) {
+          const chainRef = token?.chainId;
+          if (chainRef == null) continue;
+          const normalized = {
+            ...token,
+            chainId: token.chainId ?? chainRef
+          };
+          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(chainRef) {
+        const normalized = normalizeChainKey(chainRef);
+        const canonicalKey = this._chainAliases.get(normalized) ?? normalized;
+        return this._chainsById.get(canonicalKey);
+      }
+      allTokens() {
+        const unique = /* @__PURE__ */ new Map();
+        for (const list of this._tokensByChain.values()) {
+          for (const token of list) {
+            unique.set(`${token.chainId}:${token.address}`, token);
+          }
+        }
+        return Array.from(unique.values());
+      }
+      tokens(chainRef) {
+        return this._tokensByChain.get(normalizeChainKey(chainRef)) ?? [];
+      }
+      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;
+        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;
+      }
+    };
+  }
+});
+
+// src/core.ts
+var core_exports = {};
+__export(core_exports, {
+  Trustware: () => Trustware
+});
+module.exports = __toCommonJS(core_exports);
+
+// src/core/index.ts
+init_store();
+
+// src/wallets/eipWallets.ts
+var CHAIN_PARAMS = {
+  8453: {
+    chainIdHex: "0x2105",
+    chainName: "Base",
+    rpcUrls: ["https://mainnet.base.org"],
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    blockExplorerUrls: ["https://basescan.org"]
+  },
+  42161: {
+    chainIdHex: "0xa4b1",
+    chainName: "Arbitrum One",
+    rpcUrls: ["https://arb1.arbitrum.io/rpc"],
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    blockExplorerUrls: ["https://arbiscan.io"]
+  },
+  43114: {
+    chainIdHex: "0xa86a",
+    chainName: "Avalanche C-Chain",
+    rpcUrls: ["https://api.avax.network/ext/bc/C/rpc"],
+    nativeCurrency: { name: "Avalanche", symbol: "AVAX", decimals: 18 },
+    blockExplorerUrls: ["https://snowtrace.io"]
+  }
+};
+async function addThenSwitch(eth, chainId) {
+  const p = CHAIN_PARAMS[chainId];
+  if (!p) throw new Error(`Unknown chain ${chainId} (no params to add)`);
+  await eth.request({ method: "wallet_addEthereumChain", params: [p] });
+  await eth.request({
+    method: "wallet_switchEthereumChain",
+    params: [{ chainId: p.chainIdHex }]
+  });
+}
+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({
+        method: "eth_requestAccounts"
+      });
+      if (!a) throw new Error("No connected address");
+      return a;
+    },
+    async getChainId() {
+      const hex = await eth.request({ method: "eth_chainId" });
+      return parseInt(String(hex), 16);
+    },
+    async switchChain(chainId) {
+      if (switching) return;
+      switching = true;
+      const hex = CHAIN_PARAMS[chainId]?.chainIdHex ?? `0x${chainId.toString(16)}`;
+      try {
+        await eth.request({
+          method: "wallet_switchEthereumChain",
+          params: [{ chainId: hex }]
+        });
+      } catch (e2) {
+        if (e2?.code === 4902) {
+          await addThenSwitch(eth, chainId);
+        } else if (e2?.code === 4001) {
+        } else {
+          throw e2;
+        }
+      } finally {
+        switching = false;
+      }
+    },
+    request: (args) => eth.request(args)
+  };
+}
+
+// src/wallets/solana.ts
+var import_web3 = require("@solana/web3.js");
+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 import_web3.VersionedTransaction.deserialize(bytes);
+  } catch {
+    return import_web3.Transaction.from(bytes);
+  }
+}
+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 import_web3.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);
+}
+
+// src/wallets/connect.ts
+function pickWagmiConnector(wagmi, metaName, metaId, metaCategory) {
+  const lower = metaName.toLowerCase();
+  const cons = wagmi.connectors();
+  return cons.find((c) => c.name.toLowerCase().includes(lower)) || metaId === "coinbase" && cons.find((c) => c.name.toLowerCase().includes("coinbase")) || metaId === "walletconnect" && cons.find((c) => (c.type ?? "").toLowerCase() === "walletconnect") || metaCategory === "injected" && cons.find((c) => (c.type ?? "").toLowerCase() === "injected") || null;
+}
+async function connectDetectedWallet(dw, opts) {
+  const { wagmi, touchAddress = true } = opts ?? {};
+  if (dw.meta.id === "walletconnect" || dw.via === "walletconnect") {
+    if (wagmi) {
+      const conn = pickWagmiConnector(
+        wagmi,
+        dw.meta.name,
+        dw.meta.id,
+        dw.meta.category
+      );
+      if (conn) {
+        await wagmi.connect(conn);
+        return { via: "wagmi", api: null };
+      }
+    }
+    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,
+      dw.meta.name,
+      dw.meta.id,
+      dw.meta.category
+    );
+    if (conn) {
+      await wagmi.connect(conn);
+      return { via: "wagmi", api: null };
+    }
+  }
+  const api = toWalletInterfaceFromDetected(dw);
+  if (touchAddress) await api.getAddress();
+  return { via: "eip1193", api };
+}
+
+// src/validation/address.ts
+var import_viem = require("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 (!(0, import_viem.isAddress)(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 ((0, import_viem.isAddress)(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") || (0, import_viem.isAddress)(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
+var import_react = require("react");
+var WalletManager = class {
+  constructor() {
+    this._status = "idle";
+    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;
+  }
+  get error() {
+    return this._error;
+  }
+  get detected() {
+    return this._detected;
+  }
+  get wallet() {
+    return this._wallet;
+  }
+  get simple() {
+    if (!this._wallet) return null;
+    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);
+    return () => this._listeners.delete(fn);
+  }
+  emit() {
+    for (const fn of this._listeners) fn(this._status);
+  }
+  /** Provide detection results (from your hook or custom function). */
+  setDetected(list) {
+    this._detected = list;
+  }
+  /** Optional: auto attach to the first/best detected wallet. */
+  async autoAttach(opts) {
+    if (!this._detected.length) return;
+    const target = (opts?.pick ?? ((l) => l[0]))(this._detected);
+    if (!target) return;
+    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;
+        this._connectedWalletId = target.meta.id;
+        this.bindProviderEvents(target);
+        await this.syncIdentityFromWallet(target.meta.id);
+      }
+      this._status = "connected";
+    } catch (e2) {
+      this._error = e2;
+      this._status = "error";
+      this.clearConnectedWalletState();
+    } finally {
+      this.emit();
+    }
+  }
+  async disconnect(wagmi) {
+    if (wagmi) await wagmi.disconnect().catch(() => {
+    });
+    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). */
+  setStatus(s) {
+    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();
+
+// 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()}/v1/routes/route`;
+  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 route";
+    throw new Error(msg);
+  }
+  const intentId = json?.data?.intentId ?? json?.intentId ?? "";
+  const route = json?.data?.route ?? json?.route;
+  const txReq = route?.execution?.transaction;
+  const actions = Array.isArray(route?.steps) ? route.steps : [];
+  const estimate = route?.estimate ?? {};
+  const finalExchangeRate = {
+    fromAmountUSD: estimate.fromAmountUsd,
+    toAmountMinUSD: estimate?.toAmountMinUsd ?? estimate?.toAmountUsd
+  };
+  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()}/v1/route-intent/${intentId}/receipt`,
+    {
+      method: "POST",
+      headers: jsonHeaders({ "Idempotency-Key": txHash }),
+      body: JSON.stringify({ txHash })
+    }
+  );
+  await assertOK(r);
+  const j = await r.json();
+  return j.data;
+}
+async function getStatus(intentId) {
+  const r = await rateLimitedFetch(
+    `${apiBase()}/v1/route-intent/${intentId}/status`,
+    {
+      headers: jsonHeaders()
+    }
+  );
+  await assertOK(r);
+  const j = await r.json();
+  return j.data;
+}
+async function pollStatus(intentId, { intervalMs = 2e3, timeoutMs = 5 * 6e4 } = {}) {
+  const t0 = Date.now();
+  while (true) {
+    const tx = await getStatus(intentId);
+    if (tx.status === "success" || tx.status === "failed") return tx;
+    if (Date.now() - t0 > timeoutMs) return tx;
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+}
+
+// src/core/balances.ts
+init_http();
+init_registry();
+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 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 (!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}`;
+  const r = await fetch(url, {
+    method: "GET",
+    credentials: "omit",
+    headers: jsonHeaders()
+  });
+  if (!r.ok) throw new Error(`balances: HTTP ${r.status}`);
+  const j = await r.json();
+  return Array.isArray(j) ? j : j.results ?? [];
+}
+var _registry;
+async function ensureRegistry() {
+  if (!_registry) {
+    _registry = new Registry(apiBase());
+  }
+  await _registry.ensureLoaded();
+  return _registry;
+}
+
+// src/core/tx.ts
+function isUserRejected(e2) {
+  const code = e2?.code ?? e2?.data?.code;
+  if (code === 4001) return true;
+  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 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;
+    }
+    const response = await w.sendTransaction({
+      to,
+      data,
+      value,
+      chainId: Number.isFinite(target) ? target : void 0
+    });
+    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 } = 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 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
+  ) ?? params.fromToken;
+  const toToken = reg.resolveToken(
+    toChain,
+    params.toToken ?? cfg.routes.toToken ?? void 0
+  ) ?? params.toToken;
+  if (!fromToken || !toToken) {
+    throw new Error("Unable to resolve route tokens");
+  }
+  try {
+    const build = await buildRoute({
+      fromChain,
+      toChain,
+      fromToken,
+      toToken,
+      fromAmount: String(params.fromAmount),
+      fromAddress,
+      toAddress: params.toAddress ?? cfg.routes.toAddress ?? cfg.routes.fromAddress ?? fromAddress,
+      slippage: cfg.routes.defaultSlippage
+    });
+    const hash = await sendRouteTransaction(build, fromChain);
+    await submitReceipt(build.intentId, hash);
+    return await pollStatus(build.intentId);
+  } catch (e2) {
+    if (isUserRejected(e2)) throw new Error("Transaction cancelled by user");
+    throw e2;
+  } finally {
+    try {
+      if (w.ecosystem === "evm" && originalChain && originalChain !== Number(fromChain)) {
+        await w.switchChain(originalChain);
+      }
+    } catch {
+    }
+  }
+}
+
+// src/core/index.ts
+init_http();
+
+// src/core/useChains.ts
+var import_react2 = require("react");
+
+// src/core/registryClient.ts
+init_config2();
+init_registry();
+init_http();
+var registryCache = /* @__PURE__ */ new Map();
+function registryCacheKey() {
+  const base = apiBase();
+  const apiKey = TrustwareConfigStore.peek()?.apiKey ?? "__uninitialized__";
+  return `${base}::${apiKey}`;
+}
+function getSharedRegistry() {
+  const key = registryCacheKey();
+  const existing = registryCache.get(key);
+  if (existing) {
+    return existing;
+  }
+  const registry = new Registry(apiBase());
+  registryCache.set(key, registry);
+  return registry;
+}
+
+// src/widget/helpers/chainHelpers.ts
+function normalizeChainKey2(id) {
+  if (id === void 0 || id === null) return "";
+  return String(id).trim().toLowerCase();
+}
+var CHAIN_TYPE_ALIASES2 = {
+  btc: "bitcoin",
+  bitcoin: "bitcoin",
+  sei: "cosmos",
+  "pacific-1": "cosmos"
+};
+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 inferChainTypeFromValue2(normalized) ?? normalized;
+}
+function canonicalChainKeyForLink(chain) {
+  const seiKey = canonicalSeiChainKey(chain.chainId ?? chain.id);
+  if (seiKey) return seiKey;
+  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 = normalizeChainKey2(chainId);
+  if (!normalized) return null;
+  if (normalized === SEI_EVM_CHAIN_ID) return "sei-evm";
+  if (normalized === SEI_COSMOS_CHAIN_ID) return "sei";
+  return null;
+}
+
+// src/core/useChains.ts
+var POPULAR_CHAIN_IDS = /* @__PURE__ */ new Set([
+  1,
+  // Ethereum Mainnet
+  137,
+  // Polygon
+  8453
+  // Base
+]);
+function filterSupportedChains(chains) {
+  const supportedChainTypes = /* @__PURE__ */ new Set(["evm", "solana", "cosmos", "bitcoin"]);
+  return chains.filter((chain) => {
+    const chainType = normalizeChainType2(chain);
+    if (!chainType) return false;
+    if (!supportedChainTypes.has(chainType)) {
+      return false;
+    }
+    if (chainType === "evm") {
+      const evmKey = canonicalChainKeyForLink(chain);
+      const disabledEvmChains = /* @__PURE__ */ new Set(["hedera", "295"]);
+      if (evmKey && disabledEvmChains.has(evmKey)) {
+        return false;
+      }
+    }
+    if (chainType === "cosmos") {
+      const seiKey = canonicalSeiChainKey(chain.chainId ?? chain.id);
+      if (seiKey !== "sei" && seiKey !== "pacific-1") {
+        return false;
+      }
+    }
+    if (chainType === "bitcoin") {
+      return false;
+    }
+    return true;
+  });
+}
+function useChains() {
+  const [chains, setChains] = (0, import_react2.useState)([]);
+  const [chainMap, setChainMap] = (0, import_react2.useState)(/* @__PURE__ */ new Map());
+  const [isLoading, setIsLoading] = (0, import_react2.useState)(true);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const registry = getSharedRegistry();
+  (0, import_react2.useEffect)(() => {
+    if (chains.length > 0) return;
+    let cancelled = false;
+    const loadChains = async () => {
+      try {
+        setIsLoading(true);
+        setError(null);
+        await registry.ensureLoaded();
+        if (cancelled) return;
+        const loadedChains = registry.chains();
+        const supportedChains = filterSupportedChains(loadedChains);
+        const chainMap2 = new Map(
+          supportedChains.map((chain) => [
+            chain.chainId ?? chain.id,
+            chain
+          ])
+        );
+        setChainMap(chainMap2);
+        setChains(supportedChains);
+      } catch (err) {
+        if (!cancelled) {
+          const message = err instanceof Error ? err.message : "Failed to load chains";
+          setError(message);
+          setChains([]);
+        }
+      } finally {
+        if (!cancelled) {
+          setIsLoading(false);
+        }
+      }
+    };
+    void loadChains();
+    return () => {
+      cancelled = true;
+    };
+  }, [registry, chains.length]);
+  const { popularChains, otherChains } = (0, import_react2.useMemo)(() => {
+    const popular = [];
+    const other = [];
+    for (const chain of chains) {
+      const chainId = Number(chain.chainId ?? chain.id);
+      if (POPULAR_CHAIN_IDS.has(chainId)) {
+        popular.push(chain);
+      } else {
+        other.push(chain);
+      }
+    }
+    const popularOrder = [1, 137, 8453];
+    popular.sort((a, b) => {
+      const aId = Number(a.chainId ?? a.id);
+      const bId = Number(b.chainId ?? b.id);
+      return popularOrder.indexOf(aId) - popularOrder.indexOf(bId);
+    });
+    return { popularChains: popular, otherChains: other };
+  }, [chains]);
+  return {
+    chains,
+    chainMap,
+    popularChains,
+    otherChains,
+    isLoading,
+    error
+  };
+}
+
+// src/core/useTokens.ts
+var import_react3 = require("react");
+
+// src/widget/data/chainPopularity.json
+var chainPopularity_default = {
+  ethereum: 1,
+  "1": 1,
+  arbitrum: 2,
+  "arbitrum-one": 2,
+  "42161": 2,
+  base: 3,
+  "8453": 3,
+  bsc: 4,
+  binance: 4,
+  "binance-smart-chain": 4,
+  "56": 4,
+  solana: 5,
+  "solana-mainnet-beta": 5,
+  avalanche: 6,
+  "avalanche-c-chain": 6,
+  "43114": 6,
+  tron: 7,
+  "728126428": 7,
+  sui: 8,
+  "137": 9,
+  polygon: 9,
+  "polygon-pos": 9,
+  optimism: 10,
+  "10": 10,
+  bitcoin: 11,
+  cosmoshub: 12,
+  cosmos: 12,
+  osmosis: 13,
+  sei: 14,
+  "sei-evm": 14,
+  "pacific-1": 14,
+  "1329": 14,
+  mantle: 15,
+  "5000": 15,
+  linea: 16,
+  "59144": 16,
+  zksync: 17,
+  "zksync-era": 17,
+  "324": 17,
+  blast: 18,
+  "81457": 18,
+  scroll: 19,
+  "534352": 19,
+  sonic: 20,
+  "146": 20
+};
+
+// src/widget/helpers/chainPopularity.ts
+var popularityByKey = chainPopularity_default;
+function getChainPopularityRank(chain) {
+  if (!chain) return null;
+  const aliases = [
+    chain.chainId,
+    chain.networkIdentifier,
+    chain.networkName,
+    chain.axelarChainName
+  ];
+  for (const alias of aliases) {
+    const key = normalizeChainKey2(alias ?? null);
+    if (!key) continue;
+    const rank = popularityByKey[key];
+    if (typeof rank === "number") {
+      return rank;
+    }
+  }
+  return null;
+}
+
+// src/widget/helpers/tokenPopularity.ts
+var POPULAR_TOKEN_SYMBOLS = new Set(
+  [
+    "USDC",
+    "USDC.E",
+    "USDBC",
+    "USDT",
+    "DAI",
+    "ETH",
+    "WETH",
+    "WBTC",
+    "BTC",
+    "SOL",
+    "MATIC"
+  ].map((symbol) => symbol.toUpperCase())
+);
+var POPULAR_TOKEN_CONTRACTS = /* @__PURE__ */ new Set([
+  "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+  // USDC (Ethereum)
+  "0xdac17f958d2ee523a2206206994597c13d831ec7",
+  // USDT (Ethereum)
+  "0x6b175474e89094c44da98b954eedeac495271d0f",
+  // DAI (Ethereum)
+  "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+  // USDC (Base)
+  "0x3c499c542cef5e3811e1192ce70d8cc03d5c3359",
+  // USDC (Polygon)
+  "0x2791bca1f2de4661ed88a30c99a7a9449aa84174",
+  // USDC.e (Polygon)
+  "0xc2132d05d31c914a87c6611c10748aeb04b58e8f",
+  // USDT (Polygon)
+  "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
+  // USDC (Arbitrum)
+  "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9",
+  // USDT (Arbitrum)
+  "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+  // EVM native token marker
+  "so11111111111111111111111111111111111111112"
+  // Wrapped SOL
+]);
+function normalizeSymbol(symbol) {
+  return (symbol ?? "").trim().toUpperCase();
+}
+function normalizeAddress2(address) {
+  return (address ?? "").trim().toLowerCase();
+}
+function hasPositiveBalance(balance) {
+  if (!balance) return false;
+  const trimmed = balance.trim();
+  if (!trimmed) return false;
+  if (/^[+-]?\d+$/.test(trimmed)) {
+    try {
+      return BigInt(trimmed) > 0n;
+    } catch {
+      return false;
+    }
+  }
+  if (/^[+-]?\d*\.\d+$/.test(trimmed)) {
+    const isNegative = trimmed.startsWith("-");
+    if (isNegative) return false;
+    const normalized = trimmed.startsWith("+") ? trimmed.slice(1) : trimmed;
+    const [whole, fraction = ""] = normalized.split(".");
+    const wholeInt = whole ? BigInt(whole) : 0n;
+    if (wholeInt > 0n) return true;
+    return /[1-9]/.test(fraction);
+  }
+  const asNumber = Number(trimmed);
+  return Number.isFinite(asNumber) && asNumber > 0;
+}
+function isPopularToken(token) {
+  const normalizedSymbol = normalizeSymbol(token.symbol);
+  const normalizedAddress = normalizeAddress2(token.address);
+  return POPULAR_TOKEN_SYMBOLS.has(normalizedSymbol) || POPULAR_TOKEN_CONTRACTS.has(normalizedAddress);
+}
+function compareText(a, b) {
+  return (a ?? "").localeCompare(b ?? "", void 0, {
+    sensitivity: "base"
+  });
+}
+function getGroupRank(token) {
+  const popular = isPopularToken(token);
+  const positiveBalance = hasPositiveBalance(token.balance);
+  if (popular && positiveBalance) return 0;
+  if (popular && !positiveBalance) return 1;
+  if (!popular && positiveBalance) return 2;
+  return 3;
+}
+function compareChainPopularity(a, b) {
+  const rankA = getChainPopularityRank({ chainId: a.chainId });
+  const rankB = getChainPopularityRank({ chainId: b.chainId });
+  if (rankA !== null && rankB !== null && rankA !== rankB) {
+    return rankA - rankB;
+  }
+  if (rankA !== null && rankB === null) return -1;
+  if (rankA === null && rankB !== null) return 1;
+  return 0;
+}
+function sortTokensByPopularity(tokens) {
+  return tokens.map((token, index) => ({ token, index })).sort((a, b) => {
+    const rankDiff = getGroupRank(a.token) - getGroupRank(b.token);
+    if (rankDiff !== 0) return rankDiff;
+    const chainPopularityDiff = compareChainPopularity(a.token, b.token);
+    if (chainPopularityDiff !== 0) return chainPopularityDiff;
+    const symbolDiff = compareText(a.token.symbol, b.token.symbol);
+    if (symbolDiff !== 0) return symbolDiff;
+    const nameDiff = compareText(a.token.name, b.token.name);
+    if (nameDiff !== 0) return nameDiff;
+    const addressDiff = compareText(a.token.address, b.token.address);
+    if (addressDiff !== 0) return addressDiff;
+    return a.index - b.index;
+  }).map(({ token }) => token);
+}
+
+// src/core/useTokens.ts
+function mapTokenDefToToken(tokenDef) {
+  return {
+    address: tokenDef.address,
+    chainId: tokenDef.chainId,
+    symbol: tokenDef.symbol,
+    name: tokenDef.name,
+    decimals: tokenDef.decimals,
+    iconUrl: tokenDef.logoURI,
+    logoURI: tokenDef.logoURI,
+    // balance is populated separately when wallet is connected
+    balance: void 0,
+    usdPrice: tokenDef.usdPrice
+  };
+}
+function useTokens(chainId) {
+  const [tokens, setTokens] = (0, import_react3.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react3.useState)(false);
+  const [error, setError] = (0, import_react3.useState)(null);
+  const [searchQuery, setSearchQuery] = (0, import_react3.useState)("");
+  const registry = getSharedRegistry();
+  const { chainMap } = useChains();
+  (0, import_react3.useEffect)(() => {
+    setSearchQuery("");
+    setError(null);
+    setTokens([]);
+    if (chainId === void 0 || chainMap.size === 0) {
+      setIsLoading(false);
+      return;
+    }
+    let cancelled = false;
+    const loadTokens = async () => {
+      try {
+        setIsLoading(true);
+        setError(null);
+        await registry.ensureLoaded();
+        if (cancelled) return;
+        const tokenDefs = chainId === null ? registry.allTokens() : registry.tokens(chainId);
+        const filteredTokens2 = tokenDefs.filter(
+          (item) => chainMap.has(item.chainId.toString())
+        );
+        if (filteredTokens2 !== void 0) {
+          setTokens(filteredTokens2.map(mapTokenDefToToken));
+        }
+      } catch (err) {
+        if (!cancelled) {
+          const message = err instanceof Error ? err.message : "Failed to load tokens";
+          setError(message);
+          setTokens([]);
+        }
+      } finally {
+        if (!cancelled) {
+          setIsLoading(false);
+        }
+      }
+    };
+    void loadTokens();
+    return () => {
+      cancelled = true;
+    };
+  }, [chainId, registry, chainMap]);
+  const filteredTokens = (0, import_react3.useMemo)(() => {
+    const query = searchQuery.toLowerCase().trim();
+    const source = query.length === 0 ? tokens : tokens.filter(
+      (token) => token.symbol.toLowerCase().includes(query) || token.name.toLowerCase().includes(query) || token.address.toLowerCase().includes(query)
+    );
+    return sortTokensByPopularity(source);
+  }, [tokens, searchQuery]);
+  return {
+    tokens,
+    filteredTokens,
+    isLoading,
+    error,
+    searchQuery,
+    setSearchQuery
+  };
+}
+
+// src/errors/TrustwareError.ts
+var TrustwareError = class extends Error {
+  constructor(params) {
+    super(params.message);
+    this.name = "TrustwareError";
+    this.code = params.code;
+    this.userMessage = params.userMessage;
+    this.cause = params.cause;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      userMessage: this.userMessage
+    };
+  }
+};
+
+// src/core/index.ts
+var _lastValidatedKey = null;
+var Trustware = {
+  /** Initialize config */
+  async init(cfg) {
+    TrustwareConfigStore.init(cfg);
+    const key = TrustwareConfigStore.get().apiKey;
+    if (_lastValidatedKey !== key) {
+      try {
+        await validateSdkAccess();
+        _lastValidatedKey = key;
+      } catch (err) {
+        const reason = err instanceof Error && err.message ? `: ${err.message}` : "";
+        const error = new TrustwareError({
+          code: "INVALID_API_KEY" /* INVALID_API_KEY */,
+          message: `Trustware.init: API key validation failed${reason}`,
+          userMessage: "API key validation failed. Please verify your Trustware API key.",
+          cause: err
+        });
+        const config = TrustwareConfigStore.get();
+        config.onError?.(error);
+        config.onEvent?.({ type: "error", error });
+        throw error;
+      }
+    }
+    return Trustware;
+  },
+  /** Attach a wallet interface directly (skips detection) */
+  useWallet(w) {
+    walletManager.attachWallet(w);
+    return Trustware;
+  },
+  /** Best-effort background attach to detected wallet(s) (detection hook should be running in the app) */
+  async autoDetect(_timeoutMs) {
+    await walletManager.autoAttach();
+    return walletManager.wallet != null;
+  },
+  /** Read resolved config */
+  getConfig() {
+    return TrustwareConfigStore.get();
+  },
+  setDestinationAddress(address) {
+    const prev = TrustwareConfigStore.get();
+    TrustwareConfigStore.update({
+      routes: {
+        ...prev.routes,
+        toAddress: address ?? void 0
+      }
+    });
+    return Trustware;
+  },
+  /** Read active wallet */
+  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;
+    if (!w) throw new Error("Trustware.wallet not configured");
+    return w.getAddress();
+  },
+  // ---- REST methods (re-export) ----
+  buildRoute,
+  buildDepositAddress,
+  submitReceipt,
+  getStatus,
+  pollStatus,
+  getBalances,
+  getBalancesByAddress,
+  useChains,
+  useTokens,
+  validateAddressForChain,
+  validateRouteAddresses,
+  // ---- Tx helpers ----
+  sendRouteTransaction,
+  runTopUp
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Trustware
+});
+//# sourceMappingURL=core.cjs.map