@sodax/dapp-kit 0.0.1-rc.9 → 1.0.0-beta

package/src/hooks/backend/README.md

@@ -0,0 +1,135 @@
+# Backend API Hooks
+
+This directory contains React hooks for interacting with the Sodax Backend API through the `BackendApiService`. These hooks provide a React-friendly interface with automatic caching, error handling, and loading states using React Query.
+
+## Available Hooks
+
+### Intent Hooks
+
+#### `useIntentByTxHash(txHash: string | undefined)`
+Fetches intent details by transaction hash.
+
+```typescript
+import { useIntentByTxHash } from '@sodax/dapp-kit';
+
+const { data: intent, isLoading, error } = useIntentByTxHash('0x123...');
+```
+
+#### `useIntentByHash(intentHash: string | undefined)`
+Fetches intent details by intent hash.
+
+```typescript
+import { useIntentByHash } from '@sodax/dapp-kit';
+
+const { data: intent, isLoading, error } = useIntentByHash('0xabc...');
+```
+
+### Solver Hooks
+
+#### `useOrderbook(params: { offset: string; limit: string } | undefined)`
+Fetches the solver orderbook with pagination support.
+
+```typescript
+import { useOrderbook } from '@sodax/dapp-kit';
+
+const { data: orderbook, isLoading, error } = useOrderbook({
+  offset: '0',
+  limit: '10'
+});
+```
+
+### Money Market Hooks
+
+#### `useMoneyMarketPosition(userAddress: string | undefined)`
+Fetches a user's money market positions.
+
+```typescript
+import { useMoneyMarketPosition } from '@sodax/dapp-kit';
+
+const { data: position, isLoading, error } = useMoneyMarketPosition('0x123...');
+```
+
+#### `useAllMoneyMarketAssets()`
+Fetches all available money market assets.
+
+```typescript
+import { useAllMoneyMarketAssets } from '@sodax/dapp-kit';
+
+const { data: assets, isLoading, error } = useAllMoneyMarketAssets();
+```
+
+#### `useMoneyMarketAsset(reserveAddress: string | undefined)`
+Fetches details for a specific money market asset.
+
+```typescript
+import { useMoneyMarketAsset } from '@sodax/dapp-kit';
+
+const { data: asset, isLoading, error } = useMoneyMarketAsset('0xabc...');
+```
+
+#### `useMoneyMarketAssetBorrowers(params)`
+Fetches borrowers for a specific money market asset.
+
+```typescript
+import { useMoneyMarketAssetBorrowers } from '@sodax/dapp-kit';
+
+const { data: borrowers, isLoading, error } = useMoneyMarketAssetBorrowers({
+  reserveAddress: '0xabc...',
+  offset: '0',
+  limit: '20'
+});
+```
+
+#### `useMoneyMarketAssetSuppliers(params)`
+Fetches suppliers for a specific money market asset.
+
+```typescript
+import { useMoneyMarketAssetSuppliers } from '@sodax/dapp-kit';
+
+const { data: suppliers, isLoading, error } = useMoneyMarketAssetSuppliers({
+  reserveAddress: '0xabc...',
+  offset: '0',
+  limit: '20'
+});
+```
+
+#### `useAllMoneyMarketBorrowers(params)`
+Fetches all money market borrowers across all assets.
+
+```typescript
+import { useAllMoneyMarketBorrowers } from '@sodax/dapp-kit';
+
+const { data: borrowers, isLoading, error } = useAllMoneyMarketBorrowers({
+  offset: '0',
+  limit: '50'
+});
+```
+
+## Features
+
+- **Automatic Caching**: All hooks use React Query for efficient data caching
+- **Error Handling**: Built-in error states and retry logic
+- **Loading States**: Automatic loading indicators
+- **TypeScript Support**: Full type safety with proper TypeScript definitions
+- **Pagination Support**: Built-in pagination for list endpoints
+- **Conditional Queries**: Queries are automatically disabled when required parameters are missing
+- **Context Integration**: Uses `useSodaxContext` for consistent SDK access across the application
+
+## Stale Times
+
+Different hooks have different stale times optimized for their data types:
+
+
+## Error Handling
+
+All hooks return standard React Query result objects with:
+
+- `data`: The fetched data (undefined when loading or on error)
+- `isLoading`: Boolean indicating if the request is in progress
+- `error`: Error object if the request failed
+- `refetch`: Function to manually trigger a data refresh
+
+## Requirements
+
+- **SodaxProvider**: All backend hooks require the app to be wrapped with `SodaxProvider` from `@sodax/dapp-kit`
+- **React Query**: The hooks use React Query for state management and caching

