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

package/dist/index.cjs

@@ -1,41 +1,40 @@
 'use strict';
 
 var types = require('@sodax/types');
-var nearConnect = require('@hot-labs/near-connect');
-var nearApiJs = require('near-api-js');
-var transactions = require('@stacks/transactions');
-var network = require('@stacks/network');
-var satsConnect = require('sats-connect');
-var React2 = require('react');
-var dappKit = require('@mysten/dapp-kit');
-var walletAdapterReact = require('@solana/wallet-adapter-react');
-var wagmi = require('wagmi');
 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');
-var chains = require('wagmi/chains');
-var networks = require('@injectivelabs/networks');
-var sdkTs = require('@injectivelabs/sdk-ts');
-var tsTypes = require('@injectivelabs/ts-types');
-var walletCore = require('@injectivelabs/wallet-core');
-var walletStrategy = require('@injectivelabs/wallet-strategy');
-var walletBase = require('@injectivelabs/wallet-base');
-var walletCosmos = require('@injectivelabs/wallet-cosmos');
+var wagmi = require('wagmi');
+var chains$1 = 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 connect = require('@stacks/connect');
+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 satsConnect = require('sats-connect');
+var react = require('react');
 var reactQuery = require('@tanstack/react-query');
-var chains$1 = require('viem/chains');
-var walletSdkCore = require('@sodax/wallet-sdk-core');
+var chains = require('viem/chains');
+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');
+var connectors = require('wagmi/connectors');
+var jsxRuntime = require('react/jsx-runtime');
+var walletAdapterReact = require('@solana/wallet-adapter-react');
+var dappKit = require('@mysten/dapp-kit');
 var client = require('@mysten/sui/client');
-var walletAdapterWallets = require('@solana/wallet-adapter-wallets');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -55,7 +54,6 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var React2__default = /*#__PURE__*/_interopDefault(React2);
 var StellarSdk__namespace = /*#__PURE__*/_interopNamespace(StellarSdk);
 var IconSdkRaw__namespace = /*#__PURE__*/_interopNamespace(IconSdkRaw);
 
