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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sodax/dapp-kit",
   "license": "MIT",
-  "version": "0.0.1-rc.30",
+  "version": "0.0.1-rc.32",
   "description": "dapp-kit of New World",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,8 +16,8 @@
   },
   "dependencies": {
     "viem": "2.29.2",
-    "@sodax/sdk": "0.0.1-rc.43",
-    "@sodax/types": "0.0.1-rc.18"
+    "@sodax/sdk": "0.0.1-rc.46",
+    "@sodax/types": "0.0.1-rc.20"
   },
   "devDependencies": {
     "@types/react": "18.3.1",

package/src/hooks/index.ts

@@ -5,3 +5,4 @@ export * from './swap';
 export * from './backend';
 export * from './bridge';
 export * from './staking';
+export * from './migrate';

package/src/hooks/migrate/index.ts

@@ -0,0 +1,4 @@
+export { useMigrate } from './useMigrate';
+export { useMigrationAllowance } from './useMigrationAllowance';
+export { useMigrationApprove } from './useMigrationApprove';
+export * from './types';

package/src/hooks/migrate/types.ts

@@ -0,0 +1,15 @@
+import type { XToken } from '@sodax/types';
+
+export const MIGRATION_MODE_ICX_SODA = 'icxsoda';
+export const MIGRATION_MODE_BNUSD = 'bnusd';
+
+export type MigrationMode = typeof MIGRATION_MODE_ICX_SODA | typeof MIGRATION_MODE_BNUSD;
+
+export interface MigrationIntentParams {
+  token: XToken | undefined;
+  amount: string | undefined;
+  sourceAddress: string | undefined;
+  migrationMode?: MigrationMode;
+  toToken?: XToken;
+  destinationAddress?: string;
+}

package/src/hooks/migrate/useMigrate.tsx

@@ -0,0 +1,110 @@
+import { parseUnits } from 'viem';
+import {
+  spokeChainConfig,
+  type UnifiedBnUSDMigrateParams,
+  type IconSpokeProvider,
+  type SonicSpokeProvider,
+  isLegacybnUSDToken,
+  type SpokeProvider,
+} from '@sodax/sdk';
+import { type ChainId, ICON_MAINNET_CHAIN_ID } from '@sodax/types';
+import { useSodaxContext } from '../shared/useSodaxContext';
+import { useMutation, type UseMutationResult } from '@tanstack/react-query';
+import { MIGRATION_MODE_BNUSD, MIGRATION_MODE_ICX_SODA, type MigrationIntentParams } from './types';
+
+/**
+ * Hook for executing migration operations between chains.
+ *
+ * This hook handles ICX/SODA and bnUSD migrations by accepting a spoke provider
+ * and returning a mutation function that accepts migration parameters.
+ *
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for the migration
+ * @returns {UseMutationResult} Mutation result object containing migration function and state
+ *
+ * @example
+ * ```typescript
+ * const { mutateAsync: migrate, isPending } = useMigrate(spokeProvider);
+ *
+ * const result = await migrate({
+ *   token: { address: "0x...", decimals: 18 },
+ *   amount: "100",
+ *   migrationMode: MIGRATION_MODE_ICX_SODA,
+ *   toToken: { address: "0x...", decimals: 18 },
+ *   destinationAddress: "0x..."
+ * });
+ * ```
+ */
+export function useMigrate(
+  spokeProvider: SpokeProvider | undefined,
+): UseMutationResult<{ spokeTxHash: string; hubTxHash: `0x${string}` }, Error, MigrationIntentParams> {
+  const { sodax } = useSodaxContext();
+
+  return useMutation({
+    mutationFn: async (params: MigrationIntentParams) => {
+      const { token, amount, migrationMode = MIGRATION_MODE_ICX_SODA, toToken, destinationAddress } = params;
+      const amountToMigrate = parseUnits(amount ?? '0', token?.decimals ?? 0);
+
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+
+      if (migrationMode === MIGRATION_MODE_ICX_SODA) {
+        // ICX->SODA migration logic
+        if (token?.xChainId === ICON_MAINNET_CHAIN_ID) {
+          const params = {
+            address: spokeChainConfig[ICON_MAINNET_CHAIN_ID].nativeToken,
+            amount: amountToMigrate,
+            to: destinationAddress as `0x${string}`,
+          };
+          const result = await sodax.migration.migrateIcxToSoda(params, spokeProvider as IconSpokeProvider, 30000);
+          if (result.ok) {
+            const [spokeTxHash, hubTxHash] = result.value;
+            return { spokeTxHash, hubTxHash };
+          }
+          throw new Error('ICX to SODA migration failed. Please try again.');
+        }
+
+        // SODA->ICX migration
+        const revertParams = {
+          amount: amountToMigrate,
+          to: destinationAddress as `hx${string}`,
+        };
+        const result = await sodax.migration.revertMigrateSodaToIcx(
+          revertParams,
+          spokeProvider as SonicSpokeProvider,
+          30000,
+        );
+        if (result.ok) {
+          const [hubTxHash, spokeTxHash] = result.value;
+          return { spokeTxHash, hubTxHash };
+        }
+        throw new Error('SODA to ICX migration failed. Please try again.');
+      }
+
+      if (migrationMode === MIGRATION_MODE_BNUSD) {
+        // bnUSD migration logic - handle dynamic source/destination chains
+        const params = {
+          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;
+
+        const result = await sodax.migration.migratebnUSD(params, spokeProvider, 30000);
+        if (result.ok) {
+          const [spokeTxHash, hubTxHash] = result.value;
+          return { spokeTxHash, hubTxHash };
+        }
+
+        const errorMessage = isLegacybnUSDToken(token?.address as string)
+          ? 'bnUSD migration failed. Please try again.'
+          : 'bnUSD reverse migration failed. Please try again.';
+        throw new Error(errorMessage);
+      }
+
+      throw new Error('Invalid migration mode');
+    },
+  });
+}

package/src/hooks/migrate/useMigrationAllowance.tsx

@@ -0,0 +1,79 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import type { ChainId } from '@sodax/types';
+import { useSodaxContext } from '../shared/useSodaxContext';
+import { parseUnits } from 'viem';
+import type { IcxCreateRevertMigrationParams, UnifiedBnUSDMigrateParams, SpokeProvider } from '@sodax/sdk';
+import { ICON_MAINNET_CHAIN_ID } from '@sodax/types';
+import { MIGRATION_MODE_ICX_SODA, type MigrationIntentParams } from './types';
+
+/**
+ * Hook for checking token allowance for migration operations.
+ *
+ * This hook verifies if the user has approved enough tokens for migration operations.
+ * It handles both ICX/SODA and bnUSD migration allowance checks.
+ *
+ * @param {MigrationIntentParams} params - The parameters for the migration allowance check
+ * @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 } = useMigrationAllowance(params, spokeProvider);
+ * ```
+ */
+export function useMigrationAllowance(
+  params: MigrationIntentParams | undefined,
+  spokeProvider: SpokeProvider | undefined,
+): UseQueryResult<boolean, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['migration-allowance', params],
+    queryFn: async () => {
+      if (!spokeProvider || !params) {
+        return false;
+      }
+
+      const { token, amount, migrationMode = MIGRATION_MODE_ICX_SODA, toToken, destinationAddress } = params;
+
+      // For ICON chain, no allowance is required (forward migrations)
+      if (token?.xChainId === ICON_MAINNET_CHAIN_ID) {
+        return true;
+      }
+
+      if (!spokeProvider) throw new Error('Spoke provider is required');
+      const amountToMigrate = parseUnits(amount ?? '0', token?.decimals ?? 0);
+
+      let migrationParams: IcxCreateRevertMigrationParams | UnifiedBnUSDMigrateParams;
+      if (migrationMode === MIGRATION_MODE_ICX_SODA) {
+        migrationParams = {
+          amount: amountToMigrate,
+          to: destinationAddress as `hx${string}`,
+        } satisfies IcxCreateRevertMigrationParams;
+      } else {
+        if (!toToken) throw new Error('Destination token is required for bnUSD migration');
+
+        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;
+      }
+
+      const allowance = await sodax.migration.isAllowanceValid(migrationParams, 'revert', spokeProvider);
+      if (allowance.ok) {
+        return allowance.value;
+      }
+      return false;
+    },
+    enabled: !!spokeProvider && !!params,
+    refetchInterval: 2000,
+  });
+}

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/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/shared/useRequestTrustline.ts

