@dappql/react 1.0.1

package/dist/react/src/Context.d.ts

@@ -0,0 +1,35 @@
+import { MutationCallbacks, AddressResolverFunction } from '../../shared/types.js';
+import { BlockSubscriptionManager } from './blocksHandler.js';
+/**
+ * Context for DappQL
+ * @param children - React children
+ * @returns DappQL context
+ */
+export declare const DappQLContext: import("react").Context<{
+    blocksRefetchInterval: number;
+    defaultBatchSize: number;
+    addressResolver?: AddressResolverFunction;
+    onBlockChange: BlockSubscriptionManager["subscribe"];
+    watchBlocks?: boolean;
+    simulateMutations?: boolean;
+} & MutationCallbacks>;
+/**
+ * Hook to access DappQL context
+ * @returns Context containing current block number, address resolver, and mutation callbacks
+ */
+export declare function useDappQL(): {
+    blocksRefetchInterval: number;
+    defaultBatchSize: number;
+    addressResolver?: AddressResolverFunction;
+    onBlockChange: BlockSubscriptionManager["subscribe"];
+    watchBlocks?: boolean;
+    simulateMutations?: boolean;
+} & MutationCallbacks;
+/**
+ * Hook to refetch on block change
+ * @param refetchFn - Function to refetch
+ * @param watchBlocks - Whether to watch blocks
+ * @param blocksRefetchInterval - Blocks refetch interval
+ */
+export declare function useRefetchOnBlockChange(refetchFn: () => any, watchBlocks?: boolean, blocksRefetchInterval?: number): void;
+//# sourceMappingURL=Context.d.ts.map

package/dist/react/src/Context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Context.d.ts","sourceRoot":"","sources":["../../../src/Context.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAA;AAClF,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAA;AAE7D;;;;GAIG;AACH,eAAO,MAAM,aAAa;2BAEC,MAAM;sBACX,MAAM;sBACN,uBAAuB;mBAC1B,wBAAwB,CAAC,WAAW,CAAC;kBACtC,OAAO;wBACD,OAAO;sBAE0D,CAAA;AAEzF;;;GAGG;AACH,wBAAgB,SAAS;2BAbE,MAAM;sBACX,MAAM;sBACN,uBAAuB;mBAC1B,wBAAwB,CAAC,WAAW,CAAC;kBACtC,OAAO;wBACD,OAAO;sBAU9B;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,EAAE,WAAW,UAAQ,EAAE,qBAAqB,SAAI,QAmB3G"}

package/dist/react/src/Context.js

@@ -0,0 +1,42 @@
+import { useContext, useEffect } from 'react';
+import { createContext } from 'react';
+/**
+ * Context for DappQL
+ * @param children - React children
+ * @returns DappQL context
+ */
+export const DappQLContext = createContext({ onBlockChange: () => () => false, blocksRefetchInterval: 1, defaultBatchSize: 1024 });
+/**
+ * Hook to access DappQL context
+ * @returns Context containing current block number, address resolver, and mutation callbacks
+ */
+export function useDappQL() {
+    return useContext(DappQLContext);
+}
+/**
+ * Hook to refetch on block change
+ * @param refetchFn - Function to refetch
+ * @param watchBlocks - Whether to watch blocks
+ * @param blocksRefetchInterval - Blocks refetch interval
+ */
+export function useRefetchOnBlockChange(refetchFn, watchBlocks = false, blocksRefetchInterval = 1) {
+    const { onBlockChange } = useDappQL();
+    useEffect(() => {
+        if (!watchBlocks)
+            return;
+        let lastBlockFetched = 0n;
+        const unsubscribe = onBlockChange((blockNumber) => {
+            if (lastBlockFetched === 0n && blockNumber > 0n) {
+                lastBlockFetched = blockNumber - 1n;
+            }
+            const shouldRefetch = blockNumber > 0n && blockNumber >= lastBlockFetched + BigInt(blocksRefetchInterval);
+            if (shouldRefetch) {
+                refetchFn();
+                lastBlockFetched = blockNumber;
+            }
+        });
+        return () => {
+            unsubscribe();
+        };
+    }, [watchBlocks, blocksRefetchInterval]);
+}

