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

package/dist/index.mjs

@@ -1,2079 +1,538 @@
-import { detectBitcoinAddressType, baseChainInfo, KAIA_MAINNET_CHAIN_ID, REDBELLY_MAINNET_CHAIN_ID, LIGHTLINK_MAINNET_CHAIN_ID, HYPEREVM_MAINNET_CHAIN_ID, POLYGON_MAINNET_CHAIN_ID, OPTIMISM_MAINNET_CHAIN_ID, SONIC_MAINNET_CHAIN_ID, BSC_MAINNET_CHAIN_ID, BASE_MAINNET_CHAIN_ID, ARBITRUM_MAINNET_CHAIN_ID, AVALANCHE_MAINNET_CHAIN_ID, ETHEREUM_MAINNET_CHAIN_ID, ChainTypeArr } from '@sodax/types';
-import { NearConnector } from '@hot-labs/near-connect';
-import { JsonRpcProvider } from 'near-api-js';
-import { fetchCallReadOnlyFunction, Cl } from '@stacks/transactions';
-import { networkFrom, createNetwork } from '@stacks/network';
-import { AddressPurpose, MessageSigningProtocols } from 'sats-connect';
-import React2, { useMemo, useCallback, useEffect } from 'react';
-import { useCurrentAccount, useCurrentWallet, useConnectWallet, useWallets, useDisconnectWallet, useSignPersonalMessage, SuiClientProvider, WalletProvider, useSuiClient } from '@mysten/dapp-kit';
-import { useWallet, ConnectionProvider, WalletProvider as WalletProvider$1, useConnection } from '@solana/wallet-adapter-react';
-import { createConfig, createStorage, http, cookieStorage, useConnections, useAccount, useConnect, useConnectors, useDisconnect, useSwitchChain, usePublicClient, useWalletClient, useSignMessage, WagmiProvider, useConfig } from 'wagmi';
-import { create } from 'zustand';
-import { devtools, persist, createJSONStorage } from 'zustand/middleware';
-import { immer } from 'zustand/middleware/immer';
-import { erc20Abi, defineChain } from 'viem';
-import { getPublicClient } from 'wagmi/actions';
-import { mainnet, avalanche, arbitrum, base, bsc, sonic, optimism, polygon, lightlinkPhoenix, kaia, redbellyMainnet } from 'wagmi/chains';
-import { getNetworkEndpoints, Network } from '@injectivelabs/networks';
-import { getInjectiveAddress, IndexerGrpcAccountPortfolioApi, ChainGrpcWasmApi, getEthereumAddress } from '@injectivelabs/sdk-ts';
-import { ChainId } from '@injectivelabs/ts-types';
-import { MsgBroadcaster } from '@injectivelabs/wallet-core';
-import { WalletStrategy } from '@injectivelabs/wallet-strategy';
-import { Wallet, isEvmBrowserWallet, isCosmosBrowserWallet } from '@injectivelabs/wallet-base';
-import { isCosmosWalletInstalled } from '@injectivelabs/wallet-cosmos';
-import { PublicKey } from '@solana/web3.js';
-import { getAssociatedTokenAddressSync, getAccount } from '@solana/spl-token';
-import { StellarWalletsKit, allowAllModules, WalletNetwork } from '@creit.tech/stellar-wallets-kit';
-import * as StellarSdk from '@stellar/stellar-sdk';
-import { SorobanRpc, Address, Contract, TimeoutInfinite, scValToBigInt, xdr } from '@stellar/stellar-sdk';
-import * as IconSdkRaw from 'icon-sdk-js';
-import { request as request$1, disconnect } from '@stacks/connect';
-import { QueryClient, useMutation, useQuery, QueryClientProvider } from '@tanstack/react-query';
-import { mainnet as mainnet$1 } from 'viem/chains';
-import { StacksWalletProvider, NearWalletProvider, SolanaWalletProvider, StellarWalletProvider, InjectiveWalletProvider, IconWalletProvider, SuiWalletProvider, EvmWalletProvider } from '@sodax/wallet-sdk-core';
+import { WalletConfigProvider, useXWalletStore, chainRegistry, useWalletConfig } from './chunk-PLCA4ZDJ.mjs';
+export { WalletConfigProvider, getXChainType, getXService, useBatchConnect, useBatchDisconnect, useChainGroups, useConnectedChains, useConnectionFlow, useEnabledChainTypes, useEnabledChains, useEvmSwitchChain, useIsChainEnabled, useIsWalletInstalled, useWalletConfig, useWalletModal, useWalletProvider, useXAccount, useXAccounts, useXConnect, useXConnection, useXConnections, useXConnectors, useXConnectorsByChain, useXDisconnect, useXService, useXServices, useXSignMessage } from './chunk-PLCA4ZDJ.mjs';
+import { StellarXService } from './chunk-66BAUK56.mjs';
+import { SuiXService, SuiXConnector } from './chunk-7ULB6DW4.mjs';
+import { createWagmiConfig, EvmXService, EvmXConnector } from './chunk-E5IAZ7E6.mjs';
+import { request } from './chunk-2BOUGCJ7.mjs';
+import { assertSuiProviderShape } from './chunk-MAQ47Q52.mjs';
+import { InjectiveXService } from './chunk-BKJB527E.mjs';
+import './chunk-BXJLBR4G.mjs';
+import { SOLANA_DEFAULT_AUTO_CONNECT, SOLANA_DEFAULT_RPC_URL, SUI_DEFAULT_AUTO_CONNECT, SUI_DEFAULT_NETWORK, EVM_DEFAULT_RECONNECT_ON_MOUNT, EVM_DEFAULT_SSR, SOLANA_METAMASK_CONNECT_TIMEOUT_MS } from './chunk-MXZVF5HR.mjs';
+import { SolanaXConnector } from './chunk-N5A2TMF6.mjs';
+import { SolanaXService } from './chunk-XZ7CHO2S.mjs';
+import { getEntryDefaults, resolveEvmDefaults } from './chunk-NY7U7OJW.mjs';
+export { getEntryDefaults, getRpcUrl, getWagmiChainId, isNativeToken, resolveEvmDefaults, sortConnectors } from './chunk-NY7U7OJW.mjs';
+import './chunk-PJLEJVAU.mjs';
+import './chunk-TZMKDXFA.mjs';
+export { XConnector, XService } from './chunk-X2MHIWXO.mjs';
+import { useRef, useEffect, useMemo, useState } from 'react';
+import { WagmiProvider, useConfig, useConnectors, useAccount, usePublicClient, useWalletClient, useReconnect, useConnect, useDisconnect, useSignMessage } from 'wagmi';
+import { walletConnect } from 'wagmi/connectors';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { SolanaWalletProvider, SuiWalletProvider, EvmWalletProvider } from '@sodax/wallet-sdk-core';
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+import { ConnectionProvider, WalletProvider, useConnection, useWallet } from '@solana/wallet-adapter-react';
+import { ChainKeys } from '@sodax/types';
+import { SuiClientProvider, WalletProvider as WalletProvider$1, useSuiClient, useCurrentWallet, useCurrentAccount, useWallets, useConnectWallet, useDisconnectWallet, useSignPersonalMessage } from '@mysten/dapp-kit';
 import { getFullnodeUrl } from '@mysten/sui/client';
-import { UnsafeBurnerWalletAdapter } from '@solana/wallet-adapter-wallets';
+import { isEvmBrowserWallet, Wallet } from '@injectivelabs/wallet-base';
+import { getInjectiveAddress } from '@injectivelabs/sdk-ts';
 
