wagmi-extended 2.1.1 → 2.2.1

package/dist/fetch-functions/common/fetchDeploymentBlockX.d.ts

@@ -0,0 +1,54 @@
+import type { Address } from "viem";
+import type { QueryClient } from "@tanstack/react-query";
+import type { Config } from "wagmi";
+/** Reusable React Query key helper for deployment block lookups. */
+export declare const deploymentBlockKey: (chainId: number | undefined, address: Address | undefined, floor: bigint) => readonly ["deploymentBlock", number | undefined, string | undefined, bigint];
+/**
+ * Builds React Query options for caching the deployment block "forever".
+ *
+ * Use with `queryClient.fetchQuery(...)`.
+ *
+ * @param address     - Contract address to probe.
+ * @param floor       - Optional lower bound (inclusive) to speed up search. Defaults to `0n`.
+ * @param wagmiConfig - Wagmi `Config` (optional; resolved via `ensureClientAndConfig` if omitted).
+ *
+ * @returns A fully-configured query options object (key + fn + metadata).
+ */
+export declare function getDeploymentBlockQueryOptionsX(address: Address, floor?: bigint, wagmiConfig?: Config): {
+    readonly staleTime: number;
+    readonly meta: {
+        readonly queryType: import("../../query-config/index.js").QueryType.MetaDataQuery;
+    };
+    readonly queryKey: readonly ["deploymentBlock", number | undefined, string | undefined, bigint];
+    readonly queryFn: () => Promise<bigint>;
+};
+/**
+ * Fetches (and caches) the first block where contract bytecode exists at `address`.
+ *
+ * Uses your shared `QueryClient` and Wagmi `Config` like other `fetch*X` helpers.
+ * Internally, this runs an **exponential descent** to find a safe lower bound,
+ * followed by an **optimal binary search** to pinpoint the exact deployment block.
+ *
+ * #### Caching
+ * - Query key: `["deploymentBlock", chainId, address.toLowerCase(), floor]`
+ * - For long-lived results, we apply `queryConfig.metaDataQuery` (tweak as needed).
+ *
+ * #### Performance
+ * - **O(log N)** `eth_getCode` calls, where `N` is the gap between the latest
+ *   block and the deployment block—optimal among comparison-based strategies.
+ *
+ * @example
+ * ```ts
+ * const block = await fetchDeploymentBlockX("0xContract...", 0n, queryClient, wagmiConfig);
+ * ```
+ *
+ * @param address - Contract address to probe.
+ * @param floor - Optional lower bound (inclusive) to speed up search. Defaults to `0n`.
+ * @param queryClient - Optional TanStack `QueryClient`. If omitted, resolved by `ensureClientAndConfig`.
+ * @param wagmiConfig - Optional Wagmi `Config`. If omitted, resolved by `ensureClientAndConfig`.
+ *
+ * @returns The earliest block number (bigint) where bytecode exists.
+ *
+ * @throws If the public client is missing or if no code is present at the latest block.
+ */
+export declare function fetchDeploymentBlockX(address: Address, floor?: bigint, queryClient?: QueryClient, wagmiConfig?: Config): Promise<bigint>;

package/dist/hooks/queries/useERC20Data.d.ts

@@ -1,4 +1,5 @@
 import { Address } from "viem";