package/dist/react/src/ContextQuery.d.ts

@@ -0,0 +1,66 @@
+import { RequestCollection, ReadContractsResult, Request, GetItemCallFunction } from '../../shared/types.js';
+import { IteratorQueryResult } from './queryHooks.js';
+/**
+ * Hook to execute contract queries through the global query manager
+ *
+ * All queries across your application using this hook will be automatically
+ * aggregated into a single multicall query. This optimization significantly
+ * reduces RPC calls by batching multiple contract reads together.
+ *
+ * For example, if you have:
+ * - Component A reading balanceOf(user1)
+ * - Component B reading balanceOf(user2)
+ * - Component C reading totalSupply()
+ *
+ * These will be combined into a single multicall instead of 3 separate RPC calls.
+ *
+ * @param requests - Collection of contract requests to execute
+ * @returns Object containing:
+ *  - isLoading: Whether the query is in progress
+ *  - isError: Whether an error occurred
+ *  - data: The query results
+ *  - error: Any error that occurred
+ *
+ * @example
+ * ```tsx
+ * const { isLoading, isError, data, error } = useContextQuery({
+ *   balanceOf: { deployAddress: '0x...', method: 'balanceOf', args: [user1] },
+ *   balanceOf2: { deployAddress: '0x...', method: 'balanceOf', args: [user2] },
+ * })
+ * ```
+ */
+export declare function useContextQuery<T extends RequestCollection>(requests: T): Omit<ReadContractsResult, 'data'> & {
+    data: {
+        [K in keyof T]: NonNullable<T[K]['defaultValue']>;
+    };
+};
+/**
+ * React hook for querying a single contract request through the global query manager
+ * @param request - The contract request to query
+ * @returns Object containing:
+ *  - isLoading: Whether the query is in progress
+ *  - isError: Whether an error occurred
+ *  - data: The query result
+ *  - error: Any error that occurred
+ *
+ * @example
+ * ```tsx
+ * const { isLoading, isError, data, error } = useSingleContextQuery({ deployAddress: '0x...', method: 'balanceOf', args: [user1] })
+ * ```
+ */
+export declare function useSingleContextQuery<T extends Request>(request: T): Omit<ReturnType<typeof useContextQuery>, 'data'> & {
+    data: NonNullable<T['defaultValue']>;
+};
+/**
+ * React hook for querying iterable data structures (like arrays) from smart contracts through the global query manager
+ * @param total Total number of items to query
+ * @param getItem Function that generates the query for a specific index
+ * @param options Query configuration options including optional starting index
+ * @returns Object containing array of query results and status
+ * @example
+ * ```ts
+ * const { data, isLoading } = useIteratorQuery(10, (i) => contracts.myContract.getValue(i))
+ * ```
+ */
+export declare function useIteratorContextQuery<T>(total: bigint, getItem: GetItemCallFunction<T>, firstIndex?: bigint): IteratorQueryResult<T>;
+//# sourceMappingURL=ContextQuery.d.ts.map

package/dist/react/src/ContextQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextQuery.d.ts","sourceRoot":"","sources":["../../../src/ContextQuery.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAC5G,OAAO,EACL,mBAAmB,EAMpB,MAAM,iBAAiB,CAAA;AAGxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,iBAAiB,EACzD,QAAQ,EAAE,CAAC,GACV,IAAI,CAAC,mBAAmB,EAAE,MAAM,CAAC,GAAG;IACrC,IAAI,EAAE;SAAG,CAAC,IAAI,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC;KAAE,CAAA;CAC5D,CA2BA;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,OAAO,EACrD,OAAO,EAAE,CAAC,GACT,IAAI,CAAC,UAAU,CAAC,OAAO,eAAe,CAAC,EAAE,MAAM,CAAC,GAAG;IAAE,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAA;CAAE,CAM7F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAC/B,UAAU,GAAE,MAAW,GACtB,mBAAmB,CAAC,CAAC,CAAC,CAIxB"}

