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

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,7 +3,8 @@ export * from './useRepay';
 export * from './useSupply';
 export * from './useWithdraw';
 export * from './useUserReservesData';
-export * from './useHubWalletAddress';
 export * from './useReservesData';
 export * from './useMMAllowance';
 export * from './useMMApprove';
+export * from './useAToken';
+export * from './useReservesUsdFormat';

package/src/hooks/mm/useAToken.ts

@@ -0,0 +1,47 @@
+import type { Address, XToken } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext';
+
+/**
+ * React hook for fetching an AToken's ERC20 metadata from the Sodax money market.
+ *
+ * Fetches and caches the metadata (name, symbol, decimals, address) for a given aToken address and chain using React Query.
+ * This metadata is typically required for rendering balances and labels in UI components.
+ *
+ * @param {Address | undefined} aToken - The aToken contract address to look up. Should be an EVM address.
+ * @param {ChainId | undefined} chainId - The EVM chain ID for the aToken.
+ *
+ * @example
+ * ```typescript
+ * const { data: aToken, isLoading, error } = useAToken(aTokenAddress, chainId);
+ * if (aToken) {
+ *   console.log(aToken.symbol); // 'aETH'
+ * }
+ * ```
+ *
+ * @returns {UseQueryResult<Erc20Token, Error>} A React Query result object containing:
+ *   - data: The aToken ERC20 metadata when available.
+ *   - isLoading: Loading state indicator.
+ *   - error: Any error that occurred during data fetching.
+ */
+export function useAToken(
+  aToken: Address | undefined,
+): UseQueryResult<XToken, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['aToken', sodax.hubProvider.chainConfig.chain.id, aToken],
+    queryFn: async () => {
+      if (!aToken) {
+        throw new Error('aToken address or hub provider is not defined');
+      }
+
+      const aTokenData = await sodax.moneyMarket.data.getATokenData(aToken);
+      return {
+        ...aTokenData,
+        xChainId: sodax.hubProvider.chainConfig.chain.id,
+      };
+    },
+    enabled: !!aToken,
+  });
+}

package/src/hooks/mm/useBorrow.ts

