/// <reference types="node" />
import { Account, AddressString, Attribute, AttributeModel, Block, ClaimTransaction, ContractTransaction, GetOptions, Hash256String, Input, InputModel, InputOutput, InvocationTransaction, InvocationTransactionModel, InvokeSendUnsafeReceiveTransactionOptions, IterOptions, NetworkType, Output, OutputModel, Param, ParamJSON, RawAction, RawCallReceipt, RawInvocationData, RawInvokeReceipt, ScriptBuilderParam, SourceMaps, Transaction, TransactionBaseModel, TransactionOptions, TransactionReceipt, TransactionResult, Transfer, UserAccount, UserAccountID, Witness, WitnessModel } from '@neo-one/client-common';
import BigNumber from 'bignumber.js';
import { Observable } from 'rxjs';
export interface InvokeMethodOptions {
    readonly contract: AddressString;
    readonly params: ReadonlyArray<ScriptBuilderParam | undefined>;
    readonly invokeMethod: string;
}
export interface InvokeRawOptions<T extends TransactionReceipt> {
    readonly invokeMethodOptionsOrScript: InvokeMethodOptions | Buffer;
    readonly transfers?: readonly FullTransfer[];
    readonly options?: TransactionOptions;
    readonly verify?: boolean;
    readonly onConfirm: (options: {
        readonly transaction: Transaction;
        readonly data: RawInvocationData;
        readonly receipt: TransactionReceipt;
    }) => Promise<T> | T;
    readonly method: string;
    readonly scripts?: readonly WitnessModel[];
    readonly labels?: Record<string, string>;
    readonly rawInputs?: readonly Input[];
    readonly rawOutputs?: readonly Output[];
    readonly sourceMaps?: SourceMaps;
    readonly reorderOutputs?: (outputs: readonly Output[]) => readonly Output[];
}
export interface ExecuteInvokeScriptOptions<T extends TransactionReceipt> {
    readonly script: Buffer;
    readonly from: UserAccountID;
    readonly attributes: readonly Attribute[];
    readonly inputs: readonly InputOutput[];
    readonly outputs: readonly Output[];
    readonly rawInputs: readonly Input[];
    readonly rawOutputs: readonly Output[];
    readonly gas: BigNumber;
    readonly scripts: readonly WitnessModel[];
    readonly verify: boolean;
    readonly reorderOutputs: (outputs: readonly Output[]) => readonly Output[];
    readonly onConfirm: (options: {
        readonly transaction: Transaction;
        readonly data: RawInvocationData;
        readonly receipt: TransactionReceipt;
    }) => Promise<T> | T;
    readonly sourceMaps?: SourceMaps;
}
export interface ExecuteInvokeMethodOptions<T extends TransactionReceipt> extends ExecuteInvokeScriptOptions<T> {
    readonly invokeMethodOptions: InvokeMethodOptions;
}
export interface ExecuteInvokeClaimOptions {
    readonly contract: AddressString;
    readonly inputs: readonly InputOutput[];
    readonly outputs: readonly Output[];
    readonly unclaimed: readonly Input[];
    readonly amount: BigNumber;
    readonly attributes: readonly Attribute[];
    readonly method: string;
    readonly params: ReadonlyArray<ScriptBuilderParam | undefined>;
    readonly paramsZipped: ReadonlyArray<readonly [string, Param | undefined]>;
    readonly from: UserAccountID;
    readonly sourceMaps?: SourceMaps;
}
export interface Provider {
    readonly networks$: Observable<readonly NetworkType[]>;
    readonly getNetworks: () => readonly NetworkType[];
    readonly getUnclaimed: (network: NetworkType, address: AddressString) => Promise<{
        readonly unclaimed: readonly Input[];
        readonly amount: BigNumber;
    }>;
    readonly getUnspentOutputs: (network: NetworkType, address: AddressString) => Promise<readonly InputOutput[]>;
    readonly getTransactionReceipt: (network: NetworkType, hash: Hash256String, options?: GetOptions) => Promise<TransactionReceipt>;
    readonly getInvocationData: (network: NetworkType, hash: Hash256String) => Promise<RawInvocationData>;
    readonly testInvoke: (network: NetworkType, transaction: InvocationTransactionModel) => Promise<RawCallReceipt>;
    readonly call: (network: NetworkType, contract: AddressString, method: string, params: ReadonlyArray<ScriptBuilderParam | undefined>) => Promise<RawCallReceipt>;
    readonly getBlockCount: (network: NetworkType) => Promise<number>;
    readonly getTransaction: (network: NetworkType, hash: Hash256String) => Promise<Transaction>;
    readonly getOutput: (network: NetworkType, input: Input) => Promise<Output>;
    readonly iterBlocks: (network: NetworkType, options?: IterOptions) => AsyncIterable<Block>;
    readonly getAccount: (network: NetworkType, address: AddressString) => Promise<Account>;
    readonly iterActionsRaw?: (network: NetworkType, options?: IterOptions) => AsyncIterable<RawAction>;
}
interface TransactionOptionsFull {
    readonly from: UserAccountID;
    readonly attributes: readonly Attribute[];
    readonly networkFee: BigNumber;
    readonly systemFee: BigNumber;
    readonly skipSysFeeCheck: boolean;
}
interface FullTransfer extends Transfer {
    readonly from: UserAccountID;
}
export declare abstract class UserAccountProviderBase<TProvider extends Provider> {
    readonly provider: TProvider;
    readonly iterActionsRaw?: (network: NetworkType, options?: IterOptions) => AsyncIterable<RawAction>;
    protected readonly mutableUsedOutputs: Set<string>;
    protected mutableBlockCount: number;
    constructor({ provider }: {
        readonly provider: TProvider;
    });
    getCurrentUserAccount(): UserAccount | undefined;
    getUserAccounts(): readonly UserAccount[];
    getNetworks(): readonly NetworkType[];
    selectUserAccount(_id?: UserAccountID): Promise<void>;
    iterBlocks(network: NetworkType, options?: IterOptions): AsyncIterable<Block>;
    getBlockCount(network: NetworkType): Promise<number>;
    getAccount(network: NetworkType, address: AddressString): Promise<Account>;
    transfer(transfers: readonly Transfer[], options?: TransactionOptions): Promise<TransactionResult<TransactionReceipt, InvocationTransaction | ContractTransaction>>;
    claim(options?: TransactionOptions): Promise<TransactionResult<TransactionReceipt, ClaimTransaction>>;
    invoke(contract: AddressString, method: string, params: ReadonlyArray<ScriptBuilderParam | undefined>, paramsZipped: ReadonlyArray<readonly [string, Param | undefined]>, verify: boolean, options?: InvokeSendUnsafeReceiveTransactionOptions, sourceMaps?: SourceMaps): Promise<TransactionResult<RawInvokeReceipt, InvocationTransaction>>;
    invokeSend(contract: AddressString, method: string, paramsIn: ReadonlyArray<ScriptBuilderParam | undefined>, paramsZipped: ReadonlyArray<readonly [string, Param | undefined]>, transfer: Transfer, options?: TransactionOptions, sourceMaps?: SourceMaps): Promise<TransactionResult<RawInvokeReceipt, InvocationTransaction>>;
    invokeCompleteSend(contract: AddressString, method: string, params: ReadonlyArray<ScriptBuilderParam | undefined>, paramsZipped: ReadonlyArray<readonly [string, Param | undefined]>, hash: Hash256String, options?: TransactionOptions, sourceMaps?: SourceMaps): Promise<TransactionResult<RawInvokeReceipt, InvocationTransaction>>;
    invokeRefundAssets(contract: AddressString, method: string, params: ReadonlyArray<ScriptBuilderParam | undefined>, paramsZipped: ReadonlyArray<readonly [string, Param | undefined]>, hash: Hash256String, options?: TransactionOptions, sourceMaps?: SourceMaps): Promise<TransactionResult<RawInvokeReceipt, InvocationTransaction>>;
    invokeClaim(contract: AddressString, method: string, params: ReadonlyArray<ScriptBuilderParam | undefined>, paramsZipped: ReadonlyArray<readonly [string, Param | undefined]>, options?: TransactionOptions, sourceMaps?: SourceMaps): Promise<TransactionResult<TransactionReceipt, ClaimTransaction>>;
    call(network: NetworkType, contract: AddressString, method: string, params: ReadonlyArray<ScriptBuilderParam | undefined>): Promise<RawCallReceipt>;
    protected getTransactionOptions(options?: TransactionOptions): TransactionOptionsFull;
    protected getInvokeAttributes(contract: AddressString, method: string, paramsZipped: ReadonlyArray<readonly [string, Param | undefined]>, verify: boolean, from?: AddressString): readonly Attribute[];
    protected getInvokeScripts(method: string, params: ReadonlyArray<ScriptBuilderParam | undefined>, verify: boolean): readonly WitnessModel[];
    protected consolidate({ inputs, transactionUnsignedIn, from, byteLimit, }: {
        readonly transactionUnsignedIn: TransactionBaseModel;
        readonly inputs: readonly InputOutput[];
        readonly from: UserAccountID;
        readonly byteLimit: number;
    }): Promise<TransactionBaseModel>;
    protected addWitness({ transaction, inputOutputs, address, witness, }: {
        readonly transaction: TransactionBaseModel;
        readonly inputOutputs: readonly Output[];
        readonly address: AddressString;
        readonly witness: WitnessModel;
    }): TransactionBaseModel;
    protected getUnspentOutputs({ from, }: {
        readonly from: UserAccountID;
    }): Promise<{
        readonly unspentOutputs: readonly InputOutput[];
        readonly wasFiltered: boolean;
    }>;
    protected getTransfersInputOutputs({ transfers, from, gas, }: {
        readonly transfers: readonly FullTransfer[];
        readonly from: UserAccountID;
        readonly gas: BigNumber;
    }): Promise<{
        readonly outputs: readonly Output[];
        readonly inputs: readonly InputOutput[];
    }>;
    protected getTransfersInputOutputsFrom({ transfers, from, }: {
        readonly transfers: readonly Transfer[];
        readonly from: UserAccountID;
    }): Promise<{
        readonly outputs: readonly Output[];
        readonly inputs: readonly InputOutput[];
    }>;
    protected getTransferInputOutputs({ to, amount: originalAmount, asset, remainingOutputs, remaining, wasFiltered, }: {
        readonly from: AddressString;
        readonly to?: AddressString;
        readonly amount: BigNumber;
        readonly asset: Hash256String;
        readonly remainingOutputs: readonly InputOutput[];
        readonly remaining: BigNumber;
        readonly wasFiltered: boolean;
    }): {
        readonly inputs: readonly InputOutput[];
        readonly outputs: readonly Output[];
        readonly remainingOutputs: readonly InputOutput[];
        readonly remaining: BigNumber;
    };
    protected getInvokeAttributeTag(contract: AddressString, method: string, paramsZipped: ReadonlyArray<readonly [string, Param | undefined]>): string;
    protected paramToJSON(param: Param): ParamJSON | undefined;
    protected convertAttributes(attributes: readonly Attribute[]): readonly AttributeModel[];
    protected convertInputs(inputs: readonly Input[]): readonly InputModel[];
    protected convertOutputs(outputs: readonly Output[]): readonly OutputModel[];
    protected convertWitness(script: Witness): WitnessModel;
    protected capture<T>(func: () => Promise<T>, { name, labels, invoke, }: {
        readonly name: string;
        readonly labels?: Record<string, string>;
        readonly invoke?: boolean;
    }): Promise<T>;
    protected checkSystemFees({ script, transfers, from, networkFee, systemFee, attributes: attributesIn, rawInputs, rawOutputs, scripts, sourceMaps, reorderOutputs, skipSysFeeCheck, }: {
        readonly script: Buffer;
        readonly transfers?: ReadonlyArray<FullTransfer>;
        readonly from: UserAccountID;
        readonly networkFee: BigNumber;
        readonly systemFee: BigNumber;
        readonly attributes?: ReadonlyArray<Attribute>;
        readonly rawInputs?: ReadonlyArray<Input>;
        readonly rawOutputs?: ReadonlyArray<Output>;
        readonly scripts?: ReadonlyArray<WitnessModel>;
        readonly sourceMaps?: SourceMaps;
        readonly reorderOutputs?: (outputs: ReadonlyArray<Output>) => ReadonlyArray<Output>;
        readonly skipSysFeeCheck?: boolean;
    }): Promise<{
        readonly gas: BigNumber;
        readonly attributes: ReadonlyArray<Attribute>;
    }>;
    protected abstract executeInvokeMethod<T extends TransactionReceipt>(options: ExecuteInvokeMethodOptions<T>): Promise<TransactionResult<T, InvocationTransaction>>;
    protected abstract executeInvokeScript<T extends TransactionReceipt>(options: ExecuteInvokeScriptOptions<T>): Promise<TransactionResult<T, InvocationTransaction>>;
    protected abstract executeInvokeClaim(options: ExecuteInvokeClaimOptions): Promise<TransactionResult<TransactionReceipt, ClaimTransaction>>;
    protected abstract executeTransfer(transfers: readonly Transfer[], from: UserAccountID, attributes: readonly Attribute[], networkFee: BigNumber): Promise<TransactionResult<TransactionReceipt, InvocationTransaction | ContractTransaction>>;
    protected abstract executeClaim(from: UserAccountID, attributes: readonly Attribute[], networkFee: BigNumber): Promise<TransactionResult<TransactionReceipt, ClaimTransaction>>;
    protected invokeRaw<T extends TransactionReceipt>({ invokeMethodOptionsOrScript, transfers, options, onConfirm, method, verify, scripts, labels, rawInputs, rawOutputs, sourceMaps, reorderOutputs, }: InvokeRawOptions<T>): Promise<TransactionResult<T, InvocationTransaction>>;
    private getScriptAndInvokeMethodOptions;
}
export {};