package/dist/react/src/ContextQuery.js

@@ -0,0 +1,94 @@
+import { useEffect, useMemo, useState } from 'react';
+import { useCallKeys, useDefaultData, useIteratorQueryData, useRequestString, useResultData, } from './queryHooks.js';
+import { useQueryContextProvider } from './ContextQueryManager.js';
+import { buildIteratorQuery } from './buildIteratorQuery.js';
+/**
+ * Hook to execute contract queries through the global query manager
+ *
+ * All queries across your application using this hook will be automatically
+ * aggregated into a single multicall query. This optimization significantly
+ * reduces RPC calls by batching multiple contract reads together.
+ *
+ * For example, if you have:
+ * - Component A reading balanceOf(user1)
+ * - Component B reading balanceOf(user2)
+ * - Component C reading totalSupply()
+ *
+ * These will be combined into a single multicall instead of 3 separate RPC calls.
+ *
+ * @param requests - Collection of contract requests to execute
+ * @returns Object containing:
+ *  - isLoading: Whether the query is in progress
+ *  - isError: Whether an error occurred
+ *  - data: The query results
+ *  - error: Any error that occurred
+ *
+ * @example
+ * ```tsx
+ * const { isLoading, isError, data, error } = useContextQuery({
+ *   balanceOf: { deployAddress: '0x...', method: 'balanceOf', args: [user1] },
+ *   balanceOf2: { deployAddress: '0x...', method: 'balanceOf', args: [user2] },
+ * })
+ * ```
+ */
+export function useContextQuery(requests) {
+    const requestString = useRequestString(requests);
+    const queryManager = useQueryContextProvider();
+    const [result, setResult] = useState({
+        isLoading: true,
+        isError: false,
+        data: undefined,
+        error: null,
+    });
+    useEffect(() => {
+        const queryId = queryManager.addQuery({
+            collection: requests,
+            callBack: setResult,
+        });
+        return () => {
+            queryManager.removeQuery(queryId);
+        };
+    }, [requestString]);
+    const callKeys = useCallKeys(requests, requestString);
+    const defaultData = useDefaultData(requests, callKeys);
+    const data = useResultData(requests, callKeys, result, defaultData);
+    return useMemo(() => {
+        return { isLoading: result.isLoading, isError: result.isError, data, error: result.error };
+    }, [result.error, result.isLoading, data]);
+}
+/**
+ * React hook for querying a single contract request through the global query manager
+ * @param request - The contract request to query
+ * @returns Object containing:
+ *  - isLoading: Whether the query is in progress
+ *  - isError: Whether an error occurred
+ *  - data: The query result
+ *  - error: Any error that occurred
+ *
+ * @example
+ * ```tsx
+ * const { isLoading, isError, data, error } = useSingleContextQuery({ deployAddress: '0x...', method: 'balanceOf', args: [user1] })
+ * ```
+ */
+export function useSingleContextQuery(request) {
+    const result = useContextQuery({ value: request });
+    return useMemo(() => {
+        return { ...result, data: result.data.value };
+    }, [result]);
+}
+/**
+ * React hook for querying iterable data structures (like arrays) from smart contracts through the global query manager
+ * @param total Total number of items to query
+ * @param getItem Function that generates the query for a specific index
+ * @param options Query configuration options including optional starting index
+ * @returns Object containing array of query results and status
+ * @example
+ * ```ts
+ * const { data, isLoading } = useIteratorQuery(10, (i) => contracts.myContract.getValue(i))
+ * ```
+ */
+export function useIteratorContextQuery(total, getItem, firstIndex = 0n) {
+    const query = useMemo(() => buildIteratorQuery(total, firstIndex, getItem), [total, firstIndex, getItem]);
+    const result = useContextQuery(query);
+    return useIteratorQueryData(total, result);
+}

package/dist/react/src/ContextQueryManager.d.ts

