/// <reference types="node" />
import { TransactionBuilder } from './TransactionBuilder';
import GXRPC from './GXRPC';
import * as types from '../types/types';
/**
 * This callback is displayed as a global member.
 * @callback signatureProvider
 * @param transaction {TransactionBuilder}
 * @param chain_id {String} - Chain Id
 */
/**
 * GXClient Class
 */
declare class GXClient {
    private_key: string;
    account_id_or_name: string;
    account_id: string;
    account: string;
    connected: boolean;
    chain_id: string;
    witness: string;
    signProvider: (transaction: TransactionBuilder, chain_id: string) => Promise<Buffer>;
    nonceProvider: () => string;
    host: string;
    rpc: GXRPC;
    isTaskStarted: boolean;
    latestBlock: number;
    /**
     *
     * @param {String} private_key - private key
     * @param {String} account_id_or_name - e.g: '1.2.44'|'gxcaccount'
     * @param {String} entry_point - entry point network address
     * @param {signatureProvider} signProvider
     */
    constructor(private_key: string, account_id_or_name: string, entry_point?: string, signProvider?: (transaction: TransactionBuilder, chain_id: string) => Promise<Buffer>, nonceProvider?: () => string);
    /**
     * generate key pair locally
     * @returns {{brainKey: *, privateKey: *, publicKey: *}}
     */
    generateKey(brainKey?: string): {
        brainKey: string;
        privateKey: string;
        publicKey: string;
    };
    /**
     * export public key from private key
     * @param privateKey {String}
     * @returns {String}
     */
    privateToPublic(privateKey: string): string;
    /**
     * check if public key is valid
     * @param publicKey {String}
     * @returns {boolean}
     */
    isValidPublic(publicKey: string): boolean;
    /**
     * check if private key is valid
     * @param privateKey {String}
     * @returns {boolean}
     */
    isValidPrivate(privateKey: string): boolean;
    /**
     * register an account by faucet
     * @param account {String} - Account name
     * @param activeKey {String} - Public Key for account operator
     * @param ownerKey {String} - Public Key for account owner
     * @param memoKey {String} - Public Key for memo
     * @param faucet {String} - faucet url
     * @returns {Promise<any>}
     * @example
     * curl ‘https://opengateway.gxb.io/account/register' -H 'Content-type: application/json' -H 'Accept: application/json’ -d ‘{“account”:{“name”:”gxb123”,”owner_key”:”GXC5wQ4RtjouyobBV57vTx7boBj4Kt3BUxZEMsUD3TU369d3C9DqZ”,”active_key”:”GXC7cPVyB9F1Pfiaaxw4nY3xKADo5993hEsTjFs294LKwhqsUrFZs”,”memo_key”:”GXC7cPVyB9F1Pfiaaxw4nY3xKADo5993hEsTjFs294LKwhqsUrFZs”,”refcode”:null,”referrer”:null}}’
     */
    register(account: string, activeKey: string, ownerKey: string, memoKey: string, faucet?: string): Promise<unknown>;
    /**
     * get object by id
     * @param object_id {String} - e.g: '1.2.3'
     * @returns {Request|PromiseLike<T>|Promise<T>}
     */
    getObject(object_id: string): Promise<any>;
    /**
     * get objects
     * @param {String[]} object_ids
     * @returns {Request|PromiseLike<T>|Promise<T>}
     */
    getObjects(object_ids: string[]): Promise<any[]>;
    /**
     * get account info by account name
     * @param account_name {String}
     * @returns {Promise<any>}
     */
    getAccount(account_name: string): Promise<{
        id: string;
        membership_expiration_date: string;
        merchant_expiration_date: string;
        datasource_expiration_date: string;
        data_transaction_member_expiration_date: string;
        registrar: string;
        referrer: string;
        lifetime_referrer: string;
        merchant_auth_referrer: string;
        datasource_auth_referrer: string;
        network_fee_percentage: number;
        lifetime_referrer_fee_percentage: number;
        referrer_rewards_percentage: number;
        name: string;
        vm_type: string;
        vm_version: string;
        code: string;
        code_version: string;
        abi: {
            version: string;
            types: any[];
            structs: any[];
            actions: any[];
            tables: any[];
            error_messages: any[];
            abi_extensions: any[];
        };
        owner: {
            weight_threshold: number;
            account_auths: any[];
            key_auths: [string, number][];
            address_auths: any[];
        };
        active: {
            weight_threshold: number;
            account_auths: any[];
            key_auths: [string, number][];
            address_auths: any[];
        };
        options: {
            memo_key: string;
            voting_account: string;
            num_witness: number;
            num_committee: number;
            votes: any[];
            extensions: any[];
        };
        statistics: string;
        whitelisting_accounts: any[];
        blacklisting_accounts: any[];
        whitelisted_accounts: any[];
        blacklisted_accounts: any[];
        cashback_vb: string;
        owner_special_authority: any[];
        active_special_authority: any[];
        top_n_control_flags: number;
    }>;
    /**
     * get current blockchain id
     * @returns {Request|PromiseLike<T>|Promise<T>}
     */
    getChainID(): Promise<string>;
    /**
     * get dynamic global properties
     * @returns {Request|PromiseLike<T>|Promise<T>}
     */
    getDynamicGlobalProperties(): Promise<{
        id: string;
        head_block_number: number;
        head_block_id: string;
        time: string;
        current_witness: string;
        next_maintenance_time: string;
        last_budget_time: string;
        witness_budget: number;
        accounts_registered_this_interval: number;
        recently_missed_count: number;
        current_aslot: number;
        recent_slots_filled: string;
        dynamic_flags: number;
        last_irreversible_block_num: number;
    }>;
    /**
     * get account_ids by public key
     * @param publicKey {String}
     * @returns {Request|PromiseLike<T>|Promise<T>}
     */
    getAccountByPublicKey(publicKey: string): Promise<{
        amount: string;
        asset_id: string;
    }[]>;
    /**
     * get account balances by account name
     * @param account_name {String}
     * @returns {Promise<any>}
     */
    getAccountBalances(account_name: string): Promise<{
        amount: string;
        asset_id: string;
    }[]>;
    /**
     * get asset info by symbol
     * @param symbol {String} - e.g: 'GXC'
     * @returns {Promise<any>}
     */
    getAsset(symbol: string): Promise<{
        id: string;
        symbol: string;
        precision: number;
        issuer: string;
        options: {
            max_supply: string;
            market_fee_percent: number;
            max_market_fee: number;
            issuer_permissions: number;
            flags: number;
            core_exchange_rate: {
                base: {
                    amount: number;
                    asset_id: string;
                };
                quote: {
                    amount: number;
                    asset_id: string;
                };
            };
            whitelist_authorities: any[];
            blacklist_authorities: any[];
            whitelist_markets: any[];
            blacklist_markets: any[];
            description: string;
            extensions: any[];
        };
        dynamic_asset_data_id: string;
    }>;
    /**
     * get block by block height
     * @param blockHeight {Number} - block height
     * @returns {Promise<any>}
     */
    getBlock(blockHeight: number): Promise<{
        previous: string;
        timestamp: string;
        witness: string;
        transaction_merkle_root: string;
        extensions: any[];
        witness_signature: string;
        transactions: types.signed_transaction[];
        block_id: string;
        signing_key: string;
        transaction_ids: string[];
    }>;
    /**
     * send transfer request to witness node
     * @param to {String} - to account name
     * @param memo {String|Function} - memo
     * @param amount_asset {String} - e.g: '1 GXC'
     * @param broadcast {Boolean}
     * @param options {Object}
     * @param options.fee_symbol {String} - e.g: 'GXC'
     * @returns {Promise<any>}
     */
    transfer(to: string, memo: string | ((from: string, to: string) => Promise<types.memo_data>), amount_asset: string, broadcast?: false, options?: {
        fee_symbol?: string;
    }): SerializeTransactionResult;
    transfer(to: string, memo: string | ((from: string, to: string) => Promise<types.memo_data>), amount_asset: string, broadcast?: true, options?: {
        fee_symbol?: string;
    }): BroadcaseTransactionResult;
    transfer(to: string, memo: string | ((from: string, to: string) => Promise<types.memo_data>), amount_asset: string, broadcast?: boolean, options?: {
        fee_symbol?: string;
    }): ProcessTransactionResult;
    /**
     * get staking programs
     */
    getStakingPrograms(): Promise<[
        string,
        {
            staking_days: number;
            weight: number;
            is_valid: boolean;
        }
    ][]>;
    /**
     * @param {String} to - trust node account name
     * @param {Number} amount - the amount of GXC to staking
     * @param {String} program_id - the staking program id
     * @param {Object} options
     * @param {String} options.fee_symbol  - e.g: 'GXC'
     * @returns {Promise<any>}
     */
    createStaking(to: string, amount: number, program_id: string, broadcast?: false, options?: {
        fee_symbol?: string;
    }): SerializeTransactionResult;
    createStaking(to: string, amount: number, program_id: string, broadcast?: true, options?: {
        fee_symbol?: string;
    }): BroadcaseTransactionResult;
    createStaking(to: string, amount: number, program_id: string, broadcast?: boolean, options?: {
        fee_symbol?: string;
    }): ProcessTransactionResult;
    /**
     * @param {String} to - trust node account name
     * @param {String} staking_id - the staking id
     * @param {Object} options
     * @param {String} options.fee_symbol  - e.g: 'GXC'
     * @returns {Promise<any>}
     */
    updateStaking(to: string, staking_id: string, broadcast?: false, options?: {
        fee_symbol?: string;
    }): SerializeTransactionResult;
    updateStaking(to: string, staking_id: string, broadcast?: true, options?: {
        fee_symbol?: string;
    }): BroadcaseTransactionResult;
    updateStaking(to: string, staking_id: string, broadcast?: boolean, options?: {
        fee_symbol?: string;
    }): ProcessTransactionResult;
    /**
     * @param {String} staking_id - the staking id
     * @param {Object} options
     * @param {String} options.fee_symbol  - e.g: 'GXC'
     * @returns {Promise<any>}
     */
    claimStaking(staking_id: string, broadcast?: false, options?: {
        fee_symbol?: string;
    }): SerializeTransactionResult;
    claimStaking(staking_id: string, broadcast?: true, options?: {
        fee_symbol?: string;
    }): BroadcaseTransactionResult;
    claimStaking(staking_id: string, broadcast?: boolean, options?: {
        fee_symbol?: string;
    }): ProcessTransactionResult;
    /**
     * @param {String} vesting_id - the vesting id
     * @param {Number} availableAmount - the amount of available withdraw
     * @param {Object} options
     * @param {String} options.fee_symbol  - e.g: 'GXC'
     * @returns {Promise<any>}
     */
    withdrawVestingBalance(vesting_id: string, availableAmount: number, broadcast?: false, options?: {
        fee_symbol?: string;
    }): SerializeTransactionResult;
    withdrawVestingBalance(vesting_id: string, availableAmount: number, broadcast?: true, options?: {
        fee_symbol?: string;
    }): BroadcaseTransactionResult;
    withdrawVestingBalance(vesting_id: string, availableAmount: number, broadcast?: boolean, options?: {
        fee_symbol?: string;
    }): ProcessTransactionResult;
    /**
     * get contract abi by contract_name
     * @param contract_name {String}
     * @returns {Promise<any>}
     */
    getContractABI(contract_name: string): Promise<any>;
    /**
     * get contract table by contract_name
     * @param contract_name {String}
     * @returns {Promise<any>}
     */
    getContractTable(contract_name: string): Promise<any>;
    /**
     * fetch contract table record by contract_name and table_name
     * @param contract_name {String}
     * @param table_name {String}
     * @param start {Number}
     * @param limit {Number}
     * @returns {Promise<any>}
     */
    getTableObjects(contract_name: string, table_name: string, start?: number, limit?: number): Promise<any>;
    /**
     * fetch contract table record by contract_name and table_name
     * @param contract_name
     * @param table_name
     * @param lower_bound
     * @param upper_bound
     * @param limit
     * @param reverse
     * @returns {*}
     */
    getTableObjectsEX(contract_name: string, table_name: string, lower_bound?: number, upper_bound?: number, limit?: number, reverse?: boolean): Promise<any>;
    /**
     * deploy smart contract
     * @param contract_name {String}
     * @param code {String} - bytecode
     * @param abi {Object} - abi object
     * @param vm_type {String}
     * @param vm_version {String}
     * @param broadcast {Boolean}
     * @param options {Object}
     * @param options.fee_symbol {String} - e.g: 'GXC'
     * @returns {Promise<any>}
     */
    createContract(contract_name: string, code: string, abi: types.abi_def, vm_type?: string, vm_version?: string, broadcast?: false, options?: {
        fee_symbol?: string;
    }): SerializeTransactionResult;
    createContract(contract_name: string, code: string, abi: types.abi_def, vm_type?: string, vm_version?: string, broadcast?: true, options?: {
        fee_symbol?: string;
    }): BroadcaseTransactionResult;
    createContract(contract_name: string, code: string, abi: types.abi_def, vm_type?: string, vm_version?: string, broadcast?: boolean, options?: {
        fee_symbol?: string;
    }): ProcessTransactionResult;
    /**
     * update smart contract
     * @param contract_name {String}
     * @param newOwner {String} - new owner account name
     * @param code {String} - same to createContract
     * @param abi {Object} - same to createContract
     * @param broadcast {Boolean}
     * @param options {Object}
     * @param options.fee_symbol {String} - e.g: 'GXC'
     * @returns {Request|PromiseLike<T>|Promise<T>}
     */
    updateContract(contract_name: string, newOwner: string, code: string, abi: types.abi_def, broadcast?: false, options?: {
        fee_symbol?: string;
    }): SerializeTransactionResult;
    updateContract(contract_name: string, newOwner: string, code: string, abi: types.abi_def, broadcast?: true, options?: {
        fee_symbol?: string;
    }): BroadcaseTransactionResult;
    updateContract(contract_name: string, newOwner: string, code: string, abi: types.abi_def, broadcast?: boolean, options?: {
        fee_symbol?: string;
    }): ProcessTransactionResult;
    /**
     * call smart contract method
     * @param contract_name {String} - The name of the smart contract
     * @param method_name {String} - Method/Action name
     * @param params {JSON} - parameters
     * @param amount_asset {String} - same to transfer eg."100 GXC"
     * @param broadcast {Boolean} - Broadcast the transaction or just return a serialized transaction
     * @param options {Object}
     * @param options.fee_symbol {String} - e.g: 'GXC'
     * @returns {Promise<any>}
     */
    callContract(contract_name: string, method_name: string, params: any, amount_asset: string, broadcast?: false, options?: {
        fee_symbol?: string;
    }): SerializeTransactionResult;
    callContract(contract_name: string, method_name: string, params: any, amount_asset: string, broadcast?: true, options?: {
        fee_symbol?: string;
    }): BroadcaseTransactionResult;
    callContract(contract_name: string, method_name: string, params: any, amount_asset: string, broadcast?: boolean, options?: {
        fee_symbol?: string;
    }): ProcessTransactionResult;
    /**
     * vote for accounts - Deprecated
     * @param accounts {String[]} - An array of account_names to vote
     * @param broadcast {Boolean}
     * @param options {Object}
     * @param options.fee_symbol {String} - e.g: 'GXC'
     * @params options.append {bool} - default: true
     * @returns {Promise<any>}
     */
    vote(accounts?: string[], broadcast?: false, options?: {
        fee_symbol?: string;
        append?: boolean;
    }): SerializeTransactionResult;
    vote(accounts?: string[], broadcast?: true, options?: {
        fee_symbol?: string;
        append?: boolean;
    }): BroadcaseTransactionResult;
    vote(accounts?: string[], broadcast?: boolean, options?: {
        fee_symbol?: string;
        append?: boolean;
    }): ProcessTransactionResult;
    /**
     * Since committee account is controled by multiple account
     * so broadcast = false
     * will use create_proposal to send this transaction
     * @param {Object} new_params Same structure as getObject('2.0.0').parameters
     * @param {Object} options
     */
    proposeUpdateGPO(new_params: any, broadcast?: false, options?: {
        fee_symbol?: string;
        append?: boolean;
    }): SerializeTransactionResult;
    proposeUpdateGPO(new_params: any, broadcast?: true, options?: {
        fee_symbol?: string;
        append?: boolean;
    }): BroadcaseTransactionResult;
    proposeUpdateGPO(new_params: any, broadcast?: boolean, options?: {
        fee_symbol?: string;
        append?: boolean;
    }): ProcessTransactionResult;
    /**
     * create a proposal
     * @param {Array} ops
     * @param {Date} expiration_time
     * @param {Number} review_period_seconds
     * @param {Boolean} broadcast
     * @param {Object} options
     */
    createProposal(ops: types.op_wrapper[], expiration_time: number | string, review_period_seconds?: number, broadcast?: false, options?: {
        fee_symbol?: string;
    }): SerializeTransactionResult;
    createProposal(ops: types.op_wrapper[], expiration_time: number | string, review_period_seconds?: number, broadcast?: true, options?: {
        fee_symbol?: string;
    }): BroadcaseTransactionResult;
    createProposal(ops: types.op_wrapper[], expiration_time: number | string, review_period_seconds?: number, broadcast?: boolean, options?: {
        fee_symbol?: string;
    }): ProcessTransactionResult;
    /**
     * calculate fee of a operation
     * @param operation {Object}
     * @param feeAssetId {String}
     * @returns {Promise<any>}
     */
    fee(operation: types.operation, feeAssetId?: string): Promise<{
        amount: number;
        asset_id: string;
    }[]>;
    /**
     * accurate multiply - fix the accurate issue of javascript
     * @private
     * @param arg1
     * @param arg2
     * @returns {number}
     */
    _accMult(arg1: any, arg2: any): number;
    /**
     *
     * @private
     */
    _connect(): Promise<void>;
    /**
     *
     * @private
     */
    _query(method: any, params: any): Promise<any>;
    /**
     * WARNING: This function have to be used after connected
     * @returns {*}
     * @private
     */
    _createTransaction(): any;
    /**
     * process transaction
     * @private
     * @param tr
     * @param broadcast
     * @returns {Promise<any[]>}
     */
    _processTransaction(tr: any, broadcast: true, useRemoteSerializer?: boolean): BroadcaseTransactionResult;
    _processTransaction(tr: any, broadcast: false, useRemoteSerializer?: boolean): SerializeTransactionResult;
    _processTransaction(tr: any, broadcast: boolean, useRemoteSerializer?: boolean): ProcessTransactionResult;
    /**
     * broadcast transaction
     * @param {TransactionBuilder} tx
     * @returns {Promise<any>}
     */
    broadcast(tx: types.signed_transaction): Promise<string[]>;
}
declare type BroadcaseTransactionResult = Promise<string[]>;
declare type SerializeTransactionResult = Promise<types.signed_transaction>;
declare type ProcessTransactionResult = Promise<types.signed_transaction | string[]>;
export default GXClient;