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

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import React, { createContext, useContext, useState, useCallback, useMemo, useRef, useEffect } from 'react';
-import { SpokeService, deriveUserWalletAddress, STELLAR_MAINNET_CHAIN_ID, StellarSpokeProvider, StellarSpokeService, HubService, spokeChainConfig, SONIC_MAINNET_CHAIN_ID, SonicSpokeProvider, EvmSpokeProvider, SuiSpokeProvider, IconSpokeProvider, InjectiveSpokeProvider, SolanaSpokeProvider, NearSpokeProvider, isLegacybnUSDToken, Sodax } from '@sodax/sdk';
+import { SpokeService, deriveUserWalletAddress, STELLAR_MAINNET_CHAIN_ID, StellarSpokeProvider, StellarSpokeService, HubService, spokeChainConfig, BitcoinSpokeProvider, SONIC_MAINNET_CHAIN_ID, SonicSpokeProvider, EvmSpokeProvider, SuiSpokeProvider, IconSpokeProvider, InjectiveSpokeProvider, SolanaSpokeProvider, NearSpokeProvider, BitcoinSpokeService, normalizePsbtToBase64, isLegacybnUSDToken, Sodax } from '@sodax/sdk';
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 import { isAddress, parseUnits } from 'viem';
 import { ICON_MAINNET_CHAIN_ID } from '@sodax/types';
