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

package/dist/index.js

@@ -143,6 +143,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 = sdk.spokeChainConfig[spokeChainId];
+      const btcRpcOverride = rpcConfig[spokeChainId];
+      return new sdk.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 === sdk.SONIC_MAINNET_CHAIN_ID) {
         return new sdk.SonicSpokeProvider(
@@ -205,6 +220,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 reactQuery.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] = React.useState();
+  const [isAuthed, setIsAuthed] = React.useState(false);
+  const [tradingAddress, setTradingAddress] = React.useState();
+  const isRefreshingRef = React.useRef(false);
+  const silentRefresh = React.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]);
+  React.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]);
+  React.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 = React.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 = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (amount) => {
+      if (!spokeProvider) {
+        throw new Error("Bitcoin spoke provider not found");
+      }
+      return sdk.BitcoinSpokeService.fundTradingWallet(amount, spokeProvider);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["btc-balance"] });
+      queryClient.invalidateQueries({ queryKey: ["xBalances"] });
+    }
+  });
+}
+function useBitcoinBalance(address, rpcUrl = "https://mempool.space/api") {
+  return reactQuery.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 reactQuery.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 reactQuery.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 = reactQuery.useQueryClient();
+  return reactQuery.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 = sdk.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 reactQuery.useMutation({
@@ -724,6 +991,54 @@ var useBackendUserIntents = ({
     }
   });
 };
+var useBackendSubmitSwapTx = (params) => {
+  const { sodax } = useSodaxContext();
+  const defaultMutationOptions = {
+    retry: 3
+  };
+  const mutationOptions = {
+    ...defaultMutationOptions,
+    ...params?.mutationOptions
+  };
+  return reactQuery.useMutation({
+    ...mutationOptions,
+    mutationFn: async (request) => {
+      return sodax.backendApi.submitSwapTx(request, params?.apiConfig);
+    }
+  });
+};
+var useBackendSubmitSwapTxStatus = (params) => {
+  const { sodax } = useSodaxContext();
+  const defaultQueryOptions = {
+    queryKey: ["api", "swaps", "submit-tx", "status", params?.params?.txHash, params?.params?.srcChainId],
+    enabled: !!params?.params?.txHash && params.params.txHash.length > 0,
+    retry: 3,
+    refetchInterval: (query) => {
+      const status = query.state.data?.data?.status;
+      if (status === "executed" || status === "failed") return false;
+      return 1e3;
+    }
+  };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions
+  };
+  return reactQuery.useQuery({
+    ...queryOptions,
+    queryFn: async () => {
+      if (!params?.params?.txHash) {
+        return void 0;
+      }
+      return sodax.backendApi.getSubmitSwapTxStatus(
+        {
+          txHash: params.params.txHash,
+          srcChainId: params.params.srcChainId
+        },
+        params.apiConfig
+      );
+    }
+  });
+};
 var useBackendOrderbook = (params) => {
   const { sodax } = useSodaxContext();
   const defaultQueryOptions = {
@@ -1521,6 +1836,11 @@ var SodaxProvider = ({ children, testnet = false, config, rpcConfig }) => {
 exports.MIGRATION_MODE_BNUSD = MIGRATION_MODE_BNUSD;
 exports.MIGRATION_MODE_ICX_SODA = MIGRATION_MODE_ICX_SODA;
 exports.SodaxProvider = SodaxProvider;
+exports.clearRadfiSession = clearRadfiSession;
+exports.isAccessTokenExpired = isAccessTokenExpired;
+exports.isRefreshTokenExpired = isRefreshTokenExpired;
+exports.loadRadfiSession = loadRadfiSession;
+exports.saveRadfiSession = saveRadfiSession;
 exports.useAToken = useAToken;
 exports.useATokensBalances = useATokensBalances;
 exports.useBackendAllMoneyMarketAssets = useBackendAllMoneyMarketAssets;
@@ -1532,7 +1852,10 @@ exports.useBackendMoneyMarketAssetBorrowers = useBackendMoneyMarketAssetBorrower
 exports.useBackendMoneyMarketAssetSuppliers = useBackendMoneyMarketAssetSuppliers;
 exports.useBackendMoneyMarketPosition = useBackendMoneyMarketPosition;
 exports.useBackendOrderbook = useBackendOrderbook;
+exports.useBackendSubmitSwapTx = useBackendSubmitSwapTx;
+exports.useBackendSubmitSwapTxStatus = useBackendSubmitSwapTxStatus;
 exports.useBackendUserIntents = useBackendUserIntents;
+exports.useBitcoinBalance = useBitcoinBalance;
 exports.useBorrow = useBorrow;
 exports.useBridge = useBridge;
 exports.useBridgeAllowance = useBridgeAllowance;
@@ -1545,6 +1868,8 @@ exports.useConvertedAssets = useConvertedAssets;
 exports.useCreateLimitOrder = useCreateLimitOrder;
 exports.useDeriveUserWalletAddress = useDeriveUserWalletAddress;
 exports.useEstimateGas = useEstimateGas;
+exports.useExpiredUtxos = useExpiredUtxos;
+exports.useFundTradingWallet = useFundTradingWallet;
 exports.useGetBridgeableAmount = useGetBridgeableAmount;
 exports.useGetBridgeableTokens = useGetBridgeableTokens;
 exports.useGetUserHubWalletAddress = useGetUserHubWalletAddress;
@@ -1559,6 +1884,9 @@ exports.useMigrate = useMigrate;
 exports.useMigrationAllowance = useMigrationAllowance;
 exports.useMigrationApprove = useMigrationApprove;
 exports.useQuote = useQuote;
+exports.useRadfiAuth = useRadfiAuth;
+exports.useRadfiSession = useRadfiSession;
+exports.useRenewUtxos = useRenewUtxos;
 exports.useRepay = useRepay;
 exports.useRequestTrustline = useRequestTrustline;
 exports.useReservesData = useReservesData;
@@ -1577,6 +1905,7 @@ exports.useSupply = useSupply;
 exports.useSwap = useSwap;
 exports.useSwapAllowance = useSwapAllowance;
 exports.useSwapApprove = useSwapApprove;
+exports.useTradingWalletBalance = useTradingWalletBalance;
 exports.useUnstake = useUnstake;
 exports.useUnstakeAllowance = useUnstakeAllowance;
 exports.useUnstakeApprove = useUnstakeApprove;