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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sodax/wallet-sdk-react",
   "license": "MIT",
-  "version": "0.0.1-rc.5",
+  "version": "0.0.1-rc.6",
   "description": "Wallet SDK of Sodax",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -45,8 +45,8 @@
     "viem": "2.29.2",
     "wagmi": "^2.14.12",
     "zustand": "4.5.2",
-    "@sodax/wallet-sdk-core": "0.0.1-rc.6",
-    "@sodax/types": "0.0.1-rc.17"
+    "@sodax/wallet-sdk-core": "0.0.1-rc.7",
+    "@sodax/types": "0.0.1-rc.18"
   },
   "devDependencies": {
     "@types/react": "^19.0.8",

package/src/Hydrate.ts

@@ -0,0 +1,62 @@
+'use client';
+
+import { useCurrentAccount, useCurrentWallet, useSuiClient } from '@mysten/dapp-kit';
+import { useEffect } from 'react';
+import { EvmXService } from './xchains/evm';
+import { SolanaXService } from './xchains/solana/SolanaXService';
+import { SuiXService } from './xchains/sui';
+import { useAnchorProvider } from './xchains/solana/hooks/useAnchorProvider';
+import { useConnection, useWallet } from '@solana/wallet-adapter-react';
+import { useConfig } from 'wagmi';
+
+export const Hydrate = () => {
+  // sui
+  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]);
+
+  // solana
+  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]);
+
+  // evm
+  const wagmiConfig = useConfig();
+  useEffect(() => {
+    if (wagmiConfig) {
+      EvmXService.getInstance().wagmiConfig = wagmiConfig;
+    }
+  }, [wagmiConfig]);
+
+  return null;
+};

package/src/SodaxWalletProvider.tsx

@@ -1,8 +1,7 @@
 'use client';
 
 // biome-ignore lint/style/useImportType: <explanation>
-import React from 'react';
-import { useEffect, useMemo } from 'react';
+import React, { useMemo } from 'react';
 
 // sui
 import { SuiClientProvider, WalletProvider as SuiWalletProvider } from '@mysten/dapp-kit';
@@ -17,34 +16,29 @@ import {
   WalletProvider as SolanaWalletProvider,
 } from '@solana/wallet-adapter-react';
 import { UnsafeBurnerWalletAdapter } from '@solana/wallet-adapter-wallets';
-import type { XConfig } from './types';
-import { initXWagmiStore, InitXWagmiStore } from './useXWagmiStore';
 
-import { getWagmiConfig } from './xchains/evm/EvmXService';
+import type { RpcConfig } from '@sodax/types';
 
