import type { TAbiItem } from '../types/TAbi';
import type { TPlatform } from '../models/TPlatform';
import type { IWeb3Client, IWeb3ClientOptions } from './interfaces/IWeb3Client';
import { ClientPool, IRpcConfig, IPoolWeb3Request, WClient } from './ClientPool';
import { ClientEventsStream } from './ClientEventsStream';
import { ClientDebugMethods } from './debug/ClientDebugMethods';
import { TRpcContractCall } from '../rpc/RpcContract';
import { RpcLogFilterOptions, RpcSubscription } from '../rpc/RpcSubscription';
import { TEth } from '../models/TEth';
import { PromiseEvent } from '../class/PromiseEvent';
import { Rpc, RpcTypes } from '../rpc/Rpc';
import { TRpc } from '../rpc/RpcBase';
import { DataLike } from '../utils/types';
import { WalletClient } from './WalletClient';
export declare abstract class Web3Client implements IWeb3Client {
    TIMEOUT: number;
    abstract platform: TPlatform;
    abstract chainId: number;
    abstract chainToken: string;
    abstract defaultGasLimit: number;
    forked?: {
        platform: TPlatform;
        block?: number;
    };
    defaultTxType: 0 | 1 | 2;
    defaultGasPriceRatio: number;
    minGasPriorityFee: number;
    blockTimeAvg: number;
    get network(): TPlatform;
    options: IWeb3ClientOptions;
    pool: ClientPool;
    debug: ClientDebugMethods;
    wallet: WalletClient;
    constructor(options: IWeb3ClientOptions);
    constructor(endpoints: IRpcConfig[]);
    request<TResult = any>(req: TRpc.IRpcAction): Promise<TResult>;
    batch(requests: TRpc.IRpcAction[]): Promise<any[]>;
    getEventStream(address: TEth.Address, abi: TAbiItem[], event: string): ClientEventsStream<any>;
    with<TResult>(fn: (wClient: WClient) => Promise<TResult>): Promise<TResult>;
    getWeb3(options?: IPoolWeb3Request): Promise<void>;
    getRpc(options?: IPoolWeb3Request): Promise<Rpc>;
    getNodeURL(options?: IPoolWeb3Request): Promise<string>;
    subscribe(type: 'logs', options: RpcLogFilterOptions, callback?: (error: Error, log: TEth.Log) => void): Promise<RpcSubscription<TEth.Log>>;
    subscribe(type: 'newHeads' | 'newBlockHeaders', callback?: (error: Error, blockHeader: TEth.Block) => void): Promise<RpcSubscription<TEth.Block>>;
    subscribe(type: 'newPendingTransactions' | 'pendingTransactions', callback?: (error: Error, transactionHash: TEth.Hex) => void): Promise<RpcSubscription<TEth.Hex>>;
    readContract(req: TRpcContractCall): Promise<any>;
    readContractBatch(requests: TRpcContractCall[]): Promise<any[]>;
    getBalance(address: TEth.Address, blockNumber?: DataLike<RpcTypes.BlockNumberOrTagOrHash>): Promise<bigint>;
    getBalances(addresses: TEth.Address[], blockNumber?: DataLike<RpcTypes.BlockNumberOrTagOrHash>): Promise<bigint[]>;
    getTransactionCount(address: TEth.Address, blockNumber?: DataLike<RpcTypes.BlockNumberOrTagOrHash>): Promise<bigint>;
    isSyncing(): Promise<RpcTypes.SyncingStatus>;
    getTransaction(txHash: TEth.Hex, opts?: IPoolWeb3Request): Promise<TEth.Tx>;
    getTransactions(txHashes: TEth.Hex[], opts?: IPoolWeb3Request): Promise<TEth.Tx[]>;
    getTransactionReceipt(txHash: TEth.Hex): Promise<TEth.TxReceipt>;
    getTransactionReceipts(hashes: TEth.Hex[]): Promise<TEth.TxReceipt[]>;
    getTransactionTrace(hash: string): Promise<any>;
    getBlock(nr: number | "earliest" | "latest" | "pending" | "safe" | "finalized"): Promise<TEth.Block>;
    getBlocks(nrs: number[]): Promise<TEth.Block<TEth.Hex>[]>;
    getCode(address: TEth.Address): Promise<`0x${string}`>;
    /**
     * Get and extract EIP-7702 Delegator
     */
    getDelegatedAddress(address: TEth.Address): Promise<TEth.Address>;
    getPendingTransactions(): Promise<RpcTypes.Transaction[]>;
    getPoolStatus(): Promise<{
        baseFee: bigint;
        pending: number;
        queued: number;
    }>;
    getStorageAt(address: TEth.Address, position: number | bigint | TEth.Hex, blockNumber?: DataLike<RpcTypes.BlockNumberOrTagOrHash>): Promise<`0x${string}`>;
    getStorageAtBatched(address: TEth.Address, slots: (string | number | bigint)[], blockNumber?: DataLike<RpcTypes.BlockNumberOrTagOrHash>): Promise<any>;
    getGasPrice(): Promise<{
        price: bigint;
        base?: bigint;
        priority?: bigint;
    }>;
    getGasPriorityFee(): Promise<bigint>;
    getGasEstimation(from: TEth.Address, tx: TEth.TxLike): Promise<bigint>;
    getAccounts(options?: IPoolWeb3Request): Promise<TEth.Address[]>;
    getChainId(options?: IPoolWeb3Request): Promise<number>;
    switchChain(params: {
        chainId: number | string;
    }, options: IPoolWeb3Request): Promise<void>;
    sendSignedTransaction(signedTxBuffer: TEth.Hex): PromiseEvent<TEth.TxReceipt>;
    sign(address: TEth.Address, message: string): Promise<string>;
    signTypedData(address: TEth.Address, typedData: DataLike<RpcTypes.TypedData>): Promise<TEth.Hex>;
    sendTransaction(data: TEth.TxLike): PromiseEvent<TEth.TxReceipt>;
    getBlockNumber(): Promise<number>;
    call(tx: TEth.TxLike): Promise<any>;
    getBlockNumberCached(): Promise<number>;
    getPastLogs(filter: RpcTypes.Filter, options?: {
        /**
         * For large block ranges and huge amounts of logs, streaming should be used, we pass the loaded logs in batches direct to onProgress
         * and do not aggregate to a final logs array to prevent memory issues.
         */
        streamed?: boolean;
        /**
         * Override the default block range limits for all underlying RPC clients, otherwise the config will be used or
         * the RPC exception will be parsed.
         */
        blockRangeLimits?: WClient['blockRangeLimits'];
        /**
         * When loading in batches the cb will be called with fetched and parsed logs on each iteration
         */
        onProgress?(info: TLogsRangeProgress<TEth.Log>): void;
    }): Promise<TEth.Log[]>;
    getNodeInfos(options?: {
        timeout?: number;
        calls?: ('net_peerCount' | 'eth_blockNumber' | 'eth_syncing' | 'net_version')[];
    }): Promise<import("./interfaces/IWeb3ClientStatus").IWeb3ClientStatus[]>;
    getNodeStats(): {
        success: number;
        fail: number;
        ping: number;
        url: string;
    }[];
    static url<T extends Web3Client>(options: IWeb3ClientOptions): any;
    static url<T extends Web3Client>(endpoints: IRpcConfig[], opts?: Partial<IWeb3ClientOptions>): any;
    static url<T extends Web3Client>(url: string, opts?: Partial<IWeb3ClientOptions>): T;
}
export type TLogsRangeProgress<TLogParsed> = {
    logs: TLogParsed[];
    /** @deprecated Use logs for current logs buffer */
    paged: TLogParsed[];
    latestBlock: number;
    blocks: {
        total: number;
        loaded: number;
    };
    blocksPerSecond: number;
    timeLeftSeconds: number;
    completed: boolean;
};