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

package/src/hooks/swapsApi/useSwapsApiAllowance.ts

@@ -0,0 +1,40 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { AllowanceCheckResponseV2, CreateIntentParamsV2, RequestOverrideConfig } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
+import type { ReadHookParams } from '../shared/types.js';
+
+export type UseSwapsApiAllowanceParams = ReadHookParams<
+  AllowanceCheckResponseV2 | undefined,
+  {
+    body: CreateIntentParamsV2 | undefined;
+    apiConfig?: RequestOverrideConfig;
+  }
+>;
+
+/**
+ * React hook to check whether the source-token allowance is already sufficient for an intent via
+ * the swaps API — `sodax.api.swaps.checkAllowance`. Returns `{ valid }`.
+ *
+ * @example
+ * const { data: allowance } = useSwapsApiAllowance({ params: { body: createIntentParams } });
+ */
+export const useSwapsApiAllowance = ({
+  params,
+  queryOptions,
+}: UseSwapsApiAllowanceParams = {}): UseQueryResult<AllowanceCheckResponseV2 | undefined, Error> => {
+  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 (): Promise<AllowanceCheckResponseV2 | undefined> => {
+      if (!body) return undefined;
+      return unwrapResult(await sodax.api.swaps.checkAllowance(body, apiConfig));
+    },
+    enabled: !!body,
+    retry: 3,
+    ...queryOptions,
+  });
+};

package/src/hooks/swapsApi/useSwapsApiApprove.ts

@@ -0,0 +1,42 @@
+import type { ApproveResponseV2, CreateIntentParamsV2, RequestOverrideConfig } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
+import type { MutationHookParams } from '../shared/types.js';
+import { useSafeMutation, type SafeUseMutationResult } from '../shared/useSafeMutation.js';
+
+/**
+ * Mutation variables for {@link useSwapsApiApprove}. The per-request `apiConfig` override belongs
+ * here rather than at the hook level — different calls in the same component can target different
+ * endpoints without re-rendering.
+ */
+export type UseSwapsApiApproveVars = {
+  body: CreateIntentParamsV2;
+  apiConfig?: RequestOverrideConfig;
+};
+
+/**
+ * React hook to build an unsigned token-approval transaction for the source token via the swaps
+ * API — `sodax.api.swaps.approve`. Returns `{ tx }` (chain-specific unsigned tx) to sign and
+ * broadcast yourself; it does not change state, so no queries are invalidated.
+ *
+ * @example
+ * const { mutateAsync: approve } = useSwapsApiApprove();
+ * const { tx } = await approve({ body: createIntentParams });
+ */
+export const useSwapsApiApprove = ({
+  mutationOptions,
+}: MutationHookParams<ApproveResponseV2, UseSwapsApiApproveVars> = {}): SafeUseMutationResult<
+  ApproveResponseV2,
+  Error,
+  UseSwapsApiApproveVars
+> => {
+  const { sodax } = useSodaxContext();
+
+  return useSafeMutation<ApproveResponseV2, Error, UseSwapsApiApproveVars>({
+    mutationKey: ['swapsApi', 'approve'],
+    retry: 3,
+    ...mutationOptions,
+    mutationFn: async ({ body, apiConfig }): Promise<ApproveResponseV2> =>
+      unwrapResult(await sodax.api.swaps.approve(body, apiConfig)),
+  });
+};

package/src/hooks/swapsApi/useSwapsApiCancelIntent.ts

