@sodax/wallet-sdk-react 0.0.1-rc.5 → 0.0.1-rc.6

package/dist/index.mjs

@@ -1,11 +1,11 @@
+import { baseChainInfo } from '@sodax/types';
 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 { getPublicClient } from 'wagmi/actions';
+import { useConnections, useAccount, useConnect, useConnectors, useDisconnect, useSwitchChain, usePublicClient, useWalletClient, useSignMessage, WagmiProvider, createConfig, http, useConfig } from 'wagmi';
+import { mainnet, avalanche, arbitrum, base, bsc, sonic, optimism, polygon, nibiru, lightlinkPhoenix } from 'wagmi/chains';
 import * as IconSdkRaw from 'icon-sdk-js';
 import { getNetworkEndpoints, Network } from '@injectivelabs/networks';
-import { IndexerGrpcAccountPortfolioApi, ChainGrpcWasmApi, getInjectiveAddress } from '@injectivelabs/sdk-ts';
+import { IndexerGrpcAccountPortfolioApi, ChainGrpcWasmApi, getInjectiveAddress, getEthereumAddress } from '@injectivelabs/sdk-ts';
 import { ChainId } from '@injectivelabs/ts-types';
 import { MsgBroadcaster } from '@injectivelabs/wallet-core';
 import { WalletStrategy } from '@injectivelabs/wallet-strategy';
