@neo-one/client-core-esnext-esm/Client.d.ts

NEO•ONE client core types implementation.

import { Account, AddressString, Block, ClaimTransaction, Hash256String, InvocationTransaction, InvokeSendUnsafeReceiveTransactionOptions, IterOptions, NetworkType, Param, RawAction, RawCallReceipt, RawInvokeReceipt, ScriptBuilderParam, SmartContractDefinition, SourceMaps, Transaction, TransactionOptions, TransactionReceipt, TransactionResult, Transfer, UpdateAccountNameOptions, UserAccount, UserAccountID, UserAccountProvider, UserAccountProviders } from '@neo-one/client-common-esnext-esm';
import BigNumber from 'bignumber.js';
import { BehaviorSubject, Observable } from 'rxjs';
import { AsyncParallelHook } from 'tapable';
import { SmartContract, SmartContractAny } from './types';
export interface ClientHooks {
    readonly beforeRelay: AsyncParallelHook<TransactionOptions>;
    readonly relayError: AsyncParallelHook<Error>;
    readonly afterRelay: AsyncParallelHook<Transaction>;
    readonly beforeConfirmed: AsyncParallelHook<Transaction>;
    readonly confirmedError: AsyncParallelHook<Transaction, Error>;
    readonly afterConfirmed: AsyncParallelHook<Transaction, TransactionReceipt>;
    readonly afterCall: AsyncParallelHook<RawCallReceipt>;
    readonly callError: AsyncParallelHook<Error>;
}
export interface UserAccountFeatures {
    readonly delete: boolean;
    readonly updateName: boolean;
}
export interface BlockEntry {
    readonly block: Block;
    readonly network: NetworkType;
}
export interface AccountStateEntry {
    readonly currentUserAccount: UserAccount;
    readonly account: Account;
}
export declare class Client<TUserAccountProvider extends UserAccountProvider = any, TUserAccountProviders extends UserAccountProviders<TUserAccountProvider> = any> {
    readonly hooks: ClientHooks;
    readonly currentUserAccount$: Observable<UserAccount | undefined>;
    readonly userAccounts$: Observable<readonly UserAccount[]>;
    readonly currentNetwork$: Observable<NetworkType>;
    readonly networks$: Observable<readonly NetworkType[]>;
    protected readonly providers$: BehaviorSubject<TUserAccountProviders>;
    protected readonly selectedProvider$: BehaviorSubject<TUserAccountProvider>;
    private readonly currentNetworkInternal$;
    private readonly reset$;
    readonly block$: Observable<BlockEntry>;
    readonly accountState$: Observable<AccountStateEntry | undefined>;
    constructor(providersIn: TUserAccountProviders);
    get providers(): TUserAccountProviders;
    getUserAccount(idIn: UserAccountID): UserAccount;
    selectUserAccount(idIn?: UserAccountID): Promise<void>;
    selectNetwork(network: NetworkType): Promise<void>;
    getSupportedFeatures(idIn: UserAccountID): Promise<UserAccountFeatures>;
    deleteUserAccount(idIn: UserAccountID): Promise<void>;
    updateUserAccountName(options: UpdateAccountNameOptions): Promise<void>;
    getCurrentUserAccount(): UserAccount | undefined;
    getCurrentNetwork(): NetworkType;
    getUserAccounts(): readonly UserAccount[];
    getNetworks(): readonly NetworkType[];
    smartContract<T extends SmartContract<any, any> = SmartContractAny>(definition: SmartContractDefinition): T;
    transfer(amount: BigNumber, asset: Hash256String, to: AddressString, options?: TransactionOptions): Promise<TransactionResult<TransactionReceipt, InvocationTransaction>>;
    transfer(transfers: readonly Transfer[], options?: TransactionOptions): Promise<TransactionResult>;
    claim(optionsIn?: TransactionOptions): Promise<TransactionResult<TransactionReceipt, ClaimTransaction>>;
    getAccount(idIn: UserAccountID): Promise<Account>;
    __iterActionsRaw(network: NetworkType, optionsIn?: IterOptions): AsyncIterable<RawAction>;
    __invoke(contract: AddressString, method: string, params: ReadonlyArray<ScriptBuilderParam | undefined>, paramsZipped: ReadonlyArray<readonly [string, Param | undefined]>, verify: boolean, optionsIn?: InvokeSendUnsafeReceiveTransactionOptions, sourceMaps?: SourceMaps): Promise<TransactionResult<RawInvokeReceipt, InvocationTransaction>>;
    __invokeSend(contract: AddressString, method: string, params: ReadonlyArray<ScriptBuilderParam | undefined>, paramsZipped: ReadonlyArray<readonly [string, Param | undefined]>, transfer: Transfer, optionsIn?: TransactionOptions, sourceMaps?: SourceMaps): Promise<TransactionResult<RawInvokeReceipt, InvocationTransaction>>;
    __invokeCompleteSend(contract: AddressString, method: string, params: ReadonlyArray<ScriptBuilderParam | undefined>, paramsZipped: ReadonlyArray<readonly [string, Param | undefined]>, hash: Hash256String, optionsIn?: TransactionOptions, sourceMaps?: SourceMaps): Promise<TransactionResult<RawInvokeReceipt, InvocationTransaction>>;
    __invokeRefundAssets(contract: AddressString, method: string, params: ReadonlyArray<ScriptBuilderParam | undefined>, paramsZipped: ReadonlyArray<readonly [string, Param | undefined]>, hash: Hash256String, optionsIn?: TransactionOptions, sourceMaps?: SourceMaps): Promise<TransactionResult<RawInvokeReceipt, InvocationTransaction>>;
    __invokeClaim(contract: AddressString, method: string, params: ReadonlyArray<ScriptBuilderParam | undefined>, paramsZipped: ReadonlyArray<readonly [string, Param | undefined]>, optionsIn?: TransactionOptions, sourceMaps?: SourceMaps): Promise<TransactionResult<TransactionReceipt, ClaimTransaction>>;
    __call(network: NetworkType, contract: AddressString, method: string, params: ReadonlyArray<ScriptBuilderParam | undefined>): Promise<RawCallReceipt>;
    reset(): void;
    protected getProvider(options?: TransactionOptions): TUserAccountProvider;
    protected getNetworkProvider(network: NetworkType): TUserAccountProvider;
    protected applyBeforeRelayHook(options: TransactionOptions): Promise<void>;
    protected addTransactionHooks<TTransactionResult extends TransactionResult>(res: Promise<TTransactionResult>): Promise<TTransactionResult>;
    protected getTransfersOptions(argsIn: readonly any[]): {
        readonly transfers: readonly Transfer[];
        readonly options: TransactionOptions;
    };
}