@@ -0,0 +1,41 @@
+import type { CancelIntentRequestV2, CancelIntentResponseV2, RequestOverrideConfig } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
+import type { MutationHookParams } from '../shared/types.js';
+import { useSafeMutation, type SafeUseMutationResult } from '../shared/useSafeMutation.js';
+
+/**
+ * Mutation variables for {@link useSwapsApiCancelIntent}. The per-request `apiConfig` override
+ * belongs here rather than at the hook level.
+ */
+export type UseSwapsApiCancelIntentVars = {
+  body: CancelIntentRequestV2;
+  apiConfig?: RequestOverrideConfig;
+};
+
+/**
+ * React hook to build an unsigned cancel-intent transaction via the swaps API —
+ * `sodax.api.swaps.cancelIntent`. The `intent` carries `bigint` numerics. Returns `{ tx }` to sign
+ * and broadcast yourself; it does not change state, so no queries are invalidated.
+ *
+ * @example
+ * const { mutateAsync: cancelIntent } = useSwapsApiCancelIntent();
+ * const { tx } = await cancelIntent({ body: { srcChainKey: 'sonic', intent } });
+ */
+export const useSwapsApiCancelIntent = ({
+  mutationOptions,
+}: MutationHookParams<CancelIntentResponseV2, UseSwapsApiCancelIntentVars> = {}): SafeUseMutationResult<
+  CancelIntentResponseV2,
+  Error,
+  UseSwapsApiCancelIntentVars
+> => {
+  const { sodax } = useSodaxContext();
+
+  return useSafeMutation<CancelIntentResponseV2, Error, UseSwapsApiCancelIntentVars>({
+    mutationKey: ['swapsApi', 'cancelIntent'],
+    retry: 3,
+    ...mutationOptions,
+    mutationFn: async ({ body, apiConfig }): Promise<CancelIntentResponseV2> =>
+      unwrapResult(await sodax.api.swaps.cancelIntent(body, apiConfig)),
+  });
+};

package/src/hooks/swapsApi/useSwapsApiCreateIntent.ts

@@ -0,0 +1,41 @@
+import type { CreateIntentParamsV2, CreateIntentResponseV2, RequestOverrideConfig } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
+import type { MutationHookParams } from '../shared/types.js';
+import { useSafeMutation, type SafeUseMutationResult } from '../shared/useSafeMutation.js';
+
+/**
+ * Mutation variables for {@link useSwapsApiCreateIntent}. The per-request `apiConfig` override
+ * belongs here rather than at the hook level.
+ */
+export type UseSwapsApiCreateIntentVars = {
+  body: CreateIntentParamsV2;
+  apiConfig?: RequestOverrideConfig;
+};
+
+/**
+ * React hook to build an unsigned create-intent transaction via the swaps API —
+ * `sodax.api.swaps.createIntent`. Returns `{ tx, intent, relayData }` to sign and broadcast
+ * yourself; it does not change state, so no queries are invalidated.
+ *
+ * @example
+ * const { mutateAsync: createIntent } = useSwapsApiCreateIntent();
+ * const { tx, intent, relayData } = await createIntent({ body: createIntentParams });
+ */
+export const useSwapsApiCreateIntent = ({
+  mutationOptions,
+}: MutationHookParams<CreateIntentResponseV2, UseSwapsApiCreateIntentVars> = {}): SafeUseMutationResult<
+  CreateIntentResponseV2,
+  Error,
+  UseSwapsApiCreateIntentVars
+> => {
+  const { sodax } = useSodaxContext();
+
+  return useSafeMutation<CreateIntentResponseV2, Error, UseSwapsApiCreateIntentVars>({
+    mutationKey: ['swapsApi', 'createIntent'],
+    retry: 3,
+    ...mutationOptions,
+    mutationFn: async ({ body, apiConfig }): Promise<CreateIntentResponseV2> =>
+      unwrapResult(await sodax.api.swaps.createIntent(body, apiConfig)),
+  });
+};

package/src/hooks/swapsApi/useSwapsApiCreateLimitOrder.ts

@@ -0,0 +1,41 @@
+import type { CreateLimitOrderParamsV2, CreateLimitOrderResponseV2, RequestOverrideConfig } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
+import type { MutationHookParams } from '../shared/types.js';
+import { useSafeMutation, type SafeUseMutationResult } from '../shared/useSafeMutation.js';
+
+/**
+ * Mutation variables for {@link useSwapsApiCreateLimitOrder}. The per-request `apiConfig` override
+ * belongs here rather than at the hook level.
+ */
+export type UseSwapsApiCreateLimitOrderVars = {
+  body: CreateLimitOrderParamsV2;
+  apiConfig?: RequestOverrideConfig;
+};
+
+/**
+ * React hook to build an unsigned create-limit-order-intent transaction via the swaps API —
+ * `sodax.api.swaps.createLimitOrderIntent` (same as create-intent but `deadline` is optional).
+ * Returns `{ tx, intent, relayData }`; it does not change state, so no queries are invalidated.
+ *
+ * @example
+ * const { mutateAsync: createLimitOrder } = useSwapsApiCreateLimitOrder();
+ * const { tx, intent, relayData } = await createLimitOrder({ body: createLimitOrderParams });
+ */
+export const useSwapsApiCreateLimitOrder = ({
+  mutationOptions,
+}: MutationHookParams<CreateLimitOrderResponseV2, UseSwapsApiCreateLimitOrderVars> = {}): SafeUseMutationResult<
+  CreateLimitOrderResponseV2,
+  Error,
+  UseSwapsApiCreateLimitOrderVars
+> => {
+  const { sodax } = useSodaxContext();
+
+  return useSafeMutation<CreateLimitOrderResponseV2, Error, UseSwapsApiCreateLimitOrderVars>({
+    mutationKey: ['swapsApi', 'createLimitOrder'],
+    retry: 3,
+    ...mutationOptions,
+    mutationFn: async ({ body, apiConfig }): Promise<CreateLimitOrderResponseV2> =>
+      unwrapResult(await sodax.api.swaps.createLimitOrderIntent(body, apiConfig)),
+  });
+};