@@ -5,7 +5,7 @@ import { useSodaxContext } from '../shared/useSodaxContext';
 import type { SpokeProvider } from '@sodax/sdk';
 interface BorrowResponse {
   ok: true;
-  value: [`0x${string}`, `0x${string}`];
+  value: [string, string];
 }
 
 /**
@@ -45,7 +45,7 @@ export function useBorrow(
         throw new Error('spokeProvider is not found');
       }
 
-      const response = await sodax.moneyMarket.borrowAndSubmit(
+      const response = await sodax.moneyMarket.borrow(
         {
           token: spokeToken.address,
           amount: parseUnits(amount, 18),

package/src/hooks/mm/useMMAllowance.ts

@@ -37,10 +37,11 @@ export function useMMAllowance(
     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, token.decimals),
+          amount: parseUnits(amount, actionBasedDecimals),
           action,
         },
         spokeProvider,

package/src/hooks/mm/useMMApprove.ts

@@ -39,10 +39,11 @@ export function useMMApprove(token: XToken, spokeProvider: SpokeProvider | undef
       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, token.decimals),
+          amount: parseUnits(amount, actionBasedDecimals),
           action,
         },
         spokeProvider,

package/src/hooks/mm/useRepay.ts

@@ -6,7 +6,7 @@ import { useSodaxContext } from '../shared/useSodaxContext';
 
 interface RepayResponse {
   ok: true;
-  value: [`0x${string}`, `0x${string}`];
+  value: [string, string];
 }
 
 /**
@@ -46,7 +46,7 @@ export function useRepay(
         throw new Error('spokeProvider is not found');
       }
 
-      const response = await sodax.moneyMarket.repayAndSubmit(
+      const response = await sodax.moneyMarket.repay(
         {
           token: spokeToken.address,
           amount: parseUnits(amount, spokeToken.decimals),

package/src/hooks/mm/useReservesData.ts

@@ -1,5 +1,3 @@
-import { getMoneyMarketConfig } from '@sodax/sdk';
-import type { HubChainId } from '@sodax/types';
 import { useQuery } from '@tanstack/react-query';
 import { useSodaxContext } from '../shared/useSodaxContext';
 /**
@@ -22,16 +20,11 @@ import { useSodaxContext } from '../shared/useSodaxContext';
 
 export function useReservesData() {
   const { sodax } = useSodaxContext();
-  const hubChainId = (sodax.config?.hubProviderConfig?.chainConfig.chain.id ?? 'sonic') as HubChainId;
 
   return useQuery({
     queryKey: ['reservesData'],
     queryFn: async () => {
-      const moneyMarketConfig = getMoneyMarketConfig(hubChainId);
-      return await sodax.moneyMarket.getReservesData(
-        moneyMarketConfig.uiPoolDataProvider,
-        moneyMarketConfig.poolAddressesProvider,
-      );
+      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

@@ -6,7 +6,7 @@ import { useSodaxContext } from '../shared/useSodaxContext';
 
 interface SupplyResponse {
   ok: true;
-  value: [`0x${string}`, `0x${string}`];
+  value: [string, string];
 }
 
 /**
@@ -45,7 +45,7 @@ export function useSupply(
         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),

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

package/src/hooks/mm/useUserReservesData.ts

@@ -1,47 +1,40 @@
-import { allXTokens } from '@/core';
-import { encodeAddress, EvmWalletAbstraction, getMoneyMarketConfig, type EvmHubProvider } from '@sodax/sdk';
-import type { HubChainId, SpokeChainId } from '@sodax/types';
-import type { ChainId } from '@sodax/types';
-import { useQuery } from '@tanstack/react-query';
-import { useHubProvider } from '../provider/useHubProvider';
+import type { SpokeProvider, UserReserveData } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
 import { useSodaxContext } from '../shared/useSodaxContext';
 
-export function useUserReservesData(spokeChainId: ChainId, address: string | undefined) {
+/**
+ * Hook for fetching user reserves data from the Sodax money market.
+ *
+ * This hook provides access to the current state of user reserves in the money market protocol.
+ * The data is automatically fetched and cached using React Query.
+ *
+ * @example
+ * ```typescript
+ * const { data: userReservesData, isLoading, error } = useUserReservesData(spokeProvider, address);
+ * ```
+ *
+ * @returns A React Query result object containing:
+ *   - data: The user reserves data when available
+ *   - isLoading: Loading state indicator
+ *   - error: Any error that occurred during data fetching
+ */
+export function useUserReservesData(
+  spokeProvider: SpokeProvider | undefined,
+  address: string | undefined,
+  refetchInterval = 5000,
+): UseQueryResult<readonly [readonly UserReserveData[], number], Error> {
   const { sodax } = useSodaxContext();
-  const hubChainId = (sodax.config?.hubProviderConfig?.chainConfig.chain.id ?? 'sonic') as HubChainId;
-  const hubProvider = useHubProvider();
 
-  const { data: userReserves } = useQuery({
-    queryKey: ['userReserves', spokeChainId, address],
+  return useQuery({
+    queryKey: ['userReserves', spokeProvider?.chainConfig.chain.id, address],
     queryFn: async () => {
-      if (!hubProvider || !address) {
-        return;
+      if (!spokeProvider) {
+        throw new Error('Spoke provider or address is not defined');
       }
 
-      const addressBytes = encodeAddress(spokeChainId, address);
-      const hubWalletAddress = await EvmWalletAbstraction.getUserHubWalletAddress(
-        spokeChainId as SpokeChainId,
-        addressBytes,
-        hubProvider as EvmHubProvider,
-      );
-
-      const moneyMarketConfig = getMoneyMarketConfig(hubChainId);
-      const [res] = await sodax.moneyMarket.getUserReservesData(
-        hubWalletAddress as `0x${string}`,
-        moneyMarketConfig.uiPoolDataProvider,
-        moneyMarketConfig.poolAddressesProvider,
-      );
-
-      return res?.map(r => {
-        return {
-          ...r,
-          token: allXTokens.find(t => t.address === r.underlyingAsset),
-        };
-      });
+      return await sodax.moneyMarket.data.getUserReservesData(spokeProvider);
     },
-    enabled: !!spokeChainId && !!hubProvider && !!address,
-    refetchInterval: 5000,
+    enabled: !!spokeProvider && !!address,
+    refetchInterval,
   });
-
-  return userReserves;
 }

package/src/hooks/mm/useWithdraw.ts

@@ -6,7 +6,7 @@ import { useSodaxContext } from '../shared/useSodaxContext';
 
 interface WithdrawResponse {
   ok: true;
-  value: [`0x${string}`, `0x${string}`];
+  value: [string, string];
 }
 
 /**
@@ -44,7 +44,7 @@ export function useWithdraw(
         throw new Error('spokeProvider is not found');
       }
 
-      const response = await sodax.moneyMarket.withdrawAndSubmit(
+      const response = await sodax.moneyMarket.withdraw(
         {
           token: spokeToken.address,
           // vault token on hub chain decimals is 18

package/src/hooks/provider/useHubProvider.ts

@@ -1,8 +1,8 @@
 import type { EvmHubProvider } from '@sodax/sdk';
 import { useSodaxContext } from '../shared/useSodaxContext';
 
-export function useHubProvider(): EvmHubProvider | undefined {
-  const { hubProvider } = useSodaxContext();
+export function useHubProvider(): EvmHubProvider {
+  const { sodax } = useSodaxContext();
 
-  return hubProvider;
+  return sodax.hubProvider;
 }