@sodax/dapp-kit 0.0.1-rc.21 → 0.0.1-rc.23

package/src/hooks/backend/useBackendIntentByHash.ts

@@ -0,0 +1,53 @@
+// packages/dapp-kit/src/hooks/backend/useIntentByHash.ts
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { IntentResponse } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext';
+
+/**
+ * Hook for fetching intent details by intent hash from the backend API.
+ *
+ * This hook provides access to intent data using the intent hash directly,
+ * including intent details, events, and transaction information. The data is automatically
+ * fetched and cached using React Query.
+ *
+ * @param {string | undefined} intentHash - The intent hash to fetch intent for. If undefined, the query will be disabled.
+ *
+ * @returns {UseQueryResult<IntentResponse | undefined>} A query result object containing:
+ *   - data: The intent response 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: intent, isLoading, error } = useIntentByHash('0xabc...');
+ *
+ * if (isLoading) return <div>Loading intent...</div>;
+ * if (error) return <div>Error: {error.message}</div>;
+ * if (intent) {
+ *   console.log('Intent found:', intent.intentHash);
+ *   console.log('Open status:', intent.open);
+ * }
+ * ```
+ *
+ * @remarks
+ * - The query is disabled when intentHash is undefined or empty
+ * - Uses React Query for efficient caching and state management
+ * - Automatically handles error states and loading indicators
+ */
+export const useBackendIntentByHash = (intentHash: string | undefined): UseQueryResult<IntentResponse | undefined> => {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['backend', 'intent', 'hash', intentHash],
+    queryFn: async (): Promise<IntentResponse | undefined> => {
+      if (!intentHash) {
+        return undefined;
+      }
+
+      return sodax.backendApiService.getIntentByHash(intentHash);
+    },
+    enabled: !!intentHash && intentHash.length > 0,
+    retry: 3,
+  });
+};

package/src/hooks/backend/useBackendIntentByTxHash.ts

@@ -0,0 +1,52 @@
+// packages/dapp-kit/src/hooks/backend/useIntentByTxHash.ts
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { IntentResponse } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext';
+
+/**
+ * Hook for fetching intent details by transaction hash from the backend API.
+ *
+ * This hook provides access to intent data associated with a specific transaction hash,
+ * including intent details, events, and transaction information. The data is automatically
+ * fetched and cached using React Query.
+ *
+ * @param {string | undefined} txHash - The transaction hash to fetch intent for. If undefined, the query will be disabled.
+ *
+ * @returns {UseQueryResult<IntentResponse | undefined>} A query result object containing:
+ *   - data: The intent response 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: intent, isLoading, error } = useIntentByTxHash('0x123...');
+ *
+ * if (isLoading) return <div>Loading intent...</div>;
+ * if (error) return <div>Error: {error.message}</div>;
+ * if (intent) {
+ *   console.log('Intent found:', intent.intentHash);
+ * }
+ * ```
+ *
+ * @remarks
+ * - The query is disabled when txHash is undefined or empty
+ * - Uses React Query for efficient caching and state management
+ * - Automatically handles error states and loading indicators
+ */
+export const useBackendIntentByTxHash = (txHash: string | undefined): UseQueryResult<IntentResponse | undefined> => {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['backend', 'intent', 'txHash', txHash],
+    queryFn: async (): Promise<IntentResponse | undefined> => {
+      if (!txHash) {
+        return undefined;
+      }
+
+      return sodax.backendApiService.getIntentByTxHash(txHash);
+    },
+    enabled: !!txHash && txHash.length > 0,
+    retry: 3,
+  });
+};

package/src/hooks/backend/useBackendMoneyMarketAsset.ts