package/src/hooks/swapsApi/useSwapsApiDeadline.ts

@@ -0,0 +1,36 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { DeadlineQueryV2, DeadlineResponseV2, RequestOverrideConfig } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
+import type { ReadHookParams } from '../shared/types.js';
+
+export type UseSwapsApiDeadlineParams = ReadHookParams<
+  DeadlineResponseV2,
+  {
+    query?: DeadlineQueryV2;
+    apiConfig?: RequestOverrideConfig;
+  }
+>;
+
+/**
+ * React hook to compute a swap deadline (hub timestamp + `offsetSeconds`, default 300s) via the
+ * swaps API — `sodax.api.swaps.getDeadline`.
+ *
+ * @example
+ * const { data: deadline } = useSwapsApiDeadline({ params: { query: { offsetSeconds: 600 } } });
+ */
+export const useSwapsApiDeadline = ({
+  params,
+  queryOptions,
+}: UseSwapsApiDeadlineParams = {}): UseQueryResult<DeadlineResponseV2, Error> => {
+  const { sodax } = useSodaxContext();
+  const query = params?.query;
+  const apiConfig = params?.apiConfig;
+
+  return useQuery<DeadlineResponseV2, Error>({
+    queryKey: ['swapsApi', 'deadline', query?.offsetSeconds ?? null],
+    queryFn: async (): Promise<DeadlineResponseV2> => unwrapResult(await sodax.api.swaps.getDeadline(query, apiConfig)),
+    retry: 3,
+    ...queryOptions,
+  });
+};

package/src/hooks/swapsApi/useSwapsApiEstimateGas.ts

@@ -0,0 +1,40 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { GasEstimateRequestV2, GasEstimateResponseV2, RequestOverrideConfig } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
+import type { ReadHookParams } from '../shared/types.js';
+
+export type UseSwapsApiEstimateGasParams = ReadHookParams<
+  GasEstimateResponseV2 | undefined,
+  {
+    body: GasEstimateRequestV2 | undefined;
+    apiConfig?: RequestOverrideConfig;
+  }
+>;
+
+/**
+ * React hook to estimate gas for a raw transaction on a spoke chain via the swaps API —
+ * `sodax.api.swaps.estimateGas`. Returns `{ gas }` (chain-specific shape).
+ *
+ * @example
+ * const { data } = useSwapsApiEstimateGas({ params: { body: { chainKey: 'sonic', tx } } });
+ */
+export const useSwapsApiEstimateGas = ({
+  params,
+  queryOptions,
+}: UseSwapsApiEstimateGasParams = {}): UseQueryResult<GasEstimateResponseV2 | undefined, Error> => {
+  const { sodax } = useSodaxContext();
+  const body = params?.body;
+  const apiConfig = params?.apiConfig;
+
+  return useQuery({
+    queryKey: ['swapsApi', 'estimateGas', body?.chainKey, body?.tx],
+    queryFn: async (): Promise<GasEstimateResponseV2 | undefined> => {
+      if (!body) return undefined;
+      return unwrapResult(await sodax.api.swaps.estimateGas(body, apiConfig));
+    },
+    enabled: !!body,
+    retry: 3,
+    ...queryOptions,
+  });
+};

package/src/hooks/swapsApi/useSwapsApiFilledIntent.ts