-// src/actions/getXChainType.ts
-function getXChainType(xChainId) {
-  if (!xChainId) {
-    return void 0;
-  }
-  return baseChainInfo[xChainId].type;
-}
-
-// src/core/XService.ts
-var XService = class {
-  constructor(xChainType) {
-    /** Available wallet connectors for this chain */
-    this.xConnectors = [];
-    this.xChainType = xChainType;
-  }
-  /**
-   * Gets the balance of a specific token for an address
-   * @param address The wallet address to check
-   * @param xToken The token to get the balance for
-   * @returns Promise resolving to the token balance as a bigint
-   */
-  async getBalance(address, xToken) {
-    return 0n;
-  }
-  /**
-   * Gets balances for multiple tokens for an address
-   * @param address The wallet address to check
-   * @param xTokens Array of tokens to get balances for
-   * @returns Promise resolving to object mapping token addresses to balances
-   */
-  async getBalances(address, xTokens) {
-    if (!address) return {};
-    const balancePromises = xTokens.map(async (xToken) => {
-      const balance = await this.getBalance(address, xToken);
-      return { address: xToken.address, balance };
-    });
-    const balances = await Promise.all(balancePromises);
-    return balances.reduce((acc, { address: address2, balance }) => {
-      acc[address2] = balance;
-      return acc;
-    }, {});
-  }
-  /**
-   * Gets all available connectors for this chain
-   */
-  getXConnectors() {
-    return this.xConnectors;
-  }
-  /**
-   * Sets the available connectors for this chain
-   */
-  setXConnectors(xConnectors) {
-    this.xConnectors = xConnectors;
-  }
-  /**
-   * Gets a specific connector by its ID
-   * @param xConnectorId The connector ID to look up
-   * @returns The matching connector or undefined if not found
-   */
-  getXConnectorById(xConnectorId) {
-    return this.getXConnectors().find((xConnector) => xConnector.id === xConnectorId);
-  }
-};
-var NearXService = class _NearXService extends XService {
-  constructor() {
-    super("NEAR");
-    this.walletSelector = new 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 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 = 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 fetchCallReadOnlyFunction({
-        contractAddress,
-        contractName,
-        functionName: "get-balance",
-        functionArgs: [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 {
-  constructor(xChainType, name, id) {
-    this.xChainType = xChainType;
-    this.name = name;
-    this._id = id;
-  }
-  /** Get the unique identifier for this connector */
-  get id() {
-    return this._id;
-  }
-  /** Get the optional icon URL for this wallet provider */
-  get icon() {
-    return this._icon;
-  }
-};
-var isNativeToken = (xToken) => {
-  const nativeAddresses = [
-    "cx0000000000000000000000000000000000000000",
-    "0x0000000000000000000000000000000000000000",
-    "inj",
-    "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI",
-    "hx0000000000000000000000000000000000000000",
-    "11111111111111111111111111111111",
-    // solana
-    "CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA",
-    // stellar
-    "ST000000000000000000002AMW42H.nativetoken",
-    // stacks
-    "0:0"
-    // bitcoin
-  ];
-  return nativeAddresses.includes(xToken.address);
-};
-var getWagmiChainId = (xChainId) => {
-  return baseChainInfo[xChainId].chainId;
-};
-
-// src/xchains/bitcoin/BitcoinXService.ts
-var BitcoinXService = class _BitcoinXService extends XService {
-  constructor(rpcUrl = "https://mempool.space/api") {
-    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 {
-  constructor(name, id) {
-    super("BITCOIN", name, id);
-  }
-  getXService() {
-    return BitcoinXService.getInstance();
-  }
-};
-var UnisatWalletProvider = class {
-  constructor(unisat, address) {
-    this.unisat = unisat;
-    this.cachedAddress = address;
-  }
-  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 = 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");
-  }
-  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 extends BitcoinXConnector {
-  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";
-  }
-  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) return void 0;
-    this.walletProvider = new UnisatWalletProvider(window.unisat, address);
-    return {
-      address,
-      xChainType: "BITCOIN"
-    };
-  }
-  async disconnect() {
-    this.walletProvider = void 0;
-  }
-  getWalletProvider() {
-    return this.walletProvider;
-  }
-  recreateWalletProvider(xAccount) {
-    if (!window.unisat || !xAccount.address) return void 0;
-    return new UnisatWalletProvider(window.unisat, xAccount.address);
-  }
-};
-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 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 = 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");
-    }
-    return result.psbt;
-  }
-  async signEcdsaMessage(message) {
-    const { request: request3 } = await import('sats-connect');
-    const response = await request3("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: request3 } = await import('sats-connect');
-    const response = await request3("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: request3 } = await import('sats-connect');
-    const response = await request3("sendTransfer", {
-      recipients: [
-        {
-          address: toAddress,
-          amount: Number(satoshis)
-        }
-      ]
-    });
-    if (response.status === "error") {
-      throw new Error(response.error?.message || "Xverse sendTransfer failed");
-    }
-    return response.result.txid;
-  }
-};
-var XVERSE_ADDRESS_TYPE_KEY = "xverse-address-type";
-var XverseXConnector = class _XverseXConnector extends BitcoinXConnector {
-  constructor() {
-    super("Xverse", "xverse");
-    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 icon() {
-    return "https://cdn.brandfetch.io/iddzGN5Rcv/w/400/h/400/theme/dark/icon.jpeg?c=1bxid64Mup7aczewSAYMX&t=1771902357797";
-  }
-  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"
-    };
-  }
-  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);
-  }
-};
-var OKXWalletProvider = class {
-  constructor(okx, address) {
-    this.okx = okx;
-    this.cachedAddress = address;
-  }
-  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 = false) {
-    const psbtHex = Buffer.from(psbtBase64, "base64").toString("hex");
-    return this.okx.signPsbt(psbtHex, { autoFinalized: finalize });
-  }
-  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 extends BitcoinXConnector {
-  constructor() {
-    super("OKX Wallet", "okx-bitcoin");
-  }
-  static isAvailable() {
-    return typeof window !== "undefined" && !!window.okxwallet?.bitcoin;
-  }
-  get icon() {
-    return "https://static.okx.com/cdn/assets/imgs/247/58E63FEA47A2B7D7.png";
-  }
-  async connect() {
-    const okx = window.okxwallet?.bitcoin;
-    if (!okx) {
-      throw new Error("OKX wallet is not installed");
-    }
-    const { address } = await okx.connect();
-    if (!address) return void 0;
-    this.walletProvider = new OKXWalletProvider(okx, address);
-    return {
-      address,
-      xChainType: "BITCOIN"
-    };
-  }
-  async disconnect() {
-    this.walletProvider = void 0;
-  }
-  getWalletProvider() {
-    return this.walletProvider;
-  }
-  recreateWalletProvider(xAccount) {
-    const okx = window.okxwallet?.bitcoin;
-    if (!okx || !xAccount.address) return void 0;
-    return new OKXWalletProvider(okx, xAccount.address);
-  }
-};
-var hyper = /* @__PURE__ */ 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
-    }
-  }
-});
-var createWagmiConfig = (config, options) => {
-  return createConfig({
-    chains: [
-      mainnet,
-      avalanche,
-      arbitrum,
-      base,
-      bsc,
-      sonic,
-      optimism,
-      polygon,
-      hyper,
-      lightlinkPhoenix,
-      kaia,
-      redbellyMainnet
-    ],
-    ssr: options?.ssr,
-    transports: {
-      [mainnet.id]: http(config[ETHEREUM_MAINNET_CHAIN_ID]),
-      [avalanche.id]: http(config[AVALANCHE_MAINNET_CHAIN_ID]),
-      [arbitrum.id]: http(config[ARBITRUM_MAINNET_CHAIN_ID]),
-      [base.id]: http(config[BASE_MAINNET_CHAIN_ID]),
-      [bsc.id]: http(config[BSC_MAINNET_CHAIN_ID]),
-      [sonic.id]: http(config[SONIC_MAINNET_CHAIN_ID]),
-      [optimism.id]: http(config[OPTIMISM_MAINNET_CHAIN_ID]),
-      [polygon.id]: http(config[POLYGON_MAINNET_CHAIN_ID]),
-      [hyper.id]: http(config[HYPEREVM_MAINNET_CHAIN_ID]),
-      [lightlinkPhoenix.id]: http(config[LIGHTLINK_MAINNET_CHAIN_ID]),
-      [redbellyMainnet.id]: http(config[REDBELLY_MAINNET_CHAIN_ID]),
-      [kaia.id]: http(config[KAIA_MAINNET_CHAIN_ID])
-    },
-    storage: createStorage({
-      storage: cookieStorage,
-      key: "sodax"
-    })
-  });
-};
-var EvmXService = class _EvmXService extends XService {
-  constructor() {
-    super("EVM");
-  }
-  getXConnectors() {
-    return [];
-  }
-  static getInstance() {
-    if (!_EvmXService.instance) {
-      _EvmXService.instance = new _EvmXService();
-    }
-    return _EvmXService.instance;
-  }
-  // get erc20 token balance in a chain (evm chain only)
-  async _getTokenBalance(address, chainId, tokenAddress) {
-    const publicClient = getPublicClient(this.wagmiConfig, { chainId });
-    if (!publicClient) throw new Error("Public client not found");
-    const balance = await publicClient.readContract({
-      abi: 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 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 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 = 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: 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);
-    }
-    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] || "0";
-      return acc;
-    }, tokenMap);
-  }
-};
-
-// src/xchains/evm/EvmXConnector.ts
-var EvmXConnector = class extends XConnector {
-  constructor(connector) {
-    super("EVM", connector.name, connector.id);
-    this.connector = connector;
-  }
-  async connect() {
-    return;
-  }
-  async disconnect() {
-    return;
-  }
-  get id() {
-    return this.connector.id;
-  }
-  get icon() {
-    return this.connector.icon;
-  }
-};
-var InjectiveXService = class _InjectiveXService extends XService {
-  constructor() {
-    super("INJECTIVE");
-    const endpoints = getNetworkEndpoints(Network.Mainnet);
-    this.walletStrategy = new WalletStrategy({
-      chainId: ChainId.Mainnet,
-      strategies: {},
-      evmOptions: {
-        evmChainId: mainnet.id,
-        rpcUrl: mainnet.rpcUrls.default.http[0]
-      }
-    });
-    this.indexerGrpcAccountPortfolioApi = new IndexerGrpcAccountPortfolioApi(endpoints.indexer);
-    this.chainGrpcWasmApi = new ChainGrpcWasmApi(endpoints.grpc);
-    this.msgBroadcaster = new MsgBroadcaster({
-      walletStrategy: this.walletStrategy,
-      network: Network.Mainnet,
-      endpoints
-    });
-  }
-  static getInstance() {
-    if (!_InjectiveXService.instance) {
-      _InjectiveXService.instance = new _InjectiveXService();
-    }
-    return _InjectiveXService.instance;
-  }
-  async getBalance(address, xToken) {
-    if (!address) return 0n;
-    const portfolio = await this.indexerGrpcAccountPortfolioApi.fetchAccountPortfolioBalances(address);
-    const xTokenAddress = xToken.address;
-    const balance = portfolio.bankBalancesList.find((_balance) => _balance.denom === xTokenAddress);
-    if (balance) {
-      return BigInt(balance.amount);
-    }
-    return 0n;
-  }
-};
-var WALLET_ICONS = {
-  metamask: "https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/metamask.svg",
-  keplr: "https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/keplr.svg",
-  leap: "https://assets.leapwallet.io/logos/leap-cosmos-logo.svg",
-  rabby: "https://raw.githubusercontent.com/RabbyHub/logo/master/symbol.svg",
-  phantom: "https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/phantom.svg",
-  "okx-wallet": "https://static.okx.com/cdn/assets/imgs/247/58E63FEA47A2B7D7.png",
-  "trust-wallet": "https://trustwallet.com/assets/images/media/assets/twLogo.svg"
-};
-var InjectiveXConnector = class extends XConnector {
-  constructor(name, wallet) {
-    super("INJECTIVE", name, wallet);
-    this.wallet = wallet;
-  }
-  getXService() {
-    return InjectiveXService.getInstance();
-  }
-  async connect() {
-    if (isCosmosBrowserWallet(this.wallet) && !isCosmosWalletInstalled(this.wallet)) {
-      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 = isEvmBrowserWallet(this.wallet) ? getInjectiveAddress(addresses[0]) : addresses[0];
-    return {
-      address,
-      xChainType: this.xChainType
-    };
-  }
-  async disconnect() {
-    if (isEvmBrowserWallet(this.wallet)) {
-      const walletStrategy = this.getXService().walletStrategy;
-      await walletStrategy.setWallet(this.wallet);
-      await walletStrategy.disconnect();
-    }
-  }
-  get icon() {
-    return WALLET_ICONS[this.wallet];
-  }
-};
-var SolanaXService = class _SolanaXService extends XService {
-  constructor() {
-    super("SOLANA");
-  }
-  static getInstance() {
-    if (!_SolanaXService.instance) {
-      _SolanaXService.instance = new _SolanaXService();
-    }
-    return _SolanaXService.instance;
-  }
-  async getBalance(address, xToken) {
-    if (!address) return BigInt(0);
-    const connection = this.connection;
-    if (!connection) {
-      return BigInt(0);
-    }
-    try {
-      if (isNativeToken(xToken)) {
-        const newBalance = await connection.getBalance(new PublicKey(address));
-        return BigInt(newBalance);
-      }
-      const tokenAccountPubkey = getAssociatedTokenAddressSync(new PublicKey(xToken.address), new PublicKey(address));
-      const tokenAccount = await getAccount(connection, tokenAccountPubkey);
-      return BigInt(tokenAccount.amount);
-    } catch {
-      return BigInt(0);
-    }
-  }
-};
-var CustomSorobanServer = class extends SorobanRpc.Server {
-  constructor(serverUrl, customHeaders) {
-    super(serverUrl, {
-      allowHttp: true
-    });
-    this.customHeaders = customHeaders;
-  }
-  async simulateTransaction(tx) {
-    const requestOptions = {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.customHeaders
-      },
-      body: JSON.stringify({
-        id: 1,
-        jsonrpc: "2.0",
-        method: "simulateTransaction",
-        params: {
-          transaction: tx.toXDR()
-        }
-      })
-    };
-    const response = await fetch(`${this.serverURL}`, requestOptions);
-    if (!response.ok) {
-      throw new Error(`HTTP error simulating TX! status: ${response.status}`);
-    }
-    return response.json().then((json) => json.result);
-  }
-  async sendTransaction(tx) {
-    const requestOptions = {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.customHeaders
-      },
-      body: JSON.stringify({
-        id: 1,
-        jsonrpc: "2.0",
-        method: "sendTransaction",
-        params: {
-          transaction: tx.toXDR()
-        }
-      })
-    };
-    const response = await fetch(`${this.serverURL}`, requestOptions);
-    if (!response.ok) {
-      throw new Error(`HTTP error submitting TX! status: ${response.status}`);
-    }
-    return response.json().then((json) => json.result);
-  }
-  async getTransaction(hash) {
-    const requestOptions = {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.customHeaders
-      },
-      body: JSON.stringify({
-        id: 1,
-        jsonrpc: "2.0",
-        method: "getTransaction",
-        params: { hash }
-      })
-    };
-    const response = await fetch(`${this.serverURL}`, requestOptions);
-    if (!response.ok) {
-      throw new Error(`HTTP error getting TX! status: ${response.status}`);
-    }
-    return response.json().then((json) => json.result);
-  }
-};
-var CustomSorobanServer_default = CustomSorobanServer;
-var accountToScVal = (account) => new Address(account).toScVal();
-var simulateTx = async (tx, server) => {
-  const response = await server.simulateTransaction(tx);
-  if (response !== void 0) {
-    return response;
-  }
-  throw new Error("cannot simulate transaction");
-};
-var getTokenBalance = async (address, tokenId, txBuilder, server) => {
-  const params = [accountToScVal(address)];
-  const contract = new Contract(tokenId);
-  const tx = txBuilder.addOperation(contract.call("balance", ...params)).setTimeout(TimeoutInfinite).build();
-  const result = await simulateTx(tx, server);
-  return result.results ? scValToBigInt(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({
-      network: WalletNetwork.PUBLIC,
-      modules: allowAllModules()
-    });
-    this.server = new StellarSdk.Horizon.Server("https://horizon.stellar.org", { allowHttp: true });
-    this.sorobanServer = new CustomSorobanServer_default("https://rpc.ankr.com/stellar_soroban", {});
-  }
-  static getInstance() {
-    if (!_StellarXService.instance) {
-      _StellarXService.instance = new _StellarXService();
-    }
-    return _StellarXService.instance;
-  }
-  async getBalance(address, xToken) {
-    if (!address) return BigInt(0);
-    const stellarAccount = await this.server.loadAccount(address);
-    if (xToken.symbol === "XLM") {
-      const xlmBalance = stellarAccount.balances.find((balance) => balance.asset_type === "native");
-      if (xlmBalance) {
-        const rawBalanceStroops = parseXlmBalanceToStroops(xlmBalance.balance);
-        const sellingLiabilitiesStroops = xlmBalance.selling_liabilities ? parseXlmBalanceToStroops(xlmBalance.selling_liabilities) : BigInt(0);
-        const reserveFields = stellarAccount;
-        const subentryCount = reserveFields.subentry_count ?? 0;
-        const numSponsoring = reserveFields.num_sponsoring ?? 0;
-        const numSponsored = reserveFields.num_sponsored ?? 0;
-        const reserveCount = Math.max(0, 2 + subentryCount + numSponsoring - numSponsored);
-        const minBalanceStroops = BigInt(reserveCount) * BigInt(STELLAR_BASE_RESERVE_STROOPS) + sellingLiabilitiesStroops;
-        const availableStroops = rawBalanceStroops > minBalanceStroops ? rawBalanceStroops - minBalanceStroops : BigInt(0);
-        return availableStroops;
-      }
-    } else {
-      try {
-        const txBuilder = new StellarSdk.TransactionBuilder(stellarAccount, {
-          fee: StellarSdk.BASE_FEE,
-          networkPassphrase: StellarSdk.Networks.PUBLIC
-        });
-        const balance = await getTokenBalance(address, xToken.address, txBuilder, this.sorobanServer);
-        return balance;
-      } catch (e) {
-        console.error(`Error while fetching token on Stellar: ${xToken.symbol}, Error: ${e}`);
-      }
-    }
-    return BigInt(0);
-  }
-};
-
-// src/xchains/stellar/StellarWalletsKitXConnector.ts
-var StellarWalletsKitXConnector = class extends XConnector {
-  constructor(wallet) {
-    super("STELLAR", wallet.name, wallet.id);
-    this._wallet = wallet;
-  }
-  getXService() {
-    return StellarXService.getInstance();
-  }
-  async connect() {
-    const kit = this.getXService().walletsKit;
-    if (!this._wallet) {
-      return;
-    }
-    if (!this._wallet.isAvailable && this._wallet.url) {
-      window.open(this._wallet.url, "_blank");
-      return;
-    }
-    kit.setWallet(this._wallet.id);
-    const { address } = await kit.getAddress();
-    return {
-      address,
-      xChainType: this.xChainType
-    };
-  }
-  async disconnect() {
-  }
-  get icon() {
-    return this._wallet.icon;
-  }
-};
-
-// src/xchains/sui/SuiXService.ts
-var SuiXService = class _SuiXService extends XService {
-  // TODO: define suiAccount type
-  constructor() {
-    super("SUI");
-  }
-  static getInstance() {
-    if (!_SuiXService.instance) {
-      _SuiXService.instance = new _SuiXService();
-    }
-    return _SuiXService.instance;
-  }
-  // 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;
-        }
-      });
-      return tokenMap;
-    } catch (e) {
-      console.log("error", e);
-      return {};
-    }
-  }
-};
-
-// src/xchains/sui/SuiXConnector.ts
-var SuiXConnector = class extends XConnector {
-  constructor(wallet) {
-    super("SUI", wallet?.name, wallet?.name);
-    this.wallet = wallet;
-  }
-  getXService() {
-    return SuiXService.getInstance();
-  }
-  async connect() {
-    return;
-  }
-  async disconnect() {
-  }
-  get icon() {
-    return this.wallet?.icon;
-  }
-};
-var IconSdk = "default" in IconSdkRaw.default ? IconSdkRaw.default : IconSdkRaw;
-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)
-    );
-  }
-  static getInstance() {
-    if (!_IconXService.instance) {
-      _IconXService.instance = new _IconXService();
-    }
-    return _IconXService.instance;
-  }
-  async getAggregateData(requireSuccess, calls) {
-    const rawTx = new IconBuilder.CallBuilder().to("cxa4aa9185e23558cff990f494c1fd2845f6cbf741").method("tryAggregate").params({ requireSuccess: IconConverter.toHex(requireSuccess ? 1 : 0), calls }).build();
-    try {
-      const result = await this.iconService.call(rawTx).execute();
-      const aggs = result["returnData"];
-      const data = aggs.map((agg) => {
-        if (agg["success"] === "0x0") {
-          return null;
-        }
-        return agg["returnData"];
-      });
-      return data;
-    } catch (err) {
-      console.error(err);
-      return Array(calls.length).fill(null);
-    }
-  }
-  async getBalances(address, xTokens) {
-    if (!address) return {};
-    const balances = {};
-    const nativeXToken = xTokens.find((xToken) => isNativeToken(xToken));
-    const nonNativeXTokens = xTokens.filter((xToken) => !isNativeToken(xToken));
-    if (nativeXToken) {
-      const balance = await this.iconService.getBalance(address).execute();
-      balances[nativeXToken.address] = BigInt(balance.toFixed());
-    }
-    const cds = nonNativeXTokens.map((token) => {
-      return {
-        target: token.address,
-        method: "balanceOf",
-        params: [address]
-      };
-    });
-    const data = await this.getAggregateData(
-      false,
-      cds.filter((cd) => cd.target.startsWith("cx"))
-    );
-    return nonNativeXTokens.reduce((agg, token, idx) => {
-      const balance = data[idx];
-      balances[token.address] = BigInt(balance);
-      return agg;
-    }, balances);
-  }
-};
-
-// src/xchains/icon/iconex/index.tsx
-var ICONEX_RELAY_RESPONSE = "ICONEX_RELAY_RESPONSE";
-var ICONEX_RELAY_REQUEST = "ICONEX_RELAY_REQUEST";
-var request = (event) => {
-  return new Promise((resolve, reject) => {
-    const handler = (evt) => {
-      window.removeEventListener(ICONEX_RELAY_RESPONSE, handler);
-      resolve(evt.detail);
-    };
-    window.addEventListener(ICONEX_RELAY_RESPONSE, handler);
-    window.dispatchEvent(
-      new CustomEvent(ICONEX_RELAY_REQUEST, {
-        detail: event
-      })
-    );
-  });
-};
-
-// src/xchains/icon/IconHanaXConnector.ts
-var IconHanaXConnector = class extends XConnector {
-  constructor() {
-    super("ICON", "Hana Wallet", "hana");
-  }
-  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
-      };
-    }
-    return void 0;
-  }
-  async disconnect() {
-    console.log("HanaIconXConnector disconnected");
-  }
-  get icon() {
-    return "https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/hana.svg";
-  }
-};
-function getProviderFromId(id) {
-  return id.split(".").reduce((acc, part) => acc?.[part], window);
-}
-var StacksXConnector = class extends XConnector {
-  constructor(config) {
-    super("STACKS", config.name, config.id);
-    this.config = config;
-  }
-  async connect() {
-    const provider = this.getProvider();
-    if (!provider) {
-      if (this.config.installUrl) {
-        window.open(this.config.installUrl, "_blank");
-      }
-      return void 0;
-    }
-    const response = await request$1({ provider }, "stx_getAddresses");
-    const stxAddress = response.addresses.find((a) => a.purpose === "stacks");
-    if (!stxAddress) {
-      return void 0;
-    }
-    return {
-      address: stxAddress.address,
-      xChainType: this.xChainType
-    };
-  }
-  async disconnect() {
-    disconnect();
-  }
-  get icon() {
-    return this.config.icon;
-  }
-  getProvider() {
-    return getProviderFromId(this.config.id);
-  }
-};
-
-// src/xchains/stacks/constants.ts
-var LEATHER_ICON = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTI4IiBoZWlnaHQ9IjEyOCIgdmlld0JveD0iMCAwIDEyOCAxMjgiIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxyZWN0IHdpZHRoPSIxMjgiIGhlaWdodD0iMTI4IiByeD0iMjYuODM4NyIgZmlsbD0iIzEyMTAwRiIvPgo8cGF0aCBkPSJNNzQuOTE3MSA1Mi43MTE0QzgyLjQ3NjYgNTEuNTQwOCA5My40MDg3IDQzLjU4MDQgOTMuNDA4NyAzNy4zNzYxQzkzLjQwODcgMzUuNTAzMSA5MS44OTY4IDM0LjIxNTQgODkuNjg3MSAzNC4yMTU0Qzg1LjUwMDQgMzQuMjE1NCA3OC40MDYxIDQwLjUzNjggNzQuOTE3MSA1Mi43MTE0Wk0zOS45MTEgODMuNDk5MUMzMC4wMjU2IDgzLjQ5OTEgMjkuMjExNSA5My4zMzI0IDM5LjA5NjkgOTMuMzMyNEM0My41MTYzIDkzLjMzMjQgNDguODY2MSA5MS41NzY0IDUxLjY1NzMgODguNDE1N0M0Ny41ODY4IDg0LjkwMzggNDQuMjE0MSA4My40OTkxIDM5LjkxMSA4My40OTkxWk0xMDIuODI5IDc5LjI4NDhDMTAzLjQxIDk1Ljc5MDcgOTUuMDM2OSAxMDUuMDM5IDgwLjg0ODQgMTA1LjAzOUM3Mi40NzQ4IDEwNS4wMzkgNjguMjg4MSAxMDEuODc4IDU5LjMzMyA5Ni4wMjQ5QzU0LjY4MSAxMDEuMTc2IDQ1Ljg0MjMgMTA1LjAzOSAzOC41MTU0IDEwNS4wMzlDMTMuMjc4NSAxMDUuMDM5IDE0LjMyNTIgNzIuODQ2MyA0MC4wMjczIDcyLjg0NjNDNDUuMzc3MSA3Mi44NDYzIDQ5LjkxMjggNzQuMjUxMSA1NS43Mjc3IDc3Ljg4TDU5LjU2NTYgNjQuNDE3N0M0My43NDg5IDYwLjA4NjQgMzUuODQwNSA0Ny45MTE4IDQzLjYzMjYgMzAuNDY5M0g1Ni4xOTI5QzQ5LjIxNSA0Mi4wNTg2IDUzLjk4MzIgNTEuNjU3OCA2Mi44MjIgNTIuNzExNEM2Ny41OTAzIDM1LjczNzIgNzcuODI0NiAyMi41MDkgOTEuNDMxNiAyMi41MDlDOTkuMTA3NCAyMi41MDkgMTA1LjE1NSAyNy41NDI4IDEwNS4xNTUgMzYuNjczN0MxMDUuMTU1IDUxLjMwNjYgODYuMDgxOSA2My4yNDcxIDcxLjY2MDcgNjQuNDE3N0w2NS43Mjk1IDg1LjM3MjFDNzIuNDc0OCA5My4yMTUzIDkxLjE5OSAxMDAuODI0IDkxLjE5OSA3OS4yODQ4SDEwMi44MjlaIiBmaWxsPSIjRjVGMUVEIi8+Cjwvc3ZnPgo=";
-var XVERSE_ICON = "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSI2MDAiIGhlaWdodD0iNjAwIj48ZyBmaWxsPSJub25lIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiPjxwYXRoIGZpbGw9IiMxNzE3MTciIGQ9Ik0wIDBoNjAwdjYwMEgweiIvPjxwYXRoIGZpbGw9IiNGRkYiIGZpbGwtcnVsZT0ibm9uemVybyIgZD0iTTQ0MCA0MzUuNHYtNTFjMC0yLS44LTMuOS0yLjItNS4zTDIyMCAxNjIuMmE3LjYgNy42IDAgMCAwLTUuNC0yLjJoLTUxLjFjLTIuNSAwLTQuNiAyLTQuNiA0LjZ2NDcuM2MwIDIgLjggNCAyLjIgNS40bDc4LjIgNzcuOGE0LjYgNC42IDAgMCAxIDAgNi41bC03OSA3OC43Yy0xIC45LTEuNCAyLTEuNCAzLjJ2NTJjMCAyLjQgMiA0LjUgNC42IDQuNUgyNDljMi42IDAgNC42LTIgNC42LTQuNlY0MDVjMC0xLjIuNS0yLjQgMS40LTMuM2w0Mi40LTQyLjJhNC42IDQuNiAwIDAgMSA2LjQgMGw3OC43IDc4LjRhNy42IDcuNiAwIDAgMCA1LjQgMi4yaDQ3LjVjMi41IDAgNC42LTIgNC42LTQuNloiLz48cGF0aCBmaWxsPSIjRUU3QTMwIiBmaWxsLXJ1bGU9Im5vbnplcm8iIGQ9Ik0zMjUuNiAyMjcuMmg0Mi44YzIuNiAwIDQuNiAyLjEgNC42IDQuNnY0Mi42YzAgNCA1IDYuMSA4IDMuMmw1OC43LTU4LjVjLjgtLjggMS4zLTIgMS4zLTMuMnYtNTEuMmMwLTIuNi0yLTQuNi00LjYtNC42TDM4NCAxNjBjLTEuMiAwLTIuNC41LTMuMyAxLjNsLTU4LjQgNTguMWE0LjYgNC42IDAgMCAwIDMuMiA3LjhaIi8+PC9nPjwvc3ZnPg==";
-var ASIGNA_ICON = "data:image/svg+xml;base64,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";
-var FORDEFI_ICON = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDIiIGhlaWdodD0iNDIiIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CiAgPHBhdGggZmlsbD0iIzEwMTExNCIgZD0iTTAgMGg0MnY0MkgweiIvPgogIDxwYXRoIGQ9Ik0xOS40NyAyNi44OUg1djMuNTdhNC41NyA0LjU3IDAgMCAwIDQuNTggNC41N2g1LjgzbDQuMDYtOC4xNFoiIGZpbGw9IiM3OTk0RkYiLz4KICA8cGF0aCBkPSJNNSAxNy40aDI3LjU4bC0zLjIgNi43OEg1VjE3LjRaIiBmaWxsPSIjNDg2REZGIi8+CiAgPHBhdGggZD0iTTE0LjY3IDdINXY3LjY4aDMzVjdoLTkuNjd2NS43NGgtMlY3aC05LjY3djUuNzRoLTEuOTlWN1oiIGZpbGw9IiM1Q0QxRkEiLz4KPC9zdmc+Cg==";
-var STACKS_PROVIDERS = [
-  {
-    id: "LeatherProvider",
-    name: "Leather",
-    icon: LEATHER_ICON,
-    installUrl: "https://chrome.google.com/webstore/detail/hiro-wallet/ldinpeekobnhjjdofggfgjlcehhmanlj"
-  },
-  {
-    id: "XverseProviders.BitcoinProvider",
-    name: "Xverse Wallet",
-    icon: XVERSE_ICON,
-    installUrl: "https://chrome.google.com/webstore/detail/xverse-wallet/idnnbdplmphpflfnlkomgpfbpcgelopg"
-  },
-  {
-    id: "AsignaProvider",
-    name: "Asigna Multisig",
-    icon: ASIGNA_ICON,
-    installUrl: "https://stx.asigna.io/"
-  },
-  {
-    id: "FordefiProviders.UtxoProvider",
-    name: "Fordefi",
-    icon: FORDEFI_ICON,
-    installUrl: "https://chromewebstore.google.com/detail/fordefi/hcmehenccjdmfbojapcbcofkgdpbnlle"
-  }
-];
-function useStacksXConnectors() {
-  return useMemo(() => STACKS_PROVIDERS.map((config) => new StacksXConnector(config)), []);
-}
-
-// src/useXWagmiStore.ts
-var initXServices = () => {
-  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", Wallet.Metamask),
-          // Cosmos wallets (detected via window globals)
-          new InjectiveXConnector("Keplr", Wallet.Keplr),
-          new InjectiveXConnector("Leap", 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;
+var EvmHydrator = () => {
+  const wagmiConfig = useConfig();
+  const connectors = useConnectors();
+  const { address, status, connector } = useAccount();
+  const evmPublicClient = usePublicClient();
+  const { data: evmWalletClient } = 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 } = useReconnect();
+  const walletConfig = useWalletConfig();
+  useEffect(() => {
+    if (wagmiConfig) {
+      EvmXService.getInstance().wagmiConfig = wagmiConfig;
     }
-  });
-  return xServices;
+  }, [wagmiConfig]);
+  const evmConnectors = useMemo(() => connectors.map((c) => new EvmXConnector(c)), [connectors]);
+  useEffect(() => {
+    EvmXService.getInstance().setXConnectors(evmConnectors);
+    useXWalletStore.getState().setXConnectors("EVM", evmConnectors);
+  }, [evmConnectors]);
+  const [hydrated, setHydrated] = useState(() => useXWalletStore.persist.hasHydrated());
+  useEffect(() => {
+    if (hydrated) return;
+    const unsub = useXWalletStore.persist.onFinishHydration(() => setHydrated(true));
+    return unsub;
+  }, [hydrated]);
+  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 = useRef(false);
+  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 = useMemo(() => {
+    if (!evmPublicClient || !evmWalletClient) return void 0;
+    if (userDisconnectedEvm) return void 0;
+    const defaults = resolveEvmDefaults(evmWalletClient.chain.id, walletConfig.EVM?.chains);
+    return new EvmWalletProvider({
+      walletClient: evmWalletClient,
+      publicClient: evmPublicClient,
+      defaults
+    });
+  }, [evmPublicClient, evmWalletClient, walletConfig.EVM?.chains, userDisconnectedEvm]);
+  useEffect(() => {
+    setWalletProvider("EVM", walletProvider);
+  }, [walletProvider, setWalletProvider]);
+  return null;
 };
