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

package/src/hooks/useXConnect.ts

@@ -1,118 +0,0 @@
-import type { XAccount } from '@/types';
-import { useConnectWallet } from '@mysten/dapp-kit';
-import { useWallet } from '@solana/wallet-adapter-react';
-import { useMutation, type UseMutationResult } from '@tanstack/react-query';
-import { useConnect } from 'wagmi';
-import type { XConnector } from '../core/XConnector';
-import { useXWagmiStore } from '../useXWagmiStore';
-import type { EvmXConnector } from '../xchains/evm';
-import type { SolanaXConnector } from '../xchains/solana';
-import type { SuiXConnector } from '../xchains/sui';
-
-/**
- * Hook for connecting to various blockchain wallets across different chains
- *
- * Handles connection logic for EVM, SUI, Solana and other supported chains.
- * Sets up wallet connections and stores connection state in XWagmiStore.
- *
- * @param {void} - No parameters required
- * @returns {UseMutationResult<XAccount | undefined, Error, XConnector>} Mutation result containing:
- * - mutateAsync: Function to connect a wallet
- * - isPending: Boolean indicating if connection is in progress
- * - error: Any error that occurred
- * - data: Connected account data if successful
- *
- * @example
- * ```ts
- * const { mutateAsync: connect, isPending } = useXConnect();
- *
- * const handleConnect = async (connector: XConnector) => {
- *   try {
- *     await connect(connector);
- *   } catch (err) {
- *     console.error(err);
- *   }
- * };
- * ```
- */
-export function useXConnect(): UseMutationResult<XAccount | undefined, Error, XConnector> {
-  const setXConnection = useXWagmiStore(state => state.setXConnection);
-
-  const { connectAsync: evmConnectAsync } = useConnect();
-  const { mutateAsync: suiConnectAsync } = useConnectWallet();
-
-  const { select, connect } = useWallet();
-
-  return useMutation({
-    mutationFn: async (xConnector: XConnector) => {
-      const xChainType = xConnector.xChainType;
-      let xAccount: XAccount | undefined;
-
-      switch (xChainType) {
-        case 'EVM':
-          await evmConnectAsync({ connector: (xConnector as EvmXConnector).connector });
-          break;
-        case 'SUI':
-          await suiConnectAsync({ wallet: (xConnector as SuiXConnector).wallet });
-          break;
-        case 'SOLANA': {
-          const walletName = (xConnector as SolanaXConnector).wallet.adapter.name;
-
-          select(walletName);
-
-          const adapter = (xConnector as SolanaXConnector).wallet.adapter;
-
-          if (!adapter) throw new Error('No adapter found for Solana wallet');
-
-          if (walletName === 'MetaMask') {
-            await new Promise<void>((resolve, reject) => {
-              const timeout = setTimeout(() => {
-                cleanup();
-                reject(new Error('Wallet connection timeout'));
-              }, 30000);
-
-              const handleConnect = () => {
-                cleanup();
-                resolve();
-              };
-
-              const handleError = (error: 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;
-    },
-  });
-}

package/src/hooks/useXConnection.ts

@@ -1,72 +0,0 @@
-import type { ChainType } from '@sodax/types';
-import { useCurrentAccount, useCurrentWallet } from '@mysten/dapp-kit';
-import { useWallet } from '@solana/wallet-adapter-react';
-import { useMemo } from 'react';
-import { useAccount, useConnections } from 'wagmi';
-import type { XConnection } from '../types';
-import { useXWagmiStore } from '../useXWagmiStore';
-
-/**
- * Hook for accessing connection details for a specific blockchain
- *
- * Retrieves the current connection state for the specified chain type,
- * including the connected account and connector ID.
- *
- * @param {ChainType} xChainType - The type of blockchain to get connection details for
- * @returns {XConnection | undefined} Connection details including account and connector ID, or undefined if not connected
- *
- * @example
- * ```ts
- * const connection = useXConnection('EVM');
- *
- * if (connection) {
- *   console.log('Connected account:', connection.xAccount.address);
- *   console.log('Using connector:', connection.xConnectorId);
- * }
- * ```
- */
-export function useXConnection(xChainType: ChainType | undefined): XConnection | undefined {
-  const xConnection = useXWagmiStore(state => (xChainType ? state.xConnections?.[xChainType] : undefined));
-
-  const evmConnections = useConnections();
-  const { address: evmAddress } = useAccount();
-  const suiAccount = useCurrentAccount();
-  const suiCurrentWallet = useCurrentWallet();
-  const solanaWallet = useWallet();
-
-  const xConnection2 = useMemo(() => {
-    if (!xChainType) {
-      return undefined;
-    }
-
-    switch (xChainType) {
-      case 'EVM':
-        return {
-          xAccount: { address: evmAddress as string, 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 undefined;
-
-      case 'SOLANA':
-        if (solanaWallet.connected) {
-          return {
-            xAccount: { address: solanaWallet.publicKey?.toString(), xChainType },
-            xConnectorId: `${solanaWallet.wallet?.adapter.name}`,
-          };
-        }
-        return undefined;
-      default:
-        return xConnection;
-    }
-  }, [xChainType, xConnection, evmAddress, suiAccount, evmConnections, suiCurrentWallet, solanaWallet]);
-
-  return xConnection2;
-}

package/src/hooks/useXConnectors.ts

@@ -1,72 +0,0 @@
-import type { ChainType } from '@sodax/types';
-import { useWallets } from '@mysten/dapp-kit';
-import { useWallet } from '@solana/wallet-adapter-react';
-import { useMemo } from 'react';
-import { useConnectors } from 'wagmi';
-import type { XConnector } from '../core';
-import { EvmXConnector } from '../xchains/evm';
-import { SolanaXConnector } from '../xchains/solana';
-import { useStellarXConnectors } from '../xchains/stellar/useStellarXConnectors';
-import { SuiXConnector } from '../xchains/sui';
-import { useXService } from './useXService';
-import { useNearXConnectors } from '../xchains/near/useNearXConnectors';
-import { useStacksXConnectors } from '../xchains/stacks/useStacksXConnectors';
-
-/**
- * Hook to retrieve available wallet connectors for a specific blockchain type.
- *
- * This hook aggregates wallet connectors from different blockchain ecosystems:
- * - EVM: Uses wagmi connectors
- * - Sui: Uses Sui wallet adapters
- * - Stellar: Uses custom Stellar connectors
- * - Solana: Uses Solana wallet adapters (filtered to installed wallets only)
- *
- * @param xChainType - The blockchain type to get connectors for ('EVM' | 'SUI' | 'STELLAR' | 'SOLANA' | 'NEAR' | 'STACKS')
- * @returns An array of XConnector instances compatible with the specified chain type
- */
-
-export function useXConnectors(xChainType: ChainType | undefined): XConnector[] {
-  const xService = useXService(xChainType);
-  const evmConnectors = useConnectors();
-  const suiWallets = useWallets();
-  const { data: stellarXConnectors } = useStellarXConnectors();
-  const { data: nearXConnectors } = useNearXConnectors();
-  const stacksXConnectors = useStacksXConnectors();
-  const { wallets: solanaWallets } = useWallet();
-
-  const xConnectors = useMemo((): XConnector[] => {
-    if (!xChainType || !xService) {
-      return [];
-    }
-
-    switch (xChainType) {
-      case 'EVM':
-        return evmConnectors.map(connector => new EvmXConnector(connector));
-      case 'SUI':
-        return suiWallets.map(wallet => new SuiXConnector(wallet));
-      case 'STELLAR':
-        return stellarXConnectors || [];
-      case 'SOLANA':
-        return solanaWallets
-          .filter(wallet => wallet.readyState === 'Installed')
-          .map(wallet => new SolanaXConnector(wallet));
-      case 'NEAR':
-        return nearXConnectors || [];
-      case 'STACKS':
-        return stacksXConnectors;
-      default:
-        return xService.getXConnectors();
-    }
-  }, [
-    xService,
-    xChainType,
-    evmConnectors,
-    suiWallets,
-    stellarXConnectors,
-    solanaWallets,
-    nearXConnectors,
-    stacksXConnectors,
-  ]);
-
-  return xConnectors;
-}

package/src/hooks/useXDisconnect.ts

@@ -1,73 +0,0 @@
-import type { ChainType } from '@sodax/types';
-import { useDisconnectWallet } from '@mysten/dapp-kit';
-import { useWallet } from '@solana/wallet-adapter-react';
-import { useCallback } from 'react';
-import { useDisconnect } from 'wagmi';
-import { getXService } from '../actions';
-import { useXWagmiStore } from '../useXWagmiStore';
-import type { NearXService } from '@/xchains/near/NearXService';
-
-/**
- * Hook for disconnecting from a specific blockchain wallet
- *
- * Handles disconnection logic for EVM, SUI, Solana and other supported chains.
- * Clears connection state from XWagmiStore.
- *
- * @param {void} - No parameters required
- * @returns {(xChainType: ChainType) => Promise<void>} Async function that disconnects from the specified chain
- *
- * @example
- * ```ts
- * const disconnect = useXDisconnect();
- *
- * const handleDisconnect = async (xChainType: ChainType) => {
- *   await disconnect(xChainType);
- * };
- * ```
- */
-export function useXDisconnect(): (xChainType: ChainType) => Promise<void> {
-  // Get connection state and disconnect handler from store
-  const xConnections = useXWagmiStore(state => state.xConnections);
-  const unsetXConnection = useXWagmiStore(state => state.unsetXConnection);
-
-  // Get chain-specific disconnect handlers
-  const { disconnectAsync } = useDisconnect();
-  const { mutateAsync: suiDisconnectAsync } = useDisconnectWallet();
-  const solanaWallet = useWallet();
-
-  return useCallback(
-    async (xChainType: ChainType) => {
-      // Handle disconnection based on chain type
-      switch (xChainType) {
-        case 'EVM':
-          await disconnectAsync();
-          break;
-        case 'SUI':
-          await suiDisconnectAsync();
-          break;
-        case 'SOLANA':
-          await solanaWallet.disconnect();
-          break;
-
-        case 'NEAR': {
-          const nearXService = getXService('NEAR') as NearXService;
-          nearXService.walletSelector.disconnect();
-          break;
-        }
-
-        default: {
-          // Handle other chain types
-          const xService = getXService(xChainType);
-          const xConnectorId = xConnections[xChainType]?.xConnectorId;
-          const xConnector = xConnectorId ? xService.getXConnectorById(xConnectorId) : undefined;
-          await xConnector?.disconnect();
-          break;
-        }
-      }
-
-      // Clear connection state from store
-      unsetXConnection(xChainType);
-    },
-    [xConnections, unsetXConnection, disconnectAsync, suiDisconnectAsync, solanaWallet],
-  );
-}

package/src/hooks/useXService.ts

@@ -1,8 +0,0 @@
-import type { ChainType } from '@sodax/types';
-import type { XService } from '../core';
-import { useXWagmiStore } from '../useXWagmiStore';
-
-export function useXService(xChainType: ChainType | undefined): XService | undefined {
-  const xService = useXWagmiStore(state => (xChainType ? state.xServices[xChainType] : undefined));
-  return xService;
-}

package/src/hooks/useXSignMessage.ts

@@ -1,82 +0,0 @@
-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,19 +0,0 @@
-export * from './actions';
-export * from './core';
-
-export * from './utils';
-
-export * from './xchains/bitcoin';
-export * from './xchains/evm';
-export * from './xchains/icon';
-export * from './xchains/injective';
-export * from './xchains/solana';
-export * from './xchains/stellar';
-export * from './xchains/sui';
-export * from './xchains/stacks';
-export * from './hooks';
-export * from './useXWagmiStore';
-export * from './SodaxWalletProvider';
-
-export * from './types';
-export type * from './types';

package/src/types/index.ts

@@ -1,22 +0,0 @@
-import type { ChainType } from '@sodax/types';
-
-export type XAccount = {
-  address: string | undefined;
-  xChainType: ChainType | undefined;
-  publicKey?: string;
-};
-
-export type XConnection = {
-  xAccount: XAccount;
-  xConnectorId: string;
-};
-
-export type CurrencyKey = string;
-
-export enum WalletId {
-  METAMASK = 'metamask',
-  HANA = 'hana',
-  PHANTOM = 'phantom',
-  SUI = 'sui',
-  KEPLR = 'keplr',
-}

package/src/useXWagmiStore.ts

@@ -1,116 +0,0 @@
-'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 { InjectiveXConnector, InjectiveXService } from './xchains/injective';
-import { Wallet } from '@injectivelabs/wallet-base';
-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';
-import { BitcoinXService } from './xchains/bitcoin';
-import { UnisatXConnector } from './xchains/bitcoin/UnisatXConnector';
-import { XverseXConnector } from './xchains/bitcoin/XverseXConnector';
-import { OKXXConnector } from './xchains/bitcoin/OKXXConnector';
-import { NearXService } from './xchains/near/NearXService';
-import { StacksXService, StacksXConnector, STACKS_PROVIDERS } from './xchains/stacks';
-
-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', 'BITCOIN', 'INJECTIVE', 'STELLAR', 'SUI', 'SOLANA', 'ICON', 'NEAR', 'STACKS'].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;
-      case 'BITCOIN':
-        xServices[xChainType] = BitcoinXService.getInstance();
-        xServices[xChainType].setXConnectors([new UnisatXConnector(), new XverseXConnector(), new OKXXConnector()]);
-        break;
-
-      // Injective, Stellar, Icon wallet connectors are supported by sodax wallet-sdk-react sdk.
-      case 'INJECTIVE':
-        xServices[xChainType] = InjectiveXService.getInstance();
-        xServices[xChainType].setXConnectors([
-          // EVM wallets (auto-detected via EIP-6963)
-          new InjectiveXConnector('MetaMask', Wallet.Metamask),
-          // Cosmos wallets (detected via window globals)
-          new InjectiveXConnector('Keplr', Wallet.Keplr),
-          new InjectiveXConnector('Leap', Wallet.Leap),
-        ]);
-        break;
-      case 'STELLAR':
-        xServices[xChainType] = StellarXService.getInstance();
-        xServices[xChainType].setXConnectors([]);
-        break;
-      case 'ICON':
-        xServices[xChainType] = IconXService.getInstance();
-        xServices[xChainType].setXConnectors([new IconHanaXConnector()]);
-        break;
-      case 'NEAR':
-        xServices[xChainType] = NearXService.getInstance();
-        xServices[xChainType].setXConnectors([]);
-        break;
-      case 'STACKS':
-        xServices[xChainType] = StacksXService.getInstance();
-        xServices[xChainType].setXConnectors(STACKS_PROVIDERS.map(config => new StacksXConnector(config)));
-        break;
-      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,21 +0,0 @@
-import { baseChainInfo, type ChainId, type XToken } from '@sodax/types';
-
-export const isNativeToken = (xToken: XToken) => {
-  const nativeAddresses = [
-    'cx0000000000000000000000000000000000000000',
-    '0x0000000000000000000000000000000000000000',
-    'inj',
-    '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI',
-    'hx0000000000000000000000000000000000000000',
-    '11111111111111111111111111111111', // solana
-    'CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA', // stellar
-    'ST000000000000000000002AMW42H.nativetoken', // stacks
-    '0:0', // bitcoin
-  ];
-
-  return nativeAddresses.includes(xToken.address);
-};
-
-export const getWagmiChainId = (xChainId: ChainId): number => {
-  return baseChainInfo[xChainId].chainId as number;
-};

package/src/xchains/bitcoin/BitcoinXConnector.ts

@@ -1,34 +0,0 @@
-import { XConnector } from '@/core';
-import type { XAccount } from '@/types';
-import type { IBitcoinWalletProvider } from '@sodax/types';
-import { BitcoinXService } from './BitcoinXService';
-
-/**
- * Abstract base class for Bitcoin wallet connectors.
- * Subclasses implement wallet-specific connection logic (Unisat, Xverse, OKX).
- */
-export abstract class BitcoinXConnector extends XConnector {
-  constructor(name: string, id: string) {
-    super('BITCOIN', name, id);
-  }
-
-  getXService(): BitcoinXService {
-    return BitcoinXService.getInstance();
-  }
-
-  abstract connect(): Promise<XAccount | undefined>;
-  abstract disconnect(): Promise<void>;
-
-  /**
-   * Returns an IBitcoinWalletProvider instance after connecting.
-   * Used by useSpokeProvider to build BitcoinSpokeProvider.
-   */
-  abstract getWalletProvider(): IBitcoinWalletProvider | undefined;
-
-  /**
-   * Recreates a walletProvider from the browser extension window object
-   * and stored xAccount data (no connect() call, no popup).
-   * Used to restore provider after page reload without requiring reconnect.
-   */
-  abstract recreateWalletProvider(xAccount: XAccount): IBitcoinWalletProvider | undefined;
-}

package/src/xchains/bitcoin/BitcoinXService.ts

@@ -1,40 +0,0 @@
-import { XService } from '@/core/XService';
-import { isNativeToken } from '@/utils';
-import type { XToken } from '@sodax/types';
-
-export class BitcoinXService extends XService {
-  private static instance: BitcoinXService;
-  private rpcUrl: string;
-
-  private constructor(rpcUrl = 'https://mempool.space/api') {
-    super('BITCOIN');
-    this.rpcUrl = rpcUrl;
-  }
-
-  public static getInstance(rpcUrl?: string): BitcoinXService {
-    if (!BitcoinXService.instance) {
-      BitcoinXService.instance = new BitcoinXService(rpcUrl);
-    } else if (rpcUrl && rpcUrl !== BitcoinXService.instance.rpcUrl) {
-      BitcoinXService.instance.rpcUrl = rpcUrl;
-    }
-    return BitcoinXService.instance;
-  }
-
-  async getBalance(address: string | undefined, xToken: XToken): Promise<bigint> {
-    if (!address) return 0n;
-
-    try {
-      if (isNativeToken(xToken)) {
-        const response = await fetch(`${this.rpcUrl}/address/${address}/utxo`);
-        if (!response.ok) return 0n;
-        const utxos: Array<{ value: number }> = await response.json();
-        const totalBalance = utxos.reduce((sum, utxo) => sum + utxo.value, 0);
-        return BigInt(totalBalance);
-      }
-    } catch {
-      return 0n;
-    }
-
-    return 0n;
-  }
-}