import { providers, utils } from 'ethers';
import { ISigner, ReadTransaction, WriteTransaction } from '../../types';
import { RpcProvider } from '..';
export declare const StaticJsonRpcProvider: typeof providers.StaticJsonRpcProvider;
/**
 * @classdesc An extension of StaticJsonRpcProvider that manages a providers chain synchronization status
 * and intercepts all RPC send() calls to ensure that the provider is in sync.
 */
declare class BaseSyncProvider extends StaticJsonRpcProvider {
    readonly domain: number;
    readonly stallTimeout: number;
    private readonly debugLogging;
    private readonly connectionInfo;
    readonly name: string;
    synced: boolean;
    lag: number;
    priority: number;
    private static readonly N_SAMPLES;
    private static readonly RELIABILITY_STEP;
    reliability: number;
    cpsTimestamps: number[];
    get cps(): number;
    private latencies;
    get latency(): number;
    private _syncedBlockNumber;
    get syncedBlockNumber(): number;
    set syncedBlockNumber(value: number);
    constructor(_connectionInfo: utils.ConnectionInfo | string, domain: number, stallTimeout?: number, debugLogging?: boolean);
    /**
     * Synchronizes the provider with chain by checking the current block number and updating the syncedBlockNumber
     * property.
     */
    sync(): Promise<void>;
    /**
     * Overridden RPC send method. If the provider is currently out of sync, this method will
     * now throw an RpcError indicating such. This way, we ensure an out of sync provider is never
     * consulted (except when checking the block number, which is used for syncing).
     *
     * @param method - RPC method name.
     * @param params - RPC method params.
     * @returns any - RPC response.
     * @throws RpcError - If the provider is currently out of sync.
     */
    send(method: string, params: Array<unknown>): Promise<unknown>;
    updateMetrics(success: boolean, sendTimestamp: number, iteration: number, method: string, params: unknown[], error?: {
        type: string;
        context: unknown;
    }): void;
    private debugLog;
}
export declare class SyncProvider implements RpcProvider {
    private readonly provider;
    constructor(connectionInfo: utils.ConnectionInfo | string, domain: number, stallTimeout?: number, debugLogging?: boolean);
    get name(): string;
    get priority(): number;
    set priority(updated: number);
    get lag(): number;
    set lag(updated: number);
    get synced(): boolean;
    set synced(updated: boolean);
    get reliability(): number;
    get latency(): number;
    get cps(): number;
    get syncedBlockNumber(): number;
    set syncedBlockNumber(value: number);
    get internalProvider(): BaseSyncProvider;
    get stallTimeout(): number;
    sync(): Promise<void>;
    getGasPrice(): Promise<string>;
    getBlock(block: number | string): Promise<providers.Block>;
    getBlockNumber(): Promise<number>;
    getCode(address: string): Promise<string>;
    getTransaction(hash: string): Promise<providers.TransactionResponse>;
    prepareRequest(method: string, params: unknown): [string, unknown[]];
    getTransactionReceipt(hash: string): Promise<providers.TransactionReceipt>;
    estimateGas(tx: ReadTransaction | WriteTransaction): Promise<string>;
    send(method: string, params: unknown[]): Promise<unknown>;
    call(tx: ReadTransaction, block: number | string): Promise<string>;
    getBalance(address: string, assetId: string): Promise<string>;
    getDecimals(assetId: string): Promise<number>;
    getTransactionCount(address: string, block: number | string): Promise<number>;
    getSigner(signer: ISigner | string): Promise<ISigner>;
    connect(signer: ISigner | string): Promise<ISigner>;
}
export {};
//# sourceMappingURL=provider.d.ts.map