@sodax/dapp-kit 2.0.0-rc.2 → 2.0.0-rc.20

package/dist/index.mjs

@@ -1,10 +1,15 @@
-import { useMutation, useQuery, useQueryClient, QueryClient, MutationCache } from '@tanstack/react-query';
-import { createContext, useCallback, useContext, useState, useRef, useEffect, useMemo } from 'react';
-import { ChainKeys, RadfiApiError, normalizePsbtToBase64, ClService, Sodax } from '@sodax/sdk';
+import { isSodaxError, ChainKeys, RadfiApiError, normalizePsbtToBase64, ClService, Sodax } from '@sodax/sdk';
 export * from '@sodax/sdk';
+import { useMutation, useQuery, useQueryClient, useQueries, QueryClient, MutationCache } from '@tanstack/react-query';
+import { createContext, useCallback, useContext, useState, useRef, useEffect, useMemo } from 'react';
 import { isAddress, erc20Abi, parseUnits } from 'viem';
 import { jsx } from 'react/jsx-runtime';
 
+// src/hooks/shared/isUserRejectedError.ts
+function isUserRejectedError(error) {
+  return isSodaxError(error) && error.code === "USER_REJECTED";
+}
+
 // src/hooks/shared/unwrapResult.ts
 function unwrapResult(result) {
   if (!result.ok) {
@@ -140,59 +145,76 @@ function useRequestTrustline(token) {
   );
   return { requestTrustline, isLoading, isRequested, error, data };
 }
-function useGetUserHubWalletAddress({
+function useNearStorageCheck({
   params,
   queryOptions
 } = {}) {
   const { sodax } = useSodaxContext();
-  const spokeChainId = params?.spokeChainId;
-  const spokeAddress = params?.spokeAddress;
+  const token = params?.token;
+  const accountId = params?.accountId;
+  const chainId = params?.chainId;
   return useQuery({
-    queryKey: ["shared", "userHubWalletAddress", spokeChainId, spokeAddress],
+    queryKey: ["shared", "nearStorageCheck", chainId, token, accountId],
     queryFn: async () => {
-      if (!spokeChainId || !spokeAddress) {
-        throw new Error("Spoke chain id and address are required");
-      }
-      return await sodax.hubProvider.getUserHubWalletAddress(spokeAddress, spokeChainId);
+      if (chainId !== ChainKeys.NEAR_MAINNET) return true;
+      if (!token || !accountId) return false;
+      return sodax.spoke.near.isStorageRegistered(token, accountId);
     },
-    enabled: !!spokeChainId && !!spokeAddress,
-    refetchInterval: false,
+    enabled: !!token && !!accountId,
     ...queryOptions
   });
 }
-var REFETCH_INTERVAL_MS = 5e3;
-function getXBalancesQueryOptions({ xService, xChainId, xTokens, address }) {
-  return {
-    // Pair symbol + address: readable in devtools, unique on-chain (symbol alone
-    // can collide — e.g. scam tokens copying legitimate ticker).
-    queryKey: ["shared", "xBalances", xChainId, xTokens.map((x) => [x.symbol, x.address]), address],
-    queryFn: async () => {
-      if (!xService) return {};
-      return xService.getBalances(address, xTokens);
-    },
-    enabled: !!xService && !!address && xTokens.length > 0,
-    refetchInterval: REFETCH_INTERVAL_MS
-  };
-}
-function useXBalances({
-  params,
-  queryOptions
+function useRegisterNearStorage({
+  mutationOptions
 } = {}) {
-  return useQuery({
-    ...getXBalancesQueryOptions({
-      xService: params?.xService,
-      xChainId: params?.xChainId,
-      xTokens: params?.xTokens ?? [],
-      address: params?.address
-    }),
-    ...queryOptions
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["shared", "registerNearStorage"],
+    ...mutationOptions,
+    mutationFn: async ({ token, accountId, walletProvider, deposit }) => sodax.spoke.near.registerStorage({ token, accountId, walletProvider, deposit, raw: false }),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({
+        queryKey: ["shared", "nearStorageCheck", ChainKeys.NEAR_MAINNET, vars.token, vars.accountId]
+      });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
+    }
   });
 }
+function resolveNearStorageGate(chainKey, check) {
+  const isNear = chainKey === ChainKeys.NEAR_MAINNET;
+  const isChecking = check.isLoading;
+  const isRegistered = check.data;
+  return {
+    isNear,
+    needsRegistration: isNear && !isChecking && isRegistered === false,
+    blocksAction: isNear && (isChecking || isRegistered === false)
+  };
+}
 
-// src/hooks/provider/useHubProvider.ts
-function useHubProvider() {
-  const { sodax } = useSodaxContext();
-  return sodax.hubProvider;
+// src/hooks/shared/useNearStorageGate.ts
+function useNearStorageGate({
+  dstChainKey,
+  token,
+  accountId,
+  walletProvider
+}) {
+  const nearWalletProvider = walletProvider?.chainType === "NEAR" ? walletProvider : void 0;
+  const storageCheck = useNearStorageCheck({ params: { token, accountId, chainId: dstChainKey } });
+  const { mutateAsyncSafe: register, isPending: isRegistering } = useRegisterNearStorage();
+  const { isNear, needsRegistration, blocksAction } = resolveNearStorageGate(dstChainKey, storageCheck);
+  const registerStorage = async () => {
+    if (!nearWalletProvider || !token || !accountId) return void 0;
+    return register({ token, accountId, walletProvider: nearWalletProvider });
+  };
+  return {
+    isNear,
+    needsRegistration,
+    blocksAction,
+    isChecking: storageCheck.isLoading,
+    isRegistering,
+    registerStorage
+  };
 }
 var SESSION_KEY = (address) => `radfi_session_${address}`;
 function saveRadfiSession(address, session) {
@@ -254,7 +276,7 @@ function useRadfiAuth({
             clearRadfiSession(walletAddress);
           }
           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."
+            "This wallet is already registered with Bound Exchange from another session. Please clear your browser storage for this site and try again, or wait for the previous session to expire."
           );
         }
         throw err;
@@ -262,6 +284,99 @@ function useRadfiAuth({
     }
   });
 }
+
+// src/hooks/bitcoin/resolveBtcReadAddress.ts
+function resolveBtcReadAddress(chainKey, address) {
+  if (chainKey !== ChainKeys.BITCOIN_MAINNET) return address;
+  return loadRadfiSession(address)?.tradingAddress ?? address;
+}
+
+// src/hooks/shared/useGetUserHubWalletAddress.ts
+function useGetUserHubWalletAddress({
+  params,
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const spokeChainId = params?.spokeChainId;
+  const spokeAddress = params?.spokeAddress;
+  return useQuery({
+    queryKey: ["shared", "userHubWalletAddress", spokeChainId, spokeAddress],
+    queryFn: async () => {
+      if (!spokeChainId || !spokeAddress) {
+        throw new Error("Spoke chain id and address are required");
+      }
+      return await sodax.hubProvider.getUserHubWalletAddress(
+        resolveBtcReadAddress(spokeChainId, spokeAddress),
+        spokeChainId
+      );
+    },
+    enabled: !!spokeChainId && !!spokeAddress,
+    refetchInterval: false,
+    ...queryOptions
+  });
+}
+var REFETCH_INTERVAL_MS = 5e3;
+function getXBalancesQueryOptions({ xService, xChainId, xTokens, address }) {
+  return {
+    // Pair symbol + address: readable in devtools, unique on-chain (symbol alone
+    // can collide — e.g. scam tokens copying legitimate ticker).
+    queryKey: ["shared", "xBalances", xChainId, xTokens.map((x) => [x.symbol, x.address]), address],
+    queryFn: async () => {
+      if (!xService) return {};
+      return xService.getBalances(address, xTokens);
+    },
+    enabled: !!xService && !!address && xTokens.length > 0,
+    refetchInterval: REFETCH_INTERVAL_MS
+  };
+}
+function useXBalances({
+  params,
+  queryOptions
+} = {}) {
+  return useQuery({
+    ...getXBalancesQueryOptions({
+      xService: params?.xService,
+      xChainId: params?.xChainId,
+      xTokens: params?.xTokens ?? [],
+      address: params?.address
+    }),
+    ...queryOptions
+  });
+}
+
+// src/hooks/provider/useHubProvider.ts
+function useHubProvider() {
+  const { sodax } = useSodaxContext();
+  return sodax.hubProvider;
+}
+
+// src/hooks/bitcoin/useEnsureRadfiAccessToken.ts
+function useEnsureRadfiAccessToken({
+  mutationOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  return useSafeMutation({
+    mutationKey: ["bitcoin", "ensureAccessToken"],
+    ...mutationOptions,
+    mutationFn: async ({ walletProvider }) => {
+      const radfi = sodax.spoke.bitcoin.radfi;
+      const walletAddress = await walletProvider.getWalletAddress();
+      const session = loadRadfiSession(walletAddress);
+      if (session?.refreshToken && !radfi.refreshToken) {
+        radfi.setRadfiAccessToken(session.accessToken, session.refreshToken);
+      }
+      await radfi.ensureRadfiAccessToken(walletProvider);
+      const accessToken = radfi.accessToken;
+      if (!accessToken) {
+        throw new Error("Failed to obtain a Bound Exchange access token");
+      }
+      if (session) {
+        saveRadfiSession(walletAddress, { ...session, accessToken, refreshToken: radfi.refreshToken });
+      }
+      return accessToken;
+    }
+  });
+}
 var REFRESH_INTERVAL = 5 * 60 * 1e3;
 function useRadfiSession(walletProvider) {
   const { sodax } = useSodaxContext();
@@ -397,6 +512,19 @@ function useTradingWalletBalance({
     ...queryOptions
   });
 }
+var INERT = { wallet: void 0, tradingBalance: void 0 };
+function useBitcoinTradingSetup({
+  chainKey,
+  walletProvider,
+  address
+}) {
+  const isBitcoin = chainKey === ChainKeys.BITCOIN_MAINNET;
+  const wallet = isBitcoin ? walletProvider : void 0;
+  const { tradingAddress } = useTradingWallet(isBitcoin ? address : void 0);
+  const { data: tradingBalance } = useTradingWalletBalance({ params: { walletProvider: wallet, tradingAddress } });
+  if (!isBitcoin) return INERT;
+  return { wallet, tradingBalance };
+}
 function useExpiredUtxos({
   params,
   queryOptions
@@ -432,7 +560,7 @@ function useRenewUtxos({
       const session = loadRadfiSession(userAddress);
       const accessToken = session?.accessToken || radfi.accessToken;
       if (!accessToken) {
-        throw new Error("Radfi authentication required. Please login first.");
+        throw new Error("Bound Exchange authentication required. Please login first.");
       }
       const buildResult = await radfi.buildRenewUtxoTransaction({ userAddress, txIdVouts }, accessToken);
       const signedTx = await walletProvider.signTransaction(buildResult.base64Psbt, false);
@@ -460,7 +588,7 @@ function useRadfiWithdraw({
       const session = loadRadfiSession(userAddress);
       const accessToken = session?.accessToken || radfi.accessToken;
       if (!accessToken) {
-        throw new Error("Radfi authentication required. Please login first.");
+        throw new Error("Bound Exchange authentication required. Please login first.");
       }
       const buildResult = await radfi.withdrawToUser({ userAddress, amount, tokenId, withdrawTo }, accessToken);
       const signedTx = await walletProvider.signTransaction(buildResult.base64Psbt, false);
@@ -581,7 +709,10 @@ function useUserReservesData({
       if (!spokeChainKey || !userAddress) {
         throw new Error("spokeChainKey and userAddress are required");
       }
-      return sodax.moneyMarket.data.getUserReservesData(spokeChainKey, userAddress);
+      return sodax.moneyMarket.data.getUserReservesData(
+        spokeChainKey,
+        resolveBtcReadAddress(spokeChainKey, userAddress)
+      );
     },
     enabled: !!spokeChainKey && !!userAddress,
     refetchInterval: 5e3,
@@ -707,7 +838,10 @@ function useATokensBalances({
           throw new Error(`Invalid aToken address: ${aToken}`);
         }
       }
-      const hubWalletAddress = await sodax.hubProvider.getUserHubWalletAddress(userAddress, spokeChainKey);
+      const hubWalletAddress = await sodax.hubProvider.getUserHubWalletAddress(
+        resolveBtcReadAddress(spokeChainKey, userAddress),
+        spokeChainKey
+      );
       return sodax.moneyMarket.data.getATokensBalances(aTokens, hubWalletAddress);
     },
     enabled: aTokens.length > 0 && !!spokeChainKey && !!userAddress,
@@ -742,7 +876,10 @@ function useUserFormattedSummary({
       }
       const [reserves, userReserves] = await Promise.all([
         sodax.moneyMarket.data.getReservesHumanized(),
-        sodax.moneyMarket.data.getUserReservesHumanized(spokeChainKey, userAddress)
+        sodax.moneyMarket.data.getUserReservesHumanized(
+          spokeChainKey,
+          resolveBtcReadAddress(spokeChainKey, userAddress)
+        )
       ]);
       const formattedReserves = sodax.moneyMarket.data.formatReservesUSD(
         sodax.moneyMarket.data.buildReserveDataWithPrice(reserves)
@@ -956,189 +1093,500 @@ var useBackendUserIntents = ({
     ...queryOptions
   });
 };
+var useBackendOrderbook = ({
+  params,
+  queryOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  const pagination = params?.pagination;
+  return useQuery({
+    queryKey: ["backend", "orderbook", pagination?.offset, pagination?.limit],
+    queryFn: async () => {
+      if (!pagination?.offset || !pagination?.limit) {
+        throw new Error("Pagination offset and limit are required");
+      }
+      return unwrapResult(await sodax.backendApi.getOrderbook(pagination));
+    },
+    enabled: !!pagination?.offset && !!pagination?.limit,
+    staleTime: 30 * 1e3,
+    retry: 3,
+    ...queryOptions
+  });
+};
+var useBackendMoneyMarketPosition = ({
+  params,
+  queryOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  const userAddress = params?.userAddress;
+  return useQuery({
+    queryKey: ["backend", "mm", "position", userAddress],
+    queryFn: async () => {
+      if (!userAddress) return void 0;
+      return unwrapResult(await sodax.backendApi.getMoneyMarketPosition(userAddress));
+    },
+    enabled: !!userAddress && userAddress.length > 0,
+    retry: 3,
+    ...queryOptions
+  });
+};
+var useBackendAllMoneyMarketAssets = ({
+  queryOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  return useQuery({
+    queryKey: ["backend", "mm", "assets", "all"],
+    queryFn: async () => {
+      return unwrapResult(await sodax.backendApi.getAllMoneyMarketAssets());
+    },
+    retry: 3,
+    ...queryOptions
+  });
+};
+var useBackendMoneyMarketAsset = ({
+  params,
+  queryOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  const reserveAddress = params?.reserveAddress;
+  return useQuery({
+    queryKey: ["backend", "mm", "asset", reserveAddress],
+    queryFn: async () => {
+      if (!reserveAddress) return void 0;
+      return unwrapResult(await sodax.backendApi.getMoneyMarketAsset(reserveAddress));
+    },
+    enabled: !!reserveAddress && reserveAddress.length > 0,
+    retry: 3,
+    ...queryOptions
+  });
+};
+var useBackendMoneyMarketAssetBorrowers = ({
+  params,
+  queryOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  const reserveAddress = params?.reserveAddress;
+  const pagination = params?.pagination;
+  return useQuery({
+    queryKey: ["backend", "mm", "asset", "borrowers", reserveAddress, pagination],
+    queryFn: async () => {
+      if (!reserveAddress || !pagination?.offset || !pagination?.limit) {
+        return void 0;
+      }
+      return unwrapResult(
+        await sodax.backendApi.getMoneyMarketAssetBorrowers(reserveAddress, {
+          offset: pagination.offset,
+          limit: pagination.limit
+        })
+      );
+    },
+    enabled: !!reserveAddress && !!pagination?.offset && !!pagination?.limit,
+    retry: 3,
+    ...queryOptions
+  });
+};
+var useBackendMoneyMarketAssetSuppliers = ({
+  params,
+  queryOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  const reserveAddress = params?.reserveAddress;
+  const pagination = params?.pagination;
+  return useQuery({
+    queryKey: ["backend", "mm", "asset", "suppliers", reserveAddress, pagination],
+    queryFn: async () => {
+      if (!reserveAddress || !pagination?.offset || !pagination?.limit) {
+        return void 0;
+      }
+      return unwrapResult(
+        await sodax.backendApi.getMoneyMarketAssetSuppliers(reserveAddress, {
+          offset: pagination.offset,
+          limit: pagination.limit
+        })
+      );
+    },
+    enabled: !!reserveAddress && !!pagination?.offset && !!pagination?.limit,
+    retry: 3,
+    ...queryOptions
+  });
+};
+var useBackendAllMoneyMarketBorrowers = ({
+  params,
+  queryOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  const pagination = params?.pagination;
+  return useQuery({
+    queryKey: ["backend", "mm", "borrowers", "all", pagination],
+    queryFn: async () => {
+      if (!pagination?.offset || !pagination?.limit) {
+        return void 0;
+      }
+      return unwrapResult(
+        await sodax.backendApi.getAllMoneyMarketBorrowers({
+          offset: pagination.offset,
+          limit: pagination.limit
+        })
+      );
+    },
+    enabled: !!pagination?.offset && !!pagination?.limit,
+    retry: 3,
+    ...queryOptions
+  });
+};
+var useSwapsApiTokens = ({
+  params,
+  queryOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  const apiConfig = params?.apiConfig;
+  return useQuery({
+    queryKey: ["swapsApi", "tokens"],
+    queryFn: async () => unwrapResult(await sodax.api.swaps.getTokens(apiConfig)),
+    retry: 3,
+    ...queryOptions
+  });
+};
+var useSwapsApiTokensByChain = ({
+  params,
+  queryOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  const chainKey = params?.chainKey;
+  const apiConfig = params?.apiConfig;
+  return useQuery({
+    queryKey: ["swapsApi", "tokens", chainKey],
+    queryFn: async () => {
+      if (!chainKey) return void 0;
+      return unwrapResult(await sodax.api.swaps.getTokensByChain(chainKey, apiConfig));
+    },
+    enabled: !!chainKey && chainKey.length > 0,
+    retry: 3,
+    ...queryOptions
+  });
+};
+var useSwapsApiQuote = ({
+  params,
+  queryOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  const body = params?.body;
+  const query = params?.query;
+  const apiConfig = params?.apiConfig;
+  return useQuery({
+    // Hash the whole request body so every quote input — including partnerFee and the other
+    // SwapExtrasV2 fields — is a cache dimension; a partnerFee change alters the quote and must
+    // miss the cache. QuoteRequestV2 is bigint-free (compile-time guaranteed), so React Query's
+    // default key hashing handles the object directly.
+    queryKey: ["swapsApi", "quote", body, query?.includeTxData ?? false],
+    queryFn: async () => {
+      if (!body) return void 0;
+      return unwrapResult(await sodax.api.swaps.getQuote(body, query, apiConfig));
+    },
+    enabled: !!body,
+    retry: 3,
+    ...queryOptions
+  });
+};
+var useSwapsApiDeadline = ({
+  params,
+  queryOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  const query = params?.query;
+  const apiConfig = params?.apiConfig;
+  return useQuery({
+    queryKey: ["swapsApi", "deadline", query?.offsetSeconds ?? null],
+    queryFn: async () => unwrapResult(await sodax.api.swaps.getDeadline(query, apiConfig)),
+    retry: 3,
+    ...queryOptions
+  });
+};
+var useSwapsApiAllowance = ({
+  params,
+  queryOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  const body = params?.body;
+  const apiConfig = params?.apiConfig;
+  return useQuery({
+    queryKey: ["swapsApi", "allowance", body?.srcChainKey, body?.inputToken, body?.inputAmount, body?.srcAddress],
+    queryFn: async () => {
+      if (!body) return void 0;
+      return unwrapResult(await sodax.api.swaps.checkAllowance(body, apiConfig));
+    },
+    enabled: !!body,
+    retry: 3,
+    ...queryOptions
+  });
+};
 
-// src/hooks/backend/useBackendSubmitSwapTx.ts
-var useBackendSubmitSwapTx = ({
+// src/hooks/swapsApi/useSwapsApiApprove.ts
+var useSwapsApiApprove = ({
   mutationOptions
 } = {}) => {
   const { sodax } = useSodaxContext();
   return useSafeMutation({
-    mutationKey: ["backend", "submitSwapTx"],
+    mutationKey: ["swapsApi", "approve"],
     retry: 3,
     ...mutationOptions,
-    mutationFn: async ({ request, apiConfig }) => unwrapResult(await sodax.backendApi.submitSwapTx(request, apiConfig))
+    mutationFn: async ({ body, apiConfig }) => unwrapResult(await sodax.api.swaps.approve(body, apiConfig))
+  });
+};
+
+// src/hooks/swapsApi/useSwapsApiCreateIntent.ts
+var useSwapsApiCreateIntent = ({
+  mutationOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  return useSafeMutation({
+    mutationKey: ["swapsApi", "createIntent"],
+    retry: 3,
+    ...mutationOptions,
+    mutationFn: async ({ body, apiConfig }) => unwrapResult(await sodax.api.swaps.createIntent(body, apiConfig))
+  });
+};
+
+// src/hooks/swapsApi/useSwapsApiSubmitIntent.ts
+var useSwapsApiSubmitIntent = ({
+  mutationOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  return useSafeMutation({
+    mutationKey: ["swapsApi", "submitIntent"],
+    retry: false,
+    ...mutationOptions,
+    mutationFn: async ({ body, apiConfig }) => unwrapResult(await sodax.api.swaps.submitIntent(body, apiConfig))
   });
 };
-var useBackendSubmitSwapTxStatus = ({
+
+// src/hooks/swapsApi/isTerminalSwapIntentStatus.ts
+var isTerminalSwapIntentStatus = (status) => status === 3 || status === 4;
+
+// src/hooks/swapsApi/useSwapsApiStatus.ts
+var useSwapsApiStatus = ({
   params,
   queryOptions
 } = {}) => {
   const { sodax } = useSodaxContext();
-  const txHash = params?.txHash;
-  const srcChainKey = params?.srcChainKey;
+  const intentTxHash = params?.intentTxHash;
   const apiConfig = params?.apiConfig;
   return useQuery({
-    queryKey: ["backend", "submitSwapTx", "status", txHash, srcChainKey],
+    queryKey: ["swapsApi", "status", intentTxHash],
     queryFn: async () => {
-      if (!txHash) return void 0;
-      return unwrapResult(
-        await sodax.backendApi.getSubmitSwapTxStatus(
-          {
-            txHash,
-            srcChainKey
-          },
-          apiConfig
-        )
-      );
+      if (!intentTxHash) return void 0;
+      return unwrapResult(await sodax.api.swaps.getStatus({ intentTxHash }, apiConfig));
     },
-    enabled: !!txHash && txHash.length > 0,
+    enabled: !!intentTxHash && intentTxHash.length > 0,
     retry: 3,
-    refetchInterval: (query) => {
-      const status = query.state.data?.data?.status;
-      if (status === "executed" || status === "failed") return false;
-      return 1e3;
+    refetchInterval: (query) => isTerminalSwapIntentStatus(query.state.data?.status) ? false : 1e3,
+    ...queryOptions
+  });
+};
+
+// src/hooks/swapsApi/useSwapsApiCancelIntent.ts
+var useSwapsApiCancelIntent = ({
+  mutationOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  return useSafeMutation({
+    mutationKey: ["swapsApi", "cancelIntent"],
+    retry: 3,
+    ...mutationOptions,
+    mutationFn: async ({ body, apiConfig }) => unwrapResult(await sodax.api.swaps.cancelIntent(body, apiConfig))
+  });
+};
+var useSwapsApiIntentHash = ({
+  params,
+  queryOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  const intent = params?.intent;
+  const apiConfig = params?.apiConfig;
+  return useQuery({
+    queryKey: ["swapsApi", "intentHash", intent?.intentId?.toString()],
+    queryFn: async () => {
+      if (!intent) return void 0;
+      return unwrapResult(await sodax.api.swaps.getIntentHash({ intent }, apiConfig));
     },
+    enabled: !!intent,
+    retry: 3,
     ...queryOptions
   });
 };
-var useBackendOrderbook = ({
+var useSwapsApiIntentPacket = ({
   params,
   queryOptions
 } = {}) => {
   const { sodax } = useSodaxContext();
-  const pagination = params?.pagination;
+  const body = params?.body;
+  const apiConfig = params?.apiConfig;
   return useQuery({
-    queryKey: ["backend", "orderbook", pagination?.offset, pagination?.limit],
+    queryKey: ["swapsApi", "intentPacket", body?.chainId, body?.fillTxHash],
+    queryFn: async () => {
+      if (!body) return void 0;
+      return unwrapResult(await sodax.api.swaps.getSolvedIntentPacket(body, apiConfig));
+    },
+    enabled: !!body,
+    retry: 3,
+    ...queryOptions
+  });
+};
+var useSwapsApiIntentExtraData = ({
+  params,
+  queryOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  const body = params?.body;
+  const apiConfig = params?.apiConfig;
+  return useQuery({
+    queryKey: ["swapsApi", "intentExtraData", body?.txHash ?? body?.intent?.intentId?.toString()],
     queryFn: async () => {
-      if (!pagination?.offset || !pagination?.limit) {
-        throw new Error("Pagination offset and limit are required");
-      }
-      return unwrapResult(await sodax.backendApi.getOrderbook(pagination));
+      if (!body || !body.txHash && !body.intent) return void 0;
+      return unwrapResult(await sodax.api.swaps.getIntentSubmitTxExtraData(body, apiConfig));
     },
-    enabled: !!pagination?.offset && !!pagination?.limit,
-    staleTime: 30 * 1e3,
+    enabled: !!body && (!!body.txHash || !!body.intent),
     retry: 3,
     ...queryOptions
   });
 };
-var useBackendMoneyMarketPosition = ({
+var useSwapsApiFilledIntent = ({
   params,
   queryOptions
 } = {}) => {
   const { sodax } = useSodaxContext();
-  const userAddress = params?.userAddress;
+  const txHash = params?.txHash;
+  const apiConfig = params?.apiConfig;
   return useQuery({
-    queryKey: ["backend", "mm", "position", userAddress],
+    queryKey: ["swapsApi", "filledIntent", txHash],
     queryFn: async () => {
-      if (!userAddress) return void 0;
-      return unwrapResult(await sodax.backendApi.getMoneyMarketPosition(userAddress));
+      if (!txHash) return void 0;
+      return unwrapResult(await sodax.api.swaps.getFilledIntent(txHash, apiConfig));
     },
-    enabled: !!userAddress && userAddress.length > 0,
+    enabled: !!txHash && txHash.length > 0,
     retry: 3,
     ...queryOptions
   });
 };
-var useBackendAllMoneyMarketAssets = ({
+var useSwapsApiIntent = ({
+  params,
   queryOptions
 } = {}) => {
   const { sodax } = useSodaxContext();
+  const txHash = params?.txHash;
+  const apiConfig = params?.apiConfig;
   return useQuery({
-    queryKey: ["backend", "mm", "assets", "all"],
+    queryKey: ["swapsApi", "intent", txHash],
     queryFn: async () => {
-      return unwrapResult(await sodax.backendApi.getAllMoneyMarketAssets());
+      if (!txHash) return void 0;
+      return unwrapResult(await sodax.api.swaps.getIntent(txHash, apiConfig));
     },
+    enabled: !!txHash && txHash.length > 0,
     retry: 3,
     ...queryOptions
   });
 };
-var useBackendMoneyMarketAsset = ({
+
+// src/hooks/swapsApi/useSwapsApiCreateLimitOrder.ts
+var useSwapsApiCreateLimitOrder = ({
+  mutationOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  return useSafeMutation({
+    mutationKey: ["swapsApi", "createLimitOrder"],
+    retry: 3,
+    ...mutationOptions,
+    mutationFn: async ({ body, apiConfig }) => unwrapResult(await sodax.api.swaps.createLimitOrderIntent(body, apiConfig))
+  });
+};
+var useSwapsApiEstimateGas = ({
   params,
   queryOptions
 } = {}) => {
   const { sodax } = useSodaxContext();
-  const reserveAddress = params?.reserveAddress;
+  const body = params?.body;
+  const apiConfig = params?.apiConfig;
   return useQuery({
-    queryKey: ["backend", "mm", "asset", reserveAddress],
+    queryKey: ["swapsApi", "estimateGas", body?.chainKey, body?.tx],
     queryFn: async () => {
-      if (!reserveAddress) return void 0;
-      return unwrapResult(await sodax.backendApi.getMoneyMarketAsset(reserveAddress));
+      if (!body) return void 0;
+      return unwrapResult(await sodax.api.swaps.estimateGas(body, apiConfig));
     },
-    enabled: !!reserveAddress && reserveAddress.length > 0,
+    enabled: !!body,
     retry: 3,
     ...queryOptions
   });
 };
-var useBackendMoneyMarketAssetBorrowers = ({
+var useSwapsApiPartnerFee = ({
   params,
   queryOptions
 } = {}) => {
   const { sodax } = useSodaxContext();
-  const reserveAddress = params?.reserveAddress;
-  const pagination = params?.pagination;
+  const amount = params?.amount;
+  const apiConfig = params?.apiConfig;
   return useQuery({
-    queryKey: ["backend", "mm", "asset", "borrowers", reserveAddress, pagination],
+    queryKey: ["swapsApi", "partnerFee", amount],
     queryFn: async () => {
-      if (!reserveAddress || !pagination?.offset || !pagination?.limit) {
-        return void 0;
-      }
-      return unwrapResult(
-        await sodax.backendApi.getMoneyMarketAssetBorrowers(reserveAddress, {
-          offset: pagination.offset,
-          limit: pagination.limit
-        })
-      );
+      if (!amount) return void 0;
+      return unwrapResult(await sodax.api.swaps.getPartnerFee({ amount }, apiConfig));
     },
-    enabled: !!reserveAddress && !!pagination?.offset && !!pagination?.limit,
+    enabled: !!amount && amount.length > 0,
     retry: 3,
     ...queryOptions
   });
 };
-var useBackendMoneyMarketAssetSuppliers = ({
+var useSwapsApiSolverFee = ({
   params,
   queryOptions
 } = {}) => {
   const { sodax } = useSodaxContext();
-  const reserveAddress = params?.reserveAddress;
-  const pagination = params?.pagination;
+  const amount = params?.amount;
+  const apiConfig = params?.apiConfig;
   return useQuery({
-    queryKey: ["backend", "mm", "asset", "suppliers", reserveAddress, pagination],
+    queryKey: ["swapsApi", "solverFee", amount],
     queryFn: async () => {
-      if (!reserveAddress || !pagination?.offset || !pagination?.limit) {
-        return void 0;
-      }
-      return unwrapResult(
-        await sodax.backendApi.getMoneyMarketAssetSuppliers(reserveAddress, {
-          offset: pagination.offset,
-          limit: pagination.limit
-        })
-      );
+      if (!amount) return void 0;
+      return unwrapResult(await sodax.api.swaps.getSolverFee({ amount }, apiConfig));
     },
-    enabled: !!reserveAddress && !!pagination?.offset && !!pagination?.limit,
+    enabled: !!amount && amount.length > 0,
     retry: 3,
     ...queryOptions
   });
 };
-var useBackendAllMoneyMarketBorrowers = ({
+
+// src/hooks/swapsApi/useSwapsApiSubmitTx.ts
+var useSwapsApiSubmitTx = ({
+  mutationOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  return useSafeMutation({
+    mutationKey: ["swapsApi", "submitTx"],
+    retry: 3,
+    ...mutationOptions,
+    mutationFn: async ({ request, apiConfig }) => unwrapResult(await sodax.api.swaps.submitTx(request, apiConfig))
+  });
+};
+var useSwapsApiSubmitTxStatus = ({
   params,
   queryOptions
 } = {}) => {
   const { sodax } = useSodaxContext();
-  const pagination = params?.pagination;
+  const txHash = params?.txHash;
+  const srcChainKey = params?.srcChainKey;
+  const apiConfig = params?.apiConfig;
   return useQuery({
-    queryKey: ["backend", "mm", "borrowers", "all", pagination],
+    queryKey: ["swapsApi", "submitTx", "status", txHash, srcChainKey],
     queryFn: async () => {
-      if (!pagination?.offset || !pagination?.limit) {
-        return void 0;
-      }
-      return unwrapResult(
-        await sodax.backendApi.getAllMoneyMarketBorrowers({
-          offset: pagination.offset,
-          limit: pagination.limit
-        })
-      );
+      if (!txHash || !srcChainKey) return void 0;
+      return unwrapResult(await sodax.api.swaps.getSubmitTxStatus({ txHash, srcChainKey }, apiConfig));
     },
-    enabled: !!pagination?.offset && !!pagination?.limit,
+    enabled: !!txHash && txHash.length > 0 && !!srcChainKey,
     retry: 3,
+    refetchInterval: (query) => {
+      const status = query.state.data?.data?.status;
+      if (status === "solved" || status === "failed") return false;
+      return 1e3;
+    },
     ...queryOptions
   });
 };
@@ -1764,6 +2212,107 @@ function useFeeClaimSwap({
     }
   });
 }
+function usePartnerCancelIntent({
+  mutationOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["partner", "cancelIntent"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.partners.feeClaim.cancelIntent({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({
+        queryKey: ["partner", "feeClaim", "assetsBalances", vars.params.srcAddress]
+      });
+      queryClient.invalidateQueries({
+        queryKey: [
+          "partner",
+          "feeClaim",
+          "userIntent",
+          vars.params.srcAddress,
+          vars.params.fromToken,
+          vars.params.toToken
+        ]
+      });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
+    }
+  });
+}
+function useGetUserIntent({ params, queryOptions } = {}) {
+  const { sodax } = useSodaxContext();
+  const user = params?.user;
+  const fromToken = params?.fromToken;
+  const toToken = params?.toToken;
+  return useQuery({
+    queryKey: ["partner", "feeClaim", "userIntent", user, fromToken, toToken],
+    queryFn: async () => {
+      if (!user || !fromToken || !toToken) {
+        throw new Error("user, fromToken and toToken are required");
+      }
+      const result = await sodax.partners.feeClaim.getUserIntent({ user, fromToken, toToken });
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: !!user && !!fromToken && !!toToken,
+    ...queryOptions
+  });
+}
+var ZERO_HASH = "0x0000000000000000000000000000000000000000000000000000000000000000";
+function useGetIntentDetails({
+  params,
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const intentHash = params?.intentHash;
+  const hasIntent = !!intentHash && intentHash !== ZERO_HASH;
+  return useQuery({
+    queryKey: ["partner", "feeClaim", "intentDetails", intentHash],
+    queryFn: async () => {
+      if (!intentHash) {
+        throw new Error("intentHash is required");
+      }
+      const result = await sodax.partners.feeClaim.getIntentDetails(intentHash);
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: hasIntent,
+    ...queryOptions
+  });
+}
+function useFeeClaimWithdraw({
+  mutationOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["partner", "feeClaimWithdraw"],
+    ...mutationOptions,
+    mutationFn: async ({ params, walletProvider }) => {
+      const bridgeParams = {
+        params: {
+          srcChainKey: ChainKeys.SONIC_MAINNET,
+          srcAddress: params.srcAddress,
+          srcToken: params.feeToken,
+          amount: params.amount,
+          dstChainKey: params.dstChainKey,
+          dstToken: params.dstToken,
+          recipient: params.recipient
+        },
+        raw: false,
+        walletProvider
+      };
+      return unwrapResult(await sodax.bridge.bridge(bridgeParams));
+    },
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({
+        queryKey: ["partner", "feeClaim", "assetsBalances", vars.params.srcAddress]
+      });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", vars.params.dstChainKey] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
+    }
+  });
+}
 function useHubAssetBalances({
   params,
   queryOptions
@@ -2482,11 +3031,162 @@ function useClaimRewards({
     }
   });
 }
+function useLeverageYieldEffectiveApr({
+  params,
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const vault = params?.vault;
+  return useQuery({
+    queryKey: ["leverageYield", "effectiveApr", vault],
+    queryFn: async () => {
+      if (!vault) throw new Error("vault is required");
+      const result = await sodax.leverageYield.getEffectiveApr(vault);
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: !!vault,
+    refetchInterval: 6e4,
+    ...queryOptions
+  });
+}
+function useLeverageYieldPosition({
+  params,
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const vault = params?.vault;
+  return useQuery({
+    queryKey: ["leverageYield", "position", vault],
+    queryFn: async () => {
+      if (!vault) throw new Error("vault is required");
+      const result = await sodax.leverageYield.getPosition(vault);
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: !!vault,
+    refetchInterval: 3e4,
+    ...queryOptions
+  });
+}
+function useLeverageYieldTotalAssets({
+  params,
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const vault = params?.vault;
+  return useQuery({
+    queryKey: ["leverageYield", "totalAssets", vault],
+    queryFn: async () => {
+      if (!vault) throw new Error("vault is required");
+      const result = await sodax.leverageYield.getTotalAssets(vault);
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: !!vault,
+    refetchInterval: 6e4,
+    ...queryOptions
+  });
+}
+function useLeverageYieldPreviewRedeem({
+  params,
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const vault = params?.vault;
+  const shares = params?.shares;
+  return useQuery({
+    queryKey: ["leverageYield", "previewRedeem", vault, shares?.toString()],
+    queryFn: async () => {
+      if (!vault || shares === void 0) throw new Error("vault and shares are required");
+      const result = await sodax.leverageYield.previewRedeem(vault, shares);
+      if (!result.ok) throw result.error;
+      return result.value;
+    },
+    enabled: !!vault && shares !== void 0,
+    refetchInterval: 6e4,
+    ...queryOptions
+  });
+}
+function useLeverageYieldShareBalances({
+  params,
+  queryOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const vault = params?.vault;
+  const holders = params?.holders;
+  return useQueries({
+    queries: (holders ?? []).map(({ chainKey, address }) => ({
+      queryKey: ["leverageYield", "shareBalance", vault, chainKey, address],
+      refetchInterval: 15e3,
+      ...queryOptions,
+      enabled: !!vault,
+      queryFn: async () => {
+        if (!vault) throw new Error("vault is required");
+        const holder = await sodax.hubProvider.getUserHubWalletAddress(address, chainKey);
+        const result = await sodax.leverageYield.getShareBalance(vault, holder);
+        if (!result.ok) throw result.error;
+        return { chainKey, holder, shares: result.value };
+      }
+    }))
+  });
+}
+
+// src/hooks/leverageYield/useLeverageYieldDeposit.ts
+function useLeverageYieldDeposit({
+  mutationOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  return useSafeMutation({
+    mutationKey: ["leverageYield", "deposit"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.leverageYield.deposit(vars))
+  });
+}
+
+// src/hooks/leverageYield/useLeverageYieldNotifySolver.ts
+function useLeverageYieldNotifySolver({
+  mutationOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  return useSafeMutation({
+    mutationKey: ["leverageYield", "notifySolver"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.leverageYield.notifySolver(vars))
+  });
+}
+function useLeverageYieldVaultSwap({
+  mutationOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+  return useSafeMutation({
+    mutationKey: ["leverageYield", "vaultSwap"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.leverageYield.vaultSwap({ ...vars, raw: false })),
+    onSuccess: async (data, vars, ctx) => {
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", vars.params.srcChainKey] });
+      queryClient.invalidateQueries({ queryKey: ["shared", "xBalances", vars.params.dstChainKey] });
+      await mutationOptions?.onSuccess?.(data, vars, ctx);
+    }
+  });
+}
+
+// src/hooks/leverageYield/useLeverageYieldWithdraw.ts
+function useLeverageYieldWithdraw({
+  mutationOptions
+} = {}) {
+  const { sodax } = useSodaxContext();
+  return useSafeMutation({
+    mutationKey: ["leverageYield", "withdraw"],
+    ...mutationOptions,
+    mutationFn: async (vars) => unwrapResult(await sodax.leverageYield.withdraw(vars))
+  });
+}
 var SodaxProvider = ({ children, config }) => {
-  const configRef = useRef(config);
-  const frozen = configRef.current;
-  const sodax = useMemo(() => new Sodax(frozen), [frozen]);
-  return /* @__PURE__ */ jsx(SodaxContext.Provider, { value: { sodax }, children });
+  const sodax = useMemo(() => new Sodax(config), [config]);
+  const contextValue = useMemo(() => ({ sodax }), [sodax]);
+  return /* @__PURE__ */ jsx(SodaxContext.Provider, { value: contextValue, children });
 };
 var defaultOnMutationError = (error) => {
   console.error("[sodax] Mutation error:", error);
@@ -2514,6 +3214,4 @@ function createSodaxQueryClient({
   });
 }
 
-export { SodaxProvider, clearRadfiSession, createDecreaseLiquidityParamsProps, createDepositParamsProps, createSodaxQueryClient, createSupplyLiquidityParamsProps, createWithdrawParamsProps, getXBalancesQueryOptions, loadRadfiSession, saveRadfiSession, toResult, unwrapResult, useAToken, useATokensBalances, useApproveToken, useBackendAllMoneyMarketAssets, useBackendAllMoneyMarketBorrowers, useBackendIntentByHash, useBackendIntentByTxHash, useBackendMoneyMarketAsset, useBackendMoneyMarketAssetBorrowers, useBackendMoneyMarketAssetSuppliers, useBackendMoneyMarketPosition, useBackendOrderbook, useBackendSubmitSwapTx, useBackendSubmitSwapTxStatus, useBackendUserIntents, useBitcoinBalance, useBorrow, useBridge, useBridgeAllowance, useBridgeApprove, useCancelLimitOrder, useCancelSwap, useCancelUnstake, useClaim, useClaimRewards, useConvertedAssets, useCreateDecreaseLiquidityParams, useCreateDepositParams, useCreateLimitOrder, useCreateSupplyLiquidityParams, useCreateWithdrawParams, useDecreaseLiquidity, useDeriveUserWalletAddress, useDexAllowance, useDexApprove, useDexDeposit, useDexWithdraw, useEstimateGas, useExpiredUtxos, useFeeClaimSwap, useFetchAssetsBalances, useFundTradingWallet, useGetAutoSwapPreferences, useGetBridgeableAmount, useGetBridgeableTokens, useGetUserHubWalletAddress, useHubAssetBalances, useHubProvider, useInstantUnstake, useInstantUnstakeAllowance, useInstantUnstakeApprove, useInstantUnstakeRatio, useIsTokenApproved, useLiquidityAmounts, useMMAllowance, useMMApprove, useMigrateBaln, useMigrateIcxToSoda, useMigratebnUSD, useMigrationAllowance, useMigrationApprove, usePoolBalances, usePoolData, usePools, usePositionInfo, useQuote, useRadfiAuth, useRadfiSession, useRadfiWithdraw, useRenewUtxos, useRepay, useRequestTrustline, useReservesData, useReservesHumanized, useReservesList, useReservesUsdFormat, useRevertMigrateSodaToIcx, useSafeMutation, useSetSwapPreference, useSodaxContext, useStake, useStakeAllowance, useStakeApprove, useStakeRatio, useStakingConfig, useStakingInfo, useStatus, useStellarTrustlineCheck, useSupply, useSupplyLiquidity, useSwap, useSwapAllowance, useSwapApprove, useTradingWallet, useTradingWalletBalance, useUnstake, useUnstakeAllowance, useUnstakeApprove, useUnstakingInfo, useUnstakingInfoWithPenalty, useUserFormattedSummary, useUserReservesData, useWithdraw, useWithdrawHubAsset, useXBalances };
-//# sourceMappingURL=index.mjs.map
-//# sourceMappingURL=index.mjs.map
+export { SodaxProvider, clearRadfiSession, createDecreaseLiquidityParamsProps, createDepositParamsProps, createSodaxQueryClient, createSupplyLiquidityParamsProps, createWithdrawParamsProps, getXBalancesQueryOptions, isTerminalSwapIntentStatus, isUserRejectedError, loadRadfiSession, resolveNearStorageGate, saveRadfiSession, toResult, unwrapResult, useAToken, useATokensBalances, useApproveToken, useBackendAllMoneyMarketAssets, useBackendAllMoneyMarketBorrowers, useBackendIntentByHash, useBackendIntentByTxHash, useBackendMoneyMarketAsset, useBackendMoneyMarketAssetBorrowers, useBackendMoneyMarketAssetSuppliers, useBackendMoneyMarketPosition, useBackendOrderbook, useBackendUserIntents, useBitcoinBalance, useBitcoinTradingSetup, useBorrow, useBridge, useBridgeAllowance, useBridgeApprove, useCancelLimitOrder, useCancelSwap, useCancelUnstake, useClaim, useClaimRewards, useConvertedAssets, useCreateDecreaseLiquidityParams, useCreateDepositParams, useCreateLimitOrder, useCreateSupplyLiquidityParams, useCreateWithdrawParams, useDecreaseLiquidity, useDeriveUserWalletAddress, useDexAllowance, useDexApprove, useDexDeposit, useDexWithdraw, useEnsureRadfiAccessToken, useEstimateGas, useExpiredUtxos, useFeeClaimSwap, useFeeClaimWithdraw, useFetchAssetsBalances, useFundTradingWallet, useGetAutoSwapPreferences, useGetBridgeableAmount, useGetBridgeableTokens, useGetIntentDetails, useGetUserHubWalletAddress, useGetUserIntent, useHubAssetBalances, useHubProvider, useInstantUnstake, useInstantUnstakeAllowance, useInstantUnstakeApprove, useInstantUnstakeRatio, useIsTokenApproved, useLeverageYieldDeposit, useLeverageYieldEffectiveApr, useLeverageYieldNotifySolver, useLeverageYieldPosition, useLeverageYieldPreviewRedeem, useLeverageYieldShareBalances, useLeverageYieldTotalAssets, useLeverageYieldVaultSwap, useLeverageYieldWithdraw, useLiquidityAmounts, useMMAllowance, useMMApprove, useMigrateBaln, useMigrateIcxToSoda, useMigratebnUSD, useMigrationAllowance, useMigrationApprove, useNearStorageCheck, useNearStorageGate, usePartnerCancelIntent, usePoolBalances, usePoolData, usePools, usePositionInfo, useQuote, useRadfiAuth, useRadfiSession, useRadfiWithdraw, useRegisterNearStorage, useRenewUtxos, useRepay, useRequestTrustline, useReservesData, useReservesHumanized, useReservesList, useReservesUsdFormat, useRevertMigrateSodaToIcx, useSafeMutation, useSetSwapPreference, useSodaxContext, useStake, useStakeAllowance, useStakeApprove, useStakeRatio, useStakingConfig, useStakingInfo, useStatus, useStellarTrustlineCheck, useSupply, useSupplyLiquidity, useSwap, useSwapAllowance, useSwapApprove, useSwapsApiAllowance, useSwapsApiApprove, useSwapsApiCancelIntent, useSwapsApiCreateIntent, useSwapsApiCreateLimitOrder, useSwapsApiDeadline, useSwapsApiEstimateGas, useSwapsApiFilledIntent, useSwapsApiIntent, useSwapsApiIntentExtraData, useSwapsApiIntentHash, useSwapsApiIntentPacket, useSwapsApiPartnerFee, useSwapsApiQuote, useSwapsApiSolverFee, useSwapsApiStatus, useSwapsApiSubmitIntent, useSwapsApiSubmitTx, useSwapsApiSubmitTxStatus, useSwapsApiTokens, useSwapsApiTokensByChain, useTradingWallet, useTradingWalletBalance, useUnstake, useUnstakeAllowance, useUnstakeApprove, useUnstakingInfo, useUnstakingInfoWithPenalty, useUserFormattedSummary, useUserReservesData, useWithdraw, useWithdrawHubAsset, useXBalances };