@sodax/dapp-kit 0.0.1-rc.9 → 1.0.0-rc.2

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/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/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,41 +1,40 @@
-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;
+      return await sodax.moneyMarket.data.getUserReservesData(spokeProvider);
     },
-    enabled: !!spokeChainId && !!hubProvider && !!address,
-    refetchInterval: 5000,
+    enabled: !!spokeProvider && !!address,
+    refetchInterval,
   });
-
-  return userReserves;
 }

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;
 }

package/src/hooks/provider/useSpokeProvider.ts

@@ -1,3 +1,4 @@
+import { useSodaxContext } from '@/index';
 import {
   EvmSpokeProvider,
   spokeChainConfig,
@@ -6,14 +7,17 @@ import {
   type EvmSpokeChainConfig,
   IconSpokeProvider,
   type IconSpokeChainConfig,
-  CWSpokeProvider,
-  type CosmosSpokeChainConfig,
+  InjectiveSpokeProvider,
+  type InjectiveSpokeChainConfig,
   StellarSpokeProvider,
   type StellarSpokeChainConfig,
   type SpokeProvider,
   type IWalletProvider,
   SolanaSpokeProvider,
   type SolanaChainConfig,
+  SONIC_MAINNET_CHAIN_ID,
+  SonicSpokeProvider,
+  type SonicSpokeChainConfig,
 } from '@sodax/sdk';
 import type {
   IEvmWalletProvider,
@@ -24,7 +28,6 @@ import type {
   IStellarWalletProvider,
   ISolanaWalletProvider,
 } from '@sodax/types';
-import { getXChainType, useWalletProvider } from '@sodax/wallet-sdk';
 import { useMemo } from 'react';
 
 /**
@@ -45,56 +48,77 @@ export function useSpokeProvider(
   spokeChainId: SpokeChainId | undefined,
   walletProvider?: IWalletProvider | undefined,
 ): SpokeProvider | undefined {
-  const xChainType = getXChainType(spokeChainId);
-  const walletProvider_ = useWalletProvider(spokeChainId);
-  const _walletProvider = walletProvider ?? walletProvider_;
+  const { rpcConfig } = useSodaxContext();
+  const xChainType = spokeChainId ? spokeChainConfig[spokeChainId]?.chain.type : undefined;
 
   const spokeProvider = useMemo(() => {
-    if (!_walletProvider) return undefined;
+    if (!walletProvider) return undefined;
     if (!spokeChainId) return undefined;
-
+    if (!xChainType) return undefined;
+    if (!rpcConfig) return undefined;
+    
     if (xChainType === 'EVM') {
+      if (spokeChainId === SONIC_MAINNET_CHAIN_ID) {
+        return new SonicSpokeProvider(
+          walletProvider as IEvmWalletProvider,
+          spokeChainConfig[spokeChainId] as SonicSpokeChainConfig,
+        );
+      }
       return new EvmSpokeProvider(
-        _walletProvider as IEvmWalletProvider,
+        walletProvider as IEvmWalletProvider,
         spokeChainConfig[spokeChainId] as EvmSpokeChainConfig,
       );
     }
+
     if (xChainType === 'SUI') {
       return new SuiSpokeProvider(
         spokeChainConfig[spokeChainId] as SuiSpokeChainConfig,
-        _walletProvider as ISuiWalletProvider,
+        walletProvider as ISuiWalletProvider,
       );
     }
+
     if (xChainType === 'ICON') {
       return new IconSpokeProvider(
-        _walletProvider as IIconWalletProvider,
+        walletProvider as IIconWalletProvider,
         spokeChainConfig[spokeChainId] as IconSpokeChainConfig,
       );
     }
+
     if (xChainType === 'INJECTIVE') {
-      return new CWSpokeProvider(
-        spokeChainConfig[spokeChainId] as CosmosSpokeChainConfig,
-        _walletProvider as IInjectiveWalletProvider,
+      return new InjectiveSpokeProvider(
+        spokeChainConfig[spokeChainId] as InjectiveSpokeChainConfig,
+        walletProvider as IInjectiveWalletProvider,
       );
     }
 
     if (xChainType === 'STELLAR') {
       const stellarConfig = spokeChainConfig[spokeChainId] as StellarSpokeChainConfig;
-      return new StellarSpokeProvider(_walletProvider as IStellarWalletProvider, stellarConfig, {
-        horizonRpcUrl: stellarConfig.horizonRpcUrl,
-        sorobanRpcUrl: stellarConfig.sorobanRpcUrl,
-      });
+      return new StellarSpokeProvider(
+        walletProvider as IStellarWalletProvider,
+        stellarConfig,
+        rpcConfig.stellar
+          ? rpcConfig.stellar
+          : {
+              horizonRpcUrl: stellarConfig.horizonRpcUrl,
+              sorobanRpcUrl: stellarConfig.sorobanRpcUrl,
+            },
+      );
     }
 
     if (xChainType === 'SOLANA') {
       return new SolanaSpokeProvider(
-        _walletProvider as ISolanaWalletProvider,
-        spokeChainConfig[spokeChainId] as SolanaChainConfig,
+        walletProvider as ISolanaWalletProvider,
+        rpcConfig.solana
+          ? ({
+              ...spokeChainConfig[spokeChainId],
+              rpcUrl: rpcConfig.solana,
+            } as SolanaChainConfig)
+          : (spokeChainConfig[spokeChainId] as SolanaChainConfig),
       );
     }
 
     return undefined;
-  }, [spokeChainId, xChainType, _walletProvider]);
+  }, [spokeChainId, xChainType, walletProvider, rpcConfig]);
 
   return spokeProvider;
 }

package/src/hooks/shared/index.ts

@@ -1 +1,5 @@
 export * from './useSodaxContext';
+export * from './useEstimateGas';
+export * from './useDeriveUserWalletAddress';
+export * from './useStellarTrustlineCheck';
+export * from './useRequestTrustline';

package/src/hooks/shared/useDeriveUserWalletAddress.ts

@@ -0,0 +1,44 @@
+// packages/dapp-kit/src/hooks/shared/useDeriveUserWalletAddress.ts
+import { deriveUserWalletAddress, type SpokeProvider } from '@sodax/sdk';
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from './useSodaxContext';
+import type { Address } from 'viem';
+
+/**
+ * Hook for deriving user wallet address for hub abstraction.
+ *
+ * This hook derives the user's abstracted wallet address for the hub chain.
+ * If the spoke chain is the same as the hub chain, it returns the original wallet address.
+ * Otherwise, it returns the abstracted wallet address for cross-chain operations.
+ *
+ * @param spokeProvider - The spoke provider instance for the origin chain
+ * @param walletAddress - Optional user wallet address on spoke chain. If not provided, will fetch from spokeProvider
+ * @returns A React Query result object containing:
+ *   - data: The derived user wallet address when available
+ *   - isLoading: Loading state indicator
+ *   - error: Any error that occurred during derivation
+ *
+ * @example
+ * ```typescript
+ * const { data: derivedAddress, isLoading, error } = useDeriveUserWalletAddress(spokeProvider, userAddress);
+ * ```
+ */
+export function useDeriveUserWalletAddress(
+  spokeProvider: SpokeProvider | undefined,
+  walletAddress?: string | undefined,
+): UseQueryResult<Address, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['deriveUserWalletAddress', spokeProvider?.chainConfig.chain.id, walletAddress],
+    queryFn: async (): Promise<Address> => {
+      if (!spokeProvider) {
+        throw new Error('Spoke provider is required');
+      }
+
+      return await deriveUserWalletAddress(spokeProvider, sodax.hubProvider, walletAddress);
+    },
+    enabled: !!spokeProvider,
+    refetchInterval: false, // This is a deterministic operation, no need to refetch
+  });
+}

package/src/hooks/shared/useEstimateGas.ts

@@ -0,0 +1,18 @@
+import { type GetEstimateGasReturnType, type SpokeProvider, SpokeService, type TxReturnType } from '@sodax/sdk';
+import { useMutation, type UseMutationResult } from '@tanstack/react-query';
+
+export function useEstimateGas<T extends SpokeProvider = SpokeProvider>(
+  spokeProvider: T | undefined,
+): UseMutationResult<GetEstimateGasReturnType<T>, Error, TxReturnType<T, true>> {
+  return useMutation<GetEstimateGasReturnType<T>, Error, TxReturnType<T, true>>({
+    mutationFn: async (rawTx: TxReturnType<T, true>) => {
+      if (!spokeProvider) {
+        throw new Error('spokeProvider is not found');
+      }
+
+      const response = await SpokeService.estimateGas(rawTx, spokeProvider);
+
+      return response;
+    },
+  });
+}