@sodax/wallet-sdk-react 1.3.0-beta → 1.3.1-beta-rc2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sodax/wallet-sdk-react",
   "license": "MIT",
-  "version": "1.3.0-beta",
+  "version": "1.3.1-beta-rc2",
   "description": "Wallet SDK of Sodax",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -23,7 +23,6 @@
     "url": "https://github.com/icon-project/sodax-frontend"
   },
   "dependencies": {
-    "@coral-xyz/anchor": "0.30.1",
     "@creit.tech/stellar-wallets-kit": "^1.7.5",
     "@hot-labs/near-connect": "0.10.0",
     "@injectivelabs/networks": "1.16.10",
@@ -36,7 +35,7 @@
     "@injectivelabs/wallet-strategy": "1.16.10",
     "@mysten/dapp-kit": "0.14.18",
     "@mysten/sui": "1.21.2",
-    "near-api-js": "7.1.1",
+    "near-api-js": "7.2.0",
     "@solana/spl-token": "0.4.9",
     "@solana/wallet-adapter-react": "0.15.35",
     "@solana/wallet-adapter-wallets": "0.19.30",
@@ -44,12 +43,13 @@
     "@stellar/stellar-sdk": "12.3.0",
     "icon-sdk-js": "1.5.3",
     "immer": "10.1.1",
+    "sats-connect": "^4.2.1",
     "viem": "2.29.2",
     "wagmi": "2.16.9",
     "zustand": "4.5.2",
     "bs58": "6.0.0",
-    "@sodax/types": "1.3.0-beta",
-    "@sodax/wallet-sdk-core": "1.3.0-beta"
+    "@sodax/wallet-sdk-core": "1.3.1-beta-rc2",
+    "@sodax/types": "1.3.1-beta-rc2"
   },
   "devDependencies": {
     "@types/react": "^19.0.8",

package/src/Hydrate.ts

@@ -5,7 +5,6 @@ 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';
 
@@ -33,7 +32,6 @@ export const Hydrate = () => {
   // solana
   const { connection: solanaConnection } = useConnection();
   const solanaWallet = useWallet();
-  const solanaProvider = useAnchorProvider();
   useEffect(() => {
     if (solanaConnection) {
       SolanaXService.getInstance().connection = solanaConnection;
@@ -44,11 +42,6 @@ export const Hydrate = () => {
       SolanaXService.getInstance().wallet = solanaWallet;
     }
   }, [solanaWallet]);
-  useEffect(() => {
-    if (solanaProvider) {
-      SolanaXService.getInstance().provider = solanaProvider;
-    }
-  }, [solanaProvider]);
 
   // evm
   const wagmiConfig = useConfig();

package/src/SodaxWalletProvider.tsx

@@ -22,7 +22,6 @@ import type { RpcConfig } from '@sodax/types';
 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';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 
@@ -40,7 +39,7 @@ export const SodaxWalletProvider = ({ children, rpcConfig }: { children: React.R
       <WagmiProvider reconnectOnMount={false} config={wagmiConfig}>
         <SuiClientProvider networks={{ mainnet: { url: getFullnodeUrl('mainnet') } }} defaultNetwork="mainnet">
           <SuiWalletProvider autoConnect={true}>
-            <SolanaConnectionProvider endpoint={rpcConfig['solana'] ?? ''}>
+            <SolanaConnectionProvider endpoint={rpcConfig['solana'] ?? 'https://api.mainnet-beta.solana.com'}>
               <SolanaWalletProvider wallets={wallets} autoConnect>
                 <Hydrate />
                 {children}

package/src/actions/getXService.ts

@@ -1,6 +1,6 @@
 import type { ChainType } from '@sodax/types';
 
-import { IconXService, InjectiveXService, SolanaXService, StellarXService } from '..';
+import { BitcoinXService, IconXService, InjectiveXService, SolanaXService, StellarXService } from '..';
 import { SuiXService } from '..';
 import { EvmXService } from '..';
 import type { XService } from '../core';
@@ -8,6 +8,8 @@ import { NearXService } from '../xchains/near/NearXService';
 
 export function getXService(xChainType: ChainType): XService {
   switch (xChainType) {
+    case 'BITCOIN':
+      return BitcoinXService.getInstance();
     case 'EVM':
       return EvmXService.getInstance();
     case 'SUI':

package/src/hooks/useWalletProvider.ts

@@ -7,8 +7,11 @@ import type {
   ISolanaWalletProvider,
   IStellarWalletProvider,
   ISuiWalletProvider,
+  IBitcoinWalletProvider,
 } from '@sodax/types';
 import { useMemo } from 'react';
+import { BitcoinXService } from '../xchains/bitcoin/BitcoinXService';
+import type { BitcoinXConnector } from '../xchains/bitcoin/BitcoinXConnector';
 import {
   EvmWalletProvider,
   IconWalletProvider,
@@ -20,7 +23,7 @@ import {
 } from '@sodax/wallet-sdk-core';
 import { getXChainType } from '../actions';
 import { usePublicClient, useWalletClient } from 'wagmi';
-import { type SolanaXService, type StellarXService, useXAccount, useXService } from '..';
+import { type SolanaXService, type StellarXService, useXAccount, useXService, useXConnection } from '..';
 import type { SuiXService } from '../xchains/sui/SuiXService';
 import { CHAIN_INFO, SupportedChainId } from '../xchains/icon/IconXService';
 import type { InjectiveXService } from '../xchains/injective/InjectiveXService';
@@ -52,6 +55,7 @@ export function useWalletProvider(
   | IInjectiveWalletProvider
   | IStellarWalletProvider
   | ISolanaWalletProvider
+  | IBitcoinWalletProvider
   | INearWalletProvider
   | undefined {
   const xChainType = getXChainType(spokeChainId);
@@ -63,6 +67,7 @@ export function useWalletProvider(
   // Cross-chain hooks
   const xService = useXService(getXChainType(spokeChainId));
   const xAccount = useXAccount(spokeChainId);
+  const xConnection = useXConnection(xChainType);
 
   return useMemo(() => {
     switch (xChainType) {
@@ -141,10 +146,17 @@ export function useWalletProvider(
 
         return new SolanaWalletProvider({
           wallet: solanaXService.wallet,
-          connection: solanaXService.connection,
+          endpoint: solanaXService.connection.rpcEndpoint,
         });
       }
 
+      case 'BITCOIN': {
+        if (!xConnection?.xConnectorId) return undefined;
+        const connector = BitcoinXService.getInstance().getXConnectorById(xConnection.xConnectorId) as BitcoinXConnector | undefined;
+        if (!connector) return undefined;
+        // Recreate from window extension object — works after page reload without reconnect
+        return connector.recreateWalletProvider(xConnection.xAccount);
+      }
       case 'NEAR': {
         const nearXService = xService as NearXService;
         if (!nearXService.walletSelector) {
@@ -157,5 +169,5 @@ export function useWalletProvider(
       default:
         return undefined;
     }
-  }, [xChainType, evmPublicClient, evmWalletClient, xService, xAccount]);
+  }, [xChainType, evmPublicClient, evmWalletClient, xService, xAccount, xConnection]);
 }

package/src/hooks/useXBalances.ts

@@ -1,5 +1,5 @@
 import { getXChainType } from '@/actions';
-import { type UseQueryResult, keepPreviousData, useQuery } from '@tanstack/react-query';
+import { type UseQueryResult, useQuery } from '@tanstack/react-query';
 import type { ChainId, XToken } from '@sodax/types';
 import { useXService } from './useXService';
 
@@ -59,8 +59,7 @@ export function useXBalances({
 
       return balances;
     },
-    enabled: !!xService,
-    placeholderData: keepPreviousData,
+    enabled: !!xService && !!address && (xTokens?.length ?? 0) > 0,
     refetchInterval: 5_000,
   });
 }

package/src/index.ts

@@ -3,6 +3,7 @@ export * from './core';
 
 export * from './utils';
 
+export * from './xchains/bitcoin';
 export * from './xchains/evm';
 export * from './xchains/icon';
 export * from './xchains/injective';

package/src/types/index.ts

@@ -3,6 +3,7 @@ import type { ChainType } from '@sodax/types';
 export type XAccount = {
   address: string | undefined;
   xChainType: ChainType | undefined;
+  publicKey?: string;
 };
 
 export type XConnection = {

package/src/useXWagmiStore.ts

@@ -13,6 +13,10 @@ 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';
 
 type XWagmiStore = {
@@ -25,7 +29,7 @@ type XWagmiStore = {
 
 const initXServices = () => {
   const xServices = {};
-  ['EVM', 'INJECTIVE', 'STELLAR', 'SUI', 'SOLANA', 'ICON', 'NEAR'].forEach(key => {
+  ['EVM', 'BITCOIN', 'INJECTIVE', 'STELLAR', 'SUI', 'SOLANA', 'ICON', 'NEAR'].forEach(key => {
     const xChainType = key as ChainType;
 
     switch (xChainType) {
@@ -42,6 +46,14 @@ const initXServices = () => {
         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':

package/src/utils/index.ts

@@ -8,7 +8,8 @@ export const isNativeToken = (xToken: XToken) => {
     '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI',
     'hx0000000000000000000000000000000000000000',
     '11111111111111111111111111111111', // solana
-    'CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA', // stellar,
+    'CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA', // stellar
+    '0:0', // bitcoin
   ];
 
   return nativeAddresses.includes(xToken.address);

package/src/xchains/bitcoin/BitcoinXConnector.ts

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,117 @@
+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);
+  }
+}

package/src/xchains/bitcoin/UnisatXConnector.ts

@@ -0,0 +1,117 @@
+import type { XAccount } from '@/types';
+import { detectBitcoinAddressType, type IBitcoinWalletProvider, type AddressType } from '@sodax/types';
+import { BitcoinXConnector } from './BitcoinXConnector';
+
+// Minimal Unisat window API types
+interface UnisatWallet {
+  getAccounts(): Promise<string[]>;
+  getPublicKey(): Promise<string>;
+  signPsbt(psbtHex: string, options?: { autoFinalized?: boolean }): Promise<string>;
+  signMessage(message: string, type?: 'bip322-simple' | 'ecdsa'): Promise<string>;
+  requestAccounts(): Promise<string[]>;
+  sendBitcoin(address: string, satoshis: number): Promise<string>;
+}
+
+declare global {
+  interface Window {
+    unisat?: UnisatWallet;
+  }
+}
+
+class UnisatWalletProvider implements IBitcoinWalletProvider {
+  private unisat: UnisatWallet;
+  private cachedAddress: string;
+
+  constructor(unisat: UnisatWallet, address: string) {
+    this.unisat = unisat;
+    this.cachedAddress = address;
+  }
+
+  async getWalletAddress(): Promise<string> {
+    try {
+      const accounts = await this.unisat.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.unisat.getPublicKey();
+  }
+
+  async getAddressType(_address: string): Promise<AddressType> {
+    const address = await this.getWalletAddress();
+    return detectBitcoinAddressType(address);
+  }
+
+  async signTransaction(psbtBase64: string, finalize = false): Promise<string> {
+    // Convert base64 → hex for Unisat, then back
+    const psbtHex = Buffer.from(psbtBase64, 'base64').toString('hex');
+    const signedHex = await this.unisat.signPsbt(psbtHex, { autoFinalized: finalize });
+    // Return as hex (BTCWalletProvider.signTransaction expects this)
+    return signedHex;
+  }
+
+  async signEcdsaMessage(message: string): Promise<string> {
+    return this.unisat.signMessage(message, 'ecdsa');
+  }
+
+  async signBip322Message(message: string): Promise<string> {
+    return this.unisat.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.unisat.sendBitcoin(toAddress, Number(satoshis));
+  }
+}
+
+export class UnisatXConnector extends BitcoinXConnector {
+  private walletProvider: UnisatWalletProvider | undefined;
+
+  constructor() {
+    super('Unisat', 'unisat');
+  }
+
+  public static isAvailable(): boolean {
+    return typeof window !== 'undefined' && !!window.unisat;
+  }
+
+  public get icon(): string {
+    return 'https://avatars.githubusercontent.com/u/125119198?s=200&v=4';
+  }
+
+  async connect(): Promise<XAccount | undefined> {
+    if (!window.unisat) {
+      throw new Error('Unisat wallet is not installed');
+    }
+
+    const accounts = await window.unisat.requestAccounts();
+    const address = accounts[0];
+    if (!address) return undefined;
+
+    this.walletProvider = new UnisatWalletProvider(window.unisat, address);
+
+    return {
+      address,
+      xChainType: 'BITCOIN',
+    };
+  }
+
+  async disconnect(): Promise<void> {
+    this.walletProvider = undefined;
+  }
+
+  getWalletProvider(): IBitcoinWalletProvider | undefined {
+    return this.walletProvider;
+  }
+
+  recreateWalletProvider(xAccount: XAccount): IBitcoinWalletProvider | undefined {
+    if (!window.unisat || !xAccount.address) return undefined;
+    return new UnisatWalletProvider(window.unisat, xAccount.address);
+  }
+}