import { BaseProvider, Formatter, TransactionRequest } from '@ethersproject/providers';
import { CallOverrides as CallOverridesSource } from '@ethersproject/contracts';
import { SimpleFallbackProviderConfig } from '../interfaces/simple-fallback-provider-config';
import { Network } from '@ethersproject/networks';
import { LoggerService } from '@nestjs/common';
import { FallbackProvider } from '../interfaces/fallback-provider';
import { BlockTag } from '../ethers/block-tag';
import { BigNumber, BigNumberish } from '@ethersproject/bignumber';
import { Deferrable } from '@ethersproject/properties';
import { EventType, Listener } from '@ethersproject/abstract-provider';
import { FeeHistory } from '../ethers/fee-history';
import { WaitForTransactionOptions, WaitForTransactionResult } from '../interfaces/wait-for-transaction';
import { TraceConfig, TraceResult } from '../interfaces/debug-traces';
import { LazyEventEmitter } from '../common/lazy-event-emitter';
import { FallbackProviderEvents } from '../events';
/**
 * EIP-1898 support
 * https://eips.ethereum.org/EIPS/eip-1898
 */
declare module '@ethersproject/providers' {
    interface BaseProvider {
        getBalance(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<BigNumber>;
        getTransactionCount(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<number>;
        getCode(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
        getStorageAt(addressOrName: string | Promise<string>, position: BigNumberish | Promise<BigNumberish>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
        call(transaction: Deferrable<TransactionRequest>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
    }
    interface CallOverrides extends Omit<CallOverridesSource, 'blockTag'> {
        blockTag?: BlockTag;
    }
}
export interface SimpleFallbackJsonRpcBatchProviderEventEmitter extends LazyEventEmitter {
    on(eventName: 'rpc', listener: (event: FallbackProviderEvents) => void): this;
    once(eventName: 'rpc', listener: (event: FallbackProviderEvents) => void): this;
    addListener(eventName: 'rpc', listener: (event: FallbackProviderEvents) => void): this;
}
export declare class SimpleFallbackJsonRpcBatchProvider extends BaseProvider {
    protected config: SimpleFallbackProviderConfig;
    protected logger: LoggerService;
    protected fallbackProviders: [FallbackProvider];
    protected activeFallbackProviderIndex: number;
    protected detectNetworkFirstRun: boolean;
    protected resetTimer: ReturnType<typeof setTimeout> | null;
    protected lastPerformError: Error | null | unknown;
    protected lastError: Error | null | unknown;
    protected _eventEmitter: SimpleFallbackJsonRpcBatchProviderEventEmitter;
    protected _childRpcListenersAttached: boolean;
    constructor(config: SimpleFallbackProviderConfig, logger: LoggerService);
    static _formatter: Formatter | null;
    static getFormatter(): Formatter;
    protected formatLog(message: string, providerIndex?: number): string;
    on(eventName: EventType, listener: Listener): this;
    getFeeHistory(blockCount: number, newestBlock?: string | null | number, rewardPercentiles?: number[]): Promise<FeeHistory>;
    getDebugTraceBlockByHash(blockHash: string, traceConfig: Partial<TraceConfig>): Promise<TraceResult[]>;
    protected get provider(): FallbackProvider;
    protected switchToNextProvider(): void;
    protected isNonRetryableError(error: Error | unknown): boolean;
    perform(method: string, params: {
        [name: string]: unknown;
    }): Promise<unknown>;
    detectNetwork(): Promise<Network>;
    protected resetFallbacks(): void;
    protected networksEqual(networkA: Network, networkB: Network): boolean;
    get activeProviderIndex(): number;
    get eventEmitter(): SimpleFallbackJsonRpcBatchProviderEventEmitter;
    /**
     * Sets up lazy subscription to child provider events.
     * Only attaches listeners to child providers when someone subscribes to the parent eventEmitter.
     * This avoids unnecessary event processing when no one is listening.
     */
    protected _setupLazyChildListeners(): void;
    /**
     * Attaches listeners to all child providers to re-emit their events on the parent eventEmitter.
     */
    protected _attachChildRpcListeners(): void;
    private _isValidProvider;
    /**
     * Waits for transaction confirmation with fallback provider support.
     *
     * Use instead of tx.wait() which hangs forever when providers fail:
     * - node_modules/@ethersproject/providers/src.ts/base-provider.ts:1055 - polling calls getTransactionReceipt
     * - node_modules/@ethersproject/providers/src.ts/base-provider.ts:1060 - .catch(e => emit("error", e)) swallows error
     * - node_modules/@ethersproject/providers/src.ts/base-provider.ts:1313 - waits for event that never comes
     * - node_modules/@ethersproject/providers/src.ts/base-provider.ts:1412 - timeout=0 by default, no reject
     *
     * This method polls via perform() with fallback and always returns/throws.
     */
    waitForTransactionWithFallback(txHash: string, options?: WaitForTransactionOptions): Promise<WaitForTransactionResult>;
}