@sodax/dapp-kit 1.3.1-beta-rc1 → 1.3.1-beta-rc2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sodax/dapp-kit",
   "license": "MIT",
-  "version": "1.3.1-beta-rc1",
+  "version": "1.3.1-beta-rc2",
   "description": "dapp-kit of New World",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,8 +16,8 @@
   },
   "dependencies": {
     "viem": "2.29.2",
-    "@sodax/sdk": "1.3.1-beta-rc1",
-    "@sodax/types": "1.3.1-beta-rc1"
+    "@sodax/sdk": "1.3.1-beta-rc2",
+    "@sodax/types": "1.3.1-beta-rc2"
   },
   "devDependencies": {
     "@types/react": "19.0.8",

package/src/hooks/bitcoin/index.ts

@@ -0,0 +1,7 @@
+export * from './useRadfiAuth';
+export * from './useRadfiSession';
+export * from './useFundTradingWallet';
+export * from './useBitcoinBalance';
+export * from './useTradingWalletBalance';
+export * from './useExpiredUtxos';
+export * from './useRenewUtxos';

package/src/hooks/bitcoin/radfiConstants.ts

@@ -0,0 +1,2 @@
+export const ACCESS_TOKEN_TTL = 10 * 60 * 1000;           // 10 minutes
+export const REFRESH_TOKEN_TTL = 7 * 24 * 60 * 60 * 1000; // 7 days

package/src/hooks/bitcoin/useBitcoinBalance.ts

@@ -0,0 +1,27 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+
+/**
+ * Hook to fetch BTC balance for any Bitcoin address.
+ * Sums all UTXOs (confirmed + unconfirmed) from mempool.space API.
+ *
+ * The UTXO set already excludes spent outputs (even from unconfirmed txs),
+ * so the total is always the correct spendable balance.
+ */
+export function useBitcoinBalance(
+  address: string | undefined,
+  rpcUrl = 'https://mempool.space/api',
+): UseQueryResult<bigint, Error> {
+  return useQuery<bigint, Error>({
+    queryKey: ['btc-balance', address],
+    queryFn: async () => {
+      if (!address) return 0n;
+
+      const response = await fetch(`${rpcUrl}/address/${address}/utxo`);
+      if (!response.ok) return 0n;
+
+      const utxos: Array<{ value: number }> = await response.json();
+      return BigInt(utxos.reduce((sum, utxo) => sum + utxo.value, 0));
+    },
+    enabled: !!address,
+  });
+}

package/src/hooks/bitcoin/useExpiredUtxos.ts

@@ -0,0 +1,25 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { BitcoinSpokeProvider, RadfiUtxo } from '@sodax/sdk';
+
+/**
+ * Hook to fetch expired UTXOs for a trading wallet address.
+ * UTXOs that are expired or within 2 weeks of expiry are considered invalid for trading
+ * and need to be renewed via the Radfi renew-utxo flow.
+ */
+export function useExpiredUtxos(
+  spokeProvider: BitcoinSpokeProvider | undefined,
+  tradingAddress: string | undefined,
+): UseQueryResult<RadfiUtxo[], Error> {
+  return useQuery<RadfiUtxo[], Error>({
+    queryKey: ['expired-utxos', tradingAddress],
+    queryFn: async () => {
+      if (!spokeProvider || !tradingAddress) {
+        throw new Error('spokeProvider and tradingAddress are required');
+      }
+      const result = await spokeProvider.radfi.getExpiredUtxos(tradingAddress);
+      return result.data;
+    },
+    enabled: !!spokeProvider && !!tradingAddress,
+    refetchInterval: 60_000, // refetch every minute
+  });
+}

package/src/hooks/bitcoin/useFundTradingWallet.ts

@@ -0,0 +1,39 @@
+import { BitcoinSpokeService, type BitcoinSpokeProvider } from '@sodax/sdk';
+import { useMutation, useQueryClient, type UseMutationResult } from '@tanstack/react-query';
+
+/**
+ * Hook to fund the Radfi trading wallet by sending BTC from the user's personal wallet.
+ *
+ * @param {BitcoinSpokeProvider | undefined} spokeProvider - The Bitcoin spoke provider with signing capability
+ * @returns {UseMutationResult} Mutation result — input is amount in satoshis, output is transaction ID
+ *
+ * @example
+ * ```tsx
+ * const { mutateAsync: fundWallet, isPending } = useFundTradingWallet(spokeProvider);
+ *
+ * const handleFund = async () => {
+ *   const txId = await fundWallet(100_000n); // fund 100,000 satoshis
+ *   console.log('Funded:', txId);
+ * };
+ * ```
+ */
+export function useFundTradingWallet(
+  spokeProvider: BitcoinSpokeProvider | undefined,
+): UseMutationResult<string, Error, bigint> {
+  const queryClient = useQueryClient();
+
+  return useMutation<string, Error, bigint>({
+    mutationFn: async (amount: bigint) => {
+      if (!spokeProvider) {
+        throw new Error('Bitcoin spoke provider not found');
+      }
+
+      return BitcoinSpokeService.fundTradingWallet(amount, spokeProvider);
+    },
+    onSuccess: () => {
+      // Invalidate balance queries to reflect the fund transfer
+      queryClient.invalidateQueries({ queryKey: ['btc-balance'] });
+      queryClient.invalidateQueries({ queryKey: ['xBalances'] });
+    },
+  });
+}

package/src/hooks/bitcoin/useRadfiAuth.ts

@@ -0,0 +1,123 @@
+import type { BitcoinSpokeProvider } from '@sodax/sdk';
+import { useMutation, type UseMutationResult } from '@tanstack/react-query';
+import { ACCESS_TOKEN_TTL, REFRESH_TOKEN_TTL } from './radfiConstants';
+
+export type RadfiSession = {
+  accessToken: string;
+  refreshToken: string;
+  tradingAddress: string;
+  publicKey: string;
+  accessTokenExpiry: number;
+  refreshTokenExpiry: number;
+};
+
+type RadfiAuthResult = {
+  accessToken: string;
+  refreshToken: string;
+  tradingAddress: string;
+};
+
+const SESSION_KEY = (address: string) => `radfi_session_${address}`;
+
+export function saveRadfiSession(address: string, session: RadfiSession): void {
+  try {
+    // Radfi tokens are only used for API rate-limiting / anti-spam, not for accessing user assets.
+    localStorage.setItem(SESSION_KEY(address), JSON.stringify(session));
+  } catch {}
+}
+
+export function loadRadfiSession(address: string): RadfiSession | null {
+  try {
+    const raw = localStorage.getItem(SESSION_KEY(address));
+    return raw ? (JSON.parse(raw) as RadfiSession) : null;
+  } catch {
+    return null;
+  }
+}
+
+export function clearRadfiSession(address: string): void {
+  try {
+    localStorage.removeItem(SESSION_KEY(address));
+  } catch {}
+}
+
+export function isAccessTokenExpired(address: string): boolean {
+  const session = loadRadfiSession(address);
+  if (!session) return true;
+  return Date.now() >= session.accessTokenExpiry;
+}
+
+export function isRefreshTokenExpired(address: string): boolean {
+  const session = loadRadfiSession(address);
+  if (!session) return true;
+  return Date.now() >= session.refreshTokenExpiry;
+}
+
+/**
+ * Hook to authenticate with Radfi using BIP322 message signing.
+ * Saves full session (accessToken, refreshToken, tradingAddress, expiry) to localStorage.
+ */
+export function useRadfiAuth(
+  spokeProvider: BitcoinSpokeProvider | undefined,
+): UseMutationResult<RadfiAuthResult, Error, void> {
+  return useMutation<RadfiAuthResult, Error, void>({
+    mutationFn: async () => {
+      if (!spokeProvider) {
+        throw new Error('Bitcoin spoke provider not found');
+      }
+
+      const walletAddress = await spokeProvider.walletProvider.getWalletAddress();
+      const existingSession = loadRadfiSession(walletAddress);
+      const cachedPublicKey = existingSession?.publicKey;
+
+      try {
+        const { accessToken, refreshToken, tradingAddress, publicKey } = await spokeProvider.authenticateWithWallet(cachedPublicKey);
+
+        const session: RadfiSession = {
+          accessToken,
+          refreshToken,
+          tradingAddress,
+          publicKey,
+          accessTokenExpiry: Date.now() + ACCESS_TOKEN_TTL,
+          refreshTokenExpiry: Date.now() + REFRESH_TOKEN_TTL,
+        };
+
+        saveRadfiSession(walletAddress, session);
+
+        return { accessToken, refreshToken, tradingAddress };
+      } catch (err: unknown) {
+        // Error 4008: wallet already registered — authenticate is register+login combined.
+        // Try to refresh with existing session if available.
+        const isAlreadyRegistered =
+          err instanceof Error &&
+          (err.message.includes('duplicatedPubKey') || err.message.includes('4008'));
+
+        if (isAlreadyRegistered) {
+          if (existingSession && !isRefreshTokenExpired(walletAddress)) {
+            // Try silent refresh
+            const refreshed = await spokeProvider.radfi.refreshAccessToken(existingSession.refreshToken);
+            const session: RadfiSession = {
+              ...existingSession,
+              accessToken: refreshed.accessToken,
+              refreshToken: refreshed.refreshToken,
+              accessTokenExpiry: Date.now() + ACCESS_TOKEN_TTL,
+              refreshTokenExpiry: Date.now() + REFRESH_TOKEN_TTL,
+            };
+            spokeProvider.setRadfiAccessToken(refreshed.accessToken);
+            saveRadfiSession(walletAddress, session);
+            return { accessToken: refreshed.accessToken, refreshToken: refreshed.refreshToken, tradingAddress: existingSession.tradingAddress };
+          }
+
+          // No valid session to refresh — guide the user
+          throw new Error(
+            'This wallet is already registered with Radfi from another session. ' +
+            'Please clear your browser storage for this site and try again, ' +
+            'or wait for the previous session to expire.',
+          );
+        }
+
+        throw err;
+      }
+    },
+  });
+}

package/src/hooks/bitcoin/useRadfiSession.ts

@@ -0,0 +1,133 @@
+import { useState, useEffect, useRef, useCallback } from 'react';
+import type { BitcoinSpokeProvider } from '@sodax/sdk';
+import {
+  useRadfiAuth,
+  loadRadfiSession,
+  saveRadfiSession,
+  clearRadfiSession,
+  isAccessTokenExpired,
+  isRefreshTokenExpired,
+  type RadfiSession,
+} from './useRadfiAuth';
+
+import { ACCESS_TOKEN_TTL } from './radfiConstants';
+const POLL_INTERVAL = 30_000; // 30 s — access tokens expire every 10 min, no need to poll faster
+
+export type UseRadfiSessionReturn = {
+  walletAddress: string | undefined;
+  isAuthed: boolean;
+  tradingAddress: string | undefined;
+  login: () => Promise<void>;
+  isLoginPending: boolean;
+};
+
+/**
+ * Manages the full Radfi session lifecycle:
+ * - Restores session from localStorage on mount
+ * - Polls every 2s: silently refreshes accessToken before expiry, resets auth when refreshToken expires
+ * - Exposes login() and isAuthed for UI
+ */
+export function useRadfiSession(
+  spokeProvider: BitcoinSpokeProvider | undefined,
+): UseRadfiSessionReturn {
+  const [walletAddress, setWalletAddress] = useState<string | undefined>();
+  const [isAuthed, setIsAuthed] = useState(false);
+  const [tradingAddress, setTradingAddress] = useState<string | undefined>();
+  const isRefreshingRef = useRef(false);
+
+  // ── Silent refresh helper ────────────────────────────────────────────────
+  const silentRefresh = useCallback(async (address: string) => {
+    if (!spokeProvider || isRefreshingRef.current) return;
+    isRefreshingRef.current = true;
+
+    try {
+      const session = loadRadfiSession(address);
+      if (!session?.refreshToken) {
+        setIsAuthed(false);
+        return;
+      }
+
+      const { accessToken, refreshToken } = await spokeProvider.radfi.refreshAccessToken(session.refreshToken);
+      const updated: RadfiSession = {
+        ...session,
+        accessToken,
+        refreshToken,
+        accessTokenExpiry: Date.now() + ACCESS_TOKEN_TTL,
+        // Keep the original refreshTokenExpiry — don't roll it forward on every silent refresh
+      };
+
+      saveRadfiSession(address, updated);
+      spokeProvider.setRadfiAccessToken(accessToken);
+      setIsAuthed(true);
+      setTradingAddress(updated.tradingAddress || undefined);
+    } catch {
+      clearRadfiSession(address);
+      spokeProvider.setRadfiAccessToken('');
+      setIsAuthed(false);
+      setTradingAddress(undefined);
+    } finally {
+      isRefreshingRef.current = false;
+    }
+  }, [spokeProvider]);
+
+  // ── Poll wallet address + restore session eagerly ────────────────────────
+  useEffect(() => {
+    if (!spokeProvider) return;
+
+    const fetchAndRestore = () => {
+      spokeProvider.walletProvider.getWalletAddress()
+        .then((addr) => {
+          setWalletAddress(addr);
+          // Eagerly restore session in the same tick to avoid extra render cycle
+          const session = loadRadfiSession(addr);
+          if (!session || isRefreshTokenExpired(addr)) return;
+
+          if (!isAccessTokenExpired(addr)) {
+            spokeProvider.setRadfiAccessToken(session.accessToken);
+            setIsAuthed(true);
+            setTradingAddress(session.tradingAddress || undefined);
+          } else {
+            // Access token expired but refresh valid — trigger silent refresh
+            silentRefresh(addr);
+          }
+        })
+        .catch(() => {});
+    };
+
+    fetchAndRestore();
+    const id = setInterval(fetchAndRestore, 3000);
+    return () => clearInterval(id);
+  }, [spokeProvider, silentRefresh]);
+
+  // ── Polling: check expiry every 30s ──────────────────────────────────────
+  useEffect(() => {
+    if (!walletAddress || !spokeProvider) return;
+
+    const id = setInterval(() => {
+      if (isRefreshTokenExpired(walletAddress)) {
+        clearRadfiSession(walletAddress);
+        spokeProvider.setRadfiAccessToken('');
+        setIsAuthed(false);
+        setTradingAddress(undefined);
+        return;
+      }
+
+      if (isAccessTokenExpired(walletAddress)) {
+        silentRefresh(walletAddress);
+      }
+    }, POLL_INTERVAL);
+
+    return () => clearInterval(id);
+  }, [walletAddress, spokeProvider, silentRefresh]);
+
+  // ── Login ────────────────────────────────────────────────────────────────
+  const { mutateAsync: loginMutate, isPending: isLoginPending } = useRadfiAuth(spokeProvider);
+
+  const login = useCallback(async () => {
+    const result = await loginMutate();
+    setIsAuthed(true);
+    setTradingAddress(result.tradingAddress || undefined);
+  }, [loginMutate]);
+
+  return { walletAddress, isAuthed, tradingAddress, login, isLoginPending };
+}

package/src/hooks/bitcoin/useRenewUtxos.ts

@@ -0,0 +1,72 @@
+import { normalizePsbtToBase64, type BitcoinSpokeProvider } from '@sodax/sdk';
+import { useMutation, useQueryClient, type UseMutationResult } from '@tanstack/react-query';
+import { loadRadfiSession } from './useRadfiAuth';
+
+type RenewUtxosParams = {
+  txIdVouts: string[];
+};
+
+/**
+ * Hook to renew expired UTXOs in the Radfi trading wallet.
+ *
+ * Flow:
+ * 1. Build renew-utxo transaction via Radfi API (returns unsigned PSBT)
+ * 2. User signs the PSBT with their wallet
+ * 3. Submit signed PSBT back to Radfi for co-signing and broadcasting
+ *
+ * @example
+ * ```tsx
+ * const { mutateAsync: renewUtxos, isPending } = useRenewUtxos(spokeProvider);
+ *
+ * const handleRenew = async (expiredUtxos: RadfiUtxo[]) => {
+ *   const txIdVouts = expiredUtxos.map(u => `${u.txId}:${u.vout}`);
+ *   const txId = await renewUtxos({ txIdVouts });
+ *   console.log('Renewed:', txId);
+ * };
+ * ```
+ */
+export function useRenewUtxos(
+  spokeProvider: BitcoinSpokeProvider | undefined,
+): UseMutationResult<string, Error, RenewUtxosParams> {
+  const queryClient = useQueryClient();
+
+  return useMutation<string, Error, RenewUtxosParams>({
+    mutationFn: async ({ txIdVouts }: RenewUtxosParams) => {
+      if (!spokeProvider) {
+        throw new Error('Bitcoin spoke provider not found');
+      }
+
+      const userAddress = await spokeProvider.walletProvider.getWalletAddress();
+      const session = loadRadfiSession(userAddress);
+      const accessToken = session?.accessToken || spokeProvider.radfiAccessToken;
+
+      if (!accessToken) {
+        throw new Error('Radfi authentication required. Please login first.');
+      }
+
+      // Step 1: Build the renew-utxo transaction
+      const buildResult = await spokeProvider.radfi.buildRenewUtxoTransaction(
+        { userAddress, txIdVouts },
+        accessToken,
+      );
+
+      // Step 2: Sign the PSBT with user's wallet
+      const signedTx = await spokeProvider.walletProvider.signTransaction(
+        buildResult.base64Psbt,
+        false,
+      );
+
+      const signedBase64Tx = normalizePsbtToBase64(signedTx);
+
+      // Step 3: Submit to Radfi for co-signing and broadcasting
+      return spokeProvider.radfi.signAndBroadcastRenewUtxo(
+        { userAddress, signedBase64Tx },
+        accessToken,
+      );
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ['expired-utxos'] });
+      queryClient.invalidateQueries({ queryKey: ['trading-wallet-balance'] });
+    },
+  });
+}

