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

package/dist/index.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
+var types = require('@sodax/types');
 var viem = require('viem');
 var actions = require('wagmi/actions');
 var wagmi = require('wagmi');
 var chains = require('wagmi/chains');
-var types = require('@sodax/types');
 var IconSdkRaw = require('icon-sdk-js');
 var networks = require('@injectivelabs/networks');
 var sdkTs = require('@injectivelabs/sdk-ts');
@@ -17,18 +17,18 @@ var web3_js = require('@solana/web3.js');
 var splToken = require('@solana/spl-token');
 var stellarWalletsKit = require('@creit.tech/stellar-wallets-kit');
 var StellarSdk = require('@stellar/stellar-sdk');
-var React3 = require('react');
+var React2 = require('react');
 var dappKit = require('@mysten/dapp-kit');
 var walletAdapterReact = require('@solana/wallet-adapter-react');
 var zustand = require('zustand');
 var middleware = require('zustand/middleware');
 var immer = require('zustand/middleware/immer');
-var anchor = require('@coral-xyz/anchor');
 var reactQuery = require('@tanstack/react-query');
 var chains$1 = require('viem/chains');
 var walletSdkCore = require('@sodax/wallet-sdk-core');
 var client = require('@mysten/sui/client');
 var walletAdapterWallets = require('@solana/wallet-adapter-wallets');
+var anchor = require('@coral-xyz/anchor');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -52,139 +52,14 @@ function _interopNamespace(e) {
 
 var IconSdkRaw__namespace = /*#__PURE__*/_interopNamespace(IconSdkRaw);
 var StellarSdk__namespace = /*#__PURE__*/_interopNamespace(StellarSdk);
-var React3__default = /*#__PURE__*/_interopDefault(React3);
-
-// 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);
+var React2__default = /*#__PURE__*/_interopDefault(React2);
 
 // src/actions/getXChainType.ts
 function getXChainType(xChainId) {
   if (!xChainId) {
     return void 0;
   }
-  return xChainMap[xChainId].xChainType;
+  return types.baseChainInfo[xChainId].type;
 }
 
 // src/actions/getXService.ts
@@ -218,23 +93,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);
@@ -281,8 +154,6 @@ var XConnector = class {
     return this._icon;
   }
 };
