@sodax/dapp-kit 0.0.1-rc.6 → 0.0.1-rc.8

package/src/hooks/mm/useBorrow.ts

@@ -1,9 +1,8 @@
 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}`];
@@ -16,6 +15,14 @@ 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(spokeToken);
@@ -26,9 +33,11 @@ interface BorrowResponse {
  *   - spokeProvider is not available
  *   - Transaction execution fails
  */
-export function useBorrow(spokeToken: XToken): UseMutationResult<BorrowResponse, Error, string> {
+export function useBorrow(
+  spokeToken: XToken,
+  spokeProvider: SpokeProvider | undefined,
+): UseMutationResult<BorrowResponse, Error, string> {
   const { sodax } = useSodaxContext();
-  const spokeProvider = useSpokeProvider(spokeToken.xChainId as SpokeChainId);
 
   return useMutation<BorrowResponse, Error, string>({
     mutationFn: async (amount: string) => {
@@ -40,12 +49,12 @@ export function useBorrow(spokeToken: XToken): UseMutationResult<BorrowResponse,
         {
           token: spokeToken.address,
           amount: parseUnits(amount, 18),
+          action: 'borrow',
         },
         spokeProvider,
       );
 
       if (!response.ok) {
-        console.log('Failed to borrow tokens', response);
         throw new Error('Failed to borrow tokens');
       }
 

package/src/hooks/mm/useMMAllowance.ts

@@ -0,0 +1,55 @@
+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 allowance = await sodax.moneyMarket.isAllowanceValid(
+        {
+          token: token.address,
+          amount: parseUnits(amount, token.decimals),
+          action,
+        },
+        spokeProvider,
+      );
+      if (allowance.ok) {
+        return allowance.value;
+      }
+      return false;
+    },
+    enabled: !!spokeProvider,
+  });
+}

package/src/hooks/mm/useMMApprove.ts

@@ -0,0 +1,67 @@
+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 allowance = await sodax.moneyMarket.approve(
+        {
+          token: token.address,
+          amount: parseUnits(amount, token.decimals),
+          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,8 +1,7 @@
-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 RepayResponse {
@@ -17,6 +16,14 @@ 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(spokeToken);
@@ -27,9 +34,11 @@ interface RepayResponse {
  *   - spokeProvider is not available
  *   - Transaction execution fails
  */
-export function useRepay(spokeToken: XToken): UseMutationResult<RepayResponse, Error, string> {
+export function useRepay(
+  spokeToken: XToken,
+  spokeProvider: SpokeProvider | undefined,
+): UseMutationResult<RepayResponse, Error, string> {
   const { sodax } = useSodaxContext();
-  const spokeProvider = useSpokeProvider(spokeToken.xChainId as SpokeChainId);
 
   return useMutation<RepayResponse, Error, string>({
     mutationFn: async (amount: string) => {
@@ -41,6 +50,7 @@ export function useRepay(spokeToken: XToken): UseMutationResult<RepayResponse, E
         {
           token: spokeToken.address,
           amount: parseUnits(amount, spokeToken.decimals),
+          action: 'repay',
         },
         spokeProvider,
       );

package/src/hooks/mm/useSupply.ts

@@ -1,8 +1,7 @@
-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 {
@@ -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) => {
@@ -47,6 +49,7 @@ export function useSupply(spokeToken: XToken): UseMutationResult<SupplyResponse,
         {
           token: spokeToken.address,
           amount: parseUnits(amount, spokeToken.decimals),
+          action: 'supply',
         },
         spokeProvider,
       );

package/src/hooks/mm/useUserReservesData.ts

@@ -1,30 +1,24 @@
 import { allXTokens } from '@/core';
-import { EvmWalletAbstraction, getMoneyMarketConfig, type EvmHubProvider } from '@sodax/sdk';
+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 { useSodaxContext } from '../shared/useSodaxContext';
-import { useSpokeProvider } from '../provider/useSpokeProvider';
 
-export function useUserReservesData(spokeChainId: ChainId) {
+export function useUserReservesData(spokeChainId: ChainId, address: string | undefined) {
   const { sodax } = useSodaxContext();
   const hubChainId = (sodax.config?.hubProviderConfig?.chainConfig.chain.id ?? 'sonic') as HubChainId;
   const hubProvider = useHubProvider();
-  const spokeProvider = useSpokeProvider(spokeChainId as SpokeChainId);
 
   const { data: userReserves } = useQuery({
-    queryKey: ['userReserves', spokeChainId],
+    queryKey: ['userReserves', spokeChainId, address],
     queryFn: async () => {
-      if (!hubProvider) {
+      if (!hubProvider || !address) {
         return;
       }
 
-      if (!spokeProvider) {
-        return;
-      }
-
-      const addressBytes = await spokeProvider.walletProvider.getWalletAddressBytes();
+      const addressBytes = encodeAddress(spokeChainId, address);
       const hubWalletAddress = await EvmWalletAbstraction.getUserHubWalletAddress(
         spokeChainId as SpokeChainId,
         addressBytes,
@@ -45,7 +39,7 @@ export function useUserReservesData(spokeChainId: ChainId) {
         };
       });
     },
-    enabled: !!spokeProvider && !!hubProvider,
+    enabled: !!spokeChainId && !!hubProvider && !!address,
     refetchInterval: 5000,
   });
 

package/src/hooks/mm/useWithdraw.ts

@@ -1,8 +1,7 @@
-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 WithdrawResponse {
@@ -17,6 +16,12 @@ interface WithdrawResponse {
  * handling the entire withdrawal process including transaction creation, submission,
  * and cross-chain communication.
  *
+ * @param {XToken} spokeToken - The token to withdraw from the spoke chain. Must be an XToken with valid address and chain information.
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for the withdraw transaction. Must be a valid SpokeProvider instance.
+ *
+ * @returns {UseMutationResult<WithdrawResponse, Error, string>} A mutation result object with the following properties:
+ *   - mutateAsync: Function to execute the withdraw transaction
+ *   - isPending: Boolean indicating if a transaction is in progress
  * @example
  * ```typescript
  * const { mutateAsync: withdraw, isPending, error } = useWithdraw(spokeToken);