@@ -0,0 +1,57 @@
+// packages/dapp-kit/src/hooks/backend/useMoneyMarketAsset.ts
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { MoneyMarketAsset } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext';
+
+/**
+ * Hook for fetching specific money market asset details from the backend API.
+ *
+ * This hook provides access to detailed information for a specific money market asset,
+ * including reserve information, liquidity rates, borrow rates, and market statistics.
+ * The data is automatically fetched and cached using React Query.
+ *
+ * @param {string | undefined} reserveAddress - The reserve contract address. If undefined, the query will be disabled.
+ *
+ * @returns {UseQueryResult<MoneyMarketAsset | undefined>} A query result object containing:
+ *   - data: The 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
+ * ```typescript
+ * const { data: asset, isLoading, error } = useMoneyMarketAsset('0xabc...');
+ *
+ * if (isLoading) return <div>Loading asset...</div>;
+ * if (error) return <div>Error: {error.message}</div>;
+ * if (asset) {
+ *   console.log('Asset symbol:', asset.symbol);
+ *   console.log('Liquidity rate:', asset.liquidityRate);
+ *   console.log('Variable borrow rate:', asset.variableBorrowRate);
+ * }
+ * ```
+ *
+ * @remarks
+ * - The query is disabled when reserveAddress is undefined or empty
+ * - Uses React Query for efficient caching and state management
+ * - Automatically handles error states and loading indicators
+ * - Returns comprehensive asset information for the specified reserve
+ */
+export const useBackendMoneyMarketAsset = (
+  reserveAddress: string | undefined,
+): UseQueryResult<MoneyMarketAsset | undefined> => {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['backend', 'moneymarket', 'asset', reserveAddress],
+    queryFn: async (): Promise<MoneyMarketAsset | undefined> => {
+      if (!reserveAddress) {
+        return undefined;
+      }
+
+      return sodax.backendApiService.getMoneyMarketAsset(reserveAddress);
+    },
+    enabled: !!reserveAddress && reserveAddress.length > 0,
+    retry: 3,
+  });
+};

package/src/hooks/backend/useBackendMoneyMarketAssetBorrowers.ts

@@ -0,0 +1,67 @@
+// packages/dapp-kit/src/hooks/backend/useMoneyMarketAssetBorrowers.ts
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { MoneyMarketAssetBorrowers } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext';
+
+/**
+ * Hook for fetching borrowers for a specific money market asset from the backend API.
+ *
+ * This hook provides access to the list of borrowers for a specific money market asset,
+ * with pagination support. The data is automatically fetched and cached using React Query.
+ *
+ * @param {Object} params - Parameters for fetching asset borrowers
+ * @param {string | undefined} params.reserveAddress - The reserve contract address. If undefined, the query will be disabled.
+ * @param {string} params.offset - The offset for pagination (number as string)
+ * @param {string} params.limit - The limit for pagination (number as string)
+ *
+ * @returns {UseQueryResult<MoneyMarketAssetBorrowers | undefined>} A query result object containing:
+ *   - data: The asset 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 } = useMoneyMarketAssetBorrowers({
+ *   reserveAddress: '0xabc...',
+ *   offset: '0',
+ *   limit: '20'
+ * });
+ *
+ * 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 reserveAddress is undefined or empty
+ * - Uses React Query for efficient caching and state management
+ * - Automatically handles error states and loading indicators
+ * - Supports pagination through offset and limit parameters
+ */
+export const useBackendMoneyMarketAssetBorrowers = (params: {
+  reserveAddress: string | undefined;
+  offset: string;
+  limit: string;
+}): UseQueryResult<MoneyMarketAssetBorrowers | undefined> => {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['backend', 'moneymarket', 'asset', 'borrowers', params],
+    queryFn: async (): Promise<MoneyMarketAssetBorrowers | undefined> => {
+      if (!params.reserveAddress || !params.offset || !params.limit) {
+        return undefined;
+      }
+
+      return sodax.backendApiService.getMoneyMarketAssetBorrowers(params.reserveAddress, {
+        offset: params.offset,
+        limit: params.limit,
+      });
+    },
+    enabled: !!params.reserveAddress && !!params.offset && !!params.limit,
+    retry: 3,
+  });
+};

package/src/hooks/backend/useBackendMoneyMarketAssetSuppliers.ts

