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

package/src/hooks/migrate/useMigrationApprove.tsx

@@ -0,0 +1,129 @@
+import { parseUnits } from 'viem';
+import { useCallback, useState, useRef, useEffect } from 'react';
+import type {
+  IcxCreateRevertMigrationParams,
+  UnifiedBnUSDMigrateParams,
+  SpokeProvider,
+  Result,
+  ChainId,
+} from '@sodax/sdk';
+import { useSodaxContext } from '../shared/useSodaxContext';
+import { MIGRATION_MODE_BNUSD, MIGRATION_MODE_ICX_SODA, type MigrationIntentParams } from './types';
+import { useQueryClient } from '@tanstack/react-query';
+
+interface UseApproveReturn {
+  approve: ({ params }: { params: MigrationIntentParams }) => Promise<boolean>;
+  isLoading: boolean;
+  error: Error | null;
+  resetError: () => void;
+  isApproved: boolean;
+}
+
+/**
+ * Hook for approving token spending for migration actions
+ * @param params The parameters for the migration approval
+ * @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 } = useMigrationApprove(params, spokeProvider);
+ *
+ * // Approve tokens for migration
+ * await approve({ params });
+ * ```
+ */
+
+export function useMigrationApprove(
+  params: MigrationIntentParams | undefined,
+  spokeProvider: SpokeProvider | undefined,
+): UseApproveReturn {
+  const { sodax } = useSodaxContext();
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+  const [isApproved, setIsApproved] = useState(false);
+  const queryClient = useQueryClient();
+
+  // Track previous values to reset approval state when needed
+  const prevTokenAddress = useRef<string | undefined>(undefined);
+  const prevAmount = useRef<string | undefined>(undefined);
+
+  useEffect(() => {
+    if (prevTokenAddress.current !== params?.token?.address || prevAmount.current !== params?.amount) {
+      setIsApproved(false);
+      prevTokenAddress.current = params?.token?.address;
+      prevAmount.current = params?.amount;
+    }
+  }, [params?.token?.address, params?.amount]);
+
+  const approve = useCallback(
+    async ({ params: approveParams }: { params: MigrationIntentParams }) => {
+      try {
+        setIsLoading(true);
+        setError(null);
+
+        if (!spokeProvider) {
+          throw new Error('Spoke provider not found');
+        }
+        if (!approveParams) {
+          throw new Error('Migration intent not found');
+        }
+
+        const { token, amount, migrationMode = MIGRATION_MODE_ICX_SODA, toToken, destinationAddress } = approveParams;
+        const amountToMigrate = parseUnits(amount ?? '0', token?.decimals ?? 0);
+
+        let result: Result<string, unknown>;
+        if (migrationMode === MIGRATION_MODE_ICX_SODA) {
+          // ICX/SODA migration approval
+          const revertParams = {
+            amount: amountToMigrate,
+            to: destinationAddress as `hx${string}`,
+          } satisfies IcxCreateRevertMigrationParams;
+
+          result = await sodax.migration.approve(revertParams, 'revert', spokeProvider, false);
+        } else if (migrationMode === MIGRATION_MODE_BNUSD) {
+          // bnUSD migration approval
+          if (!toToken) throw new Error('Destination token is required for bnUSD migration');
+
+          const migrationParams = {
+            srcChainId: token?.xChainId as ChainId,
+            dstChainId: toToken?.xChainId as ChainId,
+            srcbnUSD: token?.address as string,
+            dstbnUSD: toToken?.address as string,
+            amount: amountToMigrate,
+            to: destinationAddress as `hx${string}` | `0x${string}`,
+          } satisfies UnifiedBnUSDMigrateParams;
+
+          result = await sodax.migration.approve(migrationParams, 'revert', spokeProvider, false);
+        } else {
+          throw new Error('Invalid migration mode');
+        }
+        if (!result.ok) {
+          throw new Error('Failed to approve tokens');
+        }
+
+        setIsApproved(true);
+        queryClient.invalidateQueries({ queryKey: ['migration-allowance', params] });
+        return result.ok;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error('An unknown error occurred');
+        setError(error);
+        throw error;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [spokeProvider, sodax, queryClient, params],
+  );
+
+  const resetError = useCallback(() => {
+    setError(null);
+  }, []);
+
+  return {
+    approve,
+    isLoading,
+    error,
+    resetError,
+    isApproved,
+  };
+}

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,56 @@
+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 actionBasedDecimals = action === 'withdraw' || action === 'borrow' ? 18 : token.decimals; // withdraw and borrow actions are in aToken decimals
+      const allowance = await sodax.moneyMarket.isAllowanceValid(
+        {
+          token: token.address,
+          amount: parseUnits(amount, actionBasedDecimals),
+          action,
+        },
+        spokeProvider,
+      );
+      if (allowance.ok) {
+        return allowance.value;
+      }
+      return false;
+    },
+    enabled: !!spokeProvider,
+  });
+}