@@ -0,0 +1,71 @@
+/**
+ * ContextQuery Module
+ *
+ * Manages the aggregation and distribution of multiple contract queries into a single global query.
+ * This optimization reduces the number of RPC calls by batching multiple contract reads together.
+ *
+ * Key features:
+ * - Query Aggregation: Combines multiple individual queries into a single batch
+ * - Version Control: Manages race conditions in async responses
+ * - Result Distribution: Routes results back to individual query callbacks
+ * - Address Resolution: Flexible contract address resolution
+ */
+import { Abi, Address } from 'viem';
+import { RequestCollection, AddressResolverFunction, ReadContractsResult, QueryContextProps } from '../../shared/types.js';
+type Query = {
+    collection: RequestCollection;
+    callBack: (result: ReadContractsResult) => void;
+};
+/**
+ * Represents a single contract call within the global query
+ */
+type Call = {
+    queryId: number;
+    abi: Abi;
+    functionName: string;
+    args: readonly any[];
+    address: Address;
+};
+/**
+ * Represents the state of all aggregated queries
+ */
+type ContextQuery = {
+    version: number;
+    count: Record<number, number>;
+    calls: Call[];
+};
+/**
+ * Manages the aggregation and distribution of contract queries
+ */
+export declare class ContextQueryManager {
+    private queries;
+    private activeQueries;
+    private currGlobal;
+    private version;
+    private queryId;
+    private addressResolver?;
+    private onUpdate;
+    /**
+     * Creates a new QueryManager instance
+     * @param onUpdate - Callback triggered when the global query changes
+     * @param addressResolver - Optional function to resolve contract addresses
+     */
+    constructor(onUpdate: (ContextQuery: ContextQuery) => any, addressResolver?: AddressResolverFunction);
+    getContextQuery(): ContextQuery;
+    getVersion(): number;
+    addQuery(query: Query): number;
+    removeQuery(id: number): void;
+    private aggregateQueries;
+    setAddressResolver(resolver?: AddressResolverFunction): void;
+    onResult(result: ReadContractsResult, version: number): void;
+}
+/**
+ * React Context provider for scoped query management
+ * Handles the lifecycle of queries and their results
+ */
+export declare function ContextQueryProvider({ children, defaultBatchSize, watchBlocks, blocksRefetchInterval, }: {
+    children: any;
+} & QueryContextProps): import("react/jsx-runtime").JSX.Element;
+export declare function useQueryContextProvider(): ContextQueryManager;
+export {};
+//# sourceMappingURL=ContextQueryManager.d.ts.map

package/dist/react/src/ContextQueryManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextQueryManager.d.ts","sourceRoot":"","sources":["../../../src/ContextQueryManager.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,GAAG,EAAa,OAAO,EAAE,MAAM,MAAM,CAAA;AAE9C,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EAEvB,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,uBAAuB,CAAA;AAG9B,KAAK,KAAK,GAAG;IAAE,UAAU,EAAE,iBAAiB,CAAC;IAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,IAAI,CAAA;CAAE,CAAA;AAC/F;;GAEG;AACH,KAAK,IAAI,GAAG;IACV,OAAO,EAAE,MAAM,CAAA;IACf,GAAG,EAAE,GAAG,CAAA;IACR,YAAY,EAAE,MAAM,CAAA;IACpB,IAAI,EAAE,SAAS,GAAG,EAAE,CAAA;IACpB,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED;;GAEG;AACH,KAAK,YAAY,GAAG;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC7B,KAAK,EAAE,IAAI,EAAE,CAAA;CACd,CAAA;AAED;;GAEG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,OAAO,CAA4B;IAC3C,OAAO,CAAC,aAAa,CAAyB;IAC9C,OAAO,CAAC,UAAU,CAAqD;IACvE,OAAO,CAAC,OAAO,CAAI;IACnB,OAAO,CAAC,OAAO,CAAY;IAC3B,OAAO,CAAC,eAAe,CAAC,CAAyB;IACjD,OAAO,CAAC,QAAQ,CAAsC;IAEtD;;;;OAIG;gBACS,QAAQ,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,GAAG,EAAE,eAAe,CAAC,EAAE,uBAAuB;IAKpG,eAAe,IAAI,YAAY;IAI/B,UAAU,IAAI,MAAM;IAIpB,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;IAQ9B,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAM7B,OAAO,CAAC,gBAAgB;IAsCxB,kBAAkB,CAAC,QAAQ,CAAC,EAAE,uBAAuB;IAKrD,QAAQ,CAAC,MAAM,EAAE,mBAAmB,EAAE,OAAO,EAAE,MAAM;CAuBtD;AAID;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,QAAQ,EACR,gBAAgB,EAChB,WAAW,EACX,qBAAqB,GACtB,EAAE;IAAE,QAAQ,EAAE,GAAG,CAAA;CAAE,GAAG,iBAAiB,2CAwBvC;AAED,wBAAgB,uBAAuB,wBAEtC"}