@@ -0,0 +1,67 @@
+// packages/dapp-kit/src/hooks/backend/useMoneyMarketAssetSuppliers.ts
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { MoneyMarketAssetSuppliers } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext';
+
+/**
+ * Hook for fetching suppliers for a specific money market asset from the backend API.
+ *
+ * This hook provides access to the list of suppliers for a specific money market asset,
+ * with pagination support. The data is automatically fetched and cached using React Query.
+ *
+ * @param {Object} params - Parameters for fetching asset suppliers
+ * @param {string | undefined} params.reserveAddress - The reserve contract address. If undefined, the query will be disabled.
+ * @param {string} params.offset - The offset for pagination (number as string)
+ * @param {string} params.limit - The limit for pagination (number as string)
+ *
+ * @returns {UseQueryResult<MoneyMarketAssetSuppliers | undefined>} A query result object containing:
+ *   - data: The asset suppliers 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: suppliers, isLoading, error } = useMoneyMarketAssetSuppliers({
+ *   reserveAddress: '0xabc...',
+ *   offset: '0',
+ *   limit: '20'
+ * });
+ *
+ * if (isLoading) return <div>Loading suppliers...</div>;
+ * if (error) return <div>Error: {error.message}</div>;
+ * if (suppliers) {
+ *   console.log('Total suppliers:', suppliers.total);
+ *   console.log('Suppliers:', suppliers.suppliers);
+ * }
+ * ```
+ *
+ * @remarks
+ * - The query is disabled when reserveAddress is undefined or empty
+ * - Uses React Query for efficient caching and state management
+ * - Automatically handles error states and loading indicators
+ * - Supports pagination through offset and limit parameters
+ */
+export const useBackendMoneyMarketAssetSuppliers = (params: {
+  reserveAddress: string | undefined;
+  offset: string;
+  limit: string;
+}): UseQueryResult<MoneyMarketAssetSuppliers | undefined> => {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['backend', 'moneymarket', 'asset', 'suppliers', params],
+    queryFn: async (): Promise<MoneyMarketAssetSuppliers | undefined> => {
+      if (!params.reserveAddress || !params.offset || !params.limit) {
+        return undefined;
+      }
+
+      return sodax.backendApiService.getMoneyMarketAssetSuppliers(params.reserveAddress, {
+        offset: params.offset,
+        limit: params.limit,
+      });
+    },
+    enabled: !!params.reserveAddress && !!params.offset && !!params.limit,
+    retry: 3,
+  });
+};

package/src/hooks/backend/useBackendMoneyMarketPosition.ts

@@ -0,0 +1,56 @@
+// packages/dapp-kit/src/hooks/backend/useMoneyMarketPosition.ts
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { MoneyMarketPosition } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext';
+
+/**
+ * Hook for fetching money market position for a specific user from the backend API.
+ *
+ * This hook provides access to a user's money market positions, including their
+ * aToken balances, variable debt token balances, and associated reserve information.
+ * The data is automatically fetched and cached using React Query.
+ *
+ * @param {string | undefined} userAddress - The user's wallet address. If undefined, the query will be disabled.
+ *
+ * @returns {UseQueryResult<MoneyMarketPosition | undefined>} A query result object containing:
+ *   - data: The money market position 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: position, isLoading, error } = useMoneyMarketPosition('0x123...');
+ *
+ * if (isLoading) return <div>Loading position...</div>;
+ * if (error) return <div>Error: {error.message}</div>;
+ * if (position) {
+ *   console.log('User address:', position.userAddress);
+ *   console.log('Positions:', position.positions);
+ * }
+ * ```
+ *
+ * @remarks
+ * - The query is disabled when userAddress is undefined or empty
+ * - Uses React Query for efficient caching and state management
+ * - Automatically handles error states and loading indicators
+ * - Includes user's aToken and debt token balances across all reserves
+ */
+export const useBackendMoneyMarketPosition = (
+  userAddress: string | undefined,
+): UseQueryResult<MoneyMarketPosition | undefined> => {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['backend', 'moneymarket', 'position', userAddress],
+    queryFn: async (): Promise<MoneyMarketPosition | undefined> => {
+      if (!userAddress) {
+        return undefined;
+      }
+
+      return sodax.backendApiService.getMoneyMarketPosition(userAddress);
+    },
+    enabled: !!userAddress && userAddress.length > 0,
+    retry: 3,
+  });
+};

package/src/hooks/backend/useBackendOrderbook.ts