-export const SodaxWalletProvider = ({ children, config }: { children: React.ReactNode; config: XConfig }) => {
-  useEffect(() => {
-    initXWagmiStore(config);
-  }, [config]);
+import { Hydrate } from './Hydrate';
+import { createWagmiConfig } from './xchains/evm/EvmXService';
+import { reconnectIcon } from './xchains/icon/actions';
+// import { reconnectInjective } from './xchains/injective/actions';
+import { reconnectStellar } from './xchains/stellar/actions';
 
-  const {
-    EVM: { chains },
-    SOLANA: { endpoint },
-  } = config;
+export const SodaxWalletProvider = ({ children, rpcConfig }: { children: React.ReactNode; rpcConfig: RpcConfig }) => {
+  const wagmiConfig = useMemo(() => {
+    return createWagmiConfig(rpcConfig);
+  }, [rpcConfig]);
 
   const wallets = useMemo(() => [new UnsafeBurnerWalletAdapter()], []);
 
-  const wagmiConfig = useMemo(() => {
-    return getWagmiConfig(chains);
-  }, [chains]);
-
   return (
-    <WagmiProvider config={wagmiConfig}>
+    <WagmiProvider config={wagmiConfig} reconnectOnMount={true}>
       <SuiClientProvider networks={{ mainnet: { url: getFullnodeUrl('mainnet') } }} defaultNetwork="mainnet">
         <SuiWalletProvider autoConnect={true}>
-          <SolanaConnectionProvider endpoint={endpoint}>
+          <SolanaConnectionProvider endpoint={rpcConfig['solana'] ?? ''}>
             <SolanaWalletProvider wallets={wallets} autoConnect>
-              <InitXWagmiStore />
+              <Hydrate />
               {children}
             </SolanaWalletProvider>
           </SolanaConnectionProvider>
@@ -53,3 +47,7 @@ export const SodaxWalletProvider = ({ children, config }: { children: React.Reac
     </WagmiProvider>
   );
 };
+
+reconnectIcon();
+// reconnectInjective();
+reconnectStellar();

package/src/actions/getXChainType.ts

@@ -1,10 +1,8 @@
-import type { ChainId, ChainType } from '@sodax/types';
-
-import { xChainMap } from '@/constants/xChains';
+import { baseChainInfo, type ChainId, type ChainType } from '@sodax/types';
 
 export function getXChainType(xChainId: ChainId | undefined): ChainType | undefined {
   if (!xChainId) {
     return undefined;
   }
-  return xChainMap[xChainId].xChainType;
+  return baseChainInfo[xChainId].type;
 }

package/src/core/XService.ts

@@ -1,4 +1,4 @@
-import type { ChainId, ChainType, XToken } from '@sodax/types';
+import type { ChainType, XToken } from '@sodax/types';
 import type { XConnector } from './XConnector';
 
 /**
@@ -33,10 +33,9 @@ export abstract class XService {
    * 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
    */
-  public async getBalance(address: string | undefined, xToken: XToken, xChainId: ChainId): Promise<bigint> {
+  public async getBalance(address: string | undefined, xToken: XToken): Promise<bigint> {
     return 0n;
   }
 
@@ -44,18 +43,13 @@ export abstract class XService {
    * 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
    */
-  public async getBalances(
-    address: string | undefined,
-    xTokens: XToken[],
-    xChainId: ChainId,
-  ): Promise<Record<string, bigint>> {
+  public async getBalances(address: string | undefined, xTokens: XToken[]): Promise<Record<string, bigint>> {
     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 };
     });
 

package/src/hooks/index.ts

@@ -6,6 +6,6 @@ export { useXConnectors } from './useXConnectors';
 export { useXDisconnect } from './useXDisconnect';
 export { useXService } from './useXService';
 export { useXBalances } from './useXBalances';
-export { useWalletProviderOptions } from './useWalletProviderOptions';
 export { useEvmSwitchChain } from './useEvmSwitchChain';
 export { useWalletProvider } from './useWalletProvider';
+export { useXSignMessage } from './useXSignMessage';

package/src/hooks/useEvmSwitchChain.ts

@@ -1,7 +1,6 @@
-import { xChainMap } from '@/constants/xChains';
 import { useCallback, useMemo } from 'react';
 import { useAccount, useSwitchChain } from 'wagmi';
-import type { ChainId } from '@sodax/types';
+import { baseChainInfo, type ChainId } from '@sodax/types';
 import { getXChainType } from '@/actions';
 import type { InjectiveXService } from '@/xchains/injective';
 import { useXService } from '@/hooks/useXService';
@@ -56,7 +55,7 @@ export const switchEthereumChain = async () => {
 
 export const useEvmSwitchChain = (expectedXChainId: ChainId): UseEvmSwitchChainReturn => {
   const xChainType = getXChainType(expectedXChainId);
-  const expectedChainId = xChainMap[expectedXChainId].id as number;
+  const expectedChainId = baseChainInfo[expectedXChainId].chainId as number;
 
   const injectiveXService = useXService('INJECTIVE') as unknown as InjectiveXService;
   const ethereumChainId = useEthereumChainId();

package/src/hooks/useWalletProvider.ts

@@ -1,4 +1,12 @@
-import type { ChainId } from '@sodax/types';
+import type {
+  ChainId,
+  IEvmWalletProvider,
+  IIconWalletProvider,
+  IInjectiveWalletProvider,
+  ISolanaWalletProvider,
+  IStellarWalletProvider,
+  ISuiWalletProvider,
+} from '@sodax/types';
 import { useMemo } from 'react';
 import {
   EvmWalletProvider,
@@ -9,9 +17,7 @@ import {
   SolanaWalletProvider,
 } from '@sodax/wallet-sdk-core';
 import { getXChainType } from '../actions';
-import type { InjectiveEoaAddress } from '@sodax/types';
 import { usePublicClient, useWalletClient } from 'wagmi';
-import { getWagmiChainId } from '../utils';
 import { type SolanaXService, type StellarXService, useXAccount, useXService } from '..';
 import type { SuiXService } from '../xchains/sui/SuiXService';
 import { CHAIN_INFO, SupportedChainId } from '../xchains/icon/IconXService';
@@ -37,22 +43,18 @@ import type { InjectiveXService } from '../xchains/injective/InjectiveXService';
 export function useWalletProvider(
   spokeChainId: ChainId | undefined,
 ):
-  | EvmWalletProvider
-  | SuiWalletProvider
-  | IconWalletProvider
-  | InjectiveWalletProvider
-  | StellarWalletProvider
-  | SolanaWalletProvider
+  | IEvmWalletProvider
+  | ISuiWalletProvider
+  | IIconWalletProvider
+  | IInjectiveWalletProvider
+  | IStellarWalletProvider
+  | ISolanaWalletProvider
   | undefined {
   const xChainType = getXChainType(spokeChainId);
-
   // EVM-specific hooks
-  const evmPublicClient = usePublicClient({
-    chainId: spokeChainId ? getWagmiChainId(spokeChainId) : undefined,
-  });
-  const { data: evmWalletClient } = useWalletClient({
-    chainId: spokeChainId ? getWagmiChainId(spokeChainId) : undefined,
-  });
+  const evmPublicClient = usePublicClient();
+
+  const { data: evmWalletClient } = useWalletClient();
 
   // Cross-chain hooks
   const xService = useXService(getXChainType(spokeChainId));
@@ -111,6 +113,9 @@ export function useWalletProvider(
 
       case 'STELLAR': {
         const stellarXService = xService as StellarXService;
+        if (!stellarXService.walletsKit) {
+          return undefined;
+        }
 
         return new StellarWalletProvider({
           type: 'BROWSER_EXTENSION',
@@ -123,11 +128,11 @@ export function useWalletProvider(
         const solanaXService = xService as SolanaXService;
 
         if (!solanaXService.wallet) {
-          throw new Error('Wallet is not initialized');
+          return undefined;
         }
 
         if (!solanaXService.connection) {
-          throw new Error('Connection is not initialized');
+          return undefined;
         }
 
         return new SolanaWalletProvider({

package/src/hooks/useXBalances.ts

@@ -55,7 +55,7 @@ export function useXBalances({
         return {};
       }
 
-      const balances = await xService.getBalances(address, xTokens, xChainId);
+      const balances = await xService.getBalances(address, xTokens);
 
       return balances;
     },

package/src/hooks/useXConnect.ts

@@ -41,8 +41,7 @@ export function useXConnect(): UseMutationResult<XAccount | undefined, Error, XC
   const { connectAsync: evmConnectAsync } = useConnect();
   const { mutateAsync: suiConnectAsync } = useConnectWallet();
 
-  // const solanaWallet = useWallet();
-  const { select, connect, connected } = useWallet();
+  const { select, connect } = useWallet();
 
   return useMutation({
     mutationFn: async (xConnector: XConnector) => {

package/src/hooks/useXSignMessage.ts

@@ -0,0 +1,82 @@
+import { useWallet } from '@solana/wallet-adapter-react';
+import { useMutation, type UseMutationResult } from '@tanstack/react-query';
+import type { ChainType } from '@sodax/types';
+import { useSignMessage } from 'wagmi';
+import { useSignPersonalMessage } from '@mysten/dapp-kit';
+import { StellarXService } from '@/xchains/stellar';
+import { InjectiveXService } from '@/xchains/injective';
+import { useXAccount } from './useXAccount';
+import { getEthereumAddress } from '@injectivelabs/sdk-ts';
+import { Wallet } from '@injectivelabs/wallet-base';
+
+type SignMessageReturnType = `0x${string}` | Uint8Array | string | undefined;
+
+export function useXSignMessage(): UseMutationResult<
+  SignMessageReturnType,
+  Error,
+  { xChainType: ChainType; message: string },
+  unknown
+> {
+  const { signMessage } = useWallet();
+  const { signMessageAsync: evmSignMessage } = useSignMessage();
+
+  const { mutateAsync: signPersonalMessage } = useSignPersonalMessage();
+
+  const { address: injectiveAddress } = useXAccount('INJECTIVE');
+
+  return useMutation({
+    mutationFn: async ({ xChainType, message }: { xChainType: ChainType; message: string }) => {
+      let signature: SignMessageReturnType;
+
+      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;
+    },
+  });
+}

package/src/index.ts

@@ -1,5 +1,4 @@
 export * from './actions';
-export * from './constants';
 export * from './core';
 
 export * from './utils';

package/src/types/index.ts

@@ -1,5 +1,4 @@
 import type { ChainType } from '@sodax/types';
-import type { EvmChainId } from '@/xchains/evm/EvmXService';
 
 export type XAccount = {
   address: string | undefined;
@@ -20,25 +19,3 @@ export enum WalletId {
   SUI = 'sui',
   KEPLR = 'keplr',
 }
-
-export type EVMConfig = {
-  chains: EvmChainId[];
-};
-
-export type SuiConfig = {
-  isMainnet: boolean;
-};
-
-export type SolanaConfig = {
-  endpoint: string;
-};
-
-export type XConfig = {
-  [key in ChainType]: key extends 'EVM'
-    ? EVMConfig
-    : key extends 'SUI'
-      ? SuiConfig
-      : key extends 'SOLANA'
-        ? SolanaConfig
-        : unknown;
-};

package/src/useXWagmiStore.ts

@@ -0,0 +1,91 @@
+'use client';
+
+import type { ChainType } from '@sodax/types';
+import { create } from 'zustand';
+import { createJSONStorage, persist, devtools } from 'zustand/middleware';
+import { immer } from 'zustand/middleware/immer';
+import type { XService } from './core';
+import type { XConnection } from './types';
+import { EvmXService } from './xchains/evm';
+import { InjectiveKelprXConnector, InjectiveMetamaskXConnector, InjectiveXService } from './xchains/injective';
+import { SolanaXService } from './xchains/solana/SolanaXService';
+import { StellarXService } from './xchains/stellar';
+import { SuiXService } from './xchains/sui';
+import { IconXService } from './xchains/icon';
+import { IconHanaXConnector } from './xchains/icon/IconHanaXConnector';
+
+type XWagmiStore = {
+  xServices: Partial<Record<ChainType, XService>>;
+  xConnections: Partial<Record<ChainType, XConnection>>;
+
+  setXConnection: (xChainType: ChainType, xConnection: XConnection) => void;
+  unsetXConnection: (xChainType: ChainType) => void;
+};
+
+const initXServices = () => {
+  const xServices = {};
+  ['EVM', 'INJECTIVE', 'STELLAR', 'SUI', 'SOLANA', 'ICON'].forEach(key => {
+    const xChainType = key as ChainType;
+
+    switch (xChainType) {
+      // EVM, SUI, Solana wallet connectors are supported by their own sdks. wagmi, @mysten/dapp-kit, @solana/wallet-adapter-react.
+      case 'EVM':
+        xServices[xChainType] = EvmXService.getInstance();
+        xServices[xChainType].setXConnectors([]);
+        break;
+      case 'SUI':
+        xServices[xChainType] = SuiXService.getInstance();
+        xServices[xChainType].setXConnectors([]);
+        break;
+      case 'SOLANA':
+        xServices[xChainType] = SolanaXService.getInstance();
+        xServices[xChainType].setXConnectors([]);
+        break;
+
+      // 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()]);
+        break;
+      default:
+        break;
+    }
+  });
+
+  return xServices;
+};
+
+export const useXWagmiStore = create<XWagmiStore>()(
+  devtools(
+    persist(
+      immer((set, get) => ({
+        xServices: initXServices(),
+        xConnections: {},
+        setXConnection: (xChainType: ChainType, xConnection: XConnection) => {
+          set(state => {
+            state.xConnections[xChainType] = xConnection;
+          });
+        },
+        unsetXConnection: (xChainType: ChainType) => {
+          set(state => {
+            delete state.xConnections[xChainType];
+          });
+        },
+      })),
+      {
+        name: 'xwagmi-store',
+        storage: createJSONStorage(() => localStorage),
+        partialize: state => ({ xConnections: state.xConnections }),
+      },
+    ),
+    { name: 'xwagmi-store' },
+  ),
+);

package/src/utils/index.ts

@@ -1,4 +1,4 @@
-import type { ChainId, XToken } from '@sodax/types';
+import { baseChainInfo, type ChainId, type XToken } from '@sodax/types';
 
 export const isNativeToken = (xToken: XToken) => {
   const nativeAddresses = [
@@ -14,20 +14,6 @@ export const isNativeToken = (xToken: XToken) => {
   return nativeAddresses.includes(xToken.address);
 };
 
-// TODO: remove this? move to dapp-kit?
 export const getWagmiChainId = (xChainId: ChainId): number => {
-  const xChainMap = {
-    '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 xChainMap[xChainId] ?? 0;
+  return baseChainInfo[xChainId].chainId as number;
 };

package/src/xchains/evm/EvmXConnector.ts

@@ -1,6 +1,6 @@
 import { XConnector } from '@/core/XConnector';
 import type { XAccount } from '@/types';
-import type { Config, Connector } from 'wagmi';
+import type { Connector } from 'wagmi';
 
 export class EvmXConnector extends XConnector {
   connector: Connector;