package/dist/react/src/ContextQueryManager.js

@@ -0,0 +1,135 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * ContextQuery Module
+ *
+ * Manages the aggregation and distribution of multiple contract queries into a single global query.
+ * This optimization reduces the number of RPC calls by batching multiple contract reads together.
+ *
+ * Key features:
+ * - Query Aggregation: Combines multiple individual queries into a single batch
+ * - Version Control: Manages race conditions in async responses
+ * - Result Distribution: Routes results back to individual query callbacks
+ * - Address Resolution: Flexible contract address resolution
+ */
+import { createContext, useContext, useEffect, useMemo, useState } from 'react';
+import { stringify } from 'viem';
+import { useReadContracts } from 'wagmi';
+import { useDappQL, useRefetchOnBlockChange } from './Context.js';
+/**
+ * Manages the aggregation and distribution of contract queries
+ */
+export class ContextQueryManager {
+    /**
+     * Creates a new QueryManager instance
+     * @param onUpdate - Callback triggered when the global query changes
+     * @param addressResolver - Optional function to resolve contract addresses
+     */
+    constructor(onUpdate, addressResolver) {
+        this.queries = {};
+        this.activeQueries = new Set();
+        this.currGlobal = { version: 0, count: {}, calls: [] };
+        this.version = 0;
+        this.queryId = 0;
+        this.addressResolver = addressResolver;
+        this.onUpdate = onUpdate;
+    }
+    getContextQuery() {
+        return this.currGlobal;
+    }
+    getVersion() {
+        return this.version;
+    }
+    addQuery(query) {
+        const id = this.queryId++;
+        this.queries[id] = query;
+        this.activeQueries.add(id);
+        this.aggregateQueries();
+        return id;
+    }
+    removeQuery(id) {
+        delete this.queries[id];
+        this.activeQueries.delete(id);
+        this.aggregateQueries();
+    }
+    aggregateQueries() {
+        const queryVersion = ++this.version;
+        const newContextQuery = Object.keys(this.queries)
+            .map((id) => {
+            const queryId = Number(id);
+            const query = this.queries[queryId];
+            return Object.values(query.collection).map((request) => ({
+                queryId,
+                abi: request.getAbi(),
+                functionName: request.method,
+                args: request.args,
+                address: request.address || this.addressResolver?.(request.contractName) || request.deployAddress,
+            }));
+        })
+            .reduce((acc, queries) => {
+            if (queries.length) {
+                acc.calls.push(...queries);
+                acc.count[queries[0].queryId] = queries.length;
+            }
+            return acc;
+        }, { version: queryVersion, count: {}, calls: [] });
+        if (stringify(newContextQuery) !== stringify(this.currGlobal)) {
+            this.currGlobal = newContextQuery;
+            if (this.version === queryVersion) {
+                this.onUpdate(newContextQuery);
+            }
+        }
+    }
+    setAddressResolver(resolver) {
+        this.addressResolver = resolver;
+        this.aggregateQueries();
+    }
+    onResult(result, version) {
+        const shouldUpdate = !result.isLoading &&
+            result.data &&
+            result.data.length === this.currGlobal.calls.length &&
+            version === this.currGlobal.version;
+        if (shouldUpdate) {
+            let index = 0;
+            this.activeQueries.forEach((id) => {
+                const queryId = Number(id);
+                const query = this.queries[queryId];
+                const count = this.currGlobal.count[queryId];
+                if (!count)
+                    return; //query has been removed
+                const chunk = result.data?.slice(index, index + count);
+                index += this.currGlobal.count[queryId];
+                if (chunk) {
+                    query.callBack({ isLoading: false, isError: result.isError, data: chunk, error: result.error });
+                }
+            });
+        }
+    }
+}
+const QueryContext = createContext(new ContextQueryManager(() => { }));
+/**
+ * React Context provider for scoped query management
+ * Handles the lifecycle of queries and their results
+ */
+export function ContextQueryProvider({ children, defaultBatchSize, watchBlocks, blocksRefetchInterval, }) {
+    const { addressResolver } = useDappQL();
+    const [query, setQuery] = useState({ version: 0, count: {}, calls: [] });
+    const queryManager = useMemo(() => new ContextQueryManager(setQuery, addressResolver), []);
+    useEffect(() => {
+        queryManager.setAddressResolver(addressResolver);
+    }, [addressResolver]);
+    const result = useReadContracts({
+        contracts: query.calls,
+        query: {
+            notifyOnChangeProps: ['data', 'error'],
+        },
+        batchSize: defaultBatchSize,
+    });
+    useRefetchOnBlockChange(result.refetch, watchBlocks && !!query.calls.length, blocksRefetchInterval);
+    useEffect(() => {
+        queryManager.onResult(result, query.version);
+    }, [result]);
+    return _jsx(QueryContext.Provider, { value: queryManager, children: children });
+}
+export function useQueryContextProvider() {
+    return useContext(QueryContext);
+}