package/src/hooks/mm/useMMApprove.ts

@@ -0,0 +1,68 @@
+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 actionBasedDecimals = action === 'withdraw' || action === 'borrow' ? 18 : token.decimals; // withdraw and borrow actions are in aToken decimals
+      const allowance = await sodax.moneyMarket.approve(
+        {
+          token: token.address,
+          amount: parseUnits(amount, actionBasedDecimals),
+          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();
+    },
+  });
+}

package/src/hooks/mm/useReservesHumanized.ts

@@ -0,0 +1,30 @@
+import type { ReservesDataHumanized } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext';
+/**
+ * Hook for fetching humanized reserves data from the Sodax money market.
+ *
+ * This hook provides access to the current state of all reserves (humanized format) 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: reservesHumanized, isLoading, error } = useReservesHumanized();
+ * ```
+ *
+ * @returns A React Query result object containing:
+ *   - data: The reserves humanized data when available
+ *   - isLoading: Loading state indicator
+ *   - error: Any error that occurred during data fetching
+ */
+export function useReservesHumanized(): UseQueryResult<ReservesDataHumanized, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['reservesHumanized'],
+    queryFn: async () => {
+      return await sodax.moneyMarket.data.getReservesHumanized();
+    },
+  });
+}

package/src/hooks/mm/useReservesList.ts

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

package/src/hooks/mm/useReservesUsdFormat.ts

@@ -0,0 +1,38 @@
+import type { FormatReserveUSDResponse, ReserveData } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext';
+
+/**
+ * Hook for fetching formatted summary of Sodax user portfolio (holdings, total liquidity,
+ *  collateral, borrows, liquidation threshold, health factor, available borrowing power, etc..).
+ *
+ * This hook provides access to the current state of user portfolio in the money market protocol.
+ * The data is automatically fetched and cached using React Query.
+ *
+ * @example
+ * ```typescript
+ * const { data: userFormattedSummary, isLoading, error } = useUserFormattedSummary();
+ * ```
+ *
+ * @returns A React Query result object containing:
+ *   - data: The formatted summary of Sodax user portfolio when available
+ *   - isLoading: Loading state indicator
+ *   - error: Any error that occurred during data fetching
+ */
+export function useReservesUsdFormat(): UseQueryResult<
+  (ReserveData & { priceInMarketReferenceCurrency: string } & FormatReserveUSDResponse)[],
+  Error
+> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['reservesUsdFormat'],
+    queryFn: async () => {
+      // fetch reserves and hub wallet address
+      const reserves = await sodax.moneyMarket.data.getReservesHumanized();
+
+      // format reserves
+      return sodax.moneyMarket.data.formatReservesUSD(sodax.moneyMarket.data.buildReserveDataWithPrice(reserves));
+    },
+  });
+}

package/src/hooks/mm/useSupply.ts

