wagmi-extended 1.1.8 → 2.0.1

package/src/fetch-functions/erc4626/fetchERC4626MaxDepositX.ts

@@ -0,0 +1,27 @@
+import { QueryClient } from "@tanstack/react-query";
+import { Address, erc4626Abi } from "viem";
+import { Config } from "wagmi";
+import { readContractQueryOptions } from "wagmi/query";
+import { queryConfig } from "../../query-config/index.js";
+import { ensureClientAndConfig } from "../../utils/ensureClientAndConfig.js";
+
+export async function fetchERC4626MaxDepositX(
+  vault: Address,
+  caller: Address,
+  queryClient?: QueryClient,
+  wagmiConfig?: Config
+): Promise<bigint> {
+  ({ queryClient, wagmiConfig } = ensureClientAndConfig(
+    queryClient,
+    wagmiConfig
+  ));
+  return queryClient.fetchQuery({
+    ...readContractQueryOptions(wagmiConfig, {
+      address: vault,
+      abi: erc4626Abi,
+      functionName: "maxDeposit",
+      args: [caller],
+    }),
+    ...queryConfig.semiSensitiveQuery,
+  });
+}

package/src/fetch-functions/erc4626/fetchERC4626MaxMintX.ts

@@ -0,0 +1,27 @@
+import { QueryClient } from "@tanstack/react-query";
+import { Address, erc4626Abi } from "viem";
+import { Config } from "wagmi";
+import { readContractQueryOptions } from "wagmi/query";
+import { queryConfig } from "../../query-config/index.js";
+import { ensureClientAndConfig } from "../../utils/ensureClientAndConfig.js";
+
+export async function fetchERC4626MaxMintX(
+  vault: Address,
+  caller: Address,
+  queryClient?: QueryClient,
+  wagmiConfig?: Config
+): Promise<bigint> {
+  ({ queryClient, wagmiConfig } = ensureClientAndConfig(
+    queryClient,
+    wagmiConfig
+  ));
+  return queryClient.fetchQuery({
+    ...readContractQueryOptions(wagmiConfig, {
+      address: vault,
+      abi: erc4626Abi,
+      functionName: "maxMint",
+      args: [caller],
+    }),
+    ...queryConfig.semiSensitiveQuery,
+  });
+}

package/src/fetch-functions/erc4626/fetchERC4626MaxRedeemX.ts

@@ -0,0 +1,27 @@
+import { QueryClient } from "@tanstack/react-query";
+import { Address, erc4626Abi } from "viem";
+import { Config } from "wagmi";
+import { readContractQueryOptions } from "wagmi/query";
+import { queryConfig } from "../../query-config/index.js";
+import { ensureClientAndConfig } from "../../utils/ensureClientAndConfig.js";
+
+export async function fetchERC4626MaxRedeemX(
+  vault: Address,
+  owner: Address,
+  queryClient?: QueryClient,
+  wagmiConfig?: Config
+): Promise<bigint> {
+  ({ queryClient, wagmiConfig } = ensureClientAndConfig(
+    queryClient,
+    wagmiConfig
+  ));
+  return queryClient.fetchQuery({
+    ...readContractQueryOptions(wagmiConfig, {
+      address: vault,
+      abi: erc4626Abi,
+      functionName: "maxRedeem",
+      args: [owner],
+    }),
+    ...queryConfig.semiSensitiveQuery,
+  });
+}

package/src/fetch-functions/erc4626/fetchERC4626MaxWithdrawX.ts

@@ -0,0 +1,27 @@
+import { QueryClient } from "@tanstack/react-query";
+import { Address, erc4626Abi } from "viem";
+import { Config } from "wagmi";
+import { readContractQueryOptions } from "wagmi/query";
+import { queryConfig } from "../../query-config/index.js";
+import { ensureClientAndConfig } from "../../utils/ensureClientAndConfig.js";
+
+export async function fetchERC4626MaxWithdrawX(
+  vault: Address,
+  owner: Address,
+  queryClient?: QueryClient,
+  wagmiConfig?: Config
+): Promise<bigint> {
+  ({ queryClient, wagmiConfig } = ensureClientAndConfig(
+    queryClient,
+    wagmiConfig
+  ));
+  return queryClient.fetchQuery({
+    ...readContractQueryOptions(wagmiConfig, {
+      address: vault,
+      abi: erc4626Abi,
+      functionName: "maxWithdraw",
+      args: [owner],
+    }),
+    ...queryConfig.semiSensitiveQuery,
+  });
+}