package/src/hooks/bitcoin/useTradingWallet.ts

@@ -0,0 +1,15 @@
+import { loadRadfiSession } from './useRadfiAuth';
+
+type UseTradingWalletReturn = {
+  tradingAddress: string | undefined;
+};
+
+/**
+ * Returns the Radfi trading wallet address from the persisted session.
+ * Trading wallet is created automatically during authentication — no API call needed.
+ */
+export function useTradingWallet(walletAddress: string | undefined): UseTradingWalletReturn {
+  if (!walletAddress) return { tradingAddress: undefined };
+  const session = loadRadfiSession(walletAddress);
+  return { tradingAddress: session?.tradingAddress || undefined };
+}

package/src/hooks/bitcoin/useTradingWalletBalance.ts

@@ -0,0 +1,22 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { BitcoinSpokeProvider, RadfiWalletBalance } from '@sodax/sdk';
+
+/**
+ * Hook to fetch trading wallet balance from Radfi API.
+ * Returns confirmed + pending satoshi balances.
+ */
+export function useTradingWalletBalance(
+  spokeProvider: BitcoinSpokeProvider | undefined,
+  tradingAddress: string | undefined,
+): UseQueryResult<RadfiWalletBalance, Error> {
+  return useQuery<RadfiWalletBalance, Error>({
+    queryKey: ['trading-wallet-balance', tradingAddress],
+    queryFn: () => {
+      if (!spokeProvider || !tradingAddress) {
+        throw new Error('spokeProvider and tradingAddress are required');
+      }
+      return spokeProvider.radfi.getBalance(tradingAddress);
+    },
+    enabled: !!spokeProvider && !!tradingAddress,
+  });
+}

