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

package/dist/chunk-PLCA4ZDJ.mjs

@@ -0,0 +1,1585 @@
+import { StellarWalletsKitXConnector, StellarXService } from './chunk-66BAUK56.mjs';
+import { SuiXService } from './chunk-7ULB6DW4.mjs';
+import { EvmXService } from './chunk-E5IAZ7E6.mjs';
+import { IconHanaXConnector, IconXService, CHAIN_INFO } from './chunk-2BOUGCJ7.mjs';
+import { assert, isRecord, hasFunctionProperty } from './chunk-MAQ47Q52.mjs';
+import { InjectiveXConnector, InjectiveXService } from './chunk-BKJB527E.mjs';
+import { NearXService, NearXConnector } from './chunk-BXJLBR4G.mjs';
+import { BITCOIN_DEFAULT_RPC_URL, WALLET_METADATA } from './chunk-MXZVF5HR.mjs';
+import { SolanaXService } from './chunk-XZ7CHO2S.mjs';
+import { isNativeToken, getEntryDefaults, getRpcUrl } from './chunk-NY7U7OJW.mjs';
+import { STACKS_PROVIDERS, StacksXService, StacksXConnector } from './chunk-PJLEJVAU.mjs';
+import { XConnector, XService } from './chunk-X2MHIWXO.mjs';
+import { ChainTypeArr, baseChainInfo, ChainKeys, detectBitcoinAddressType, CHAIN_KEYS } from '@sodax/types';
+import { AddressPurpose, MessageSigningProtocols } from 'sats-connect';
+import { createContext, useMemo, useSyncExternalStore, useCallback, useState, useRef, useContext, useEffect } from 'react';
+import { create } from 'zustand';
+import { devtools, persist, createJSONStorage } from 'zustand/middleware';
+import { immer } from 'zustand/middleware/immer';
+import { StacksWalletProvider, NearWalletProvider, IconWalletProvider, StellarWalletProvider, InjectiveWalletProvider } from '@sodax/wallet-sdk-core';
+import { Wallet } from '@injectivelabs/wallet-base';
+import { getEthereumAddress } from '@injectivelabs/sdk-ts';
+import { useMutation } from '@tanstack/react-query';
+import { useAccount, useSwitchChain } from 'wagmi';
+import { mainnet } from 'viem/chains';
+
+// src/xchains/bitcoin/BitcoinXService.ts
+var BitcoinXService = class _BitcoinXService extends XService {
+  static instance;
+  rpcUrl;
+  constructor(rpcUrl = BITCOIN_DEFAULT_RPC_URL) {
+    super("BITCOIN");
+    this.rpcUrl = rpcUrl;
+  }
+  static getInstance(rpcUrl) {
+    if (!_BitcoinXService.instance) {
+      _BitcoinXService.instance = new _BitcoinXService(rpcUrl);
+    } else if (rpcUrl && rpcUrl !== _BitcoinXService.instance.rpcUrl) {
+      _BitcoinXService.instance.rpcUrl = rpcUrl;
+    }
+    return _BitcoinXService.instance;
+  }
+  async getBalance(address, xToken) {
+    if (!address) return 0n;
+    try {
+      if (isNativeToken(xToken)) {
+        const response = await fetch(`${this.rpcUrl}/address/${address}/utxo`);
+        if (!response.ok) return 0n;
+        const utxos = await response.json();
+        const totalBalance = utxos.reduce((sum, utxo) => sum + utxo.value, 0);
+        return BigInt(totalBalance);
+      }
+    } catch {
+      return 0n;
+    }
+    return 0n;
+  }
+};
+
+// src/xchains/bitcoin/BitcoinXConnector.ts
+var BitcoinXConnector = class extends XConnector {
+  defaults;
+  constructor(name, id, defaults) {
+    super("BITCOIN", name, id);
+    this.defaults = defaults;
+  }
+  getXService() {
+    return BitcoinXService.getInstance();
+  }
+};
+var UnisatWalletProvider = class {
+  chainType = "BITCOIN";
+  cachedAddress;
+  defaults;
+  constructor(address, defaults) {
+    this.cachedAddress = address;
+    this.defaults = defaults;
+  }
+  // Lazy resolve so the provider can be constructed before the extension finishes injecting `window.unisat` (post-refresh rehydrate path).
+  get unisat() {
+    const u = window.unisat;
+    if (!u) throw new Error("Unisat wallet not available");
+    return u;
+  }
+  async getWalletAddress() {
+    try {
+      const accounts = await this.unisat.getAccounts();
+      if (accounts[0]) this.cachedAddress = accounts[0];
+    } catch {
+    }
+    return this.cachedAddress;
+  }
+  async getPublicKey() {
+    return this.unisat.getPublicKey();
+  }
+  async getAddressType(_address) {
+    const address = await this.getWalletAddress();
+    return detectBitcoinAddressType(address);
+  }
+  async signTransaction(psbtBase64, finalize) {
+    const effectiveFinalize = finalize ?? this.defaults?.defaultFinalize ?? false;
+    const psbtHex = Buffer.from(psbtBase64, "base64").toString("hex");
+    const signedHex = await this.unisat.signPsbt(psbtHex, { autoFinalized: effectiveFinalize });
+    return signedHex;
+  }
+  async signEcdsaMessage(message) {
+    return this.unisat.signMessage(message, "ecdsa");
+  }
+  async signBip322Message(message) {
+    return this.unisat.signMessage(message, "bip322-simple");
+  }
+  async sendBitcoin(toAddress, satoshis) {
+    if (satoshis > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error(`Amount ${satoshis} satoshis exceeds safe integer range`);
+    }
+    return this.unisat.sendBitcoin(toAddress, Number(satoshis));
+  }
+};
+var UnisatXConnector = class _UnisatXConnector extends BitcoinXConnector {
+  walletProvider;
+  constructor(defaults) {
+    super("Unisat", "unisat", defaults);
+  }
+  static isAvailable() {
+    return typeof window !== "undefined" && !!window.unisat;
+  }
+  get isInstalled() {
+    return _UnisatXConnector.isAvailable();
+  }
+  get installUrl() {
+    return WALLET_METADATA.unisat.installUrl;
+  }
+  get icon() {
+    return WALLET_METADATA.unisat.icon;
+  }
+  async connect() {
+    if (!window.unisat) {
+      throw new Error("Unisat wallet is not installed");
+    }
+    const accounts = await window.unisat.requestAccounts();
+    const address = accounts[0];
+    if (!address) {
+      console.warn("[UnisatXConnector] connect: requestAccounts returned no address");
+      return void 0;
+    }
+    this.walletProvider = new UnisatWalletProvider(address, this.defaults);
+    return {
+      address,
+      xChainType: "BITCOIN"
+    };
+  }
+  async disconnect() {
+    this.walletProvider = void 0;
+  }
+  getWalletProvider() {
+    return this.walletProvider;
+  }
+  recreateWalletProvider(xAccount) {
+    if (!xAccount.address) return void 0;
+    return new UnisatWalletProvider(xAccount.address, this.defaults);
+  }
+};
+var XverseWalletProvider = class {
+  chainType = "BITCOIN";
+  address;
+  publicKey;
+  defaults;
+  constructor(address, publicKey, defaults) {
+    this.address = address;
+    this.publicKey = publicKey;
+    this.defaults = defaults;
+  }
+  async getWalletAddress() {
+    return this.address;
+  }
+  async getPublicKey() {
+    return this.publicKey;
+  }
+  async getAddressType(_address) {
+    return detectBitcoinAddressType(this.address);
+  }
+  /**
+   * Parse a base64-encoded PSBT to count the number of inputs.
+   * Reads the unsigned transaction from the PSBT global section.
+   */
+  countPsbtInputs(psbtBase64) {
+    const data = Buffer.from(psbtBase64, "base64");
+    let offset = 5;
+    const keyLen = data[offset++] ?? 0;
+    if (keyLen !== 1 || data[offset++] !== 0) {
+      return 1;
+    }
+    const firstByte = data[offset++] ?? 0;
+    if (firstByte === 253) offset += 2;
+    else if (firstByte === 254) offset += 4;
+    else if (firstByte === 255) offset += 8;
+    offset += 4;
+    const inputByte = data[offset] ?? 0;
+    if (inputByte < 253) return inputByte;
+    return 1;
+  }
+  async signTransaction(psbtBase64, finalize) {
+    const effectiveFinalize = finalize ?? this.defaults?.defaultFinalize ?? false;
+    const { request } = await import('sats-connect');
+    const inputCount = this.countPsbtInputs(psbtBase64);
+    const signingIndexes = Array.from({ length: inputCount }, (_, i) => i);
+    const response = await request("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 } = await import('sats-connect');
+    const response = await request("signMessage", {
+      address: this.address,
+      message,
+      protocol: 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 } = await import('sats-connect');
+    const response = await request("signMessage", {
+      address: this.address,
+      message,
+      protocol: 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 } = await import('sats-connect');
+    const response = await request("sendTransfer", {
+      recipients: [
+        {
+          address: toAddress,
+          amount: Number(satoshis)
+        }
+      ]
+    });
+    if (response.status === "error") {
+      throw new Error(response.error?.message || "Xverse sendTransfer failed");
+    }
+    return response.result.txid;
+  }
+};
+var XVERSE_ADDRESS_TYPE_KEY = "xverse-address-type";
+var XverseXConnector = class _XverseXConnector extends BitcoinXConnector {
+  walletProvider;
+  /** Address purpose used when connecting. Taproot (Ordinals) by default to match Radfi. */
+  addressPurpose;
+  constructor(defaults) {
+    super("Xverse", "xverse", defaults);
+    const saved = typeof window !== "undefined" ? localStorage.getItem(XVERSE_ADDRESS_TYPE_KEY) : null;
+    this.addressPurpose = saved === "segwit" ? AddressPurpose.Payment : AddressPurpose.Ordinals;
+  }
+  /** Set address purpose and persist to localStorage. */
+  setAddressPurpose(type) {
+    this.addressPurpose = type === "taproot" ? AddressPurpose.Ordinals : AddressPurpose.Payment;
+    if (typeof window !== "undefined") {
+      localStorage.setItem(XVERSE_ADDRESS_TYPE_KEY, type);
+    }
+  }
+  static isAvailable() {
+    return typeof window !== "undefined" && !!window.BitcoinProvider;
+  }
+  get isInstalled() {
+    return _XverseXConnector.isAvailable();
+  }
+  get installUrl() {
+    return WALLET_METADATA.xverse.installUrl;
+  }
+  get icon() {
+    return WALLET_METADATA.xverse.icon;
+  }
+  async connect() {
+    if (!_XverseXConnector.isAvailable()) {
+      throw new Error("Xverse wallet is not installed");
+    }
+    const { request } = await import('sats-connect');
+    const response = await request("getAccounts", {
+      purposes: [this.addressPurpose],
+      message: "Connect to Sodax"
+    });
+    if (response.status === "error") {
+      throw new Error(response.error?.message || "Xverse connection failed");
+    }
+    const accounts = response.result;
+    const paymentAccount = accounts.find((a) => a.purpose === this.addressPurpose) || accounts[0];
+    if (!paymentAccount) return void 0;
+    this.walletProvider = new XverseWalletProvider(
+      paymentAccount.address,
+      paymentAccount.publicKey,
+      this.defaults
+    );
+    return {
+      address: paymentAccount.address,
+      publicKey: paymentAccount.publicKey,
+      xChainType: "BITCOIN"
+    };
+  }
+  async disconnect() {
+    this.walletProvider = void 0;
+  }
+  getWalletProvider() {
+    return this.walletProvider;
+  }
+  recreateWalletProvider(xAccount) {
+    if (!xAccount.address || !xAccount.publicKey) return void 0;
+    return new XverseWalletProvider(xAccount.address, xAccount.publicKey, this.defaults);
+  }
+};
+var OKXWalletProvider = class {
+  chainType = "BITCOIN";
+  cachedAddress;
+  defaults;
+  constructor(address, defaults) {
+    this.cachedAddress = address;
+    this.defaults = defaults;
+  }
+  // Lazy resolve so the provider can be constructed before the extension finishes injecting `window.okxwallet` (post-refresh rehydrate path).
+  get okx() {
+    const o = window.okxwallet?.bitcoin;
+    if (!o) throw new Error("OKX wallet not available");
+    return o;
+  }
+  async getWalletAddress() {
+    try {
+      const accounts = await this.okx.getAccounts();
+      if (accounts[0]) this.cachedAddress = accounts[0];
+    } catch {
+    }
+    return this.cachedAddress;
+  }
+  async getPublicKey() {
+    return this.okx.getPublicKey();
+  }
+  async getAddressType(_address) {
+    const address = await this.getWalletAddress();
+    return 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);
+  }
+};
+function getXChainType(xChainId) {
+  if (!xChainId) {
+    return void 0;
+  }
+  return baseChainInfo[xChainId].type;
+}
+
+// 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";
+}
+
+// src/chainRegistry.ts
+function defineChain(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: defineChain({
+    createService: () => EvmXService.getInstance(),
+    displayName: "EVM",
+    defaultConnectors: () => [],
+    providerManaged: true
+  }),
+  SUI: defineChain({
+    createService: () => SuiXService.getInstance(),
+    displayName: "Sui",
+    defaultConnectors: () => [],
+    providerManaged: true
+  }),
+  SOLANA: defineChain({
+    createService: () => SolanaXService.getInstance(),
+    displayName: "Solana",
+    defaultConnectors: () => [],
+    providerManaged: true
+  }),
+  BITCOIN: defineChain({
+    createService: (walletConfig) => BitcoinXService.getInstance(getRpcUrl(walletConfig?.BITCOIN?.chains?.[ChainKeys.BITCOIN_MAINNET])),
+    displayName: "Bitcoin",
+    defaultConnectors: (walletConfig) => {
+      const defaults = getEntryDefaults(
+        walletConfig?.BITCOIN?.chains?.[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 = 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: defineChain({
+    createService: (walletConfig) => InjectiveXService.getInstance(walletConfig?.INJECTIVE?.chains?.[ChainKeys.INJECTIVE_MAINNET]),
+    displayName: "Injective",
+    defaultConnectors: () => [
+      new InjectiveXConnector("MetaMask", Wallet.Metamask),
+      new InjectiveXConnector("Keplr", Wallet.Keplr),
+      new InjectiveXConnector("Leap", 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 = getEthereumAddress(address);
+        const walletStrategy = service.walletStrategy;
+        const res = await walletStrategy.signArbitrary(
+          walletStrategy.getWallet() === 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?.[ChainKeys.INJECTIVE_MAINNET]
+      );
+      return new InjectiveWalletProvider({ msgBroadcaster: service.msgBroadcaster, defaults });
+    }
+  }),
+  STELLAR: defineChain({
+    createService: (walletConfig) => {
+      const stellarRpc = walletConfig?.STELLAR?.chains?.[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?.[ChainKeys.STELLAR_MAINNET]
+      );
+      return new 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: defineChain({
+    createService: (walletConfig) => IconXService.getInstance(getRpcUrl(walletConfig?.ICON?.chains?.[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?.[ChainKeys.ICON_MAINNET]
+      );
+      return new IconWalletProvider({
+        walletAddress: address,
+        rpcUrl: chainInfo.APIEndpoint,
+        defaults
+      });
+    }
+  }),
+  NEAR: defineChain({
+    createService: (walletConfig) => NearXService.getInstance(getRpcUrl(walletConfig?.NEAR?.chains?.[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?.[ChainKeys.NEAR_MAINNET]
+      );
+      return new NearWalletProvider({ wallet: service.walletSelector, defaults });
+    }
+  }),
+  STACKS: defineChain({
+    createService: (walletConfig) => StacksXService.getInstance(walletConfig?.STACKS?.chains?.[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?.[ChainKeys.STACKS_MAINNET]
+      );
+      return new StacksWalletProvider({ address, provider, defaults });
+    }
+  })
+};
+var createChainServices = (walletConfig, getStore) => {
+  const xServices = {};
+  const xConnectorsByChain = {};
+  const enabledChains = [];
+  const chainActions = {};
+  for (const chainType of ChainTypeArr) {
+    if (!hasChainOfType(chainType, walletConfig)) continue;
+    const factory = chainRegistry[chainType];
+    if (!factory) continue;
+    const service = factory.createService(walletConfig);
+    xServices[chainType] = service;
+    enabledChains.push(chainType);
+    if (!factory.providerManaged) {
+      const override = readConnectorsOverride(chainType, walletConfig);
+      const connectors = override ? narrowConnectors(override, chainType) : factory.defaultConnectors(walletConfig);
+      service.setXConnectors(connectors);
+      xConnectorsByChain[chainType] = connectors;
+      chainActions[chainType] = factory.createActions ? factory.createActions(service, getStore) : createDefaultActions(chainType, service, getStore);
+      if (factory.discoverConnectors) {
+        factory.discoverConnectors(service, getStore).catch((err) => {
+          console.warn(`[wallet-sdk-react] discoverConnectors failed for ${chainType}:`, err);
+        });
+      }
+    }
+  }
+  return { xServices, xConnectorsByChain, enabledChains, chainActions };
+};
+
+// src/useXWalletStore.ts
+var useXWalletStore = create()(
+  devtools(
+    persist(
+      immer((set, get) => ({
+        xServices: {},
+        xConnections: {},
+        xConnectorsByChain: {},
+        enabledChains: [],
+        chainActions: {},
+        walletProviders: {},
+        walletConfig: void 0,
+        userDisconnected: {},
+        setXConnection: (xChainType, xConnection) => {
+          set((state) => {
+            state.xConnections[xChainType] = xConnection;
+          });
+          const factory = chainRegistry[xChainType]?.createWalletProvider;
+          if (factory) {
+            const service = get().xServices[xChainType];
+            if (service) {
+              const provider = factory(service, () => get());
+              get().setWalletProvider(xChainType, provider);
+            }
+          }
+        },
+        unsetXConnection: (xChainType) => {
+          set((state) => {
+            delete state.xConnections[xChainType];
+            delete state.walletProviders[xChainType];
+          });
+        },
+        setXConnectors: (xChainType, connectors) => {
+          set((state) => {
+            state.xConnectorsByChain[xChainType] = connectors;
+          });
+        },
+        registerChainActions: (xChainType, actions) => {
+          set((state) => {
+            state.chainActions[xChainType] = actions;
+          });
+        },
+        setWalletProvider: (xChainType, provider) => {
+          set((state) => {
+            if (provider) {
+              state.walletProviders[xChainType] = provider;
+            } else {
+              delete state.walletProviders[xChainType];
+            }
+          });
+        },
+        getWalletProvider: (xChainType) => {
+          if (!xChainType) return void 0;
+          return get().walletProviders[xChainType];
+        },
+        initChainServices: (walletConfig) => {
+          const result = createChainServices(walletConfig, () => get());
+          set((state) => {
+            state.xServices = result.xServices;
+            state.enabledChains = result.enabledChains;
+            Object.assign(state.xConnectorsByChain, result.xConnectorsByChain);
+            Object.assign(state.chainActions, result.chainActions);
+          });
+          set({ walletConfig });
+        },
+        cleanupDisabledConnections: () => {
+          set((state) => {
+            for (const chainType of 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: createJSONStorage(() => localStorage),
+        partialize: (state) => ({
+          xConnections: state.xConnections,
+          userDisconnected: state.userDisconnected
+        })
+      }
+    ),
+    { name: "xwagmi-store" }
+  )
+);
+
+// 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;
+}
+
+// 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 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 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 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 CHAIN_KEYS) {
+    if (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 useMemo(
+    () => buildChainGroups(enabledChains, xConnections, chainRegistry, order),
+    [enabledChains, xConnections, order]
+  );
+}
+function buildConnectedChains(xConnections, xConnectorsByChain, isReady = true, order) {
+  const chains = [];
+  for (const chainType of 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 = useSyncExternalStore(
+    subscribeHydration,
+    () => useXWalletStore.persist.hasHydrated(),
+    () => false
+  );
+  return useMemo(
+    () => buildConnectedChains(xConnections, xConnectorsByChain, isReady, order),
+    [xConnections, xConnectorsByChain, isReady, order]
+  );
+}
+function useXDisconnect() {
+  const actionsRegistry = useXWalletStore((state) => state.chainActions);
+  return 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 disconnect = useXDisconnect();
+  const [error, setError] = useState(null);
+  const [activeConnector, setActiveConnector] = useState(null);
+  const lastConnectorRef = useRef(null);
+  const connect = 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 = useCallback(async () => {
+    const last = lastConnectorRef.current;
+    if (!last) return void 0;
+    return connect(last);
+  }, [connect]);
+  const reset = 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,
+    retry,
+    reset
+  };
+}
+function resolveBatchTargets(connectors, connectorsByChain) {
+  const targets = [];
+  for (const chainType of 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] = useState("idle");
+  const [result, setResult] = useState(null);
+  const inFlightRef = useRef(null);
+  const onProgressRef = useRef(onProgress);
+  onProgressRef.current = onProgress;
+  const run = 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)
+      });
+      setResult(finalResult);
+      setStatus("done");
+      return finalResult;
+    })();
+    inFlightRef.current = batchPromise;
+    try {
+      return await batchPromise;
+    } finally {
+      inFlightRef.current = null;
+    }
+  }, [connect, connectors, xConnectorsByChain, xConnections, skipConnected]);
+  const reset = useCallback(() => {
+    setStatus("idle");
+    setResult(null);
+  }, []);
+  return { run, status, result, reset };
+}
+function resolveDisconnectTargets(connectors, xConnections, xConnectorsByChain) {
+  const targets = [];
+  for (const chainType of 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, disconnect, onProgress) {
+  const successful = [];
+  const failed = [];
+  const emit = (event) => {
+    if (!onProgress) return;
+    try {
+      onProgress(event);
+    } catch (err) {
+      console.error("[useBatchDisconnect] onProgress threw:", err);
+    }
+  };
+  for (const chainType of chainTypes) {
+    try {
+      await disconnect({ 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 disconnect = useXDisconnect();
+  const xConnections = useXConnections();
+  const xConnectorsByChain = useXConnectorsByChain();
+  const [status, setStatus] = useState("idle");
+  const [result, setResult] = useState(null);
+  const inFlightRef = useRef(null);
+  const onProgressRef = useRef(onProgress);
+  onProgressRef.current = onProgress;
+  const run = useCallback(async () => {
+    if (inFlightRef.current) return inFlightRef.current;
+    const batchPromise = (async () => {
+      setStatus("running");
+      const targets = resolveDisconnectTargets(connectors, xConnections, xConnectorsByChain);
+      const finalResult = await runBatchDisconnect(targets, disconnect, (event) => onProgressRef.current?.(event));
+      setResult(finalResult);
+      setStatus("done");
+      return finalResult;
+    })();
+    inFlightRef.current = batchPromise;
+    try {
+      return await batchPromise;
+    } finally {
+      inFlightRef.current = null;
+    }
+  }, [connectors, disconnect, xConnections, xConnectorsByChain]);
+  const reset = useCallback(() => {
+    setStatus("idle");
+    setResult(null);
+  }, []);
+  return { run, status, result, reset };
+}
+var useWalletModalStore = create()(
+  devtools(
+    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 = useRef(null);
+  const selectWallet = 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 = 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 = createContext(null);
+var WalletConfigProvider = WalletConfigContext.Provider;
+function useWalletConfig() {
+  const config = 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] = useState(null);
+  useEffect(() => {
+    if (!injectiveXService?.walletStrategy?.getWallet()) return;
+    const walletStrategy = injectiveXService.walletStrategy;
+    if (walletStrategy.getWallet() !== 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 = 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 } = useAccount();
+  const isWrongChain = useMemo(() => {
+    return xChainType === "EVM" && chainId !== expectedChainId || xChainType === "INJECTIVE" && injectiveXService !== void 0 && injectiveXService.walletStrategy.getWallet() === Wallet.Metamask && ethereumChainId !== mainnet.id;
+  }, [xChainType, chainId, expectedChainId, ethereumChainId, injectiveXService]);
+  const { switchChain } = useSwitchChain();
+  const handleSwitchChain = useCallback(() => {
+    if (xChainType === "INJECTIVE") {
+      switchEthereumChain();
+    } else if (xChainType === "EVM" && typeof expectedChainId === "number") {
+      switchChain({ chainId: expectedChainId });
+    }
+  }, [switchChain, expectedChainId, xChainType]);
+  return 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 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/useBitcoinXConnectors.ts
+function useBitcoinXConnectors() {
+  const xService = useXService({ xChainType: "BITCOIN" });
+  return useMemo(() => {
+    const connectors = xService?.getXConnectors() ?? [];
+    return connectors.filter((c) => c instanceof BitcoinXConnector);
+  }, [xService]);
+}
+
+export { BitcoinXConnector, BitcoinXService, OKXXConnector, UnisatXConnector, WalletConfigProvider, XverseXConnector, chainRegistry, getXChainType, getXService, useBatchConnect, useBatchDisconnect, useBitcoinXConnectors, useChainGroups, useConnectedChains, useConnectionFlow, useEnabledChainTypes, useEnabledChains, useEvmSwitchChain, useIsChainEnabled, useIsWalletInstalled, useWalletConfig, useWalletModal, useWalletProvider, useXAccount, useXAccounts, useXConnect, useXConnection, useXConnections, useXConnectors, useXConnectorsByChain, useXDisconnect, useXService, useXServices, useXSignMessage, useXWalletStore };
+//# sourceMappingURL=chunk-PLCA4ZDJ.mjs.map
+//# sourceMappingURL=chunk-PLCA4ZDJ.mjs.map