import { providers, utils } from 'ethers';
import { IProviderMethods, ProviderMethod } from './ProviderMethods.js';
import { HyperlaneLogFilter, RpcConfigWithConnectionInfo } from './types.js';
/**
 * Thrown when a log query would take more than
 * {@link MAX_LOG_BLOCK_RANGES_TO_QUERY} sub-queries to serve in full.
 *
 * The message names the block range because that is what `isBlockRangeError` in
 * `rpc/evm/utils.ts` matches on, so a paginating caller shrinks its chunks and
 * completes the scan instead of failing it.
 *
 * The decision is made from the requested span alone, before any log query is
 * issued, and is the same every time it is asked, so the error carries
 * `isRecoverable = false` to keep SmartProvider from spending its retry budget
 * and backoffs re-deriving it. That flag is also what `isTerminalLogReadError`
 * reads, which is why `getLogsFromRpc` classifies a range rejection first.
 */
export declare class LogBlockRangeTooLargeError extends Error {
    readonly isRecoverable = false;
}
/**
 * Thrown when a log query reaches below the earliest block this RPC says it
 * serves, through either `pagination.minBlockNumber` or
 * `pagination.maxBlockAge`.
 *
 * The start block used to be raised to the floor and the logs of the remaining
 * window returned, which is the silent truncation
 * {@link LogBlockRangeTooLargeError} removes on the other bound: nothing in the
 * response marked the blocks that had been dropped.
 *
 * Unlike a span that is too wide, this is not something a caller can page
 * around, because no part of the missing history is on this endpoint at any
 * chunk size. The only recovery is another RPC, so the message deliberately
 * avoids the wording `isBlockRangeError` in `rpc/evm/utils.ts` matches, and the
 * error carries `isRecoverable = false` so that `getLogsFromRpc` surfaces it at
 * once instead of halving its way to the one block minimum first. SmartProvider
 * moves on to the next provider either way, and once every provider has refused
 * it passes the flag on rather than retrying them all again.
 */
export declare class LogBlockHistoryUnavailableError extends Error {
    readonly isRecoverable = false;
}
export declare class HyperlaneJsonRpcProvider extends providers.StaticJsonRpcProvider implements IProviderMethods {
    readonly rpcConfig: RpcConfigWithConnectionInfo;
    readonly options?: {
        debug?: boolean;
    } | undefined;
    protected readonly logger: import("pino").pino.Logger<never>;
    readonly supportedMethods: ProviderMethod[];
    constructor(rpcConfig: RpcConfigWithConnectionInfo, network: providers.Networkish, options?: {
        debug?: boolean;
    } | undefined, connectionOverride?: utils.ConnectionInfo);
    prepareRequest(method: string, params: any): [string, any[]];
    getLogs(filter: HyperlaneLogFilter | Promise<HyperlaneLogFilter>): Promise<providers.Log[]>;
    perform(method: string, params: any, reqId?: number): Promise<any>;
    performGetLogs(params: {
        filter: HyperlaneLogFilter;
    }): Promise<any>;
    getBaseUrl(): string;
}
//# sourceMappingURL=HyperlaneJsonRpcProvider.d.ts.map