@sodax/dapp-kit 2.0.0-rc.17 → 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
 } = {}) {
@@ -1883,6 +2207,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
@@ -2784,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, 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 };
+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.17",
+  "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.17"
+    "@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 },
@@ -43,6 +42,8 @@ const HOOKS: Array<{ path: string; nativeThrow?: true }> = [
   { path: 'mm/useWithdraw.ts' },
   { path: 'partner/useApproveToken.ts' },
   { path: 'partner/useFeeClaimSwap.ts' },
+  { path: 'partner/useFeeClaimWithdraw.ts' },
+  { path: 'partner/usePartnerCancelIntent.ts' },
   { path: 'partner/useSetSwapPreference.ts' },
   { path: 'recovery/useWithdrawHubAsset.ts' },
   { path: 'shared/useEstimateGas.ts' },
@@ -60,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/partner/index.ts

@@ -4,3 +4,7 @@ export * from './useIsTokenApproved.js';
 export * from './useApproveToken.js';
 export * from './useSetSwapPreference.js';
 export * from './useFeeClaimSwap.js';
+export * from './usePartnerCancelIntent.js';
+export * from './useGetUserIntent.js';
+export * from './useGetIntentDetails.js';
+export * from './useFeeClaimWithdraw.js';