@sodax/dapp-kit 2.0.0-rc.18 → 2.0.0-rc.19

package/dist/index.mjs

@@ -507,6 +507,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
@@ -1075,51 +1088,6 @@ var useBackendUserIntents = ({
     ...queryOptions
   });
 };
-
-// src/hooks/backend/useBackendSubmitSwapTx.ts
-var useBackendSubmitSwapTx = ({
-  mutationOptions
-} = {}) => {
-  const { sodax } = useSodaxContext();
-  return useSafeMutation({
-    mutationKey: ["backend", "submitSwapTx"],
-    retry: 3,
-    ...mutationOptions,
-    mutationFn: async ({ request, apiConfig }) => unwrapResult(await sodax.backendApi.submitSwapTx(request, apiConfig))
-  });
-};
-var useBackendSubmitSwapTxStatus = ({
-  params,
-  queryOptions
-} = {}) => {
-  const { sodax } = useSodaxContext();
-  const txHash = params?.txHash;
-  const srcChainKey = params?.srcChainKey;
-  const apiConfig = params?.apiConfig;
-  return useQuery({
-    queryKey: ["backend", "submitSwapTx", "status", txHash, srcChainKey],
-    queryFn: async () => {
-      if (!txHash) return void 0;
-      return unwrapResult(
-        await sodax.backendApi.getSubmitSwapTxStatus(
-          {
-            txHash,
-            srcChainKey
-          },
-          apiConfig
-        )
-      );
-    },
-    enabled: !!txHash && txHash.length > 0,
-    retry: 3,
-    refetchInterval: (query) => {
-      const status = query.state.data?.data?.status;
-      if (status === "executed" || status === "failed") return false;
-      return 1e3;
-    },
-    ...queryOptions
-  });
-};
 var useBackendOrderbook = ({
   params,
   queryOptions
@@ -1261,6 +1229,362 @@ var useBackendAllMoneyMarketBorrowers = ({
     ...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/swapsApi/useSwapsApiApprove.ts
+var useSwapsApiApprove = ({
+  mutationOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  return useSafeMutation({
+    mutationKey: ["swapsApi", "approve"],
+    retry: 3,
+    ...mutationOptions,
+    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))
+  });
+};
+
+// 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 intentTxHash = params?.intentTxHash;
+  const apiConfig = params?.apiConfig;
+  return useQuery({
+    queryKey: ["swapsApi", "status", intentTxHash],
+    queryFn: async () => {
+      if (!intentTxHash) return void 0;
+      return unwrapResult(await sodax.api.swaps.getStatus({ intentTxHash }, apiConfig));
+    },
+    enabled: !!intentTxHash && intentTxHash.length > 0,
+    retry: 3,
+    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 useSwapsApiIntentPacket = ({
+  params,
+  queryOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  const body = params?.body;
+  const apiConfig = params?.apiConfig;
+  return useQuery({
+    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 (!body || !body.txHash && !body.intent) return void 0;
+      return unwrapResult(await sodax.api.swaps.getIntentSubmitTxExtraData(body, apiConfig));
+    },
+    enabled: !!body && (!!body.txHash || !!body.intent),
+    retry: 3,
+    ...queryOptions
+  });
+};
+var useSwapsApiFilledIntent = ({
+  params,
+  queryOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  const txHash = params?.txHash;
+  const apiConfig = params?.apiConfig;
+  return useQuery({
+    queryKey: ["swapsApi", "filledIntent", txHash],
+    queryFn: async () => {
+      if (!txHash) return void 0;
+      return unwrapResult(await sodax.api.swaps.getFilledIntent(txHash, apiConfig));
+    },
+    enabled: !!txHash && txHash.length > 0,
+    retry: 3,
+    ...queryOptions
+  });
+};
+var useSwapsApiIntent = ({
+  params,
+  queryOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  const txHash = params?.txHash;
+  const apiConfig = params?.apiConfig;
+  return useQuery({
+    queryKey: ["swapsApi", "intent", txHash],
+    queryFn: async () => {
+      if (!txHash) return void 0;
+      return unwrapResult(await sodax.api.swaps.getIntent(txHash, apiConfig));
+    },
+    enabled: !!txHash && txHash.length > 0,
+    retry: 3,
+    ...queryOptions
+  });
+};
+
+// 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 body = params?.body;
+  const apiConfig = params?.apiConfig;
+  return useQuery({
+    queryKey: ["swapsApi", "estimateGas", body?.chainKey, body?.tx],
+    queryFn: async () => {
+      if (!body) return void 0;
+      return unwrapResult(await sodax.api.swaps.estimateGas(body, apiConfig));
+    },
+    enabled: !!body,
+    retry: 3,
+    ...queryOptions
+  });
+};
+var useSwapsApiPartnerFee = ({
+  params,
+  queryOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  const amount = params?.amount;
+  const apiConfig = params?.apiConfig;
+  return useQuery({
+    queryKey: ["swapsApi", "partnerFee", amount],
+    queryFn: async () => {
+      if (!amount) return void 0;
+      return unwrapResult(await sodax.api.swaps.getPartnerFee({ amount }, apiConfig));
+    },
+    enabled: !!amount && amount.length > 0,
+    retry: 3,
+    ...queryOptions
+  });
+};
+var useSwapsApiSolverFee = ({
+  params,
+  queryOptions
+} = {}) => {
+  const { sodax } = useSodaxContext();
+  const amount = params?.amount;
+  const apiConfig = params?.apiConfig;
+  return useQuery({
+    queryKey: ["swapsApi", "solverFee", amount],
+    queryFn: async () => {
+      if (!amount) return void 0;
+      return unwrapResult(await sodax.api.swaps.getSolverFee({ amount }, apiConfig));
+    },
+    enabled: !!amount && amount.length > 0,
+    retry: 3,
+    ...queryOptions
+  });
+};
+
+// 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 txHash = params?.txHash;
+  const srcChainKey = params?.srcChainKey;
+  const apiConfig = params?.apiConfig;
+  return useQuery({
+    queryKey: ["swapsApi", "submitTx", "status", txHash, srcChainKey],
+    queryFn: async () => {
+      if (!txHash || !srcChainKey) return void 0;
+      return unwrapResult(await sodax.api.swaps.getSubmitTxStatus({ txHash, srcChainKey }, apiConfig));
+    },
+    enabled: !!txHash && txHash.length > 0 && !!srcChainKey,
+    retry: 3,
+    refetchInterval: (query) => {
+      const status = query.state.data?.data?.status;
+      if (status === "executed" || status === "failed") return false;
+      return 1e3;
+    },
+    ...queryOptions
+  });
+};
 function useBridge({
   mutationOptions
 } = {}) {
@@ -2885,4 +3209,4 @@ function createSodaxQueryClient({
   });
 }
 
-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, 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, useTradingWallet, useTradingWalletBalance, useUnstake, useUnstakeAllowance, useUnstakeApprove, useUnstakingInfo, useUnstakingInfoWithPenalty, useUserFormattedSummary, useUserReservesData, useWithdraw, useWithdrawHubAsset, useXBalances };
+export { SodaxProvider, clearRadfiSession, createDecreaseLiquidityParamsProps, createDepositParamsProps, createSodaxQueryClient, createSupplyLiquidityParamsProps, createWithdrawParamsProps, getXBalancesQueryOptions, isTerminalSwapIntentStatus, 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 };

package/package.json

@@ -5,7 +5,7 @@
     "access": "public"
   },
   "license": "MIT",
-  "version": "2.0.0-rc.18",
+  "version": "2.0.0-rc.19",
   "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.18"
+    "@sodax/sdk": "2.0.0-rc.19"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "0.17.4",

package/src/hooks/_mutationContract.test.ts

@@ -13,7 +13,6 @@ const HOOKS_DIR = resolve(fileURLToPath(import.meta.url), '..');
  * registration so the contract is enforced from day one.
  */
 const HOOKS: Array<{ path: string; nativeThrow?: true }> = [
-  { path: 'backend/useBackendSubmitSwapTx.ts' },
   { path: 'bitcoin/useEnsureRadfiAccessToken.ts', nativeThrow: true },
   { path: 'bitcoin/useFundTradingWallet.ts', nativeThrow: true },
   { path: 'bitcoin/useRadfiAuth.ts', nativeThrow: true },
@@ -62,6 +61,12 @@ const HOOKS: Array<{ path: string; nativeThrow?: true }> = [
   { path: 'swap/useCreateLimitOrder.ts' },
   { path: 'swap/useSwap.ts' },
   { path: 'swap/useSwapApprove.ts' },
+  { path: 'swapsApi/useSwapsApiApprove.ts' },
+  { path: 'swapsApi/useSwapsApiCancelIntent.ts' },
+  { path: 'swapsApi/useSwapsApiCreateIntent.ts' },
+  { path: 'swapsApi/useSwapsApiCreateLimitOrder.ts' },
+  { path: 'swapsApi/useSwapsApiSubmitIntent.ts' },
+  { path: 'swapsApi/useSwapsApiSubmitTx.ts' },
 ];
 
 describe.each(HOOKS)('mutation hook contract: $path', ({ path, nativeThrow }) => {

package/src/hooks/backend/index.ts

@@ -12,10 +12,6 @@ export { useBackendIntentByTxHash } from './useBackendIntentByTxHash.js';
 export { useBackendIntentByHash } from './useBackendIntentByHash.js';
 export { useBackendUserIntents } from './useBackendUserIntents.js';
 
-// Swap submit-tx hooks
-export { useBackendSubmitSwapTx } from './useBackendSubmitSwapTx.js';
-export { useBackendSubmitSwapTxStatus } from './useBackendSubmitSwapTxStatus.js';
-
 // Solver hooks
 export { useBackendOrderbook } from './useBackendOrderbook.js';
 
@@ -26,4 +22,4 @@ export { useBackendMoneyMarketAsset } from './useBackendMoneyMarketAsset.js';
 export { useBackendMoneyMarketAssetBorrowers } from './useBackendMoneyMarketAssetBorrowers.js';
 export { useBackendMoneyMarketAssetSuppliers } from './useBackendMoneyMarketAssetSuppliers.js';
 export { useBackendAllMoneyMarketBorrowers } from './useBackendAllMoneyMarketBorrowers.js';
-export * from './types.js';
+export * from './types.js';

package/src/hooks/bitcoin/index.ts

@@ -5,6 +5,7 @@ export * from './useFundTradingWallet.js';
 export * from './useBitcoinBalance.js';
 export * from './useTradingWallet.js';
 export * from './useTradingWalletBalance.js';
+export * from './useBitcoinTradingSetup.js';
 export * from './useExpiredUtxos.js';
 export * from './useRenewUtxos.js';
 export * from './useRadfiWithdraw.js';

package/src/hooks/bitcoin/useBitcoinTradingSetup.ts

@@ -0,0 +1,45 @@
+import {
+  ChainKeys,
+  type IBitcoinWalletProvider,
+  type IWalletProvider,
+  type RadfiWalletBalance,
+  type SpokeChainKey,
+} from '@sodax/sdk';
+import { useTradingWallet } from './useTradingWallet.js';
+import { useTradingWalletBalance } from './useTradingWalletBalance.js';
+
+export interface UseBitcoinTradingSetupParams {
+  chainKey: SpokeChainKey;
+  /** This side's wallet provider + account, e.g. `useWalletProvider` / `useXAccount`. */
+  walletProvider: IWalletProvider | undefined;
+  address: string | undefined;
+}
+
+export interface BitcoinTradingSetup {
+  wallet: IBitcoinWalletProvider | undefined;
+  tradingBalance: RadfiWalletBalance | undefined;
+}
+
+const INERT: BitcoinTradingSetup = { wallet: undefined, tradingBalance: undefined };
+
+/**
+ * Bitcoin trading-wallet setup for one side of a cross-chain flow: Bitcoin funds move through a
+ * Bound Exchange (Radfi) trading wallet, not the personal wallet. Inert (no work) unless `chainKey`
+ * is Bitcoin. Wallet-layer inputs are passed in — this package doesn't depend on wallet-sdk-react.
+ */
+export function useBitcoinTradingSetup({
+  chainKey,
+  walletProvider,
+  address,
+}: UseBitcoinTradingSetupParams): BitcoinTradingSetup {
+  const isBitcoin = chainKey === ChainKeys.BITCOIN_MAINNET;
+  // Safe: when this side is Bitcoin its provider IS the Bitcoin one (TS can't relate chainKey to provider type).
+  const wallet = isBitcoin ? (walletProvider as IBitcoinWalletProvider | undefined) : undefined;
+
+  // Hooks run every render; undefined inputs keep the Bound balance query disabled when not Bitcoin.
+  const { tradingAddress } = useTradingWallet(isBitcoin ? address : undefined);
+  const { data: tradingBalance } = useTradingWalletBalance({ params: { walletProvider: wallet, tradingAddress } });
+
+  if (!isBitcoin) return INERT;
+  return { wallet, tradingBalance };
+}

package/src/hooks/index.ts

@@ -4,6 +4,7 @@ export * from './bitcoin/index.js';
 export * from './mm/index.js';
 export * from './swap/index.js';
 export * from './backend/index.js';
+export * from './swapsApi/index.js';
 export * from './bridge/index.js';
 export * from './staking/index.js';
 export * from './partner/index.js';

package/src/hooks/swapsApi/index.ts

@@ -0,0 +1,41 @@
+/**
+ * Swaps API v2 hooks — typed React Query wrappers over `sodax.api.swaps.*` (the SwapsApiService
+ * HTTP client). One hook per endpoint of the backend Swaps API v2.
+ *
+ * Distinct from the on-chain `swap/` hooks (`useQuote`/`useStatus`/`useSwap`/…), which drive the
+ * `SwapService` path (wallet → hub chain). These hooks call the backend HTTP API instead.
+ */
+
+// Tokens
+export * from './useSwapsApiTokens.js';
+export * from './useSwapsApiTokensByChain.js';
+
+// Quote · deadline
+export * from './useSwapsApiQuote.js';
+export * from './useSwapsApiDeadline.js';
+
+// Allowance · approve · create intent
+export * from './useSwapsApiAllowance.js';
+export * from './useSwapsApiApprove.js';
+export * from './useSwapsApiCreateIntent.js';
+
+// Intent lifecycle: submit · status · cancel · hash · packet · extra-data · lookup
+export * from './useSwapsApiSubmitIntent.js';
+export * from './useSwapsApiStatus.js';
+export * from './isTerminalSwapIntentStatus.js'; // terminal-status predicate (drives the status hook's polling)
+export * from './useSwapsApiCancelIntent.js';
+export * from './useSwapsApiIntentHash.js';
+export * from './useSwapsApiIntentPacket.js';
+export * from './useSwapsApiIntentExtraData.js';
+export * from './useSwapsApiFilledIntent.js';
+export * from './useSwapsApiIntent.js';
+
+// Limit orders · gas · fees
+export * from './useSwapsApiCreateLimitOrder.js';
+export * from './useSwapsApiEstimateGas.js';
+export * from './useSwapsApiPartnerFee.js';
+export * from './useSwapsApiSolverFee.js';
+
+// Submit-tx state machine
+export * from './useSwapsApiSubmitTx.js';
+export * from './useSwapsApiSubmitTxStatus.js';

package/src/hooks/swapsApi/isTerminalSwapIntentStatus.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import { isTerminalSwapIntentStatus } from './isTerminalSwapIntentStatus.js';
+
+/**
+ * Guards the polling-stop invariant for `useSwapsApiStatus.refetchInterval`: the hook keeps polling
+ * (1s) until the solver reports a terminal status, then stops. Tested as a pure predicate because
+ * dapp-kit's vitest runs in the `node` environment (no hook rendering) — see nearStorageGate.test.ts.
+ */
+describe('isTerminalSwapIntentStatus', () => {
+  it('is terminal for SOLVED (3) and FAILED (4)', () => {
+    expect(isTerminalSwapIntentStatus(3)).toBe(true);
+    expect(isTerminalSwapIntentStatus(4)).toBe(true);
+  });
+
+  it('is non-terminal for NOT_FOUND (-1), NOT_STARTED_YET (1), and STARTED_NOT_FINISHED (2)', () => {
+    expect(isTerminalSwapIntentStatus(-1)).toBe(false);
+    expect(isTerminalSwapIntentStatus(1)).toBe(false);
+    expect(isTerminalSwapIntentStatus(2)).toBe(false);
+  });
+
+  it('is non-terminal when no status has arrived yet (undefined) — keeps polling', () => {
+    expect(isTerminalSwapIntentStatus(undefined)).toBe(false);
+  });
+});

package/src/hooks/swapsApi/isTerminalSwapIntentStatus.ts

@@ -0,0 +1,11 @@
+import type { SwapIntentStatusCodeV2 } from '@sodax/sdk';
+
+/**
+ * Terminal solver intent states: once reached, the intent is resolved and polling stops.
+ * `3` = SOLVED, `4` = FAILED (per `SwapIntentStatusCodeV2`); `-1` / `1` / `2` are non-terminal.
+ *
+ * Kept in its own pure module (no React/context imports) so it is unit-testable in dapp-kit's
+ * `node` test environment — importing the hook itself pulls in `useSodaxContext`.
+ */
+export const isTerminalSwapIntentStatus = (status: SwapIntentStatusCodeV2 | undefined): boolean =>
+  status === 3 || status === 4;