@sodax/dapp-kit 1.5.6-beta → 2.0.0-rc.1

package/package.json

@@ -1,29 +1,32 @@
 {
   "name": "@sodax/dapp-kit",
   "license": "MIT",
-  "version": "1.5.6-beta",
+  "version": "2.0.0-rc.1",
   "description": "dapp-kit of New World",
-  "main": "dist/index.js",
+  "type": "module",
+  "main": "dist/index.cjs",
   "types": "dist/index.d.ts",
   "module": "dist/index.mjs",
   "files": [
     "dist",
-    "src"
+    "src",
+    "ai-exported"
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/icon-project/sodax-frontend"
+    "url": "https://github.com/icon-project/sodax-sdks"
   },
   "dependencies": {
     "viem": "2.29.2",
-    "@sodax/sdk": "1.5.6-beta",
-    "@sodax/types": "1.5.6-beta"
+    "@sodax/sdk": "2.0.0-rc.1"
   },
   "devDependencies": {
+    "@tanstack/react-query": "5.87.4",
     "@types/react": "19.0.8",
     "knip": "5.30.5",
     "tsup": "8.5.0",
-    "typescript": "5.5.4"
+    "typescript": "5.5.4",
+    "vitest": "2.1.9"
   },
   "peerDependencies": {
     "@tanstack/react-query": "5.x",
@@ -37,17 +40,24 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
+      "require": "./dist/index.cjs"
     }
   },
   "scripts": {
     "build": "tsup",
     "dev": "tsup --watch ./src",
-    "test": "tsc --noEmit",
+    "test": "vitest run",
     "clean": "rm -rf dist && rm -rf node_modules && rm -rf .turbo",
     "pretty": "biome format . --write",
     "checkTs": "tsc --noEmit",
     "knip": "knip",
-    "lint": "biome lint . --write"
+    "lint": "biome lint . --write",
+    "check:ai-exported": "bash ./scripts/check-ai-exported.sh",
+    "check:ai-scope": "bash ./scripts/check-ai-scope.sh",
+    "check:ai-links": "bash ./scripts/check-ai-links.sh",
+    "check:ai-imports": "bash ./scripts/check-ai-imports.sh",
+    "check:ai-snippets": "bash ./scripts/check-ai-snippets.sh",
+    "check:ai-keys": "bash ./scripts/check-ai-keys.sh",
+    "check:ai-consistency": "bash ./scripts/check-ai-consistency.sh"
   }
 }

package/src/contexts/index.ts

@@ -1,11 +1,8 @@
 import { createContext } from 'react';
 import type { Sodax } from '@sodax/sdk';
-import type { RpcConfig } from '@sodax/types';
 
 export interface SodaxContextType {
   sodax: Sodax;
-  testnet: boolean;
-  rpcConfig: RpcConfig;
 }
 
 export const SodaxContext = createContext<SodaxContextType | null>(null);

package/src/hooks/_mutationContract.test.ts