@@ -69,9 +67,11 @@ function getXChainType(xChainId) {
 
 // src/core/XService.ts
 var XService = class {
+  /** The blockchain type this service handles */
+  xChainType;
+  /** Available wallet connectors for this chain */
+  xConnectors = [];
   constructor(xChainType) {
-    /** Available wallet connectors for this chain */
-    this.xConnectors = [];
     this.xChainType = xChainType;
   }
   /**
@@ -122,106 +122,17 @@ var XService = class {
     return this.getXConnectors().find((xConnector) => xConnector.id === xConnectorId);
   }
 };
-var NearXService = class _NearXService extends XService {
-  constructor() {
-    super("NEAR");
-    this.walletSelector = new nearConnect.NearConnector({
-      network: "mainnet",
-      logger: console,
-      autoConnect: true,
-      excludedWallets: ["okx-wallet"]
-    });
-  }
-  static getInstance() {
-    if (!_NearXService.instance) {
-      _NearXService.instance = new _NearXService();
-    }
-    return _NearXService.instance;
-  }
-  async getBalance(address, xToken) {
-    const url = "https://1rpc.io/near";
-    const provider = new nearApiJs.JsonRpcProvider({ url });
-    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);
-  }
-};
-var StacksXService = class _StacksXService extends XService {
-  constructor() {
-    super("STACKS");
-    this.network = network.networkFrom("mainnet");
-  }
-  static getInstance() {
-    if (!_StacksXService.instance) {
-      _StacksXService.instance = new _StacksXService();
-    }
-    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 [contractAddress, contractName] = xToken.address.split(".");
-    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;
-    }
-  }
-};
-
-// src/actions/getXService.ts
-function getXService(xChainType) {
-  switch (xChainType) {
-    case "BITCOIN":
-      return BitcoinXService.getInstance();
-    case "EVM":
-      return EvmXService.getInstance();
-    case "SUI":
-      return SuiXService.getInstance();
-    case "SOLANA":
-      return SolanaXService.getInstance();
-    case "ICON":
-      return IconXService.getInstance();
-    case "INJECTIVE":
-      return InjectiveXService.getInstance();
-    case "STELLAR":
-      return StellarXService.getInstance();
-    case "NEAR":
-      return NearXService.getInstance();
-    case "STACKS":
-      return StacksXService.getInstance();
-    default:
-      throw new Error(`Unsupported chain type: ${xChainType}`);
-  }
-}
 
 // 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;
@@ -235,7 +146,55 @@ var XConnector = class {
   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;
+  }
 };
+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;
+}
+function resolveEvmDefaults(activeChainId, evmChains) {
+  const key = types.getEvmChainKeyByChainId(activeChainId);
+  if (!key || !evmChains) return void 0;
+  return evmChains[key]?.defaults;
+}
+
+// src/utils/sortConnectors.ts
+function sortConnectors(connectors, options = {}) {
+  const { preferred = [] } = options;
+  const preferredIndex = new Map(preferred.map((id, i) => [id, i]));
+  return [...connectors].map((connector, originalIndex) => ({ connector, originalIndex })).sort((a, b) => {
+    const aPref = preferredIndex.get(a.connector.id);
+    const bPref = preferredIndex.get(b.connector.id);
+    if (aPref !== bPref) {
+      if (aPref === void 0) return 1;
+      if (bPref === void 0) return -1;
+      return aPref - bPref;
+    }
+    if (a.connector.isInstalled !== b.connector.isInstalled) {
+      return a.connector.isInstalled ? -1 : 1;
+    }
+    return a.originalIndex - b.originalIndex;
+  }).map(({ connector }) => connector);
+}
+
+// src/utils/index.ts
 var isNativeToken = (xToken) => {
   const nativeAddresses = [
     "cx0000000000000000000000000000000000000000",
@@ -255,516 +214,716 @@ var isNativeToken = (xToken) => {
   return nativeAddresses.includes(xToken.address);
 };
 var getWagmiChainId = (xChainId) => {
-  return types.baseChainInfo[xChainId].chainId;
+  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/xchains/bitcoin/BitcoinXService.ts
-var BitcoinXService = class _BitcoinXService extends XService {
-  constructor(rpcUrl = "https://mempool.space/api") {
-    super("BITCOIN");
-    this.rpcUrl = rpcUrl;
+var hyper = /* @__PURE__ */ viem.defineChain({
+  id: 999,
+  name: "HyperEVM",
+  nativeCurrency: {
+    decimals: 18,
+    name: "HYPE",
+    symbol: "HYPE"
+  },
+  rpcUrls: {
+    default: { http: ["https://rpc.hyperliquid.xyz/evm"] }
+  },
+  blockExplorers: {
+    default: {
+      name: "HyperEVMScan",
+      url: "https://hyperevmscan.io/"
+    }
+  },
+  contracts: {
+    multicall3: {
+      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+      blockCreated: 13051
+    }
   }
-  static getInstance(rpcUrl) {
-    if (!_BitcoinXService.instance) {
-      _BitcoinXService.instance = new _BitcoinXService(rpcUrl);
-    } else if (rpcUrl && rpcUrl !== _BitcoinXService.instance.rpcUrl) {
-      _BitcoinXService.instance.rpcUrl = rpcUrl;
+});
+var createWagmiConfig = (evmChains, options) => {
+  return wagmi.createConfig({
+    chains: [
+      chains$1.mainnet,
+      chains$1.avalanche,
+      chains$1.arbitrum,
+      chains$1.base,
+      chains$1.bsc,
+      chains$1.sonic,
+      chains$1.optimism,
+      chains$1.polygon,
+      hyper,
+      chains$1.lightlinkPhoenix,
+      chains$1.kaia,
+      chains$1.redbellyMainnet
+    ],
+    connectors: options?.connectors ?? [],
+    ssr: options?.ssr,
+    transports: {
+      [chains$1.mainnet.id]: wagmi.http(getRpcUrl(evmChains?.[types.ChainKeys.ETHEREUM_MAINNET])),
+      [chains$1.avalanche.id]: wagmi.http(getRpcUrl(evmChains?.[types.ChainKeys.AVALANCHE_MAINNET])),
+      [chains$1.arbitrum.id]: wagmi.http(getRpcUrl(evmChains?.[types.ChainKeys.ARBITRUM_MAINNET])),
+      [chains$1.base.id]: wagmi.http(getRpcUrl(evmChains?.[types.ChainKeys.BASE_MAINNET])),
+      [chains$1.bsc.id]: wagmi.http(getRpcUrl(evmChains?.[types.ChainKeys.BSC_MAINNET])),
+      [chains$1.sonic.id]: wagmi.http(getRpcUrl(evmChains?.[types.ChainKeys.SONIC_MAINNET])),
+      [chains$1.optimism.id]: wagmi.http(getRpcUrl(evmChains?.[types.ChainKeys.OPTIMISM_MAINNET])),
+      [chains$1.polygon.id]: wagmi.http(getRpcUrl(evmChains?.[types.ChainKeys.POLYGON_MAINNET])),
+      [hyper.id]: wagmi.http(getRpcUrl(evmChains?.[types.ChainKeys.HYPEREVM_MAINNET])),
+      [chains$1.lightlinkPhoenix.id]: wagmi.http(getRpcUrl(evmChains?.[types.ChainKeys.LIGHTLINK_MAINNET])),
+      [chains$1.redbellyMainnet.id]: wagmi.http(getRpcUrl(evmChains?.[types.ChainKeys.REDBELLY_MAINNET])),
+      [chains$1.kaia.id]: wagmi.http(getRpcUrl(evmChains?.[types.ChainKeys.KAIA_MAINNET]))
+    },
+    storage: wagmi.createStorage({
+      storage: wagmi.cookieStorage,
+      key: "sodax"
+    })
+  });
+};
+var EvmXService = class _EvmXService extends XService {
+  static instance;
+  wagmiConfig;
+  constructor() {
+    super("EVM");
+  }
+  static getInstance() {
+    if (!_EvmXService.instance) {
+      _EvmXService.instance = new _EvmXService();
     }
-    return _BitcoinXService.instance;
+    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;
-    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;
+    if (!this.wagmiConfig) return 0n;
+    const chainId = getWagmiChainId(xToken.chainKey);
+    if (isNativeToken(xToken)) {
+      return this._getChainBalance(address, chainId);
     }
-    return 0n;
+    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);
   }
 };
 
-// src/xchains/bitcoin/BitcoinXConnector.ts
-var BitcoinXConnector = class extends XConnector {
-  constructor(name, id) {
-    super("BITCOIN", name, id);
+// src/xchains/evm/EvmXConnector.ts
+var WALLETCONNECT_ICON = "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='32' height='32' viewBox='0 0 32 32'%3E%3Cpath fill='%233B99FC' d='M9.58 11.58c3.55-3.47 9.29-3.47 12.84 0l.43.42a.44.44 0 0 1 0 .63l-1.46 1.43a.23.23 0 0 1-.32 0l-.59-.57a6.72 6.72 0 0 0-9.36 0l-.63.61a.23.23 0 0 1-.32 0L8.71 12.7a.44.44 0 0 1 0-.63l.87-.5Zm15.87 2.95 1.3 1.28a.44.44 0 0 1 0 .63l-5.87 5.74a.46.46 0 0 1-.64 0l-4.17-4.08a.11.11 0 0 0-.16 0l-4.17 4.08a.46.46 0 0 1-.64 0l-5.87-5.74a.44.44 0 0 1 0-.63l1.3-1.28a.46.46 0 0 1 .64 0l4.17 4.08a.11.11 0 0 0 .16 0l4.17-4.08a.46.46 0 0 1 .64 0l4.17 4.08a.11.11 0 0 0 .16 0l4.17-4.08a.46.46 0 0 1 .64 0Z'/%3E%3C/svg%3E";
+var EvmXConnector = class extends XConnector {
+  connector;
+  constructor(connector) {
+    super("EVM", connector.name, connector.id);
+    this.connector = connector;
   }
-  getXService() {
-    return BitcoinXService.getInstance();
+  async connect() {
+    return;
   }
-};
-var UnisatWalletProvider = class {
-  constructor(unisat, address) {
-    this.unisat = unisat;
-    this.cachedAddress = address;
+  async disconnect() {
+    return;
   }
-  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 = false) {
-    const psbtHex = Buffer.from(psbtBase64, "base64").toString("hex");
-    const signedHex = await this.unisat.signPsbt(psbtHex, { autoFinalized: finalize });
-    return signedHex;
-  }
-  async signEcdsaMessage(message) {
-    return this.unisat.signMessage(message, "ecdsa");
-  }
-  async signBip322Message(message) {
-    return this.unisat.signMessage(message, "bip322-simple");
+  get id() {
+    return this.connector.id;
   }
-  async sendBitcoin(toAddress, satoshis) {
-    if (satoshis > BigInt(Number.MAX_SAFE_INTEGER)) {
-      throw new Error(`Amount ${satoshis} satoshis exceeds safe integer range`);
+  get icon() {
+    if (!this.connector.icon && this.connector.type === "walletConnect") {
+      return WALLETCONNECT_ICON;
     }
-    return this.unisat.sendBitcoin(toAddress, Number(satoshis));
+    return this.connector.icon;
   }
 };
-var UnisatXConnector = class extends BitcoinXConnector {
+var SolanaXService = class _SolanaXService extends XService {
+  static instance;
+  connection;
+  wallet;
   constructor() {
-    super("Unisat", "unisat");
-  }
-  static isAvailable() {
-    return typeof window !== "undefined" && !!window.unisat;
-  }
-  get icon() {
-    return "https://avatars.githubusercontent.com/u/125119198?s=200&v=4";
+    super("SOLANA");
   }
-  async connect() {
-    if (!window.unisat) {
-      throw new Error("Unisat wallet is not installed");
+  static getInstance() {
+    if (!_SolanaXService.instance) {
+      _SolanaXService.instance = new _SolanaXService();
     }
-    const accounts = await window.unisat.requestAccounts();
-    const address = accounts[0];
-    if (!address) return void 0;
-    this.walletProvider = new UnisatWalletProvider(window.unisat, address);
-    return {
-      address,
-      xChainType: "BITCOIN"
-    };
-  }
-  async disconnect() {
-    this.walletProvider = void 0;
-  }
-  getWalletProvider() {
-    return this.walletProvider;
+    return _SolanaXService.instance;
   }
-  recreateWalletProvider(xAccount) {
-    if (!window.unisat || !xAccount.address) return void 0;
-    return new UnisatWalletProvider(window.unisat, xAccount.address);
+  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 XverseWalletProvider = class {
-  constructor(address, publicKey) {
-    this.address = address;
-    this.publicKey = publicKey;
-  }
-  async getWalletAddress() {
-    return this.address;
-  }
-  async getPublicKey() {
-    return this.publicKey;
-  }
-  async getAddressType(_address) {
-    return types.detectBitcoinAddressType(this.address);
+
+// 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 hasOptionalStringProperty(value, key) {
+  return isRecord(value) && (value[key] === void 0 || 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);
   }
-  /**
-   * 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;
+}
+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`);
+}
+
+// src/xchains/sui/SuiXService.ts
+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");
   }
-  async signTransaction(psbtBase64, finalize = 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 (finalize) {
-      return Buffer.from(result.psbt, "base64").toString("hex");
+  static getInstance() {
+    if (!_SuiXService.instance) {
+      _SuiXService.instance = new _SuiXService();
     }
-    return result.psbt;
+    return _SuiXService.instance;
   }
-  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");
+  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;
     }
-    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
+    assertSuiProviderShape("SuiXService", this.suiClient, this.suiWallet, this.suiAccount);
+    return new walletSdkCore.SuiWalletProvider({
+      client: this.suiClient,
+      wallet: this.suiWallet,
+      account: this.suiAccount
     });
-    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)
+  // 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";
         }
-      ]
-    });
-    if (response.status === "error") {
-      throw new Error(response.error?.message || "Xverse sendTransfer failed");
+        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 {};
     }
-    return response.result.txid;
   }
 };
-var XVERSE_ADDRESS_TYPE_KEY = "xverse-address-type";
-var XverseXConnector = class _XverseXConnector extends BitcoinXConnector {
-  constructor() {
-    super("Xverse", "xverse");
-    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;
+
+// src/xchains/sui/SuiXConnector.ts
+var isSuiWalletInfo = (value) => {
+  return isRecord(value) && hasStringProperty(value, "name") && // Some wallets may not expose `id` — in that case we fall back to `name` for stability.
+  // We still validate if it exists.
+  hasOptionalStringProperty(value, "id") && hasOptionalStringProperty(value, "icon");
+};
+var SuiXConnector = class extends XConnector {
+  wallet;
+  constructor(wallet) {
+    assert(isSuiWalletInfo(wallet), "[SuiXConnector] invalid wallet object");
+    const id = wallet.id ?? wallet.name;
+    assert(typeof id === "string" && id.length > 0, "[SuiXConnector] invalid wallet id");
+    super("SUI", wallet.name, id);
+    this.wallet = { id, name: wallet.name, icon: wallet.icon };
   }
-  get icon() {
-    return "https://cdn.brandfetch.io/iddzGN5Rcv/w/400/h/400/theme/dark/icon.jpeg?c=1bxid64Mup7aczewSAYMX&t=1771902357797";
+  getXService() {
+    return SuiXService.getInstance();
   }
   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
-    );
-    return {
-      address: paymentAccount.address,
-      publicKey: paymentAccount.publicKey,
-      xChainType: "BITCOIN"
-    };
+    return;
   }
   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);
+  get icon() {
+    return this.wallet.icon;
   }
 };
-var OKXWalletProvider = class {
-  constructor(okx, address) {
-    this.okx = okx;
-    this.cachedAddress = address;
+var CustomSorobanServer = class extends StellarSdk.rpc.Server {
+  customHeaders;
+  constructor(serverUrl, customHeaders) {
+    super(serverUrl, {
+      allowHttp: true
+    });
+    this.customHeaders = customHeaders;
   }
-  async getWalletAddress() {
-    try {
-      const accounts = await this.okx.getAccounts();
-      if (accounts[0]) this.cachedAddress = accounts[0];
-    } catch {
+  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 this.cachedAddress;
+    return response.json().then((json) => StellarSdk.rpc.parseRawSimulation(json.result));
   }
-  async getPublicKey() {
-    return this.okx.getPublicKey();
+  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 getAddressType(_address) {
-    const address = await this.getWalletAddress();
-    return types.detectBitcoinAddressType(address);
+  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);
   }
-  async signTransaction(psbtBase64, finalize = false) {
-    const psbtHex = Buffer.from(psbtBase64, "base64").toString("hex");
-    return this.okx.signPsbt(psbtHex, { autoFinalized: finalize });
+};
+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)}`);
   }
-  async signEcdsaMessage(message) {
-    return this.okx.signMessage(message, "ecdsa");
+  return result.result ? StellarSdk.scValToBigInt(result.result.retval) : 0n;
+};
+
+// src/constants.ts
+var SUI_DEFAULT_NETWORK = "mainnet";
+var SUI_DEFAULT_AUTO_CONNECT = true;
+var EVM_DEFAULT_RECONNECT_ON_MOUNT = false;
+var EVM_DEFAULT_SSR = true;
+var SOLANA_DEFAULT_AUTO_CONNECT = true;
+var SOLANA_DEFAULT_RPC_URL = "https://api.mainnet-beta.solana.com";
+var SOLANA_METAMASK_CONNECT_TIMEOUT_MS = 3e4;
+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"
   }
-  async signBip322Message(message) {
-    return this.okx.signMessage(message, "bip322-simple");
+};
+
+// 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, {});
   }
-  async sendBitcoin(toAddress, satoshis) {
-    if (satoshis > BigInt(Number.MAX_SAFE_INTEGER)) {
-      throw new Error(`Amount ${satoshis} satoshis exceeds safe integer range`);
+  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 this.okx.sendBitcoin(toAddress, Number(satoshis));
+    return _StellarXService.instance;
   }
-};
-var OKXXConnector = class extends BitcoinXConnector {
-  constructor() {
-    super("OKX Wallet", "okx-bitcoin");
+  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);
   }
-  static isAvailable() {
-    return typeof window !== "undefined" && !!window.okxwallet?.bitcoin;
+};
+
+// src/xchains/stellar/StellarWalletsKitXConnector.ts
+var StellarWalletsKitXConnector = class extends XConnector {
+  _wallet;
+  constructor(wallet) {
+    super("STELLAR", wallet.name, wallet.id);
+    this._wallet = wallet;
   }
-  get icon() {
-    return "https://static.okx.com/cdn/assets/imgs/247/58E63FEA47A2B7D7.png";
+  getXService() {
+    return StellarXService.getInstance();
   }
   async connect() {
-    const okx = window.okxwallet?.bitcoin;
-    if (!okx) {
-      throw new Error("OKX wallet is not installed");
+    const kit = this.getXService().walletsKit;
+    if (!this._wallet) {
+      return;
     }
-    const { address } = await okx.connect();
-    if (!address) return void 0;
-    this.walletProvider = new OKXWalletProvider(okx, address);
+    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: "BITCOIN"
+      xChainType: this.xChainType
     };
   }
   async disconnect() {
-    this.walletProvider = void 0;
   }
-  getWalletProvider() {
-    return this.walletProvider;
+  get icon() {
+    return this._wallet.icon;
   }
-  recreateWalletProvider(xAccount) {
-    const okx = window.okxwallet?.bitcoin;
-    if (!okx || !xAccount.address) return void 0;
-    return new OKXWalletProvider(okx, xAccount.address);
+  get isInstalled() {
+    return this._wallet.isAvailable;
   }
-};
-var hyper = /* @__PURE__ */ viem.defineChain({
-  id: 999,
-  name: "HyperEVM",
-  nativeCurrency: {
-    decimals: 18,
-    name: "HYPE",
-    symbol: "HYPE"
-  },
-  rpcUrls: {
-    default: { http: ["https://rpc.hyperliquid.xyz/evm"] }
-  },
-  blockExplorers: {
-    default: {
-      name: "HyperEVMScan",
-      url: "https://hyperevmscan.io/"
-    }
-  },
-  contracts: {
-    multicall3: {
-      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
-      blockCreated: 13051
-    }
+  get installUrl() {
+    return this._wallet.url;
   }
-});
-var createWagmiConfig = (config, options) => {
-  return wagmi.createConfig({
-    chains: [
-      chains.mainnet,
-      chains.avalanche,
-      chains.arbitrum,
-      chains.base,
-      chains.bsc,
-      chains.sonic,
-      chains.optimism,
-      chains.polygon,
-      hyper,
-      chains.lightlinkPhoenix,
-      chains.kaia,
-      chains.redbellyMainnet
-    ],
-    ssr: options?.ssr,
-    transports: {
-      [chains.mainnet.id]: wagmi.http(config[types.ETHEREUM_MAINNET_CHAIN_ID]),
-      [chains.avalanche.id]: wagmi.http(config[types.AVALANCHE_MAINNET_CHAIN_ID]),
-      [chains.arbitrum.id]: wagmi.http(config[types.ARBITRUM_MAINNET_CHAIN_ID]),
-      [chains.base.id]: wagmi.http(config[types.BASE_MAINNET_CHAIN_ID]),
-      [chains.bsc.id]: wagmi.http(config[types.BSC_MAINNET_CHAIN_ID]),
-      [chains.sonic.id]: wagmi.http(config[types.SONIC_MAINNET_CHAIN_ID]),
-      [chains.optimism.id]: wagmi.http(config[types.OPTIMISM_MAINNET_CHAIN_ID]),
-      [chains.polygon.id]: wagmi.http(config[types.POLYGON_MAINNET_CHAIN_ID]),
-      [hyper.id]: wagmi.http(config[types.HYPEREVM_MAINNET_CHAIN_ID]),
-      [chains.lightlinkPhoenix.id]: wagmi.http(config[types.LIGHTLINK_MAINNET_CHAIN_ID]),
-      [chains.redbellyMainnet.id]: wagmi.http(config[types.REDBELLY_MAINNET_CHAIN_ID]),
-      [chains.kaia.id]: wagmi.http(config[types.KAIA_MAINNET_CHAIN_ID])
-    },
-    storage: wagmi.createStorage({
-      storage: wagmi.cookieStorage,
-      key: "sodax"
-    })
-  });
 };
-var EvmXService = class _EvmXService extends XService {
-  constructor() {
-    super("EVM");
+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)
+    );
   }
-  getXConnectors() {
-    return [];
+  static getInstance(rpcUrl) {
+    if (!_IconXService.instance) {
+      _IconXService.instance = new _IconXService(rpcUrl);
+    }
+    return _IconXService.instance;
   }
-  static getInstance() {
-    if (!_EvmXService.instance) {
-      _EvmXService.instance = new _EvmXService();
+  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);
     }
-    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.xChainId);
-    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 balances = {};
+    const nativeXToken = xTokens.find((xToken) => isNativeToken(xToken));
     const nonNativeXTokens = xTokens.filter((xToken) => !isNativeToken(xToken));
-    const xChainId = xTokens[0].xChainId;
-    const viemChain = this.wagmiConfig.chains.find((chain) => chain.id === getWagmiChainId(xChainId));
-    const chainId = getWagmiChainId(xChainId);
-    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) => {
-        acc[token.address] = result?.[index]?.result?.toString() || "0";
-        return acc;
-      }, tokenMap);
+    if (nativeXToken) {
+      const balance = await this.iconService.getBalance(address).execute();
+      balances[nativeXToken.address] = BigInt(balance.toFixed());
     }
-    const nonNativeTokenBalances = await Promise.all(
-      nonNativeXTokens.map((token) => this._getTokenBalance(address, chainId, token.address))
+    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((acc, token, idx) => {
-      acc[token.address] = nonNativeTokenBalances[idx] || "0";
-      return acc;
-    }, tokenMap);
+    return nonNativeXTokens.reduce((agg, token, idx) => {
+      const balance = data[idx];
+      if (balance) {
+        balances[token.address] = BigInt(balance);
+      }
+      return agg;
+    }, balances);
   }
 };
 
-// src/xchains/evm/EvmXConnector.ts
-var EvmXConnector = class extends XConnector {
-  constructor(connector) {
-    super("EVM", connector.name, connector.id);
-    this.connector = connector;
+// 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() {
-    return;
+    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() {
-    return;
-  }
-  get id() {
-    return this.connector.id;
+    console.log("HanaIconXConnector disconnected");
   }
   get icon() {
-    return this.connector.icon;
+    return WALLET_METADATA.hana.icon;
   }
 };
 var InjectiveXService = class _InjectiveXService extends XService {
-  constructor() {
+  static instance;
+  walletStrategy;
+  indexerGrpcAccountPortfolioApi;
+  chainGrpcWasmApi;
+  msgBroadcaster;
+  constructor(rpcConfig) {
     super("INJECTIVE");
-    const endpoints = networks.getNetworkEndpoints(networks.Network.Mainnet);
+    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]
+        evmChainId: chains$1.mainnet.id,
+        rpcUrl: chains$1.mainnet.rpcUrls.default.http[0]
       }
     });
     this.indexerGrpcAccountPortfolioApi = new sdkTs.IndexerGrpcAccountPortfolioApi(endpoints.indexer);
@@ -775,9 +934,15 @@ var InjectiveXService = class _InjectiveXService extends XService {
       endpoints
     });
   }
-  static getInstance() {
+  /**
+   * @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();
+      _InjectiveXService.instance = new _InjectiveXService(rpcConfig);
     }
     return _InjectiveXService.instance;
   }
@@ -802,6 +967,7 @@ var WALLET_ICONS = {
   "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;
@@ -811,13 +977,22 @@ var InjectiveXConnector = class extends XConnector {
   }
   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) return void 0;
-    const address = walletBase.isEvmBrowserWallet(this.wallet) ? sdkTs.getInjectiveAddress(addresses[0]) : addresses[0];
+    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
@@ -833,392 +1008,1295 @@ var InjectiveXConnector = class extends XConnector {
   get icon() {
     return WALLET_ICONS[this.wallet];
   }
+  get isInstalled() {
+    if (walletBase.isCosmosBrowserWallet(this.wallet)) {
+      return walletCosmos.isCosmosWalletInstalled(this.wallet);
+    }
+    return true;
+  }
 };
-var SolanaXService = class _SolanaXService extends XService {
-  constructor() {
-    super("SOLANA");
+
+// 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() {
-    if (!_SolanaXService.instance) {
-      _SolanaXService.instance = new _SolanaXService();
+  static getInstance(rpcUrl) {
+    if (!_BitcoinXService.instance) {
+      _BitcoinXService.instance = new _BitcoinXService(rpcUrl);
+    } else if (rpcUrl && rpcUrl !== _BitcoinXService.instance.rpcUrl) {
+      _BitcoinXService.instance.rpcUrl = rpcUrl;
     }
-    return _SolanaXService.instance;
+    return _BitcoinXService.instance;
   }
   async getBalance(address, xToken) {
-    if (!address) return BigInt(0);
-    const connection = this.connection;
-    if (!connection) {
-      return BigInt(0);
-    }
+    if (!address) return 0n;
     try {
       if (isNativeToken(xToken)) {
-        const newBalance = await connection.getBalance(new web3_js.PublicKey(address));
-        return BigInt(newBalance);
+        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);
       }
-      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);
+      return 0n;
     }
+    return 0n;
   }
 };
-var CustomSorobanServer = class extends StellarSdk.SorobanRpc.Server {
-  constructor(serverUrl, customHeaders) {
-    super(serverUrl, {
-      allowHttp: true
-    });
-    this.customHeaders = customHeaders;
+
+// src/xchains/bitcoin/BitcoinXConnector.ts
+var BitcoinXConnector = class extends XConnector {
+  defaults;
+  constructor(name, id, defaults) {
+    super("BITCOIN", name, id);
+    this.defaults = defaults;
   }
-  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) => json.result);
+  getXService() {
+    return BitcoinXService.getInstance();
   }
-  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);
+};
+var UnisatWalletProvider = class {
+  chainType = "BITCOIN";
+  cachedAddress;
+  defaults;
+  constructor(address, defaults) {
+    this.cachedAddress = address;
+    this.defaults = defaults;
   }
-  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}`);
+  // 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 response.json().then((json) => json.result);
+    return this.cachedAddress;
   }
-};
-var CustomSorobanServer_default = CustomSorobanServer;
-var accountToScVal = (account) => new StellarSdk.Address(account).toScVal();
-var simulateTx = async (tx, server) => {
-  const response = await server.simulateTransaction(tx);
-  if (response !== void 0) {
-    return response;
+  async getPublicKey() {
+    return this.unisat.getPublicKey();
   }
-  throw new Error("cannot simulate transaction");
-};
-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);
-  return result.results ? StellarSdk.scValToBigInt(StellarSdk.xdr.ScVal.fromXDR(result.results[0].xdr, "base64")) : 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 {
-  constructor() {
-    super("STELLAR");
-    this.walletsKit = new stellarWalletsKit.StellarWalletsKit({
-      network: stellarWalletsKit.WalletNetwork.PUBLIC,
-      modules: stellarWalletsKit.allowAllModules()
-    });
-    this.server = new StellarSdk__namespace.Horizon.Server("https://horizon.stellar.org", { allowHttp: true });
-    this.sorobanServer = new CustomSorobanServer_default("https://rpc.ankr.com/stellar_soroban", {});
+  async getAddressType(_address) {
+    const address = await this.getWalletAddress();
+    return types.detectBitcoinAddressType(address);
   }
-  static getInstance() {
-    if (!_StellarXService.instance) {
-      _StellarXService.instance = new _StellarXService();
-    }
-    return _StellarXService.instance;
+  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 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}`);
-      }
+  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 BigInt(0);
+    return this.unisat.sendBitcoin(toAddress, Number(satoshis));
   }
 };
-
-// src/xchains/stellar/StellarWalletsKitXConnector.ts
-var StellarWalletsKitXConnector = class extends XConnector {
-  constructor(wallet) {
-    super("STELLAR", wallet.name, wallet.id);
-    this._wallet = wallet;
+var UnisatXConnector = class _UnisatXConnector extends BitcoinXConnector {
+  walletProvider;
+  constructor(defaults) {
+    super("Unisat", "unisat", defaults);
   }
-  getXService() {
-    return StellarXService.getInstance();
+  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() {
-    const kit = this.getXService().walletsKit;
-    if (!this._wallet) {
-      return;
+    if (!window.unisat) {
+      throw new Error("Unisat wallet is not installed");
     }
-    if (!this._wallet.isAvailable && this._wallet.url) {
-      window.open(this._wallet.url, "_blank");
-      return;
+    const accounts = await window.unisat.requestAccounts();
+    const address = accounts[0];
+    if (!address) {
+      console.warn("[UnisatXConnector] connect: requestAccounts returned no address");
+      return void 0;
     }
-    kit.setWallet(this._wallet.id);
-    const { address } = await kit.getAddress();
+    this.walletProvider = new UnisatWalletProvider(address, this.defaults);
     return {
       address,
-      xChainType: this.xChainType
+      xChainType: "BITCOIN"
     };
   }
   async disconnect() {
+    this.walletProvider = void 0;
   }
-  get icon() {
-    return this._wallet.icon;
+  getWalletProvider() {
+    return this.walletProvider;
+  }
+  recreateWalletProvider(xAccount) {
+    if (!xAccount.address) return void 0;
+    return new UnisatWalletProvider(xAccount.address, this.defaults);
   }
 };
-
-// src/xchains/sui/SuiXService.ts
-var SuiXService = class _SuiXService extends XService {
-  // TODO: define suiAccount type
-  constructor() {
-    super("SUI");
+var XverseWalletProvider = class {
+  chainType = "BITCOIN";
+  address;
+  publicKey;
+  defaults;
+  constructor(address, publicKey, defaults) {
+    this.address = address;
+    this.publicKey = publicKey;
+    this.defaults = defaults;
   }
-  static getInstance() {
-    if (!_SuiXService.instance) {
-      _SuiXService.instance = new _SuiXService();
+  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;
     }
-    return _SuiXService.instance;
+    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;
   }
-  // getBalance is not used because getBalances uses getAllBalances which returns all balances
-  async getBalances(address, xTokens) {
-    if (!address) return {};
-    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 this.suiClient.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;
+  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)
         }
-      });
-      return tokenMap;
-    } catch (e) {
-      console.log("error", e);
-      return {};
+      ]
+    });
+    if (response.status === "error") {
+      throw new Error(response.error?.message || "Xverse sendTransfer failed");
     }
+    return response.result.txid;
   }
 };
-
-// src/xchains/sui/SuiXConnector.ts
-var SuiXConnector = class extends XConnector {
-  constructor(wallet) {
-    super("SUI", wallet?.name, wallet?.name);
-    this.wallet = wallet;
+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;
   }
-  getXService() {
-    return SuiXService.getInstance();
+  /** 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);
+    }
   }
-  async connect() {
-    return;
+  static isAvailable() {
+    return typeof window !== "undefined" && !!window.BitcoinProvider;
   }
-  async disconnect() {
+  get isInstalled() {
+    return _XverseXConnector.isAvailable();
   }
-  get icon() {
-    return this.wallet?.icon;
+  get installUrl() {
+    return WALLET_METADATA.xverse.installUrl;
   }
-};
-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 {
-  constructor() {
-    super("ICON");
-    this.iconService = new IconServiceConstructor(
-      new IconServiceConstructor.HttpProvider(CHAIN_INFO[1 /* MAINNET */].APIEndpoint)
-    );
+  get icon() {
+    return WALLET_METADATA.xverse.icon;
   }
-  static getInstance() {
-    if (!_IconXService.instance) {
-      _IconXService.instance = new _IconXService();
-    }
-    return _IconXService.instance;
+  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 getAggregateData(requireSuccess, calls) {
-    const rawTx = new IconBuilder.CallBuilder().to("cxa4aa9185e23558cff990f494c1fd2845f6cbf741").method("tryAggregate").params({ requireSuccess: IconConverter.toHex(requireSuccess ? 1 : 0), calls }).build();
+  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 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"];
+      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/hooks/useXConnection.ts
+function useXConnection({ xChainType } = {}) {
+  return useXWalletStore((state) => xChainType ? state.xConnections?.[xChainType] : void 0);
+}
+
+// src/hooks/useXAccount.ts
+function useXAccount({ xChainId, xChainType }) {
+  assert(!(xChainId && xChainType), "[useXAccount] pass either xChainId or xChainType, not both");
+  assert(xChainId || xChainType, "[useXAccount] pass xChainId or xChainType");
+  const target = xChainType ?? getXChainType(xChainId);
+  const xConnection = useXConnection({ xChainType: target });
+  return react.useMemo(
+    () => xConnection?.xAccount ?? { address: void 0, xChainType: target },
+    [target, xConnection]
+  );
+}
+
+// src/hooks/useEnabledChains.ts
+function useEnabledChains() {
+  return useXWalletStore((state) => state.enabledChains);
+}
+
+// src/hooks/useXConnections.ts
+function useXConnections() {
+  return useXWalletStore((state) => state.xConnections);
+}
+
+// src/hooks/useXAccounts.ts
+function useXAccounts() {
+  const enabledChains = useEnabledChains();
+  const xConnections = useXConnections();
+  return react.useMemo(() => {
+    const result = {};
+    for (const xChainType of enabledChains) {
+      const xConnection = xConnections[xChainType];
+      result[xChainType] = xConnection?.xAccount ?? { address: void 0, xChainType };
+    }
+    return result;
+  }, [enabledChains, xConnections]);
+}
+function useXConnect() {
+  const setXConnection = useXWalletStore((state) => state.setXConnection);
+  const actionsRegistry = useXWalletStore((state) => state.chainActions);
+  return reactQuery.useMutation({
+    mutationFn: async (xConnector) => {
+      const chainActions = actionsRegistry[xConnector.xChainType];
+      if (!chainActions) {
+        throw new Error(`Chain "${xConnector.xChainType}" is not enabled or ChainActions not registered`);
+      }
+      const xAccount = await chainActions.connect(xConnector.id);
+      if (xAccount) {
+        setXConnection(xConnector.xChainType, {
+          xAccount,
+          xConnectorId: xConnector.id
+        });
+      }
+      return xAccount;
+    }
+  });
+}
+
+// src/hooks/useXConnectors.ts
+var warnedChains = /* @__PURE__ */ new Set();
+function useXConnectors({ xChainType } = {}) {
+  return useXWalletStore((state) => {
+    if (!xChainType) return [];
+    if (!state.enabledChains.includes(xChainType) && !warnedChains.has(xChainType)) {
+      warnedChains.add(xChainType);
+      console.warn(
+        `[useXConnectors] chain "${xChainType}" is not enabled in SodaxWalletProvider config.chains \u2014 returning empty list`
+      );
+    }
+    return state.xConnectorsByChain[xChainType] ?? [];
+  });
+}
+
+// src/hooks/useXConnectorsByChain.ts
+function useXConnectorsByChain() {
+  return useXWalletStore((state) => state.xConnectorsByChain);
+}
+
+// src/utils/matchConnectorIdentifier.ts
+var SHORT_IDENTIFIER_THRESHOLD = 3;
+var warnedShortIdentifiers = /* @__PURE__ */ new Set();
+function matchesConnectorIdentifier(connector, identifier) {
+  const needle = identifier.toLowerCase();
+  if (needle.length > 0 && needle.length < SHORT_IDENTIFIER_THRESHOLD && !warnedShortIdentifiers.has(needle)) {
+    warnedShortIdentifiers.add(needle);
+    console.warn(
+      `[matchesConnectorIdentifier] identifier "${identifier}" is ${needle.length} chars \u2014 substring matching on short strings frequently hits unintended connectors. Use a more distinctive wallet brand name, or match a single connector via useXConnectors(chainType).find(c => c.id === '...') directly.`
+    );
+  }
+  return connector.id.toLowerCase().includes(needle) || connector.name.toLowerCase().includes(needle);
+}
+
+// src/hooks/useIsWalletInstalled.ts
+function useIsWalletInstalled(options) {
+  const xConnectorsByChain = useXWalletStore((s) => s.xConnectorsByChain);
+  return isAnyConnectorInstalled(options, xConnectorsByChain);
+}
+function isAnyConnectorInstalled(options, xConnectorsByChain) {
+  const { connectors: identifiers, chainType } = options;
+  if (identifiers === void 0 && chainType === void 0) {
+    console.warn(
+      "[useIsWalletInstalled] called without `connectors` or `chainType` \u2014 returning `false`. Supply at least one filter."
+    );
+    return false;
+  }
+  if (identifiers && identifiers.length === 0) return false;
+  const chainsToScan = chainType ? [xConnectorsByChain[chainType]] : Object.values(xConnectorsByChain);
+  for (const chainConnectors of chainsToScan) {
+    if (!chainConnectors) continue;
+    for (const connector of chainConnectors) {
+      if (!connector.isInstalled) continue;
+      if (!identifiers) return true;
+      if (identifiers.some((id) => matchesConnectorIdentifier(connector, id))) return true;
+    }
+  }
+  return false;
+}
+
+// src/utils/chainOrder.ts
+function compareChainByOrder(a, b, order) {
+  const ia = order.indexOf(a);
+  const ib = order.indexOf(b);
+  if (ia === -1 && ib === -1) return a.localeCompare(b);
+  if (ia === -1) return 1;
+  if (ib === -1) return -1;
+  return ia - ib;
+}
+
+// src/hooks/useChainGroups.ts
+function getSpokeChainKeysByType(chainType) {
+  const ids = [];
+  for (const chainKey of types.CHAIN_KEYS) {
+    if (types.baseChainInfo[chainKey].type === chainType) ids.push(chainKey);
+  }
+  return ids;
+}
+function buildChainGroups(enabledChains, xConnections, registry = chainRegistry, order) {
+  const chains = order ? [...enabledChains].sort((a, b) => compareChainByOrder(a, b, order)) : enabledChains;
+  return chains.map((chainType) => {
+    const factory = registry[chainType];
+    const connection = xConnections[chainType];
+    return {
+      chainType,
+      chainIds: getSpokeChainKeysByType(chainType),
+      displayName: factory?.displayName ?? chainType,
+      iconUrl: factory?.iconUrl,
+      isConnected: !!connection?.xAccount.address,
+      account: connection?.xAccount,
+      connectorId: connection?.xConnectorId
+    };
+  });
+}
+function useChainGroups({ order } = {}) {
+  const enabledChains = useEnabledChains();
+  const xConnections = useXConnections();
+  return react.useMemo(
+    () => buildChainGroups(enabledChains, xConnections, chainRegistry, order),
+    [enabledChains, xConnections, order]
+  );
+}
+function buildConnectedChains(xConnections, xConnectorsByChain, isReady = true, order) {
+  const chains = [];
+  for (const chainType of types.ChainTypeArr) {
+    const connection = xConnections[chainType];
+    if (!connection?.xAccount.address) continue;
+    const connectors = xConnectorsByChain[chainType] ?? [];
+    const connector = connectors.find((c) => c.id === connection.xConnectorId);
+    chains.push({
+      chainType,
+      account: connection.xAccount,
+      connectorId: connection.xConnectorId,
+      connectorName: connector?.name,
+      connectorIcon: connector?.icon
+    });
+  }
+  if (order) {
+    chains.sort((a, b) => compareChainByOrder(a.chainType, b.chainType, order));
+  }
+  return {
+    chains,
+    total: chains.length,
+    status: isReady ? "ready" : "loading"
+  };
+}
+function subscribeHydration(onChange) {
+  const unsubHydrate = useXWalletStore.persist.onHydrate(onChange);
+  const unsubFinish = useXWalletStore.persist.onFinishHydration(onChange);
+  return () => {
+    unsubHydrate();
+    unsubFinish();
+  };
+}
+function useConnectedChains({ order } = {}) {
+  const xConnections = useXConnections();
+  const xConnectorsByChain = useXConnectorsByChain();
+  const isReady = react.useSyncExternalStore(
+    subscribeHydration,
+    () => useXWalletStore.persist.hasHydrated(),
+    () => false
+  );
+  return react.useMemo(
+    () => buildConnectedChains(xConnections, xConnectorsByChain, isReady, order),
+    [xConnections, xConnectorsByChain, isReady, order]
+  );
+}
+function useXDisconnect() {
+  const actionsRegistry = useXWalletStore((state) => state.chainActions);
+  return react.useCallback(
+    async ({ xChainType }) => {
+      const chainActions = actionsRegistry[xChainType];
+      if (chainActions) {
+        await chainActions.disconnect();
+      } else {
+        console.warn(
+          `[useXDisconnect] No chain actions registered for "${xChainType}". Is it enabled in config.chains?`
+        );
+      }
+    },
+    [actionsRegistry]
+  );
+}
+
+// src/hooks/useConnectionFlow.ts
+function useConnectionFlow() {
+  const mutation = useXConnect();
+  const disconnect2 = useXDisconnect();
+  const [error, setError] = react.useState(null);
+  const [activeConnector, setActiveConnector] = react.useState(null);
+  const lastConnectorRef = react.useRef(null);
+  const connect = react.useCallback(
+    async (connector) => {
+      lastConnectorRef.current = connector;
+      setActiveConnector(connector);
+      setError(null);
+      try {
+        return await mutation.mutateAsync(connector);
+      } catch (raw) {
+        setError(raw instanceof Error ? raw : new Error(String(raw)));
+        return void 0;
+      }
+    },
+    [mutation]
+  );
+  const retry = react.useCallback(async () => {
+    const last = lastConnectorRef.current;
+    if (!last) return void 0;
+    return connect(last);
+  }, [connect]);
+  const reset = react.useCallback(() => {
+    mutation.reset();
+    setError(null);
+    setActiveConnector(null);
+    lastConnectorRef.current = null;
+  }, [mutation]);
+  const status = error ? "error" : mutation.isPending ? "connecting" : mutation.isSuccess ? "success" : "idle";
+  return {
+    status,
+    error,
+    activeConnector,
+    activeChainType: activeConnector?.xChainType ?? null,
+    connect,
+    disconnect: disconnect2,
+    retry,
+    reset
+  };
+}
+function resolveBatchTargets(connectors, connectorsByChain) {
+  const targets = [];
+  for (const chainType of types.ChainTypeArr) {
+    const chainConnectors = connectorsByChain[chainType];
+    if (!chainConnectors?.length) continue;
+    for (const identifier of connectors) {
+      const match = chainConnectors.find((c) => matchesConnectorIdentifier(c, identifier));
+      if (match) targets.push({ chainType, connector: match });
+    }
+  }
+  return targets;
+}
+async function runBatchConnect(targets, helpers) {
+  const successful = [];
+  const failed = [];
+  const skipped = [];
+  const finalized = /* @__PURE__ */ new Set();
+  const pendingError = /* @__PURE__ */ new Map();
+  const emit = (event) => {
+    if (!helpers.onProgress) return;
+    try {
+      helpers.onProgress(event);
+    } catch (err) {
+      console.error("[useBatchConnect] onProgress threw:", err);
+    }
+  };
+  for (const target of targets) {
+    if (finalized.has(target.chainType)) continue;
+    if (helpers.skipConnected && helpers.isConnected(target.chainType)) {
+      skipped.push(target.chainType);
+      finalized.add(target.chainType);
+      emit({ chainType: target.chainType, outcome: "skipped" });
+      continue;
+    }
+    try {
+      await helpers.connect(target.connector);
+      successful.push(target.chainType);
+      finalized.add(target.chainType);
+      pendingError.delete(target.chainType);
+      emit({ chainType: target.chainType, outcome: "success" });
+    } catch (raw) {
+      const error = raw instanceof Error ? raw : new Error(String(raw));
+      pendingError.set(target.chainType, error);
+      emit({ chainType: target.chainType, outcome: "failure", error });
+    }
+  }
+  for (const [chainType, error] of pendingError) {
+    if (!finalized.has(chainType)) failed.push({ chainType, error });
+  }
+  return { successful, failed, skipped };
+}
+function useBatchConnect({
+  connectors,
+  skipConnected = false,
+  onProgress
+}) {
+  assert(Array.isArray(connectors), "useBatchConnect: connectors must be an array");
+  const { mutateAsync: connect } = useXConnect();
+  const xConnectorsByChain = useXConnectorsByChain();
+  const xConnections = useXConnections();
+  const [status, setStatus] = react.useState("idle");
+  const [result, setResult] = react.useState(null);
+  const inFlightRef = react.useRef(null);
+  const onProgressRef = react.useRef(onProgress);
+  onProgressRef.current = onProgress;
+  const run = react.useCallback(async () => {
+    if (inFlightRef.current) return inFlightRef.current;
+    const batchPromise = (async () => {
+      setStatus("running");
+      const targets = resolveBatchTargets(connectors, xConnectorsByChain);
+      const finalResult = await runBatchConnect(targets, {
+        connect,
+        isConnected: (chainType) => !!xConnections[chainType]?.xAccount.address,
+        skipConnected,
+        onProgress: (event) => onProgressRef.current?.(event)
       });
-      return data;
+      setResult(finalResult);
+      setStatus("done");
+      return finalResult;
+    })();
+    inFlightRef.current = batchPromise;
+    try {
+      return await batchPromise;
+    } finally {
+      inFlightRef.current = null;
+    }
+  }, [connect, connectors, xConnectorsByChain, xConnections, skipConnected]);
+  const reset = react.useCallback(() => {
+    setStatus("idle");
+    setResult(null);
+  }, []);
+  return { run, status, result, reset };
+}
+function resolveDisconnectTargets(connectors, xConnections, xConnectorsByChain) {
+  const targets = [];
+  for (const chainType of types.ChainTypeArr) {
+    const connection = xConnections[chainType];
+    if (!connection?.xAccount.address) continue;
+    if (!connectors) {
+      targets.push(chainType);
+      continue;
+    }
+    const activeConnector = xConnectorsByChain[chainType]?.find((c) => c.id === connection.xConnectorId);
+    if (!activeConnector) continue;
+    if (connectors.some((identifier) => matchesConnectorIdentifier(activeConnector, identifier))) {
+      targets.push(chainType);
+    }
+  }
+  return targets;
+}
+async function runBatchDisconnect(chainTypes, disconnect2, onProgress) {
+  const successful = [];
+  const failed = [];
+  const emit = (event) => {
+    if (!onProgress) return;
+    try {
+      onProgress(event);
     } catch (err) {
-      console.error(err);
-      return Array(calls.length).fill(null);
+      console.error("[useBatchDisconnect] onProgress threw:", err);
+    }
+  };
+  for (const chainType of chainTypes) {
+    try {
+      await disconnect2({ xChainType: chainType });
+      successful.push(chainType);
+      emit({ chainType, outcome: "success" });
+    } catch (raw) {
+      const error = raw instanceof Error ? raw : new Error(String(raw));
+      failed.push({ chainType, error });
+      emit({ chainType, outcome: "failure", error });
+    }
+  }
+  return { successful, failed };
+}
+function useBatchDisconnect({
+  connectors,
+  onProgress
+} = {}) {
+  const disconnect2 = useXDisconnect();
+  const xConnections = useXConnections();
+  const xConnectorsByChain = useXConnectorsByChain();
+  const [status, setStatus] = react.useState("idle");
+  const [result, setResult] = react.useState(null);
+  const inFlightRef = react.useRef(null);
+  const onProgressRef = react.useRef(onProgress);
+  onProgressRef.current = onProgress;
+  const run = react.useCallback(async () => {
+    if (inFlightRef.current) return inFlightRef.current;
+    const batchPromise = (async () => {
+      setStatus("running");
+      const targets = resolveDisconnectTargets(connectors, xConnections, xConnectorsByChain);
+      const finalResult = await runBatchDisconnect(targets, disconnect2, (event) => onProgressRef.current?.(event));
+      setResult(finalResult);
+      setStatus("done");
+      return finalResult;
+    })();
+    inFlightRef.current = batchPromise;
+    try {
+      return await batchPromise;
+    } finally {
+      inFlightRef.current = null;
+    }
+  }, [connectors, disconnect2, xConnections, xConnectorsByChain]);
+  const reset = react.useCallback(() => {
+    setStatus("idle");
+    setResult(null);
+  }, []);
+  return { run, status, result, reset };
+}
+var useWalletModalStore = 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/useWalletModal.ts
+var DEFAULT_HYDRATION_TIMEOUT_MS = 5e3;
+function waitForXConnection(chainType, expectedConnectorId, timeoutMs = DEFAULT_HYDRATION_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const matches = (connection) => connection?.xConnectorId === expectedConnectorId && !!connection?.xAccount?.address;
+    const finish = (account) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      unsubscribe();
+      resolve(account);
+    };
+    const timer = setTimeout(() => finish(void 0), timeoutMs);
+    const unsubscribe = useXWalletStore.subscribe((state) => {
+      const connection = state.xConnections[chainType];
+      if (matches(connection)) finish(connection?.xAccount);
+    });
+    const initial = useXWalletStore.getState().xConnections[chainType];
+    if (matches(initial)) finish(initial?.xAccount);
+  });
+}
+function useWalletModal({
+  onConnected,
+  hydrationTimeoutMs
+} = {}) {
+  const state = useWalletModalStore((s) => s.walletModal);
+  const open = useWalletModalStore((s) => s.open);
+  const close = useWalletModalStore((s) => s.close);
+  const back = useWalletModalStore((s) => s.back);
+  const selectChain = useWalletModalStore((s) => s.selectChain);
+  const setConnecting = useWalletModalStore((s) => s.setConnecting);
+  const setSuccess = useWalletModalStore((s) => s.setSuccess);
+  const setError = useWalletModalStore((s) => s.setError);
+  const { mutateAsync: connect } = useXConnect();
+  const inFlightRef = react.useRef(null);
+  const selectWallet = react.useCallback(
+    async (connector) => {
+      if (inFlightRef.current?.connector === connector) {
+        return inFlightRef.current.promise;
+      }
+      if (!connector.isInstalled) {
+        const installHint = connector.installUrl ? " Install the extension and reload the page." : "";
+        setError(
+          connector.xChainType,
+          connector,
+          new Error(`${connector.name} is not installed.${installHint}`)
+        );
+        return void 0;
+      }
+      const isStillCurrent = () => {
+        const current = useWalletModalStore.getState().walletModal;
+        return current.kind === "connecting" && current.connector === connector;
+      };
+      const promise = (async () => {
+        setConnecting(connector.xChainType, connector);
+        try {
+          const direct = await connect(connector);
+          if (!isStillCurrent()) return void 0;
+          const account = direct?.address ? direct : await waitForXConnection(connector.xChainType, connector.id, hydrationTimeoutMs);
+          if (!isStillCurrent()) return void 0;
+          if (account?.address) {
+            setSuccess(connector.xChainType, connector, account);
+            try {
+              await onConnected?.(connector.xChainType, account);
+            } catch (callbackError) {
+              console.error("[useWalletModal] onConnected threw \u2014 connection is still successful:", callbackError);
+            }
+            return account;
+          }
+          setError(
+            connector.xChainType,
+            connector,
+            new Error("Connection did not complete. Did you close the wallet popup?")
+          );
+          return void 0;
+        } catch (raw) {
+          if (!isStillCurrent()) return void 0;
+          const error = raw instanceof Error ? raw : new Error(String(raw));
+          setError(connector.xChainType, connector, error);
+          return void 0;
+        } finally {
+          if (inFlightRef.current?.connector === connector) {
+            inFlightRef.current = null;
+          }
+        }
+      })();
+      inFlightRef.current = { connector, promise };
+      return promise;
+    },
+    [connect, onConnected, hydrationTimeoutMs, setConnecting, setError, setSuccess]
+  );
+  const retry = react.useCallback(async () => {
+    if (state.kind !== "error") return void 0;
+    return selectWallet(state.connector);
+  }, [state, selectWallet]);
+  return { state, open, close, back, selectChain, selectWallet, retry };
+}
+
+// src/hooks/useXService.ts
+function useXService({ xChainType } = {}) {
+  const xService = useXWalletStore((state) => xChainType ? state.xServices[xChainType] : void 0);
+  return xService;
+}
+
+// src/hooks/useXServices.ts
+function useXServices() {
+  return useXWalletStore((state) => state.xServices);
+}
+var WalletConfigContext = react.createContext(null);
+var WalletConfigProvider = WalletConfigContext.Provider;
+function useWalletConfig() {
+  const config = react.useContext(WalletConfigContext);
+  if (!config) {
+    throw new Error("useWalletConfig must be used within SodaxWalletProvider");
+  }
+  return config;
+}
+function useIsChainEnabled(chainType) {
+  const config = useWalletConfig();
+  return config[chainType] !== void 0;
+}
+function useEnabledChainTypes() {
+  const config = useWalletConfig();
+  return Object.keys(config).filter((t) => config[t] !== void 0);
+}
+function useEthereumChainId() {
+  const xService = useXService({ xChainType: "INJECTIVE" });
+  const injectiveXService = xService instanceof InjectiveXService ? xService : void 0;
+  const [ethereumChainId, setEthereumChainId] = react.useState(null);
+  react.useEffect(() => {
+    if (!injectiveXService?.walletStrategy?.getWallet()) return;
+    const walletStrategy = injectiveXService.walletStrategy;
+    if (walletStrategy.getWallet() !== walletBase.Wallet.Metamask) return;
+    const getEthereumChainId = async () => {
+      try {
+        const chainId = await walletStrategy.getEthereumChainId();
+        setEthereumChainId(Number.parseInt(chainId));
+      } catch (error) {
+        console.warn("Failed to get Ethereum chain ID:", error);
+      }
+    };
+    getEthereumChainId();
+    try {
+      const strategy = walletStrategy.getStrategy();
+      const isEvmStrategy = isRecord(strategy) && hasFunctionProperty(strategy, "onChainIdChanged");
+      assert(isEvmStrategy, "[useEthereumChainId] walletStrategy.getStrategy() is not an EvmWalletStrategy");
+      strategy.onChainIdChanged(getEthereumChainId);
+    } catch (error) {
+      console.warn("Failed to subscribe to chain ID changes:", error);
+    }
+  }, [injectiveXService?.walletStrategy]);
+  return ethereumChainId;
+}
+var EVM_DISABLED_RESULT = { isWrongChain: false, handleSwitchChain: () => {
+} };
+var isEip1193Provider = (value) => {
+  return isRecord(value) && hasFunctionProperty(value, "request") && hasFunctionProperty(value, "on");
+};
+var getInjectedEthereumProvider = () => {
+  const maybeEthereum = window.ethereum;
+  assert(isEip1193Provider(maybeEthereum), "[useEvmSwitchChain] window.ethereum is not an EIP-1193 provider");
+  return maybeEthereum;
+};
+var switchEthereumChain = async () => {
+  const metamaskProvider = getInjectedEthereumProvider();
+  return await Promise.race([
+    metamaskProvider.request({
+      method: "wallet_switchEthereumChain",
+      params: [{ chainId: "0x1" }]
+    }),
+    new Promise((resolve) => {
+      const handler = (chainId) => {
+        if (chainId === "0x1") {
+          metamaskProvider.removeListener("chainChanged", handler);
+          resolve();
+        }
+      };
+      metamaskProvider.on("chainChanged", handler);
+    })
+  ]);
+};
+function useEvmSwitchChain({ xChainId }) {
+  const evmEnabled = useIsChainEnabled("EVM");
+  if (!evmEnabled) {
+    return EVM_DISABLED_RESULT;
+  }
+  return useEvmSwitchChainInner({ xChainId });
+}
+function useEvmSwitchChainInner({ xChainId }) {
+  const xChainType = getXChainType(xChainId);
+  const expectedChainId = types.baseChainInfo[xChainId].chainId;
+  if (xChainType === "EVM") {
+    assert(typeof expectedChainId === "number", "[useEvmSwitchChain] EVM chain must have numeric chainId");
+  }
+  const xService = useXService({ xChainType: "INJECTIVE" });
+  const injectiveXService = xService instanceof InjectiveXService ? xService : void 0;
+  const ethereumChainId = useEthereumChainId();
+  const { chainId } = wagmi.useAccount();
+  const isWrongChain = react.useMemo(() => {
+    return xChainType === "EVM" && chainId !== expectedChainId || xChainType === "INJECTIVE" && injectiveXService !== void 0 && injectiveXService.walletStrategy.getWallet() === walletBase.Wallet.Metamask && ethereumChainId !== chains.mainnet.id;
+  }, [xChainType, chainId, expectedChainId, ethereumChainId, injectiveXService]);
+  const { switchChain } = wagmi.useSwitchChain();
+  const handleSwitchChain = react.useCallback(() => {
+    if (xChainType === "INJECTIVE") {
+      switchEthereumChain();
+    } else if (xChainType === "EVM" && typeof expectedChainId === "number") {
+      switchChain({ chainId: expectedChainId });
+    }
+  }, [switchChain, expectedChainId, xChainType]);
+  return react.useMemo(
+    () => ({
+      isWrongChain,
+      handleSwitchChain
+    }),
+    [isWrongChain, handleSwitchChain]
+  );
+}
+
+// src/hooks/useWalletProvider.ts
+var warnedChains2 = /* @__PURE__ */ new Set();
+function useWalletProvider({
+  xChainId,
+  xChainType
+} = {}) {
+  assert(!(xChainId && xChainType), "[useWalletProvider] pass either xChainId or xChainType, not both");
+  const target = xChainType ?? (xChainId ? getXChainType(xChainId) : void 0);
+  return useXWalletStore((state) => {
+    if (!target) return void 0;
+    if (!state.enabledChains.includes(target) && !warnedChains2.has(target)) {
+      warnedChains2.add(target);
+      console.warn(
+        `[useWalletProvider] chain "${target}" is not enabled in SodaxWalletProvider config.chains \u2014 returning undefined`
+      );
+    }
+    return state.getWalletProvider(target);
+  });
+}
+function useXSignMessage() {
+  const actionsRegistry = useXWalletStore((state) => state.chainActions);
+  return reactQuery.useMutation({
+    mutationFn: async ({ xChainType, message }) => {
+      const chainActions = actionsRegistry[xChainType];
+      if (!chainActions?.signMessage) {
+        console.warn(`[useXSignMessage] signMessage not supported for chain "${xChainType}"`);
+        return void 0;
+      }
+      return await chainActions.signMessage(message);
+    }
+  });
+}
+
+// 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 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());
+  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 cds = nonNativeXTokens.map((token) => {
-      return {
-        target: token.address,
-        method: "balanceOf",
-        params: [address]
-      };
+    const res = await provider.callFunction({
+      contractId: xToken.address,
+      method: "ft_balance_of",
+      args: { account_id: address }
     });
-    const data = await this.getAggregateData(
-      false,
-      cds.filter((cd) => cd.target.startsWith("cx"))
-    );
-    return nonNativeXTokens.reduce((agg, token, idx) => {
-      const balance = data[idx];
-      balances[token.address] = BigInt(balance);
-      return agg;
-    }, balances);
+    return BigInt(res ?? 0);
   }
 };
 
-// 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 IconHanaXConnector = class extends XConnector {
-  constructor() {
-    super("ICON", "Hana Wallet", "hana");
+// 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 { hanaWallet } = window;
-    if (window && !hanaWallet && !hanaWallet?.isAvailable) {
-      window.open("https://chromewebstore.google.com/detail/hana-wallet/jfdlamikmbghhapbgfoogdffldioobgl", "_blank");
-      return;
-    }
-    const detail = await request({
-      type: "REQUEST_ADDRESS" /* REQUEST_ADDRESS */
-    });
-    if (detail?.type === "RESPONSE_ADDRESS" /* RESPONSE_ADDRESS */) {
-      return {
-        address: detail?.payload,
-        xChainType: this.xChainType
-      };
+    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 void 0;
+    return {
+      address: accounts[0].accountId,
+      xChainType: this.xChainType
+    };
   }
   async disconnect() {
-    console.log("HanaIconXConnector disconnected");
+    const walletSelector = this.getXService().walletSelector;
+    await walletSelector.disconnect(this._wallet);
   }
   get icon() {
-    return "https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/hana.svg";
+    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;
@@ -1226,14 +2304,15 @@ var StacksXConnector = class extends XConnector {
   async connect() {
     const provider = this.getProvider();
     if (!provider) {
-      if (this.config.installUrl) {
-        window.open(this.config.installUrl, "_blank");
-      }
-      return void 0;
+      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 {
@@ -1247,6 +2326,13 @@ var StacksXConnector = class extends XConnector {
   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);
   }
@@ -1283,258 +2369,553 @@ var STACKS_PROVIDERS = [
     installUrl: "https://chromewebstore.google.com/detail/fordefi/hcmehenccjdmfbojapcbcofkgdpbnlle"
   }
 ];
-function useStacksXConnectors() {
-  return React2.useMemo(() => STACKS_PROVIDERS.map((config) => new StacksXConnector(config)), []);
-}
 
-// src/useXWagmiStore.ts
-var initXServices = () => {
+// 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 = {};
-  ["EVM", "BITCOIN", "INJECTIVE", "STELLAR", "SUI", "SOLANA", "ICON", "NEAR", "STACKS"].forEach((key) => {
-    const xChainType = key;
-    switch (xChainType) {
-      // EVM, SUI, Solana wallet connectors are supported by their own sdks. wagmi, @mysten/dapp-kit, @solana/wallet-adapter-react.
-      case "EVM":
-        xServices[xChainType] = EvmXService.getInstance();
-        xServices[xChainType].setXConnectors([]);
-        break;
-      case "SUI":
-        xServices[xChainType] = SuiXService.getInstance();
-        xServices[xChainType].setXConnectors([]);
-        break;
-      case "SOLANA":
-        xServices[xChainType] = SolanaXService.getInstance();
-        xServices[xChainType].setXConnectors([]);
-        break;
-      case "BITCOIN":
-        xServices[xChainType] = BitcoinXService.getInstance();
-        xServices[xChainType].setXConnectors([new UnisatXConnector(), new XverseXConnector(), new OKXXConnector()]);
-        break;
-      // Injective, Stellar, Icon wallet connectors are supported by sodax wallet-sdk-react sdk.
-      case "INJECTIVE":
-        xServices[xChainType] = InjectiveXService.getInstance();
-        xServices[xChainType].setXConnectors([
-          // EVM wallets (auto-detected via EIP-6963)
-          new InjectiveXConnector("MetaMask", walletBase.Wallet.Metamask),
-          // Cosmos wallets (detected via window globals)
-          new InjectiveXConnector("Keplr", walletBase.Wallet.Keplr),
-          new InjectiveXConnector("Leap", walletBase.Wallet.Leap)
-        ]);
-        break;
-      case "STELLAR":
-        xServices[xChainType] = StellarXService.getInstance();
-        xServices[xChainType].setXConnectors([]);
-        break;
-      case "ICON":
-        xServices[xChainType] = IconXService.getInstance();
-        xServices[xChainType].setXConnectors([new IconHanaXConnector()]);
-        break;
-      case "NEAR":
-        xServices[xChainType] = NearXService.getInstance();
-        xServices[xChainType].setXConnectors([]);
-        break;
-      case "STACKS":
-        xServices[xChainType] = StacksXService.getInstance();
-        xServices[xChainType].setXConnectors(STACKS_PROVIDERS.map((config) => new StacksXConnector(config)));
-        break;
+  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;
+  }
+  return { xServices, xConnectorsByChain, enabledChains, chainActions };
 };
-var useXWagmiStore = zustand.create()(
+
+// src/useXWalletStore.ts
+var useXWalletStore = zustand.create()(
   middleware.devtools(
     middleware.persist(
       immer.immer((set, get) => ({
-        xServices: initXServices(),
+        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 })
+        partialize: (state) => ({
+          xConnections: state.xConnections,
+          userDisconnected: state.userDisconnected
+        })
       }
     ),
     { name: "xwagmi-store" }
   )
 );
 
-// src/hooks/useXConnection.ts
-function useXConnection(xChainType) {
-  const xConnection = useXWagmiStore((state) => xChainType ? state.xConnections?.[xChainType] : void 0);
-  const evmConnections = wagmi.useConnections();
-  const { address: evmAddress } = wagmi.useAccount();
-  const suiAccount = dappKit.useCurrentAccount();
-  const suiCurrentWallet = dappKit.useCurrentWallet();
-  const solanaWallet = walletAdapterReact.useWallet();
-  const xConnection2 = React2.useMemo(() => {
-    if (!xChainType) {
-      return void 0;
-    }
-    switch (xChainType) {
-      case "EVM":
-        return {
-          xAccount: { address: evmAddress, xChainType },
-          xConnectorId: evmConnections?.[0]?.connector.id
-        };
-      case "SUI":
-        if (suiCurrentWallet.currentWallet && suiCurrentWallet.connectionStatus === "connected") {
-          return {
-            xAccount: { address: suiAccount?.address, xChainType },
-            xConnectorId: suiCurrentWallet.currentWallet.name
-          };
-        }
-        return void 0;
-      case "SOLANA":
-        if (solanaWallet.connected) {
-          return {
-            xAccount: { address: solanaWallet.publicKey?.toString(), xChainType },
-            xConnectorId: `${solanaWallet.wallet?.adapter.name}`
-          };
-        }
-        return void 0;
-      default:
-        return xConnection;
-    }
-  }, [xChainType, xConnection, evmAddress, suiAccount, evmConnections, suiCurrentWallet, solanaWallet]);
-  return xConnection2;
-}
-
-// src/hooks/useXAccount.ts
-function isChainType(chainIdentifier) {
-  return types.ChainTypeArr.includes(chainIdentifier);
-}
-function useXAccount(chainIdentifier) {
-  const resolvedChainType = chainIdentifier ? isChainType(chainIdentifier) ? chainIdentifier : getXChainType(chainIdentifier) : void 0;
-  const xConnection = useXConnection(resolvedChainType);
-  const xAccount = React2.useMemo(() => {
-    if (!resolvedChainType) {
-      return {
-        address: void 0,
-        xChainType: void 0
-      };
-    }
-    return xConnection?.xAccount || { address: void 0, xChainType: resolvedChainType };
-  }, [resolvedChainType, xConnection]);
-  return xAccount;
+// src/actions/getXService.ts
+function getXService(xChainType) {
+  const service = useXWalletStore.getState().xServices[xChainType];
+  if (!service) {
+    throw new Error(`XService for chain type "${xChainType}" is not initialized. Is the chain enabled in config?`);
+  }
+  return service;
 }
-function useXAccounts() {
-  const xChainTypes = useXWagmiStore((state) => Object.keys(state.xServices));
-  const xConnections = useXWagmiStore((state) => state.xConnections);
-  const { address: evmAddress } = wagmi.useAccount();
-  const suiAccount = dappKit.useCurrentAccount();
-  const solanaWallet = walletAdapterReact.useWallet();
-  const xAccounts = React2.useMemo(() => {
-    const result = {};
-    for (const xChainType of xChainTypes) {
-      const xConnection = xConnections[xChainType];
-      if (xConnection?.xAccount) {
-        result[xChainType] = xConnection.xAccount;
-      } else {
-        result[xChainType] = {
-          address: void 0,
-          xChainType
-        };
-      }
-    }
-    if (evmAddress) {
-      result["EVM"] = {
-        address: evmAddress,
-        xChainType: "EVM"
-      };
-    }
-    if (suiAccount) {
-      result["SUI"] = {
-        address: suiAccount.address,
-        xChainType: "SUI"
-      };
-    }
-    if (solanaWallet.publicKey) {
-      result["SOLANA"] = {
-        address: solanaWallet.publicKey.toString(),
-        xChainType: "SOLANA"
-      };
+var EvmHydrator = () => {
+  const wagmiConfig = wagmi.useConfig();
+  const connectors = wagmi.useConnectors();
+  const { address, status, connector } = wagmi.useAccount();
+  const evmPublicClient = wagmi.usePublicClient();
+  const { data: evmWalletClient } = wagmi.useWalletClient();
+  const setXConnection = useXWalletStore((state) => state.setXConnection);
+  const unsetXConnection = useXWalletStore((state) => state.unsetXConnection);
+  const setWalletProvider = useXWalletStore((state) => state.setWalletProvider);
+  const userDisconnectedEvm = useXWalletStore((state) => state.userDisconnected.EVM);
+  const { reconnect } = wagmi.useReconnect();
+  const walletConfig = useWalletConfig();
+  react.useEffect(() => {
+    if (wagmiConfig) {
+      EvmXService.getInstance().wagmiConfig = wagmiConfig;
     }
-    return result;
-  }, [xChainTypes, xConnections, evmAddress, suiAccount, solanaWallet]);
-  return xAccounts;
-}
-function useXConnect() {
-  const setXConnection = useXWagmiStore((state) => state.setXConnection);
-  const { connectAsync: evmConnectAsync } = wagmi.useConnect();
-  const { mutateAsync: suiConnectAsync } = dappKit.useConnectWallet();
-  const { select, connect } = walletAdapterReact.useWallet();
-  return reactQuery.useMutation({
-    mutationFn: async (xConnector) => {
-      const xChainType = xConnector.xChainType;
-      let xAccount;
-      switch (xChainType) {
-        case "EVM":
-          await evmConnectAsync({ connector: xConnector.connector });
-          break;
-        case "SUI":
-          await suiConnectAsync({ wallet: xConnector.wallet });
-          break;
-        case "SOLANA": {
-          const walletName = xConnector.wallet.adapter.name;
-          select(walletName);
-          const adapter = xConnector.wallet.adapter;
-          if (!adapter) throw new Error("No adapter found for Solana wallet");
-          if (walletName === "MetaMask") {
-            await new Promise((resolve, reject) => {
-              const timeout = setTimeout(() => {
-                cleanup();
-                reject(new Error("Wallet connection timeout"));
-              }, 3e4);
-              const handleConnect = () => {
-                cleanup();
-                resolve();
-              };
-              const handleError = (error) => {
-                cleanup();
-                reject(error);
-              };
-              const cleanup = () => {
-                clearTimeout(timeout);
-                adapter.off("connect", handleConnect);
-                adapter.off("error", handleError);
-              };
-              adapter.on("connect", handleConnect);
-              adapter.on("error", handleError);
-              connect().catch((err) => {
-                cleanup();
-                reject(err);
-              });
-            });
+  }, [wagmiConfig]);
+  const evmConnectors = react.useMemo(() => connectors.map((c) => new EvmXConnector(c)), [connectors]);
+  react.useEffect(() => {
+    EvmXService.getInstance().setXConnectors(evmConnectors);
+    useXWalletStore.getState().setXConnectors("EVM", evmConnectors);
+  }, [evmConnectors]);
+  const [hydrated, setHydrated] = react.useState(() => useXWalletStore.persist.hasHydrated());
+  react.useEffect(() => {
+    if (hydrated) return;
+    const unsub = useXWalletStore.persist.onFinishHydration(() => setHydrated(true));
+    return unsub;
+  }, [hydrated]);
+  react.useEffect(() => {
+    if (!hydrated) return;
+    if (status !== "disconnected") return;
+    const state = useXWalletStore.getState();
+    if (!state.xConnections.EVM) return;
+    if (state.userDisconnected.EVM) return;
+    reconnect();
+  }, [hydrated, connectors, status, reconnect]);
+  const wasConnectedRef = react.useRef(false);
+  react.useEffect(() => {
+    if (status === "connecting" || status === "reconnecting") return;
+    if (status === "connected" && address && connector) {
+      if (userDisconnectedEvm) return;
+      wasConnectedRef.current = true;
+      setXConnection("EVM", {
+        xAccount: { address, xChainType: "EVM" },
+        xConnectorId: connector.id
+      });
+    } else if (status === "disconnected" && wasConnectedRef.current) {
+      wasConnectedRef.current = false;
+      unsetXConnection("EVM");
+    }
+  }, [address, status, connector, userDisconnectedEvm, setXConnection, unsetXConnection]);
+  const walletProvider = react.useMemo(() => {
+    if (!evmPublicClient || !evmWalletClient) return void 0;
+    if (userDisconnectedEvm) return void 0;
+    const defaults = resolveEvmDefaults(evmWalletClient.chain.id, walletConfig.EVM?.chains);
+    return new walletSdkCore.EvmWalletProvider({
+      walletClient: evmWalletClient,
+      publicClient: evmPublicClient,
+      defaults
+    });
+  }, [evmPublicClient, evmWalletClient, walletConfig.EVM?.chains, userDisconnectedEvm]);
+  react.useEffect(() => {
+    setWalletProvider("EVM", walletProvider);
+  }, [walletProvider, setWalletProvider]);
+  return null;
+};
+var EvmActions = () => {
+  const wagmiConfig = wagmi.useConfig();
+  const { connectAsync } = wagmi.useConnect();
+  const { disconnectAsync } = wagmi.useDisconnect();
+  const { signMessageAsync } = wagmi.useSignMessage();
+  const registerChainActions = useXWalletStore((state) => state.registerChainActions);
+  const connectRef = react.useRef(connectAsync);
+  const disconnectRef = react.useRef(disconnectAsync);
+  const signMessageRef = react.useRef(signMessageAsync);
+  const wagmiConfigRef = react.useRef(wagmiConfig);
+  react.useEffect(() => {
+    connectRef.current = connectAsync;
+    disconnectRef.current = disconnectAsync;
+    signMessageRef.current = signMessageAsync;
+    wagmiConfigRef.current = wagmiConfig;
+  }, [connectAsync, disconnectAsync, signMessageAsync, wagmiConfig]);
+  react.useEffect(() => {
+    registerChainActions("EVM", {
+      connect: async (xConnectorId) => {
+        const connector = wagmiConfigRef.current.connectors.find((c) => c.id === xConnectorId);
+        if (!connector) {
+          console.warn(
+            `[EvmActions] connect: connector "${xConnectorId}" not found in wagmi config`,
+            wagmiConfigRef.current.connectors.map((c) => c.id)
+          );
+          return void 0;
+        }
+        useXWalletStore.getState().clearUserDisconnected("EVM");
+        try {
+          await connectRef.current({ connector });
+        } catch (error) {
+          if (error instanceof Error && error.name === "ConnectorAlreadyConnectedError") {
+            return void 0;
           }
-          break;
+          throw error;
+        }
+        return void 0;
+      },
+      disconnect: async () => {
+        const store = useXWalletStore.getState();
+        store.unsetXConnection("EVM");
+        store.markUserDisconnected("EVM");
+        try {
+          await disconnectRef.current();
+        } catch (error) {
+          console.warn("[EvmActions] wagmi disconnect failed (zustand already cleared):", error);
         }
-        default:
-          xAccount = await xConnector.connect();
-          break;
+      },
+      getConnectors: () => useXWalletStore.getState().xConnectorsByChain.EVM ?? [],
+      getConnection: () => useXWalletStore.getState().xConnections.EVM,
+      signMessage: async (message) => {
+        const signature = await signMessageRef.current({ message });
+        return signature;
       }
-      if (xAccount) {
-        setXConnection(xConnector.xChainType, {
-          xAccount,
-          xConnectorId: xConnector.id
-        });
+    });
+  }, [registerChainActions]);
+  return null;
+};
+var EvmProvider = ({ children, config }) => {
+  const reconnectOnMount = config.reconnectOnMount ?? EVM_DEFAULT_RECONNECT_ON_MOUNT;
+  const ssr = config.ssr ?? EVM_DEFAULT_SSR;
+  const queryClientRef = react.useRef(null);
+  if (!queryClientRef.current) {
+    queryClientRef.current = new reactQuery.QueryClient();
+  }
+  const walletConnectConfig = config.walletConnect;
+  const wagmiConfig = react.useMemo(() => {
+    const connectors$1 = [];
+    if (walletConnectConfig) {
+      if (walletConnectConfig.projectId) {
+        connectors$1.push(connectors.walletConnect({ showQrModal: true, ...walletConnectConfig }));
+      } else {
+        console.warn("[wallet-sdk-react] walletConnect.projectId is required \u2014 WalletConnect connector skipped.");
       }
-      return xAccount;
     }
-  });
-}
+    return createWagmiConfig(config.chains, { ssr, connectors: connectors$1 });
+  }, [config.chains, reconnectOnMount, ssr, walletConnectConfig]);
+  return /* @__PURE__ */ jsxRuntime.jsx(reactQuery.QueryClientProvider, { client: queryClientRef.current, children: /* @__PURE__ */ jsxRuntime.jsxs(wagmi.WagmiProvider, { reconnectOnMount, config: wagmiConfig, initialState: config.initialState, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(EvmHydrator, {}),
+    /* @__PURE__ */ jsxRuntime.jsx(EvmActions, {}),
+    children
+  ] }) });
+};
 
 // src/xchains/solana/SolanaXConnector.ts
 var SolanaXConnector = class extends XConnector {
+  wallet;
   constructor(wallet) {
     super("SOLANA", wallet?.adapter.name, wallet?.adapter.name);
     this.wallet = wallet;
@@ -1550,598 +2931,407 @@ var SolanaXConnector = class extends XConnector {
   get icon() {
     return this.wallet?.adapter.icon;
   }
-};
-var useStellarXConnectors = () => {
-  const xService = useXService("STELLAR");
-  return reactQuery.useQuery({
-    queryKey: ["stellar-wallets", xService],
-    queryFn: async () => {
-      if (!xService) {
-        return [];
-      }
-      const wallets = await xService.walletsKit.getSupportedWallets();
-      return wallets.filter((wallet) => wallet.isAvailable).map((wallet) => new StellarWalletsKitXConnector(wallet));
-    }
-  });
-};
-
-// src/hooks/useXService.ts
-function useXService(xChainType) {
-  const xService = useXWagmiStore((state) => xChainType ? state.xServices[xChainType] : void 0);
-  return xService;
-}
-
-// src/xchains/near/NearXConnector.ts
-var NearXConnector = class extends XConnector {
-  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) {
-      return void 0;
-    }
-    return {
-      address: accounts[0].accountId,
-      xChainType: this.xChainType
-    };
-  }
-  async disconnect() {
-    const walletSelector = this.getXService().walletSelector;
-    await walletSelector.disconnect(this._wallet);
+  get isInstalled() {
+    const state = this.wallet?.readyState;
+    return state === "Installed" || state === "Loadable";
   }
-  get icon() {
-    return this._wallet.manifest.icon;
+  get installUrl() {
+    return this.wallet?.adapter.url;
   }
 };
 
-// src/xchains/near/useNearXConnectors.ts
-var useNearXConnectors = () => {
-  const xService = useXService("NEAR");
-  return reactQuery.useQuery({
-    queryKey: ["near-wallets"],
-    queryFn: async () => {
-      if (!xService) {
-        return [];
-      }
-      await xService.walletSelector.whenManifestLoaded;
-      const wallets = xService.walletSelector.availableWallets;
-      return wallets.map((wallet) => new NearXConnector(wallet));
-    }
-  });
-};
-
-// src/hooks/useXConnectors.ts
-function useXConnectors(xChainType) {
-  const xService = useXService(xChainType);
-  const evmConnectors = wagmi.useConnectors();
-  const suiWallets = dappKit.useWallets();
-  const { data: stellarXConnectors } = useStellarXConnectors();
-  const { data: nearXConnectors } = useNearXConnectors();
-  const stacksXConnectors = useStacksXConnectors();
-  const { wallets: solanaWallets } = walletAdapterReact.useWallet();
-  const xConnectors = React2.useMemo(() => {
-    if (!xChainType || !xService) {
-      return [];
-    }
-    switch (xChainType) {
-      case "EVM":
-        return evmConnectors.map((connector) => new EvmXConnector(connector));
-      case "SUI":
-        return suiWallets.map((wallet) => new SuiXConnector(wallet));
-      case "STELLAR":
-        return stellarXConnectors || [];
-      case "SOLANA":
-        return solanaWallets.filter((wallet) => wallet.readyState === "Installed").map((wallet) => new SolanaXConnector(wallet));
-      case "NEAR":
-        return nearXConnectors || [];
-      case "STACKS":
-        return stacksXConnectors;
-      default:
-        return xService.getXConnectors();
-    }
-  }, [
-    xService,
-    xChainType,
-    evmConnectors,
-    suiWallets,
-    stellarXConnectors,
-    solanaWallets,
-    nearXConnectors,
-    stacksXConnectors
-  ]);
-  return xConnectors;
-}
-function useXDisconnect() {
-  const xConnections = useXWagmiStore((state) => state.xConnections);
-  const unsetXConnection = useXWagmiStore((state) => state.unsetXConnection);
-  const { disconnectAsync } = wagmi.useDisconnect();
-  const { mutateAsync: suiDisconnectAsync } = dappKit.useDisconnectWallet();
+// src/providers/solana/SolanaHydrator.tsx
+var SolanaHydrator = () => {
+  const { connection } = walletAdapterReact.useConnection();
   const solanaWallet = walletAdapterReact.useWallet();
-  return React2.useCallback(
-    async (xChainType) => {
-      switch (xChainType) {
-        case "EVM":
-          await disconnectAsync();
-          break;
-        case "SUI":
-          await suiDisconnectAsync();
-          break;
-        case "SOLANA":
-          await solanaWallet.disconnect();
-          break;
-        case "NEAR": {
-          const nearXService = getXService("NEAR");
-          nearXService.walletSelector.disconnect();
-          break;
-        }
-        default: {
-          const xService = getXService(xChainType);
-          const xConnectorId = xConnections[xChainType]?.xConnectorId;
-          const xConnector = xConnectorId ? xService.getXConnectorById(xConnectorId) : void 0;
-          await xConnector?.disconnect();
-          break;
-        }
-      }
-      unsetXConnection(xChainType);
-    },
-    [xConnections, unsetXConnection, disconnectAsync, suiDisconnectAsync, solanaWallet]
+  const setXConnection = useXWalletStore((state) => state.setXConnection);
+  const unsetXConnection = useXWalletStore((state) => state.unsetXConnection);
+  const setWalletProvider = useXWalletStore((state) => state.setWalletProvider);
+  const walletConfig = useWalletConfig();
+  const solanaDefaults = getEntryDefaults(
+    walletConfig.SOLANA?.chains?.[types.ChainKeys.SOLANA_MAINNET]
   );
-}
-function useXBalances({
-  xChainId,
-  xTokens,
-  address
-}) {
-  const xService = useXService(getXChainType(xChainId));
-  return reactQuery.useQuery({
-    queryKey: ["xBalances", xChainId, xTokens.map((x) => x.symbol), address],
-    queryFn: async () => {
-      if (!xService) {
-        return {};
-      }
-      const balances = await xService.getBalances(address, xTokens);
-      return balances;
-    },
-    enabled: !!xService && !!address && (xTokens?.length ?? 0) > 0,
-    refetchInterval: 5e3
+  react.useEffect(() => {
+    if (connection) {
+      SolanaXService.getInstance().connection = connection;
+    }
+  }, [connection]);
+  const solanaWalletRef = react.useRef(solanaWallet);
+  react.useEffect(() => {
+    solanaWalletRef.current = solanaWallet;
   });
-}
-function useEthereumChainId() {
-  const injectiveXService = useXService("INJECTIVE");
-  const [ethereumChainId, setEthereumChainId] = React2__default.default.useState(null);
-  React2.useEffect(() => {
-    if (!injectiveXService?.walletStrategy?.getWallet()) return;
-    const walletStrategy = injectiveXService.walletStrategy;
-    if (walletStrategy.getWallet() !== walletBase.Wallet.Metamask) return;
-    const getEthereumChainId = async () => {
-      try {
-        const chainId = await walletStrategy.getEthereumChainId();
-        setEthereumChainId(Number.parseInt(chainId));
-      } catch (e) {
-        console.warn("Failed to get Ethereum chain ID:", e);
-      }
-    };
-    getEthereumChainId();
-    try {
-      walletStrategy.getStrategy().onChainIdChanged(getEthereumChainId);
-    } catch (e) {
-      console.warn("Failed to subscribe to chain ID changes:", e);
-    }
-  }, [injectiveXService?.walletStrategy]);
-  return ethereumChainId;
-}
-var switchEthereumChain = async () => {
-  const metamaskProvider = window.ethereum;
-  return await Promise.race([
-    metamaskProvider.request({
-      method: "wallet_switchEthereumChain",
-      params: [{ chainId: "0x1" }]
-    }),
-    new Promise(
-      (resolve) => metamaskProvider.on("change", ({ chain }) => {
-        if (chain?.id === 1) {
-          resolve();
-        }
-      })
-    )
-  ]);
-};
-var useEvmSwitchChain = (expectedXChainId) => {
-  const xChainType = getXChainType(expectedXChainId);
-  const expectedChainId = types.baseChainInfo[expectedXChainId].chainId;
-  const injectiveXService = useXService("INJECTIVE");
-  const ethereumChainId = useEthereumChainId();
-  const { chainId } = wagmi.useAccount();
-  const isWrongChain = React2.useMemo(() => {
-    return xChainType === "EVM" && chainId !== expectedChainId || xChainType === "INJECTIVE" && injectiveXService && injectiveXService.walletStrategy.getWallet() === walletBase.Wallet.Metamask && ethereumChainId !== chains$1.mainnet.id;
-  }, [xChainType, chainId, expectedChainId, ethereumChainId, injectiveXService]);
-  const { switchChain } = wagmi.useSwitchChain();
-  const handleSwitchChain = React2.useCallback(() => {
-    if (xChainType === "INJECTIVE") {
-      switchEthereumChain();
-    } else {
-      switchChain({ chainId: expectedChainId });
-    }
-  }, [switchChain, expectedChainId, xChainType]);
-  return React2.useMemo(
-    () => ({
-      isWrongChain,
-      handleSwitchChain
-    }),
-    [isWrongChain, handleSwitchChain]
+  const solanaConnectors = react.useMemo(
+    () => solanaWallet.wallets.filter((wallet) => wallet.readyState === "Installed").map((wallet) => new SolanaXConnector(wallet)),
+    [solanaWallet.wallets]
   );
+  react.useEffect(() => {
+    SolanaXService.getInstance().setXConnectors(solanaConnectors);
+    useXWalletStore.getState().setXConnectors("SOLANA", solanaConnectors);
+  }, [solanaConnectors]);
+  const wasConnectedRef = react.useRef(!!useXWalletStore.getState().xConnections.SOLANA);
+  react.useEffect(() => {
+    if (solanaWallet.connected && solanaWallet.publicKey) {
+      wasConnectedRef.current = true;
+      setXConnection("SOLANA", {
+        xAccount: { address: solanaWallet.publicKey.toString(), xChainType: "SOLANA" },
+        xConnectorId: `${solanaWallet.wallet?.adapter.name}`
+      });
+    } else if (wasConnectedRef.current) {
+      wasConnectedRef.current = false;
+      unsetXConnection("SOLANA");
+    }
+  }, [solanaWallet.connected, solanaWallet.publicKey, solanaWallet.wallet, setXConnection, unsetXConnection]);
+  const walletProvider = react.useMemo(() => {
+    if (solanaWallet.connected && solanaWallet.publicKey && solanaWallet.wallet && connection) {
+      return new walletSdkCore.SolanaWalletProvider({
+        wallet: solanaWallet,
+        endpoint: connection.rpcEndpoint,
+        defaults: solanaDefaults
+      });
+    }
+    return void 0;
+  }, [solanaWallet.connected, solanaWallet.publicKey, solanaWallet.wallet, connection, solanaDefaults]);
+  react.useEffect(() => {
+    SolanaXService.getInstance().wallet = solanaWalletRef.current;
+    setWalletProvider("SOLANA", walletProvider);
+  }, [walletProvider, setWalletProvider]);
+  return null;
 };
-function useWalletProvider(spokeChainId) {
-  const xChainType = getXChainType(spokeChainId);
-  const evmPublicClient = wagmi.usePublicClient();
-  const { data: evmWalletClient } = wagmi.useWalletClient();
-  const xService = useXService(getXChainType(spokeChainId));
-  const xAccount = useXAccount(spokeChainId);
-  const stacksConnection = useXConnection("STACKS");
-  const stacksConnectors = useXConnectors("STACKS");
-  const xConnection = useXConnection(xChainType);
-  return React2.useMemo(() => {
-    switch (xChainType) {
-      case "EVM": {
-        if (!evmWalletClient) {
-          return void 0;
-        }
-        if (!evmPublicClient) {
-          return void 0;
-        }
-        return new walletSdkCore.EvmWalletProvider({
-          walletClient: evmWalletClient,
-          publicClient: evmPublicClient
-        });
-      }
-      case "SUI": {
-        const suiXService = xService;
-        const { client, wallet, account } = {
-          client: suiXService.suiClient,
-          wallet: suiXService.suiWallet,
-          account: suiXService.suiAccount
-        };
-        return new walletSdkCore.SuiWalletProvider({ client, wallet, account });
-      }
-      case "ICON": {
-        const { walletAddress, rpcUrl } = {
-          walletAddress: xAccount.address,
-          rpcUrl: CHAIN_INFO[1 /* MAINNET */].APIEndpoint
-        };
-        return new walletSdkCore.IconWalletProvider({
-          walletAddress,
-          rpcUrl
-        });
-      }
-      case "INJECTIVE": {
-        const injectiveXService = xService;
-        if (!injectiveXService) {
-          return void 0;
-        }
-        return new walletSdkCore.InjectiveWalletProvider({
-          msgBroadcaster: injectiveXService.msgBroadcaster
-        });
-      }
-      case "STELLAR": {
-        const stellarXService = xService;
-        if (!stellarXService.walletsKit) {
-          return void 0;
-        }
-        return new walletSdkCore.StellarWalletProvider({
-          type: "BROWSER_EXTENSION",
-          walletsKit: stellarXService.walletsKit,
-          network: "PUBLIC"
-        });
-      }
-      case "SOLANA": {
-        const solanaXService = xService;
-        if (!solanaXService.wallet) {
+var SolanaActions = () => {
+  const solanaWallet = walletAdapterReact.useWallet();
+  const registerChainActions = useXWalletStore((state) => state.registerChainActions);
+  const walletRef = react.useRef(solanaWallet);
+  react.useEffect(() => {
+    walletRef.current = solanaWallet;
+  }, [solanaWallet]);
+  react.useEffect(() => {
+    registerChainActions("SOLANA", {
+      connect: async (xConnectorId) => {
+        const wallet = walletRef.current.wallets.find((w) => w.adapter.name === xConnectorId);
+        if (!wallet) {
+          console.warn(
+            `[SolanaActions] connect: wallet "${xConnectorId}" not found in adapter list`,
+            walletRef.current.wallets.map((w) => w.adapter.name)
+          );
           return void 0;
         }
-        if (!solanaXService.connection) {
+        walletRef.current.select(wallet.adapter.name);
+        if (wallet.adapter.connected) {
           return void 0;
         }
-        return new walletSdkCore.SolanaWalletProvider({
-          wallet: solanaXService.wallet,
-          endpoint: solanaXService.connection.rpcEndpoint
+        await new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => {
+            cleanup();
+            reject(new Error("Wallet connection timeout"));
+          }, SOLANA_METAMASK_CONNECT_TIMEOUT_MS);
+          const onConnect = () => {
+            cleanup();
+            resolve();
+          };
+          const onError = (err) => {
+            cleanup();
+            reject(err);
+          };
+          const cleanup = () => {
+            clearTimeout(timeout);
+            wallet.adapter.off("connect", onConnect);
+            wallet.adapter.off("error", onError);
+          };
+          wallet.adapter.on("connect", onConnect);
+          wallet.adapter.on("error", onError);
+          setTimeout(() => {
+            if (!wallet.adapter.connected && !wallet.adapter.connecting) {
+              walletRef.current.connect().catch((err) => {
+                cleanup();
+                reject(err);
+              });
+            }
+          }, 0);
         });
-      }
-      case "BITCOIN": {
-        if (!xConnection?.xConnectorId) return void 0;
-        const connector = BitcoinXService.getInstance().getXConnectorById(xConnection.xConnectorId);
-        if (!connector) return void 0;
-        return connector.recreateWalletProvider(xConnection.xAccount);
-      }
-      case "NEAR": {
-        const nearXService = xService;
-        if (!nearXService.walletSelector) {
-          return void 0;
-        }
-        return new walletSdkCore.NearWalletProvider({ wallet: nearXService.walletSelector });
-      }
-      case "STACKS": {
-        const address = xAccount.address;
-        if (!address) {
-          return void 0;
+        return void 0;
+      },
+      disconnect: async () => {
+        await walletRef.current.disconnect();
+      },
+      getConnectors: () => useXWalletStore.getState().xConnectorsByChain.SOLANA ?? [],
+      getConnection: () => useXWalletStore.getState().xConnections.SOLANA,
+      signMessage: async (message) => {
+        if (!walletRef.current.signMessage) {
+          throw new Error("Solana wallet not connected");
         }
-        const activeStacksConnector = stacksConnectors.find((c) => c.id === stacksConnection?.xConnectorId);
-        return new walletSdkCore.StacksWalletProvider({ address, provider: activeStacksConnector?.getProvider() });
+        const signature = await walletRef.current.signMessage(new TextEncoder().encode(message));
+        return Buffer.from(signature).toString("base64");
       }
-      default:
-        return void 0;
+    });
+  }, [registerChainActions]);
+  return null;
+};
+var emptyWallets = [];
+var SolanaProvider = ({ children, config }) => {
+  const autoConnect = config.autoConnect ?? SOLANA_DEFAULT_AUTO_CONNECT;
+  const endpoint = config.chains?.[types.ChainKeys.SOLANA_MAINNET]?.rpcUrl ?? SOLANA_DEFAULT_RPC_URL;
+  return /* @__PURE__ */ jsxRuntime.jsx(walletAdapterReact.ConnectionProvider, { endpoint, children: /* @__PURE__ */ jsxRuntime.jsxs(walletAdapterReact.WalletProvider, { wallets: emptyWallets, autoConnect, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(SolanaHydrator, {}),
+    /* @__PURE__ */ jsxRuntime.jsx(SolanaActions, {}),
+    children
+  ] }) });
+};
+var SuiHydrator = () => {
+  const suiClient = dappKit.useSuiClient();
+  const { currentWallet } = dappKit.useCurrentWallet();
+  const suiAccount = dappKit.useCurrentAccount();
+  const suiWallets = dappKit.useWallets();
+  const setXConnection = useXWalletStore((state) => state.setXConnection);
+  const unsetXConnection = useXWalletStore((state) => state.unsetXConnection);
+  const setWalletProvider = useXWalletStore((state) => state.setWalletProvider);
+  const walletConfig = useWalletConfig();
+  const suiDefaults = getEntryDefaults(walletConfig.SUI?.chains?.[types.ChainKeys.SUI_MAINNET]);
+  react.useEffect(() => {
+    const service = SuiXService.getInstance();
+    if (suiClient) service.suiClient = suiClient;
+    if (currentWallet) service.suiWallet = currentWallet;
+    if (suiAccount) service.suiAccount = suiAccount;
+  }, [suiClient, currentWallet, suiAccount]);
+  const suiConnectors = react.useMemo(() => suiWallets.map((wallet) => new SuiXConnector(wallet)), [suiWallets]);
+  react.useEffect(() => {
+    SuiXService.getInstance().setXConnectors(suiConnectors);
+    useXWalletStore.getState().setXConnectors("SUI", suiConnectors);
+  }, [suiConnectors]);
+  const wasConnectedRef = react.useRef(!!useXWalletStore.getState().xConnections.SUI);
+  react.useEffect(() => {
+    if (currentWallet && suiAccount?.address) {
+      wasConnectedRef.current = true;
+      setXConnection("SUI", {
+        xAccount: { address: suiAccount.address, xChainType: "SUI" },
+        // Match SuiXConnector.id derivation: prefer Wallet Standard `id`, fall back to `name`.
+        xConnectorId: currentWallet.id ?? currentWallet.name
+      });
+    } else if (wasConnectedRef.current) {
+      wasConnectedRef.current = false;
+      unsetXConnection("SUI");
+    }
+  }, [currentWallet, suiAccount, setXConnection, unsetXConnection]);
+  const walletProvider = react.useMemo(() => {
+    if (suiClient && currentWallet && suiAccount) {
+      assertSuiProviderShape("SuiHydrator", suiClient, currentWallet, suiAccount);
+      return new walletSdkCore.SuiWalletProvider({
+        client: suiClient,
+        wallet: currentWallet,
+        account: suiAccount,
+        defaults: suiDefaults
+      });
     }
-  }, [
-    xChainType,
-    evmPublicClient,
-    evmWalletClient,
-    xService,
-    xAccount,
-    stacksConnection,
-    stacksConnectors,
-    xConnection
-  ]);
-}
-function useXSignMessage() {
-  const { signMessage } = walletAdapterReact.useWallet();
-  const { signMessageAsync: evmSignMessage } = wagmi.useSignMessage();
+    return void 0;
+  }, [suiClient, currentWallet, suiAccount, suiDefaults]);
+  react.useEffect(() => {
+    setWalletProvider("SUI", walletProvider);
+  }, [walletProvider, setWalletProvider]);
+  return null;
+};
+var SuiActions = () => {
+  const suiWallets = dappKit.useWallets();
+  const { mutateAsync: suiConnectAsync } = dappKit.useConnectWallet();
+  const { mutateAsync: suiDisconnectAsync } = dappKit.useDisconnectWallet();
   const { mutateAsync: signPersonalMessage } = dappKit.useSignPersonalMessage();
-  const { address: injectiveAddress } = useXAccount("INJECTIVE");
-  return reactQuery.useMutation({
-    mutationFn: async ({ xChainType, message }) => {
-      let signature;
-      switch (xChainType) {
-        case "EVM": {
-          signature = await evmSignMessage({ message });
-          break;
-        }
-        case "SUI": {
-          const res = await signPersonalMessage({ message: new Uint8Array(new TextEncoder().encode(message)) });
-          signature = res.signature;
-          break;
-        }
-        case "SOLANA": {
-          if (!signMessage) {
-            throw new Error("Solana wallet not connected");
-          }
-          signature = await signMessage(new TextEncoder().encode(message));
-          break;
-        }
-        case "STELLAR": {
-          const res = await StellarXService.getInstance().walletsKit.signMessage(message);
-          signature = res.signedMessage;
-          break;
-        }
-        case "INJECTIVE": {
-          if (!injectiveAddress) {
-            throw new Error("Injective address not found");
-          }
-          const ethereumAddress = sdkTs.getEthereumAddress(injectiveAddress);
-          const walletStrategy = InjectiveXService.getInstance().walletStrategy;
-          const res = await walletStrategy.signArbitrary(
-            walletStrategy.getWallet() === walletBase.Wallet.Metamask ? ethereumAddress : injectiveAddress,
-            message
+  const registerChainActions = useXWalletStore((state) => state.registerChainActions);
+  const connectRef = react.useRef(suiConnectAsync);
+  const disconnectRef = react.useRef(suiDisconnectAsync);
+  const signMessageRef = react.useRef(signPersonalMessage);
+  const walletsRef = react.useRef(suiWallets);
+  react.useEffect(() => {
+    connectRef.current = suiConnectAsync;
+  }, [suiConnectAsync]);
+  react.useEffect(() => {
+    disconnectRef.current = suiDisconnectAsync;
+  }, [suiDisconnectAsync]);
+  react.useEffect(() => {
+    signMessageRef.current = signPersonalMessage;
+  }, [signPersonalMessage]);
+  react.useEffect(() => {
+    walletsRef.current = suiWallets;
+  }, [suiWallets]);
+  react.useEffect(() => {
+    registerChainActions("SUI", {
+      connect: async (xConnectorId) => {
+        const wallet = walletsRef.current.find((w) => (w.id ?? w.name) === xConnectorId);
+        if (!wallet) {
+          console.warn(
+            `[SuiActions] connect: wallet "${xConnectorId}" not found in adapter list`,
+            walletsRef.current.map((w) => w.name)
           );
-          if (!res) {
-            throw new Error("Injective signature not found");
-          }
-          signature = res;
-          break;
+          return void 0;
         }
-        default:
-          console.warn("Unsupported chain type");
-          break;
+        await connectRef.current({ wallet });
+        return void 0;
+      },
+      disconnect: async () => {
+        await disconnectRef.current();
+      },
+      getConnectors: () => useXWalletStore.getState().xConnectorsByChain.SUI ?? [],
+      getConnection: () => useXWalletStore.getState().xConnections.SUI,
+      signMessage: async (message) => {
+        const res = await signMessageRef.current({ message: new Uint8Array(new TextEncoder().encode(message)) });
+        return res.signature;
       }
-      return signature;
-    }
-  });
-}
-
-// src/xchains/bitcoin/useBitcoinXConnectors.ts
-function useBitcoinXConnectors() {
-  const xService = useXService("BITCOIN");
-  return React2.useMemo(() => {
-    return xService?.getXConnectors() || [];
-  }, [xService]);
-}
-var Hydrate = ({ rpcConfig }) => {
-  const suiClient = dappKit.useSuiClient();
-  React2.useEffect(() => {
-    if (suiClient) {
-      SuiXService.getInstance().suiClient = suiClient;
-    }
-  }, [suiClient]);
-  const { currentWallet: suiWallet } = dappKit.useCurrentWallet();
-  React2.useEffect(() => {
-    if (suiWallet) {
-      SuiXService.getInstance().suiWallet = suiWallet;
-    }
-  }, [suiWallet]);
-  const suiAccount = dappKit.useCurrentAccount();
-  React2.useEffect(() => {
-    if (suiAccount) {
-      SuiXService.getInstance().suiAccount = suiAccount;
-    }
-  }, [suiAccount]);
-  const { connection: solanaConnection } = walletAdapterReact.useConnection();
-  const solanaWallet = walletAdapterReact.useWallet();
-  React2.useEffect(() => {
-    if (solanaConnection) {
-      SolanaXService.getInstance().connection = solanaConnection;
-    }
-  }, [solanaConnection]);
-  React2.useEffect(() => {
-    if (solanaWallet) {
-      SolanaXService.getInstance().wallet = solanaWallet;
-    }
-  }, [solanaWallet]);
-  const wagmiConfig = wagmi.useConfig();
-  React2.useEffect(() => {
-    if (wagmiConfig) {
-      EvmXService.getInstance().wagmiConfig = wagmiConfig;
-    }
-  }, [wagmiConfig]);
-  React2.useEffect(() => {
-    StacksXService.getInstance().network = network.createNetwork({
-      network: "mainnet",
-      client: { baseUrl: rpcConfig.stacks ?? "https://api.mainnet.hiro.so" }
     });
-  }, [rpcConfig.stacks]);
+  }, [registerChainActions]);
   return null;
 };
+var SuiProvider = ({ children, config }) => {
+  const autoConnect = config.autoConnect ?? SUI_DEFAULT_AUTO_CONNECT;
+  const network = config.network ?? SUI_DEFAULT_NETWORK;
+  const rpcUrl = config.chains?.[types.ChainKeys.SUI_MAINNET]?.rpcUrl ?? client.getFullnodeUrl(network);
+  return /* @__PURE__ */ jsxRuntime.jsx(dappKit.SuiClientProvider, { networks: { [network]: { url: rpcUrl } }, defaultNetwork: network, children: /* @__PURE__ */ jsxRuntime.jsxs(dappKit.WalletProvider, { autoConnect, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(SuiHydrator, {}),
+    /* @__PURE__ */ jsxRuntime.jsx(SuiActions, {}),
+    children
+  ] }) });
+};
 
 // src/xchains/icon/actions.ts
 var reconnectIcon = async () => {
-  const iconConnection = useXWagmiStore.getState().xConnections.ICON;
+  const iconConnection = useXWalletStore.getState().xConnections.ICON;
   if (!iconConnection) return;
   const recentXConnectorId = iconConnection.xConnectorId;
   const detail = await request({
     type: "REQUEST_ADDRESS" /* REQUEST_ADDRESS */
   });
   if (detail?.type === "RESPONSE_ADDRESS" /* RESPONSE_ADDRESS */) {
-    useXWagmiStore.setState({
-      xConnections: {
-        ...useXWagmiStore.getState().xConnections,
-        ICON: {
-          xAccount: {
-            address: detail?.payload,
-            xChainType: "ICON"
-          },
-          xConnectorId: recentXConnectorId
-        }
-      }
+    useXWalletStore.getState().setXConnection("ICON", {
+      xAccount: {
+        address: detail?.payload,
+        xChainType: "ICON"
+      },
+      xConnectorId: recentXConnectorId
     });
   }
 };
+function isWallet(value) {
+  return Object.values(walletBase.Wallet).some((v) => v === value);
+}
 var reconnectInjective = async () => {
-  const injectiveConnection = useXWagmiStore.getState().xConnections.INJECTIVE;
+  const injectiveConnection = useXWalletStore.getState().xConnections.INJECTIVE;
   if (!injectiveConnection) return;
   const recentXConnectorId = injectiveConnection.xConnectorId;
+  if (!isWallet(recentXConnectorId)) {
+    console.warn(`[Injective] Stale wallet ID skipped: ${recentXConnectorId}`);
+    return;
+  }
   const walletStrategy = InjectiveXService.getInstance().walletStrategy;
   await walletStrategy.setWallet(recentXConnectorId);
   const addresses = await walletStrategy.getAddresses();
-  const address = walletBase.isEvmBrowserWallet(recentXConnectorId) ? sdkTs.getInjectiveAddress(addresses?.[0]) : addresses?.[0];
-  useXWagmiStore.setState({
-    xConnections: {
-      ...useXWagmiStore.getState().xConnections,
-      INJECTIVE: {
-        xAccount: {
-          address,
-          xChainType: "INJECTIVE"
-        },
-        xConnectorId: recentXConnectorId
-      }
-    }
+  const firstAddress = addresses?.[0];
+  if (!firstAddress) return;
+  const address = walletBase.isEvmBrowserWallet(recentXConnectorId) ? sdkTs.getInjectiveAddress(firstAddress) : firstAddress;
+  useXWalletStore.getState().setXConnection("INJECTIVE", {
+    xAccount: {
+      address,
+      xChainType: "INJECTIVE"
+    },
+    xConnectorId: recentXConnectorId
   });
 };
 
 // src/xchains/stellar/actions.ts
 var reconnectStellar = async () => {
-  const stellarConnection = useXWagmiStore.getState().xConnections.STELLAR;
+  const stellarConnection = useXWalletStore.getState().xConnections.STELLAR;
   if (!stellarConnection) return;
   const recentXConnectorId = stellarConnection.xConnectorId;
   const stellarWalletKit = StellarXService.getInstance().walletsKit;
   stellarWalletKit.setWallet(recentXConnectorId);
   const { address } = await stellarWalletKit.getAddress();
-  useXWagmiStore.setState({
-    xConnections: {
-      ...useXWagmiStore.getState().xConnections,
-      STELLAR: {
-        xAccount: {
-          address,
-          xChainType: "STELLAR"
-        },
-        xConnectorId: recentXConnectorId
-      }
-    }
+  useXWalletStore.getState().setXConnection("STELLAR", {
+    xAccount: {
+      address,
+      xChainType: "STELLAR"
+    },
+    xConnectorId: recentXConnectorId
   });
 };
-var queryClient = new reactQuery.QueryClient();
-var defaultOptions = {
-  wagmi: {
-    reconnectOnMount: false,
-    ssr: true
-  },
-  solana: {
-    autoConnect: true
-  },
-  sui: {
-    autoConnect: true
+
+// src/hooks/useInitChainServices.ts
+function useInitChainServices(walletConfig) {
+  const initChainServices = useXWalletStore((state) => state.initChainServices);
+  const cleanupDisabledConnections = useXWalletStore((state) => state.cleanupDisabledConnections);
+  react.useEffect(() => {
+    initChainServices(walletConfig);
+    const afterHydration = () => {
+      cleanupDisabledConnections();
+      const store = useXWalletStore.getState();
+      for (const chainType of Object.keys(store.xConnections)) {
+        if (!chainRegistry[chainType]?.createWalletProvider) continue;
+        const conn = store.xConnections[chainType];
+        if (conn) store.setXConnection(chainType, conn);
+      }
+      if (walletConfig.ICON) {
+        reconnectIcon().catch((error) => console.warn("[wallet-sdk-react] ICON reconnect failed:", error));
+      }
+      if (walletConfig.INJECTIVE) {
+        reconnectInjective().catch((error) => console.warn("[wallet-sdk-react] Injective reconnect failed:", error));
+      }
+      if (walletConfig.STELLAR) {
+        reconnectStellar().catch((error) => console.warn("[wallet-sdk-react] Stellar reconnect failed:", error));
+      }
+    };
+    if (useXWalletStore.persist.hasHydrated()) {
+      afterHydration();
+    } else {
+      useXWalletStore.persist.onFinishHydration(afterHydration);
+    }
+  }, []);
+}
+var SodaxWalletProvider = ({ children, config }) => {
+  const configRef = react.useRef(config);
+  const frozen = configRef.current;
+  useInitChainServices(frozen);
+  let content = /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children });
+  if (frozen.SOLANA) {
+    content = /* @__PURE__ */ jsxRuntime.jsx(SolanaProvider, { config: frozen.SOLANA, children: content });
   }
+  if (frozen.SUI) {
+    content = /* @__PURE__ */ jsxRuntime.jsx(SuiProvider, { config: frozen.SUI, children: content });
+  }
+  if (frozen.EVM) {
+    content = /* @__PURE__ */ jsxRuntime.jsx(EvmProvider, { config: frozen.EVM, children: content });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(WalletConfigProvider, { value: frozen, children: content });
 };
-var SodaxWalletProvider = ({ children, rpcConfig, options, initialState }) => {
-  const wagmi$1 = React2.useMemo(() => ({ ...defaultOptions.wagmi, ...options?.wagmi }), [options?.wagmi]);
-  const wagmiConfig = React2.useMemo(() => {
-    return createWagmiConfig(rpcConfig, wagmi$1);
-  }, [rpcConfig, wagmi$1]);
-  const wallets = React2.useMemo(() => [new walletAdapterWallets.UnsafeBurnerWalletAdapter()], []);
-  const solana = React2.useMemo(() => ({ ...defaultOptions.solana, ...options?.solana }), [options?.solana]);
-  const sui = React2.useMemo(() => ({ ...defaultOptions.sui, ...options?.sui }), [options?.sui]);
-  return /* @__PURE__ */ React2__default.default.createElement(reactQuery.QueryClientProvider, { client: queryClient }, /* @__PURE__ */ React2__default.default.createElement(wagmi.WagmiProvider, { reconnectOnMount: wagmi$1.reconnectOnMount, config: wagmiConfig, initialState }, /* @__PURE__ */ React2__default.default.createElement(dappKit.SuiClientProvider, { networks: { mainnet: { url: client.getFullnodeUrl("mainnet") } }, defaultNetwork: "mainnet" }, /* @__PURE__ */ React2__default.default.createElement(dappKit.WalletProvider, { autoConnect: sui.autoConnect }, /* @__PURE__ */ React2__default.default.createElement(walletAdapterReact.ConnectionProvider, { endpoint: rpcConfig["solana"] ?? "https://api.mainnet-beta.solana.com" }, /* @__PURE__ */ React2__default.default.createElement(walletAdapterReact.WalletProvider, { wallets, autoConnect: solana.autoConnect }, /* @__PURE__ */ React2__default.default.createElement(Hydrate, { rpcConfig }), children))))));
-};
-reconnectIcon();
-reconnectInjective();
-reconnectStellar();
-
-// src/types/index.ts
-var WalletId = /* @__PURE__ */ ((WalletId2) => {
-  WalletId2["METAMASK"] = "metamask";
-  WalletId2["HANA"] = "hana";
-  WalletId2["PHANTOM"] = "phantom";
-  WalletId2["SUI"] = "sui";
-  WalletId2["KEPLR"] = "keplr";
-  return WalletId2;
-})(WalletId || {});
 
-exports.BitcoinXConnector = BitcoinXConnector;
-exports.BitcoinXService = BitcoinXService;
-exports.EvmXConnector = EvmXConnector;
-exports.EvmXService = EvmXService;
-exports.IconHanaXConnector = IconHanaXConnector;
-exports.IconXService = IconXService;
-exports.InjectiveXConnector = InjectiveXConnector;
-exports.InjectiveXService = InjectiveXService;
-exports.OKXXConnector = OKXXConnector;
-exports.STACKS_PROVIDERS = STACKS_PROVIDERS;
 exports.SodaxWalletProvider = SodaxWalletProvider;
-exports.SolanaXConnector = SolanaXConnector;
-exports.SolanaXService = SolanaXService;
-exports.StacksXConnector = StacksXConnector;
-exports.StacksXService = StacksXService;
-exports.StellarWalletsKitXConnector = StellarWalletsKitXConnector;
-exports.StellarXService = StellarXService;
-exports.SuiXConnector = SuiXConnector;
-exports.SuiXService = SuiXService;
-exports.UnisatXConnector = UnisatXConnector;
-exports.WalletId = WalletId;
+exports.WalletConfigProvider = WalletConfigProvider;
 exports.XConnector = XConnector;
 exports.XService = XService;
-exports.XverseXConnector = XverseXConnector;
-exports.createWagmi = createWagmiConfig;
-exports.createWagmiConfig = createWagmiConfig;
+exports.getEntryDefaults = getEntryDefaults;
+exports.getRpcUrl = getRpcUrl;
 exports.getWagmiChainId = getWagmiChainId;
 exports.getXChainType = getXChainType;
 exports.getXService = getXService;
 exports.isNativeToken = isNativeToken;
-exports.useBitcoinXConnectors = useBitcoinXConnectors;
+exports.resolveEvmDefaults = resolveEvmDefaults;
+exports.sortConnectors = sortConnectors;
+exports.useBatchConnect = useBatchConnect;
+exports.useBatchDisconnect = useBatchDisconnect;
+exports.useChainGroups = useChainGroups;
+exports.useConnectedChains = useConnectedChains;
+exports.useConnectionFlow = useConnectionFlow;
+exports.useEnabledChainTypes = useEnabledChainTypes;
+exports.useEnabledChains = useEnabledChains;
 exports.useEvmSwitchChain = useEvmSwitchChain;
-exports.useStacksXConnectors = useStacksXConnectors;
+exports.useIsChainEnabled = useIsChainEnabled;
+exports.useIsWalletInstalled = useIsWalletInstalled;
+exports.useWalletConfig = useWalletConfig;
+exports.useWalletModal = useWalletModal;
 exports.useWalletProvider = useWalletProvider;
 exports.useXAccount = useXAccount;
 exports.useXAccounts = useXAccounts;
-exports.useXBalances = useXBalances;
 exports.useXConnect = useXConnect;
 exports.useXConnection = useXConnection;
+exports.useXConnections = useXConnections;
 exports.useXConnectors = useXConnectors;
+exports.useXConnectorsByChain = useXConnectorsByChain;
 exports.useXDisconnect = useXDisconnect;
 exports.useXService = useXService;
+exports.useXServices = useXServices;
 exports.useXSignMessage = useXSignMessage;
-exports.useXWagmiStore = useXWagmiStore;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map