@@ -27,9 +32,11 @@ interface WithdrawResponse {
  *   - spokeProvider is not available
  *   - Transaction execution fails
  */
-export function useWithdraw(spokeToken: XToken): UseMutationResult<WithdrawResponse, Error, string> {
+export function useWithdraw(
+  spokeToken: XToken,
+  spokeProvider: SpokeProvider | undefined,
+): UseMutationResult<WithdrawResponse, Error, string> {
   const { sodax } = useSodaxContext();
-  const spokeProvider = useSpokeProvider(spokeToken.xChainId as SpokeChainId);
 
   return useMutation<WithdrawResponse, Error, string>({
     mutationFn: async (amount: string) => {
@@ -42,6 +49,7 @@ export function useWithdraw(spokeToken: XToken): UseMutationResult<WithdrawRespo
           token: spokeToken.address,
           // vault token on hub chain decimals is 18
           amount: parseUnits(amount, 18),
+          action: 'withdraw',
         },
         spokeProvider,
       );

package/src/hooks/provider/useSpokeProvider.ts

@@ -8,6 +8,10 @@ import {
   type IconSpokeChainConfig,
   CWSpokeProvider,
   type CosmosSpokeChainConfig,
+  StellarSpokeProvider,
+  type StellarSpokeChainConfig,
+  type SpokeProvider,
+  type IWalletProvider,
 } from '@sodax/sdk';
 import type {
   IEvmWalletProvider,
@@ -15,42 +19,74 @@ import type {
   ISuiWalletProvider,
   SpokeChainId,
   IInjectiveWalletProvider,
+  IStellarWalletProvider,
 } from '@sodax/types';
 import { getXChainType, useWalletProvider } from '@sodax/wallet-sdk';
 import { useMemo } from 'react';
 
-export function useSpokeProvider(spokeChainId: SpokeChainId) {
+/**
+ * Hook to get the appropriate spoke provider based on the chain type.
+ * Supports EVM, SUI, ICON and INJECTIVE chains.
+ *
+ * @param {SpokeChainId | undefined} spokeChainId - The spoke chain ID to get the provider for
+ * @param {IWalletProvider | undefined} walletProvider - The wallet provider to use
+ * @returns {SpokeProvider | undefined} The appropriate spoke provider instance for the given chain ID, or undefined if invalid/unsupported
+ *
+ * @example
+ * ```tsx
+ * // Using a specific SpokeChainId and wallet provider
+ * const spokeProvider = useSpokeProvider(spokeChainId, walletProvider);
+ * ```
+ */
+export function useSpokeProvider(
+  spokeChainId: SpokeChainId | undefined,
+  walletProvider?: IWalletProvider | undefined,
+): SpokeProvider | undefined {
   const xChainType = getXChainType(spokeChainId);
-  const walletProvider = useWalletProvider(spokeChainId);
+  const walletProvider_ = useWalletProvider(spokeChainId);
+  const _walletProvider = walletProvider ?? walletProvider_;
+
   const spokeProvider = useMemo(() => {
-    if (!walletProvider) return undefined;
+    if (!_walletProvider) return undefined;
+    if (!spokeChainId) return undefined;
+
     if (xChainType === 'EVM') {
       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,
+        _walletProvider as IInjectiveWalletProvider,
+      );
+    }
+
+    if (xChainType === 'STELLAR') {
+      const stellarConfig = spokeChainConfig[spokeChainId] as StellarSpokeChainConfig;
+      return new StellarSpokeProvider(
+        _walletProvider as IStellarWalletProvider,
+        stellarConfig.addresses.assetManager,
+        stellarConfig,
+        stellarConfig.rpc_url,
       );
     }
 
     return undefined;
-  }, [walletProvider, xChainType, spokeChainId]);
+  }, [spokeChainId, xChainType, _walletProvider]);
 
   return spokeProvider;
 }

package/src/hooks/shared/index.ts

@@ -1,3 +1 @@
 export * from './useSodaxContext';
-export * from './useAllowance';
-export * from './useApprove';

package/src/hooks/swap/index.ts

@@ -1,3 +1,5 @@
 export * from './useQuote';
 export * from './useCreateIntentOrder';
 export * from './useStatus';
+export * from './useSwapAllowance';
+export * from './useSwapApprove';

package/src/hooks/swap/useCreateIntentOrder.ts

@@ -1,15 +1,14 @@
 import { useSodaxContext } from '../shared/useSodaxContext';
 import type {
   CreateIntentParams,
-  SpokeChainId,
   IntentExecutionResponse,
   Result,
   IntentSubmitErrorCode,
   Intent,
   PacketData,
   IntentSubmitError,
+  SpokeProvider,
 } from '@sodax/sdk';
-import { useSpokeProvider } from '../provider/useSpokeProvider';
 import { useMutation, type UseMutationResult } from '@tanstack/react-query';
 
 type CreateIntentResult = Result<
@@ -21,12 +20,12 @@ type CreateIntentResult = Result<
  * Hook for creating and submitting an intent order for cross-chain swaps.
  * Uses React Query's useMutation for better state management and caching.
  *
- * @param {SpokeChainId} chainId - The source chain ID where the swap will originate
+ * @param {SpokeProvider} spokeProvider - The spoke provider to use for the swap
  * @returns {UseMutationResult} Mutation result object containing mutation function and state
  *
  * @example
  * ```typescript
- * const { mutateAsync: createIntent, isPending } = useCreateIntentOrder('0xa4b1.arbitrum');
+ * const { mutateAsync: createIntent, isPending } = useCreateIntentOrder(spokeProvider);
  *
  * const handleSwap = async () => {
  *   const result = await createIntent({
@@ -41,10 +40,9 @@ type CreateIntentResult = Result<
  * ```
  */
 export function useCreateIntentOrder(
-  chainId: SpokeChainId,
+  spokeProvider: SpokeProvider | undefined,
 ): UseMutationResult<CreateIntentResult, Error, CreateIntentParams> {
   const { sodax } = useSodaxContext();
-  const spokeProvider = useSpokeProvider(chainId);
 
   return useMutation<CreateIntentResult, Error, CreateIntentParams>({
     mutationFn: async (params: CreateIntentParams) => {

package/src/hooks/swap/useSwapAllowance.ts

@@ -0,0 +1,44 @@
+import { useQuery, type UseQueryResult } from '@tanstack/react-query';
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { CreateIntentParams, 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 {CreateIntentParams} params - The parameters for the intent 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 } = useMMAllowance(params, spokeProvider);
+ * ```
+ */
+export function useSwapAllowance(
+  params: CreateIntentParams | undefined,
+  spokeProvider: SpokeProvider | undefined,
+): UseQueryResult<boolean, Error> {
+  const { sodax } = useSodaxContext();
+
+  return useQuery({
+    queryKey: ['allowance', params],
+    queryFn: async () => {
+      if (!spokeProvider || !params) {
+        return false;
+      }
+      const allowance = await sodax.solver.isAllowanceValid(params, spokeProvider);
+      if (allowance.ok) {
+        return allowance.value;
+      }
+      return false;
+    },
+    enabled: !!spokeProvider && !!params,
+  });
+}

package/src/hooks/swap/useSwapApprove.ts

@@ -0,0 +1,68 @@
+import { useSodaxContext } from '../shared/useSodaxContext';
+import type { Token } from '@sodax/types';
+import { type Address, parseUnits } from 'viem';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import type { SpokeProvider } from '@sodax/sdk';
+
+interface UseApproveReturn {
+  approve: ({ amount }: { amount: string }) => 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 } = useApprove(token, spokeProvider);
+ *
+ * // Approve tokens for supply action
+ * await approve({ amount: "100", action: "supply" });
+ * ```
+ */
+
+export function useSwapApprove(token: Token | undefined, spokeProvider: SpokeProvider | undefined): UseApproveReturn {
+  const { sodax } = useSodaxContext();
+  const queryClient = useQueryClient();
+
+  const {
+    mutateAsync: approve,
+    isPending,
+    error,
+    reset: resetError,
+  } = useMutation({
+    mutationFn: async ({ amount }: { amount: string }) => {
+      if (!spokeProvider) {
+        throw new Error('Spoke provider not found');
+      }
+      if (!token) {
+        throw new Error('Token not found');
+      }
+
+      const allowance = await sodax.solver.approve(
+        token.address as Address,
+        parseUnits(amount, token.decimals),
+        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/dist/hooks/shared/useAllowance.d.ts

@@ -1,3 +0,0 @@
-import type { XToken } from '@sodax/types';
-export declare function useAllowance(token: XToken, amount: string): import("@tanstack/react-query").UseQueryResult<boolean, Error>;
-//# sourceMappingURL=useAllowance.d.ts.map

package/dist/hooks/shared/useAllowance.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useAllowance.d.ts","sourceRoot":"","sources":["../../../src/hooks/shared/useAllowance.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAgB,MAAM,EAAE,MAAM,cAAc,CAAC;AAKzD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,kEAwBzD"}

package/dist/hooks/shared/useApprove.d.ts

@@ -1,10 +0,0 @@
-import type { XToken } from '@sodax/types';
-interface UseApproveReturn {
-    approve: (amount: string) => Promise<boolean>;
-    isLoading: boolean;
-    error: Error | null;
-    resetError: () => void;
-}
-export declare function useApprove(token: XToken): UseApproveReturn;
-export {};
-//# sourceMappingURL=useApprove.d.ts.map

package/dist/hooks/shared/useApprove.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useApprove.d.ts","sourceRoot":"","sources":["../../../src/hooks/shared/useApprove.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAgB,MAAM,EAAE,MAAM,cAAc,CAAC;AAKzD,UAAU,gBAAgB;IACxB,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9C,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,gBAAgB,CAsC1D"}

package/src/hooks/shared/useAllowance.ts

@@ -1,31 +0,0 @@
-import { useQuery } from '@tanstack/react-query';
-import type { SpokeChainId, XToken } from '@sodax/types';
-import { useSodaxContext } from '../shared/useSodaxContext';
-import { useSpokeProvider } from '../provider/useSpokeProvider';
-import { parseUnits } from 'viem';
-
-export function useAllowance(token: XToken, amount: string) {
-  const { sodax } = useSodaxContext();
-  const spokeProvider = useSpokeProvider(token.xChainId as SpokeChainId);
-
-  return useQuery({
-    queryKey: ['allowance', token.address, amount],
-    queryFn: async () => {
-      if (!spokeProvider) {
-        return false;
-      }
-      const allowance = await sodax.moneyMarket.isAllowanceValid(
-        {
-          token: token.address,
-          amount: parseUnits(amount, token.decimals),
-        },
-        spokeProvider,
-      );
-      if (allowance.ok) {
-        return allowance.value;
-      }
-      return false;
-    },
-    enabled: !!spokeProvider,
-  });
-}