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

package/dist/hooks/backend/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 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.
+ */
+export { useBackendIntentByTxHash } from './useBackendIntentByTxHash';
+export { useBackendIntentByHash } from './useBackendIntentByHash';
+export { useBackendOrderbook } from './useBackendOrderbook';
+export { useBackendMoneyMarketPosition } from './useBackendMoneyMarketPosition';
+export { useBackendAllMoneyMarketAssets } from './useBackendAllMoneyMarketAssets';
+export { useBackendMoneyMarketAsset } from './useBackendMoneyMarketAsset';
+export { useBackendMoneyMarketAssetBorrowers } from './useBackendMoneyMarketAssetBorrowers';
+export { useBackendMoneyMarketAssetSuppliers } from './useBackendMoneyMarketAssetSuppliers';
+export { useBackendAllMoneyMarketBorrowers } from './useBackendAllMoneyMarketBorrowers';
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/backend/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/backend/index.ts"],"names":[],"mappings":"AACA;;;;;;GAMG;AAGH,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAG5D,OAAO,EAAE,6BAA6B,EAAE,MAAM,iCAAiC,CAAC;AAChF,OAAO,EAAE,8BAA8B,EAAE,MAAM,kCAAkC,CAAC;AAClF,OAAO,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAC1E,OAAO,EAAE,mCAAmC,EAAE,MAAM,uCAAuC,CAAC;AAC5F,OAAO,EAAE,mCAAmC,EAAE,MAAM,uCAAuC,CAAC;AAC5F,OAAO,EAAE,iCAAiC,EAAE,MAAM,qCAAqC,CAAC"}

package/dist/hooks/backend/useBackendAllMoneyMarketAssets.d.ts