-var useXWagmiStore = create()(
-  devtools(
-    persist(
-      immer((set, get) => ({
-        xServices: initXServices(),
-        xConnections: {},
-        setXConnection: (xChainType, xConnection) => {
-          set((state) => {
-            state.xConnections[xChainType] = xConnection;
-          });
-        },
-        unsetXConnection: (xChainType) => {
-          set((state) => {
-            delete state.xConnections[xChainType];
-          });
-        }
-      })),
-      {
-        name: "xwagmi-store",
-        storage: createJSONStorage(() => localStorage),
-        partialize: (state) => ({ xConnections: state.xConnections })
-      }
-    ),
-    { name: "xwagmi-store" }
-  )
-);
-
-// src/hooks/useXConnection.ts
-function useXConnection(xChainType) {
-  const xConnection = useXWagmiStore((state) => xChainType ? state.xConnections?.[xChainType] : void 0);
-  const evmConnections = useConnections();
-  const { address: evmAddress } = useAccount();
-  const suiAccount = useCurrentAccount();
-  const suiCurrentWallet = useCurrentWallet();
-  const solanaWallet = useWallet();
-  const xConnection2 = 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
-          };
+var EvmActions = () => {
+  const wagmiConfig = useConfig();
+  const { connectAsync } = useConnect();
+  const { disconnectAsync } = useDisconnect();
+  const { signMessageAsync } = useSignMessage();
+  const registerChainActions = useXWalletStore((state) => state.registerChainActions);
+  const connectRef = useRef(connectAsync);
+  const disconnectRef = useRef(disconnectAsync);
+  const signMessageRef = useRef(signMessageAsync);
+  const wagmiConfigRef = useRef(wagmiConfig);
+  useEffect(() => {
+    connectRef.current = connectAsync;
+    disconnectRef.current = disconnectAsync;
+    signMessageRef.current = signMessageAsync;
+    wagmiConfigRef.current = wagmiConfig;
+  }, [connectAsync, disconnectAsync, signMessageAsync, wagmiConfig]);
+  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;
         }
