@sodax/wallet-sdk-react 1.5.6-beta → 2.0.0-rc.1

package/dist/xchains/bitcoin/index.cjs

@@ -0,0 +1,1927 @@
+'use strict';
+
+var types = require('@sodax/types');
+var satsConnect = require('sats-connect');
+var react = require('react');
+var zustand = require('zustand');
+var middleware = require('zustand/middleware');
+var immer = require('zustand/middleware/immer');
+var walletSdkCore = require('@sodax/wallet-sdk-core');
+var walletBase = require('@injectivelabs/wallet-base');
+var sdkTs = require('@injectivelabs/sdk-ts');
+var viem = require('viem');
+var actions = require('wagmi/actions');
+require('wagmi');
+var chains = require('wagmi/chains');
+var web3_js = require('@solana/web3.js');
+var splToken = require('@solana/spl-token');
+var stellarWalletsKit = require('@creit.tech/stellar-wallets-kit');
+var StellarSdk = require('@stellar/stellar-sdk');
+var IconSdkRaw = require('icon-sdk-js');
+var networks = require('@injectivelabs/networks');
+var tsTypes = require('@injectivelabs/ts-types');
+var walletCore = require('@injectivelabs/wallet-core');
+var walletStrategy = require('@injectivelabs/wallet-strategy');
+var walletCosmos = require('@injectivelabs/wallet-cosmos');
+var nearConnect = require('@hot-labs/near-connect');
+var nearApiJs = require('near-api-js');
+var transactions = require('@stacks/transactions');
+var network = require('@stacks/network');
+var connect = require('@stacks/connect');
+require('@tanstack/react-query');
+require('viem/chains');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var StellarSdk__namespace = /*#__PURE__*/_interopNamespace(StellarSdk);
+var IconSdkRaw__namespace = /*#__PURE__*/_interopNamespace(IconSdkRaw);
+
+// src/core/XService.ts
+var XService = class {
+  /** The blockchain type this service handles */
+  xChainType;
+  /** Available wallet connectors for this chain */
+  xConnectors = [];
+  constructor(xChainType) {
+    this.xChainType = xChainType;
+  }
+  /**
+   * Gets the balance of a specific token for an address
+   * @param address The wallet address to check
+   * @param xToken The token to get the balance for
+   * @returns Promise resolving to the token balance as a bigint
+   */
+  async getBalance(address, xToken) {
+    return 0n;
+  }
+  /**
+   * Gets balances for multiple tokens for an address
+   * @param address The wallet address to check
+   * @param xTokens Array of tokens to get balances for
+   * @returns Promise resolving to object mapping token addresses to balances
+   */
+  async getBalances(address, xTokens) {
+    if (!address) return {};
+    const balancePromises = xTokens.map(async (xToken) => {
+      const balance = await this.getBalance(address, xToken);
+      return { address: xToken.address, balance };
+    });
+    const balances = await Promise.all(balancePromises);
+    return balances.reduce((acc, { address: address2, balance }) => {
+      acc[address2] = balance;
+      return acc;
+    }, {});
+  }
+  /**
+   * Gets all available connectors for this chain
+   */
+  getXConnectors() {
+    return this.xConnectors;
+  }
+  /**
+   * Sets the available connectors for this chain
+   */
+  setXConnectors(xConnectors) {
+    this.xConnectors = xConnectors;
+  }
+  /**
+   * Gets a specific connector by its ID
+   * @param xConnectorId The connector ID to look up
+   * @returns The matching connector or undefined if not found
+   */
+  getXConnectorById(xConnectorId) {
+    return this.getXConnectors().find((xConnector) => xConnector.id === xConnectorId);
+  }
+};
+function getEntryDefaults(entry) {
+  if (!entry || typeof entry === "string") return void 0;
+  return entry.defaults;
+}
+function getRpcUrl(entry) {
+  if (!entry || typeof entry === "string") return void 0;
+  return entry.rpcUrl;
+}
+
+// src/utils/index.ts
+var isNativeToken = (xToken) => {
+  const nativeAddresses = [
+    "cx0000000000000000000000000000000000000000",
+    "0x0000000000000000000000000000000000000000",
+    "inj",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI",
+    "hx0000000000000000000000000000000000000000",
+    "11111111111111111111111111111111",
+    // solana
+    "CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA",
+    // stellar
+    "ST000000000000000000002AMW42H.nativetoken",
+    // stacks
+    "0:0"
+    // bitcoin
+  ];
+  return nativeAddresses.includes(xToken.address);
+};
+var getWagmiChainId = (xChainId) => {
+  const chainId = types.baseChainInfo[xChainId].chainId;
+  if (typeof chainId !== "number") {
+    throw new Error(`[wallet-sdk-react] getWagmiChainId: expected numeric chainId, got ${typeof chainId}`);
+  }
+  return chainId;
+};
+
+// src/constants.ts
+var BITCOIN_DEFAULT_RPC_URL = "https://mempool.space/api";
+var STELLAR_DEFAULT_HORIZON_RPC_URL = "https://horizon.stellar.org";
+var STELLAR_DEFAULT_SOROBAN_RPC_URL = "https://rpc.ankr.com/stellar_soroban";
+var NEAR_DEFAULT_RPC_URL = "https://1rpc.io/near";
+var WALLET_METADATA = {
+  unisat: {
+    installUrl: "https://chromewebstore.google.com/detail/unisat-wallet/ppbibelpcjmhbdihakflkdcoccbgbkpo",
+    icon: "https://avatars.githubusercontent.com/u/125119198?s=200&v=4"
+  },
+  xverse: {
+    installUrl: "https://chromewebstore.google.com/detail/xverse-bitcoin-crypto-wal/idnnbdplmphpflfnlkomgpfbpcgelopg",
+    icon: "https://cdn.brandfetch.io/iddzGN5Rcv/w/400/h/400/theme/dark/icon.jpeg?c=1bxid64Mup7aczewSAYMX&t=1771902357797"
+  },
+  okx: {
+    installUrl: "https://chromewebstore.google.com/detail/okx-wallet/mcohilncbfahbmgdjkbpemcciiolgcge",
+    icon: "https://static.okx.com/cdn/assets/imgs/247/58E63FEA47A2B7D7.png"
+  },
+  hana: {
+    installUrl: "https://chromewebstore.google.com/detail/hana-wallet/jfdlamikmbghhapbgfoogdffldioobgl",
+    icon: "https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/hana.svg"
+  }
+};
+
+// src/xchains/bitcoin/BitcoinXService.ts
+var BitcoinXService = class _BitcoinXService extends XService {
+  static instance;
+  rpcUrl;
+  constructor(rpcUrl = BITCOIN_DEFAULT_RPC_URL) {
+    super("BITCOIN");
+    this.rpcUrl = rpcUrl;
+  }
+  static getInstance(rpcUrl) {
+    if (!_BitcoinXService.instance) {
+      _BitcoinXService.instance = new _BitcoinXService(rpcUrl);
+    } else if (rpcUrl && rpcUrl !== _BitcoinXService.instance.rpcUrl) {
+      _BitcoinXService.instance.rpcUrl = rpcUrl;
+    }
+    return _BitcoinXService.instance;
+  }
+  async getBalance(address, xToken) {
+    if (!address) return 0n;
+    try {
+      if (isNativeToken(xToken)) {
+        const response = await fetch(`${this.rpcUrl}/address/${address}/utxo`);
+        if (!response.ok) return 0n;
+        const utxos = await response.json();
+        const totalBalance = utxos.reduce((sum, utxo) => sum + utxo.value, 0);
+        return BigInt(totalBalance);
+      }
+    } catch {
+      return 0n;
+    }
+    return 0n;
+  }
+};
+
+// src/core/XConnector.ts
+var XConnector = class {
+  /** The blockchain type this connector supports */
+  xChainType;
+  /** Display name of the wallet provider */
+  name;
+  /** Unique identifier for the connector */
+  _id;
+  /** Optional icon URL for the wallet provider */
+  _icon;
+  constructor(xChainType, name, id) {
+    this.xChainType = xChainType;
+    this.name = name;
+    this._id = id;
+  }
+  /** Get the unique identifier for this connector */
+  get id() {
+    return this._id;
+  }
+  /** Get the optional icon URL for this wallet provider */
+  get icon() {
+    return this._icon;
+  }
+  /**
+   * True when the wallet extension backing this connector is installed.
+   * Default: true (for provider-managed chains where connector presence already
+   * implies install — EVM via EIP-6963, Solana/Sui via adapter discovery).
+   * Subclasses backed by extension injection (Bitcoin, ICON, Stacks) override
+   * this with a window probe.
+   */
+  get isInstalled() {
+    return true;
+  }
+  /** URL to install the wallet extension when missing. Subclasses override. */
+  get installUrl() {
+    return void 0;
+  }
+};
+
+// src/xchains/bitcoin/BitcoinXConnector.ts
+var BitcoinXConnector = class extends XConnector {
+  defaults;
+  constructor(name, id, defaults) {
+    super("BITCOIN", name, id);
+    this.defaults = defaults;
+  }
+  getXService() {
+    return BitcoinXService.getInstance();
+  }
+};
+var UnisatWalletProvider = class {
+  chainType = "BITCOIN";
+  cachedAddress;
+  defaults;
+  constructor(address, defaults) {
+    this.cachedAddress = address;
+    this.defaults = defaults;
+  }
+  // Lazy resolve so the provider can be constructed before the extension finishes injecting `window.unisat` (post-refresh rehydrate path).
+  get unisat() {
+    const u = window.unisat;
+    if (!u) throw new Error("Unisat wallet not available");
+    return u;
+  }
+  async getWalletAddress() {
+    try {
+      const accounts = await this.unisat.getAccounts();
+      if (accounts[0]) this.cachedAddress = accounts[0];
+    } catch {
+    }
+    return this.cachedAddress;
+  }
+  async getPublicKey() {
+    return this.unisat.getPublicKey();
+  }
+  async getAddressType(_address) {
+    const address = await this.getWalletAddress();
+    return types.detectBitcoinAddressType(address);
+  }
+  async signTransaction(psbtBase64, finalize) {
+    const effectiveFinalize = finalize ?? this.defaults?.defaultFinalize ?? false;
+    const psbtHex = Buffer.from(psbtBase64, "base64").toString("hex");
+    const signedHex = await this.unisat.signPsbt(psbtHex, { autoFinalized: effectiveFinalize });
+    return signedHex;
+  }
+  async signEcdsaMessage(message) {
+    return this.unisat.signMessage(message, "ecdsa");
+  }
+  async signBip322Message(message) {
+    return this.unisat.signMessage(message, "bip322-simple");
+  }
+  async sendBitcoin(toAddress, satoshis) {
+    if (satoshis > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error(`Amount ${satoshis} satoshis exceeds safe integer range`);
+    }
+    return this.unisat.sendBitcoin(toAddress, Number(satoshis));
+  }
+};
+var UnisatXConnector = class _UnisatXConnector extends BitcoinXConnector {
+  walletProvider;
+  constructor(defaults) {
+    super("Unisat", "unisat", defaults);
+  }
+  static isAvailable() {
+    return typeof window !== "undefined" && !!window.unisat;
+  }
+  get isInstalled() {
+    return _UnisatXConnector.isAvailable();
+  }
+  get installUrl() {
+    return WALLET_METADATA.unisat.installUrl;
+  }
+  get icon() {
+    return WALLET_METADATA.unisat.icon;
+  }
+  async connect() {
+    if (!window.unisat) {
+      throw new Error("Unisat wallet is not installed");
+    }
+    const accounts = await window.unisat.requestAccounts();
+    const address = accounts[0];
+    if (!address) {
+      console.warn("[UnisatXConnector] connect: requestAccounts returned no address");
+      return void 0;
+    }
+    this.walletProvider = new UnisatWalletProvider(address, this.defaults);
+    return {
+      address,
+      xChainType: "BITCOIN"
+    };
+  }
+  async disconnect() {
+    this.walletProvider = void 0;
+  }
+  getWalletProvider() {
+    return this.walletProvider;
+  }
+  recreateWalletProvider(xAccount) {
+    if (!xAccount.address) return void 0;
+    return new UnisatWalletProvider(xAccount.address, this.defaults);
+  }
+};
+var XverseWalletProvider = class {
+  chainType = "BITCOIN";
+  address;
+  publicKey;
+  defaults;
+  constructor(address, publicKey, defaults) {
+    this.address = address;
+    this.publicKey = publicKey;
+    this.defaults = defaults;
+  }
+  async getWalletAddress() {
+    return this.address;
+  }
+  async getPublicKey() {
+    return this.publicKey;
+  }
+  async getAddressType(_address) {
+    return types.detectBitcoinAddressType(this.address);
+  }
+  /**
+   * Parse a base64-encoded PSBT to count the number of inputs.
+   * Reads the unsigned transaction from the PSBT global section.
+   */
+  countPsbtInputs(psbtBase64) {
+    const data = Buffer.from(psbtBase64, "base64");
+    let offset = 5;
+    const keyLen = data[offset++] ?? 0;
+    if (keyLen !== 1 || data[offset++] !== 0) {
+      return 1;
+    }
+    const firstByte = data[offset++] ?? 0;
+    if (firstByte === 253) offset += 2;
+    else if (firstByte === 254) offset += 4;
+    else if (firstByte === 255) offset += 8;
+    offset += 4;
+    const inputByte = data[offset] ?? 0;
+    if (inputByte < 253) return inputByte;
+    return 1;
+  }
+  async signTransaction(psbtBase64, finalize) {
+    const effectiveFinalize = finalize ?? this.defaults?.defaultFinalize ?? false;
+    const { request: request3 } = await import('sats-connect');
+    const inputCount = this.countPsbtInputs(psbtBase64);
+    const signingIndexes = Array.from({ length: inputCount }, (_, i) => i);
+    const response = await request3("signPsbt", {
+      psbt: psbtBase64,
+      broadcast: false,
+      signInputs: {
+        [this.address]: signingIndexes
+      }
+    });
+    if (response.status === "error") {
+      throw new Error(response.error?.message || "Xverse PSBT signing failed");
+    }
+    const result = response.result;
+    if (effectiveFinalize) {
+      return Buffer.from(result.psbt, "base64").toString("hex");
+    }
+    return result.psbt;
+  }
+  async signEcdsaMessage(message) {
+    const { request: request3 } = await import('sats-connect');
+    const response = await request3("signMessage", {
+      address: this.address,
+      message,
+      protocol: satsConnect.MessageSigningProtocols.ECDSA
+    });
+    if (response.status === "error") {
+      throw new Error(response.error?.message || "Xverse ECDSA signing failed");
+    }
+    return response.result.signature;
+  }
+  async signBip322Message(message) {
+    const { request: request3 } = await import('sats-connect');
+    const response = await request3("signMessage", {
+      address: this.address,
+      message,
+      protocol: satsConnect.MessageSigningProtocols.BIP322
+    });
+    if (response.status === "error") {
+      throw new Error(response.error?.message || "Xverse BIP322 signing failed");
+    }
+    return response.result.signature;
+  }
+  async sendBitcoin(toAddress, satoshis) {
+    const { request: request3 } = await import('sats-connect');
+    const response = await request3("sendTransfer", {
+      recipients: [
+        {
+          address: toAddress,
+          amount: Number(satoshis)
+        }
+      ]
+    });
+    if (response.status === "error") {
+      throw new Error(response.error?.message || "Xverse sendTransfer failed");
+    }
+    return response.result.txid;
+  }
+};
+var XVERSE_ADDRESS_TYPE_KEY = "xverse-address-type";
+var XverseXConnector = class _XverseXConnector extends BitcoinXConnector {
+  walletProvider;
+  /** Address purpose used when connecting. Taproot (Ordinals) by default to match Radfi. */
+  addressPurpose;
+  constructor(defaults) {
+    super("Xverse", "xverse", defaults);
+    const saved = typeof window !== "undefined" ? localStorage.getItem(XVERSE_ADDRESS_TYPE_KEY) : null;
+    this.addressPurpose = saved === "segwit" ? satsConnect.AddressPurpose.Payment : satsConnect.AddressPurpose.Ordinals;
+  }
+  /** Set address purpose and persist to localStorage. */
+  setAddressPurpose(type) {
+    this.addressPurpose = type === "taproot" ? satsConnect.AddressPurpose.Ordinals : satsConnect.AddressPurpose.Payment;
+    if (typeof window !== "undefined") {
+      localStorage.setItem(XVERSE_ADDRESS_TYPE_KEY, type);
+    }
+  }
+  static isAvailable() {
+    return typeof window !== "undefined" && !!window.BitcoinProvider;
+  }
+  get isInstalled() {
+    return _XverseXConnector.isAvailable();
+  }
+  get installUrl() {
+    return WALLET_METADATA.xverse.installUrl;
+  }
+  get icon() {
+    return WALLET_METADATA.xverse.icon;
+  }
+  async connect() {
+    if (!_XverseXConnector.isAvailable()) {
+      throw new Error("Xverse wallet is not installed");
+    }
+    const { request: request3 } = await import('sats-connect');
+    const response = await request3("getAccounts", {
+      purposes: [this.addressPurpose],
+      message: "Connect to Sodax"
+    });
+    if (response.status === "error") {
+      throw new Error(response.error?.message || "Xverse connection failed");
+    }
+    const accounts = response.result;
+    const paymentAccount = accounts.find((a) => a.purpose === this.addressPurpose) || accounts[0];
+    if (!paymentAccount) return void 0;
+    this.walletProvider = new XverseWalletProvider(
+      paymentAccount.address,
+      paymentAccount.publicKey,
+      this.defaults
+    );
+    return {
+      address: paymentAccount.address,
+      publicKey: paymentAccount.publicKey,
+      xChainType: "BITCOIN"
+    };
+  }
+  async disconnect() {
+    this.walletProvider = void 0;
+  }
+  getWalletProvider() {
+    return this.walletProvider;
+  }
+  recreateWalletProvider(xAccount) {
+    if (!xAccount.address || !xAccount.publicKey) return void 0;
+    return new XverseWalletProvider(xAccount.address, xAccount.publicKey, this.defaults);
+  }
+};
+var OKXWalletProvider = class {
+  chainType = "BITCOIN";
+  cachedAddress;
+  defaults;
+  constructor(address, defaults) {
+    this.cachedAddress = address;
+    this.defaults = defaults;
+  }
+  // Lazy resolve so the provider can be constructed before the extension finishes injecting `window.okxwallet` (post-refresh rehydrate path).
+  get okx() {
+    const o = window.okxwallet?.bitcoin;
+    if (!o) throw new Error("OKX wallet not available");
+    return o;
+  }
+  async getWalletAddress() {
+    try {
+      const accounts = await this.okx.getAccounts();
+      if (accounts[0]) this.cachedAddress = accounts[0];
+    } catch {
+    }
+    return this.cachedAddress;
+  }
+  async getPublicKey() {
+    return this.okx.getPublicKey();
+  }
+  async getAddressType(_address) {
+    const address = await this.getWalletAddress();
+    return types.detectBitcoinAddressType(address);
+  }
+  async signTransaction(psbtBase64, finalize) {
+    const effectiveFinalize = finalize ?? this.defaults?.defaultFinalize ?? false;
+    const psbtHex = Buffer.from(psbtBase64, "base64").toString("hex");
+    return this.okx.signPsbt(psbtHex, { autoFinalized: effectiveFinalize });
+  }
+  async signEcdsaMessage(message) {
+    return this.okx.signMessage(message, "ecdsa");
+  }
+  async signBip322Message(message) {
+    return this.okx.signMessage(message, "bip322-simple");
+  }
+  async sendBitcoin(toAddress, satoshis) {
+    if (satoshis > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error(`Amount ${satoshis} satoshis exceeds safe integer range`);
+    }
+    return this.okx.sendBitcoin(toAddress, Number(satoshis));
+  }
+};
+var OKXXConnector = class _OKXXConnector extends BitcoinXConnector {
+  walletProvider;
+  constructor(defaults) {
+    super("OKX Wallet", "okx-bitcoin", defaults);
+  }
+  static isAvailable() {
+    return typeof window !== "undefined" && !!window.okxwallet?.bitcoin;
+  }
+  get isInstalled() {
+    return _OKXXConnector.isAvailable();
+  }
+  get installUrl() {
+    return WALLET_METADATA.okx.installUrl;
+  }
+  get icon() {
+    return WALLET_METADATA.okx.icon;
+  }
+  async connect() {
+    const okx = window.okxwallet?.bitcoin;
+    if (!okx) {
+      throw new Error("OKX wallet is not installed");
+    }
+    const { address } = await okx.connect();
+    if (!address) {
+      console.warn("[OKXXConnector] connect: okx.connect() returned no address");
+      return void 0;
+    }
+    this.walletProvider = new OKXWalletProvider(address, this.defaults);
+    return {
+      address,
+      xChainType: "BITCOIN"
+    };
+  }
+  async disconnect() {
+    this.walletProvider = void 0;
+  }
+  getWalletProvider() {
+    return this.walletProvider;
+  }
+  recreateWalletProvider(xAccount) {
+    if (!xAccount.address) return void 0;
+    return new OKXWalletProvider(xAccount.address, this.defaults);
+  }
+};
+
+// src/shared/guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function hasStringProperty(value, key) {
+  return isRecord(value) && typeof value[key] === "string";
+}
+function hasBooleanProperty(value, key) {
+  return isRecord(value) && typeof value[key] === "boolean";
+}
+function hasFunctionProperty(value, key) {
+  return isRecord(value) && typeof value[key] === "function";
+}
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+function assertSuiProviderShape(caller, client, wallet, account) {
+  const clientOk = isRecord(client) && hasFunctionProperty(client, "executeTransactionBlock") && hasFunctionProperty(client, "devInspectTransactionBlock") && hasFunctionProperty(client, "getCoins");
+  assert(clientOk, `[${caller}] invalid Sui client shape`);
+  const walletOk = isRecord(wallet) && hasStringProperty(wallet, "name");
+  assert(walletOk, `[${caller}] invalid Sui wallet shape`);
+  const accountOk = isRecord(account) && hasStringProperty(account, "address");
+  assert(accountOk, `[${caller}] invalid Sui account shape`);
+}
+var EvmXService = class _EvmXService extends XService {
+  static instance;
+  wagmiConfig;
+  constructor() {
+    super("EVM");
+  }
+  static getInstance() {
+    if (!_EvmXService.instance) {
+      _EvmXService.instance = new _EvmXService();
+    }
+    return _EvmXService.instance;
+  }
+  // get erc20 token balance in a chain (evm chain only)
+  async _getTokenBalance(address, chainId, tokenAddress) {
+    const publicClient = actions.getPublicClient(this.wagmiConfig, { chainId });
+    if (!publicClient) throw new Error("Public client not found");
+    const balance = await publicClient.readContract({
+      abi: viem.erc20Abi,
+      address: tokenAddress,
+      functionName: "balanceOf",
+      args: [address]
+    });
+    return balance || 0n;
+  }
+  //get native balance of the chain (evm chain only)
+  async _getChainBalance(address, chainId) {
+    const balance = await actions.getPublicClient(this.wagmiConfig, { chainId })?.getBalance({
+      address
+    });
+    return balance || 0n;
+  }
+  async getBalance(address, xToken) {
+    if (!address) return 0n;
+    if (!this.wagmiConfig) return 0n;
+    const chainId = getWagmiChainId(xToken.chainKey);
+    if (isNativeToken(xToken)) {
+      return this._getChainBalance(address, chainId);
+    }
+    throw new Error(`Unsupported token: ${xToken.symbol}`);
+  }
+  async getBalances(address, xTokens) {
+    if (!address) return {};
+    if (!this.wagmiConfig) return {};
+    const nativeTokenBalancePromises = xTokens.filter((xToken) => isNativeToken(xToken)).map(async (xToken) => {
+      const balance = await this.getBalance(address, xToken);
+      return { symbol: xToken.symbol, address: xToken.address, balance };
+    });
+    const nativeTokenBalances = await Promise.all(nativeTokenBalancePromises);
+    const tokenMap = nativeTokenBalances.reduce(
+      (map, { address: address2, balance }) => {
+        if (balance) map[address2] = balance;
+        return map;
+      },
+      {}
+    );
+    const nonNativeXTokens = xTokens.filter((xToken) => !isNativeToken(xToken));
+    const firstToken = xTokens[0];
+    if (!firstToken) return tokenMap;
+    const chainKey = firstToken.chainKey;
+    const viemChain = this.wagmiConfig.chains.find((chain) => chain.id === getWagmiChainId(chainKey));
+    const chainId = getWagmiChainId(chainKey);
+    const publicClient = actions.getPublicClient(this.wagmiConfig, { chainId });
+    if (!publicClient) throw new Error("Public client not found");
+    if (viemChain?.contracts?.multicall3) {
+      const result = await publicClient.multicall({
+        contracts: nonNativeXTokens.map((token) => ({
+          abi: viem.erc20Abi,
+          address: token.address,
+          functionName: "balanceOf",
+          args: [address]
+        }))
+      });
+      return nonNativeXTokens.reduce((acc, token, index) => {
+        const resultValue = result?.[index]?.result;
+        acc[token.address] = resultValue !== void 0 && resultValue !== null ? BigInt(resultValue) : 0n;
+        return acc;
+      }, tokenMap);
+    }
+    const nonNativeTokenBalances = await Promise.all(
+      nonNativeXTokens.map((token) => this._getTokenBalance(address, chainId, token.address))
+    );
+    return nonNativeXTokens.reduce((acc, token, idx) => {
+      acc[token.address] = nonNativeTokenBalances[idx] ?? 0n;
+      return acc;
+    }, tokenMap);
+  }
+};
+var SolanaXService = class _SolanaXService extends XService {
+  static instance;
+  connection;
+  wallet;
+  constructor() {
+    super("SOLANA");
+  }
+  static getInstance() {
+    if (!_SolanaXService.instance) {
+      _SolanaXService.instance = new _SolanaXService();
+    }
+    return _SolanaXService.instance;
+  }
+  async getBalance(address, xToken) {
+    if (!address) return BigInt(0);
+    const connection = this.connection;
+    if (!connection) {
+      return BigInt(0);
+    }
+    try {
+      if (isNativeToken(xToken)) {
+        const newBalance = await connection.getBalance(new web3_js.PublicKey(address));
+        return BigInt(newBalance);
+      }
+      const tokenAccountPubkey = splToken.getAssociatedTokenAddressSync(new web3_js.PublicKey(xToken.address), new web3_js.PublicKey(address));
+      const tokenAccount = await splToken.getAccount(connection, tokenAccountPubkey);
+      return BigInt(tokenAccount.amount);
+    } catch {
+      return BigInt(0);
+    }
+  }
+};
+var SuiXService = class _SuiXService extends XService {
+  static instance;
+  // Hydrated by SuiHydrator. Start undefined because wallet may not be connected yet.
+  // suiClient is typed structurally for the methods we call directly.
+  // suiWallet/suiAccount are opaque — stored and passed through to SuiWalletProvider.
+  suiClient;
+  suiWallet;
+  suiAccount;
+  constructor() {
+    super("SUI");
+  }
+  static getInstance() {
+    if (!_SuiXService.instance) {
+      _SuiXService.instance = new _SuiXService();
+    }
+    return _SuiXService.instance;
+  }
+  createWalletProvider() {
+    if (!this.suiClient || !this.suiWallet || !this.suiAccount) {
+      console.warn(
+        "[SuiXService] createWalletProvider: missing dependencies \u2014 wallet not connected yet",
+        { hasClient: !!this.suiClient, hasWallet: !!this.suiWallet, hasAccount: !!this.suiAccount }
+      );
+      return void 0;
+    }
+    assertSuiProviderShape("SuiXService", this.suiClient, this.suiWallet, this.suiAccount);
+    return new walletSdkCore.SuiWalletProvider({
+      client: this.suiClient,
+      wallet: this.suiWallet,
+      account: this.suiAccount
+    });
+  }
+  // getBalance is not used because getBalances uses getAllBalances which returns all balances
+  async getBalances(address, xTokens) {
+    if (!address || !this.suiClient) return {};
+    const client = this.suiClient;
+    try {
+      const balancePromises = xTokens.map(async (xToken) => {
+        let coinType = isNativeToken(xToken) ? "0x2::sui::SUI" : xToken.address;
+        if (coinType === "0x03917a812fe4a6d6bc779c5ab53f8a80ba741f8af04121193fc44e0f662e2ceb::balanced_dollar::BALANCED_DOLLAR") {
+          coinType = "0x3917a812fe4a6d6bc779c5ab53f8a80ba741f8af04121193fc44e0f662e2ceb::balanced_dollar::BALANCED_DOLLAR";
+        }
+        const balance = await client.getBalance({
+          owner: address,
+          coinType
+        });
+        return {
+          address: xToken.address,
+          balance: balance ? BigInt(balance.totalBalance) : void 0
+        };
+      });
+      const results = await Promise.all(balancePromises);
+      const tokenMap = {};
+      results.forEach((result) => {
+        if (result.balance !== void 0) {
+          tokenMap[result.address] = result.balance;
+        }
+      });
+      return tokenMap;
+    } catch (error) {
+      console.error("[wallet-sdk-react] SUI getBalances failed:", error);
+      return {};
+    }
+  }
+};
+var CustomSorobanServer = class extends StellarSdk.rpc.Server {
+  customHeaders;
+  constructor(serverUrl, customHeaders) {
+    super(serverUrl, {
+      allowHttp: true
+    });
+    this.customHeaders = customHeaders;
+  }
+  async simulateTransaction(tx) {
+    const requestOptions = {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.customHeaders
+      },
+      body: JSON.stringify({
+        id: 1,
+        jsonrpc: "2.0",
+        method: "simulateTransaction",
+        params: {
+          transaction: tx.toXDR()
+        }
+      })
+    };
+    const response = await fetch(`${this.serverURL}`, requestOptions);
+    if (!response.ok) {
+      throw new Error(`HTTP error simulating TX! status: ${response.status}`);
+    }
+    return response.json().then((json) => StellarSdk.rpc.parseRawSimulation(json.result));
+  }
+  async sendTransaction(tx) {
+    const requestOptions = {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.customHeaders
+      },
+      body: JSON.stringify({
+        id: 1,
+        jsonrpc: "2.0",
+        method: "sendTransaction",
+        params: {
+          transaction: tx.toXDR()
+        }
+      })
+    };
+    const response = await fetch(`${this.serverURL}`, requestOptions);
+    if (!response.ok) {
+      throw new Error(`HTTP error submitting TX! status: ${response.status}`);
+    }
+    return response.json().then((json) => json.result);
+  }
+  async getTransaction(hash) {
+    const requestOptions = {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.customHeaders
+      },
+      body: JSON.stringify({
+        id: 1,
+        jsonrpc: "2.0",
+        method: "getTransaction",
+        params: { hash }
+      })
+    };
+    const response = await fetch(`${this.serverURL}`, requestOptions);
+    if (!response.ok) {
+      throw new Error(`HTTP error getting TX! status: ${response.status}`);
+    }
+    return response.json().then((json) => json.result);
+  }
+};
+var CustomSorobanServer_default = CustomSorobanServer;
+var accountToScVal = (account) => new StellarSdk.Address(account).toScVal();
+var simulateTx = (tx, server) => server.simulateTransaction(tx);
+var getTokenBalance = async (address, tokenId, txBuilder, server) => {
+  const params = [accountToScVal(address)];
+  const contract = new StellarSdk.Contract(tokenId);
+  const tx = txBuilder.addOperation(contract.call("balance", ...params)).setTimeout(StellarSdk.TimeoutInfinite).build();
+  const result = await simulateTx(tx, server);
+  if (!StellarSdk.rpc.Api.isSimulationSuccess(result)) {
+    throw new Error(`Simulation failed: ${JSON.stringify(result)}`);
+  }
+  return result.result ? StellarSdk.scValToBigInt(result.result.retval) : 0n;
+};
+
+// src/xchains/stellar/StellarXService.ts
+var STELLAR_BASE_RESERVE_STROOPS = 5e6;
+function parseXlmBalanceToStroops(balanceStr) {
+  const parts = balanceStr.split(".");
+  const whole = parts[0] ?? "0";
+  const frac = (parts[1] ?? "").padEnd(7, "0").slice(0, 7);
+  return BigInt(whole + frac);
+}
+var StellarXService = class _StellarXService extends XService {
+  static instance;
+  walletsKit;
+  server;
+  sorobanServer;
+  constructor(horizonRpcUrl, sorobanRpcUrl) {
+    super("STELLAR");
+    this.walletsKit = new stellarWalletsKit.StellarWalletsKit({
+      network: stellarWalletsKit.WalletNetwork.PUBLIC,
+      modules: stellarWalletsKit.allowAllModules()
+    });
+    this.server = new StellarSdk__namespace.Horizon.Server(horizonRpcUrl ?? STELLAR_DEFAULT_HORIZON_RPC_URL, { allowHttp: true });
+    this.sorobanServer = new CustomSorobanServer_default(sorobanRpcUrl ?? STELLAR_DEFAULT_SOROBAN_RPC_URL, {});
+  }
+  static getInstance(horizonRpcUrl, sorobanRpcUrl) {
+    if (!_StellarXService.instance) {
+      _StellarXService.instance = new _StellarXService(horizonRpcUrl, sorobanRpcUrl);
+    } else {
+      if (horizonRpcUrl) {
+        _StellarXService.instance.server = new StellarSdk__namespace.Horizon.Server(horizonRpcUrl, { allowHttp: true });
+      }
+      if (sorobanRpcUrl) {
+        _StellarXService.instance.sorobanServer = new CustomSorobanServer_default(sorobanRpcUrl, {});
+      }
+    }
+    return _StellarXService.instance;
+  }
+  async getBalance(address, xToken) {
+    if (!address) return BigInt(0);
+    const stellarAccount = await this.server.loadAccount(address);
+    if (xToken.symbol === "XLM") {
+      const xlmBalance = stellarAccount.balances.find((balance) => balance.asset_type === "native");
+      if (xlmBalance) {
+        const rawBalanceStroops = parseXlmBalanceToStroops(xlmBalance.balance);
+        const sellingLiabilitiesStroops = xlmBalance.selling_liabilities ? parseXlmBalanceToStroops(xlmBalance.selling_liabilities) : BigInt(0);
+        const reserveFields = stellarAccount;
+        const subentryCount = reserveFields.subentry_count ?? 0;
+        const numSponsoring = reserveFields.num_sponsoring ?? 0;
+        const numSponsored = reserveFields.num_sponsored ?? 0;
+        const reserveCount = Math.max(0, 2 + subentryCount + numSponsoring - numSponsored);
+        const minBalanceStroops = BigInt(reserveCount) * BigInt(STELLAR_BASE_RESERVE_STROOPS) + sellingLiabilitiesStroops;
+        const availableStroops = rawBalanceStroops > minBalanceStroops ? rawBalanceStroops - minBalanceStroops : BigInt(0);
+        return availableStroops;
+      }
+    } else {
+      try {
+        const txBuilder = new StellarSdk__namespace.TransactionBuilder(stellarAccount, {
+          fee: StellarSdk__namespace.BASE_FEE,
+          networkPassphrase: StellarSdk__namespace.Networks.PUBLIC
+        });
+        const balance = await getTokenBalance(address, xToken.address, txBuilder, this.sorobanServer);
+        return balance;
+      } catch (e) {
+        console.error(`Error while fetching token on Stellar: ${xToken.symbol}, Error: ${e}`);
+      }
+    }
+    return BigInt(0);
+  }
+};
+
+// src/xchains/stellar/StellarWalletsKitXConnector.ts
+var StellarWalletsKitXConnector = class extends XConnector {
+  _wallet;
+  constructor(wallet) {
+    super("STELLAR", wallet.name, wallet.id);
+    this._wallet = wallet;
+  }
+  getXService() {
+    return StellarXService.getInstance();
+  }
+  async connect() {
+    const kit = this.getXService().walletsKit;
+    if (!this._wallet) {
+      return;
+    }
+    if (!this._wallet.isAvailable) {
+      throw new Error(`${this._wallet.name} is not installed. Install the wallet and reload the page.`);
+    }
+    kit.setWallet(this._wallet.id);
+    const { address } = await kit.getAddress();
+    return {
+      address,
+      xChainType: this.xChainType
+    };
+  }
+  async disconnect() {
+  }
+  get icon() {
+    return this._wallet.icon;
+  }
+  get isInstalled() {
+    return this._wallet.isAvailable;
+  }
+  get installUrl() {
+    return this._wallet.url;
+  }
+};
+var IconSdk = "default" in IconSdkRaw__namespace.default ? IconSdkRaw__namespace.default : IconSdkRaw__namespace;
+var { IconService: IconServiceConstructor, Builder: IconBuilder, Converter: IconConverter } = IconSdk;
+var CHAIN_INFO = {
+  [1 /* MAINNET */]: {
+    APIEndpoint: "https://ctz.solidwallet.io/api/v3"}
+};
+var IconXService = class _IconXService extends XService {
+  static instance;
+  iconService;
+  constructor(rpcUrl) {
+    super("ICON");
+    const mainnetInfo = CHAIN_INFO[1 /* MAINNET */];
+    if (!mainnetInfo) throw new Error("ICON mainnet chain info not found");
+    this.iconService = new IconServiceConstructor(
+      new IconServiceConstructor.HttpProvider(rpcUrl ?? mainnetInfo.APIEndpoint)
+    );
+  }
+  static getInstance(rpcUrl) {
+    if (!_IconXService.instance) {
+      _IconXService.instance = new _IconXService(rpcUrl);
+    }
+    return _IconXService.instance;
+  }
+  async getAggregateData(requireSuccess, calls) {
+    const rawTx = new IconBuilder.CallBuilder().to("cxa4aa9185e23558cff990f494c1fd2845f6cbf741").method("tryAggregate").params({ requireSuccess: IconConverter.toHex(requireSuccess ? 1 : 0), calls }).build();
+    try {
+      const result = await this.iconService.call(rawTx).execute();
+      const aggs = result["returnData"];
+      const data = aggs.map((agg) => {
+        if (agg["success"] === "0x0") {
+          return null;
+        }
+        return agg["returnData"];
+      });
+      return data;
+    } catch (err) {
+      console.error(err);
+      return Array(calls.length).fill(null);
+    }
+  }
+  async getBalances(address, xTokens) {
+    if (!address) return {};
+    const balances = {};
+    const nativeXToken = xTokens.find((xToken) => isNativeToken(xToken));
+    const nonNativeXTokens = xTokens.filter((xToken) => !isNativeToken(xToken));
+    if (nativeXToken) {
+      const balance = await this.iconService.getBalance(address).execute();
+      balances[nativeXToken.address] = BigInt(balance.toFixed());
+    }
+    const cds = nonNativeXTokens.map((token) => {
+      return {
+        target: token.address,
+        method: "balanceOf",
+        params: [address]
+      };
+    });
+    const data = await this.getAggregateData(
+      false,
+      cds.filter((cd) => cd.target.startsWith("cx"))
+    );
+    return nonNativeXTokens.reduce((agg, token, idx) => {
+      const balance = data[idx];
+      if (balance) {
+        balances[token.address] = BigInt(balance);
+      }
+      return agg;
+    }, balances);
+  }
+};
+
+// src/xchains/icon/iconex/index.tsx
+var ICONEX_RELAY_RESPONSE = "ICONEX_RELAY_RESPONSE";
+var ICONEX_RELAY_REQUEST = "ICONEX_RELAY_REQUEST";
+var request = (event) => {
+  return new Promise((resolve, reject) => {
+    const handler = (evt) => {
+      window.removeEventListener(ICONEX_RELAY_RESPONSE, handler);
+      resolve(evt.detail);
+    };
+    window.addEventListener(ICONEX_RELAY_RESPONSE, handler);
+    window.dispatchEvent(
+      new CustomEvent(ICONEX_RELAY_REQUEST, {
+        detail: event
+      })
+    );
+  });
+};
+
+// src/xchains/icon/IconHanaXConnector.ts
+var isHanaWallet = (value) => {
+  return isRecord(value) && (value.available === void 0 || hasBooleanProperty(value, "available"));
+};
+var IconHanaXConnector = class extends XConnector {
+  constructor() {
+    super("ICON", "Hana Wallet", "hana");
+  }
+  get isInstalled() {
+    if (typeof window === "undefined") return false;
+    const hanaWallet = window.hanaWallet;
+    return isHanaWallet(hanaWallet) && hanaWallet.available === true;
+  }
+  get installUrl() {
+    return WALLET_METADATA.hana.installUrl;
+  }
+  async connect() {
+    const hanaWallet = window.hanaWallet;
+    assert(isHanaWallet(hanaWallet) || hanaWallet === void 0, "[IconHanaXConnector] invalid window.hanaWallet type");
+    if (!hanaWallet || !hanaWallet.available) {
+      window.open(WALLET_METADATA.hana.installUrl, "_blank", "noopener,noreferrer");
+      return;
+    }
+    const detail = await request({
+      type: "REQUEST_ADDRESS" /* REQUEST_ADDRESS */
+    });
+    if (detail?.type === "RESPONSE_ADDRESS" /* RESPONSE_ADDRESS */) {
+      return {
+        address: detail?.payload,
+        xChainType: this.xChainType
+      };
+    }
+    console.warn("[IconHanaXConnector] connect: unexpected response from Hana wallet", detail);
+    return void 0;
+  }
+  async disconnect() {
+    console.log("HanaIconXConnector disconnected");
+  }
+  get icon() {
+    return WALLET_METADATA.hana.icon;
+  }
+};
+var InjectiveXService = class _InjectiveXService extends XService {
+  static instance;
+  walletStrategy;
+  indexerGrpcAccountPortfolioApi;
+  chainGrpcWasmApi;
+  msgBroadcaster;
+  constructor(rpcConfig) {
+    super("INJECTIVE");
+    const defaults = networks.getNetworkEndpoints(networks.Network.Mainnet);
+    const endpoints = {
+      ...defaults,
+      indexer: rpcConfig?.indexer || defaults.indexer,
+      grpc: rpcConfig?.grpc || defaults.grpc
+    };
+    this.walletStrategy = new walletStrategy.WalletStrategy({
+      chainId: tsTypes.ChainId.Mainnet,
+      strategies: {},
+      evmOptions: {
+        evmChainId: chains.mainnet.id,
+        rpcUrl: chains.mainnet.rpcUrls.default.http[0]
+      }
+    });
+    this.indexerGrpcAccountPortfolioApi = new sdkTs.IndexerGrpcAccountPortfolioApi(endpoints.indexer);
+    this.chainGrpcWasmApi = new sdkTs.ChainGrpcWasmApi(endpoints.grpc);
+    this.msgBroadcaster = new walletCore.MsgBroadcaster({
+      walletStrategy: this.walletStrategy,
+      network: networks.Network.Mainnet,
+      endpoints
+    });
+  }
+  /**
+   * @param rpcConfig - Only applied on first call. Subsequent calls return the
+   *   existing instance unchanged — gRPC/Indexer clients are built in the
+   *   constructor and can't be rebuilt at runtime. Pass the desired endpoints
+   *   via `SodaxWalletProvider.config.rpcConfig` once at app init.
+   */
+  static getInstance(rpcConfig) {
+    if (!_InjectiveXService.instance) {
+      _InjectiveXService.instance = new _InjectiveXService(rpcConfig);
+    }
+    return _InjectiveXService.instance;
+  }
+  async getBalance(address, xToken) {
+    if (!address) return 0n;
+    const portfolio = await this.indexerGrpcAccountPortfolioApi.fetchAccountPortfolioBalances(address);
+    const xTokenAddress = xToken.address;
+    const balance = portfolio.bankBalancesList.find((_balance) => _balance.denom === xTokenAddress);
+    if (balance) {
+      return BigInt(balance.amount);
+    }
+    return 0n;
+  }
+};
+var WALLET_ICONS = {
+  metamask: "https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/metamask.svg",
+  keplr: "https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/keplr.svg",
+  leap: "https://assets.leapwallet.io/logos/leap-cosmos-logo.svg",
+  rabby: "https://raw.githubusercontent.com/RabbyHub/logo/master/symbol.svg",
+  phantom: "https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/phantom.svg",
+  "okx-wallet": "https://static.okx.com/cdn/assets/imgs/247/58E63FEA47A2B7D7.png",
+  "trust-wallet": "https://trustwallet.com/assets/images/media/assets/twLogo.svg"
+};
+var InjectiveXConnector = class extends XConnector {
+  wallet;
+  constructor(name, wallet) {
+    super("INJECTIVE", name, wallet);
+    this.wallet = wallet;
+  }
+  getXService() {
+    return InjectiveXService.getInstance();
+  }
+  async connect() {
+    if (walletBase.isCosmosBrowserWallet(this.wallet) && !walletCosmos.isCosmosWalletInstalled(this.wallet)) {
+      console.warn(`[InjectiveXConnector] connect: ${this.wallet} cosmos wallet not installed`);
+      return void 0;
+    }
+    const walletStrategy = this.getXService().walletStrategy;
+    await walletStrategy.setWallet(this.wallet);
+    const addresses = await walletStrategy.getAddresses();
+    if (!addresses?.length) {
+      console.warn(`[InjectiveXConnector] connect: ${this.wallet} returned no addresses`);
+      return void 0;
+    }
+    const firstAddress = addresses[0];
+    if (!firstAddress) {
+      console.warn(`[InjectiveXConnector] connect: ${this.wallet} returned empty addresses array`);
+      return void 0;
+    }
+    const address = walletBase.isEvmBrowserWallet(this.wallet) ? sdkTs.getInjectiveAddress(firstAddress) : firstAddress;
+    return {
+      address,
+      xChainType: this.xChainType
+    };
+  }
+  async disconnect() {
+    if (walletBase.isEvmBrowserWallet(this.wallet)) {
+      const walletStrategy = this.getXService().walletStrategy;
+      await walletStrategy.setWallet(this.wallet);
+      await walletStrategy.disconnect();
+    }
+  }
+  get icon() {
+    return WALLET_ICONS[this.wallet];
+  }
+  get isInstalled() {
+    if (walletBase.isCosmosBrowserWallet(this.wallet)) {
+      return walletCosmos.isCosmosWalletInstalled(this.wallet);
+    }
+    return true;
+  }
+};
+
+// src/xchains/bitcoin/bitcoinSignGuards.ts
+function hasSignBip322(c) {
+  return "signBip322Message" in c && typeof c.signBip322Message === "function";
+}
+function hasSignEcdsa(c) {
+  return "signEcdsaMessage" in c && typeof c.signEcdsaMessage === "function";
+}
+var NearXService = class _NearXService extends XService {
+  static instance;
+  walletSelector;
+  rpcUrl;
+  /**
+   * @param rpcUrl - Used by `getBalance` via `JsonRpcProvider({ url: rpcUrl })`.
+   *   Does NOT affect `walletSelector` — `@hot-labs/near-connect` only accepts
+   *   the network preset name (`'mainnet'`/`'testnet'`) and fetches RPC internally.
+   *   Custom RPC is therefore read-only for balance queries.
+   */
+  constructor(rpcUrl = NEAR_DEFAULT_RPC_URL) {
+    super("NEAR");
+    this.rpcUrl = rpcUrl;
+    this.walletSelector = new nearConnect.NearConnector({
+      network: "mainnet",
+      logger: console,
+      autoConnect: true,
+      excludedWallets: ["okx-wallet"]
+    });
+  }
+  /**
+   * @param rpcUrl - Re-applied on every call (matches StacksXService semantics).
+   *   `rpcUrl` only drives `getBalance` via a per-call `JsonRpcProvider`, so it's
+   *   safe to update at runtime — no persistent chain client to rebuild.
+   */
+  static getInstance(rpcUrl) {
+    if (!_NearXService.instance) {
+      _NearXService.instance = new _NearXService(rpcUrl);
+    } else if (rpcUrl) {
+      _NearXService.instance.rpcUrl = rpcUrl;
+    }
+    return _NearXService.instance;
+  }
+  async getBalance(address, xToken) {
+    const provider = new nearApiJs.JsonRpcProvider({ url: this.rpcUrl });
+    if (xToken.symbol === "NEAR") {
+      const account = await provider.viewAccount({ accountId: address ?? "" });
+      return BigInt(account.amount);
+    }
+    const res = await provider.callFunction({
+      contractId: xToken.address,
+      method: "ft_balance_of",
+      args: { account_id: address }
+    });
+    return BigInt(res ?? 0);
+  }
+};
+
+// src/xchains/near/NearXConnector.ts
+var NearXConnector = class extends XConnector {
+  _wallet;
+  constructor(wallet) {
+    super("NEAR", wallet.manifest.name, wallet.manifest.id);
+    this._wallet = wallet;
+  }
+  getXService() {
+    return NearXService.getInstance();
+  }
+  async connect() {
+    const walletSelector = this.getXService().walletSelector;
+    const wallet = await walletSelector.connect({ walletId: this._wallet.manifest.id });
+    const accounts = await wallet.getAccounts();
+    if (accounts.length === 0 || accounts[0] === void 0) {
+      console.warn(`[NearXConnector] connect: ${this._wallet.manifest.name} returned no accounts`);
+      return void 0;
+    }
+    return {
+      address: accounts[0].accountId,
+      xChainType: this.xChainType
+    };
+  }
+  async disconnect() {
+    const walletSelector = this.getXService().walletSelector;
+    await walletSelector.disconnect(this._wallet);
+  }
+  get icon() {
+    return this._wallet.manifest.icon;
+  }
+};
+var StacksXService = class _StacksXService extends XService {
+  static instance;
+  network;
+  constructor(network$1) {
+    super("STACKS");
+    this.network = network.networkFrom(network$1 || "mainnet");
+  }
+  static getInstance(network$1) {
+    if (!_StacksXService.instance) {
+      _StacksXService.instance = new _StacksXService(network$1);
+    } else if (network$1) {
+      _StacksXService.instance.network = network.networkFrom(network$1);
+    }
+    return _StacksXService.instance;
+  }
+  async getBalance(address, xToken) {
+    if (!address) return 0n;
+    if (xToken.symbol === "STX") {
+      const url = `${this.network.client.baseUrl}/extended/v1/address/${address}/balances`;
+      try {
+        const response = await fetch(url);
+        if (!response.ok) {
+          throw new Error(`Error fetching data: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return BigInt(data.stx.balance);
+      } catch (error) {
+        console.error("Error fetching STX balance:", error);
+        return 0n;
+      }
+    }
+    const parts = xToken.address.split(".");
+    const contractAddress = parts[0] ?? "";
+    const contractName = parts[1] ?? "";
+    try {
+      const result = await transactions.fetchCallReadOnlyFunction({
+        contractAddress,
+        contractName,
+        functionName: "get-balance",
+        functionArgs: [transactions.Cl.principal(address)],
+        network: this.network,
+        senderAddress: address
+      });
+      return result.value.value;
+    } catch (error) {
+      console.error("Error fetching token balance:", error);
+      return 0n;
+    }
+  }
+};
+function getProviderFromId(id) {
+  return id.split(".").reduce((acc, part) => acc?.[part], window);
+}
+var StacksXConnector = class extends XConnector {
+  config;
+  constructor(config) {
+    super("STACKS", config.name, config.id);
+    this.config = config;
+  }
+  async connect() {
+    const provider = this.getProvider();
+    if (!provider) {
+      throw new Error(`${this.config.name} is not installed. Install the extension and reload the page.`);
+    }
+    const response = await connect.request({ provider }, "stx_getAddresses");
+    const stxAddress = response.addresses.find((a) => a.purpose === "stacks");
+    if (!stxAddress) {
+      console.warn(
+        `[StacksXConnector] ${this.config.name}: no address with purpose="stacks" returned from stx_getAddresses`,
+        response.addresses
+      );
+      return void 0;
+    }
+    return {
+      address: stxAddress.address,
+      xChainType: this.xChainType
+    };
+  }
+  async disconnect() {
+    connect.disconnect();
+  }
+  get icon() {
+    return this.config.icon;
+  }
+  get isInstalled() {
+    if (typeof window === "undefined") return false;
+    return getProviderFromId(this.config.id) !== void 0;
+  }
+  get installUrl() {
+    return this.config.installUrl;
+  }
+  getProvider() {
+    return getProviderFromId(this.config.id);
+  }
+};
+
+// src/xchains/stacks/constants.ts
+var LEATHER_ICON = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTI4IiBoZWlnaHQ9IjEyOCIgdmlld0JveD0iMCAwIDEyOCAxMjgiIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxyZWN0IHdpZHRoPSIxMjgiIGhlaWdodD0iMTI4IiByeD0iMjYuODM4NyIgZmlsbD0iIzEyMTAwRiIvPgo8cGF0aCBkPSJNNzQuOTE3MSA1Mi43MTE0QzgyLjQ3NjYgNTEuNTQwOCA5My40MDg3IDQzLjU4MDQgOTMuNDA4NyAzNy4zNzYxQzkzLjQwODcgMzUuNTAzMSA5MS44OTY4IDM0LjIxNTQgODkuNjg3MSAzNC4yMTU0Qzg1LjUwMDQgMzQuMjE1NCA3OC40MDYxIDQwLjUzNjggNzQuOTE3MSA1Mi43MTE0Wk0zOS45MTEgODMuNDk5MUMzMC4wMjU2IDgzLjQ5OTEgMjkuMjExNSA5My4zMzI0IDM5LjA5NjkgOTMuMzMyNEM0My41MTYzIDkzLjMzMjQgNDguODY2MSA5MS41NzY0IDUxLjY1NzMgODguNDE1N0M0Ny41ODY4IDg0LjkwMzggNDQuMjE0MSA4My40OTkxIDM5LjkxMSA4My40OTkxWk0xMDIuODI5IDc5LjI4NDhDMTAzLjQxIDk1Ljc5MDcgOTUuMDM2OSAxMDUuMDM5IDgwLjg0ODQgMTA1LjAzOUM3Mi40NzQ4IDEwNS4wMzkgNjguMjg4MSAxMDEuODc4IDU5LjMzMyA5Ni4wMjQ5QzU0LjY4MSAxMDEuMTc2IDQ1Ljg0MjMgMTA1LjAzOSAzOC41MTU0IDEwNS4wMzlDMTMuMjc4NSAxMDUuMDM5IDE0LjMyNTIgNzIuODQ2MyA0MC4wMjczIDcyLjg0NjNDNDUuMzc3MSA3Mi44NDYzIDQ5LjkxMjggNzQuMjUxMSA1NS43Mjc3IDc3Ljg4TDU5LjU2NTYgNjQuNDE3N0M0My43NDg5IDYwLjA4NjQgMzUuODQwNSA0Ny45MTE4IDQzLjYzMjYgMzAuNDY5M0g1Ni4xOTI5QzQ5LjIxNSA0Mi4wNTg2IDUzLjk4MzIgNTEuNjU3OCA2Mi44MjIgNTIuNzExNEM2Ny41OTAzIDM1LjczNzIgNzcuODI0NiAyMi41MDkgOTEuNDMxNiAyMi41MDlDOTkuMTA3NCAyMi41MDkgMTA1LjE1NSAyNy41NDI4IDEwNS4xNTUgMzYuNjczN0MxMDUuMTU1IDUxLjMwNjYgODYuMDgxOSA2My4yNDcxIDcxLjY2MDcgNjQuNDE3N0w2NS43Mjk1IDg1LjM3MjFDNzIuNDc0OCA5My4yMTUzIDkxLjE5OSAxMDAuODI0IDkxLjE5OSA3OS4yODQ4SDEwMi44MjlaIiBmaWxsPSIjRjVGMUVEIi8+Cjwvc3ZnPgo=";
+var XVERSE_ICON = "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSI2MDAiIGhlaWdodD0iNjAwIj48ZyBmaWxsPSJub25lIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiPjxwYXRoIGZpbGw9IiMxNzE3MTciIGQ9Ik0wIDBoNjAwdjYwMEgweiIvPjxwYXRoIGZpbGw9IiNGRkYiIGZpbGwtcnVsZT0ibm9uemVybyIgZD0iTTQ0MCA0MzUuNHYtNTFjMC0yLS44LTMuOS0yLjItNS4zTDIyMCAxNjIuMmE3LjYgNy42IDAgMCAwLTUuNC0yLjJoLTUxLjFjLTIuNSAwLTQuNiAyLTQuNiA0LjZ2NDcuM2MwIDIgLjggNCAyLjIgNS40bDc4LjIgNzcuOGE0LjYgNC42IDAgMCAxIDAgNi41bC03OSA3OC43Yy0xIC45LTEuNCAyLTEuNCAzLjJ2NTJjMCAyLjQgMiA0LjUgNC42IDQuNUgyNDljMi42IDAgNC42LTIgNC42LTQuNlY0MDVjMC0xLjIuNS0yLjQgMS40LTMuM2w0Mi40LTQyLjJhNC42IDQuNiAwIDAgMSA2LjQgMGw3OC43IDc4LjRhNy42IDcuNiAwIDAgMCA1LjQgMi4yaDQ3LjVjMi41IDAgNC42LTIgNC42LTQuNloiLz48cGF0aCBmaWxsPSIjRUU3QTMwIiBmaWxsLXJ1bGU9Im5vbnplcm8iIGQ9Ik0zMjUuNiAyMjcuMmg0Mi44YzIuNiAwIDQuNiAyLjEgNC42IDQuNnY0Mi42YzAgNCA1IDYuMSA4IDMuMmw1OC43LTU4LjVjLjgtLjggMS4zLTIgMS4zLTMuMnYtNTEuMmMwLTIuNi0yLTQuNi00LjYtNC42TDM4NCAxNjBjLTEuMiAwLTIuNC41LTMuMyAxLjNsLTU4LjQgNTguMWE0LjYgNC42IDAgMCAwIDMuMiA3LjhaIi8+PC9nPjwvc3ZnPg==";
+var ASIGNA_ICON = "data:image/svg+xml;base64,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";
+var FORDEFI_ICON = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDIiIGhlaWdodD0iNDIiIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CiAgPHBhdGggZmlsbD0iIzEwMTExNCIgZD0iTTAgMGg0MnY0MkgweiIvPgogIDxwYXRoIGQ9Ik0xOS40NyAyNi44OUg1djMuNTdhNC41NyA0LjU3IDAgMCAwIDQuNTggNC41N2g1LjgzbDQuMDYtOC4xNFoiIGZpbGw9IiM3OTk0RkYiLz4KICA8cGF0aCBkPSJNNSAxNy40aDI3LjU4bC0zLjIgNi43OEg1VjE3LjRaIiBmaWxsPSIjNDg2REZGIi8+CiAgPHBhdGggZD0iTTE0LjY3IDdINXY3LjY4aDMzVjdoLTkuNjd2NS43NGgtMlY3aC05LjY3djUuNzRoLTEuOTlWN1oiIGZpbGw9IiM1Q0QxRkEiLz4KPC9zdmc+Cg==";
+var STACKS_PROVIDERS = [
+  {
+    id: "LeatherProvider",
+    name: "Leather",
+    icon: LEATHER_ICON,
+    installUrl: "https://chrome.google.com/webstore/detail/hiro-wallet/ldinpeekobnhjjdofggfgjlcehhmanlj"
+  },
+  {
+    id: "XverseProviders.BitcoinProvider",
+    name: "Xverse Wallet",
+    icon: XVERSE_ICON,
+    installUrl: "https://chrome.google.com/webstore/detail/xverse-wallet/idnnbdplmphpflfnlkomgpfbpcgelopg"
+  },
+  {
+    id: "AsignaProvider",
+    name: "Asigna Multisig",
+    icon: ASIGNA_ICON,
+    installUrl: "https://stx.asigna.io/"
+  },
+  {
+    id: "FordefiProviders.UtxoProvider",
+    name: "Fordefi",
+    icon: FORDEFI_ICON,
+    installUrl: "https://chromewebstore.google.com/detail/fordefi/hcmehenccjdmfbojapcbcofkgdpbnlle"
+  }
+];
+
+// src/chainRegistry.ts
+function defineChain2(factory) {
+  return factory;
+}
+function narrowConnectors(items, chainType) {
+  return items.filter((item) => {
+    if (!(item instanceof XConnector)) {
+      console.warn(
+        `[chainRegistry] ${chainType} connector "${item.id}" must extend XConnector \u2014 skipping. Implement the abstract XConnector class instead of raw IXConnector for full SDK support.`
+      );
+      return false;
+    }
+    return true;
+  });
+}
+function readConnectorsOverride(chainType, walletConfig) {
+  return walletConfig?.[chainType]?.connectors;
+}
+function hasChainOfType(chainType, walletConfig) {
+  return walletConfig[chainType] !== void 0;
+}
+var createDefaultActions = (chainType, service, getStore) => ({
+  connect: async (xConnectorId) => {
+    const connector = service.getXConnectorById(xConnectorId);
+    return connector?.connect();
+  },
+  disconnect: async () => {
+    const store = getStore();
+    const connectorId = store.xConnections[chainType]?.xConnectorId;
+    const connector = connectorId ? service.getXConnectorById(connectorId) : void 0;
+    try {
+      await connector?.disconnect();
+    } finally {
+      store.unsetXConnection(chainType);
+    }
+  },
+  getConnectors: () => getStore().xConnectorsByChain[chainType] ?? [],
+  getConnection: () => getStore().xConnections[chainType]
+});
+var chainRegistry = {
+  EVM: defineChain2({
+    createService: () => EvmXService.getInstance(),
+    displayName: "EVM",
+    defaultConnectors: () => [],
+    providerManaged: true
+  }),
+  SUI: defineChain2({
+    createService: () => SuiXService.getInstance(),
+    displayName: "Sui",
+    defaultConnectors: () => [],
+    providerManaged: true
+  }),
+  SOLANA: defineChain2({
+    createService: () => SolanaXService.getInstance(),
+    displayName: "Solana",
+    defaultConnectors: () => [],
+    providerManaged: true
+  }),
+  BITCOIN: defineChain2({
+    createService: (walletConfig) => BitcoinXService.getInstance(getRpcUrl(walletConfig?.BITCOIN?.chains?.[types.ChainKeys.BITCOIN_MAINNET])),
+    displayName: "Bitcoin",
+    defaultConnectors: (walletConfig) => {
+      const defaults = getEntryDefaults(
+        walletConfig?.BITCOIN?.chains?.[types.ChainKeys.BITCOIN_MAINNET]
+      );
+      return [new UnisatXConnector(defaults), new XverseXConnector(defaults), new OKXXConnector(defaults)];
+    },
+    providerManaged: false,
+    createActions: (service, getStore) => ({
+      ...createDefaultActions("BITCOIN", service, getStore),
+      signMessage: async (message) => {
+        const store = getStore();
+        const connection = store.xConnections.BITCOIN;
+        const connector = connection?.xConnectorId ? service.getXConnectorById(connection.xConnectorId) : void 0;
+        if (!(connector instanceof BitcoinXConnector)) {
+          throw new Error("Bitcoin wallet not connected");
+        }
+        const address = connection?.xAccount.address;
+        if (!address) throw new Error("Bitcoin address not found");
+        const addressType = types.detectBitcoinAddressType(address);
+        switch (addressType) {
+          case "P2WPKH":
+          case "P2TR": {
+            if (!hasSignBip322(connector)) {
+              throw new Error(`${connector.id} does not support BIP-322 signing`);
+            }
+            return connector.signBip322Message(message);
+          }
+          case "P2SH":
+          case "P2PKH": {
+            if (!hasSignEcdsa(connector)) {
+              throw new Error(`${connector.id} does not support ECDSA signing`);
+            }
+            return connector.signEcdsaMessage(message);
+          }
+          default: {
+            const _exhaustiveCheck = addressType;
+            throw new Error(`Unhandled Bitcoin address type: ${_exhaustiveCheck}`);
+          }
+        }
+      }
+    }),
+    createWalletProvider: (service, getStore) => {
+      const store = getStore();
+      const connection = store.xConnections.BITCOIN;
+      if (!connection?.xConnectorId) return void 0;
+      const connector = service.getXConnectorById(connection.xConnectorId);
+      if (!(connector instanceof BitcoinXConnector)) return void 0;
+      return connector.recreateWalletProvider(connection.xAccount);
+    }
+  }),
+  INJECTIVE: defineChain2({
+    createService: (walletConfig) => InjectiveXService.getInstance(walletConfig?.INJECTIVE?.chains?.[types.ChainKeys.INJECTIVE_MAINNET]),
+    displayName: "Injective",
+    defaultConnectors: () => [
+      new InjectiveXConnector("MetaMask", walletBase.Wallet.Metamask),
+      new InjectiveXConnector("Keplr", walletBase.Wallet.Keplr),
+      new InjectiveXConnector("Leap", walletBase.Wallet.Leap)
+    ],
+    providerManaged: false,
+    createActions: (service, getStore) => ({
+      ...createDefaultActions("INJECTIVE", service, getStore),
+      signMessage: async (message) => {
+        const store = getStore();
+        const address = store.xConnections.INJECTIVE?.xAccount.address;
+        if (!address) throw new Error("Injective address not found");
+        const ethereumAddress = sdkTs.getEthereumAddress(address);
+        const walletStrategy = service.walletStrategy;
+        const res = await walletStrategy.signArbitrary(
+          walletStrategy.getWallet() === walletBase.Wallet.Metamask ? ethereumAddress : address,
+          message
+        );
+        if (!res) throw new Error("Injective signature not found");
+        return res;
+      }
+    }),
+    createWalletProvider: (service, getStore) => {
+      if (!service) return void 0;
+      const defaults = getEntryDefaults(
+        getStore().walletConfig?.INJECTIVE?.chains?.[types.ChainKeys.INJECTIVE_MAINNET]
+      );
+      return new walletSdkCore.InjectiveWalletProvider({ msgBroadcaster: service.msgBroadcaster, defaults });
+    }
+  }),
+  STELLAR: defineChain2({
+    createService: (walletConfig) => {
+      const stellarRpc = walletConfig?.STELLAR?.chains?.[types.ChainKeys.STELLAR_MAINNET];
+      return StellarXService.getInstance(stellarRpc?.horizonRpcUrl, stellarRpc?.sorobanRpcUrl);
+    },
+    displayName: "Stellar",
+    defaultConnectors: () => [],
+    providerManaged: false,
+    discoverConnectors: async (service, getStore) => {
+      const STELLAR_DISCOVER_DELAYS_MS = [0, 100, 500];
+      let lastIds = "";
+      for (const delay of STELLAR_DISCOVER_DELAYS_MS) {
+        if (delay) await new Promise((r) => setTimeout(r, delay));
+        const wallets = await service.walletsKit.getSupportedWallets();
+        const connectors = wallets.filter((w) => w.isAvailable).map((w) => new StellarWalletsKitXConnector(w));
+        const ids = connectors.map((c) => c.id).sort().join(",");
+        if (ids === lastIds) break;
+        lastIds = ids;
+        service.setXConnectors(connectors);
+        getStore().setXConnectors("STELLAR", connectors);
+      }
+    },
+    createActions: (service, getStore) => ({
+      ...createDefaultActions("STELLAR", service, getStore),
+      signMessage: async (message) => {
+        const res = await service.walletsKit.signMessage(message);
+        return res.signedMessage;
+      }
+    }),
+    createWalletProvider: (service, getStore) => {
+      if (!service?.walletsKit) return void 0;
+      const defaults = getEntryDefaults(
+        getStore().walletConfig?.STELLAR?.chains?.[types.ChainKeys.STELLAR_MAINNET]
+      );
+      return new walletSdkCore.StellarWalletProvider({
+        type: "BROWSER_EXTENSION",
+        walletsKit: service.walletsKit,
+        network: "PUBLIC",
+        defaults
+      });
+    }
+  }),
+  // ICON: signMessage not implemented — Hana wallet does not expose a signing API.
+  // connect/disconnect use createDefaultActions (no createActions override needed).
+  ICON: defineChain2({
+    createService: (walletConfig) => IconXService.getInstance(getRpcUrl(walletConfig?.ICON?.chains?.[types.ChainKeys.ICON_MAINNET])),
+    displayName: "ICON",
+    defaultConnectors: () => [new IconHanaXConnector()],
+    providerManaged: false,
+    createWalletProvider: (_service, getStore) => {
+      const store = getStore();
+      const address = store.xConnections.ICON?.xAccount.address;
+      if (!address) return void 0;
+      const chainInfo = CHAIN_INFO[1 /* MAINNET */];
+      if (!chainInfo) throw new Error("ICON mainnet chain info not found");
+      const defaults = getEntryDefaults(
+        store.walletConfig?.ICON?.chains?.[types.ChainKeys.ICON_MAINNET]
+      );
+      return new walletSdkCore.IconWalletProvider({
+        walletAddress: address,
+        rpcUrl: chainInfo.APIEndpoint,
+        defaults
+      });
+    }
+  }),
+  NEAR: defineChain2({
+    createService: (walletConfig) => NearXService.getInstance(getRpcUrl(walletConfig?.NEAR?.chains?.[types.ChainKeys.NEAR_MAINNET])),
+    displayName: "NEAR",
+    defaultConnectors: () => [],
+    providerManaged: false,
+    discoverConnectors: async (service, getStore) => {
+      await service.walletSelector.whenManifestLoaded;
+      const connectors = service.walletSelector.availableWallets.map((w) => new NearXConnector(w));
+      service.setXConnectors(connectors);
+      getStore().setXConnectors("NEAR", connectors);
+    },
+    createActions: (service, getStore) => ({
+      ...createDefaultActions("NEAR", service, getStore),
+      disconnect: async () => {
+        try {
+          service.walletSelector.disconnect();
+        } finally {
+          getStore().unsetXConnection("NEAR");
+        }
+      }
+    }),
+    createWalletProvider: (service, getStore) => {
+      if (!service?.walletSelector) return void 0;
+      const defaults = getEntryDefaults(
+        getStore().walletConfig?.NEAR?.chains?.[types.ChainKeys.NEAR_MAINNET]
+      );
+      return new walletSdkCore.NearWalletProvider({ wallet: service.walletSelector, defaults });
+    }
+  }),
+  STACKS: defineChain2({
+    createService: (walletConfig) => StacksXService.getInstance(walletConfig?.STACKS?.chains?.[types.ChainKeys.STACKS_MAINNET]),
+    displayName: "Stacks",
+    defaultConnectors: () => STACKS_PROVIDERS.map((c) => new StacksXConnector(c)),
+    providerManaged: false,
+    createWalletProvider: (service, getStore) => {
+      const store = getStore();
+      const connection = store.xConnections.STACKS;
+      const address = connection?.xAccount.address;
+      if (!address) return void 0;
+      const connector = connection?.xConnectorId ? service.getXConnectorById(connection.xConnectorId) : void 0;
+      const provider = connector instanceof StacksXConnector ? connector.getProvider() : void 0;
+      const defaults = getEntryDefaults(
+        store.walletConfig?.STACKS?.chains?.[types.ChainKeys.STACKS_MAINNET]
+      );
+      return new walletSdkCore.StacksWalletProvider({ address, provider, defaults });
+    }
+  })
+};
+var createChainServices = (walletConfig, getStore) => {
+  const xServices = {};
+  const xConnectorsByChain = {};
+  const enabledChains = [];
+  const chainActions = {};
+  for (const chainType of types.ChainTypeArr) {
+    if (!hasChainOfType(chainType, walletConfig)) continue;
+    const factory = chainRegistry[chainType];
+    if (!factory) continue;
+    const service = factory.createService(walletConfig);
+    xServices[chainType] = service;
+    enabledChains.push(chainType);
+    if (!factory.providerManaged) {
+      const override = readConnectorsOverride(chainType, walletConfig);
+      const connectors = override ? narrowConnectors(override, chainType) : factory.defaultConnectors(walletConfig);
+      service.setXConnectors(connectors);
+      xConnectorsByChain[chainType] = connectors;
+      chainActions[chainType] = factory.createActions ? factory.createActions(service, getStore) : createDefaultActions(chainType, service, getStore);
+      if (factory.discoverConnectors) {
+        factory.discoverConnectors(service, getStore).catch((err) => {
+          console.warn(`[wallet-sdk-react] discoverConnectors failed for ${chainType}:`, err);
+        });
+      }
+    }
+  }
+  return { xServices, xConnectorsByChain, enabledChains, chainActions };
+};
+
+// src/useXWalletStore.ts
+var useXWalletStore = zustand.create()(
+  middleware.devtools(
+    middleware.persist(
+      immer.immer((set, get) => ({
+        xServices: {},
+        xConnections: {},
+        xConnectorsByChain: {},
+        enabledChains: [],
+        chainActions: {},
+        walletProviders: {},
+        walletConfig: void 0,
+        userDisconnected: {},
+        setXConnection: (xChainType, xConnection) => {
+          set((state) => {
+            state.xConnections[xChainType] = xConnection;
+          });
+          const factory = chainRegistry[xChainType]?.createWalletProvider;
+          if (factory) {
+            const service = get().xServices[xChainType];
+            if (service) {
+              const provider = factory(service, () => get());
+              get().setWalletProvider(xChainType, provider);
+            }
+          }
+        },
+        unsetXConnection: (xChainType) => {
+          set((state) => {
+            delete state.xConnections[xChainType];
+            delete state.walletProviders[xChainType];
+          });
+        },
+        setXConnectors: (xChainType, connectors) => {
+          set((state) => {
+            state.xConnectorsByChain[xChainType] = connectors;
+          });
+        },
+        registerChainActions: (xChainType, actions) => {
+          set((state) => {
+            state.chainActions[xChainType] = actions;
+          });
+        },
+        setWalletProvider: (xChainType, provider) => {
+          set((state) => {
+            if (provider) {
+              state.walletProviders[xChainType] = provider;
+            } else {
+              delete state.walletProviders[xChainType];
+            }
+          });
+        },
+        getWalletProvider: (xChainType) => {
+          if (!xChainType) return void 0;
+          return get().walletProviders[xChainType];
+        },
+        initChainServices: (walletConfig) => {
+          const result = createChainServices(walletConfig, () => get());
+          set((state) => {
+            state.xServices = result.xServices;
+            state.enabledChains = result.enabledChains;
+            Object.assign(state.xConnectorsByChain, result.xConnectorsByChain);
+            Object.assign(state.chainActions, result.chainActions);
+          });
+          set({ walletConfig });
+        },
+        cleanupDisabledConnections: () => {
+          set((state) => {
+            for (const chainType of types.ChainTypeArr) {
+              if (state.xConnections[chainType] && !state.enabledChains.includes(chainType)) {
+                delete state.xConnections[chainType];
+                delete state.walletProviders[chainType];
+              }
+            }
+          });
+        },
+        markUserDisconnected: (xChainType) => {
+          set((state) => {
+            state.userDisconnected[xChainType] = true;
+          });
+        },
+        clearUserDisconnected: (xChainType) => {
+          set((state) => {
+            delete state.userDisconnected[xChainType];
+          });
+        }
+      })),
+      {
+        // key kept as 'xwagmi-store' for backward compat — existing users won't lose persisted connections on upgrade
+        name: "xwagmi-store",
+        storage: middleware.createJSONStorage(() => localStorage),
+        partialize: (state) => ({
+          xConnections: state.xConnections,
+          userDisconnected: state.userDisconnected
+        })
+      }
+    ),
+    { name: "xwagmi-store" }
+  )
+);
+zustand.create()(
+  middleware.devtools(
+    immer.immer((set) => ({
+      walletModal: { kind: "closed" },
+      open: () => {
+        set((state) => {
+          state.walletModal = { kind: "chainSelect" };
+        });
+      },
+      close: () => {
+        set((state) => {
+          state.walletModal = { kind: "closed" };
+        });
+      },
+      back: () => {
+        set((state) => {
+          const current = state.walletModal;
+          switch (current.kind) {
+            case "walletSelect":
+              state.walletModal = { kind: "chainSelect" };
+              return;
+            case "connecting":
+            case "error":
+              state.walletModal = { kind: "walletSelect", chainType: current.chainType };
+              return;
+            case "success":
+              state.walletModal = { kind: "closed" };
+              return;
+          }
+        });
+      },
+      selectChain: (chainType) => {
+        set((state) => {
+          state.walletModal = { kind: "walletSelect", chainType };
+        });
+      },
+      setConnecting: (chainType, connector) => {
+        set((state) => {
+          state.walletModal = { kind: "connecting", chainType, connector };
+        });
+      },
+      setSuccess: (chainType, connector, account) => {
+        set((state) => {
+          state.walletModal = { kind: "success", chainType, connector, account };
+        });
+      },
+      setError: (chainType, connector, error) => {
+        set((state) => {
+          state.walletModal = { kind: "error", chainType, connector, error };
+        });
+      }
+    })),
+    { name: "wallet-modal-store" }
+  )
+);
+
+// src/hooks/useXService.ts
+function useXService({ xChainType } = {}) {
+  const xService = useXWalletStore((state) => xChainType ? state.xServices[xChainType] : void 0);
+  return xService;
+}
+var WalletConfigContext = react.createContext(null);
+WalletConfigContext.Provider;
+
+// src/xchains/bitcoin/useBitcoinXConnectors.ts
+function useBitcoinXConnectors() {
+  const xService = useXService({ xChainType: "BITCOIN" });
+  return react.useMemo(() => {
+    const connectors = xService?.getXConnectors() ?? [];
+    return connectors.filter((c) => c instanceof BitcoinXConnector);
+  }, [xService]);
+}
+
+exports.BitcoinXConnector = BitcoinXConnector;
+exports.BitcoinXService = BitcoinXService;
+exports.OKXXConnector = OKXXConnector;
+exports.UnisatXConnector = UnisatXConnector;
+exports.XverseXConnector = XverseXConnector;
+exports.useBitcoinXConnectors = useBitcoinXConnectors;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map