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

package/src/hooks/swapsApi/useSwapsApiStatus.ts

@@ -0,0 +1,45 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { RequestOverrideConfig, StatusResponseV2 } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
+import type { ReadHookParams } from '../shared/types.js';
+import { isTerminalSwapIntentStatus } from './isTerminalSwapIntentStatus.js';
+
+export type UseSwapsApiStatusParams = ReadHookParams<
+  StatusResponseV2 | undefined,
+  {
+    intentTxHash: string | undefined;
+    apiConfig?: RequestOverrideConfig;
+  }
+>;
+
+/**
+ * React hook for polling the solver intent status by hub-chain intent tx hash via the swaps API —
+ * `sodax.api.swaps.getStatus`. Returns `{ status, fillTxHash? }` (`fillTxHash` set when `status === 3`).
+ *
+ * @example
+ * const { data } = useSwapsApiStatus({ params: { intentTxHash: '0x123...' } });
+ *
+ * @remarks
+ * - Default refetch interval is 1 second; stops once `status` is `3` (SOLVED) or `4` (FAILED).
+ */
+export const useSwapsApiStatus = ({
+  params,
+  queryOptions,
+}: UseSwapsApiStatusParams = {}): UseQueryResult<StatusResponseV2 | undefined, Error> => {
+  const { sodax } = useSodaxContext();
+  const intentTxHash = params?.intentTxHash;
+  const apiConfig = params?.apiConfig;
+
+  return useQuery({
+    queryKey: ['swapsApi', 'status', intentTxHash],
+    queryFn: async (): Promise<StatusResponseV2 | undefined> => {
+      if (!intentTxHash) return undefined;
+      return unwrapResult(await sodax.api.swaps.getStatus({ intentTxHash }, apiConfig));
+    },
+    enabled: !!intentTxHash && intentTxHash.length > 0,
+    retry: 3,
+    refetchInterval: query => (isTerminalSwapIntentStatus(query.state.data?.status) ? false : 1000),
+    ...queryOptions,
+  });
+};

package/src/hooks/swapsApi/useSwapsApiSubmitIntent.ts

@@ -0,0 +1,43 @@
+import type { RequestOverrideConfig, SubmitIntentRequestV2, SubmitIntentResponseV2 } 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 useSwapsApiSubmitIntent}. The per-request `apiConfig` override
+ * belongs here rather than at the hook level.
+ */
+export type UseSwapsApiSubmitIntentVars = {
+  body: SubmitIntentRequestV2;
+  apiConfig?: RequestOverrideConfig;
+};
+
+/**
+ * React hook to submit the broadcast intent tx to the relay via the swaps API —
+ * `sodax.api.swaps.submitIntent`. Returns `{ result }` (opaque relay response).
+ *
+ * No auto-retry (`retry: false`): submitting is non-idempotent — a retry after a lost response
+ * could double-submit to the relay. Override via `mutationOptions.retry` if your relay dedupes.
+ *
+ * @example
+ * const { mutateAsync: submitIntent } = useSwapsApiSubmitIntent();
+ * const { result } = await submitIntent({ body: { chainId: '146', txHash: '0x123...' } });
+ */
+export const useSwapsApiSubmitIntent = ({
+  mutationOptions,
+}: MutationHookParams<SubmitIntentResponseV2, UseSwapsApiSubmitIntentVars> = {}): SafeUseMutationResult<
+  SubmitIntentResponseV2,
+  Error,
+  UseSwapsApiSubmitIntentVars
+> => {
+  const { sodax } = useSodaxContext();
+
+  return useSafeMutation<SubmitIntentResponseV2, Error, UseSwapsApiSubmitIntentVars>({
+    mutationKey: ['swapsApi', 'submitIntent'],
+    retry: false,
+    ...mutationOptions,
+    mutationFn: async ({ body, apiConfig }): Promise<SubmitIntentResponseV2> =>
+      unwrapResult(await sodax.api.swaps.submitIntent(body, apiConfig)),
+  });
+};

package/src/hooks/{backend/useBackendSubmitSwapTx.ts → swapsApi/useSwapsApiSubmitTx.ts}

@@ -1,49 +1,48 @@
-// packages/dapp-kit/src/hooks/backend/useBackendSubmitSwapTx.ts
-import type { RequestOverrideConfig, SubmitSwapTxRequest, SubmitSwapTxResponse } from '@sodax/sdk';
+import type { RequestOverrideConfig, SubmitTxRequestV2, SubmitTxResponseV2 } from '@sodax/sdk';
 import { useSodaxContext } from '../shared/useSodaxContext.js';