package/dist/react/src/Mutation.d.ts

@@ -0,0 +1,79 @@
+import { Chain, type Address, PublicClient } from 'viem';
+import { type MutationConfig } from '../../shared/types.js';
+import { WriteContractErrorType } from 'wagmi/actions';
+declare function useSimulate<M extends string, Args extends readonly any[]>(config: MutationConfig<M, Args>, address: Address, account: Address | undefined, chain: Chain | undefined, client: PublicClient | undefined): (...args: Args) => Promise<import("viem").SimulateContractReturnType<import("viem").Abi, M, Args, Chain | undefined, import("viem").Account | undefined, Chain | undefined, `0x${string}`>>;
+declare function useEstimate<M extends string, Args extends readonly any[]>(config: MutationConfig<M, Args>, address: Address, account: Address | undefined, chain: Chain | undefined, client: PublicClient | undefined): (...args: Args) => Promise<bigint>;
+declare function useMutationConfirmation(hash: `0x${string}` | undefined): import("wagmi").UseWaitForTransactionReceiptReturnType<import("wagmi").Config, number, {
+    blobGasPrice?: bigint | undefined;
+    blobGasUsed?: bigint | undefined;
+    blockHash: import("viem").Hash;
+    blockNumber: bigint;
+    contractAddress: Address | null | undefined;
+    cumulativeGasUsed: bigint;
+    effectiveGasPrice: bigint;
+    from: Address;
+    gasUsed: bigint;
+    logs: import("viem").Log<bigint, number, false>[];
+    logsBloom: import("viem").Hex;
+    root?: `0x${string}` | undefined;
+    status: "success" | "reverted";
+    to: Address | null;
+    transactionHash: import("viem").Hash;
+    transactionIndex: number;
+    type: import("viem").TransactionType;
+    chainId: number;
+}>;
+/**
+ * Configuration options for mutations
+ * Can be either a string (transaction name) or an object with additional options
+ */
+export type MutationOptions = {
+    /** Human-readable name for the transaction */
+    transactionName?: string;
+    /** Override the contract address */
+    address?: Address;
+    /** Whether to simulate the transaction before sending */
+    simulate?: boolean;
+} | string;
+/**
+ * Hook for executing contract write operations (mutations)
+ * @param config Configuration object containing contract details and ABI
+ * @param optionsOrTransactionName Optional configuration or transaction name
+ * @returns Object containing mutation state and send function
+ *
+ * @example
+ * const mutation = useMutation({
+ *   contractName: 'MyContract',
+ *   functionName: 'setValue',
+ *   getAbi: () => CONTRACT_ABI,
+ *   deployAddress: '0x...'
+ * }, 'Set Value')
+ *
+ * // Execute the mutation
+ * mutation.send(newValue)
+ */
+export declare function useMutation<M extends string, Args extends readonly any[]>(config: MutationConfig<M, Args>, optionsOrTransactionName?: MutationOptions): {
+    status: 'pending' | 'success' | 'error' | 'idle';
+    data: Address | undefined;
+    error: WriteContractErrorType | null;
+    isPending: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    isLoading: boolean;
+    failureCount: number;
+    failureReason: WriteContractErrorType | null;
+    isIdle: boolean;
+    submittedAt: number;
+    confirmation: ReturnType<typeof useMutationConfirmation>;
+    reset: () => void;
+    send: (...args: Args) => void;
+    simulate: ReturnType<typeof useSimulate<M, Args>>;
+    estimate: ReturnType<typeof useEstimate<M, Args>>;
+};
+/**
+ * Return type of the useMutation hook
+ * Includes transaction state, confirmation status, and send function
+ */
+export type Mutation<M extends string, Args extends readonly any[]> = ReturnType<typeof useMutation<M, Args>>;
+export {};
+//# sourceMappingURL=Mutation.d.ts.map

