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

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 { 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,
+  });
+}

package/src/hooks/bridge/useGetBridgeableTokens.ts

@@ -0,0 +1,62 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { XToken, SpokeChainId } from '@sodax/sdk';
+import { useSodaxContext } from '../shared';
+
+/**
+/**
+ * Hook for retrieving all bridgeable tokens from a source token on one chain to a destination chain.
+ *
+ * This hook queries and tracks the set of tokens on the destination chain that can be bridged to,
+ * given a source chain, destination chain, and source token address.
+ *
+ * @param {SpokeChainId | undefined} from - The source chain ID
+ * @param {SpokeChainId | undefined} to - The destination chain ID
+ * @param {string | undefined} token - The source token address
+ *
+ * @returns {UseQueryResult<XToken[], Error>} A React Query result containing:
+ *   - data: Array of bridgeable tokens (XToken[]) on the destination chain
+ *   - error: Any error that occurred during the query
+ *
+ *
+ * @example
+ * ```typescript
+ * const { data: bridgeableTokens, isLoading } = useGetBridgeableTokens(
+ *   fromChainId,
+ *   toChainId,
+ *   fromTokenAddress
+ * );
+ *
+ * if (bridgeableTokens && bridgeableTokens.length > 0) {
+ *   bridgeableTokens.forEach(token => {
+ *     console.log(`Bridgeable token: ${token.symbol} (${token.address}) on chain ${token.xChainId}`);
+ *   });
+ * } else {
+ *   console.log('No bridgeable tokens found for the selected route.');
+ * }
+ * ```
+ */
+export function useGetBridgeableTokens(
+  from: SpokeChainId | undefined,
+  to: SpokeChainId | undefined,
+  token: string | undefined,
+): UseQueryResult<XToken[], Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['bridgeable-tokens', from, to, token],
+    queryFn: async () => {
+      if (!from || !to || !token) {
+        return [];
+      }
+
+      const result = sodax.bridge.getBridgeableTokens(from, to, token);
+      if (result.ok) {
+        return result.value;
+      }
+
+      console.error('Error getting bridgeable tokens:', result.error);
+      return [];
+    },
+    enabled: !!from && !!to && !!token,
+  });
+}

package/src/hooks/index.ts

@@ -2,3 +2,6 @@ export * from './shared';
 export * from './provider';
 export * from './mm';
 export * from './swap';
+export * from './backend';
+export * from './bridge';
+export * from './staking';

package/src/hooks/mm/index.ts

@@ -3,4 +3,6 @@ export * from './useRepay';
 export * from './useSupply';
 export * from './useWithdraw';
 export * from './useUserReservesData';
-export * from './useHubWalletAddress';
+export * from './useReservesData';
+export * from './useMMAllowance';
+export * from './useMMApprove';

package/src/hooks/mm/useBorrow.ts

@@ -1,12 +1,11 @@
-import type { ChainId, XToken } from '@sodax/types';
+import type { XToken } from '@sodax/types';
 import { useMutation, type UseMutationResult } from '@tanstack/react-query';
 import { parseUnits } from 'viem';
-import { useSpokeProvider } from '../provider/useSpokeProvider';
 import { useSodaxContext } from '../shared/useSodaxContext';
-import type { SpokeChainId } from '@sodax/sdk';
+import type { SpokeProvider } from '@sodax/sdk';
 interface BorrowResponse {
   ok: true;
-  value: [`0x${string}`, `0x${string}`];
+  value: [string, string];
 }
 
 /**
@@ -16,9 +15,17 @@ interface BorrowResponse {
  * handling the entire borrow process including transaction creation, submission,
  * and cross-chain communication.
  *
+ * @param {XToken} spokeToken - The token to borrow from the spoke chain. Must be an XToken with valid address and chain information.
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for the borrow transaction. Must be a valid SpokeProvider instance.
+ *
+ * @returns {UseMutationResult<BorrowResponse, Error, string>} A mutation result object with the following properties:
+ *   - mutateAsync: Function to execute the borrow transaction
+ *   - isPending: Boolean indicating if a transaction is in progress
+ *   - error: Error object if the last transaction failed, null otherwise
+ *
  * @example
  * ```typescript
- * const { mutateAsync: borrow, isPending, error } = useBorrow(hubToken, spokeChainId);
+ * const { mutateAsync: borrow, isPending, error } = useBorrow(spokeToken);
  * await borrow('100');
  * ```
  *
@@ -26,9 +33,11 @@ interface BorrowResponse {
  *   - spokeProvider is not available
  *   - Transaction execution fails
  */