@@ -0,0 +1,41 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { IntentStateV2, RequestOverrideConfig } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
+import type { ReadHookParams } from '../shared/types.js';
+
+export type UseSwapsApiFilledIntentParams = ReadHookParams<
+  IntentStateV2 | undefined,
+  {
+    txHash: string | undefined;
+    apiConfig?: RequestOverrideConfig;
+  }
+>;
+
+/**
+ * React hook to get the on-chain fill state for an intent by its hub-chain tx hash via the swaps
+ * API — `sodax.api.swaps.getFilledIntent`. Returns
+ * `{ exists, remainingInput, receivedOutput, pendingPayment }`.
+ *
+ * @example
+ * const { data: fill } = useSwapsApiFilledIntent({ params: { txHash: '0x123...' } });
+ */
+export const useSwapsApiFilledIntent = ({
+  params,
+  queryOptions,
+}: UseSwapsApiFilledIntentParams = {}): UseQueryResult<IntentStateV2 | undefined, Error> => {
+  const { sodax } = useSodaxContext();
+  const txHash = params?.txHash;
+  const apiConfig = params?.apiConfig;
+
+  return useQuery({
+    queryKey: ['swapsApi', 'filledIntent', txHash],
+    queryFn: async (): Promise<IntentStateV2 | undefined> => {
+      if (!txHash) return undefined;
+      return unwrapResult(await sodax.api.swaps.getFilledIntent(txHash, apiConfig));
+    },
+    enabled: !!txHash && txHash.length > 0,
+    retry: 3,
+    ...queryOptions,
+  });
+};

package/src/hooks/swapsApi/useSwapsApiIntent.ts

@@ -0,0 +1,40 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { GetIntentResponseV2, RequestOverrideConfig } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
+import type { ReadHookParams } from '../shared/types.js';
+
+export type UseSwapsApiIntentParams = ReadHookParams<
+  GetIntentResponseV2 | undefined,
+  {
+    txHash: string | undefined;
+    apiConfig?: RequestOverrideConfig;
+  }
+>;
+
+/**
+ * React hook to look up an Intent struct by its hub-chain creation tx hash via the swaps API —
+ * `sodax.api.swaps.getIntent`. The decoded intent's bigint fields are returned as decimal strings.
+ *
+ * @example
+ * const { data: intent } = useSwapsApiIntent({ params: { txHash: '0x123...' } });
+ */
+export const useSwapsApiIntent = ({
+  params,
+  queryOptions,
+}: UseSwapsApiIntentParams = {}): UseQueryResult<GetIntentResponseV2 | undefined, Error> => {
+  const { sodax } = useSodaxContext();
+  const txHash = params?.txHash;
+  const apiConfig = params?.apiConfig;
+
+  return useQuery({
+    queryKey: ['swapsApi', 'intent', txHash],
+    queryFn: async (): Promise<GetIntentResponseV2 | undefined> => {
+      if (!txHash) return undefined;
+      return unwrapResult(await sodax.api.swaps.getIntent(txHash, apiConfig));
+    },
+    enabled: !!txHash && txHash.length > 0,
+    retry: 3,
+    ...queryOptions,
+  });
+};

package/src/hooks/swapsApi/useSwapsApiIntentExtraData.ts

@@ -0,0 +1,41 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { IntentExtraDataRequestV2, IntentExtraDataResponseV2, RequestOverrideConfig } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
+import type { ReadHookParams } from '../shared/types.js';
+
+export type UseSwapsApiIntentExtraDataParams = ReadHookParams<
+  IntentExtraDataResponseV2 | undefined,
+  {
+    body: IntentExtraDataRequestV2 | undefined;
+    apiConfig?: RequestOverrideConfig;
+  }
+>;
+
+/**
+ * React hook to recover the relay extra data needed by `/swaps/intents/submit` via the swaps API —
+ * `sodax.api.swaps.getIntentSubmitTxExtraData`. Provide EITHER `txHash` OR `intent` in the body
+ * (whose `bigint` numerics are serialized by the SDK). Returns `{ address, payload }`.
+ *
+ * @example
+ * const { data } = useSwapsApiIntentExtraData({ params: { body: { txHash: '0x123...' } } });
+ */
+export const useSwapsApiIntentExtraData = ({
+  params,
+  queryOptions,
+}: UseSwapsApiIntentExtraDataParams = {}): UseQueryResult<IntentExtraDataResponseV2 | undefined, Error> => {
+  const { sodax } = useSodaxContext();
+  const body = params?.body;
+  const apiConfig = params?.apiConfig;
+
+  return useQuery({
+    queryKey: ['swapsApi', 'intentExtraData', body?.txHash ?? body?.intent?.intentId?.toString()],
+    queryFn: async (): Promise<IntentExtraDataResponseV2 | undefined> => {
+      if (!body || (!body.txHash && !body.intent)) return undefined;
+      return unwrapResult(await sodax.api.swaps.getIntentSubmitTxExtraData(body, apiConfig));
+    },
+    enabled: !!body && (!!body.txHash || !!body.intent),
+    retry: 3,
+    ...queryOptions,
+  });
+};