package/dist/react/src/Mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mutation.d.ts","sourceRoot":"","sources":["../../../src/Mutation.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,KAAK,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAGxD,OAAO,EAAgB,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAEzE,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAA;AAEtD,iBAAS,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,SAAS,SAAS,GAAG,EAAE,EAChE,MAAM,EAAE,cAAc,CAAC,CAAC,EAAE,IAAI,CAAC,EAC/B,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,MAAM,EAAE,YAAY,GAAG,SAAS,aAGd,IAAI,8KAYvB;AAED,iBAAS,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,SAAS,SAAS,GAAG,EAAE,EAChE,MAAM,EAAE,cAAc,CAAC,CAAC,EAAE,IAAI,CAAC,EAC/B,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,MAAM,EAAE,YAAY,GAAG,SAAS,aAGd,IAAI,qBAYvB;AAED,iBAAS,uBAAuB,CAAC,IAAI,EAAE,KAAK,MAAM,EAAE,GAAG,SAAS;;;;;;;;;;;;;;;;;;;GAE/D;AAED;;;GAGG;AACH,MAAM,MAAM,eAAe,GACvB;IACE,8CAA8C;IAC9C,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,oCAAoC;IACpC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,yDAAyD;IACzD,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,GACD,MAAM,CAAA;AAEV;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,SAAS,SAAS,GAAG,EAAE,EACvE,MAAM,EAAE,cAAc,CAAC,CAAC,EAAE,IAAI,CAAC,EAC/B,wBAAwB,CAAC,EAAE,eAAe,GACzC;IACD,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,CAAA;IAChD,IAAI,EAAE,OAAO,GAAG,SAAS,CAAA;IACzB,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAAA;IACpC,SAAS,EAAE,OAAO,CAAA;IAClB,SAAS,EAAE,OAAO,CAAA;IAClB,OAAO,EAAE,OAAO,CAAA;IAChB,SAAS,EAAE,OAAO,CAAA;IAClB,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,sBAAsB,GAAG,IAAI,CAAA;IAC5C,MAAM,EAAE,OAAO,CAAA;IACf,WAAW,EAAE,MAAM,CAAA;IACnB,YAAY,EAAE,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAA;IACxD,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,IAAI,CAAA;IAC7B,QAAQ,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAA;IACjD,QAAQ,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAA;CAClD,CA6HA;AAED;;;GAGG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,SAAS,SAAS,GAAG,EAAE,IAAI,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAA"}