-export function useBorrow(hubToken: XToken, spokeChainId: ChainId): UseMutationResult<BorrowResponse, Error, string> {
+export function useBorrow(
+  spokeToken: XToken,
+  spokeProvider: SpokeProvider | undefined,
+): UseMutationResult<BorrowResponse, Error, string> {
   const { sodax } = useSodaxContext();
-  const spokeProvider = useSpokeProvider(spokeChainId as SpokeChainId);
 
   return useMutation<BorrowResponse, Error, string>({
     mutationFn: async (amount: string) => {
@@ -36,10 +45,11 @@ export function useBorrow(hubToken: XToken, spokeChainId: ChainId): UseMutationR
         throw new Error('spokeProvider is not found');
       }
 
-      const response = await sodax.moneyMarket.borrowAndSubmit(
+      const response = await sodax.moneyMarket.borrow(
         {
-          token: hubToken.address,
-          amount: parseUnits(amount, hubToken.decimals),
+          token: spokeToken.address,
+          amount: parseUnits(amount, 18),
+          action: 'borrow',
         },
         spokeProvider,
       );

package/src/hooks/mm/useMMAllowance.ts

@@ -0,0 +1,55 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { XToken } from '@sodax/types';
+import { useSodaxContext } from '../shared/useSodaxContext';
+import { parseUnits } from 'viem';
+import type { MoneyMarketAction, SpokeProvider } from '@sodax/sdk';
+
+/**
+ * Hook for checking token allowance for money market operations.
+ *
+ * This hook verifies if the user has approved enough tokens for a specific money market action
+ * (borrow/repay). It automatically queries and tracks the allowance status.
+ *
+ * @param {XToken} token - The token to check allowance for. Must be an XToken with valid address and chain information.
+ * @param {string} amount - The amount to check allowance for, as a decimal string
+ * @param {MoneyMarketAction} action - The money market action to check allowance for ('borrow' or 'repay')
+ * @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 } = useMMAllowance(token, "100", "repay", provider);
+ * ```
+ */
+export function useMMAllowance(
+  token: XToken,
+  amount: string,
+  action: MoneyMarketAction,
+  spokeProvider: SpokeProvider | undefined,
+): UseQueryResult<boolean, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['allowance', token.address, amount, action],
+    queryFn: async () => {
+      if (!spokeProvider) throw new Error('Spoke provider is required');
+      const allowance = await sodax.moneyMarket.isAllowanceValid(
+        {
+          token: token.address,
+          amount: parseUnits(amount, token.decimals),
+          action,
+        },
+        spokeProvider,
+      );
+      if (allowance.ok) {
+        return allowance.value;
+      }
+      return false;
+    },
+    enabled: !!spokeProvider,
+  });
+}

package/src/hooks/mm/useMMApprove.ts

@@ -0,0 +1,67 @@
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { XToken } from '@sodax/types';
+import { parseUnits } from 'viem';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import type { MoneyMarketAction, SpokeProvider } from '@sodax/sdk';
+
+interface UseApproveReturn {
+  approve: ({ amount, action }: { amount: string; action: MoneyMarketAction }) => Promise<boolean>;
+  isLoading: boolean;
+  error: Error | null;
+  resetError: () => void;
+}
+
+/**
+ * Hook for approving token spending for money market actions
+ * @param token The token to approve spending for
+ * @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 } = useMMApprove(token, spokeProvider);
+ *
+ * // Approve tokens for supply action
+ * await approve({ amount: "100", action: "supply" });
+ * ```
+ */
+
+export function useMMApprove(token: XToken, spokeProvider: SpokeProvider | undefined): UseApproveReturn {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+
+  const {
+    mutateAsync: approve,
+    isPending,
+    error,
+    reset: resetError,
+  } = useMutation({
+    mutationFn: async ({ amount, action }: { amount: string; action: MoneyMarketAction }) => {
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+      const allowance = await sodax.moneyMarket.approve(
+        {
+          token: token.address,
+          amount: parseUnits(amount, token.decimals),
+          action,
+        },
+        spokeProvider,
+      );
+      if (!allowance.ok) {
+        throw new Error('Failed to approve tokens');
+      }
+      return allowance.ok;
+    },
+    onSuccess: () => {
+      // Invalidate allowance query to refetch the new allowance
+      queryClient.invalidateQueries({ queryKey: ['allowance', token.address] });
+    },
+  });
+
+  return {
+    approve,
+    isLoading: isPending,
+    error: error,
+    resetError,
+  };
+}

package/src/hooks/mm/useRepay.ts

@@ -1,13 +1,12 @@
-import type { SpokeChainId } from '@sodax/sdk';
-import type { ChainId, XToken } from '@sodax/types';
+import type { SpokeProvider } from '@sodax/sdk';
+import type { XToken } from '@sodax/types';
 import { useMutation, type UseMutationResult } from '@tanstack/react-query';
 import { parseUnits } from 'viem';
-import { useSpokeProvider } from '../provider/useSpokeProvider';
 import { useSodaxContext } from '../shared/useSodaxContext';
 
 interface RepayResponse {
   ok: true;
-  value: [`0x${string}`, `0x${string}`];
+  value: [string, string];
 }
 
 /**
@@ -17,9 +16,17 @@ interface RepayResponse {
  * handling the entire repayment process including transaction creation, submission,
  * and cross-chain communication.
  *
+ * @param {XToken} spokeToken - The token to repay on the spoke chain. Must be an XToken with valid address and chain information.
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for the repay transaction. Must be a valid SpokeProvider instance.
+ *
+ * @returns {UseMutationResult<RepayResponse, Error, string>} A mutation result object with the following properties:
+ *   - mutateAsync: Function to execute the repay transaction
+ *   - isPending: Boolean indicating if a transaction is in progress
+ *   - error: Error object if the last transaction failed, null otherwise
+ *
  * @example
  * ```typescript
- * const { mutateAsync: repay, isPending, error } = useRepay(hubToken, spokeChainId);
+ * const { mutateAsync: repay, isPending, error } = useRepay(spokeToken);
  * await repay('100');
  * ```
  *
@@ -27,9 +34,11 @@ interface RepayResponse {
  *   - spokeProvider is not available
  *   - Transaction execution fails
  */
-export function useRepay(hubToken: XToken, spokeChainId: ChainId): UseMutationResult<RepayResponse, Error, string> {
+export function useRepay(
+  spokeToken: XToken,
+  spokeProvider: SpokeProvider | undefined,
+): UseMutationResult<RepayResponse, Error, string> {
   const { sodax } = useSodaxContext();
-  const spokeProvider = useSpokeProvider(spokeChainId as SpokeChainId);
 
   return useMutation<RepayResponse, Error, string>({
     mutationFn: async (amount: string) => {
@@ -37,10 +46,11 @@ export function useRepay(hubToken: XToken, spokeChainId: ChainId): UseMutationRe
         throw new Error('spokeProvider is not found');
       }
 
-      const response = await sodax.moneyMarket.repayAndSubmit(
+      const response = await sodax.moneyMarket.repay(
         {
-          token: hubToken.address,
-          amount: parseUnits(amount, hubToken.decimals),
+          token: spokeToken.address,
+          amount: parseUnits(amount, spokeToken.decimals),
+          action: 'repay',
         },
         spokeProvider,
       );

package/src/hooks/mm/useReservesData.ts

@@ -0,0 +1,30 @@
+import { useQuery } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext';
+/**
+ * Hook for fetching reserves data from the Sodax money market.
+ *
+ * This hook provides access to the current state of all reserves in the money market protocol,
+ * including liquidity, interest rates, and other key metrics. The data is automatically
+ * fetched and cached using React Query.
+ *
+ * @example
+ * ```typescript
+ * const { data: reservesData, isLoading, error } = useReservesData();
+ * ```
+ *
+ * @returns A React Query result object containing:
+ *   - data: The reserves data when available
+ *   - isLoading: Loading state indicator
+ *   - error: Any error that occurred during data fetching
+ */
+
+export function useReservesData() {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['reservesData'],
+    queryFn: async () => {
+      return await sodax.moneyMarket.data.getReservesData();
+    },
+  });
+}