@@ -0,0 +1,99 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'vitest';
+
+const HOOKS_DIR = resolve(fileURLToPath(import.meta.url), '..');
+
+/**
+ * Manifest of every mutation hook. `nativeThrow: true` marks hooks whose underlying SDK methods
+ * throw natively (Radfi APIs) and so don't need `unwrapResult`.
+ *
+ * To add a new mutation hook, add its path here. The friction is intentional — it forces explicit
+ * registration so the contract is enforced from day one.
+ */
+const HOOKS: Array<{ path: string; nativeThrow?: true }> = [
+  { path: 'backend/useBackendSubmitSwapTx.ts' },
+  { path: 'bitcoin/useFundTradingWallet.ts', nativeThrow: true },
+  { path: 'bitcoin/useRadfiAuth.ts', nativeThrow: true },
+  { path: 'bitcoin/useRadfiWithdraw.ts', nativeThrow: true },
+  { path: 'bitcoin/useRenewUtxos.ts', nativeThrow: true },
+  { path: 'bridge/useBridge.ts' },
+  { path: 'bridge/useBridgeApprove.ts' },
+  { path: 'dex/useClaimRewards.ts' },
+  { path: 'dex/useDecreaseLiquidity.ts' },
+  { path: 'dex/useDexApprove.ts' },
+  { path: 'dex/useDexDeposit.ts' },
+  { path: 'dex/useDexWithdraw.ts' },
+  { path: 'dex/useSupplyLiquidity.ts' },
+  { path: 'migrate/useMigrateBaln.ts' },
+  { path: 'migrate/useMigrateIcxToSoda.ts' },
+  { path: 'migrate/useMigratebnUSD.ts' },
+  { path: 'migrate/useMigrationApprove.ts' },
+  { path: 'migrate/useRevertMigrateSodaToIcx.ts' },
+  { path: 'mm/useBorrow.ts' },
+  { path: 'mm/useMMApprove.ts' },
+  { path: 'mm/useRepay.ts' },
+  { path: 'mm/useSupply.ts' },
+  { path: 'mm/useWithdraw.ts' },
+  { path: 'partner/useApproveToken.ts' },
+  { path: 'partner/useFeeClaimSwap.ts' },
+  { path: 'partner/useSetSwapPreference.ts' },
+  { path: 'recovery/useWithdrawHubAsset.ts' },
+  { path: 'shared/useEstimateGas.ts' },
+  { path: 'staking/useCancelUnstake.ts' },
+  { path: 'staking/useClaim.ts' },
+  { path: 'staking/useInstantUnstake.ts' },
+  { path: 'staking/useInstantUnstakeApprove.ts' },
+  { path: 'staking/useStake.ts' },
+  { path: 'staking/useStakeApprove.ts' },
+  { path: 'staking/useUnstake.ts' },
+  { path: 'staking/useUnstakeApprove.ts' },
+  { path: 'swap/useCancelLimitOrder.ts' },
+  { path: 'swap/useCancelSwap.ts' },
+  { path: 'swap/useCreateLimitOrder.ts' },
+  { path: 'swap/useSwap.ts' },
+  { path: 'swap/useSwapApprove.ts' },
+];
+
+describe.each(HOOKS)('mutation hook contract: $path', ({ path, nativeThrow }) => {
+  const src = readFileSync(resolve(HOOKS_DIR, path), 'utf8');
+
+  it('uses useSafeMutation (not useMutation)', () => {
+    expect(src).toMatch(/useSafeMutation</);
+    // Negative lookbehind excludes useSafeMutation; catches a regression to bare useMutation.
+    expect(src).not.toMatch(/(?<!Safe)useMutation</);
+  });
+
+  it('returns SafeUseMutationResult', () => {
+    expect(src).toMatch(/SafeUseMutationResult</);
+  });
+
+  it('sets a default mutationKey before the mutationOptions spread', () => {
+    const keyIdx = src.search(/mutationKey:\s*\[/);
+    const spreadIdx = src.indexOf('...mutationOptions');
+    expect(keyIdx).toBeGreaterThan(-1);
+    expect(spreadIdx).toBeGreaterThan(-1);
+    expect(keyIdx).toBeLessThan(spreadIdx);
+  });
+
+  it('mutationKey first segment matches feature directory', () => {
+    // Feature directory = first segment of `path`. e.g. `mm/useSupply.ts` → `mm`.
+    const featureDir = path.split('/')[0];
+    const match = src.match(/mutationKey:\s*\[\s*'([^']+)'/);
+    expect(match).not.toBeNull();
+    expect(match?.[1]).toBe(featureDir);
+  });
+
+  it('defines mutationFn after the mutationOptions spread', () => {
+    const spreadIdx = src.indexOf('...mutationOptions');
+    const fnIdx = src.search(/\bmutationFn:/);
+    expect(fnIdx).toBeGreaterThan(spreadIdx);
+  });
+
+  if (!nativeThrow) {
+    it('translates SDK Result via unwrapResult', () => {
+      expect(src).toMatch(/unwrapResult\(/);
+    });
+  }
+});

package/src/hooks/backend/README.md

@@ -100,14 +100,14 @@ Fetches a user's money market position. The query is disabled if `userAddress` i
 import { useBackendMoneyMarketPosition } from '@sodax/dapp-kit';
 
 const { data: position, isLoading, error } = useBackendMoneyMarketPosition({
-  userAddress: '0x123...',
+  params: { userAddress: '0x123...' },
   queryOptions: { staleTime: 60000 }, // optional
 });
 ```
 
 **Parameters:**
 
-- `params.userAddress` (string | undefined): The user's wallet address to fetch positions for
+- `params.params.userAddress` (string | undefined): The user's wallet address to fetch positions for
 - `params.queryOptions` (optional): React Query options to customize behavior
 
 #### `useBackendAllMoneyMarketAssets(params)`

package/src/hooks/backend/index.ts

@@ -8,22 +8,22 @@
  */
 
 // Intent hooks
-export { useBackendIntentByTxHash } from './useBackendIntentByTxHash';
-export { useBackendIntentByHash } from './useBackendIntentByHash';
-export { useBackendUserIntents } from './useBackendUserIntents';
+export { useBackendIntentByTxHash } from './useBackendIntentByTxHash.js';
+export { useBackendIntentByHash } from './useBackendIntentByHash.js';
+export { useBackendUserIntents } from './useBackendUserIntents.js';
 
 // Swap submit-tx hooks
-export { useBackendSubmitSwapTx } from './useBackendSubmitSwapTx';
-export { useBackendSubmitSwapTxStatus } from './useBackendSubmitSwapTxStatus';
+export { useBackendSubmitSwapTx } from './useBackendSubmitSwapTx.js';
+export { useBackendSubmitSwapTxStatus } from './useBackendSubmitSwapTxStatus.js';
 
 // Solver hooks
-export { useBackendOrderbook } from './useBackendOrderbook';
+export { useBackendOrderbook } from './useBackendOrderbook.js';
 
 // Money Market hooks
-export { useBackendMoneyMarketPosition } from './useBackendMoneyMarketPosition';
-export { useBackendAllMoneyMarketAssets } from './useBackendAllMoneyMarketAssets';
-export { useBackendMoneyMarketAsset } from './useBackendMoneyMarketAsset';
-export { useBackendMoneyMarketAssetBorrowers } from './useBackendMoneyMarketAssetBorrowers';
-export { useBackendMoneyMarketAssetSuppliers } from './useBackendMoneyMarketAssetSuppliers';
-export { useBackendAllMoneyMarketBorrowers } from './useBackendAllMoneyMarketBorrowers';
-export * from './types';
+export { useBackendMoneyMarketPosition } from './useBackendMoneyMarketPosition.js';
+export { useBackendAllMoneyMarketAssets } from './useBackendAllMoneyMarketAssets.js';
+export { useBackendMoneyMarketAsset } from './useBackendMoneyMarketAsset.js';
+export { useBackendMoneyMarketAssetBorrowers } from './useBackendMoneyMarketAssetBorrowers.js';
+export { useBackendMoneyMarketAssetSuppliers } from './useBackendMoneyMarketAssetSuppliers.js';
+export { useBackendAllMoneyMarketBorrowers } from './useBackendAllMoneyMarketBorrowers.js';
+export * from './types.js';

package/src/hooks/backend/unwrapResult.ts

@@ -0,0 +1 @@
+export { unwrapResult } from '../shared/unwrapResult.js';

package/src/hooks/backend/useBackendAllMoneyMarketAssets.ts

@@ -1,60 +1,28 @@
-// packages/dapp-kit/src/hooks/backend/useAllMoneyMarketAssets.ts
-import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
 import type { MoneyMarketAsset } from '@sodax/sdk';
-import { useSodaxContext } from '../shared/useSodaxContext';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from './unwrapResult.js';
+import type { ReadHookParams } from '../shared/types.js';
 
-export type UseBackendAllMoneyMarketAssetsParams = {
-  queryOptions?: UseQueryOptions<MoneyMarketAsset[], Error>;
-};
+export type UseBackendAllMoneyMarketAssetsParams = ReadHookParams<MoneyMarketAsset[]>;
 
 /**
  * React hook to fetch all money market assets from the backend API.
  *
- * @param {UseBackendAllMoneyMarketAssetsParams | undefined} params - Optional parameters:
- *   - `queryOptions` (optional): React Query options to override default behavior (e.g., caching, retry, etc).
- *
- * @returns {UseQueryResult<MoneyMarketAsset[], Error>} React Query result object:
- *   - `data`: Array of all money market asset data when available.
- *   - `isLoading`: Boolean indicating if the request is in progress.
- *   - `error`: Error object if the request failed.
- *   - `refetch`: Function to manually trigger a data refresh.
- *
  * @example
  * const { data: assets, isLoading, error } = useBackendAllMoneyMarketAssets();
- *
- * if (isLoading) return <div>Loading assets...</div>;
- * if (error) return <div>Error: {error.message}</div>;
- * if (assets) {
- *   console.log('Total assets:', assets.length);
- *   assets.forEach(asset => {
- *     console.log(`${asset.symbol}: ${asset.liquidityRate} liquidity rate`);
- *   });
- * }
- *
- * @remarks
- * - No required parameters — fetches all available money market assets from backend.
- * - Uses React Query for caching, retries, and loading/error state management.
- * - Supports overriding React Query config via `queryOptions`.
  */
-export const useBackendAllMoneyMarketAssets = (
-  params: UseBackendAllMoneyMarketAssetsParams | undefined,
-): UseQueryResult<MoneyMarketAsset[], Error> => {
+export const useBackendAllMoneyMarketAssets = ({
+  queryOptions,
+}: UseBackendAllMoneyMarketAssetsParams = {}): UseQueryResult<MoneyMarketAsset[], Error> => {
   const { sodax } = useSodaxContext();
 
-  const defaultQueryOptions = {
-    queryKey: ['api', 'mm', 'assets', 'all'],
-    enabled: true,
-    retry: 3,
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions,
-  };
-
-  return useQuery({
-    ...queryOptions,
+  return useQuery<MoneyMarketAsset[], Error>({
+    queryKey: ['backend', 'mm', 'assets', 'all'],
     queryFn: async (): Promise<MoneyMarketAsset[]> => {
-      return sodax.backendApi.getAllMoneyMarketAssets();
+      return unwrapResult(await sodax.backendApi.getAllMoneyMarketAssets());
     },
+    retry: 3,
+    ...queryOptions,
   });
 };

package/src/hooks/backend/useBackendAllMoneyMarketBorrowers.ts

@@ -1,79 +1,49 @@
-// packages/dapp-kit/src/hooks/backend/useAllMoneyMarketBorrowers.ts
-import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
 import type { MoneyMarketBorrowers } from '@sodax/sdk';
-import { useSodaxContext } from '../shared/useSodaxContext';
-import type { BackendPaginationParams } from './types';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import { unwrapResult } from './unwrapResult.js';
+import type { BackendPaginationParams } from './types.js';
+import type { ReadHookParams } from '../shared/types.js';
 
-export type UseBackendAllMoneyMarketBorrowersParams = {
-  pagination: BackendPaginationParams;
-  queryOptions?: UseQueryOptions<MoneyMarketBorrowers | undefined, Error>;
-};
+export type UseBackendAllMoneyMarketBorrowersParams = ReadHookParams<
+  MoneyMarketBorrowers | undefined,
+  {
+    pagination: BackendPaginationParams;
+  }
+>;
 
 /**
  * Hook for fetching all money market borrowers from the backend API.
  *
- * This hook provides access to the list of all borrowers across all money market assets,
- * with pagination support. The data is automatically fetched and cached using React Query.
- *
- * @param {Object} params - Pagination parameters for fetching all borrowers
- * @param {string} params.offset - The offset for pagination (number as string)
- * @param {string} params.limit - The limit for pagination (number as string)
- *
- * @returns {UseQueryResult<MoneyMarketBorrowers | undefined>} A query result object containing:
- *   - data: The all borrowers data when available
- *   - isLoading: Boolean indicating if the request is in progress
- *   - error: Error object if the request failed
- *   - refetch: Function to manually trigger a data refresh
- *
  * @example
  * ```typescript
- * const { data: borrowers, isLoading, error } = useAllMoneyMarketBorrowers({
- *   offset: '0',
- *   limit: '50'
+ * const { data, isLoading, error } = useBackendAllMoneyMarketBorrowers({
+ *   params: { pagination: { offset: '0', limit: '50' } },
  * });
- *
- * if (isLoading) return <div>Loading borrowers...</div>;
- * if (error) return <div>Error: {error.message}</div>;
- * if (borrowers) {
- *   console.log('Total borrowers:', borrowers.total);
- *   console.log('Borrowers:', borrowers.borrowers);
- * }
  * ```
- *
- * @remarks
- * - The query is disabled when params are undefined or invalid
- * - Uses React Query for efficient caching and state management
- * - Automatically handles error states and loading indicators
- * - Supports pagination through offset and limit parameters
- * - Returns borrowers across all money market assets
  */
-export const useBackendAllMoneyMarketBorrowers = (
-  params: UseBackendAllMoneyMarketBorrowersParams | undefined,
-): UseQueryResult<MoneyMarketBorrowers | undefined> => {
+export const useBackendAllMoneyMarketBorrowers = ({
+  params,
+  queryOptions,
+}: UseBackendAllMoneyMarketBorrowersParams = {}): UseQueryResult<MoneyMarketBorrowers | undefined> => {
   const { sodax } = useSodaxContext();
-
-  const defaultQueryOptions = {
-    queryKey: ['api', 'mm', 'borrowers', 'all', params],
-    enabled: !!params && !!params.pagination.offset && !!params.pagination.limit,
-    retry: 3,
-  };
-
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions,
-  };
+  const pagination = params?.pagination;
 
   return useQuery({
-    ...queryOptions,
+    queryKey: ['backend', 'mm', 'borrowers', 'all', pagination],
     queryFn: async (): Promise<MoneyMarketBorrowers | undefined> => {
-      if (!params || !params.pagination.offset || !params.pagination.limit) {
+      if (!pagination?.offset || !pagination?.limit) {
         return undefined;
       }
-
-      return sodax.backendApi.getAllMoneyMarketBorrowers({
-        offset: params.pagination.offset,
-        limit: params.pagination.limit,
-      });
+      return unwrapResult(
+        await sodax.backendApi.getAllMoneyMarketBorrowers({
+          offset: pagination.offset,
+          limit: pagination.limit,
+        }),
+      );
     },
+    enabled: !!pagination?.offset && !!pagination?.limit,
+    retry: 3,
+    ...queryOptions,
   });
 };

package/src/hooks/backend/useBackendIntentByHash.ts

@@ -1,63 +1,37 @@
-import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
 import type { IntentResponse } from '@sodax/sdk';
-import { useSodaxContext } from '../shared/useSodaxContext';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { ReadHookParams } from '../shared/types.js';
 
-export type UseBackendIntentByHashParams = {
-  params: {
+export type UseBackendIntentByHashParams = ReadHookParams<
+  IntentResponse | undefined,
+  {
     intentHash: string | undefined;
-  };
-  queryOptions?: UseQueryOptions<IntentResponse | undefined, Error>;
-};
+  }
+>;
 
 /**
  * React hook to fetch intent details from the backend API using an intent hash.
  *
- * @param {UseBackendIntentByHashParams | undefined} params - Parameters for the query:
- *   - params: { intentHash: string | undefined }
- *     - `intentHash`: The hash identifying the intent to fetch (disables query if undefined or empty).
- *   - queryOptions (optional): Options to customize React Query (e.g., staleTime, enabled).
- *
- * @returns {UseQueryResult<IntentResponse | undefined, Error>} React Query result containing intent response data, loading, error, and refetch states.
- *
  * @example
- * const { data: intent, isLoading, error } = useBackendIntentByHash({
- *   params: { intentHash: '0xabc...' },
- * });
- *
- * if (isLoading) return <div>Loading intent...</div>;
- * if (error) return <div>Error: {error.message}</div>;
- * if (intent) {
- *   console.log('Intent found:', intent.intentHash);
- * }
- *
- * @remarks
- * - Returns `undefined` data if no intentHash is provided or query is disabled.
- * - Query is cached and managed using React Query.
- * - Use `queryOptions` to customize caching, retry and fetch behavior.
+ * const { data: intent } = useBackendIntentByHash({ params: { intentHash: '0xabc...' } });
  */
-export const useBackendIntentByHash = (
-  params: UseBackendIntentByHashParams | undefined,
-): UseQueryResult<IntentResponse | undefined, Error> => {
+export const useBackendIntentByHash = ({
+  params,
+  queryOptions,
+}: UseBackendIntentByHashParams = {}): UseQueryResult<IntentResponse | undefined, Error> => {
   const { sodax } = useSodaxContext();
-
-  const defaultQueryOptions = {
-    queryKey: ['api', 'intent', 'hash', params?.params?.intentHash],
-    enabled: !!params?.params?.intentHash && params?.params?.intentHash.length > 0,
-    retry: 3,
-  };
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions,
-  };
+  const intentHash = params?.intentHash;
 
   return useQuery({
-    ...queryOptions,
+    queryKey: ['backend', 'intent', 'hash', intentHash],
     queryFn: async (): Promise<IntentResponse | undefined> => {
-      if (!params?.params?.intentHash) {
-        return undefined;
-      }
-
-      return sodax.backendApi.getIntentByHash(params.params.intentHash);
+      if (!intentHash) return undefined;
+      const result = await sodax.backendApi.getIntentByHash(intentHash);
+      return result.ok ? result.value : undefined;
     },
+    enabled: !!intentHash && intentHash.length > 0,
+    retry: 3,
+    ...queryOptions,
   });
 };

package/src/hooks/backend/useBackendIntentByTxHash.ts

@@ -1,69 +1,42 @@
-// packages/dapp-kit/src/hooks/backend/useIntentByTxHash.ts
-import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
 import type { IntentResponse } from '@sodax/sdk';
-import { useSodaxContext } from '../shared/useSodaxContext';
+import { useSodaxContext } from '../shared/useSodaxContext.js';
+import type { ReadHookParams } from '../shared/types.js';
 
-export type UseBackendIntentByTxHashParams = {
-  params: {
+export type UseBackendIntentByTxHashParams = ReadHookParams<
+  IntentResponse | undefined,
+  {
     txHash: string | undefined;
-  };
-  queryOptions?: UseQueryOptions<IntentResponse | undefined, Error>;
-};
+  }
+>;
 
 /**
  * React hook for fetching intent details from the backend API using a transaction hash.
  *
- * @param {UseBackendIntentByTxHashParams | undefined} params - Parameters for the query:
- *   - params: { txHash: string | undefined }
- *       - `txHash`: Transaction hash used to retrieve the associated intent; query is disabled if undefined or empty.
- *   - queryOptions (optional): React Query options to customize request behavior (e.g., caching, retry, refetchInterval, etc.).
- *
- * @returns {UseQueryResult<IntentResponse | undefined, Error>} React Query result object, including:
- *   - `data`: The intent response or undefined if unavailable,
- *   - `isLoading`: Loading state,
- *   - `error`: Error (if request failed),
- *   - `refetch`: Function to refetch the data.
- *
  * @example
- * const { data: intent, isLoading, error } = useBackendIntentByTxHash({
- *   params: { txHash: '0x123...' },
- * });
- *
- * if (isLoading) return <div>Loading intent...</div>;
- * if (error) return <div>Error: {error.message}</div>;
- * if (intent) {
- *   console.log('Intent found:', intent.intentHash);
- * }
+ * const { data: intent } = useBackendIntentByTxHash({ params: { txHash: '0x123...' } });
  *
  * @remarks
  * - Intents are only created on the hub chain, so `txHash` must originate from there.
- * - Query is disabled if `params` is undefined, or if `params.params.txHash` is undefined or an empty string.
- * - Default refetch interval is 1 second. Uses React Query for state management, caching, and retries.
+ * - Default refetch interval is 1 second.
  */
-export const useBackendIntentByTxHash = (
-  params: UseBackendIntentByTxHashParams | undefined,
-): UseQueryResult<IntentResponse | undefined, Error> => {
+export const useBackendIntentByTxHash = ({
+  params,
+  queryOptions,
+}: UseBackendIntentByTxHashParams = {}): UseQueryResult<IntentResponse | undefined, Error> => {
   const { sodax } = useSodaxContext();
-
-  const defaultQueryOptions = {
-    queryKey: ['api', 'intent', 'txHash', params?.params?.txHash],
-    enabled: !!params?.params?.txHash && params?.params?.txHash.length > 0,
-    retry: 3,
-    refetchInterval: 1000,
-  };
-
-  const queryOptions = {
-    ...defaultQueryOptions,
-    ...params?.queryOptions,
-  };
+  const txHash = params?.txHash;
 
   return useQuery({
-    ...queryOptions,
+    queryKey: ['backend', 'intent', 'txHash', txHash],
     queryFn: async (): Promise<IntentResponse | undefined> => {
-      if (!params?.params?.txHash) {
-        return undefined;
-      }
-      return sodax.backendApi.getIntentByTxHash(params.params.txHash);
+      if (!txHash) return undefined;
+      const result = await sodax.backendApi.getIntentByTxHash(txHash);
+      return result.ok ? result.value : undefined;
     },
+    enabled: !!txHash && txHash.length > 0,
+    retry: 3,
+    refetchInterval: 1000,
+    ...queryOptions,
   });
 };