-        return void 0;
-      case "SOLANA":
-        if (solanaWallet.connected) {
-          return {
-            xAccount: { address: solanaWallet.publicKey?.toString(), xChainType },
-            xConnectorId: `${solanaWallet.wallet?.adapter.name}`
-          };
+        useXWalletStore.getState().clearUserDisconnected("EVM");
+        try {
+          await connectRef.current({ connector });
+        } catch (error) {
+          if (error instanceof Error && error.name === "ConnectorAlreadyConnectedError") {
+            return void 0;
+          }
+          throw error;
         }
         return void 0;
-      default:
-        return xConnection;
-    }
-  }, [xChainType, xConnection, evmAddress, suiAccount, evmConnections, suiCurrentWallet, solanaWallet]);
-  return xConnection2;
-}
-
-// src/hooks/useXAccount.ts
-function isChainType(chainIdentifier) {
-  return ChainTypeArr.includes(chainIdentifier);
-}
-function useXAccount(chainIdentifier) {
-  const resolvedChainType = chainIdentifier ? isChainType(chainIdentifier) ? chainIdentifier : getXChainType(chainIdentifier) : void 0;
-  const xConnection = useXConnection(resolvedChainType);
-  const xAccount = useMemo(() => {
-    if (!resolvedChainType) {
-      return {
-        address: void 0,
-        xChainType: void 0
-      };
-    }
-    return xConnection?.xAccount || { address: void 0, xChainType: resolvedChainType };
-  }, [resolvedChainType, xConnection]);
-  return xAccount;
-}
-function useXAccounts() {
-  const xChainTypes = useXWagmiStore((state) => Object.keys(state.xServices));
-  const xConnections = useXWagmiStore((state) => state.xConnections);
-  const { address: evmAddress } = useAccount();
-  const suiAccount = useCurrentAccount();
-  const solanaWallet = useWallet();
-  const xAccounts = 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"
-      };
-    }
-    return result;
-  }, [xChainTypes, xConnections, evmAddress, suiAccount, solanaWallet]);
-  return xAccounts;
-}
-function useXConnect() {
-  const setXConnection = useXWagmiStore((state) => state.setXConnection);
-  const { connectAsync: evmConnectAsync } = useConnect();
-  const { mutateAsync: suiConnectAsync } = useConnectWallet();
-  const { select, connect } = useWallet();
-  return 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);
-              });
-            });
-          }
-          break;
+      },
+      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;
-      }
-      if (xAccount) {
-        setXConnection(xConnector.xChainType, {
-          xAccount,
-          xConnectorId: xConnector.id
-        });
-      }
-      return xAccount;
-    }
-  });
-}
-
-// src/xchains/solana/SolanaXConnector.ts
-var SolanaXConnector = class extends XConnector {
-  constructor(wallet) {
-    super("SOLANA", wallet?.adapter.name, wallet?.adapter.name);
-    this.wallet = wallet;
-  }
-  getXService() {
-    return SolanaXService.getInstance();
-  }
-  async connect() {
-    return;
-  }
-  async disconnect() {
-  }
-  get icon() {
-    return this.wallet?.adapter.icon;
-  }
-};
-var useStellarXConnectors = () => {
-  const xService = useXService("STELLAR");
-  return useQuery({
-    queryKey: ["stellar-wallets", xService],
-    queryFn: async () => {
-      if (!xService) {
-        return [];
+      },
+      getConnectors: () => useXWalletStore.getState().xConnectorsByChain.EVM ?? [],
+      getConnection: () => useXWalletStore.getState().xConnections.EVM,
+      signMessage: async (message) => {
+        const signature = await signMessageRef.current({ message });
+        return signature;
       }
-      const wallets = await xService.walletsKit.getSupportedWallets();
-      return wallets.filter((wallet) => wallet.isAvailable).map((wallet) => new StellarWalletsKitXConnector(wallet));
-    }
-  });
+    });
+  }, [registerChainActions]);
+  return null;
 };