@@ -0,0 +1,63 @@
+// packages/dapp-kit/src/hooks/backend/useOrderbook.ts
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { OrderbookResponse } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext';
+
+/**
+ * Hook for fetching the solver orderbook from the backend API.
+ *
+ * This hook provides access to the solver orderbook data, including intent states
+ * and intent data for all available intents. The data is automatically fetched
+ * and cached using React Query with pagination support.
+ *
+ * @param {Object} params - Pagination parameters for the orderbook
+ * @param {string} params.offset - The offset for pagination (number as string)
+ * @param {string} params.limit - The limit for pagination (number as string)
+ *
+ * @returns {UseQueryResult<OrderbookResponse | undefined>} A query result object containing:
+ *   - data: The orderbook response 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: orderbook, isLoading, error } = useOrderbook({
+ *   offset: '0',
+ *   limit: '10'
+ * });
+ *
+ * if (isLoading) return <div>Loading orderbook...</div>;
+ * if (error) return <div>Error: {error.message}</div>;
+ * if (orderbook) {
+ *   console.log('Total intents:', orderbook.total);
+ *   console.log('Intents:', orderbook.data);
+ * }
+ * ```
+ *
+ * @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
+ * - Stale time of 30 seconds for real-time orderbook data
+ * - Supports pagination through offset and limit parameters
+ */
+export const useBackendOrderbook = (
+  params: { offset: string; limit: string } | undefined,
+): UseQueryResult<OrderbookResponse | undefined> => {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['backend', 'solver', 'orderbook', params],
+    queryFn: async (): Promise<OrderbookResponse | undefined> => {
+      if (!params || !params.offset || !params.limit) {
+        return undefined;
+      }
+
+      return sodax.backendApiService.getOrderbook(params);
+    },
+    enabled: !!params && !!params.offset && !!params.limit,
+    staleTime: 30 * 1000, // 30 seconds for real-time data
+    retry: 3,
+  });
+};

package/src/hooks/bridge/index.ts

@@ -0,0 +1,5 @@
+export * from './useBridgeAllowance';
+export * from './useBridgeApprove';
+export * from './useBridge';
+export * from './useGetBridgeableAmount';
+export * from './useGetBridgeableTokens';

package/src/hooks/bridge/useBridge.ts

@@ -0,0 +1,57 @@
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { BridgeError, BridgeErrorCode, SpokeTxHash, HubTxHash, Result, CreateBridgeIntentParams } from '@sodax/sdk';
+import { useMutation, type UseMutationResult } from '@tanstack/react-query';
+import type { SpokeProvider } from '@sodax/sdk';
+
+/**
+ * Hook for executing bridge transactions to transfer tokens between chains.
+ * Uses React Query's useMutation for better state management and caching.
+ *
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for the bridge
+ * @returns {UseMutationResult} Mutation result object containing mutation function and state
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: bridge, isPending } = useBridge(spokeProvider);
+ *
+ * const handleBridge = async () => {
+ *   const result = await bridge({
+ *     srcChainId: '0x2105.base',
+ *     srcAsset: '0x...',
+ *     amount: 1000n,
+ *     dstChainId: '0x89.polygon',
+ *     dstAsset: '0x...',
+ *     recipient: '0x...'
+ *   });
+ *
+ *   console.log('Bridge transaction hashes:', {
+ *     spokeTxHash: result.spokeTxHash,
+ *     hubTxHash: result.hubTxHash
+ *   });
+ * };
+ * ```
+ */
+export function useBridge(
+  spokeProvider: SpokeProvider | undefined,
+): UseMutationResult<Result<[SpokeTxHash, HubTxHash], BridgeError<BridgeErrorCode>>, Error, CreateBridgeIntentParams> {
+  const { sodax } = useSodaxContext();
+
+  return useMutation<Result<[SpokeTxHash, HubTxHash], BridgeError<BridgeErrorCode>>, Error, CreateBridgeIntentParams>({
+    mutationFn: async (params: CreateBridgeIntentParams) => {
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+
+      const result = await sodax.bridge.bridge({
+        params,
+        spokeProvider,
+      });
+
+      if (!result.ok) {
+        throw new Error(`Bridge failed: ${result.error.code}`);
+      }
+
+      return result;
+    },
+  });
+}

package/src/hooks/bridge/useBridgeAllowance.ts