@@ -137,6 +137,21 @@ function useSpokeProvider(spokeChainId, walletProvider) {
     if (!spokeChainId) return void 0;
     if (!xChainType) return void 0;
     if (!rpcConfig) return void 0;
+    if (xChainType === "BITCOIN") {
+      const bitcoinConfig = spokeChainConfig[spokeChainId];
+      const btcRpcOverride = rpcConfig[spokeChainId];
+      return new BitcoinSpokeProvider(
+        walletProvider,
+        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(
@@ -144,9 +159,11 @@ function useSpokeProvider(spokeChainId, walletProvider) {
           spokeChainConfig[spokeChainId]
         );
       }
+      const evmRpcUrl = rpcConfig[spokeChainId];
       return new EvmSpokeProvider(
         walletProvider,
-        spokeChainConfig[spokeChainId]
+        spokeChainConfig[spokeChainId],
+        typeof evmRpcUrl === "string" ? evmRpcUrl : void 0
       );
     }
     if (xChainType === "SUI") {
@@ -197,6 +214,258 @@ function useSpokeProvider(spokeChainId, walletProvider) {
   }, [spokeChainId, xChainType, walletProvider, rpcConfig]);
   return spokeProvider;
 }
+
+// src/hooks/bitcoin/radfiConstants.ts
+var ACCESS_TOKEN_TTL = 10 * 60 * 1e3;
+var REFRESH_TOKEN_TTL = 7 * 24 * 60 * 60 * 1e3;
+
+// src/hooks/bitcoin/useRadfiAuth.ts
+var SESSION_KEY = (address) => `radfi_session_${address}`;
+function saveRadfiSession(address, session) {
+  try {
+    localStorage.setItem(SESSION_KEY(address), JSON.stringify(session));
+  } catch {
+  }
+}
+function loadRadfiSession(address) {
+  try {
+    const raw = localStorage.getItem(SESSION_KEY(address));
+    return raw ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+function clearRadfiSession(address) {
+  try {
+    localStorage.removeItem(SESSION_KEY(address));
+  } catch {
+  }
+}
+function isAccessTokenExpired(address) {
+  const session = loadRadfiSession(address);
+  if (!session) return true;
+  return Date.now() >= session.accessTokenExpiry;
+}
+function isRefreshTokenExpired(address) {
+  const session = loadRadfiSession(address);
+  if (!session) return true;
+  return Date.now() >= session.refreshTokenExpiry;
+}
+function useRadfiAuth(spokeProvider) {
+  return useMutation({
+    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 = {
+          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) {
+        const isAlreadyRegistered = err instanceof Error && (err.message.includes("duplicatedPubKey") || err.message.includes("4008"));
+        if (isAlreadyRegistered) {
+          if (existingSession && !isRefreshTokenExpired(walletAddress)) {
+            const refreshed = await spokeProvider.radfi.refreshAccessToken(existingSession.refreshToken);
+            const session = {
+              ...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 };
+          }
+          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;
+      }
+    }
+  });
+}
+var POLL_INTERVAL = 3e4;
+function useRadfiSession(spokeProvider) {
+  const [walletAddress, setWalletAddress] = useState();
+  const [isAuthed, setIsAuthed] = useState(false);
+  const [tradingAddress, setTradingAddress] = useState();
+  const isRefreshingRef = useRef(false);
+  const silentRefresh = useCallback(async (address) => {
+    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 = {
+        ...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 || void 0);
+    } catch {
+      clearRadfiSession(address);
+      spokeProvider.setRadfiAccessToken("");
+      setIsAuthed(false);
+      setTradingAddress(void 0);
+    } finally {
+      isRefreshingRef.current = false;
+    }
+  }, [spokeProvider]);
+  useEffect(() => {
+    if (!spokeProvider) return;
+    const fetchAndRestore = () => {
+      spokeProvider.walletProvider.getWalletAddress().then((addr) => {
+        setWalletAddress(addr);
+        const session = loadRadfiSession(addr);
+        if (!session || isRefreshTokenExpired(addr)) return;
+        if (!isAccessTokenExpired(addr)) {
+          spokeProvider.setRadfiAccessToken(session.accessToken);
+          setIsAuthed(true);
+          setTradingAddress(session.tradingAddress || void 0);
+        } else {
+          silentRefresh(addr);
+        }
+      }).catch(() => {
+      });
+    };
+    fetchAndRestore();
+    const id = setInterval(fetchAndRestore, 3e3);
+    return () => clearInterval(id);
+  }, [spokeProvider, silentRefresh]);
+  useEffect(() => {
+    if (!walletAddress || !spokeProvider) return;
+    const id = setInterval(() => {
+      if (isRefreshTokenExpired(walletAddress)) {
+        clearRadfiSession(walletAddress);
+        spokeProvider.setRadfiAccessToken("");
+        setIsAuthed(false);
+        setTradingAddress(void 0);
+        return;
+      }
+      if (isAccessTokenExpired(walletAddress)) {
+        silentRefresh(walletAddress);
+      }
+    }, POLL_INTERVAL);
+    return () => clearInterval(id);
+  }, [walletAddress, spokeProvider, silentRefresh]);
+  const { mutateAsync: loginMutate, isPending: isLoginPending } = useRadfiAuth(spokeProvider);
+  const login = useCallback(async () => {
+    const result = await loginMutate();
+    setIsAuthed(true);
+    setTradingAddress(result.tradingAddress || void 0);
+  }, [loginMutate]);
+  return { walletAddress, isAuthed, tradingAddress, login, isLoginPending };
+}
+function useFundTradingWallet(spokeProvider) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (amount) => {
+      if (!spokeProvider) {
+        throw new Error("Bitcoin spoke provider not found");
+      }
+      return BitcoinSpokeService.fundTradingWallet(amount, spokeProvider);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["btc-balance"] });
+      queryClient.invalidateQueries({ queryKey: ["xBalances"] });
+    }
+  });
+}
+function useBitcoinBalance(address, rpcUrl = "https://mempool.space/api") {
+  return useQuery({
+    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 = await response.json();
+      return BigInt(utxos.reduce((sum, utxo) => sum + utxo.value, 0));
+    },
+    enabled: !!address
+  });
+}
+function useTradingWalletBalance(spokeProvider, tradingAddress) {
+  return useQuery({
+    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
+  });
+}
+function useExpiredUtxos(spokeProvider, tradingAddress) {
+  return useQuery({
+    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: 6e4
+    // refetch every minute
+  });
+}
+function useRenewUtxos(spokeProvider) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ txIdVouts }) => {
+      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.");
+      }
+      const buildResult = await spokeProvider.radfi.buildRenewUtxoTransaction(
+        { userAddress, txIdVouts },
+        accessToken
+      );
+      const signedTx = await spokeProvider.walletProvider.signTransaction(
+        buildResult.base64Psbt,
+        false
+      );
+      const signedBase64Tx = normalizePsbtToBase64(signedTx);
+      return spokeProvider.radfi.signAndBroadcastRenewUtxo(
+        { userAddress, signedBase64Tx },
+        accessToken
+      );
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["expired-utxos"] });
+      queryClient.invalidateQueries({ queryKey: ["trading-wallet-balance"] });
+    }
+  });
+}
 function useBorrow() {
   const { sodax } = useSodaxContext();
   return useMutation({
@@ -318,8 +587,22 @@ function useMMAllowance({
   const { sodax } = useSodaxContext();
   const defaultQueryOptions = {
     queryKey: ["mm", "allowance", params?.token, params?.action],
-    enabled: !!spokeProvider,
-    refetchInterval: 5e3
+    /**
+     * IMPORTANT: Skip allowance checks for 'borrow' and 'withdraw' actions.
+     *
+     * Reason: According to the SDK's MoneyMarketService.isAllowanceValid() implementation,
+     * borrow and withdraw actions do NOT require ERC-20 token approval. The SDK's
+     * isAllowanceValid() method always returns `true` for these actions without making
+     * any on-chain allowance checks.
+     *
+     * This optimization prevents unnecessary RPC calls and avoids showing confusing states for actions that don't actually need approval.
+     *
+     * Only 'supply' and 'repay' actions require token approval and should trigger allowance checks.
+     */
+    enabled: !!spokeProvider && !!params && params.action !== "borrow" && params.action !== "withdraw",
+    refetchInterval: 5e3,
+    gcTime: 0
+    // Don't cache failed queries
   };
   queryOptions = {
     ...defaultQueryOptions,
@@ -331,6 +614,9 @@ function useMMAllowance({
     queryFn: async () => {
       if (!spokeProvider) throw new Error("Spoke provider is required");
       if (!params) throw new Error("Params are required");
+      if (params.action === "borrow" || params.action === "withdraw") {
+        return true;
+      }
       const allowance = await sodax.moneyMarket.isAllowanceValid(params, spokeProvider);
       if (!allowance.ok) {
         throw allowance.error;
@@ -1170,11 +1456,9 @@ function useInstantUnstakeRatio(amount, refetchInterval = 1e4) {
 }
 function useConvertedAssets(amount, refetchInterval = 1e4) {
   const { sodax } = useSodaxContext();
-  console.log("useConvertedAssets hook called with:", { amount: amount?.toString(), sodax: !!sodax });
   return useQuery({
     queryKey: ["soda", "convertedAssets", amount?.toString()],
     queryFn: async () => {
-      console.log("useConvertedAssets queryFn called with amount:", amount?.toString());
       if (!amount || amount <= 0n) {
         throw new Error("Amount must be greater than 0");
       }
@@ -1495,6 +1779,6 @@ var SodaxProvider = ({ children, testnet = false, config, rpcConfig }) => {
   return /* @__PURE__ */ React.createElement(SodaxContext.Provider, { value: { sodax, testnet, rpcConfig } }, children);
 };
 
-export { MIGRATION_MODE_BNUSD, MIGRATION_MODE_ICX_SODA, SodaxProvider, useAToken, useATokensBalances, useBackendAllMoneyMarketAssets, useBackendAllMoneyMarketBorrowers, useBackendIntentByHash, useBackendIntentByTxHash, useBackendMoneyMarketAsset, useBackendMoneyMarketAssetBorrowers, useBackendMoneyMarketAssetSuppliers, useBackendMoneyMarketPosition, useBackendOrderbook, useBackendUserIntents, useBorrow, useBridge, useBridgeAllowance, useBridgeApprove, useCancelLimitOrder, useCancelSwap, useCancelUnstake, useClaim, useConvertedAssets, useCreateLimitOrder, useDeriveUserWalletAddress, useEstimateGas, useGetBridgeableAmount, useGetBridgeableTokens, useGetUserHubWalletAddress, useHubProvider, useInstantUnstake, useInstantUnstakeAllowance, useInstantUnstakeApprove, useInstantUnstakeRatio, useMMAllowance, useMMApprove, useMigrate, useMigrationAllowance, useMigrationApprove, useQuote, useRepay, useRequestTrustline, useReservesData, useReservesUsdFormat, useSodaxContext, useSpokeProvider, useStake, useStakeAllowance, useStakeApprove, useStakeRatio, useStakingConfig, useStakingInfo, useStatus, useStellarTrustlineCheck, useSupply, useSwap, useSwapAllowance, useSwapApprove, useUnstake, useUnstakeAllowance, useUnstakeApprove, useUnstakingInfo, useUnstakingInfoWithPenalty, useUserFormattedSummary, useUserReservesData, useWithdraw };
+export { MIGRATION_MODE_BNUSD, MIGRATION_MODE_ICX_SODA, SodaxProvider, clearRadfiSession, isAccessTokenExpired, isRefreshTokenExpired, loadRadfiSession, saveRadfiSession, useAToken, useATokensBalances, useBackendAllMoneyMarketAssets, useBackendAllMoneyMarketBorrowers, useBackendIntentByHash, useBackendIntentByTxHash, useBackendMoneyMarketAsset, useBackendMoneyMarketAssetBorrowers, useBackendMoneyMarketAssetSuppliers, useBackendMoneyMarketPosition, useBackendOrderbook, useBackendUserIntents, useBitcoinBalance, useBorrow, useBridge, useBridgeAllowance, useBridgeApprove, useCancelLimitOrder, useCancelSwap, useCancelUnstake, useClaim, useConvertedAssets, useCreateLimitOrder, useDeriveUserWalletAddress, useEstimateGas, useExpiredUtxos, useFundTradingWallet, useGetBridgeableAmount, useGetBridgeableTokens, useGetUserHubWalletAddress, useHubProvider, useInstantUnstake, useInstantUnstakeAllowance, useInstantUnstakeApprove, useInstantUnstakeRatio, useMMAllowance, useMMApprove, useMigrate, useMigrationAllowance, useMigrationApprove, useQuote, useRadfiAuth, useRadfiSession, useRenewUtxos, useRepay, useRequestTrustline, useReservesData, useReservesUsdFormat, useSodaxContext, useSpokeProvider, useStake, useStakeAllowance, useStakeApprove, useStakeRatio, useStakingConfig, useStakingInfo, useStatus, useStellarTrustlineCheck, useSupply, useSwap, useSwapAllowance, useSwapApprove, useTradingWalletBalance, useUnstake, useUnstakeAllowance, useUnstakeApprove, useUnstakingInfo, useUnstakingInfoWithPenalty, useUserFormattedSummary, useUserReservesData, useWithdraw };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map