-
-// 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 icon() {
-    return this._wallet.manifest.icon;
+var EvmProvider = ({ children, config }) => {
+  const reconnectOnMount = config.reconnectOnMount ?? EVM_DEFAULT_RECONNECT_ON_MOUNT;
+  const ssr = config.ssr ?? EVM_DEFAULT_SSR;
+  const queryClientRef = useRef(null);
+  if (!queryClientRef.current) {
+    queryClientRef.current = new QueryClient();
   }
-};
-
-// src/xchains/near/useNearXConnectors.ts
-var useNearXConnectors = () => {
-  const xService = useXService("NEAR");
-  return useQuery({
-    queryKey: ["near-wallets"],
-    queryFn: async () => {
-      if (!xService) {
-        return [];
+  const walletConnectConfig = config.walletConnect;
+  const wagmiConfig = useMemo(() => {
+    const connectors = [];
+    if (walletConnectConfig) {
+      if (walletConnectConfig.projectId) {
+        connectors.push(walletConnect({ showQrModal: true, ...walletConnectConfig }));
+      } else {
+        console.warn("[wallet-sdk-react] walletConnect.projectId is required \u2014 WalletConnect connector skipped.");
       }
-      await xService.walletSelector.whenManifestLoaded;
-      const wallets = xService.walletSelector.availableWallets;
-      return wallets.map((wallet) => new NearXConnector(wallet));
     }
-  });
+    return createWagmiConfig(config.chains, { reconnectOnMount, ssr, connectors });
+  }, [config.chains, reconnectOnMount, ssr, walletConnectConfig]);
+  return /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClientRef.current, children: /* @__PURE__ */ jsxs(WagmiProvider, { reconnectOnMount, config: wagmiConfig, initialState: config.initialState, children: [
+    /* @__PURE__ */ jsx(EvmHydrator, {}),
+    /* @__PURE__ */ jsx(EvmActions, {}),
+    children
+  ] }) });
 };