@@ -1,32 +1,32 @@
 import { type SpokeProvider, StellarSpokeProvider, StellarSpokeService, type TxReturnType } from '@sodax/sdk';
-import { useMutation, type UseMutationResult, useQueryClient } from '@tanstack/react-query';
+import { useQueryClient } from '@tanstack/react-query';
+import { useCallback, useState } from 'react';
 
 /**
  * React hook to request a Stellar trustline for a given token and amount.
  *
- * This hook provides a mutation for requesting a trustline on the Stellar network
+ * This hook provides a callback function for requesting a trustline on the Stellar network
  * using the provided SpokeProvider. It is intended for use with StellarSpokeProvider
  * and will throw if used with a non-Stellar provider. Upon success, it invalidates
  * the trustline check query to ensure UI reflects the updated trustline state.
  *
  * @template T - The type of SpokeProvider, defaults to SpokeProvider.
  * @param {string | undefined} token - The Stellar asset code or token address for which to request a trustline.
- * @returns {UseMutationResult<TxReturnType<StellarSpokeProvider, false>, Error, { token: string; amount: bigint; spokeProvider: T }>}
- *   A React Query mutation result object containing:
- *   - `mutate`/`mutateAsync`: Function to trigger the trustline request.
- *   - `data`: The transaction result if successful.
+ * @returns {Object} An object containing:
+ *   - `requestTrustline`: Function to trigger the trustline request.
+ *   - `isLoading`: Whether the request is in progress.
+ *   - `isRequested`: Whether a trustline has been successfully requested.
  *   - `error`: Any error encountered during the request.
- *   - `isLoading`: Whether the mutation is in progress.
- *   - Other React Query mutation state.
+ *   - `data`: The transaction result if successful.
  *
  * @example
  * ```tsx
  * import { useRequestTrustline } from '@sodax/dapp-kit';
  *
- * const { mutate: requestTrustline, isLoading, error, data } = useRequestTrustline('USDC-G...TOKEN');
+ * const { requestTrustline, isLoading, isRequested, error, data } = useRequestTrustline('USDC-G...TOKEN');
  *
  * // To request a trustline:
- * requestTrustline({
+ * await requestTrustline({
  *   token: 'USDC-G...TOKEN',
  *   amount: 10000000n,
  *   spokeProvider: stellarProvider,
@@ -34,33 +34,31 @@ import { useMutation, type UseMutationResult, useQueryClient } from '@tanstack/r
  *
  * if (isLoading) return <span>Requesting trustline...</span>;
  * if (error) return <span>Error: {error.message}</span>;
- * if (data) return <span>Trustline requested! Tx: {data.txHash}</span>;
+ * if (isRequested) return <span>Trustline requested! Tx: {data?.txHash}</span>;
  * ```
  */
 
 export function useRequestTrustline<T extends SpokeProvider = SpokeProvider>(
   token: string | undefined,
-): UseMutationResult<
-  TxReturnType<StellarSpokeProvider, false>,
-  Error,
-  {
+): {
+  requestTrustline: (params: {
     token: string;
     amount: bigint;
     spokeProvider: T;
-  }
-> {
+  }) => Promise<TxReturnType<StellarSpokeProvider, false>>;
+  isLoading: boolean;
+  isRequested: boolean;
+  error: Error | null;
+  data: TxReturnType<StellarSpokeProvider, false> | null;
+} {
   const queryClient = useQueryClient();
+  const [isLoading, setIsLoading] = useState<boolean>(false);
+  const [isRequested, setIsRequested] = useState<boolean>(false);
+  const [error, setError] = useState<Error | null>(null);
+  const [data, setData] = useState<TxReturnType<StellarSpokeProvider, false> | null>(null);
 
-  return useMutation<
-    TxReturnType<StellarSpokeProvider, false>,
-    Error,
-    {
-      token: string;
-      amount: bigint;
-      spokeProvider: T;
-    }
-  >({
-    mutationFn: async ({
+  const requestTrustline = useCallback(
+    async ({
       token,
       amount,
       spokeProvider,
@@ -68,15 +66,38 @@ export function useRequestTrustline<T extends SpokeProvider = SpokeProvider>(
       token: string;
       amount: bigint;
       spokeProvider: T;
-    }) => {
+    }): Promise<TxReturnType<StellarSpokeProvider, false>> => {
       if (!spokeProvider || !token || !amount || !(spokeProvider instanceof StellarSpokeProvider)) {
-        throw new Error('Spoke provider, token or amount not found');
+        const error = new Error('Spoke provider, token or amount not found');
+        setError(error);
+        throw error;
       }
 
-      return StellarSpokeService.requestTrustline(token, amount, spokeProvider);
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['stellar-trustline-check', token] });
+      setIsLoading(true);
+      setError(null);
+
+      try {
+        const result = await StellarSpokeService.requestTrustline(token, amount, spokeProvider);
+        setData(result);
+        setIsRequested(true);
+        queryClient.invalidateQueries({ queryKey: ['stellar-trustline-check', token] });
+        return result;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error('Unknown error occurred');
+        setError(error);
+        throw error;
+      } finally {
+        setIsLoading(false);
+      }
     },
-  });
+    [queryClient],
+  );
+
+  return {
+    requestTrustline,
+    isLoading,
+    isRequested,
+    error,
+    data,
+  };
 }