package/src/hooks/backend/index.ts

@@ -0,0 +1,23 @@
+// packages/dapp-kit/src/hooks/backend/index.ts
+/**
+ * Backend API Hooks
+ *
+ * This module exports all hooks for interacting with the BackendApiService.
+ * These hooks provide a React-friendly interface to the Sodax Backend API,
+ * including intent management, solver orderbook, and money market operations.
+ */
+
+// Intent hooks
+export { useBackendIntentByTxHash } from './useBackendIntentByTxHash';
+export { useBackendIntentByHash } from './useBackendIntentByHash';
+
+// Solver hooks
+export { useBackendOrderbook } from './useBackendOrderbook';
+
+// 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';

package/src/hooks/backend/useBackendAllMoneyMarketAssets.ts

@@ -0,0 +1,49 @@
+// packages/dapp-kit/src/hooks/backend/useAllMoneyMarketAssets.ts
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { MoneyMarketAsset } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext';
+
+/**
+ * Hook for fetching all money market assets from the backend API.
+ *
+ * This hook provides access to all available money market assets, including
+ * their reserve information, liquidity rates, borrow rates, and market statistics.
+ * The data is automatically fetched and cached using React Query.
+ *
+ * @returns {UseQueryResult<MoneyMarketAsset[]>} A query result object containing:
+ *   - data: Array of 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: assets, isLoading, error } = useAllMoneyMarketAssets();
+ *
+ * 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
+ * - Uses React Query for efficient caching and state management
+ * - Automatically handles error states and loading indicators
+ * - Returns comprehensive asset information including rates and statistics
+ * - No parameters required - fetches all available assets
+ */
+export const useBackendAllMoneyMarketAssets = (): UseQueryResult<MoneyMarketAsset[]> => {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['backend', 'moneymarket', 'assets', 'all'],
+    queryFn: async (): Promise<MoneyMarketAsset[]> => {
+      return sodax.backendApi.getAllMoneyMarketAssets();
+    },
+    retry: 3,
+  });
+};

package/src/hooks/backend/useBackendAllMoneyMarketBorrowers.ts

@@ -0,0 +1,61 @@
+// packages/dapp-kit/src/hooks/backend/useAllMoneyMarketBorrowers.ts
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { MoneyMarketBorrowers } from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext';
+
+/**
+ * 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'
+ * });
+ *
+ * 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: { offset: string; limit: string } | undefined,
+): UseQueryResult<MoneyMarketBorrowers | undefined> => {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['backend', 'moneymarket', 'borrowers', 'all', params],
+    queryFn: async (): Promise<MoneyMarketBorrowers | undefined> => {
+      if (!params || !params.offset || !params.limit) {
+        return undefined;
+      }
+
+      return sodax.backendApi.getAllMoneyMarketBorrowers(params);
+    },
+    enabled: !!params && !!params.offset && !!params.limit,
+    retry: 3,
+  });
+};

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.backendApi.getIntentByHash(intentHash);
+    },
+    enabled: !!intentHash && intentHash.length > 0,
+    retry: 3,
+  });
+};

package/src/hooks/backend/useBackendIntentByTxHash.ts

@@ -0,0 +1,57 @@
+// 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 intent created transaction hash from the backend API.
+ *
+ * This hook provides access to intent data associated with the transaction hash from when
+ * the intent was created on the hub chain, including intent details, events, and transaction
+ * information. The data is automatically fetched and cached using React Query.
+ *
+ * @param {string | undefined} txHash - The intent created transaction hash from the hub chain 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
+ * - Intents are only created on the hub chain, so the transaction hash must be from the hub chain
+ * - 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,
+  refetchInterval = 1000,
+): UseQueryResult<IntentResponse | undefined> => {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['backend', 'intent', 'txHash', txHash],
+    queryFn: async (): Promise<IntentResponse | undefined> => {
+      if (!txHash) {
+        return undefined;
+      }
+
+      return sodax.backendApi.getIntentByTxHash(txHash);
+    },
+    refetchInterval,
+    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.backendApi.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.backendApi.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.backendApi.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.backendApi.getMoneyMarketPosition(userAddress);
+    },
+    enabled: !!userAddress && userAddress.length > 0,
+    retry: 3,
+  });
+};