@@ -0,0 +1,37 @@
+import { type UseQueryResult } from '@tanstack/react-query';
+import type { MoneyMarketAsset } from '@sodax/sdk';
+/**
+ * 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 declare const useBackendAllMoneyMarketAssets: () => UseQueryResult<MoneyMarketAsset[]>;
+//# sourceMappingURL=useBackendAllMoneyMarketAssets.d.ts.map

package/dist/hooks/backend/useBackendAllMoneyMarketAssets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBackendAllMoneyMarketAssets.d.ts","sourceRoot":"","sources":["../../../src/hooks/backend/useBackendAllMoneyMarketAssets.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAGnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,8BAA8B,QAAO,cAAc,CAAC,gBAAgB,EAAE,CAUlF,CAAC"}

package/dist/hooks/backend/useBackendAllMoneyMarketBorrowers.d.ts

@@ -0,0 +1,45 @@
+import { type UseQueryResult } from '@tanstack/react-query';
+import type { MoneyMarketBorrowers } from '@sodax/sdk';
+/**
+ * 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 declare const useBackendAllMoneyMarketBorrowers: (params: {
+    offset: string;
+    limit: string;
+} | undefined) => UseQueryResult<MoneyMarketBorrowers | undefined>;
+//# sourceMappingURL=useBackendAllMoneyMarketBorrowers.d.ts.map

package/dist/hooks/backend/useBackendAllMoneyMarketBorrowers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBackendAllMoneyMarketBorrowers.d.ts","sourceRoot":"","sources":["../../../src/hooks/backend/useBackendAllMoneyMarketBorrowers.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAGvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,iCAAiC,WACpC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,KACpD,cAAc,CAAC,oBAAoB,GAAG,SAAS,CAejD,CAAC"}

package/dist/hooks/backend/useBackendIntentByHash.d.ts

@@ -0,0 +1,36 @@
+import { type UseQueryResult } from '@tanstack/react-query';
+import type { IntentResponse } from '@sodax/sdk';
+/**
+ * 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 declare const useBackendIntentByHash: (intentHash: string | undefined) => UseQueryResult<IntentResponse | undefined>;
+//# sourceMappingURL=useBackendIntentByHash.d.ts.map

package/dist/hooks/backend/useBackendIntentByHash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBackendIntentByHash.d.ts","sourceRoot":"","sources":["../../../src/hooks/backend/useBackendIntentByHash.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAGjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,sBAAsB,eAAgB,MAAM,GAAG,SAAS,KAAG,cAAc,CAAC,cAAc,GAAG,SAAS,CAehH,CAAC"}

package/dist/hooks/backend/useBackendIntentByTxHash.d.ts

@@ -0,0 +1,35 @@
+import { type UseQueryResult } from '@tanstack/react-query';
+import type { IntentResponse } from '@sodax/sdk';
+/**
+ * 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 declare const useBackendIntentByTxHash: (txHash: string | undefined) => UseQueryResult<IntentResponse | undefined>;
+//# sourceMappingURL=useBackendIntentByTxHash.d.ts.map

package/dist/hooks/backend/useBackendIntentByTxHash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBackendIntentByTxHash.d.ts","sourceRoot":"","sources":["../../../src/hooks/backend/useBackendIntentByTxHash.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAGjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,wBAAwB,WAAY,MAAM,GAAG,SAAS,KAAG,cAAc,CAAC,cAAc,GAAG,SAAS,CAe9G,CAAC"}

package/dist/hooks/backend/useBackendMoneyMarketAsset.d.ts

@@ -0,0 +1,38 @@
+import { type UseQueryResult } from '@tanstack/react-query';
+import type { MoneyMarketAsset } from '@sodax/sdk';
+/**
+ * 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 declare const useBackendMoneyMarketAsset: (reserveAddress: string | undefined) => UseQueryResult<MoneyMarketAsset | undefined>;
+//# sourceMappingURL=useBackendMoneyMarketAsset.d.ts.map

package/dist/hooks/backend/useBackendMoneyMarketAsset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBackendMoneyMarketAsset.d.ts","sourceRoot":"","sources":["../../../src/hooks/backend/useBackendMoneyMarketAsset.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAGnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,0BAA0B,mBACrB,MAAM,GAAG,SAAS,KACjC,cAAc,CAAC,gBAAgB,GAAG,SAAS,CAe7C,CAAC"}

package/dist/hooks/backend/useBackendMoneyMarketAssetBorrowers.d.ts

@@ -0,0 +1,47 @@
+import { type UseQueryResult } from '@tanstack/react-query';
+import type { MoneyMarketAssetBorrowers } from '@sodax/sdk';
+/**
+ * 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 declare const useBackendMoneyMarketAssetBorrowers: (params: {
+    reserveAddress: string | undefined;
+    offset: string;
+    limit: string;
+}) => UseQueryResult<MoneyMarketAssetBorrowers | undefined>;
+//# sourceMappingURL=useBackendMoneyMarketAssetBorrowers.d.ts.map

package/dist/hooks/backend/useBackendMoneyMarketAssetBorrowers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBackendMoneyMarketAssetBorrowers.d.ts","sourceRoot":"","sources":["../../../src/hooks/backend/useBackendMoneyMarketAssetBorrowers.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAG5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,mCAAmC,WAAY;IAC1D,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,KAAG,cAAc,CAAC,yBAAyB,GAAG,SAAS,CAkBvD,CAAC"}

package/dist/hooks/backend/useBackendMoneyMarketAssetSuppliers.d.ts

@@ -0,0 +1,47 @@
+import { type UseQueryResult } from '@tanstack/react-query';
+import type { MoneyMarketAssetSuppliers } from '@sodax/sdk';
+/**
+ * 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 declare const useBackendMoneyMarketAssetSuppliers: (params: {
+    reserveAddress: string | undefined;
+    offset: string;
+    limit: string;
+}) => UseQueryResult<MoneyMarketAssetSuppliers | undefined>;
+//# sourceMappingURL=useBackendMoneyMarketAssetSuppliers.d.ts.map

package/dist/hooks/backend/useBackendMoneyMarketAssetSuppliers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBackendMoneyMarketAssetSuppliers.d.ts","sourceRoot":"","sources":["../../../src/hooks/backend/useBackendMoneyMarketAssetSuppliers.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAG5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,mCAAmC,WAAY;IAC1D,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,KAAG,cAAc,CAAC,yBAAyB,GAAG,SAAS,CAkBvD,CAAC"}

package/dist/hooks/backend/useBackendMoneyMarketPosition.d.ts

@@ -0,0 +1,37 @@
+import { type UseQueryResult } from '@tanstack/react-query';
+import type { MoneyMarketPosition } from '@sodax/sdk';
+/**
+ * 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 declare const useBackendMoneyMarketPosition: (userAddress: string | undefined) => UseQueryResult<MoneyMarketPosition | undefined>;
+//# sourceMappingURL=useBackendMoneyMarketPosition.d.ts.map

package/dist/hooks/backend/useBackendMoneyMarketPosition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBackendMoneyMarketPosition.d.ts","sourceRoot":"","sources":["../../../src/hooks/backend/useBackendMoneyMarketPosition.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAGtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,6BAA6B,gBAC3B,MAAM,GAAG,SAAS,KAC9B,cAAc,CAAC,mBAAmB,GAAG,SAAS,CAehD,CAAC"}

package/dist/hooks/backend/useBackendOrderbook.d.ts

@@ -0,0 +1,46 @@
+import { type UseQueryResult } from '@tanstack/react-query';
+import type { OrderbookResponse } from '@sodax/sdk';
+/**
+ * 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 declare const useBackendOrderbook: (params: {
+    offset: string;
+    limit: string;
+} | undefined) => UseQueryResult<OrderbookResponse | undefined>;
+//# sourceMappingURL=useBackendOrderbook.d.ts.map

package/dist/hooks/backend/useBackendOrderbook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBackendOrderbook.d.ts","sourceRoot":"","sources":["../../../src/hooks/backend/useBackendOrderbook.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAGpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,mBAAmB,WACtB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,KACpD,cAAc,CAAC,iBAAiB,GAAG,SAAS,CAgB9C,CAAC"}

package/dist/hooks/bridge/useGetBridgeableTokens.d.ts

@@ -1,5 +1,5 @@
 import { type UseQueryResult } from '@tanstack/react-query';
-import { type XToken, type SpokeChainId } from '@sodax/sdk';
+import type { XToken, SpokeChainId } from '@sodax/sdk';
 /**
 /**
  * Hook for retrieving all bridgeable tokens from a source token on one chain to a destination chain.

package/dist/hooks/bridge/useGetBridgeableTokens.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useGetBridgeableTokens.d.ts","sourceRoot":"","sources":["../../../src/hooks/bridge/useGetBridgeableTokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAG5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,YAAY,GAAG,SAAS,EAC9B,EAAE,EAAE,YAAY,GAAG,SAAS,EAC5B,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,cAAc,CAAC,MAAM,EAAE,EAAE,KAAK,CAAC,CAoBjC"}
+{"version":3,"file":"useGetBridgeableTokens.d.ts","sourceRoot":"","sources":["../../../src/hooks/bridge/useGetBridgeableTokens.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAGvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,YAAY,GAAG,SAAS,EAC9B,EAAE,EAAE,YAAY,GAAG,SAAS,EAC5B,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,cAAc,CAAC,MAAM,EAAE,EAAE,KAAK,CAAC,CAoBjC"}

package/dist/hooks/index.d.ts

@@ -2,5 +2,6 @@ export * from './shared';
 export * from './provider';
 export * from './mm';
 export * from './swap';
+export * from './backend';
 export * from './bridge';
 //# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,MAAM,CAAC;AACrB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,MAAM,CAAC;AACrB,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC"}

package/dist/index.js

@@ -393,6 +393,136 @@ function useCancelSwap(spokeProvider) {
     }
   });
 }
+var useBackendIntentByTxHash = (txHash) => {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["backend", "intent", "txHash", txHash],
+    queryFn: async () => {
+      if (!txHash) {
+        return void 0;
+      }
+      return sodax.backendApiService.getIntentByTxHash(txHash);
+    },
+    enabled: !!txHash && txHash.length > 0,
+    retry: 3
+  });
+};
+var useBackendIntentByHash = (intentHash) => {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["backend", "intent", "hash", intentHash],
+    queryFn: async () => {
+      if (!intentHash) {
+        return void 0;
+      }
+      return sodax.backendApiService.getIntentByHash(intentHash);
+    },
+    enabled: !!intentHash && intentHash.length > 0,
+    retry: 3
+  });
+};
+var useBackendOrderbook = (params) => {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["backend", "solver", "orderbook", params],
+    queryFn: async () => {
+      if (!params || !params.offset || !params.limit) {
+        return void 0;
+      }
+      return sodax.backendApiService.getOrderbook(params);
+    },
+    enabled: !!params && !!params.offset && !!params.limit,
+    staleTime: 30 * 1e3,
+    // 30 seconds for real-time data
+    retry: 3
+  });
+};
+var useBackendMoneyMarketPosition = (userAddress) => {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["backend", "moneymarket", "position", userAddress],
+    queryFn: async () => {
+      if (!userAddress) {
+        return void 0;
+      }
+      return sodax.backendApiService.getMoneyMarketPosition(userAddress);
+    },
+    enabled: !!userAddress && userAddress.length > 0,
+    retry: 3
+  });
+};
+var useBackendAllMoneyMarketAssets = () => {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["backend", "moneymarket", "assets", "all"],
+    queryFn: async () => {
+      return sodax.backendApiService.getAllMoneyMarketAssets();
+    },
+    retry: 3
+  });
+};
+var useBackendMoneyMarketAsset = (reserveAddress) => {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["backend", "moneymarket", "asset", reserveAddress],
+    queryFn: async () => {
+      if (!reserveAddress) {
+        return void 0;
+      }
+      return sodax.backendApiService.getMoneyMarketAsset(reserveAddress);
+    },
+    enabled: !!reserveAddress && reserveAddress.length > 0,
+    retry: 3
+  });
+};
+var useBackendMoneyMarketAssetBorrowers = (params) => {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["backend", "moneymarket", "asset", "borrowers", params],
+    queryFn: async () => {
+      if (!params.reserveAddress || !params.offset || !params.limit) {
+        return void 0;
+      }
+      return sodax.backendApiService.getMoneyMarketAssetBorrowers(params.reserveAddress, {
+        offset: params.offset,
+        limit: params.limit
+      });
+    },
+    enabled: !!params.reserveAddress && !!params.offset && !!params.limit,
+    retry: 3
+  });
+};
+var useBackendMoneyMarketAssetSuppliers = (params) => {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["backend", "moneymarket", "asset", "suppliers", params],
+    queryFn: async () => {
+      if (!params.reserveAddress || !params.offset || !params.limit) {
+        return void 0;
+      }
+      return sodax.backendApiService.getMoneyMarketAssetSuppliers(params.reserveAddress, {
+        offset: params.offset,
+        limit: params.limit
+      });
+    },
+    enabled: !!params.reserveAddress && !!params.offset && !!params.limit,
+    retry: 3
+  });
+};
+var useBackendAllMoneyMarketBorrowers = (params) => {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["backend", "moneymarket", "borrowers", "all", params],
+    queryFn: async () => {
+      if (!params || !params.offset || !params.limit) {
+        return void 0;
+      }
+      return sodax.backendApiService.getAllMoneyMarketBorrowers(params);
+    },
+    enabled: !!params && !!params.offset && !!params.limit,
+    retry: 3
+  });
+};
 function useBridgeAllowance(params, spokeProvider) {
   const { sodax } = useSodaxContext();
   return reactQuery.useQuery({
@@ -514,6 +644,15 @@ var getSpokeTokenAddressByVault = (spokeChainId, vault) => {
 
 exports.SodaxProvider = SodaxProvider;
 exports.getSpokeTokenAddressByVault = getSpokeTokenAddressByVault;
+exports.useBackendAllMoneyMarketAssets = useBackendAllMoneyMarketAssets;
+exports.useBackendAllMoneyMarketBorrowers = useBackendAllMoneyMarketBorrowers;
+exports.useBackendIntentByHash = useBackendIntentByHash;
+exports.useBackendIntentByTxHash = useBackendIntentByTxHash;
+exports.useBackendMoneyMarketAsset = useBackendMoneyMarketAsset;
+exports.useBackendMoneyMarketAssetBorrowers = useBackendMoneyMarketAssetBorrowers;
+exports.useBackendMoneyMarketAssetSuppliers = useBackendMoneyMarketAssetSuppliers;
+exports.useBackendMoneyMarketPosition = useBackendMoneyMarketPosition;
+exports.useBackendOrderbook = useBackendOrderbook;
 exports.useBorrow = useBorrow;
 exports.useBridge = useBridge;
 exports.useBridgeAllowance = useBridgeAllowance;