package/src/fetch-functions/erc4626/fetchERC4626TotalAssetsX.ts

@@ -0,0 +1,25 @@
+import { QueryClient } from "@tanstack/react-query";
+import { Address, erc4626Abi } from "viem";
+import { Config } from "wagmi";
+import { readContractQueryOptions } from "wagmi/query";
+import { queryConfig } from "../../query-config/index.js";
+import { ensureClientAndConfig } from "../../utils/ensureClientAndConfig.js";
+
+export async function fetchERC4626TotalAssetsX(
+  vault: Address,
+  queryClient?: QueryClient,
+  wagmiConfig?: Config
+): Promise<bigint> {
+  ({ queryClient, wagmiConfig } = ensureClientAndConfig(
+    queryClient,
+    wagmiConfig
+  ));
+  return queryClient.fetchQuery({
+    ...readContractQueryOptions(wagmiConfig, {
+      address: vault,
+      abi: erc4626Abi,
+      functionName: "totalAssets",
+    }),
+    ...queryConfig.semiSensitiveQuery,
+  });
+}

package/src/fetch-functions/fetchTokenX.ts

@@ -2,8 +2,8 @@ import { QueryClient } from "@tanstack/react-query";
 import { readContractQueryOptions } from "wagmi/query";
 import { Address, zeroAddress, erc20Abi } from "viem";
 import { Config } from "wagmi";
-import { getDefaults } from "../config/defaults.js";
 import { queryConfig } from "../query-config/index.js";