-
-// src/utils/index.ts
 var isNativeToken = (xToken) => {
   const nativeAddresses = [
     "cx0000000000000000000000000000000000000000",
@@ -298,22 +169,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 types.baseChainInfo[xChainId].chainId;
 };
-var hyper2 = /* @__PURE__ */ viem.defineChain({
+var hyper = /* @__PURE__ */ viem.defineChain({
   id: 999,
   name: "HyperEVM",
   nativeCurrency: {
@@ -337,32 +195,22 @@ var hyper2 = /* @__PURE__ */ viem.defineChain({
     }
   }
 });
-var evmChainMap = {
-  [types.AVALANCHE_MAINNET_CHAIN_ID]: chains.avalanche,
-  [types.ARBITRUM_MAINNET_CHAIN_ID]: chains.arbitrum,
-  [types.BASE_MAINNET_CHAIN_ID]: chains.base,
-  [types.BSC_MAINNET_CHAIN_ID]: chains.bsc,
-  [types.SONIC_MAINNET_CHAIN_ID]: chains.sonic,
-  [types.OPTIMISM_MAINNET_CHAIN_ID]: chains.optimism,
-  [types.POLYGON_MAINNET_CHAIN_ID]: chains.polygon,
-  [types.NIBIRU_MAINNET_CHAIN_ID]: chains.nibiru,
-  [types.HYPEREVM_MAINNET_CHAIN_ID]: hyper2,
-  [types.LIGHTLINK_MAINNET_CHAIN_ID]: chains.lightlinkPhoenix
-};
-var getWagmiConfig = (chains$1) => {
-  const mappedChains = chains$1.map((chain) => evmChainMap[chain]);
-  const finalChains = mappedChains.length > 0 ? mappedChains : [chains.mainnet];
-  const transports = finalChains.reduce(
-    (acc, chain) => {
-      acc[chain.id] = wagmi.http();
-      return acc;
-    },
-    {}
-  );
+var createWagmiConfig = (config) => {
   return wagmi.createConfig({
-    chains: finalChains,
-    transports
-    // ssr: true,
+    chains: [chains.mainnet, chains.avalanche, chains.arbitrum, chains.base, chains.bsc, chains.sonic, chains.optimism, chains.polygon, chains.nibiru, hyper, chains.lightlinkPhoenix],
+    transports: {
+      [chains.mainnet.id]: wagmi.http(config["mainnet"]),
+      [chains.avalanche.id]: wagmi.http(config["avalanche"]),
+      [chains.arbitrum.id]: wagmi.http(config["arbitrum"]),
+      [chains.base.id]: wagmi.http(config["base"]),
+      [chains.bsc.id]: wagmi.http(config["bsc"]),
+      [chains.sonic.id]: wagmi.http(config["sonic"]),
+      [chains.optimism.id]: wagmi.http(config["optimism"]),
+      [chains.polygon.id]: wagmi.http(config["polygon"]),
+      [chains.nibiru.id]: wagmi.http(config["nibiru"]),
+      [hyper.id]: wagmi.http(config["hyper"]),
+      [chains.lightlinkPhoenix.id]: wagmi.http(config["lightlinkPhoenix"])
+    }
   });
 };
 var EvmXService = class _EvmXService extends XService {
@@ -378,34 +226,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 actions.getPublicClient(getWagmiConfig(this.config.chains), { chainId });
-  }
-  async getWalletClient(chainId) {
-    if (!this.config) {
-      throw new Error("EvmXService: config is not initialized yet");
-    }
-    return await actions.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 actions.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);
@@ -414,7 +251,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 actions.getPublicClient(this.wagmiConfig, { chainId: getWagmiChainId(xChainId) })?.multicall({
       contracts: nonNativeXTokens.map((token) => ({
         abi: viem.erc20Abi,
         address: token.address,
@@ -489,7 +327,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));
@@ -603,7 +441,7 @@ var InjectiveXService = class _InjectiveXService extends XService {
 };
 var InjectiveKelprXConnector = class extends XConnector {
   constructor() {
-    super("INJECTIVE", "Keplr", "keplr");
+    super("INJECTIVE", "Keplr", walletBase.Wallet.Keplr);
   }
   getXService() {
     return InjectiveXService.getInstance();
@@ -628,7 +466,7 @@ var InjectiveKelprXConnector = class extends XConnector {
 };
 var InjectiveMetamaskXConnector = class extends XConnector {
   constructor() {
-    super("INJECTIVE", "MetaMask", "metamask");
+    super("INJECTIVE", "MetaMask", walletBase.Wallet.Metamask);
   }
   getXService() {
     return InjectiveXService.getInstance();
@@ -815,7 +653,6 @@ var StellarXService = class _StellarXService extends XService {
     super("STELLAR");
     this.walletsKit = new stellarWalletsKit.StellarWalletsKit({
       network: stellarWalletsKit.WalletNetwork.PUBLIC,
-      selectedWalletId: stellarWalletsKit.FREIGHTER_ID,
       modules: stellarWalletsKit.allowAllModules()
     });
     this.server = new StellarSdk__namespace.Horizon.Server("https://horizon.stellar.org", { allowHttp: true });
@@ -937,70 +774,14 @@ var SuiXConnector = class extends XConnector {
     return this.wallet?.icon;
   }
 };
-function useAnchorProvider() {
-  const { connection } = walletAdapterReact.useConnection();
-  const wallet = walletAdapterReact.useWallet();
-  return new anchor.AnchorProvider(connection, wallet, { commitment: "confirmed" });
-}
-var useXWagmiStore = zustand.create()(
-  middleware.persist(
-    immer.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: middleware.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":
@@ -1011,6 +792,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()]);
@@ -1019,50 +809,32 @@ var initXServices = (config) => {
   });
   return xServices;
 };
-var initXWagmiStore = (config) => {
-  useXWagmiStore.setState({
-    xServices: initXServices(config)
-  });
-};
-var InitXWagmiStore = () => {
-  const suiClient = dappKit.useSuiClient();
-  React3.useEffect(() => {
-    if (suiClient) {
-      SuiXService.getInstance().suiClient = suiClient;
-    }
-  }, [suiClient]);
-  const { currentWallet: suiWallet } = dappKit.useCurrentWallet();
-  React3.useEffect(() => {
-    if (suiWallet) {
-      SuiXService.getInstance().suiWallet = suiWallet;
-    }
-  }, [suiWallet]);
-  const suiAccount = dappKit.useCurrentAccount();
-  React3.useEffect(() => {
-    if (suiAccount) {
-      SuiXService.getInstance().suiAccount = suiAccount;
-    }
-  }, [suiAccount]);
-  const { connection: solanaConnection } = walletAdapterReact.useConnection();
-  const solanaWallet = walletAdapterReact.useWallet();
-  const solanaProvider = useAnchorProvider();
-  React3.useEffect(() => {
-    if (solanaConnection) {
-      SolanaXService.getInstance().connection = solanaConnection;
-    }
-  }, [solanaConnection]);
-  React3.useEffect(() => {
-    if (solanaWallet) {
-      SolanaXService.getInstance().wallet = solanaWallet;
-    }
-  }, [solanaWallet]);
-  React3.useEffect(() => {
-    if (solanaProvider) {
-      SolanaXService.getInstance().provider = solanaProvider;
-    }
-  }, [solanaProvider]);
-  return /* @__PURE__ */ React3__default.default.createElement(React3__default.default.Fragment, null);
-};
+var useXWagmiStore = zustand.create()(
+  middleware.devtools(
+    middleware.persist(
+      immer.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: middleware.createJSONStorage(() => localStorage),
+        partialize: (state) => ({ xConnections: state.xConnections })
+      }
+    ),
+    { name: "xwagmi-store" }
+  )
+);
 
 // src/hooks/useXConnection.ts
 function useXConnection(xChainType) {
@@ -1072,7 +844,7 @@ function useXConnection(xChainType) {
   const suiAccount = dappKit.useCurrentAccount();
   const suiCurrentWallet = dappKit.useCurrentWallet();
   const solanaWallet = walletAdapterReact.useWallet();
-  const xConnection2 = React3.useMemo(() => {
+  const xConnection2 = React2.useMemo(() => {
     if (!xChainType) {
       return void 0;
     }
@@ -1112,7 +884,7 @@ function isChainType(chainIdentifier) {
 function useXAccount(chainIdentifier) {
   const resolvedChainType = chainIdentifier ? isChainType(chainIdentifier) ? chainIdentifier : getXChainType(chainIdentifier) : void 0;
   const xConnection = useXConnection(resolvedChainType);
-  const xAccount = React3.useMemo(() => {
+  const xAccount = React2.useMemo(() => {
     if (!resolvedChainType) {
       return {
         address: void 0,
@@ -1129,7 +901,7 @@ function useXAccounts() {
   const { address: evmAddress } = wagmi.useAccount();
   const suiAccount = dappKit.useCurrentAccount();
   const solanaWallet = walletAdapterReact.useWallet();
-  const xAccounts = React3.useMemo(() => {
+  const xAccounts = React2.useMemo(() => {
     const result = {};
     for (const xChainType of xChainTypes) {
       const xConnection = xConnections[xChainType];
@@ -1168,7 +940,7 @@ function useXConnect() {
   const setXConnection = useXWagmiStore((state) => state.setXConnection);
   const { connectAsync: evmConnectAsync } = wagmi.useConnect();
   const { mutateAsync: suiConnectAsync } = dappKit.useConnectWallet();
-  const { select, connect, connected } = walletAdapterReact.useWallet();
+  const { select, connect } = walletAdapterReact.useWallet();
   return reactQuery.useMutation({
     mutationFn: async (xConnector) => {
       const xChainType = xConnector.xChainType;
@@ -1182,7 +954,7 @@ function useXConnect() {
           break;
         case "SOLANA": {
           const walletName = xConnector.wallet.adapter.name;
-          await select(walletName);
+          select(walletName);
           const adapter = xConnector.wallet.adapter;
           if (!adapter) throw new Error("No adapter found for Solana wallet");
           if (walletName === "MetaMask") {
@@ -1255,7 +1027,7 @@ function useXConnectors(xChainType) {
   const suiWallets = dappKit.useWallets();
   const { data: stellarXConnectors } = useStellarXConnectors();
   const { wallets: solanaWallets } = walletAdapterReact.useWallet();
-  const xConnectors = React3.useMemo(() => {
+  const xConnectors = React2.useMemo(() => {
     if (!xChainType || !xService) {
       return [];
     }
@@ -1280,7 +1052,7 @@ function useXDisconnect() {
   const { disconnectAsync } = wagmi.useDisconnect();
   const { mutateAsync: suiDisconnectAsync } = dappKit.useDisconnectWallet();
   const solanaWallet = walletAdapterReact.useWallet();
-  return React3.useCallback(
+  return React2.useCallback(
     async (xChainType) => {
       switch (xChainType) {
         case "EVM":
@@ -1317,7 +1089,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,
@@ -1325,46 +1097,10 @@ function useXBalances({
     refetchInterval: 5e3
   });
 }
-function useWalletProviderOptions(xChainId) {
-  const xChainType = getXChainType(xChainId);
-  const evmPublicClient = wagmi.usePublicClient({
-    chainId: xChainId ? getWagmiChainId(xChainId) : void 0
-  });
-  const { data: evmWalletClient } = wagmi.useWalletClient({
-    chainId: xChainId ? getWagmiChainId(xChainId) : void 0
-  });
-  const xService = useXService(getXChainType(xChainId));
-  const xAccount = useXAccount(xChainId);
-  return React3.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 = networks.getNetworkEndpoints(networks.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__default.default.useState(null);
-  React3.useEffect(() => {
+  const [ethereumChainId, setEthereumChainId] = React2__default.default.useState(null);
+  React2.useEffect(() => {
     if (!injectiveXService?.walletStrategy?.getWallet()) return;
     const walletStrategy = injectiveXService.walletStrategy;
     if (walletStrategy.getWallet() !== walletBase.Wallet.Metamask) return;
@@ -1395,22 +1131,22 @@ var switchEthereumChain2 = async () => {
 };
 var useEvmSwitchChain = (expectedXChainId) => {
   const xChainType = getXChainType(expectedXChainId);
-  const expectedChainId = xChainMap[expectedXChainId].id;
+  const expectedChainId = types.baseChainInfo[expectedXChainId].chainId;
   const injectiveXService = useXService("INJECTIVE");
   const ethereumChainId = useEthereumChainId();
   const { chainId } = wagmi.useAccount();
-  const isWrongChain = React3.useMemo(() => {
+  const isWrongChain = React2.useMemo(() => {
     return xChainType === "EVM" && chainId !== expectedChainId || xChainType === "INJECTIVE" && injectiveXService && injectiveXService.walletStrategy.getWallet() === walletBase.Wallet.Metamask && ethereumChainId !== chains$1.mainnet.id;
   }, [xChainType, chainId, expectedChainId, ethereumChainId, injectiveXService]);
   const { switchChain } = wagmi.useSwitchChain();
-  const handleSwitchChain = React3.useCallback(() => {
+  const handleSwitchChain = React2.useCallback(() => {
     if (xChainType === "INJECTIVE") {
       switchEthereumChain2();
     } else {
       switchChain({ chainId: expectedChainId });
     }
   }, [switchChain, expectedChainId, xChainType]);
-  return React3.useMemo(
+  return React2.useMemo(
     () => ({
       isWrongChain,
       handleSwitchChain
@@ -1420,15 +1156,11 @@ var useEvmSwitchChain = (expectedXChainId) => {
 };
 function useWalletProvider(spokeChainId) {
   const xChainType = getXChainType(spokeChainId);
-  const evmPublicClient = wagmi.usePublicClient({
-    chainId: spokeChainId ? getWagmiChainId(spokeChainId) : void 0
-  });
-  const { data: evmWalletClient } = wagmi.useWalletClient({
-    chainId: spokeChainId ? getWagmiChainId(spokeChainId) : void 0
-  });
+  const evmPublicClient = wagmi.usePublicClient();
+  const { data: evmWalletClient } = wagmi.useWalletClient();
   const xService = useXService(getXChainType(spokeChainId));
   const xAccount = useXAccount(spokeChainId);
-  return React3.useMemo(() => {
+  return React2.useMemo(() => {
     switch (xChainType) {
       case "EVM": {
         if (!evmWalletClient) {
@@ -1466,17 +1198,15 @@ function useWalletProvider(spokeChainId) {
         if (!injectiveXService) {
           return void 0;
         }
-        const { walletAddress, msgBroadcaster } = {
-          walletAddress: xAccount.address,
-          msgBroadcaster: injectiveXService.msgBroadcaster
-        };
         return new walletSdkCore.InjectiveWalletProvider({
-          walletAddress,
-          msgBroadcaster
+          msgBroadcaster: injectiveXService.msgBroadcaster
         });
       }
       case "STELLAR": {
         const stellarXService = xService;
+        if (!stellarXService.walletsKit) {
+          return void 0;
+        }
         return new walletSdkCore.StellarWalletProvider({
           type: "BROWSER_EXTENSION",
           walletsKit: stellarXService.walletsKit,
@@ -1486,10 +1216,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 walletSdkCore.SolanaWalletProvider({
           wallet: solanaXService.wallet,
@@ -1501,20 +1231,167 @@ function useWalletProvider(spokeChainId) {
     }
   }, [xChainType, evmPublicClient, evmWalletClient, xService, xAccount]);
 }
-var SodaxWalletProvider = ({ children, config }) => {
-  React3.useEffect(() => {
-    initXWagmiStore(config);
-  }, [config]);
-  const {
-    EVM: { chains },
-    SOLANA: { endpoint }
-  } = config;
-  const wallets = React3.useMemo(() => [new walletAdapterWallets.UnsafeBurnerWalletAdapter()], []);
-  const wagmiConfig = React3.useMemo(() => {
-    return getWagmiConfig(chains);
-  }, [chains]);
-  return /* @__PURE__ */ React3__default.default.createElement(wagmi.WagmiProvider, { config: wagmiConfig }, /* @__PURE__ */ React3__default.default.createElement(dappKit.SuiClientProvider, { networks: { mainnet: { url: client.getFullnodeUrl("mainnet") } }, defaultNetwork: "mainnet" }, /* @__PURE__ */ React3__default.default.createElement(dappKit.WalletProvider, { autoConnect: true }, /* @__PURE__ */ React3__default.default.createElement(walletAdapterReact.ConnectionProvider, { endpoint }, /* @__PURE__ */ React3__default.default.createElement(walletAdapterReact.WalletProvider, { wallets, autoConnect: true }, /* @__PURE__ */ React3__default.default.createElement(InitXWagmiStore, null), children)))));
+function useXSignMessage() {
+  const { signMessage } = walletAdapterReact.useWallet();
+  const { signMessageAsync: evmSignMessage } = wagmi.useSignMessage();
+  const { mutateAsync: signPersonalMessage } = dappKit.useSignPersonalMessage();
+  const { address: injectiveAddress } = useXAccount("INJECTIVE");
+  return reactQuery.useMutation({
+    mutationFn: async ({ xChainType, message }) => {
+      let signature;
+      switch (xChainType) {
+        case "EVM": {
+          signature = await evmSignMessage({ message });
+          break;
+        }
+        case "SUI": {
+          const res = await signPersonalMessage({ message: new Uint8Array(new TextEncoder().encode(message)) });
+          signature = res.signature;
+          break;
+        }
+        case "SOLANA": {
+          if (!signMessage) {
+            throw new Error("Solana wallet not connected");
+          }
+          signature = await signMessage(new TextEncoder().encode(message));
+          break;
+        }
+        case "STELLAR": {
+          const res = await StellarXService.getInstance().walletsKit.signMessage(message);
+          signature = res.signedMessage;
+          break;
+        }
+        case "INJECTIVE": {
+          if (!injectiveAddress) {
+            throw new Error("Injective address not found");
+          }
+          const ethereumAddress = sdkTs.getEthereumAddress(injectiveAddress);
+          const walletStrategy = InjectiveXService.getInstance().walletStrategy;
+          const res = await walletStrategy.signArbitrary(
+            walletStrategy.getWallet() === walletBase.Wallet.Metamask ? ethereumAddress : injectiveAddress,
+            message
+          );
+          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 } = walletAdapterReact.useConnection();
+  const wallet = walletAdapterReact.useWallet();
+  return new anchor.AnchorProvider(connection, wallet, { commitment: "confirmed" });
+}
+var Hydrate = () => {
+  const suiClient = dappKit.useSuiClient();
+  React2.useEffect(() => {
+    if (suiClient) {
+      SuiXService.getInstance().suiClient = suiClient;
+    }
+  }, [suiClient]);
+  const { currentWallet: suiWallet } = dappKit.useCurrentWallet();
+  React2.useEffect(() => {
+    if (suiWallet) {
+      SuiXService.getInstance().suiWallet = suiWallet;
+    }
+  }, [suiWallet]);
+  const suiAccount = dappKit.useCurrentAccount();
+  React2.useEffect(() => {
+    if (suiAccount) {
+      SuiXService.getInstance().suiAccount = suiAccount;
+    }
+  }, [suiAccount]);
+  const { connection: solanaConnection } = walletAdapterReact.useConnection();
+  const solanaWallet = walletAdapterReact.useWallet();
+  const solanaProvider = useAnchorProvider();
+  React2.useEffect(() => {
+    if (solanaConnection) {
+      SolanaXService.getInstance().connection = solanaConnection;
+    }
+  }, [solanaConnection]);
+  React2.useEffect(() => {
+    if (solanaWallet) {
+      SolanaXService.getInstance().wallet = solanaWallet;
+    }
+  }, [solanaWallet]);
+  React2.useEffect(() => {
+    if (solanaProvider) {
+      SolanaXService.getInstance().provider = solanaProvider;
+    }
+  }, [solanaProvider]);
+  const wagmiConfig = wagmi.useConfig();
+  React2.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 = React2.useMemo(() => {
+    return createWagmiConfig(rpcConfig);
+  }, [rpcConfig]);
+  const wallets = React2.useMemo(() => [new walletAdapterWallets.UnsafeBurnerWalletAdapter()], []);
+  return /* @__PURE__ */ React2__default.default.createElement(wagmi.WagmiProvider, { config: wagmiConfig, reconnectOnMount: true }, /* @__PURE__ */ React2__default.default.createElement(dappKit.SuiClientProvider, { networks: { mainnet: { url: client.getFullnodeUrl("mainnet") } }, defaultNetwork: "mainnet" }, /* @__PURE__ */ React2__default.default.createElement(dappKit.WalletProvider, { autoConnect: true }, /* @__PURE__ */ React2__default.default.createElement(walletAdapterReact.ConnectionProvider, { endpoint: rpcConfig["solana"] ?? "" }, /* @__PURE__ */ React2__default.default.createElement(walletAdapterReact.WalletProvider, { wallets, autoConnect: true }, /* @__PURE__ */ React2__default.default.createElement(Hydrate, null), children)))));
 };
+reconnectIcon();
+reconnectStellar();
 
 // src/types/index.ts
 var WalletId = /* @__PURE__ */ ((WalletId2) => {
@@ -1530,7 +1407,6 @@ exports.EvmXConnector = EvmXConnector;
 exports.EvmXService = EvmXService;
 exports.IconHanaXConnector = IconHanaXConnector;
 exports.IconXService = IconXService;
-exports.InitXWagmiStore = InitXWagmiStore;
 exports.InjectiveKelprXConnector = InjectiveKelprXConnector;
 exports.InjectiveMetamaskXConnector = InjectiveMetamaskXConnector;
 exports.InjectiveXService = InjectiveXService;
@@ -1544,30 +1420,13 @@ exports.SuiXService = SuiXService;
 exports.WalletId = WalletId;
 exports.XConnector = XConnector;
 exports.XService = XService;
-exports.arbitrum = arbitrum;
-exports.avalanche = avalanche;
-exports.base = base;
-exports.bsc = bsc;
 exports.getWagmiChainId = getWagmiChainId;
 exports.getXChainType = getXChainType;
 exports.getXService = getXService;
-exports.hyper = hyper;
-exports.icon = icon;
-exports.initXWagmiStore = initXWagmiStore;
-exports.injective = injective;
 exports.isNativeToken = isNativeToken;
-exports.lightlink = lightlink;
-exports.nibiru = nibiru;
-exports.optimism = optimism;
-exports.polygon = polygon;
-exports.solana = solana;
-exports.sonic = sonic;
-exports.stellar = stellar;
-exports.sui = sui;
 exports.switchEthereumChain = switchEthereumChain;
 exports.useEvmSwitchChain = useEvmSwitchChain;
 exports.useWalletProvider = useWalletProvider;
-exports.useWalletProviderOptions = useWalletProviderOptions;
 exports.useXAccount = useXAccount;
 exports.useXAccounts = useXAccounts;
 exports.useXBalances = useXBalances;
@@ -1576,8 +1435,7 @@ exports.useXConnection = useXConnection;
 exports.useXConnectors = useXConnectors;
 exports.useXDisconnect = useXDisconnect;
 exports.useXService = useXService;
+exports.useXSignMessage = useXSignMessage;
 exports.useXWagmiStore = useXWagmiStore;
-exports.xChainMap = xChainMap;
-exports.xChains = xChains;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map