@sodax/wallet-sdk-react 0.0.1-rc.2

package/dist/index.mjs

@@ -0,0 +1,1513 @@
+import { erc20Abi, defineChain } from 'viem';
+import { getPublicClient, getWalletClient } from 'wagmi/actions';
+import { http, createConfig, useConnections, useAccount, useConnect, useConnectors, useDisconnect, usePublicClient, useWalletClient, useSwitchChain, WagmiProvider } from 'wagmi';
+import { mainnet, lightlinkPhoenix, nibiru as nibiru$1, polygon as polygon$1, optimism as optimism$1, sonic as sonic$1, bsc as bsc$1, base as base$1, arbitrum as arbitrum$1, avalanche as avalanche$1 } from 'wagmi/chains';
+import { LIGHTLINK_MAINNET_CHAIN_ID, HYPEREVM_MAINNET_CHAIN_ID, NIBIRU_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 } from '@sodax/types';
+import { IconService, Builder, Converter } from 'icon-sdk-js';
+import { getNetworkEndpoints, Network } from '@injectivelabs/networks';
+import { IndexerGrpcAccountPortfolioApi, ChainGrpcWasmApi, getInjectiveAddress } from '@injectivelabs/sdk-ts';
+import { ChainId, EvmChainId } from '@injectivelabs/ts-types';
+import { EvmWalletStrategy } from '@injectivelabs/wallet-evm';
+import { BaseWalletStrategy, MsgBroadcaster } from '@injectivelabs/wallet-core';
+import { Wallet, isEvmBrowserWallet } 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, FREIGHTER_ID, 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 React3, { useEffect, useMemo, useCallback } from 'react';
+import { useSuiClient, useCurrentWallet, useCurrentAccount, useConnectWallet, useWallets, useDisconnectWallet, SuiClientProvider, WalletProvider } from '@mysten/dapp-kit';
+import { useConnection, useWallet, ConnectionProvider, WalletProvider as WalletProvider$1 } from '@solana/wallet-adapter-react';
+import { create } from 'zustand';
+import { persist, createJSONStorage } from 'zustand/middleware';
+import { immer } from 'zustand/middleware/immer';
+import { AnchorProvider } from '@coral-xyz/anchor';
+import { useMutation, useQuery, keepPreviousData } from '@tanstack/react-query';
+import { mainnet as mainnet$1 } from 'viem/chains';
+import { SolanaWalletProvider, StellarWalletProvider, InjectiveWalletProvider, IconWalletProvider, SuiWalletProvider, EvmWalletProvider } from '@sodax/wallet-sdk-core';
+import { getFullnodeUrl } from '@mysten/sui/client';
+import { UnsafeBurnerWalletAdapter } from '@solana/wallet-adapter-wallets';
+
+// src/constants/xChains.ts
+var icon = {
+  id: 1,
+  name: "ICON",
+  xChainId: "0x1.icon",
+  xChainType: "ICON",
+  testnet: false
+};
+var avalanche = {
+  id: 43114,
+  name: "Avalanche",
+  xChainId: "0xa86a.avax",
+  xChainType: "EVM",
+  testnet: false
+};
+var bsc = {
+  id: 56,
+  name: "BNB Chain",
+  xChainId: "0x38.bsc",
+  xChainType: "EVM",
+  testnet: false
+};
+var arbitrum = {
+  id: 42161,
+  name: "Arbitrum",
+  xChainId: "0xa4b1.arbitrum",
+  xChainType: "EVM",
+  testnet: false
+};
+var base = {
+  id: 8453,
+  name: "Base",
+  xChainId: "0x2105.base",
+  xChainType: "EVM",
+  testnet: false
+};
+var injective = {
+  id: "injective-1",
+  name: "Injective",
+  xChainId: "injective-1",
+  xChainType: "INJECTIVE",
+  testnet: false
+};
+var stellar = {
+  id: "stellar",
+  name: "Stellar",
+  xChainId: "stellar",
+  xChainType: "STELLAR",
+  testnet: false
+};
+var sui = {
+  id: "sui",
+  name: "Sui",
+  xChainId: "sui",
+  xChainType: "SUI",
+  testnet: false
+};
+var solana = {
+  id: "solana",
+  name: "Solana",
+  xChainId: "solana",
+  xChainType: "SOLANA",
+  testnet: false
+};
+var optimism = {
+  id: 10,
+  name: "Optimism",
+  xChainId: "0xa.optimism",
+  xChainType: "EVM",
+  testnet: false
+};
+var sonic = {
+  id: 146,
+  name: "Sonic",
+  xChainId: "sonic",
+  xChainType: "EVM",
+  testnet: false
+};
+var polygon = {
+  id: 137,
+  name: "Polygon",
+  xChainId: "0x89.polygon",
+  xChainType: "EVM",
+  testnet: false
+};
+var nibiru = {
+  id: 6900,
+  name: "Nibiru",
+  xChainId: "nibiru",
+  xChainType: "EVM",
+  testnet: false
+};
+var hyper = {
+  id: 999,
+  name: "HyperEVM",
+  xChainId: "hyper",
+  xChainType: "EVM",
+  testnet: false
+};
+var lightlink = {
+  id: 1890,
+  name: "Lightlink",
+  xChainId: "lightlink",
+  xChainType: "EVM",
+  testnet: false
+};
+var xChainMap = {
+  "0x1.icon": icon,
+  "0xa4b1.arbitrum": arbitrum,
+  "0xa86a.avax": avalanche,
+  "0x38.bsc": bsc,
+  "0x2105.base": base,
+  "0xa.optimism": optimism,
+  "injective-1": injective,
+  stellar,
+  sui,
+  solana,
+  sonic,
+  "0x89.polygon": polygon,
+  nibiru,
+  hyper,
+  lightlink
+};
+var xChains = Object.values(xChainMap);
+
+// src/actions/getXChainType.ts
+function getXChainType(xChainId) {
+  if (!xChainId) {
+    return void 0;
+  }
+  return xChainMap[xChainId].xChainType;
+}
+
+// src/actions/getXService.ts
+function getXService(xChainType) {
+  switch (xChainType) {
+    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();
+    default:
+      throw new Error(`Unsupported chain type: ${xChainType}`);
+  }
+}
+
+// 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
+   * @param xChainId The chain ID to query
+   * @returns Promise resolving to the token balance as a bigint
+   */
+  async getBalance(address, xToken, xChainId) {
+    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
+   * @param xChainId The chain ID to query
+   * @returns Promise resolving to object mapping token addresses to balances
+   */
+  async getBalances(address, xTokens, xChainId) {
+    if (!address) return {};
+    const balancePromises = xTokens.map(async (xToken) => {
+      const balance = await this.getBalance(address, xToken, xChainId);
+      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);
+  }
+};
+
+// 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;
+  }
+};
+
+// src/utils/index.ts
+var isNativeToken = (xToken) => {
+  const nativeAddresses = [
+    "cx0000000000000000000000000000000000000000",
+    "0x0000000000000000000000000000000000000000",
+    "inj",
+    "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI",
+    "hx0000000000000000000000000000000000000000",
+    "11111111111111111111111111111111",
+    // solana
+    "CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA"
+    // stellar,
+  ];
+  return nativeAddresses.includes(xToken.address);
+};
+var getWagmiChainId = (xChainId) => {
+  const xChainMap2 = {
+    "0xa869.fuji": 43113,
+    "sonic-blaze": 57054,
+    sonic: 146,
+    "0xa86a.avax": 43114,
+    "0x38.bsc": 56,
+    "0xa4b1.arbitrum": 42161,
+    "0x2105.base": 8453,
+    "0xa.optimism": 10,
+    "0x89.polygon": 137,
+    hyper: 999,
+    lightlink: 1890
+  };
+  return xChainMap2[xChainId] ?? 0;
+};
+var hyper2 = /* @__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 evmChainMap = {
+  [AVALANCHE_MAINNET_CHAIN_ID]: avalanche$1,
+  [ARBITRUM_MAINNET_CHAIN_ID]: arbitrum$1,
+  [BASE_MAINNET_CHAIN_ID]: base$1,
+  [BSC_MAINNET_CHAIN_ID]: bsc$1,
+  [SONIC_MAINNET_CHAIN_ID]: sonic$1,
+  [OPTIMISM_MAINNET_CHAIN_ID]: optimism$1,
+  [POLYGON_MAINNET_CHAIN_ID]: polygon$1,
+  [NIBIRU_MAINNET_CHAIN_ID]: nibiru$1,
+  [HYPEREVM_MAINNET_CHAIN_ID]: hyper2,
+  [LIGHTLINK_MAINNET_CHAIN_ID]: lightlinkPhoenix
+};
+var getWagmiConfig = (chains) => {
+  const mappedChains = chains.map((chain) => evmChainMap[chain]);
+  const finalChains = mappedChains.length > 0 ? mappedChains : [mainnet];
+  const transports = finalChains.reduce(
+    (acc, chain) => {
+      acc[chain.id] = http();
+      return acc;
+    },
+    {}
+  );
+  return createConfig({
+    chains: finalChains,
+    transports
+    // ssr: true,
+  });
+};
+var EvmXService = class _EvmXService extends XService {
+  constructor() {
+    super("EVM");
+  }
+  getXConnectors() {
+    return [];
+  }
+  static getInstance() {
+    if (!_EvmXService.instance) {
+      _EvmXService.instance = new _EvmXService();
+    }
+    return _EvmXService.instance;
+  }
+  setConfig(config) {
+    this.config = config;
+  }
+  getPublicClient(chainId) {
+    if (!this.config) {
+      throw new Error("EvmXService: config is not initialized yet");
+    }
+    return getPublicClient(getWagmiConfig(this.config.chains), { chainId });
+  }
+  async getWalletClient(chainId) {
+    if (!this.config) {
+      throw new Error("EvmXService: config is not initialized yet");
+    }
+    return await getWalletClient(getWagmiConfig(this.config.chains), { chainId });
+  }
+  async getBalance(address, xToken, xChainId) {
+    if (!address) return 0n;
+    const chainId = getWagmiChainId(xChainId);
+    if (isNativeToken(xToken)) {
+      const balance = await this.getPublicClient(chainId)?.getBalance({ address });
+      return balance || 0n;
+    }
+    throw new Error(`Unsupported token: ${xToken.symbol}`);
+  }
+  async getBalances(address, xTokens, xChainId) {
+    if (!address) return {};
+    const balancePromises = xTokens.filter((xToken) => isNativeToken(xToken)).map(async (xToken) => {
+      const balance = await this.getBalance(address, xToken, xChainId);
+      return { symbol: xToken.symbol, address: xToken.address, balance };
+    });
+    const balances = await Promise.all(balancePromises);
+    const tokenMap = balances.reduce((map, { address: address2, balance }) => {
+      if (balance) map[address2] = balance;
+      return map;
+    }, {});
+    const nonNativeXTokens = xTokens.filter((xToken) => !isNativeToken(xToken));
+    const result = await this.getPublicClient(getWagmiChainId(xChainId))?.multicall({
+      contracts: nonNativeXTokens.map((token) => ({
+        abi: erc20Abi,
+        address: token.address,
+        functionName: "balanceOf",
+        args: [address],
+        chainId: getWagmiChainId(xChainId)
+      }))
+    });
+    return nonNativeXTokens.map((token, index) => ({
+      symbol: token.symbol,
+      address: token.address,
+      balance: result?.[index]?.result?.toString() || "0"
+    })).reduce((acc, balance) => {
+      acc[balance.address] = balance.balance;
+      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 CHAIN_INFO = {
+  [1 /* MAINNET */]: {
+    APIEndpoint: "https://ctz.solidwallet.io/api/v3"}
+};
+var IconXService = class _IconXService extends XService {
+  constructor() {
+    super("ICON");
+    this.iconService = new IconService(
+      new IconService.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 Builder.CallBuilder().to("cxa4aa9185e23558cff990f494c1fd2845f6cbf741").method("tryAggregate").params({ requireSuccess: Converter.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, xChainId) {
+    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";
+  }
+};
+var InjectiveXService = class _InjectiveXService extends XService {
+  constructor() {
+    super("INJECTIVE");
+    const endpoints = getNetworkEndpoints(Network.Mainnet);
+    this.walletStrategy = new BaseWalletStrategy({
+      chainId: ChainId.Mainnet,
+      strategies: {
+        [Wallet.Metamask]: new EvmWalletStrategy({
+          chainId: ChainId.Mainnet,
+          wallet: Wallet.Metamask,
+          evmOptions: {
+            evmChainId: EvmChainId.Mainnet,
+            rpcUrl: mainnet.rpcUrls.default.http[0]
+          }
+        })
+        // [Wallet.Keplr]: new CosmosWalletStrategy({
+        //   chainId: InjectiveChainId.Mainnet,
+        //   wallet: Wallet.Keplr,
+        // }),
+      }
+    });
+    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 InjectiveKelprXConnector = class extends XConnector {
+  constructor() {
+    super("INJECTIVE", "Keplr", "keplr");
+  }
+  getXService() {
+    return InjectiveXService.getInstance();
+  }
+  async connect() {
+    if (!isCosmosWalletInstalled(Wallet.Keplr)) {
+      window.open("https://chrome.google.com/webstore/detail/keplr/dmkamcknogkgcdfhhbddcghachkejeap?hl=en", "_blank");
+      return;
+    }
+    this.getXService().walletStrategy.setWallet(Wallet.Keplr);
+    const addresses = await this.getXService().walletStrategy.getAddresses();
+    return {
+      address: addresses?.[0],
+      xChainType: this.xChainType
+    };
+  }
+  async disconnect() {
+  }
+  get icon() {
+    return "https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/keplr.svg";
+  }
+};
+var InjectiveMetamaskXConnector = class extends XConnector {
+  constructor() {
+    super("INJECTIVE", "MetaMask", "metamask");
+  }
+  getXService() {
+    return InjectiveXService.getInstance();
+  }
+  async connect() {
+    if (!isEvmBrowserWallet(Wallet.Metamask)) {
+      window.open("https://chromewebstore.google.com/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn?hl=en", "_blank");
+      return;
+    }
+    this.getXService().walletStrategy.setWallet(Wallet.Metamask);
+    const addresses = await this.getXService().walletStrategy.getAddresses();
+    const injectiveAddresses = addresses.map(getInjectiveAddress);
+    return {
+      address: injectiveAddresses?.[0],
+      xChainType: this.xChainType
+    };
+  }
+  async disconnect() {
+    await this.getXService().walletStrategy.disconnect();
+  }
+  get icon() {
+    return "https://raw.githubusercontent.com/balancednetwork/icons/master/wallets/metamask.svg";
+  }
+};
+
+// src/xchains/injective/utils.ts
+var switchEthereumChain = async (chainId) => {
+  const metamaskProvider = window.ethereum;
+  await Promise.race([
+    metamaskProvider.request({
+      method: "wallet_switchEthereumChain",
+      params: [{ chainId: `0x${chainId}` }]
+    }),
+    new Promise(
+      (resolve) => metamaskProvider.on("change", ({ chain }) => {
+        if (chain?.id === chainId) {
+          resolve();
+        }
+      })
+    )
+  ]);
+};
+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) {
+      throw new Error("Connection is not initialized");
+    }
+    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 (e) {
+      console.log("error", e);
+    }
+    return BigInt(0);
+  }
+};
+
+// 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 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 StellarXService = class _StellarXService extends XService {
+  constructor() {
+    super("STELLAR");
+    this.walletsKit = new StellarWalletsKit({
+      network: WalletNetwork.PUBLIC,
+      selectedWalletId: FREIGHTER_ID,
+      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) {
+        return BigInt(xlmBalance.balance.replace(".", ""));
+      }
+    } 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 allBalances = await this.suiClient.getAllBalances({
+        owner: address
+      });
+      const tokenMap = xTokens.reduce((map, 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 = allBalances.find((b) => b.coinType === coinType);
+        if (balance) map[xToken.address] = balance.totalBalance;
+        return map;
+      }, {});
+      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;
+  }
+};
+function useAnchorProvider() {
+  const { connection } = useConnection();
+  const wallet = useWallet();
+  return new AnchorProvider(connection, wallet, { commitment: "confirmed" });
+}
+var useXWagmiStore = create()(
+  persist(
+    immer((set, get) => ({
+      xServices: {},
+      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 }),
+      // TODO: better way to handle rehydration of xConnections?
+      onRehydrateStorage: (state) => {
+        console.log("hydration starts");
+        return (state2, error) => {
+          if (state2?.xConnections) {
+            console.log("rehydrating xConnections", state2.xConnections);
+            Object.entries(state2.xConnections).forEach(([xChainType, xConnection]) => {
+              const xConnector = getXService(xChainType).getXConnectorById(xConnection.xConnectorId);
+              xConnector?.connect();
+            });
+          }
+          if (error) {
+            console.log("an error happened during hydration", error);
+          } else {
+            console.log("hydration finished");
+          }
+        };
+      }
+    }
+  )
+);
+var initXServices = (config) => {
+  const xServices = {};
+  Object.keys(config).forEach((key) => {
+    const xChainType = key;
+    switch (xChainType) {
+      case "EVM":
+        if (config[xChainType]) {
+          xServices[xChainType] = EvmXService.getInstance();
+          xServices[xChainType].setXConnectors([]);
+          xServices[xChainType].setConfig(config[xChainType]);
+        }
+        break;
+      case "INJECTIVE":
+        xServices[xChainType] = InjectiveXService.getInstance();
+        xServices[xChainType].setXConnectors([new InjectiveMetamaskXConnector()]);
+        break;
+      case "STELLAR":
+        xServices[xChainType] = StellarXService.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 "ICON":
+        xServices[xChainType] = IconXService.getInstance();
+        xServices[xChainType].setXConnectors([new IconHanaXConnector()]);
+        break;
+    }
+  });
+  return xServices;
+};
+var initXWagmiStore = (config) => {
+  useXWagmiStore.setState({
+    xServices: initXServices(config)
+  });
+};
+var InitXWagmiStore = () => {
+  const suiClient = useSuiClient();
+  useEffect(() => {
+    if (suiClient) {
+      SuiXService.getInstance().suiClient = suiClient;
+    }
+  }, [suiClient]);
+  const { currentWallet: suiWallet } = useCurrentWallet();
+  useEffect(() => {
+    if (suiWallet) {
+      SuiXService.getInstance().suiWallet = suiWallet;
+    }
+  }, [suiWallet]);
+  const suiAccount = useCurrentAccount();
+  useEffect(() => {
+    if (suiAccount) {
+      SuiXService.getInstance().suiAccount = suiAccount;
+    }
+  }, [suiAccount]);
+  const { connection: solanaConnection } = useConnection();
+  const solanaWallet = useWallet();
+  const solanaProvider = useAnchorProvider();
+  useEffect(() => {
+    if (solanaConnection) {
+      SolanaXService.getInstance().connection = solanaConnection;
+    }
+  }, [solanaConnection]);
+  useEffect(() => {
+    if (solanaWallet) {
+      SolanaXService.getInstance().wallet = solanaWallet;
+    }
+  }, [solanaWallet]);
+  useEffect(() => {
+    if (solanaProvider) {
+      SolanaXService.getInstance().provider = solanaProvider;
+    }
+  }, [solanaProvider]);
+  return /* @__PURE__ */ React3.createElement(React3.Fragment, null);
+};
+
+// 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
+          };
+        }
+        return void 0;
+      case "SOLANA":
+        if (solanaWallet.connected) {
+          return {
+            xAccount: { address: solanaWallet.publicKey?.toString(), xChainType },
+            xConnectorId: `${solanaWallet.wallet?.adapter.name}`
+          };
+        }
+        return void 0;
+      default:
+        return xConnection;
+    }
+  }, [xChainType, xConnection, evmAddress, suiAccount, evmConnections, suiCurrentWallet, solanaWallet]);
+  return xConnection2;
+}
+
+// src/hooks/useXAccount.ts
+function isChainType(chainIdentifier) {
+  return ["ICON", "EVM", "INJECTIVE", "SUI", "STELLAR", "SOLANA"].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, connected } = 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;
+          await 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;
+        }
+        default:
+          xAccount = await xConnector.connect();
+          break;
+      }
+      if (xAccount) {
+        setXConnection(xConnector.xChainType, {
+          xAccount,
+          xConnectorId: xConnector.id
+        });
+      }
+      return xAccount;
+    }
+  });
+}
+var useStellarXConnectors = () => {
+  const xService = useXService("STELLAR");
+  return useQuery({
+    queryKey: ["stellar-wallets", xService],
+    queryFn: async () => {
+      if (!xService) {
+        return [];
+      }
+      const wallets = await xService.walletsKit.getSupportedWallets();
+      return wallets.filter((wallet) => wallet.isAvailable).map((wallet) => new StellarWalletsKitXConnector(wallet));
+    }
+  });
+};
+
+// src/hooks/useXService.ts
+function useXService(xChainType) {
+  const xService = useXWagmiStore((state) => xChainType ? state.xServices[xChainType] : void 0);
+  return xService;
+}
+
+// src/hooks/useXConnectors.ts
+function useXConnectors(xChainType) {
+  const xService = useXService(xChainType);
+  const evmConnectors = useConnectors();
+  const suiWallets = useWallets();
+  const { data: stellarXConnectors } = useStellarXConnectors();
+  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));
+      default:
+        return xService.getXConnectors();
+    }
+  }, [xService, xChainType, evmConnectors, suiWallets, stellarXConnectors, solanaWallets]);
+  return xConnectors;
+}
+function useXDisconnect() {
+  const xConnections = useXWagmiStore((state) => state.xConnections);
+  const unsetXConnection = useXWagmiStore((state) => state.unsetXConnection);
+  const { disconnectAsync } = useDisconnect();
+  const { mutateAsync: suiDisconnectAsync } = useDisconnectWallet();
+  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;
+        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]
+  );
+}
+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, xChainId);
+      return balances;
+    },
+    enabled: !!xService,
+    placeholderData: keepPreviousData,
+    refetchInterval: 5e3
+  });
+}
+function useWalletProviderOptions(xChainId) {
+  const xChainType = getXChainType(xChainId);
+  const evmPublicClient = usePublicClient({
+    chainId: xChainId ? getWagmiChainId(xChainId) : void 0
+  });
+  const { data: evmWalletClient } = useWalletClient({
+    chainId: xChainId ? getWagmiChainId(xChainId) : void 0
+  });
+  const xService = useXService(getXChainType(xChainId));
+  const xAccount = useXAccount(xChainId);
+  return useMemo(() => {
+    switch (xChainType) {
+      case "EVM": {
+        return { walletClient: evmWalletClient, publicClient: evmPublicClient };
+      }
+      case "SUI": {
+        const suiXService = xService;
+        return { client: suiXService.suiClient, wallet: suiXService.suiWallet, account: suiXService.suiAccount };
+      }
+      case "ICON": {
+        return { walletAddress: xAccount.address, rpcUrl: CHAIN_INFO[1 /* MAINNET */].APIEndpoint };
+      }
+      case "INJECTIVE": {
+        const injectiveXService = xService;
+        const endpoints = getNetworkEndpoints(Network.Mainnet);
+        return {
+          walletAddress: xAccount.address,
+          msgBroadcaster: injectiveXService.msgBroadcaster,
+          rpcUrl: endpoints.rpc
+        };
+      }
+      default:
+        return void 0;
+    }
+  }, [xChainType, evmPublicClient, evmWalletClient, xService, xAccount]);
+}
+function useEthereumChainId() {
+  const injectiveXService = useXService("INJECTIVE");
+  const [ethereumChainId, setEthereumChainId] = React3.useState(null);
+  useEffect(() => {
+    if (!injectiveXService?.walletStrategy?.getWallet()) return;
+    const walletStrategy = injectiveXService.walletStrategy;
+    if (walletStrategy.getWallet() !== Wallet.Metamask) return;
+    const getEthereumChainId = async () => {
+      const chainId = await walletStrategy.getEthereumChainId();
+      setEthereumChainId(Number.parseInt(chainId));
+    };
+    getEthereumChainId();
+    walletStrategy.getStrategy().onChainIdChanged(getEthereumChainId);
+  }, [injectiveXService?.walletStrategy]);
+  return ethereumChainId;
+}
+var switchEthereumChain2 = 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 = xChainMap[expectedXChainId].id;
+  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") {
+      switchEthereumChain2();
+    } else {
+      switchChain({ chainId: expectedChainId });
+    }
+  }, [switchChain, expectedChainId, xChainType]);
+  return useMemo(
+    () => ({
+      isWrongChain,
+      handleSwitchChain
+    }),
+    [isWrongChain, handleSwitchChain]
+  );
+};
+function useWalletProvider(spokeChainId) {
+  const xChainType = getXChainType(spokeChainId);
+  const evmPublicClient = usePublicClient({
+    chainId: spokeChainId ? getWagmiChainId(spokeChainId) : void 0
+  });
+  const { data: evmWalletClient } = useWalletClient({
+    chainId: spokeChainId ? getWagmiChainId(spokeChainId) : void 0
+  });
+  const xService = useXService(getXChainType(spokeChainId));
+  const xAccount = useXAccount(spokeChainId);
+  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;
+        }
+        const { walletAddress, msgBroadcaster } = {
+          walletAddress: xAccount.address,
+          msgBroadcaster: injectiveXService.msgBroadcaster
+        };
+        return new InjectiveWalletProvider({
+          walletAddress,
+          msgBroadcaster
+        });
+      }
+      case "STELLAR": {
+        const stellarXService = xService;
+        return new StellarWalletProvider({
+          type: "BROWSER_EXTENSION",
+          walletsKit: stellarXService.walletsKit,
+          network: "PUBLIC"
+        });
+      }
+      case "SOLANA": {
+        const solanaXService = xService;
+        if (!solanaXService.wallet) {
+          throw new Error("Wallet is not initialized");
+        }
+        if (!solanaXService.connection) {
+          throw new Error("Connection is not initialized");
+        }
+        return new SolanaWalletProvider({
+          wallet: solanaXService.wallet,
+          connection: solanaXService.connection
+        });
+      }
+      default:
+        return void 0;
+    }
+  }, [xChainType, evmPublicClient, evmWalletClient, xService, xAccount]);
+}
+var SodaxWalletProvider = ({ children, config }) => {
+  useEffect(() => {
+    initXWagmiStore(config);
+  }, [config]);
+  const {
+    EVM: { chains },
+    SOLANA: { endpoint }
+  } = config;
+  const wallets = useMemo(() => [new UnsafeBurnerWalletAdapter()], []);
+  const wagmiConfig = useMemo(() => {
+    return getWagmiConfig(chains);
+  }, [chains]);
+  return /* @__PURE__ */ React3.createElement(WagmiProvider, { config: wagmiConfig }, /* @__PURE__ */ React3.createElement(SuiClientProvider, { networks: { mainnet: { url: getFullnodeUrl("mainnet") } }, defaultNetwork: "mainnet" }, /* @__PURE__ */ React3.createElement(WalletProvider, { autoConnect: true }, /* @__PURE__ */ React3.createElement(ConnectionProvider, { endpoint }, /* @__PURE__ */ React3.createElement(WalletProvider$1, { wallets, autoConnect: true }, /* @__PURE__ */ React3.createElement(InitXWagmiStore, null), children)))));
+};
+
+// 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 { EvmXConnector, EvmXService, IconHanaXConnector, IconXService, InitXWagmiStore, InjectiveKelprXConnector, InjectiveMetamaskXConnector, InjectiveXService, SodaxWalletProvider, SolanaXConnector, SolanaXService, StellarWalletsKitXConnector, StellarXService, SuiXConnector, SuiXService, WalletId, XConnector, XService, arbitrum, avalanche, base, bsc, getWagmiChainId, getXChainType, getXService, hyper, icon, initXWagmiStore, injective, isNativeToken, lightlink, nibiru, optimism, polygon, solana, sonic, stellar, sui, switchEthereumChain, useEvmSwitchChain, useWalletProvider, useWalletProviderOptions, useXAccount, useXAccounts, useXBalances, useXConnect, useXConnection, useXConnectors, useXDisconnect, useXService, useXWagmiStore, xChainMap, xChains };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map