+import { ensureClientAndConfig } from "../utils/ensureClientAndConfig.js";
 
 export interface Token {
   symbol: string;
@@ -22,15 +22,10 @@ export async function fetchDecimalsX(
   queryClient?: QueryClient,
   wagmiConfig?: Config
 ): Promise<number | undefined> {
-  if (!queryClient || !wagmiConfig) {
-    ({ queryClient, wagmiConfig } = getDefaults());
-  }
-  if (!queryClient || !wagmiConfig) {
-    throw new Error(
-      "Could not find queryClient or wagmiConfig, either pass them as arguments or set them using setDefaults()"
-    );
-  }
-
+  ({ queryClient, wagmiConfig } = ensureClientAndConfig(
+    queryClient,
+    wagmiConfig
+  ));
   if (token === zeroAddress) return EthTokenData.decimals;
 
   const decimals = await queryClient.fetchQuery({
@@ -39,7 +34,7 @@ export async function fetchDecimalsX(
       abi: erc20Abi,
       functionName: "decimals",
     }),
-    ...queryConfig.metadataQueryConfig,
+    ...queryConfig.metaDataQuery,
   });
 
   return decimals;
@@ -50,15 +45,10 @@ export async function fetchSymbolX(
   queryClient?: QueryClient,
   wagmiConfig?: Config
 ): Promise<string> {
-  if (!queryClient || !wagmiConfig) {
-    ({ queryClient, wagmiConfig } = getDefaults());
-  }
-  if (!queryClient || !wagmiConfig) {
-    throw new Error(
-      "Could not find queryClient or wagmiConfig, either pass them as arguments or set them using setDefaults()"
-    );
-  }
-
+  ({ queryClient, wagmiConfig } = ensureClientAndConfig(
+    queryClient,
+    wagmiConfig
+  ));
   if (token === zeroAddress) return EthTokenData.symbol;
 
   const symbol = await queryClient.fetchQuery({
@@ -67,7 +57,7 @@ export async function fetchSymbolX(
       abi: erc20Abi,
       functionName: "symbol",
     }),
-    ...queryConfig.metadataQueryConfig,
+    ...queryConfig.metaDataQuery,
   });
 
   return symbol;
@@ -80,14 +70,10 @@ export async function fetchNameX(
 ): Promise<string> {
   if (token === zeroAddress) return EthTokenData.name;
 
-  if (!queryClient || !wagmiConfig) {
-    ({ queryClient, wagmiConfig } = getDefaults());
-  }
-  if (!queryClient || !wagmiConfig) {
-    throw new Error(
-      "Could not find queryClient or wagmiConfig, either pass them as arguments or set them using setDefaults()"
-    );
-  }
+  ({ queryClient, wagmiConfig } = ensureClientAndConfig(
+    queryClient,
+    wagmiConfig
+  ));
 
   const name = await queryClient.fetchQuery({
     ...readContractQueryOptions(wagmiConfig, {
@@ -95,7 +81,7 @@ export async function fetchNameX(
       abi: erc20Abi,
       functionName: "name",
     }),
-    ...queryConfig.metadataQueryConfig,
+    ...queryConfig.metaDataQuery,
   });
 
   return name;

package/src/hooks/{useContractWriteX.ts → mutations/useContractWriteX.ts}

@@ -1,8 +1,9 @@
-import { useWriteContract } from "wagmi";
+import { usePublicClient, useSimulateContract, useWriteContract } from "wagmi";
 import {
   WriteExtendedAsyncParams,
   useHandleTransactionMutationX,
 } from "./useHandleTransactionMutationX.js";
+import { Address } from "viem";
 
 /**
  * Custom hook for writing to a smart contract using Wagmi.
@@ -64,23 +65,42 @@ import {
  * }
  */
 
-export function useContractWriteX(settings?: WriteExtendedAsyncParams) {
+export function useContractWriteX(settings: WriteExtendedAsyncParams) {
+  const publicClient = usePublicClient();
+
   const { isPending, errorMessage, onMutate, onSettled } =
-    useHandleTransactionMutationX({
-      settings,
-    });
+    useHandleTransactionMutationX({ settings });
 
-  const { writeContractAsync, ...rest } = useWriteContract({
-    mutation: {
-      onMutate,
-      onSettled,
-    },
+  // Underlying Wagmi write hook:
+  const wagmiWrite = useWriteContract({
+    mutation: { onMutate, onSettled },
   });
 
+  async function simulateAsyncAndWriteContract(
+    params: Parameters<typeof wagmiWrite.writeContract>[0]
+  ) {
+    // 0) signal start
+    onMutate();
+
+    try {
+      // 1) optional dry-run
+      const { chain, ...others } = params;
+
+      await publicClient?.simulateContract({
+        ...others,
+        ...(chain != null ? { chain } : {}),
+      });
+
+      wagmiWrite.writeContract(params);
+    } catch (err) {
+      await onSettled(undefined, err, params);
+    }
+  }
+
   return {
-    ...rest,
+    ...wagmiWrite,
+    simulateAsyncAndWriteContract,
     isPending,
     errorMessage,
-    writeContractAsync,
   };
 }

package/src/hooks/{useERC20ApproveX.ts → mutations/useERC20ApproveX.ts}

@@ -1,6 +1,6 @@
 import { useState, useEffect } from "react";
 import { Address, maxUint256, erc20Abi } from "viem";
-import { useFetchAssetAllowanceX } from "./useFetchAssetAllowanceX.js";
+import { useFetchAssetAllowanceX } from "../queries/useFetchAssetAllowanceX.js";
 import { useContractWriteX } from "./useContractWriteX.js";
 
 /**

package/src/hooks/{useHandleTransactionMutationX.ts → mutations/useHandleTransactionMutationX.ts}

@@ -1,16 +1,28 @@
 import { waitForTransactionReceipt } from "wagmi/actions";
 import { useConfig } from "wagmi";
-import { QueryKey } from "@tanstack/query-core";
+import { Query, QueryKey } from "@tanstack/query-core";
 import { Address } from "viem";
 import { useState } from "react";
-import { getParsedErrorX } from "../utils/errorParserX.js";
 import { useInvalidateQueries } from "./useInvalidateQueries.js";
+import { useQueryClient } from "@tanstack/react-query";
+import { getParsedErrorX } from "../../utils/errorParserX.js";
 
 export type WriteExtendedAsyncParams = {
   onSuccess?: (txHash: Address) => void;
   onError?: (e: any) => void;
   onSettled?: () => void;
+
+  onSuccessAsync?: (txHash: Address) => Promise<void>;
+  onErrorAsync?: (e: any) => Promise<void>;
+  onSettledAsync?: () => Promise<void>;
+
+  /** simple list of keys to invalidate */
   queriesToInvalidate?: (QueryKey | undefined)[];
+  /** a predicate to decide which queries to invalidate */
+  invalidatePredicate?: (query: Query<unknown, unknown>) => boolean;
+
+  simulationOverrideAbis?: any;
+
   disableLogging?: boolean;
   disableWaitingForReceipt?: boolean;
 };
@@ -26,6 +38,7 @@ export function useHandleTransactionMutationX({
   settings?: WriteExtendedAsyncParams;
 }) {
   const wagmiConfig = useConfig();
+  const queryClient = useQueryClient();
 
   const { invalidateMany } = useInvalidateQueries();
   const [isPending, setIsPending] = useState(false);
@@ -60,11 +73,22 @@ export function useHandleTransactionMutationX({
       }
 
       // 3. invalidate queries
-      if (settings?.queriesToInvalidate)
-        await invalidateMany(settings?.queriesToInvalidate);
+      const { queriesToInvalidate, invalidatePredicate } = settings || {};
+
+      if (invalidatePredicate) {
+        // 1) predicate-based
+        await queryClient.invalidateQueries({
+          predicate: invalidatePredicate,
+        });
+      }
+      if (queriesToInvalidate) {
+        // 2) explicit key list
+        await invalidateMany(queriesToInvalidate);
+      }
 
       // 4. call onSuccess callback
       settings?.onSuccess?.(txHash!);
+      if (settings?.onSuccessAsync) await settings.onSuccessAsync(txHash!);
 
       if (!settings?.disableLogging) {
         // 5. log result
@@ -90,10 +114,12 @@ export function useHandleTransactionMutationX({
 
       // 3. call callback
       settings?.onError?.(error);
+      if (settings?.onErrorAsync) await settings.onErrorAsync(error);
     } finally {
       setIsPending(false);
       // 1. call callback
       settings?.onSettled?.();
+      if (settings?.onSettledAsync) await settings.onSettledAsync();
     }
     return undefined;
   };

package/src/hooks/{useSendTransactionX.ts → mutations/useSendTransactionX.ts}

@@ -1,8 +1,9 @@
-import { useSendTransaction } from "wagmi";
+import { usePublicClient, useSendTransaction, useWriteContract } from "wagmi";
 import {
   useHandleTransactionMutationX,
   WriteExtendedAsyncParams,
 } from "./useHandleTransactionMutationX.js";
+import { writeContract } from "wagmi/actions";
 
 /**
  * Custom hook for sending a transaction using Wagmi.
@@ -52,22 +53,54 @@ import {
  */
 
 export function useSendTransactionX(settings?: WriteExtendedAsyncParams) {
+  const publicClient = usePublicClient();
+
   const { isPending, errorMessage, onMutate, onSettled } =
     useHandleTransactionMutationX({
       settings,
     });
 
-  const { sendTransactionAsync, ...rest } = useSendTransaction({
+  const { sendTransaction, ...rest } = useSendTransaction({
     mutation: {
       onMutate,
       onSettled,
     },
   });
 
+  /**
+   * Wraps sendTransaction with an optional simulation.
+   */
+  async function simulateAsyncAndSendTransaction(
+    params: Parameters<typeof sendTransaction>[0],
+    simulationParams: Parameters<typeof writeContract>[1]
+  ) {
+    onMutate();
+
+    try {
+      if (params.to) {
+        //simulate!
+        await publicClient?.simulateContract({
+          address: params.to,
+          abi: simulationParams.abi,
+          functionName: simulationParams.functionName,
+          args: simulationParams.args ?? [],
+          account: params.account,
+          ...(simulationParams.chain != null
+            ? { chain: simulationParams.chain }
+            : {}),
+        });
+      }
+      // actual send!
+      await sendTransaction(params);
+    } catch (err) {
+      await onSettled(undefined, err, params);
+    }
+  }
+
   return {
     ...rest,
     isPending,
     errorMessage,
-    sendTransactionAsync,
+    simulateAsyncAndSendTransaction,
   };
 }

package/src/hooks/queries/useERC20Data.ts

@@ -0,0 +1,40 @@
+// hooks/useFetchERC20DataX.js
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { Address } from "viem";
+import { useAccount, useConfig } from "wagmi";
+import { fetchERC20DataX } from "../../fetch-functions/erc20/fetchERC20DataX.js";
+import { queryConfig } from "../../query-config/index.js";
+
+const HookFetchERC20DataQK = (
+  address?: Address,
+  userAddress?: Address,
+  spender?: Address
+) => ["HookFetchERC20Data", address, userAddress, spender] as const;
+
+/**
+ * Hook to fetch ERC-20 summary data for a given token and optional user/spender context.
+ *
+ * @param {{ address?: Address; user?: Address; spender?: Address }} params
+ * @param {import('@tanstack/react-query').UseQueryOptions=} options
+ */
+export function useFetchERC20DataX({
+  address,
+  user,
+  spender,
+}: {
+  address?: Address;
+  user?: Address;
+  spender?: Address;
+}) {
+  const config = useConfig();
+  const queryClient = useQueryClient();
+  const { address: account } = useAccount();
+  const userAddress = user || account;
+
+  return useQuery({
+    queryKey: HookFetchERC20DataQK(address, userAddress, spender),
+    queryFn: () =>
+      fetchERC20DataX(address!, userAddress, spender, queryClient, config),
+    enabled: Boolean(address),
+  });
+}

package/src/hooks/{useFetchAssetAllowanceX.ts → queries/useFetchAssetAllowanceX.ts}

@@ -1,8 +1,8 @@
 import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { Address, erc20Abi } from "viem";
 import { useAccount, useConfig } from "wagmi";
-import { queryConfig } from "../query-config/index.js";
-import { fetchAllowance } from "../fetch-functions/fetchAllowanceX.js";
+import { fetchAllowanceX } from "../../fetch-functions/erc20/fetchAllowanceX.js";
+import { queryConfig } from "../../query-config/index.js";
 
 const HookFetchAssetAllowanceQK = (
   asset?: Address,
@@ -43,13 +43,15 @@ export const useFetchAssetAllowanceX = ({
   spender?: Address;
 }) => {
   const config = useConfig();
+  const queryClient = useQueryClient();
   const { address: userAddress } = useAccount();
 
   const { data, ...rest } = useQuery({
     queryKey: HookFetchAssetAllowanceQK(asset, spender, userAddress),
-    queryFn: () => fetchAllowance(asset!, spender!, userAddress!, config),
+    queryFn: () =>
+      fetchAllowanceX(asset!, spender!, userAddress!, queryClient, config),
     enabled: Boolean(asset) && Boolean(spender) && Boolean(userAddress),
-    ...queryConfig.sensitiveDataQueryConfig,
+    ...queryConfig.lowSensitiveQuery,
   });
 
   return {

package/src/hooks/queries/useFetchERC4626DataX.ts

@@ -0,0 +1,39 @@
+// hooks/useFetchERC4626DataX.js
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { Address } from "viem";
+import { useAccount, useConfig } from "wagmi";
+import { fetchERC4626DataX } from "../../fetch-functions/erc4626/fetchERC4626DataX.js";
+
+const HookFetchERC4626DataQK = (
+  vault?: Address,
+  userAddress?: Address,
+  spender?: Address
+) => ["HookFetchERC4626Data", vault, userAddress, spender] as const;
+
+/**
+ * Hook to fetch ERC-4626 vault summary data for a given vault and user/spender.
+ *
+ * @param {{ vault?: Address; user?: Address; spender?: Address }} params
+ * @param {import('@tanstack/react-query').UseQueryOptions=} options
+ */
+export function useFetchERC4626DataX({
+  vault,
+  user,
+  spender,
+}: {
+  vault?: Address;
+  user?: Address;
+  spender?: Address;
+}) {
+  const config = useConfig();
+  const queryClient = useQueryClient();
+  const { address: account } = useAccount();
+  const userAddress = user || account;
+
+  return useQuery({
+    queryKey: HookFetchERC4626DataQK(vault, userAddress, spender),
+    queryFn: () =>
+      fetchERC4626DataX(vault!, userAddress, spender, queryClient, config),
+    enabled: Boolean(vault),
+  });
+}

package/src/hooks/{useTokenX.ts → queries/useTokenX.ts}

@@ -1,7 +1,7 @@
 import { useQueryClient, useQuery } from "@tanstack/react-query";
 import { Address } from "viem";
 import { useConfig } from "wagmi";
-import { fetchTokenX } from "../fetch-functions/fetchTokenX.js";
+import { fetchTokenX } from "../../fetch-functions/fetchTokenX.js";
 
 /**
  * Returns a query key for fetching token data.

package/src/index.ts

@@ -1,20 +1,31 @@
 /* ------------- */
 /*   Mutations   */
 /* ------------- */
-export * from "./hooks/useContractWriteX.js";
-export * from "./hooks/useSendTransactionX.js";
-export * from "./hooks/useERC20ApproveX.js";
+export * from "./hooks/mutations/useContractWriteX.js";
+export * from "./hooks/mutations/useSendTransactionX.js";
+export * from "./hooks/mutations/useERC20ApproveX.js";
 
 /* ------------- */
 /*     Queries   */
 /* ------------- */
-export * from "./hooks/useTokenX.js";
-export * from "./hooks/useFetchAssetAllowanceX.js";
+export * from "./hooks/queries/useTokenX.js";
+export * from "./hooks/queries/useFetchAssetAllowanceX.js";
 
 /* ------------- */
 /*      Fetch    */
 /* ------------- */
 export * from "./fetch-functions/fetchTokenX.js";
+export * from "./fetch-functions/erc20/fetchAllowanceX.js";
+export * from "./fetch-functions/erc20/fetchBalanceOfX.js";
+export * from "./fetch-functions/erc20/fetchTotalSupplyX.js";
+export * from "./fetch-functions/erc20/fetchERC20DataX.js";
+export * from "./fetch-functions/erc4626/fetchERC4626AssetX.js";
+export * from "./fetch-functions/erc4626/fetchERC4626TotalAssetsX.js";
+export * from "./fetch-functions/erc4626/fetchERC4626MaxDepositX.js";
+export * from "./fetch-functions/erc4626/fetchERC4626MaxMintX.js";
+export * from "./fetch-functions/erc4626/fetchERC4626MaxRedeemX.js";
+export * from "./fetch-functions/erc4626/fetchERC4626MaxWithdrawX.js";
+export * from "./fetch-functions/erc4626/fetchERC4626DataX.js";
 
 /* ------------- */
 /*       Utils   */

package/src/query-config/index.ts

@@ -1,8 +1,18 @@
 export const queryConfig = {
-  metadataQueryConfig: {
-    staleTime: Infinity,
+  metaDataQuery: {
+    staleTime: Number.POSITIVE_INFINITY,
+    meta: { category: "metadata" } as const,
   },
-  sensitiveDataQueryConfig: {
+  lowSensitiveQuery: {
     staleTime: 60_000,
+    meta: { category: "lowSensitive" } as const,
+  },
+  semiSensitiveQuery: {
+    staleTime: 180_000,
+    meta: { category: "semiSensitive" } as const,
+  },
+  expensiveQuery: {
+    staleTime: 60 * 60 * 1000,
+    meta: { category: "expensive" } as const,
   },
 };

package/src/utils/ensureClientAndConfig.ts

@@ -0,0 +1,18 @@
+import { QueryClient } from "@tanstack/react-query";
+import { Config } from "wagmi";
+import { getDefaults } from "../config/defaults.js";
+
+export function ensureClientAndConfig(
+  queryClient?: QueryClient,
+  wagmiConfig?: Config
+): { queryClient: QueryClient; wagmiConfig: Config } {
+  if (!queryClient || !wagmiConfig) {
+    ({ queryClient, wagmiConfig } = getDefaults());
+  }
+  if (!queryClient || !wagmiConfig) {
+    throw new Error(
+      "Could not find queryClient or wagmiConfig; pass them in or setDefaults() first"
+    );
+  }
+  return { queryClient, wagmiConfig };
+}

package/dist/fetch-functions/fetchAllowanceX.d.ts

@@ -1,2 +0,0 @@
-import { Address } from "viem";
-export declare const fetchAllowance: (asset: Address, spender: Address, userAddress: Address, config: any) => Promise<bigint>;

package/src/fetch-functions/fetchAllowanceX.ts

@@ -1,22 +0,0 @@
-import { Address, erc20Abi } from "viem";
-import { readContract } from "viem/actions";
-
-export const fetchAllowance = async (
-  asset: Address,
-  spender: Address,
-  userAddress: Address,
-  config: any
-) => {
-  const allowance = await readContract(config, {
-    address: asset,
-    abi: erc20Abi,
-    functionName: "allowance",
-    args: [userAddress, spender],
-  });
-
-  if (allowance == null) {
-    throw new Error("Failed to fetch token data or allowance");
-  }
-
-  return allowance;
-};