import { iMulticall3Abi } from '../contracts/abis/viemAbis';
import { Abi, AbiFunction, AbiStateMutability, Address, BlockNumber, BlockTag, ContractFunctionArgs, ContractFunctionName, ContractFunctionReturnType, GetContractReturnType, PublicClient } from 'viem';
import { Contract, ExtractAbiFunction } from '../common/types';
export declare const DEFAULT_CALL_LIMIT = 256;
export type BlockTagMulticall = BlockTag | BlockNumber;
export type MulticallOptions = {
    blockTag?: BlockTag;
    blockNumber?: BlockNumber;
    disableMulticall?: boolean;
    account?: Address;
};
export type OverrideMulticallFunction<abi extends Abi, functionName extends ContractFunctionName<abi, AbiStateMutability> = ContractFunctionName<abi, AbiStateMutability>, abiFunction extends AbiFunction = ExtractAbiFunction<abi, functionName>, mutability extends AbiStateMutability = abiFunction['stateMutability'], args = ContractFunctionArgs<abi, AbiStateMutability, functionName>> = args extends readonly [] ? (multicallOptions?: MulticallOptions) => Promise<ContractFunctionReturnType<abi, mutability, functionName>> : args extends readonly any[] ? (...args: [...args, MulticallOptions | undefined]) => Promise<ContractFunctionReturnType<abi, mutability, functionName>> : (...args: [args, MulticallOptions | undefined]) => Promise<ContractFunctionReturnType<abi, mutability, functionName>>;
export type MulticallSimulate<abi extends Abi, T extends Contract<abi> = Contract<abi>> = T extends {
    simulate: object;
} ? {
    [K in keyof T['simulate']]: K extends ContractFunctionName<abi, 'nonpayable' | 'payable'> ? OverrideMulticallFunction<abi, K> : T['simulate'][K];
} : {};
export type MulticallRead<abi extends Abi, T extends Contract<abi> = Contract<abi>> = T extends {
    read: object;
} ? {
    [K in keyof T['read']]: K extends ContractFunctionName<abi, 'view' | 'pure'> ? OverrideMulticallFunction<abi, K> : T['read'][K];
} : {};
export type MulticallFuncs<abi extends Abi> = {
    read: MulticallRead<abi>;
    simulate: MulticallSimulate<abi>;
};
export declare class MulticallRPCError extends Error {
    constructor(error: any, opts?: {
        nCall?: number;
        block?: string;
    });
    static getViemErrorMessage(error: any): string;
}
export declare class ContractCall {
    abi: Abi;
    functionName: string;
    address: Address;
    params: unknown[];
    constructor({ abi, address, functionName, params, }: {
        abi: Abi;
        address: Address;
        functionName: string;
        params: unknown[];
    });
}
type Multicall3 = GetContractReturnType<typeof iMulticall3Abi, PublicClient, Address>;
export declare class Multicall {
    static isMulticallOptions(options?: any): options is MulticallOptions | undefined;
    multicallContract: Multicall3;
    readonly batchMap: Map<BlockTagMulticall, MulticallBatch>;
    readonly callLimit: number;
    private multicallCache;
    private disableMulticall;
    constructor({ address, client, callLimit, }: {
        address: Address;
        client: PublicClient;
        callLimit?: number;
    });
    private monitor;
    doAggregateCalls(calls: readonly ContractCall[], blockTagMulticall: BlockTagMulticall): Promise<any[]>;
    wrapFunctions<abi extends Abi, T extends Contract<abi> = Contract<abi>>(contract: T, functionType: 'read' | 'simulate'): Record<string, any> | undefined;
    wrap<abi extends Abi, T extends Contract<abi> = Contract<abi>>(contract: T): MulticallFuncs<abi>;
}
declare class MulticallBatch {
    private readonly multicallInstance;
    readonly blockTagMulticall: BlockTagMulticall;
    readonly pendingContractCalls: ContractCall[];
    readonly promise: Promise<any[]>;
    constructor(multicallInstance: Multicall, blockTagMulticall?: BlockTagMulticall);
}
export {};