-
-// src/hooks/useXConnectors.ts
-function useXConnectors(xChainType) {
-  const xService = useXService(xChainType);
-  const evmConnectors = useConnectors();
-  const suiWallets = useWallets();
-  const { data: stellarXConnectors } = useStellarXConnectors();
-  const { data: nearXConnectors } = useNearXConnectors();
-  const stacksXConnectors = useStacksXConnectors();
-  const { wallets: solanaWallets } = useWallet();
-  const xConnectors = 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 } = useDisconnect();
-  const { mutateAsync: suiDisconnectAsync } = useDisconnectWallet();
+var SolanaHydrator = () => {
+  const { connection } = useConnection();
   const solanaWallet = useWallet();
-  return 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?.[ChainKeys.SOLANA_MAINNET]
   );
-}
-function useXBalances({
-  xChainId,
-  xTokens,
-  address
-}) {
-  const xService = useXService(getXChainType(xChainId));
-  return 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
-  });
-}
-function useEthereumChainId() {
-  const injectiveXService = useXService("INJECTIVE");
-  const [ethereumChainId, setEthereumChainId] = React2.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 (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 = baseChainInfo[expectedXChainId].chainId;
-  const injectiveXService = useXService("INJECTIVE");
-  const ethereumChainId = useEthereumChainId();
-  const { chainId } = useAccount();
-  const isWrongChain = useMemo(() => {
-    return xChainType === "EVM" && chainId !== expectedChainId || xChainType === "INJECTIVE" && injectiveXService && injectiveXService.walletStrategy.getWallet() === Wallet.Metamask && ethereumChainId !== mainnet$1.id;
-  }, [xChainType, chainId, expectedChainId, ethereumChainId, injectiveXService]);
-  const { switchChain } = useSwitchChain();
-  const handleSwitchChain = useCallback(() => {
-    if (xChainType === "INJECTIVE") {
-      switchEthereumChain();
-    } else {
-      switchChain({ chainId: expectedChainId });
+    if (connection) {
+      SolanaXService.getInstance().connection = connection;
     }
-  }, [switchChain, expectedChainId, xChainType]);
-  return useMemo(
-    () => ({
-      isWrongChain,
-      handleSwitchChain
-    }),
-    [isWrongChain, handleSwitchChain]
+  }, [connection]);
+  const solanaWalletRef = useRef(solanaWallet);
+  useEffect(() => {
+    solanaWalletRef.current = solanaWallet;
+  });
+  const solanaConnectors = useMemo(
+    () => solanaWallet.wallets.filter((wallet) => wallet.readyState === "Installed").map((wallet) => new SolanaXConnector(wallet)),
+    [solanaWallet.wallets]
   );
+  useEffect(() => {
+    SolanaXService.getInstance().setXConnectors(solanaConnectors);
+    useXWalletStore.getState().setXConnectors("SOLANA", solanaConnectors);
+  }, [solanaConnectors]);
+  const wasConnectedRef = useRef(!!useXWalletStore.getState().xConnections.SOLANA);
+  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 = useMemo(() => {
+    if (solanaWallet.connected && solanaWallet.publicKey && solanaWallet.wallet && connection) {
+      return new SolanaWalletProvider({
+        wallet: solanaWallet,
+        endpoint: connection.rpcEndpoint,
+        defaults: solanaDefaults
+      });
+    }
+    return void 0;
+  }, [solanaWallet.connected, solanaWallet.publicKey, solanaWallet.wallet, connection, solanaDefaults]);
+  useEffect(() => {
+    SolanaXService.getInstance().wallet = solanaWalletRef.current;
+    setWalletProvider("SOLANA", walletProvider);
+  }, [walletProvider, setWalletProvider]);
+  return null;
 };
-function useWalletProvider(spokeChainId) {
-  const xChainType = getXChainType(spokeChainId);
-  const evmPublicClient = usePublicClient();
-  const { data: evmWalletClient } = useWalletClient();
-  const xService = useXService(getXChainType(spokeChainId));
-  const xAccount = useXAccount(spokeChainId);
-  const stacksConnection = useXConnection("STACKS");
-  const stacksConnectors = useXConnectors("STACKS");
-  const xConnection = useXConnection(xChainType);
-  return useMemo(() => {
-    switch (xChainType) {
-      case "EVM": {
-        if (!evmWalletClient) {
-          return void 0;
-        }
-        if (!evmPublicClient) {
-          return void 0;
-        }
-        return new 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 SuiWalletProvider({ client, wallet, account });
-      }
-      case "ICON": {
-        const { walletAddress, rpcUrl } = {
-          walletAddress: xAccount.address,
-          rpcUrl: CHAIN_INFO[1 /* MAINNET */].APIEndpoint
-        };
-        return new IconWalletProvider({
-          walletAddress,
-          rpcUrl
-        });
-      }
-      case "INJECTIVE": {
-        const injectiveXService = xService;
-        if (!injectiveXService) {
-          return void 0;
-        }
-        return new InjectiveWalletProvider({
-          msgBroadcaster: injectiveXService.msgBroadcaster
-        });
-      }
-      case "STELLAR": {
-        const stellarXService = xService;
-        if (!stellarXService.walletsKit) {
-          return void 0;
-        }
-        return new StellarWalletProvider({
-          type: "BROWSER_EXTENSION",
-          walletsKit: stellarXService.walletsKit,
-          network: "PUBLIC"
-        });
-      }
-      case "SOLANA": {
-        const solanaXService = xService;
-        if (!solanaXService.wallet) {
+var SolanaActions = () => {
+  const solanaWallet = useWallet();
+  const registerChainActions = useXWalletStore((state) => state.registerChainActions);
+  const walletRef = useRef(solanaWallet);
+  useEffect(() => {
+    walletRef.current = solanaWallet;
+  }, [solanaWallet]);
+  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 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 NearWalletProvider({ wallet: nearXService.walletSelector });
-      }
-      case "STACKS": {
-        const address = xAccount.address;
-        if (!address) {
-          return void 0;
-        }
-        const activeStacksConnector = stacksConnectors.find((c) => c.id === stacksConnection?.xConnectorId);
-        return new StacksWalletProvider({ address, provider: activeStacksConnector?.getProvider() });
-      }
-      default:
         return void 0;
-    }
-  }, [
-    xChainType,
-    evmPublicClient,
-    evmWalletClient,
-    xService,
-    xAccount,
-    stacksConnection,
-    stacksConnectors,
-    xConnection
-  ]);
-}
-function useXSignMessage() {
-  const { signMessage } = useWallet();
-  const { signMessageAsync: evmSignMessage } = useSignMessage();
-  const { mutateAsync: signPersonalMessage } = useSignPersonalMessage();
-  const { address: injectiveAddress } = useXAccount("INJECTIVE");
-  return 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 = getEthereumAddress(injectiveAddress);
-          const walletStrategy = InjectiveXService.getInstance().walletStrategy;
-          const res = await walletStrategy.signArbitrary(
-            walletStrategy.getWallet() === Wallet.Metamask ? ethereumAddress : injectiveAddress,
-            message
-          );
-          if (!res) {
-            throw new Error("Injective signature not found");
-          }
-          signature = res;
-          break;
+      },
+      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");
         }
-        default:
-          console.warn("Unsupported chain type");
-          break;
+        const signature = await walletRef.current.signMessage(new TextEncoder().encode(message));
+        return Buffer.from(signature).toString("base64");
       }
-      return signature;
-    }
-  });
-}
-
-// src/xchains/bitcoin/useBitcoinXConnectors.ts
-function useBitcoinXConnectors() {
-  const xService = useXService("BITCOIN");
-  return useMemo(() => {
-    return xService?.getXConnectors() || [];
-  }, [xService]);
-}
-var Hydrate = ({ rpcConfig }) => {
+    });
+  }, [registerChainActions]);
+  return null;
+};
+var emptyWallets = [];
+var SolanaProvider = ({ children, config }) => {
+  const autoConnect = config.autoConnect ?? SOLANA_DEFAULT_AUTO_CONNECT;
+  const endpoint = config.chains?.[ChainKeys.SOLANA_MAINNET]?.rpcUrl ?? SOLANA_DEFAULT_RPC_URL;
+  return /* @__PURE__ */ jsx(ConnectionProvider, { endpoint, children: /* @__PURE__ */ jsxs(WalletProvider, { wallets: emptyWallets, autoConnect, children: [
+    /* @__PURE__ */ jsx(SolanaHydrator, {}),
+    /* @__PURE__ */ jsx(SolanaActions, {}),
+    children
+  ] }) });
+};
+var SuiHydrator = () => {
   const suiClient = useSuiClient();
+  const { currentWallet } = useCurrentWallet();
+  const suiAccount = useCurrentAccount();
+  const suiWallets = 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?.[ChainKeys.SUI_MAINNET]);
   useEffect(() => {
-    if (suiClient) {
-      SuiXService.getInstance().suiClient = suiClient;
-    }
-  }, [suiClient]);
-  const { currentWallet: suiWallet } = useCurrentWallet();
+    const service = SuiXService.getInstance();
+    if (suiClient) service.suiClient = suiClient;
+    if (currentWallet) service.suiWallet = currentWallet;
+    if (suiAccount) service.suiAccount = suiAccount;
+  }, [suiClient, currentWallet, suiAccount]);
+  const suiConnectors = useMemo(() => suiWallets.map((wallet) => new SuiXConnector(wallet)), [suiWallets]);
   useEffect(() => {
-    if (suiWallet) {
-      SuiXService.getInstance().suiWallet = suiWallet;
-    }
-  }, [suiWallet]);
-  const suiAccount = useCurrentAccount();
+    SuiXService.getInstance().setXConnectors(suiConnectors);
+    useXWalletStore.getState().setXConnectors("SUI", suiConnectors);
+  }, [suiConnectors]);
+  const wasConnectedRef = useRef(!!useXWalletStore.getState().xConnections.SUI);
   useEffect(() => {
-    if (suiAccount) {
-      SuiXService.getInstance().suiAccount = suiAccount;
+    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 = useMemo(() => {
+    if (suiClient && currentWallet && suiAccount) {
+      assertSuiProviderShape("SuiHydrator", suiClient, currentWallet, suiAccount);
+      return new SuiWalletProvider({
+        client: suiClient,
+        wallet: currentWallet,
+        account: suiAccount,
+        defaults: suiDefaults
+      });
     }
-  }, [suiAccount]);
-  const { connection: solanaConnection } = useConnection();
-  const solanaWallet = useWallet();
+    return void 0;
+  }, [suiClient, currentWallet, suiAccount, suiDefaults]);
   useEffect(() => {
-    if (solanaConnection) {
-      SolanaXService.getInstance().connection = solanaConnection;
-    }
-  }, [solanaConnection]);
+    setWalletProvider("SUI", walletProvider);
+  }, [walletProvider, setWalletProvider]);
+  return null;
+};
+var SuiActions = () => {
+  const suiWallets = useWallets();
+  const { mutateAsync: suiConnectAsync } = useConnectWallet();
+  const { mutateAsync: suiDisconnectAsync } = useDisconnectWallet();
+  const { mutateAsync: signPersonalMessage } = useSignPersonalMessage();
+  const registerChainActions = useXWalletStore((state) => state.registerChainActions);
+  const connectRef = useRef(suiConnectAsync);
+  const disconnectRef = useRef(suiDisconnectAsync);
+  const signMessageRef = useRef(signPersonalMessage);
+  const walletsRef = useRef(suiWallets);
   useEffect(() => {
-    if (solanaWallet) {
-      SolanaXService.getInstance().wallet = solanaWallet;
-    }
-  }, [solanaWallet]);
-  const wagmiConfig = useConfig();
+    connectRef.current = suiConnectAsync;
+  }, [suiConnectAsync]);
   useEffect(() => {
-    if (wagmiConfig) {
-      EvmXService.getInstance().wagmiConfig = wagmiConfig;
-    }
-  }, [wagmiConfig]);
+    disconnectRef.current = suiDisconnectAsync;
+  }, [suiDisconnectAsync]);
   useEffect(() => {
-    StacksXService.getInstance().network = createNetwork({
-      network: "mainnet",
-      client: { baseUrl: rpcConfig.stacks ?? "https://api.mainnet.hiro.so" }
+    signMessageRef.current = signPersonalMessage;
+  }, [signPersonalMessage]);
+  useEffect(() => {
+    walletsRef.current = suiWallets;
+  }, [suiWallets]);
+  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)
+          );
+          return void 0;
+        }
+        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;
+      }
     });