@@ -0,0 +1,49 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { SpokeProvider, CreateBridgeIntentParams } from '@sodax/sdk';
+
+/**
+ * Hook for checking token allowance for bridge operations.
+ *
+ * This hook verifies if the user has approved enough tokens for a specific bridge action.
+ * It automatically queries and tracks the allowance status.
+ *
+ * @param {BridgeParams} params - The parameters for the bridge to check allowance for.
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for allowance checks
+ *
+ * @returns {UseQueryResult<boolean, Error>} A React Query result containing:
+ *   - data: Boolean indicating if allowance is sufficient
+ *   - isLoading: Loading state indicator
+ *   - error: Any error that occurred during the check
+ *
+ * @example
+ * ```typescript
+ * const { data: hasAllowed, isLoading } = useBridgeAllowance(params, spokeProvider);
+ * ```
+ */
+export function useBridgeAllowance(
+  params: CreateBridgeIntentParams | undefined,
+  spokeProvider: SpokeProvider | undefined,
+): UseQueryResult<boolean, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['bridge-allowance', params],
+    queryFn: async () => {
+      if (!spokeProvider || !params) {
+        return false;
+      }
+
+      const allowance = await sodax.bridge.isAllowanceValid({
+        params,
+        spokeProvider,
+      });
+
+      if (allowance.ok) {
+        return allowance.value;
+      }
+      return false;
+    },
+    enabled: !!spokeProvider && !!params,
+  });
+}

package/src/hooks/bridge/useBridgeApprove.ts

@@ -0,0 +1,68 @@
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { CreateBridgeIntentParams, SpokeProvider } from '@sodax/sdk';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+
+interface UseBridgeApproveReturn {
+  approve: (params: CreateBridgeIntentParams) => Promise<boolean>;
+  isLoading: boolean;
+  error: Error | null;
+  resetError: () => void;
+}
+
+/**
+ * Hook for approving token spending for bridge actions
+ * @param spokeProvider The spoke provider instance for the chain
+ * @returns Object containing approve function, loading state, error state and reset function
+ * @example
+ * ```tsx
+ * const { approve, isLoading, error } = useBridgeApprove(spokeProvider);
+ *
+ * // Approve tokens for bridge action
+ * await approve({
+ *   srcChainId: '0x2105.base',
+ *   srcAsset: '0x...',
+ *   amount: 1000n,
+ *   dstChainId: '0x89.polygon',
+ *   dstAsset: '0x...',
+ *   recipient: '0x...'
+ * });
+ * ```
+ */
+export function useBridgeApprove(spokeProvider: SpokeProvider | undefined): UseBridgeApproveReturn {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+
+  const {
+    mutateAsync: approve,
+    isPending,
+    error,
+    reset: resetError,
+  } = useMutation({
+    mutationFn: async (params: CreateBridgeIntentParams) => {
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+
+      const allowance = await sodax.bridge.approve({
+        params,
+        spokeProvider,
+      });
+
+      if (!allowance.ok) {
+        throw new Error('Failed to approve tokens for bridge');
+      }
+      return true;
+    },
+    onSuccess: (_, params) => {
+      // Invalidate allowance query to refetch the new allowance
+      queryClient.invalidateQueries({ queryKey: ['bridge-allowance', params] });
+    },
+  });
+
+  return {
+    approve,
+    isLoading: isPending,
+    error: error,
+    resetError,
+  };
+}

package/src/hooks/bridge/useGetBridgeableAmount.ts

@@ -0,0 +1,50 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { Result, SpokeChainId, XToken } from '@sodax/sdk';
+
+/**
+ * Hook for getting the amount available to be bridged.
+ *
+ * This hook is used to check if a target chain has enough balance to bridge when bridging.
+ * It automatically queries and tracks the available amount to be bridged.
+ *
+ * @param {SpokeChainId | undefined} chainId - The chain ID to get the balance for
+ * @param {string | undefined} token - The token address to get the balance for
+ *
+ * @returns {UseQueryResult<bigint, Error>} A React Query result containing:
+ *   - data: The available amount to be bridged (bigint)
+ *   - error: Any error that occurred during the check
+ *
+ * @example
+ * ```typescript
+ * const { data: balance, isLoading } = useSpokeAssetManagerTokenBalance(chainId, tokenAddress);
+ *
+ * if (balance) {
+ *   console.log('Asset manager token balance:', balance.toString());
+ * }
+ * ```
+ */
+export function useGetBridgeableAmount(
+  from: XToken | undefined,
+  to: XToken | undefined,
+): UseQueryResult<bigint, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['spoke-asset-manager-token-balance', from, to],
+    queryFn: async () => {
+      if (!from || !to) {
+        return 0n;
+      }
+
+      const result = await sodax.bridge.getBridgeableAmount(from, to);
+      if (result.ok) {
+        return result.value;
+      }
+
+      console.error('Error getting bridgeable amount:', result.error);
+      return 0n;
+    },
+    enabled: !!from && !!to,
+  });
+}