package/src/hooks/swapsApi/useSwapsApiIntentHash.ts

@@ -0,0 +1,40 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { IntentHashResponseV2, IntentRequestV2, RequestOverrideConfig } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
+import type { ReadHookParams } from '../shared/types.js';
+
+export type UseSwapsApiIntentHashParams = ReadHookParams<
+  IntentHashResponseV2 | undefined,
+  {
+    intent: IntentRequestV2 | undefined;
+    apiConfig?: RequestOverrideConfig;
+  }
+>;
+
+/**
+ * React hook to compute the keccak256 hash of an Intent struct via the swaps API —
+ * `sodax.api.swaps.getIntentHash`. The `intent` carries `bigint` numerics. Returns `{ hash }`.
+ *
+ * @example
+ * const { data } = useSwapsApiIntentHash({ params: { intent } });
+ */
+export const useSwapsApiIntentHash = ({
+  params,
+  queryOptions,
+}: UseSwapsApiIntentHashParams = {}): UseQueryResult<IntentHashResponseV2 | undefined, Error> => {
+  const { sodax } = useSodaxContext();
+  const intent = params?.intent;
+  const apiConfig = params?.apiConfig;
+
+  return useQuery({
+    queryKey: ['swapsApi', 'intentHash', intent?.intentId?.toString()],
+    queryFn: async (): Promise<IntentHashResponseV2 | undefined> => {
+      if (!intent) return undefined;
+      return unwrapResult(await sodax.api.swaps.getIntentHash({ intent }, apiConfig));
+    },
+    enabled: !!intent,
+    retry: 3,
+    ...queryOptions,
+  });
+};

package/src/hooks/swapsApi/useSwapsApiIntentPacket.ts

@@ -0,0 +1,43 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { IntentPacketRequestV2, IntentPacketResponseV2, RequestOverrideConfig } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
+import type { ReadHookParams } from '../shared/types.js';
+
+export type UseSwapsApiIntentPacketParams = ReadHookParams<
+  IntentPacketResponseV2 | undefined,
+  {
+    body: IntentPacketRequestV2 | undefined;
+    apiConfig?: RequestOverrideConfig;
+  }
+>;
+
+/**
+ * React hook to long-poll the relayer until the fill packet lands on the destination chain via the
+ * swaps API — `sodax.api.swaps.getSolvedIntentPacket`. The request is held open server-side until
+ * the packet arrives (or `body.timeout` ms elapses), so no client-side `refetchInterval` is set.
+ *
+ * @example
+ * const { data: packet } = useSwapsApiIntentPacket({
+ *   params: { body: { chainId: '146', fillTxHash: '0x123...' } },
+ * });
+ */
+export const useSwapsApiIntentPacket = ({
+  params,
+  queryOptions,
+}: UseSwapsApiIntentPacketParams = {}): UseQueryResult<IntentPacketResponseV2 | undefined, Error> => {
+  const { sodax } = useSodaxContext();
+  const body = params?.body;
+  const apiConfig = params?.apiConfig;
+
+  return useQuery({
+    queryKey: ['swapsApi', 'intentPacket', body?.chainId, body?.fillTxHash],
+    queryFn: async (): Promise<IntentPacketResponseV2 | undefined> => {
+      if (!body) return undefined;
+      return unwrapResult(await sodax.api.swaps.getSolvedIntentPacket(body, apiConfig));
+    },
+    enabled: !!body,
+    retry: 3,
+    ...queryOptions,
+  });
+};

package/src/hooks/swapsApi/useSwapsApiPartnerFee.ts