@@ -1,13 +1,12 @@
-import type { SpokeChainId } from '@sodax/sdk';
+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 SupplyResponse {
   ok: true;
-  value: [`0x${string}`, `0x${string}`];
+  value: [string, string];
 }
 
 /**
@@ -18,6 +17,7 @@ interface SupplyResponse {
  * and cross-chain communication.
  *
  * @param {XToken} spokeToken - The token to supply on the spoke chain. Must be an XToken with valid address and chain information.
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for the supply transaction. Must be a valid SpokeProvider instance.
  *
  * @returns {UseMutationResult<SupplyResponse, Error, string>} A mutation result object with the following properties:
  *   - mutateAsync: Function to execute the supply transaction
@@ -33,9 +33,11 @@ interface SupplyResponse {
  * @throws {Error} When:
  *   - spokeProvider is not available
  */
-export function useSupply(spokeToken: XToken): UseMutationResult<SupplyResponse, Error, string> {
+export function useSupply(
+  spokeToken: XToken,
+  spokeProvider: SpokeProvider | undefined,
+): UseMutationResult<SupplyResponse, Error, string> {
   const { sodax } = useSodaxContext();
-  const spokeProvider = useSpokeProvider(spokeToken.xChainId as SpokeChainId);
 
   return useMutation<SupplyResponse, Error, string>({
     mutationFn: async (amount: string) => {
@@ -43,10 +45,11 @@ export function useSupply(spokeToken: XToken): UseMutationResult<SupplyResponse,
         throw new Error('spokeProvider is not found');
       }
 
-      const response = await sodax.moneyMarket.supplyAndSubmit(
+      const response = await sodax.moneyMarket.supply(
         {
           token: spokeToken.address,
           amount: parseUnits(amount, spokeToken.decimals),
+          action: 'supply',
         },
         spokeProvider,
       );

package/src/hooks/mm/useUserFormattedSummary.ts

@@ -0,0 +1,54 @@
+import type { FormatUserSummaryResponse, FormatReserveUSDResponse, SpokeProvider } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext';
+
+/**
+ * Hook for fetching formatted summary of Sodax user portfolio (holdings, total liquidity,
+ *  collateral, borrows, liquidation threshold, health factor, available borrowing power, etc..).
+ *
+ * This hook provides access to the current state of user portfolio in the money market protocol.
+ * The data is automatically fetched and cached using React Query.
+ *
+ * @example
+ * ```typescript
+ * const { data: userFormattedSummary, isLoading, error } = useUserFormattedSummary(spokeProvider, address);
+ * ```
+ *
+ * @returns A React Query result object containing:
+ *   - data: The formatted summary of Sodax user portfolio when available
+ *   - isLoading: Loading state indicator
+ *   - error: Any error that occurred during data fetching
+ */
+export function useUserFormattedSummary(
+  spokeProvider: SpokeProvider | undefined,
+  address: string | undefined,
+): UseQueryResult<FormatUserSummaryResponse<FormatReserveUSDResponse>, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['userFormattedSummary', spokeProvider?.chainConfig.chain.id, address],
+    queryFn: async () => {
+      if (!spokeProvider || !address) {
+        throw new Error('Spoke provider or address is not defined');
+      }
+
+      // fetch reserves and hub wallet address
+      const reserves = await sodax.moneyMarket.data.getReservesHumanized();
+
+      // format reserves
+      const formattedReserves = sodax.moneyMarket.data.formatReservesUSD(
+        sodax.moneyMarket.data.buildReserveDataWithPrice(reserves),
+      );
+
+      // fetch user reserves
+      const userReserves = await sodax.moneyMarket.data.getUserReservesHumanized(spokeProvider);
+
+      // format user summary
+      return sodax.moneyMarket.data.formatUserSummary(
+        sodax.moneyMarket.data.buildUserSummaryRequest(reserves, formattedReserves, userReserves),
+      );
+    },
+    enabled: !!spokeProvider && !!address,
+    refetchInterval: 5000,
+  });
+}