-import { unwrapResult } from './unwrapResult.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 useBackendSubmitSwapTx}. The per-request `apiConfig` override
+ * Mutation variables for {@link useSwapsApiSubmitTx}. The per-request `apiConfig` override
  * (e.g. base URL) belongs here rather than at the hook level — different submissions in the same
  * component can target different endpoints without re-rendering.
  */
-export type UseBackendSubmitSwapTxVars = {
-  request: SubmitSwapTxRequest;
+export type UseSwapsApiSubmitTxVars = {
+  request: SubmitTxRequestV2;
   apiConfig?: RequestOverrideConfig;
 };
 
 /**
- * React hook for submitting a swap transaction to be processed by the backend (relay, post
- * execution to solver, etc.).
+ * React hook for submitting a swap transaction to be processed (relay, post execution to the
+ * solver, etc.) via the swaps API — `sodax.api.swaps.submitTx`.
  *
  * Pure mutation: pass `{ request, apiConfig? }` to `mutate({...})`. Default `retry: 3` is applied
  * at the hook level — consumers can override via `mutationOptions.retry`.
  *
  * @example
- * const { mutateAsync: submitSwapTx, isPending, error } = useBackendSubmitSwapTx();
+ * const { mutateAsync: submitSwapTx, isPending, error } = useSwapsApiSubmitTx();
  *
  * const result = await submitSwapTx({
  *   request: { txHash: '0x123...', srcChainKey: 'sonic', walletAddress: '0xabc...', intent: { ... }, relayData: '0x...' },
  *   apiConfig: { baseURL: 'https://...' },
  * });
  */
-export const useBackendSubmitSwapTx = ({
+export const useSwapsApiSubmitTx = ({
   mutationOptions,
-}: MutationHookParams<SubmitSwapTxResponse, UseBackendSubmitSwapTxVars> = {}): SafeUseMutationResult<
-  SubmitSwapTxResponse,
+}: MutationHookParams<SubmitTxResponseV2, UseSwapsApiSubmitTxVars> = {}): SafeUseMutationResult<
+  SubmitTxResponseV2,
   Error,
-  UseBackendSubmitSwapTxVars
+  UseSwapsApiSubmitTxVars
 > => {
   const { sodax } = useSodaxContext();
 
-  return useSafeMutation<SubmitSwapTxResponse, Error, UseBackendSubmitSwapTxVars>({
-    mutationKey: ['backend', 'submitSwapTx'],
+  return useSafeMutation<SubmitTxResponseV2, Error, UseSwapsApiSubmitTxVars>({
+    mutationKey: ['swapsApi', 'submitTx'],
     retry: 3,
     ...mutationOptions,
-    mutationFn: async ({ request, apiConfig }): Promise<SubmitSwapTxResponse> =>
-      unwrapResult(await sodax.backendApi.submitSwapTx(request, apiConfig)),
+    mutationFn: async ({ request, apiConfig }): Promise<SubmitTxResponseV2> =>
+      unwrapResult(await sodax.api.swaps.submitTx(request, apiConfig)),
   });
 };

package/src/hooks/swapsApi/useSwapsApiSubmitTxStatus.ts

@@ -0,0 +1,55 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { RequestOverrideConfig, SubmitTxStatusResponseV2 } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from '../shared/unwrapResult.js';
+import type { ReadHookParams } from '../shared/types.js';
+
+export type UseSwapsApiSubmitTxStatusParams = ReadHookParams<
+  SubmitTxStatusResponseV2 | undefined,
+  {
+    txHash: string | undefined;
+    srcChainKey?: string;
+    apiConfig?: RequestOverrideConfig;
+  }
+>;
+
+/**
+ * React hook for polling the processing status of a submitted swap transaction via the swaps API —
+ * `sodax.api.swaps.getSubmitTxStatus`. Both `txHash` and `srcChainKey` are required for the query
+ * to run (the swaps API v2 status query requires the source chain key).
+ *
+ * @example
+ * const { data: status } = useSwapsApiSubmitTxStatus({
+ *   params: { txHash: '0x123...', srcChainKey: 'sonic' },
+ * });
+ *
+ * @remarks
+ * - Default refetch interval is 1 second; stops on 'executed' or 'failed' status.
+ */
+export const useSwapsApiSubmitTxStatus = ({
+  params,
+  queryOptions,
+}: UseSwapsApiSubmitTxStatusParams = {}): UseQueryResult<SubmitTxStatusResponseV2 | undefined, Error> => {
+  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 (): Promise<SubmitTxStatusResponseV2 | undefined> => {
+      // `srcChainKey` is required by the swaps API v2 status query. The `enabled` gate below
+      // ensures both are present; this guard also narrows the types for the call.
+      if (!txHash || !srcChainKey) return undefined;
+      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 1000;
+    },
+    ...queryOptions,
+  });
+};

package/src/hooks/swapsApi/useSwapsApiTokens.ts

@@ -0,0 +1,34 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { GetSwapTokensResponseV2, 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 UseSwapsApiTokensParams = ReadHookParams<
+  GetSwapTokensResponseV2,
+  {
+    apiConfig?: RequestOverrideConfig;
+  }
+>;
+
+/**
+ * React hook to fetch all supported swap tokens grouped by SpokeChainKey via the swaps API —
+ * `sodax.api.swaps.getTokens`.
+ *
+ * @example
+ * const { data: tokensByChain } = useSwapsApiTokens();
+ */
+export const useSwapsApiTokens = ({
+  params,
+  queryOptions,
+}: UseSwapsApiTokensParams = {}): UseQueryResult<GetSwapTokensResponseV2, Error> => {
+  const { sodax } = useSodaxContext();
+  const apiConfig = params?.apiConfig;
+
+  return useQuery<GetSwapTokensResponseV2, Error>({
+    queryKey: ['swapsApi', 'tokens'],
+    queryFn: async (): Promise<GetSwapTokensResponseV2> => unwrapResult(await sodax.api.swaps.getTokens(apiConfig)),
+    retry: 3,
+    ...queryOptions,
+  });
+};

package/src/hooks/swapsApi/useSwapsApiTokensByChain.ts

@@ -0,0 +1,40 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { GetSwapTokensByChainResponseV2, 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 UseSwapsApiTokensByChainParams = ReadHookParams<
+  GetSwapTokensByChainResponseV2 | undefined,
+  {
+    chainKey: string | undefined;
+    apiConfig?: RequestOverrideConfig;
+  }
+>;
+
+/**
+ * React hook to fetch supported swap tokens for a single SpokeChainKey via the swaps API —
+ * `sodax.api.swaps.getTokensByChain`.
+ *
+ * @example
+ * const { data: tokens } = useSwapsApiTokensByChain({ params: { chainKey: '0xa4b1.arbitrum' } });
+ */
+export const useSwapsApiTokensByChain = ({
+  params,
+  queryOptions,
+}: UseSwapsApiTokensByChainParams = {}): UseQueryResult<GetSwapTokensByChainResponseV2 | undefined, Error> => {
+  const { sodax } = useSodaxContext();
+  const chainKey = params?.chainKey;
+  const apiConfig = params?.apiConfig;
+
+  return useQuery({
+    queryKey: ['swapsApi', 'tokens', chainKey],
+    queryFn: async (): Promise<GetSwapTokensByChainResponseV2 | undefined> => {
+      if (!chainKey) return undefined;
+      return unwrapResult(await sodax.api.swaps.getTokensByChain(chainKey, apiConfig));
+    },
+    enabled: !!chainKey && chainKey.length > 0,
+    retry: 3,
+    ...queryOptions,
+  });
+};

package/src/hooks/backend/useBackendSubmitSwapTxStatus.ts

@@ -1,59 +0,0 @@
-import { useQuery, type UseQueryResult } from '@tanstack/react-query';
-import type { RequestOverrideConfig, SubmitSwapTxStatusResponse } from '@sodax/sdk';
-import { useSodaxContext } from '../shared/useSodaxContext.js';
-import { unwrapResult } from './unwrapResult.js';
-import type { ReadHookParams } from '../shared/types.js';
-
-export type UseBackendSubmitSwapTxStatusParams = ReadHookParams<
-  SubmitSwapTxStatusResponse | undefined,
-  {
-    txHash: string | undefined;
-    srcChainKey?: string;
-    apiConfig?: RequestOverrideConfig;
-  }
->;
-
-/**
- * React hook for polling the processing status of a submitted swap transaction.
- *
- * @example
- * const { data: status } = useBackendSubmitSwapTxStatus({
- *   params: { txHash: '0x123...', srcChainKey: 'sonic' },
- * });
- *
- * @remarks
- * - Default refetch interval is 1 second; stops on 'executed' or 'failed' status.
- */
-export const useBackendSubmitSwapTxStatus = ({
-  params,
-  queryOptions,
-}: UseBackendSubmitSwapTxStatusParams = {}): UseQueryResult<SubmitSwapTxStatusResponse | undefined, Error> => {
-  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 (): Promise<SubmitSwapTxStatusResponse | undefined> => {
-      if (!txHash) return undefined;
-      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 1000;
-    },
-    ...queryOptions,
-  });
-};