import { class_Dfr } from 'atma-utils';
import type { TAbiItem } from '../types/TAbi';
import type { TLogsRangeProgress, Web3Client } from '../clients/Web3Client';
import { TAddress } from '../models/TAddress';
import { ITxLogItem } from '../txs/receipt/ITxLogItem';
import { RpcTypes } from '../rpc/Rpc';
import { TEth } from '../models/TEth';
import { WClient } from '../clients/ClientPool';
export interface IContractReader {
    forBlock(mix: number | Date | undefined): IContractReader;
    forBlockNumber(blockNumber: number | undefined): IContractReader;
    forBlockAt(date: Date | undefined): IContractReader;
    readAsync<T = any>(address: string, methodAbi: string | TAbiItem, ...params: any[]): Promise<T>;
}
export declare class ContractReader implements IContractReader {
    client: Web3Client;
    private ctx?;
    private blockNumberTask;
    private options;
    constructor(client?: Web3Client, ctx?: {
        name?: string;
    });
    forBlock(mix: number | Date | undefined): any;
    forBlockNumber(blockNumber: number | undefined): IContractReader;
    forBlockAt(date: Date | undefined): IContractReader;
    withAddress(address: TAddress): IContractReader;
    getStorageAt(address: TAddress, position: TEth.Hex | number | bigint): Promise<`0x${string}`>;
    readAsync<TResult = any>(address: TEth.Address, methodAbi: string | TAbiItem, ...params: any[]): Promise<TResult>;
    executeBatch<T extends readonly unknown[] | ContractReaderUtils.IContractReadParams[]>(requestArr: T): Promise<{
        -readonly [P in keyof T]: ContractReaderUtils.TIContractReadParamsInferred<T[P]>;
    }>;
    getLogsParsed(...args: Parameters<ContractReader['getLogsFilter']>): Promise<ITxLogItem[]>;
    getLogs(filters: RpcTypes.Filter, options?: {
        streamed?: boolean;
        blockRangeLimits?: WClient['blockRangeLimits'];
        onProgress?(info: TLogsRangeProgress<TEth.Log>): any;
    }): Promise<TEth.Log[]>;
    getLogsFilter(abi: TAbiItem | string | '*' | TAbiItem[], options: {
        /** Can be UNDEFINED, then the logs will be searched globally */
        address?: TAddress | TAddress[];
        /**
         * "deployment": get the contracts deployment date to skip lots of blocks (in case we use pagination to fetch logs)
         */
        fromBlock?: number | Date | 'deployment';
        toBlock?: number | Date;
        params?: {
            [key: string]: any;
        } | any[];
    }): Promise<RpcTypes.Filter>;
    static read(client: Web3Client, address: TAddress, methodAbi: string): Promise<any>;
}
export declare namespace ContractReaderUtils {
    class DeferredRequest<T = any> {
        request: {
            address: TAddress;
            abi: string | TAbiItem;
            params: any[];
            blockNumber?: Date | number;
            options?: {
                from?: TAddress;
            };
        };
        promise: class_Dfr<T> & {
            request: DeferredRequest;
        };
        constructor(request: {
            address: TAddress;
            abi: string | TAbiItem;
            params: any[];
            blockNumber?: Date | number;
            options?: {
                from?: TAddress;
            };
        });
    }
    interface IContractReadParams<TOutput = any> {
        address: TAddress;
        abi: string | TAbiItem;
        params?: any[];
        blockNumber?: number | Date;
        options?: {
            from?: TAddress;
        };
    }
    type TIContractReadParamsInferred<T> = T extends IContractReadParams<infer P> ? P : never;
    type TIContractReadParamsInferredMany<T extends IContractReadParams[]> = {
        [P in keyof T]: T[P] extends IContractReadParams<infer P> ? P : never;
    };
    function readAsyncBatch(client: Web3Client, requests: (IContractReadParams | null)[]): Promise<any[]>;
}