@@ -0,0 +1,40 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { FeeResponseV2, RequestOverrideConfig } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
+import type { ReadHookParams } from '../shared/types.js';
+
+export type UseSwapsApiPartnerFeeParams = ReadHookParams<
+  FeeResponseV2 | undefined,
+  {
+    amount: string | undefined;
+    apiConfig?: RequestOverrideConfig;
+  }
+>;
+
+/**
+ * React hook to compute the partner fee for a given input amount via the swaps API —
+ * `sodax.api.swaps.getPartnerFee`. Returns `{ fee }` (decimal string).
+ *
+ * @example
+ * const { data } = useSwapsApiPartnerFee({ params: { amount: '1000000' } });
+ */
+export const useSwapsApiPartnerFee = ({
+  params,
+  queryOptions,
+}: UseSwapsApiPartnerFeeParams = {}): UseQueryResult<FeeResponseV2 | undefined, Error> => {
+  const { sodax } = useSodaxContext();
+  const amount = params?.amount;
+  const apiConfig = params?.apiConfig;
+
+  return useQuery({
+    queryKey: ['swapsApi', 'partnerFee', amount],
+    queryFn: async (): Promise<FeeResponseV2 | undefined> => {
+      if (!amount) return undefined;
+      return unwrapResult(await sodax.api.swaps.getPartnerFee({ amount }, apiConfig));
+    },
+    enabled: !!amount && amount.length > 0,
+    retry: 3,
+    ...queryOptions,
+  });
+};

package/src/hooks/swapsApi/useSwapsApiQuote.ts

@@ -0,0 +1,55 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { QuoteQueryV2, QuoteRequestV2, QuoteResponseV2, RequestOverrideConfig } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
+import type { ReadHookParams } from '../shared/types.js';
+
+export type UseSwapsApiQuoteParams = ReadHookParams<
+  QuoteResponseV2 | undefined,
+  {
+    body: QuoteRequestV2 | undefined;
+    query?: QuoteQueryV2;
+    apiConfig?: RequestOverrideConfig;
+  }
+>;
+
+/**
+ * React hook to get a solver quote for a cross-chain swap via the swaps API —
+ * `sodax.api.swaps.getQuote`. Pass `query.includeTxData = true` to also build an unsigned
+ * create-intent transaction (`txData`); `srcAddress`/`dstAddress` are then required in the body.
+ *
+ * @example
+ * const { data: quote } = useSwapsApiQuote({
+ *   params: {
+ *     body: {
+ *       tokenSrc: '0x...', tokenSrcChainKey: '0xa4b1.arbitrum',
+ *       tokenDst: '0x...', tokenDstChainKey: 'sonic',
+ *       amount: '1000000', quoteType: 'exact_input',
+ *     },
+ *   },
+ * });
+ */
+export const useSwapsApiQuote = ({
+  params,
+  queryOptions,
+}: UseSwapsApiQuoteParams = {}): UseQueryResult<QuoteResponseV2 | undefined, Error> => {
+  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 (): Promise<QuoteResponseV2 | undefined> => {
+      if (!body) return undefined;
+      return unwrapResult(await sodax.api.swaps.getQuote(body, query, apiConfig));
+    },
+    enabled: !!body,
+    retry: 3,
+    ...queryOptions,
+  });
+};

package/src/hooks/swapsApi/useSwapsApiSolverFee.ts

@@ -0,0 +1,40 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { FeeResponseV2, RequestOverrideConfig } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
+import type { ReadHookParams } from '../shared/types.js';
+
+export type UseSwapsApiSolverFeeParams = ReadHookParams<
+  FeeResponseV2 | undefined,
+  {
+    amount: string | undefined;
+    apiConfig?: RequestOverrideConfig;
+  }
+>;
+
+/**
+ * React hook to compute the protocol (solver) fee for a given input amount via the swaps API —
+ * `sodax.api.swaps.getSolverFee`. Returns `{ fee }` (decimal string).
+ *
+ * @example
+ * const { data } = useSwapsApiSolverFee({ params: { amount: '1000000' } });
+ */
+export const useSwapsApiSolverFee = ({
+  params,
+  queryOptions,
+}: UseSwapsApiSolverFeeParams = {}): UseQueryResult<FeeResponseV2 | undefined, Error> => {
+  const { sodax } = useSodaxContext();
+  const amount = params?.amount;
+  const apiConfig = params?.apiConfig;
+
+  return useQuery({
+    queryKey: ['swapsApi', 'solverFee', amount],
+    queryFn: async (): Promise<FeeResponseV2 | undefined> => {
+      if (!amount) return undefined;
+      return unwrapResult(await sodax.api.swaps.getSolverFee({ amount }, apiConfig));
+    },
+    enabled: !!amount && amount.length > 0,
+    retry: 3,
+    ...queryOptions,
+  });
+};