@sodax/dapp-kit 0.0.1-rc.29 → 0.0.1-rc.30

package/src/hooks/staking/useStakingConfig.ts

@@ -0,0 +1,40 @@
+// packages/dapp-kit/src/hooks/staking/useStakingConfig.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { StakingConfig } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+
+/**
+ * Hook for fetching staking configuration from the stakedSoda contract.
+ * Uses React Query for efficient caching and state management.
+ *
+ * @param {number} refetchInterval - The interval in milliseconds to refetch data (default: 30000)
+ * @returns {UseQueryResult<StakingConfig, Error>} Query result object containing staking config and state
+ *
+ * @example
+ * ```typescript
+ * const { data: stakingConfig, isLoading, error } = useStakingConfig();
+ *
+ * if (isLoading) return <div>Loading staking config...</div>;
+ * if (stakingConfig) {
+ *   console.log('Unstaking period (days):', stakingConfig.unstakingPeriod / 86400n);
+ *   console.log('Max penalty (%):', stakingConfig.maxPenalty);
+ * }
+ * ```
+ */
+export function useStakingConfig(refetchInterval = 30000): UseQueryResult<StakingConfig, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['soda', 'stakingConfig'],
+    queryFn: async () => {
+      const result = await sodax.staking.getStakingConfig();
+
+      if (!result.ok) {
+        throw new Error(`Failed to fetch staking config: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+    refetchInterval,
+  });
+}

package/src/hooks/staking/useStakingInfo.ts

@@ -0,0 +1,50 @@
+// packages/dapp-kit/src/hooks/staking/useStakingInfo.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { StakingInfo, SpokeProvider } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+
+/**
+ * Hook for fetching comprehensive staking information for a user.
+ * Uses React Query for efficient caching and state management.
+ *
+ * @param {SpokeProvider | undefined} spokeProvider - The spoke provider to use for the query
+ * @param {number} refetchInterval - The interval in milliseconds to refetch data (default: 5000)
+ * @returns {UseQueryResult<StakingInfo, Error>} Query result object containing staking info and state
+ *
+ * @example
+ * ```typescript
+ * const { data: stakingInfo, isLoading, error } = useStakingInfo(spokeProvider);
+ *
+ * if (isLoading) return <div>Loading staking info...</div>;
+ * if (stakingInfo) {
+ *   console.log('Total staked:', stakingInfo.totalStaked);
+ *   console.log('User staked:', stakingInfo.userStaked);
+ *   console.log('xSODA balance:', stakingInfo.userXSodaBalance);
+ * }
+ * ```
+ */
+export function useStakingInfo(
+  spokeProvider: SpokeProvider | undefined,
+  refetchInterval = 5000,
+): UseQueryResult<StakingInfo, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['soda', 'stakingInfo', spokeProvider?.chainConfig.chain.id],
+    queryFn: async () => {
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+
+      const result = await sodax.staking.getStakingInfoFromSpoke(spokeProvider);
+
+      if (!result.ok) {
+        throw new Error(`Failed to fetch staking info: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+    enabled: !!spokeProvider,
+    refetchInterval,
+  });
+}

package/src/hooks/staking/useUnstake.ts

