import { Account, AccountJSON, AddressString, Asset, Block, BlockJSON, ConfirmedTransaction, Contract, GetOptions, Hash256String, Input, InputOutput, InvocationTransactionModel, IterOptions, NetworkSettings, NetworkType, Output, Peer, RawAction, RawCallReceipt, RawInvocationData, RelayTransactionResult, ScriptBuilderParam, StorageItem, Transaction, TransactionBaseModel, TransactionJSON, TransactionReceipt } from '@neo-one/client-common';
import BigNumber from 'bignumber.js';
import { JSONRPCClient } from './JSONRPCClient';
import { JSONRPCProvider, JSONRPCProviderManager } from './JSONRPCProvider';
export interface DataProviderOptions {
    readonly network: NetworkType;
    readonly rpcURL: string | JSONRPCProvider | JSONRPCProviderManager;
    readonly iterBlocksFetchTimeoutMS?: number;
    readonly iterBlocksBatchSize?: number;
}
export interface DataProvider {
    readonly setRPCURL: (rpcURL: string) => void;
    readonly getUnclaimed: (address: AddressString) => Promise<{
        readonly unclaimed: readonly Input[];
        readonly amount: BigNumber;
    }>;
    readonly getClaimAmount: (input: Input) => Promise<BigNumber>;
    readonly getUnspentOutputs: (address: AddressString) => Promise<readonly InputOutput[]>;
    readonly relayTransaction: (transaction: TransactionBaseModel, networkFee?: BigNumber) => Promise<RelayTransactionResult>;
    readonly getTransactionReceipt: (hash: Hash256String, options?: GetOptions) => Promise<TransactionReceipt>;
    readonly getInvocationData: (hash: Hash256String) => Promise<RawInvocationData>;
    readonly testInvoke: (transaction: InvocationTransactionModel) => Promise<RawCallReceipt>;
    readonly getAccount: (address: AddressString) => Promise<Account>;
    readonly getAsset: (hash: Hash256String) => Promise<Asset>;
    readonly getBlock: (hashOrIndex: Hash256String | number, options?: GetOptions) => Promise<Block>;
    readonly iterBlocks: (options: IterOptions) => AsyncIterable<Block>;
    readonly getBestBlockHash: () => Promise<Hash256String>;
    readonly getBlockCount: () => Promise<number>;
    readonly getContract: (address: AddressString) => Promise<Contract>;
    readonly getMemPool: () => Promise<readonly Hash256String[]>;
    readonly getTransaction: (hash: Hash256String) => Promise<Transaction>;
    readonly getOutput: (input: Input) => Promise<Output>;
    readonly getConnectedPeers: () => Promise<readonly Peer[]>;
    readonly getNetworkSettings: () => Promise<NetworkSettings>;
    readonly iterActionsRaw: (options: IterOptions) => AsyncIterable<RawAction>;
    readonly call: (contract: AddressString, method: string, params: ReadonlyArray<ScriptBuilderParam | undefined>) => Promise<RawCallReceipt>;
    readonly iterStorage: (address: AddressString) => AsyncIterable<StorageItem>;
}
export declare abstract class DataProviderBase implements DataProvider {
    readonly network: NetworkType;
    protected mutableClient: JSONRPCClient;
    protected readonly iterBlocksFetchTimeoutMS: number | undefined;
    protected readonly iterBlocksBatchSize: number | undefined;
    constructor({ network, rpcURL, iterBlocksFetchTimeoutMS, iterBlocksBatchSize }: DataProviderOptions);
    setRPCURL(rpcURL: string): void;
    getUnclaimed(address: AddressString): Promise<{
        readonly unclaimed: readonly Input[];
        readonly amount: BigNumber;
    }>;
    getClaimAmount(_input: Input): Promise<BigNumber>;
    getUnspentOutputs(address: AddressString): Promise<readonly InputOutput[]>;
    relayTransaction(transaction: TransactionBaseModel, networkFee?: BigNumber): Promise<RelayTransactionResult>;
    relayStrippedTransaction(verificationTransaction: InvocationTransactionModel, relayTransaction: InvocationTransactionModel, networkFee?: BigNumber): Promise<RelayTransactionResult>;
    getTransactionReceipt(hash: Hash256String, options?: GetOptions): Promise<TransactionReceipt>;
    getInvocationData(_hash: Hash256String): Promise<RawInvocationData>;
    testInvoke(transaction: InvocationTransactionModel): Promise<RawCallReceipt>;
    getAccount(address: AddressString): Promise<Account>;
    getAsset(hash: Hash256String): Promise<Asset>;
    getBlock(hashOrIndex: Hash256String | number, options?: GetOptions): Promise<Block>;
    iterBlocks(options?: IterOptions): AsyncIterable<Block>;
    getBestBlockHash(): Promise<Hash256String>;
    getBlockCount(): Promise<number>;
    getContract(address: AddressString): Promise<Contract>;
    getMemPool(): Promise<readonly Hash256String[]>;
    getTransaction(hash: Hash256String): Promise<Transaction>;
    getOutput(input: Input): Promise<Output>;
    getConnectedPeers(): Promise<readonly Peer[]>;
    getNetworkSettings(): Promise<NetworkSettings>;
    iterActionsRaw(_options?: IterOptions): AsyncIterable<RawAction>;
    call(contract: AddressString, method: string, params: ReadonlyArray<ScriptBuilderParam | undefined>): Promise<RawCallReceipt>;
    iterStorage(_address: AddressString): AsyncIterable<StorageItem>;
    protected getAccountInternal(address: AddressString): Promise<AccountJSON>;
    protected abstract executeGetUnclaimed(address: AddressString): Promise<{
        readonly unclaimed: readonly Input[];
        readonly amount: BigNumber;
    }>;
    protected abstract executeGetUnspentOutputs(address: AddressString): Promise<readonly InputOutput[]>;
    protected abstract executeRelayTransaction(transaction: TransactionBaseModel, networkFee?: BigNumber): Promise<RelayTransactionResult>;
    protected abstract executeRelayStrippedTransaction(verificationTransaction: InvocationTransactionModel, relayTransaction: InvocationTransactionModel, networkFee?: BigNumber): Promise<RelayTransactionResult>;
    protected abstract executeGetTransactionReceipt(hash: Hash256String, options?: GetOptions): Promise<TransactionReceipt>;
    protected abstract executeTestInvoke(transaction: InvocationTransactionModel): Promise<RawCallReceipt>;
    protected abstract executeGetOutput(input: Input): Promise<Output>;
    protected abstract executeGetAccountInternal(address: AddressString): Promise<AccountJSON>;
    protected abstract convertConfirmedTransaction(transaction: TransactionJSON, block: BlockJSON): ConfirmedTransaction;
    protected capture<T>(func: () => Promise<T>, title: string): Promise<T>;
}