package/src/hooks/index.ts

@@ -1,5 +1,6 @@
 export * from './shared';
 export * from './provider';
+export * from './bitcoin';
 export * from './mm';
 export * from './swap';
 export * from './backend';

package/src/hooks/provider/useSpokeProvider.ts

@@ -1,5 +1,6 @@
 import { useSodaxContext } from '@/index';
 import {
+  BitcoinSpokeProvider,
   EvmSpokeProvider,
   spokeChainConfig,
   type SuiSpokeChainConfig,
@@ -22,6 +23,9 @@ import {
   type NearSpokeChainConfig,
 } from '@sodax/sdk';
 import type {
+  BitcoinSpokeChainConfig,
+  BitcoinRpcConfig,
+  IBitcoinWalletProvider,
   IEvmWalletProvider,
   IIconWalletProvider,
   ISuiWalletProvider,
@@ -60,6 +64,22 @@ export function useSpokeProvider(
     if (!xChainType) return undefined;
     if (!rpcConfig) return undefined;
 
+    if (xChainType === 'BITCOIN') {
+      const bitcoinConfig = spokeChainConfig[spokeChainId] as BitcoinSpokeChainConfig;
+      const btcRpcOverride = rpcConfig[spokeChainId] as BitcoinRpcConfig | undefined;
+      return new BitcoinSpokeProvider(
+        walletProvider as IBitcoinWalletProvider,
+        bitcoinConfig,
+        {
+          url: btcRpcOverride?.radfiApiUrl || bitcoinConfig.radfiApiUrl,
+          apiKey: bitcoinConfig.radfiApiKey,
+          umsUrl: btcRpcOverride?.radfiUmsUrl || bitcoinConfig.radfiUmsUrl,
+        },
+        'TRADING',
+        btcRpcOverride?.rpcUrl || bitcoinConfig.rpcUrl,
+      );
+    }
+
     if (xChainType === 'EVM') {
       if (spokeChainId === SONIC_MAINNET_CHAIN_ID) {
         return new SonicSpokeProvider(