@@ -13,153 +13,28 @@ 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 { 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 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 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 { create } from 'zustand';
-import { persist, createJSONStorage } from 'zustand/middleware';
+import { devtools, 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);
+import { AnchorProvider } from '@coral-xyz/anchor';
 
 // src/actions/getXChainType.ts
 function getXChainType(xChainId) {
   if (!xChainId) {
     return void 0;
   }
-  return xChainMap[xChainId].xChainType;
+  return baseChainInfo[xChainId].type;
 }
 
 // src/actions/getXService.ts
@@ -193,23 +68,21 @@ var XService = class {
    * 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) {
+  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
-   * @param xChainId The chain ID to query
    * @returns Promise resolving to object mapping token addresses to balances
    */
-  async getBalances(address, xTokens, xChainId) {
+  async getBalances(address, xTokens) {
     if (!address) return {};
     const balancePromises = xTokens.map(async (xToken) => {
-      const balance = await this.getBalance(address, xToken, xChainId);
+      const balance = await this.getBalance(address, xToken);
       return { address: xToken.address, balance };
     });
     const balances = await Promise.all(balancePromises);
@@ -256,8 +129,6 @@ var XConnector = class {
     return this._icon;
   }
 };
-
-// src/utils/index.ts
 var isNativeToken = (xToken) => {
   const nativeAddresses = [
     "cx0000000000000000000000000000000000000000",
@@ -273,22 +144,9 @@ var isNativeToken = (xToken) => {
   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;
+  return baseChainInfo[xChainId].chainId;
 };
-var hyper2 = /* @__PURE__ */ defineChain({
+var hyper = /* @__PURE__ */ defineChain({
   id: 999,
   name: "HyperEVM",
   nativeCurrency: {
@@ -312,32 +170,22 @@ var hyper2 = /* @__PURE__ */ defineChain({
     }
   }
 });
-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;
-    },
-    {}
-  );
+var createWagmiConfig = (config) => {
   return createConfig({
-    chains: finalChains,
-    transports
-    // ssr: true,
+    chains: [mainnet, avalanche, arbitrum, base, bsc, sonic, optimism, polygon, nibiru, hyper, lightlinkPhoenix],
+    transports: {
+      [mainnet.id]: http(config["mainnet"]),
+      [avalanche.id]: http(config["avalanche"]),
+      [arbitrum.id]: http(config["arbitrum"]),
+      [base.id]: http(config["base"]),
+      [bsc.id]: http(config["bsc"]),
+      [sonic.id]: http(config["sonic"]),
+      [optimism.id]: http(config["optimism"]),
+      [polygon.id]: http(config["polygon"]),
+      [nibiru.id]: http(config["nibiru"]),
+      [hyper.id]: http(config["hyper"]),
+      [lightlinkPhoenix.id]: http(config["lightlinkPhoenix"])
+    }
   });
 };
 var EvmXService = class _EvmXService extends XService {
@@ -353,34 +201,23 @@ var EvmXService = class _EvmXService extends XService {
     }
     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) {
+  async getBalance(address, xToken) {
     if (!address) return 0n;
-    const chainId = getWagmiChainId(xChainId);
+    if (!this.wagmiConfig) return 0n;
+    const chainId = getWagmiChainId(xToken.xChainId);
     if (isNativeToken(xToken)) {
-      const balance = await this.getPublicClient(chainId)?.getBalance({ address });
+      const balance = await getPublicClient(this.wagmiConfig, { chainId })?.getBalance({
+        address
+      });
       return balance || 0n;
     }
     throw new Error(`Unsupported token: ${xToken.symbol}`);
   }
-  async getBalances(address, xTokens, xChainId) {
+  async getBalances(address, xTokens) {
     if (!address) return {};
+    if (!this.wagmiConfig) return {};
     const balancePromises = xTokens.filter((xToken) => isNativeToken(xToken)).map(async (xToken) => {
-      const balance = await this.getBalance(address, xToken, xChainId);
+      const balance = await this.getBalance(address, xToken);
       return { symbol: xToken.symbol, address: xToken.address, balance };
     });
     const balances = await Promise.all(balancePromises);
@@ -389,7 +226,8 @@ var EvmXService = class _EvmXService extends XService {
       return map;
     }, {});
     const nonNativeXTokens = xTokens.filter((xToken) => !isNativeToken(xToken));
-    const result = await this.getPublicClient(getWagmiChainId(xChainId))?.multicall({
+    const xChainId = xTokens[0].xChainId;
+    const result = await getPublicClient(this.wagmiConfig, { chainId: getWagmiChainId(xChainId) })?.multicall({
       contracts: nonNativeXTokens.map((token) => ({
         abi: erc20Abi,
         address: token.address,
@@ -464,7 +302,7 @@ var IconXService = class _IconXService extends XService {
       return Array(calls.length).fill(null);
     }
   }
-  async getBalances(address, xTokens, xChainId) {
+  async getBalances(address, xTokens) {
     if (!address) return {};
     const balances = {};
     const nativeXToken = xTokens.find((xToken) => isNativeToken(xToken));
@@ -578,7 +416,7 @@ var InjectiveXService = class _InjectiveXService extends XService {
 };
 var InjectiveKelprXConnector = class extends XConnector {
   constructor() {
-    super("INJECTIVE", "Keplr", "keplr");
+    super("INJECTIVE", "Keplr", Wallet.Keplr);
   }
   getXService() {
     return InjectiveXService.getInstance();
@@ -603,7 +441,7 @@ var InjectiveKelprXConnector = class extends XConnector {
 };
 var InjectiveMetamaskXConnector = class extends XConnector {
   constructor() {
-    super("INJECTIVE", "MetaMask", "metamask");
+    super("INJECTIVE", "MetaMask", Wallet.Metamask);
   }
   getXService() {
     return InjectiveXService.getInstance();
@@ -790,7 +628,6 @@ var StellarXService = class _StellarXService extends XService {
     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 });
@@ -912,70 +749,14 @@ var SuiXConnector = class extends XConnector {
     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) => {
+var initXServices = () => {
   const xServices = {};
-  Object.keys(config).forEach((key) => {
+  ["EVM", "INJECTIVE", "STELLAR", "SUI", "SOLANA", "ICON"].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":
-        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(), new InjectiveKelprXConnector()]);
-        break;
-      case "STELLAR":
-        xServices[xChainType] = StellarXService.getInstance();
+        xServices[xChainType] = EvmXService.getInstance();
         xServices[xChainType].setXConnectors([]);
         break;
       case "SUI":
@@ -986,6 +767,15 @@ var initXServices = (config) => {
         xServices[xChainType] = SolanaXService.getInstance();
         xServices[xChainType].setXConnectors([]);
         break;
+      // Injective, Stellar, Icon wallet connectors are supported by sodax wallet-sdk-react sdk.
+      case "INJECTIVE":
+        xServices[xChainType] = InjectiveXService.getInstance();
+        xServices[xChainType].setXConnectors([new InjectiveMetamaskXConnector(), new InjectiveKelprXConnector()]);
+        break;
+      case "STELLAR":
+        xServices[xChainType] = StellarXService.getInstance();
+        xServices[xChainType].setXConnectors([]);
+        break;
       case "ICON":
         xServices[xChainType] = IconXService.getInstance();
         xServices[xChainType].setXConnectors([new IconHanaXConnector()]);
@@ -994,50 +784,32 @@ var initXServices = (config) => {
   });
   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);
-};
+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) {
@@ -1143,7 +915,7 @@ function useXConnect() {
   const setXConnection = useXWagmiStore((state) => state.setXConnection);
   const { connectAsync: evmConnectAsync } = useConnect();
   const { mutateAsync: suiConnectAsync } = useConnectWallet();
-  const { select, connect, connected } = useWallet();
+  const { select, connect } = useWallet();
   return useMutation({
     mutationFn: async (xConnector) => {
       const xChainType = xConnector.xChainType;
@@ -1292,7 +1064,7 @@ function useXBalances({
       if (!xService) {
         return {};
       }
-      const balances = await xService.getBalances(address, xTokens, xChainId);
+      const balances = await xService.getBalances(address, xTokens);
       return balances;
     },
     enabled: !!xService,
@@ -1300,45 +1072,9 @@ function useXBalances({
     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);
+  const [ethereumChainId, setEthereumChainId] = React2.useState(null);
   useEffect(() => {
     if (!injectiveXService?.walletStrategy?.getWallet()) return;
     const walletStrategy = injectiveXService.walletStrategy;
@@ -1370,7 +1106,7 @@ var switchEthereumChain2 = async () => {
 };
 var useEvmSwitchChain = (expectedXChainId) => {
   const xChainType = getXChainType(expectedXChainId);
-  const expectedChainId = xChainMap[expectedXChainId].id;
+  const expectedChainId = baseChainInfo[expectedXChainId].chainId;
   const injectiveXService = useXService("INJECTIVE");
   const ethereumChainId = useEthereumChainId();
   const { chainId } = useAccount();
@@ -1395,12 +1131,8 @@ var useEvmSwitchChain = (expectedXChainId) => {
 };
 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 evmPublicClient = usePublicClient();
+  const { data: evmWalletClient } = useWalletClient();
   const xService = useXService(getXChainType(spokeChainId));
   const xAccount = useXAccount(spokeChainId);
   return useMemo(() => {
@@ -1447,6 +1179,9 @@ function useWalletProvider(spokeChainId) {
       }
       case "STELLAR": {
         const stellarXService = xService;
+        if (!stellarXService.walletsKit) {
+          return void 0;
+        }
         return new StellarWalletProvider({
           type: "BROWSER_EXTENSION",
           walletsKit: stellarXService.walletsKit,
@@ -1456,10 +1191,10 @@ function useWalletProvider(spokeChainId) {
       case "SOLANA": {
         const solanaXService = xService;
         if (!solanaXService.wallet) {
-          throw new Error("Wallet is not initialized");
+          return void 0;
         }
         if (!solanaXService.connection) {
-          throw new Error("Connection is not initialized");
+          return void 0;
         }
         return new SolanaWalletProvider({
           wallet: solanaXService.wallet,
@@ -1471,20 +1206,167 @@ function useWalletProvider(spokeChainId) {
     }
   }, [xChainType, evmPublicClient, evmWalletClient, xService, xAccount]);
 }
-var SodaxWalletProvider = ({ children, config }) => {
+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;
+        }
+        default:
+          console.warn("Unsupported chain type");
+          break;
+      }
+      return signature;
+    }
+  });
+}
+function useAnchorProvider() {
+  const { connection } = useConnection();
+  const wallet = useWallet();
+  return new AnchorProvider(connection, wallet, { commitment: "confirmed" });
+}
+var Hydrate = () => {
+  const suiClient = useSuiClient();
   useEffect(() => {
-    initXWagmiStore(config);
-  }, [config]);
-  const {
-    EVM: { chains },
-    SOLANA: { endpoint }
-  } = config;
-  const wallets = useMemo(() => [new UnsafeBurnerWalletAdapter()], []);
+    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]);
+  const wagmiConfig = useConfig();
+  useEffect(() => {
+    if (wagmiConfig) {
+      EvmXService.getInstance().wagmiConfig = wagmiConfig;
+    }
+  }, [wagmiConfig]);
+  return null;
+};
+
+// src/xchains/icon/actions.ts
+var reconnectIcon = async () => {
+  const iconConnection = useXWagmiStore.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
+        }
+      }
+    });
+  }
+};
+
+// src/xchains/stellar/actions.ts
+var reconnectStellar = async () => {
+  const stellarConnection = useXWagmiStore.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
+      }
+    }
+  });
+};
+
+// src/SodaxWalletProvider.tsx
+var SodaxWalletProvider = ({ children, rpcConfig }) => {
   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)))));
+    return createWagmiConfig(rpcConfig);
+  }, [rpcConfig]);
+  const wallets = useMemo(() => [new UnsafeBurnerWalletAdapter()], []);
+  return /* @__PURE__ */ React2.createElement(WagmiProvider, { config: wagmiConfig, reconnectOnMount: true }, /* @__PURE__ */ React2.createElement(SuiClientProvider, { networks: { mainnet: { url: getFullnodeUrl("mainnet") } }, defaultNetwork: "mainnet" }, /* @__PURE__ */ React2.createElement(WalletProvider, { autoConnect: true }, /* @__PURE__ */ React2.createElement(ConnectionProvider, { endpoint: rpcConfig["solana"] ?? "" }, /* @__PURE__ */ React2.createElement(WalletProvider$1, { wallets, autoConnect: true }, /* @__PURE__ */ React2.createElement(Hydrate, null), children)))));
 };
+reconnectIcon();
+reconnectStellar();
 
 // src/types/index.ts
 var WalletId = /* @__PURE__ */ ((WalletId2) => {
@@ -1496,6 +1378,6 @@ var WalletId = /* @__PURE__ */ ((WalletId2) => {
   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 };
+export { EvmXConnector, EvmXService, IconHanaXConnector, IconXService, InjectiveKelprXConnector, InjectiveMetamaskXConnector, InjectiveXService, SodaxWalletProvider, SolanaXConnector, SolanaXService, StellarWalletsKitXConnector, StellarXService, SuiXConnector, SuiXService, WalletId, XConnector, XService, getWagmiChainId, getXChainType, getXService, isNativeToken, switchEthereumChain, useEvmSwitchChain, useWalletProvider, useXAccount, useXAccounts, useXBalances, useXConnect, useXConnection, useXConnectors, useXDisconnect, useXService, useXSignMessage, useXWagmiStore };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map