import { Signer, providers } from 'ethers';
import { ReadTransaction, WriteTransaction, IBlock, ISigner, ITransactionResponse, ITransactionReceipt } from '../types';
export { SyncProvider } from './eth';
export declare const SupportedVms: {
    readonly evm: "evm";
    readonly tvm: "tvm";
    readonly svm: "svm";
};
export type SupportedVm = (typeof SupportedVms)[keyof typeof SupportedVms];
export declare const MAX_CONFIRMATION = 10000;
export interface SignerTypeMaps {
    [SupportedVms.evm]: Signer;
}
export interface BlockTypeMap {
    [SupportedVms.evm]: providers.Block;
}
export interface TransactionRequestTypeMap {
    [SupportedVms.evm]: providers.TransactionRequest;
}
export interface TransactionResponseTypeMap {
    [SupportedVms.evm]: providers.TransactionResponse;
}
export interface TransactionReceiptTypeMap {
    [SupportedVms.evm]: providers.TransactionReceipt;
}
/**
 * Defines the interface for a generic RPC provider for a given VM
 * S = Signer type for the transaction (whats used to sign + send a transaction)
 * B = Block type for the chain (whats returned when block is fetched)
 * T = TransactionResponse type for the chain (whats returned when transaction is submitted)
 * R = TransactionReceipt type for the chain (whats returned when transaction is mined)
 */
export type RpcProvider = {
    name: string;
    priority: number;
    lag: number;
    synced: boolean;
    reliability: number;
    latency: number;
    cps: number;
    syncedBlockNumber: number;
    sync(): Promise<void>;
    call: (tx: ReadTransaction, block: number | string) => Promise<string>;
    send: (method: string, params: unknown[]) => Promise<unknown>;
    getTransaction: (hash: string) => Promise<ITransactionResponse | undefined>;
    prepareRequest: (method: string, params: unknown) => [string, unknown[]];
    estimateGas: (tx: ReadTransaction | WriteTransaction) => Promise<string>;
    getTransactionReceipt: (hash: string) => Promise<ITransactionReceipt>;
    getGasPrice: () => Promise<string>;
    getBlock: (block: number | string) => Promise<IBlock>;
    getBlockNumber: () => Promise<number>;
    getCode: (address: string) => Promise<string>;
    getBalance: (address: string, assetId: string) => Promise<string>;
    getDecimals: (address: string) => Promise<number>;
    getTransactionCount: (address: string, block: number | string) => Promise<number>;
    getSigner: (signer: string | ISigner) => Promise<ISigner>;
    connect: (signer: ISigner | string) => Promise<ISigner>;
};
/**
 * Get the VM type from a domain id
 * TODO: should likely move to utils?
 */
export declare const getVmFromDomainId: (domainId: number) => SupportedVm;
/**
 * Returns an RPC provider for the given domain. Must pass in a qualified URL
 * for the given domain.
 */
export declare const getRpcClient: (domainId: number, url: string) => RpcProvider;
//# sourceMappingURL=index.d.ts.map