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

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;
-  }
-}

package/src/xchains/bitcoin/OKXXConnector.ts

@@ -1,117 +0,0 @@
-import type { XAccount } from '@/types';
-import { detectBitcoinAddressType, type IBitcoinWalletProvider, type AddressType } from '@sodax/types';
-import { BitcoinXConnector } from './BitcoinXConnector';
-
-// OKX Bitcoin wallet window API types
-interface OKXBitcoinWallet {
-  getAccounts(): Promise<string[]>;
-  getPublicKey(): Promise<string>;
-  signPsbt(psbtHex: string, options?: { autoFinalized?: boolean }): Promise<string>;
-  signMessage(message: string, type?: 'bip322-simple' | 'ecdsa'): Promise<string>;
-  connect(): Promise<{ address: string; publicKey: string }>;
-  sendBitcoin(toAddress: string, satoshis: number): Promise<string>;
-}
-
-declare global {
-  interface Window {
-    okxwallet?: {
-      bitcoin?: OKXBitcoinWallet;
-    };
-  }
-}
-
-class OKXWalletProvider implements IBitcoinWalletProvider {
-  private okx: OKXBitcoinWallet;
-  private cachedAddress: string;
-
-  constructor(okx: OKXBitcoinWallet, address: string) {
-    this.okx = okx;
-    this.cachedAddress = address;
-  }
-
-  async getWalletAddress(): Promise<string> {
-    try {
-      const accounts = await this.okx.getAccounts();
-      if (accounts[0]) this.cachedAddress = accounts[0];
-    } catch {
-      // wallet locked — fall through to cached address
-    }
-    return this.cachedAddress;
-  }
-
-  async getPublicKey(): Promise<string> {
-    return this.okx.getPublicKey();
-  }
-
-  async getAddressType(_address: string): Promise<AddressType> {
-    const address = await this.getWalletAddress();
-    return detectBitcoinAddressType(address);
-  }
-
-  async signTransaction(psbtBase64: string, finalize = false): Promise<string> {
-    const psbtHex = Buffer.from(psbtBase64, 'base64').toString('hex');
-    return this.okx.signPsbt(psbtHex, { autoFinalized: finalize });
-  }
-
-  async signEcdsaMessage(message: string): Promise<string> {
-    return this.okx.signMessage(message, 'ecdsa');
-  }
-
-  async signBip322Message(message: string): Promise<string> {
-    return this.okx.signMessage(message, 'bip322-simple');
-  }
-
-  async sendBitcoin(toAddress: string, satoshis: bigint): Promise<string> {
-    if (satoshis > BigInt(Number.MAX_SAFE_INTEGER)) {
-      throw new Error(`Amount ${satoshis} satoshis exceeds safe integer range`);
-    }
-    return this.okx.sendBitcoin(toAddress, Number(satoshis));
-  }
-}
-
-export class OKXXConnector extends BitcoinXConnector {
-  private walletProvider: OKXWalletProvider | undefined;
-
-  constructor() {
-    super('OKX Wallet', 'okx-bitcoin');
-  }
-
-  public static isAvailable(): boolean {
-    return typeof window !== 'undefined' && !!window.okxwallet?.bitcoin;
-  }
-
-  public get icon(): string {
-    return 'https://static.okx.com/cdn/assets/imgs/247/58E63FEA47A2B7D7.png';
-  }
-
-  async connect(): Promise<XAccount | undefined> {
-    const okx = window.okxwallet?.bitcoin;
-    if (!okx) {
-      throw new Error('OKX wallet is not installed');
-    }
-
-    const { address } = await okx.connect();
-    if (!address) return undefined;
-
-    this.walletProvider = new OKXWalletProvider(okx, address);
-
-    return {
-      address,
-      xChainType: 'BITCOIN',
-    };
-  }
-
-  async disconnect(): Promise<void> {
-    this.walletProvider = undefined;
-  }
-
-  getWalletProvider(): IBitcoinWalletProvider | undefined {
-    return this.walletProvider;
-  }
-
-  recreateWalletProvider(xAccount: XAccount): IBitcoinWalletProvider | undefined {
-    const okx = window.okxwallet?.bitcoin;
-    if (!okx || !xAccount.address) return undefined;
-    return new OKXWalletProvider(okx, xAccount.address);
-  }
-}