@@ -0,0 +1,54 @@
+// packages/dapp-kit/src/hooks/staking/useUnstake.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { UnstakeParams, SpokeTxHash, HubTxHash, SpokeProvider } from '@sodax/sdk';
+import { useMutation, useQueryClient, type UseMutationResult } from '@tanstack/react-query';
+
+/**
+ * Hook for executing unstake transactions to unstake xSODA shares.
+ * Uses React Query's useMutation for better state management and caching.
+ *
+ * @param {SpokeProvider | undefined} spokeProvider - The spoke provider to use for the unstake
+ * @returns {UseMutationResult<[SpokeTxHash, HubTxHash], Error, Omit<UnstakeParams, 'action'>>} Mutation result object containing mutation function and state
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: unstake, isPending } = useUnstake(spokeProvider);
+ *
+ * const handleUnstake = async () => {
+ *   const result = await unstake({
+ *     amount: 1000000000000000000n, // 1 xSODA
+ *     account: '0x...'
+ *   });
+ *
+ *   console.log('Unstake successful:', result);
+ * };
+ * ```
+ */
+export function useUnstake(
+  spokeProvider: SpokeProvider | undefined,
+): UseMutationResult<[SpokeTxHash, HubTxHash], Error, Omit<UnstakeParams, 'action'>> {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+
+  return useMutation<[SpokeTxHash, HubTxHash], Error, Omit<UnstakeParams, 'action'>>({
+    mutationFn: async (params: Omit<UnstakeParams, 'action'>) => {
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+
+      const result = await sodax.staking.unstake({ ...params, action: 'unstake' }, spokeProvider);
+
+      if (!result.ok) {
+        throw new Error(`Unstake failed: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+    onSuccess: () => {
+      // Invalidate relevant queries to refresh data
+      queryClient.invalidateQueries({ queryKey: ['stakingInfo'] });
+      queryClient.invalidateQueries({ queryKey: ['unstakingInfo'] });
+      queryClient.invalidateQueries({ queryKey: ['unstakingInfoWithPenalty'] });
+    },
+  });
+}

package/src/hooks/staking/useUnstakeAllowance.ts

@@ -0,0 +1,58 @@
+// packages/dapp-kit/src/hooks/staking/useStakeAllowance.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { UnstakeParams, SpokeProvider } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+
+/**
+ * Hook for checking xSODA token allowance for unstaking operations.
+ * Uses React Query for efficient caching and state management.
+ *
+ * @param {Omit<UnstakeParams, 'action'> | undefined} params - The unstaking parameters. If undefined, the query will be disabled.
+ * @param {SpokeProvider | undefined} spokeProvider - The spoke provider to use for the allowance check
+ * @returns {UseQueryResult<boolean, Error>} Query result object containing allowance data and state
+ *
+ * @example
+ * ```typescript
+ * const { data: hasAllowed, isLoading } = useUnstakeAllowance(
+ *   {
+ *     amount: 1000000000000000000n, // 1 xSODA
+ *     account: '0x...'
+ *   },
+ *   spokeProvider
+ * );
+ *
+ * if (isLoading) return <div>Checking allowance...</div>;
+ * if (hasAllowed) {
+ *   console.log('Sufficient allowance for unstaking');
+ * }
+ * ```
+ */
+export function useUnstakeAllowance(
+  params: Omit<UnstakeParams, 'action'> | undefined,
+  spokeProvider: SpokeProvider | undefined,
+): UseQueryResult<boolean, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['soda', 'unstakeAllowance', params, spokeProvider?.chainConfig.chain.id],
+    queryFn: async () => {
+      if (!params || !spokeProvider) {
+        return false;
+      }
+
+      const result = await sodax.staking.isAllowanceValid({
+        params: { ...params, action: 'unstake' },
+        spokeProvider,
+      });
+
+      if (!result.ok) {
+        console.error(`Unstake allowance check failed: ${result.error.code}, error: ${result.error.error}`);
+        throw new Error(`Unstake allowance check failed: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+    enabled: !!params && !!spokeProvider,
+    refetchInterval: 5000, // Refetch every 5 seconds
+  });
+}

package/src/hooks/staking/useUnstakeApprove.ts

@@ -0,0 +1,52 @@
+// packages/dapp-kit/src/hooks/staking/useStakeApprove.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { TxReturnType, UnstakeParams } from '@sodax/sdk';
+import { useMutation, type UseMutationResult } from '@tanstack/react-query';
+import type { SpokeProvider } from '@sodax/sdk';
+
+/**
+ * Hook for approving xSODA token spending for unstaking operations.
+ * Uses React Query's useMutation for better state management and caching.
+ *
+ * @param {SpokeProvider | undefined} spokeProvider - The spoke provider to use for the approval
+ * @returns {UseMutationResult<TxReturnType<SpokeProvider, false>, Error, Omit<UnstakeParams, 'action'>>} Mutation result object containing mutation function and state
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: approve, isPending } = useUnstakeApprove(spokeProvider);
+ *
+ * const handleApprove = async () => {
+ *   const result = await approve({
+ *     amount: 1000000000000000000n, // 1 xSODA
+ *     account: '0x...'
+ *   });
+ *
+ *   console.log('Approval successful:', result);
+ * };
+ * ```
+ */
+export function useUnstakeApprove(
+  spokeProvider: SpokeProvider | undefined,
+): UseMutationResult<TxReturnType<SpokeProvider, false>, Error, Omit<UnstakeParams, 'action'>> {
+  const { sodax } = useSodaxContext();
+
+  return useMutation<TxReturnType<SpokeProvider, false>, Error, Omit<UnstakeParams, 'action'>>({
+    mutationFn: async (params: Omit<UnstakeParams, 'action'>) => {
+      console.log('useUnstakeApprove called with params:', params);
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+
+      const result = await sodax.staking.approve({
+        params: { ...params, action: 'unstake' },
+        spokeProvider,
+      });
+
+      if (!result.ok) {
+        throw new Error(`Unstake approval failed: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+  });
+}

package/src/hooks/staking/useUnstakingInfo.ts

@@ -0,0 +1,53 @@
+// packages/dapp-kit/src/hooks/staking/useUnstakingInfoWithPenalty.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { UnstakingInfo, SpokeProvider } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+
+/**
+ * Hook for fetching unstaking information from the stakedSoda contract.
+ * Uses React Query for efficient caching and state management.
+ *
+ * @param {string | undefined} userAddress - The user address to fetch unstaking info for
+ * @param {SpokeProvider | undefined} spokeProvider - The spoke provider instance
+ * @param {number} refetchInterval - The interval in milliseconds to refetch data (default: 5000)
+ * @returns {UseQueryResult<UnstakingInfo, Error>} Query result object containing unstaking info and state
+ *
+ * @example
+ * ```typescript
+ * const { data: unstakingInfo, isLoading, error } = useUnstakingInfo(userAddress, spokeProvider);
+ *
+ * if (isLoading) return <div>Loading unstaking info...</div>;
+ * if (unstakingInfo) {
+ *   console.log('Total unstaking:', unstakingInfo.totalUnstaking);
+ *   unstakingInfo.userUnstakeSodaRequests.forEach(request => {
+ *     console.log('Request amount:', request.request.amount);
+ *   });
+ * }
+ * ```
+ */
+export function useUnstakingInfo(
+  userAddress: string | undefined,
+  spokeProvider: SpokeProvider | undefined,
+  refetchInterval = 5000,
+): UseQueryResult<UnstakingInfo, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['soda', 'unstakingInfoWithPenalty', spokeProvider?.chainConfig.chain.id, userAddress],
+    queryFn: async () => {
+      if (!spokeProvider || !userAddress) {
+        throw new Error('Spoke provider or user address not found');
+      }
+
+      const result = await sodax.staking.getUnstakingInfo(spokeProvider);
+
+      if (!result.ok) {
+        throw new Error(`Failed to fetch unstaking info: ${result.error.code}`);
+      }
+
+      return result.value;
+    },
+    enabled: !!spokeProvider && !!userAddress,
+    refetchInterval,
+  });
+}

package/src/hooks/staking/useUnstakingInfoWithPenalty.ts

@@ -0,0 +1,59 @@
+// packages/dapp-kit/src/hooks/staking/useUnstakingInfoWithPenalty.ts
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { UnstakingInfo, UnstakeRequestWithPenalty, SpokeProvider } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+
+export type UnstakingInfoWithPenalty = UnstakingInfo & {
+  requestsWithPenalty: UnstakeRequestWithPenalty[];
+};
+
+/**
+ * Hook for fetching unstaking information with penalty calculations from the stakedSoda contract.
+ * Uses React Query for efficient caching and state management.
+ *
+ * @param {string | undefined} userAddress - The user address to fetch unstaking info for
+ * @param {SpokeProvider | undefined} spokeProvider - The spoke provider instance
+ * @param {number} refetchInterval - The interval in milliseconds to refetch data (default: 5000)
+ * @returns {UseQueryResult<UnstakingInfoWithPenalty, Error>} Query result object containing unstaking info with penalties and state
+ *
+ * @example
+ * ```typescript
+ * const { data: unstakingInfo, isLoading, error } = useUnstakingInfoWithPenalty(userAddress, spokeProvider);
+ *
+ * if (isLoading) return <div>Loading unstaking info...</div>;
+ * if (unstakingInfo) {
+ *   console.log('Total unstaking:', unstakingInfo.totalUnstaking);
+ *   unstakingInfo.requestsWithPenalty.forEach(request => {
+ *     console.log('Penalty:', request.penaltyPercentage + '%');
+ *     console.log('Claimable amount:', request.claimableAmount);
+ *   });
+ * }
+ * ```
+ */
+export function useUnstakingInfoWithPenalty(
+  userAddress: string | undefined,
+  spokeProvider: SpokeProvider | undefined,
+  refetchInterval = 5000,
+): UseQueryResult<UnstakingInfoWithPenalty, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['soda', 'unstakingInfoWithPenalty', spokeProvider?.chainConfig.chain.id, userAddress],
+    queryFn: async () => {
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+
+      // Get unstaking info with penalty calculations
+      const penaltyResult = await sodax.staking.getUnstakingInfoWithPenalty(spokeProvider);
+
+      if (!penaltyResult.ok) {
+        throw new Error(`Failed to fetch unstaking info with penalty: ${penaltyResult.error.code}`);
+      }
+
+      return penaltyResult.value;
+    },
+    enabled: !!spokeProvider && !!userAddress,
+    refetchInterval,
+  });
+}

package/src/index.ts

@@ -1,4 +1,3 @@
 export * from './hooks';
 export * from './providers';
 export * from './core';
-export * from './types';

package/src/providers/SodaxProvider.tsx

@@ -3,7 +3,7 @@ import React from 'react';
 
 import { Sodax, type SodaxConfig } from '@sodax/sdk';
 import { SodaxContext } from '@/contexts';
-import type { RpcConfig } from '@/types';
+import type { RpcConfig } from '@sodax/types';
 
 interface SodaxProviderProps {
   children: ReactNode;

package/dist/contexts/index.d.ts

@@ -1,9 +0,0 @@
-import type { Sodax } from '@sodax/sdk';
-import type { RpcConfig } from '@/types';
-export interface SodaxContextType {
-    sodax: Sodax;
-    testnet: boolean;
-    rpcConfig: RpcConfig;
-}
-export declare const SodaxContext: import("react").Context<SodaxContextType | null>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/contexts/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,SAAS,CAAC;CACtB;AAED,eAAO,MAAM,YAAY,kDAA+C,CAAC"}

package/dist/core/index.d.ts

@@ -1,3 +0,0 @@
-import type { ChainId } from '@sodax/types';
-export declare const getSpokeTokenAddressByVault: (spokeChainId: ChainId, vault: string) => string | undefined;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAI5C,eAAO,MAAM,2BAA2B,iBAAkB,OAAO,SAAS,MAAM,uBAO/E,CAAC"}

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

@@ -1,17 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,37 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,45 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,36 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,35 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,38 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}