@sodax/dapp-kit 2.0.0-rc.11 → 2.0.0-rc.13

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { useMutation, useQuery, useQueryClient, QueryClient, MutationCache } from '@tanstack/react-query';
+import { useMutation, useQuery, useQueryClient, useQueries, 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';
 export * from '@sodax/sdk';
@@ -140,59 +140,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 +271,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 +279,71 @@ 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;
+}
 var REFRESH_INTERVAL = 5 * 60 * 1e3;
 function useRadfiSession(walletProvider) {
   const { sodax } = useSodaxContext();
@@ -432,7 +514,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 +542,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 +663,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 +792,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 +830,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)
@@ -2482,6 +2573,158 @@ 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 sodax = useMemo(() => new Sodax(config), [config]);
   const contextValue = useMemo(() => ({ sodax }), [sodax]);
@@ -2513,4 +2756,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 };
+export { SodaxProvider, clearRadfiSession, createDecreaseLiquidityParamsProps, createDepositParamsProps, createSodaxQueryClient, createSupplyLiquidityParamsProps, createWithdrawParamsProps, getXBalancesQueryOptions, loadRadfiSession, resolveNearStorageGate, 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, useLeverageYieldDeposit, useLeverageYieldEffectiveApr, useLeverageYieldNotifySolver, useLeverageYieldPosition, useLeverageYieldPreviewRedeem, useLeverageYieldShareBalances, useLeverageYieldTotalAssets, useLeverageYieldVaultSwap, useLeverageYieldWithdraw, useLiquidityAmounts, useMMAllowance, useMMApprove, useMigrateBaln, useMigrateIcxToSoda, useMigratebnUSD, useMigrationAllowance, useMigrationApprove, useNearStorageCheck, useNearStorageGate, 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, useTradingWallet, useTradingWalletBalance, useUnstake, useUnstakeAllowance, useUnstakeApprove, useUnstakingInfo, useUnstakingInfoWithPenalty, useUserFormattedSummary, useUserReservesData, useWithdraw, useWithdrawHubAsset, useXBalances };

package/package.json

@@ -5,7 +5,7 @@
     "access": "public"
   },
   "license": "MIT",