-  }, [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?.[ChainKeys.SUI_MAINNET]?.rpcUrl ?? getFullnodeUrl(network);
+  return /* @__PURE__ */ jsx(SuiClientProvider, { networks: { [network]: { url: rpcUrl } }, defaultNetwork: network, children: /* @__PURE__ */ jsxs(WalletProvider$1, { autoConnect, children: [
+    /* @__PURE__ */ jsx(SuiHydrator, {}),
+    /* @__PURE__ */ 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(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 = isEvmBrowserWallet(recentXConnectorId) ? 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 = isEvmBrowserWallet(recentXConnectorId) ? 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 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);
+  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 = useRef(config);
+  const frozen = configRef.current;
+  useInitChainServices(frozen);
+  let content = /* @__PURE__ */ jsx(Fragment, { children });
+  if (frozen.SOLANA) {
+    content = /* @__PURE__ */ jsx(SolanaProvider, { config: frozen.SOLANA, children: content });
   }
+  if (frozen.SUI) {
+    content = /* @__PURE__ */ jsx(SuiProvider, { config: frozen.SUI, children: content });
+  }
+  if (frozen.EVM) {
+    content = /* @__PURE__ */ jsx(EvmProvider, { config: frozen.EVM, children: content });
+  }
+  return /* @__PURE__ */ jsx(WalletConfigProvider, { value: frozen, children: content });
 };
-var SodaxWalletProvider = ({ children, rpcConfig, options, initialState }) => {
-  const wagmi = useMemo(() => ({ ...defaultOptions.wagmi, ...options?.wagmi }), [options?.wagmi]);
-  const wagmiConfig = useMemo(() => {
-    return createWagmiConfig(rpcConfig, wagmi);
-  }, [rpcConfig, wagmi]);
-  const wallets = useMemo(() => [new UnsafeBurnerWalletAdapter()], []);
-  const solana = useMemo(() => ({ ...defaultOptions.solana, ...options?.solana }), [options?.solana]);
-  const sui = useMemo(() => ({ ...defaultOptions.sui, ...options?.sui }), [options?.sui]);
-  return /* @__PURE__ */ React2.createElement(QueryClientProvider, { client: queryClient }, /* @__PURE__ */ React2.createElement(WagmiProvider, { reconnectOnMount: wagmi.reconnectOnMount, config: wagmiConfig, initialState }, /* @__PURE__ */ React2.createElement(SuiClientProvider, { networks: { mainnet: { url: getFullnodeUrl("mainnet") } }, defaultNetwork: "mainnet" }, /* @__PURE__ */ React2.createElement(WalletProvider, { autoConnect: sui.autoConnect }, /* @__PURE__ */ React2.createElement(ConnectionProvider, { endpoint: rpcConfig["solana"] ?? "https://api.mainnet-beta.solana.com" }, /* @__PURE__ */ React2.createElement(WalletProvider$1, { wallets, autoConnect: solana.autoConnect }, /* @__PURE__ */ React2.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 || {});
 
-export { BitcoinXConnector, BitcoinXService, EvmXConnector, EvmXService, IconHanaXConnector, IconXService, InjectiveXConnector, InjectiveXService, OKXXConnector, STACKS_PROVIDERS, SodaxWalletProvider, SolanaXConnector, SolanaXService, StacksXConnector, StacksXService, StellarWalletsKitXConnector, StellarXService, SuiXConnector, SuiXService, UnisatXConnector, WalletId, XConnector, XService, XverseXConnector, createWagmiConfig as createWagmi, createWagmiConfig, getWagmiChainId, getXChainType, getXService, isNativeToken, useBitcoinXConnectors, useEvmSwitchChain, useStacksXConnectors, useWalletProvider, useXAccount, useXAccounts, useXBalances, useXConnect, useXConnection, useXConnectors, useXDisconnect, useXService, useXSignMessage, useXWagmiStore };
+export { SodaxWalletProvider };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map