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

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.backendApi.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,7 @@ export * from './shared';
 export * from './provider';
 export * from './mm';
 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,
+  });
+}