-  "version": "2.0.0-rc.11",
+  "version": "2.0.0-rc.13",
   "description": "React hooks for building dApps on the SODAX cross-chain DeFi platform",
   "keywords": [
     "sodax",
@@ -34,7 +34,7 @@
   },
   "dependencies": {
     "viem": "2.29.2",
-    "@sodax/sdk": "2.0.0-rc.11"
+    "@sodax/sdk": "2.0.0-rc.13"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "0.17.4",

package/src/hooks/_mutationContract.test.ts

@@ -7,7 +7,7 @@ const HOOKS_DIR = resolve(fileURLToPath(import.meta.url), '..');
 
 /**
  * Manifest of every mutation hook. `nativeThrow: true` marks hooks whose underlying SDK methods
- * throw natively (Radfi APIs) and so don't need `unwrapResult`.
+ * throw natively (Bound Exchange APIs) and so don't need `unwrapResult`.
  *
  * To add a new mutation hook, add its path here. The friction is intentional — it forces explicit
  * registration so the contract is enforced from day one.
@@ -26,6 +26,10 @@ const HOOKS: Array<{ path: string; nativeThrow?: true }> = [
   { path: 'dex/useDexDeposit.ts' },
   { path: 'dex/useDexWithdraw.ts' },
   { path: 'dex/useSupplyLiquidity.ts' },
+  { path: 'leverageYield/useLeverageYieldDeposit.ts' },
+  { path: 'leverageYield/useLeverageYieldNotifySolver.ts' },
+  { path: 'leverageYield/useLeverageYieldVaultSwap.ts' },
+  { path: 'leverageYield/useLeverageYieldWithdraw.ts' },
   { path: 'migrate/useMigrateBaln.ts' },
   { path: 'migrate/useMigrateIcxToSoda.ts' },
   { path: 'migrate/useMigratebnUSD.ts' },
@@ -41,6 +45,7 @@ const HOOKS: Array<{ path: string; nativeThrow?: true }> = [
   { path: 'partner/useSetSwapPreference.ts' },
   { path: 'recovery/useWithdrawHubAsset.ts' },
   { path: 'shared/useEstimateGas.ts' },
+  { path: 'shared/useRegisterNearStorage.ts', nativeThrow: true },
   { path: 'staking/useCancelUnstake.ts' },
   { path: 'staking/useClaim.ts' },
   { path: 'staking/useInstantUnstake.ts' },

package/src/hooks/bitcoin/resolveBtcReadAddress.test.ts

@@ -0,0 +1,54 @@
+import { ChainKeys } from '@sodax/sdk';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { RadfiSession } from './useRadfiAuth.js';
+import { loadRadfiSession } from './useRadfiAuth.js';
+import { resolveBtcReadAddress } from './resolveBtcReadAddress.js';
+
+// resolveBtcReadAddress reads the Bound Exchange session via loadRadfiSession (localStorage-backed).
+// The dapp-kit test env is `node` (no localStorage), so mock the session lookup to drive each branch.
+vi.mock('./useRadfiAuth.js', () => ({
+  loadRadfiSession: vi.fn(),
+}));
+
+const mockLoadRadfiSession = vi.mocked(loadRadfiSession);
+
+const PERSONAL_ADDRESS = 'bc1qpersonal00000000000000000000000000000';
+const TRADING_ADDRESS = 'bc1qtrading000000000000000000000000000000';
+
+const session = (tradingAddress: string): RadfiSession => ({
+  accessToken: 'access',
+  refreshToken: 'refresh',
+  tradingAddress,
+  publicKey: 'pub',
+});
+
+describe('resolveBtcReadAddress', () => {
+  beforeEach(() => {
+    mockLoadRadfiSession.mockReset();
+  });
+
+  it('passes the address through unchanged for non-Bitcoin chains (no session lookup)', () => {
+    const result = resolveBtcReadAddress(ChainKeys.ARBITRUM_MAINNET, PERSONAL_ADDRESS);
+
+    expect(result).toBe(PERSONAL_ADDRESS);
+    expect(mockLoadRadfiSession).not.toHaveBeenCalled();
+  });
+
+  it('returns the trading address from the local session for Bitcoin', () => {
+    mockLoadRadfiSession.mockReturnValue(session(TRADING_ADDRESS));
+
+    const result = resolveBtcReadAddress(ChainKeys.BITCOIN_MAINNET, PERSONAL_ADDRESS);
+
+    expect(result).toBe(TRADING_ADDRESS);
+    // The session is keyed by the personal address.
+    expect(mockLoadRadfiSession).toHaveBeenCalledWith(PERSONAL_ADDRESS);
+  });
+
+  it('falls back to the personal address for Bitcoin when there is no session', () => {
+    mockLoadRadfiSession.mockReturnValue(null);
+
+    const result = resolveBtcReadAddress(ChainKeys.BITCOIN_MAINNET, PERSONAL_ADDRESS);
+
+    expect(result).toBe(PERSONAL_ADDRESS);
+  });
+});

package/src/hooks/bitcoin/resolveBtcReadAddress.ts

@@ -0,0 +1,21 @@
+import { ChainKeys, type SpokeChainKey } from '@sodax/sdk';
+import { loadRadfiSession } from './useRadfiAuth.js';
+
+/**
+ * Resolve a spoke address for READ queries (positions, balances, hub-wallet display).
+ *
+ * Bitcoin positions live under the Bound Exchange trading-wallet-derived hub wallet, so for Bitcoin we
+ * resolve to the trading address from the locally-persisted Bound Exchange session. This is intentionally
+ * a LOCAL lookup (no network call): a transient Bound Exchange API outage can never make a real position
+ * read as empty, and reads never throw "Trading wallet not found". When there is no session, the
+ * user has no Bitcoin position to show, so the original (personal) address is returned — deriving
+ * an empty hub wallet, which is correct. Non-Bitcoin chains pass through unchanged.
+ *
+ * The WRITE path resolves the trading address authoritatively in the SDK
+ * (`getEffectiveWalletAddress`, called from the money-market create*Intent flows); reads
+ * deliberately use this lighter, fail-safe path.
+ */
+export function resolveBtcReadAddress(chainKey: SpokeChainKey, address: string): string {
+  if (chainKey !== ChainKeys.BITCOIN_MAINNET) return address;
+  return loadRadfiSession(address)?.tradingAddress ?? address;
+}

package/src/hooks/bitcoin/useFundTradingWallet.ts

@@ -11,7 +11,7 @@ export type UseFundTradingWalletVars = {
 };
 
 /**
- * React hook for funding the user's Radfi trading wallet from their personal Bitcoin wallet.
+ * React hook for funding the user's Bound Exchange trading wallet from their personal Bitcoin wallet.
  * Pure mutation: pass `{ amount, walletProvider }` to `mutate({...})`. Returns the broadcast tx
  * id on success.
  */

package/src/hooks/bitcoin/useRadfiAuth.ts

@@ -45,7 +45,7 @@ export function clearRadfiSession(address: string): void {
 }
 
 /**
- * React hook for authenticating with Radfi via BIP322-signed message. Pure mutation: pass
+ * React hook for authenticating with Bound Exchange via BIP322-signed message. Pure mutation: pass
  * `{ walletProvider }` to `mutate({...})`. The hook itself takes no arguments other than the
  * structural `mutationOptions` slot.
  */
@@ -95,7 +95,7 @@ export function useRadfiAuth({
           }
 
           throw new Error(
-            'This wallet is already registered with Radfi from another session. ' +
+            '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.',
           );

package/src/hooks/bitcoin/useRadfiWithdraw.ts

@@ -19,7 +19,7 @@ type WithdrawResult = {
 };
 
 /**
- * React hook for withdrawing BTC from the user's Radfi trading wallet back to their personal
+ * React hook for withdrawing BTC from the user's Bound Exchange trading wallet back to their personal
  * Bitcoin wallet. Pure mutation: pass all inputs (including the wallet provider) to
  * `mutate({...})`.
  */
@@ -44,7 +44,7 @@ export function useRadfiWithdraw({
       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);

package/src/hooks/bitcoin/useRenewUtxos.ts

@@ -12,7 +12,7 @@ export type UseRenewUtxosVars = {
 };
 
 /**
- * React hook for renewing expired UTXOs in the user's Radfi trading wallet. Pure mutation: pass
+ * React hook for renewing expired UTXOs in the user's Bound Exchange trading wallet. Pure mutation: pass
  * `{ txIdVouts, walletProvider }` to `mutate({...})`.
  */
 export function useRenewUtxos({
@@ -32,7 +32,7 @@ export function useRenewUtxos({
       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);

package/src/hooks/bitcoin/useTradingWallet.ts

@@ -5,7 +5,7 @@ type UseTradingWalletReturn = {
 };
 
 /**
- * Returns the Radfi trading wallet address from the persisted session.
+ * Returns the Bound Exchange 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 {

package/src/hooks/index.ts

@@ -10,3 +10,4 @@ export * from './partner/index.js';
 export * from './recovery/index.js';
 export * from './migrate/index.js';
 export * from './dex/index.js';
+export * from './leverageYield/index.js';

package/src/hooks/leverageYield/index.ts

@@ -0,0 +1,9 @@
+export * from './useLeverageYieldEffectiveApr.js';
+export * from './useLeverageYieldPosition.js';
+export * from './useLeverageYieldTotalAssets.js';
+export * from './useLeverageYieldPreviewRedeem.js';
+export * from './useLeverageYieldShareBalances.js';
+export * from './useLeverageYieldDeposit.js';
+export * from './useLeverageYieldNotifySolver.js';
+export * from './useLeverageYieldVaultSwap.js';
+export * from './useLeverageYieldWithdraw.js';