+export declare const HookFetchERC20DataQK: (address?: Address, userAddress?: Address, spender?: Address) => readonly ["HookFetchERC20Data", `0x${string}` | undefined, `0x${string}` | undefined, `0x${string}` | undefined];
 /**
  * Hook to fetch ERC-20 summary data for a given token and optional user/spender context.
  *

package/dist/hooks/queries/useFetchAssetAllowanceX.d.ts

@@ -1,4 +1,5 @@
 import { Address } from "viem";
+export declare const HookFetchAssetAllowanceQK: (asset?: Address, spender?: Address, userAddress?: Address) => readonly ["HookFetchAllowance", `0x${string}` | undefined, `0x${string}` | undefined, `0x${string}` | undefined];
 /**
  * Custom hook for fetching asset allowance.
  *

package/dist/hooks/queries/useFetchERC4626DataX.d.ts

@@ -1,4 +1,5 @@
 import { Address } from "viem";
+export declare const HookFetchERC4626DataQK: (vault?: Address, userAddress?: Address, spender?: Address) => readonly ["HookFetchERC4626Data", `0x${string}` | undefined, `0x${string}` | undefined, `0x${string}` | undefined];
 /**
  * Hook to fetch ERC-4626 vault summary data for a given vault and user/spender.
  *

package/dist/index.cjs.js

@@ -87,16 +87,18 @@ const getErrorMapping = () => currentErrorMapping;
  * console.log(message); // Outputs a custom error message or a default error message.
  */
 const getParsedErrorX = (error) => {
-    var _a, _b, _c, _d;
     const defaultMessage = "An unknown error occurred. Please contact support.";
     let message = defaultMessage;
     let errorKey = "";
-    const revertedError = (error === null || error === void 0 ? void 0 : error.walk)
+    const revertedError = error?.walk
         ? error.walk((err) => err instanceof viem.ContractFunctionRevertedError)
         : null;
     if (revertedError instanceof viem.ContractFunctionRevertedError) {
         errorKey =
-            (_d = (_c = (_b = (_a = revertedError.data) === null || _a === void 0 ? void 0 : _a.errorName) !== null && _b !== void 0 ? _b : revertedError.signature) !== null && _c !== void 0 ? _c : revertedError.reason) !== null && _d !== void 0 ? _d : "";
+            revertedError.data?.errorName ??
+                revertedError.signature ??
+                revertedError.reason ??
+                "";
         if (currentErrorMapping[errorKey])
             return currentErrorMapping[errorKey];
     }
@@ -120,11 +122,10 @@ function useHandleTransactionMutationX({ settings, }) {
         setErrorMessage(undefined);
     };
     const onSettled = async (txHash, error, args) => {
-        var _a, _b, _c;
         try {
             if (error)
                 throw error;
-            if (!(settings === null || settings === void 0 ? void 0 : settings.disableWaitingForReceipt)) {
+            if (!settings?.disableWaitingForReceipt) {
                 // 1. wait for transaction receipt
                 const txReceipt = await actions.waitForTransactionReceipt(wagmiConfig, {
                     hash: txHash,
@@ -148,10 +149,10 @@ function useHandleTransactionMutationX({ settings, }) {
                 await invalidateMany(queriesToInvalidate);
             }
             // 4. call onSuccess callback
-            (_a = settings === null || settings === void 0 ? void 0 : settings.onSuccess) === null || _a === void 0 ? void 0 : _a.call(settings, txHash);
-            if (settings === null || settings === void 0 ? void 0 : settings.onSuccessAsync)
+            settings?.onSuccess?.(txHash);
+            if (settings?.onSuccessAsync)
                 await settings.onSuccessAsync(txHash);
-            if (!(settings === null || settings === void 0 ? void 0 : settings.disableLogging)) {
+            if (!settings?.disableLogging) {
                 // 5. log result
                 // eslint-disable-next-line no-console
                 console.info("Operation successful:", txHash); // todo: add logging service
@@ -161,7 +162,7 @@ function useHandleTransactionMutationX({ settings, }) {
         }
         catch (error) {
             const parsedError = getParsedErrorX(error);
-            if (!(settings === null || settings === void 0 ? void 0 : settings.disableLogging)) {
+            if (!settings?.disableLogging) {
                 // 1. log error
                 console.error(`ContractWriteExtended Operation failed with error(parsed): ${parsedError}`, { error }, { args });
                 console.error({ error });
@@ -169,15 +170,15 @@ function useHandleTransactionMutationX({ settings, }) {
             // 2. set error message
             setErrorMessage(parsedError);
             // 3. call callback
-            (_b = settings === null || settings === void 0 ? void 0 : settings.onError) === null || _b === void 0 ? void 0 : _b.call(settings, error);
-            if (settings === null || settings === void 0 ? void 0 : settings.onErrorAsync)
+            settings?.onError?.(error);
+            if (settings?.onErrorAsync)
                 await settings.onErrorAsync(error);
         }
         finally {
             setIsPending(false);
             // 1. call callback
-            (_c = settings === null || settings === void 0 ? void 0 : settings.onSettled) === null || _c === void 0 ? void 0 : _c.call(settings);
-            if (settings === null || settings === void 0 ? void 0 : settings.onSettledAsync)
+            settings?.onSettled?.();
+            if (settings?.onSettledAsync)
                 await settings.onSettledAsync();
         }
         return undefined;
@@ -227,10 +228,10 @@ function useContractWriteX(settings) {
             // 1) optional dry-run
             const { chain, ...others } = params;
             if (!disableSimulation) {
-                await (publicClient === null || publicClient === void 0 ? void 0 : publicClient.simulateContract({
+                await publicClient?.simulateContract({
                     ...others,
                     ...(chain != null ? { chain } : {}),
-                }));
+                });
             }
             wagmiWrite.writeContract(params);
         }
@@ -292,21 +293,20 @@ function useSendTransactionX(settings) {
      * @returns {Promise<void>}
      */
     async function sendTransactionX(params, simulationParams) {
-        var _a;
         onMutate();
         try {
             if (params.to && simulationParams) {
                 //simulate!
-                await (publicClient === null || publicClient === void 0 ? void 0 : publicClient.simulateContract({
+                await publicClient?.simulateContract({
                     address: params.to,
                     abi: simulationParams.abi,
                     functionName: simulationParams.functionName,
-                    args: (_a = simulationParams.args) !== null && _a !== void 0 ? _a : [],
+                    args: simulationParams.args ?? [],
                     account: params.account,
                     ...(simulationParams.chain != null
                         ? { chain: simulationParams.chain }
                         : {}),
-                }));
+                });
             }
             // actual send!
             await sendTransaction(params);
@@ -324,19 +324,36 @@ function useSendTransactionX(settings) {
     };
 }
 
+exports.QueryType = void 0;
+(function (QueryType) {
+    QueryType["MetaDataQuery"] = "metaDataQuery";
+    QueryType["SemiSensitiveQuery"] = "semiSensitiveQuery";
+    QueryType["LowSensitiveQuery"] = "lowSensitiveQuery";
+    QueryType["ExpensiveQuery"] = "expensiveQuery";
+    QueryType["PriceQuery"] = "priceQuery";
+})(exports.QueryType || (exports.QueryType = {}));
 const queryConfig = {
     metaDataQuery: {
         staleTime: Number.POSITIVE_INFINITY,
-        meta: { category: "metadata" },
+        meta: { queryType: exports.QueryType.MetaDataQuery },
     },
     lowSensitiveQuery: {
         staleTime: 60000,
-        meta: { category: "lowSensitive" },
+        meta: { queryType: exports.QueryType.SemiSensitiveQuery },
     },
     semiSensitiveQuery: {
         staleTime: 180000,
-        meta: { category: "semiSensitive" },
-    }};
+        meta: { queryType: exports.QueryType.LowSensitiveQuery },
+    },
+    priceQuery: {
+        staleTime: 30 * 60 * 1000,
+        meta: { queryType: exports.QueryType.PriceQuery },
+    },
+    expensiveQuery: {
+        staleTime: 60 * 60 * 1000,
+        meta: { queryType: exports.QueryType.ExpensiveQuery },
+    },
+};
 
 // You can adjust the type for wagmiConfig to match your needs.
 let defaultQueryClient = null;
@@ -838,11 +855,150 @@ async function fetchERC4626DataX(vault, user, spender, queryClient, wagmiConfig)
     };
 }
 
+/** Reusable React Query key helper for deployment block lookups. */
+const deploymentBlockKey = (chainId, address, floor) => ["deploymentBlock", chainId, address?.toLowerCase(), floor];
+/**
+ * Internal helper: checks if there is bytecode at `address` on `blockNumber`.
+ */
+async function hasCodeAtX(address, blockNumber, wagmiConfig) {
+    const client = actions.getPublicClient(wagmiConfig);
+    if (!client)
+        throw new Error("Public client is missing");
+    const code = await client.getCode({ address, blockNumber });
+    return !!code && code !== "0x";
+}
+/**
+ * Internal helper: finds the earliest block where code exists at `address`,
+ * using exponential descent to find a lower bound and then binary search.
+ *
+ * @param address - Contract address to probe.
+ * @param floor   - Optional lower bound (inclusive) to start from. If you know
+ *                  the contract cannot exist below this block, pass it to
+ *                  speed up the search. Defaults to `0n`.
+ * @returns The first block number (bigint) where code is present.
+ * @throws  If no code exists at the latest block (i.e., contract not deployed).
+ */
+async function findDeploymentBlockRpcX(address, wagmiConfig, floor = 0n) {
+    const client = actions.getPublicClient(wagmiConfig);
+    if (!client)
+        throw new Error("Public client is missing");
+    const latest = await client.getBlockNumber();
+    if (!(await hasCodeAtX(address, latest, wagmiConfig))) {
+        const chainId = client.chain?.id ?? 0;
+        throw new Error(`No code for ${address} at latest block ${latest} on chain ${chainId}.`);
+    }
+    // If caller-supplied floor already has code, it *is* the first code block.
+    if (floor > 0n && (await hasCodeAtX(address, floor, wagmiConfig)))
+        return floor;
+    // Exponential descent to find a "no code" lower bound fast.
+    let lo = floor; // known (or assumed) no code
+    let hi = latest; // known has code
+    let step = 1n;
+    while (hi - step > lo) {
+        const probe = hi - step;
+        if (await hasCodeAtX(address, probe, wagmiConfig)) {
+            hi = probe; // still has code -> move upper bound down
+            step <<= 1n; // double the step
+        }
+        else {
+            lo = probe; // found a no-code block
+            break;
+        }
+    }
+    // Binary search to the first block with code in (lo, hi]
+    while (lo + 1n < hi) {
+        const mid = lo + (hi - lo) / 2n;
+        if (await hasCodeAtX(address, mid, wagmiConfig))
+            hi = mid;
+        else
+            lo = mid;
+    }
+    return hi;
+}
+/**
+ * Builds React Query options for caching the deployment block "forever".
+ *
+ * Use with `queryClient.fetchQuery(...)`.
+ *
+ * @param address     - Contract address to probe.
+ * @param floor       - Optional lower bound (inclusive) to speed up search. Defaults to `0n`.
+ * @param wagmiConfig - Wagmi `Config` (optional; resolved via `ensureClientAndConfig` if omitted).
+ *
+ * @returns A fully-configured query options object (key + fn + metadata).
+ */
+function getDeploymentBlockQueryOptionsX(address, floor = 0n, wagmiConfig) {
+    if (!address)
+        throw new Error("Address is required");
+    // Resolve config (caller may pass undefined; we'll normalize later in fetcher too)
+    // We only need chainId for the key; if wagmiConfig is missing here,
+    // we allow it since fetcher re-resolves. But key stability benefits from chainId.
+    const client = wagmiConfig ? actions.getPublicClient(wagmiConfig) : undefined;
+    const chainId = client?.chain?.id;
+    return {
+        queryKey: deploymentBlockKey(chainId, address, floor),
+        queryFn: async () => {
+            if (!wagmiConfig)
+                throw new Error("wagmiConfig is required at execution time");
+            return findDeploymentBlockRpcX(address, wagmiConfig, floor);
+        },
+        ...queryConfig.metaDataQuery,
+    };
+}
+/**
+ * Fetches (and caches) the first block where contract bytecode exists at `address`.
+ *
+ * Uses your shared `QueryClient` and Wagmi `Config` like other `fetch*X` helpers.
+ * Internally, this runs an **exponential descent** to find a safe lower bound,
+ * followed by an **optimal binary search** to pinpoint the exact deployment block.
+ *
+ * #### Caching
+ * - Query key: `["deploymentBlock", chainId, address.toLowerCase(), floor]`
+ * - For long-lived results, we apply `queryConfig.metaDataQuery` (tweak as needed).
+ *
+ * #### Performance
+ * - **O(log N)** `eth_getCode` calls, where `N` is the gap between the latest
+ *   block and the deployment block—optimal among comparison-based strategies.
+ *
+ * @example
+ * ```ts
+ * const block = await fetchDeploymentBlockX("0xContract...", 0n, queryClient, wagmiConfig);
+ * ```
+ *
+ * @param address - Contract address to probe.
+ * @param floor - Optional lower bound (inclusive) to speed up search. Defaults to `0n`.
+ * @param queryClient - Optional TanStack `QueryClient`. If omitted, resolved by `ensureClientAndConfig`.
+ * @param wagmiConfig - Optional Wagmi `Config`. If omitted, resolved by `ensureClientAndConfig`.
+ *
+ * @returns The earliest block number (bigint) where bytecode exists.
+ *
+ * @throws If the public client is missing or if no code is present at the latest block.
+ */
+async function fetchDeploymentBlockX(address, floor = 0n, queryClient, wagmiConfig) {
+    if (!address)
+        throw new Error("Address is required");
+    ({ queryClient, wagmiConfig } = ensureClientAndConfig(queryClient, wagmiConfig));
+    // Resolve chainId for a stable cache key
+    const client = actions.getPublicClient(wagmiConfig);
+    const chainId = client?.chain?.id;
+    if (!chainId)
+        throw new Error("Client chain ID is missing");
+    return queryClient.fetchQuery({
+        ...getDeploymentBlockQueryOptionsX(address, floor, wagmiConfig),
+        // Ensure the final key includes a concrete chainId
+        queryKey: deploymentBlockKey(chainId, address, floor),
+        // Reinstate metadata (in case your ensure/util merges)
+        ...queryConfig.metaDataQuery,
+    });
+}
+
 exports.EthTokenData = EthTokenData;
+exports.HookFetchAssetAllowanceQK = HookFetchAssetAllowanceQK;
 exports.HookFetchTokenQK = HookFetchTokenQK;
+exports.deploymentBlockKey = deploymentBlockKey;
 exports.fetchAllowanceX = fetchAllowanceX;
 exports.fetchBalanceOfX = fetchBalanceOfX;
 exports.fetchDecimalsX = fetchDecimalsX;
+exports.fetchDeploymentBlockX = fetchDeploymentBlockX;
 exports.fetchERC20DataX = fetchERC20DataX;
 exports.fetchERC4626AssetX = fetchERC4626AssetX;
 exports.fetchERC4626DataX = fetchERC4626DataX;
@@ -856,8 +1012,10 @@ exports.fetchSymbolX = fetchSymbolX;
 exports.fetchTokenX = fetchTokenX;
 exports.fetchTotalSupplyX = fetchTotalSupplyX;
 exports.getDefaults = getDefaults;
+exports.getDeploymentBlockQueryOptionsX = getDeploymentBlockQueryOptionsX;
 exports.getErrorMapping = getErrorMapping;
 exports.getParsedErrorX = getParsedErrorX;
+exports.queryConfig = queryConfig;
 exports.resetErrorMapping = resetErrorMapping;
 exports.setDefaults = setDefaults;
 exports.setErrorMapping = setErrorMapping;