wallet.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2017 Cryptonomex, Inc., and contributors.
 *
 * The MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#pragma once
 
#include <fc/optional.hpp>
#include <graphene/chain/htlc_object.hpp>
#include <graphene/app/api.hpp>
#include <graphene/utilities/key_conversion.hpp>
#include "wallet_structs.hpp"
 
namespace fc
{
   void to_variant( const account_multi_index_type& accts, variant& vo, uint32_t max_depth );
   void from_variant( const variant &var, account_multi_index_type &vo, uint32_t max_depth );
}
 
namespace graphene { namespace wallet {
 
object* create_object( const variant& v );
 
class wallet_api
{
   public:
      // Variables
      fc::signal<void(bool)> lock_changed;
      std::shared_ptr<detail::wallet_api_impl> my;
 
      // Methods
      wallet_api( const wallet_data& initial_data, const fc::api<login_api>& rapi );
      virtual ~wallet_api();
 
      bool copy_wallet_file( const string& destination_filename )const;
 
      fc::ecc::private_key derive_private_key( const string& prefix_string, uint32_t sequence_number ) const;
 
      variant                           info()const;
      variant_object                    about() const;
      optional<signed_block_with_info>    get_block( uint32_t num )const;
      uint64_t                          get_account_count()const;
      vector<account_object>            list_my_accounts()const;
      map<string, account_id_type, std::less<>> list_accounts( const string& lowerbound, uint32_t limit )const;
      vector<asset>                     list_account_balances( const string& account_name_or_id )const;
      vector<extended_asset_object>     list_assets( const string& lowerbound, uint32_t limit )const;
      uint64_t get_asset_count()const;
 
      vector<operation_detail>  get_account_history( const string& account_name_or_id, uint32_t limit )const;
 
     vector<operation_detail>  get_relative_account_history( const string& account_name_or_id, uint32_t stop,
                                                             uint32_t limit, uint32_t start )const;
 
      full_account                      get_full_account( const string& name_or_id )const;
 
      vector<bucket_object> get_market_history( const string& symbol, const string& symbol2, uint32_t bucket,
                                                const time_point_sec& start, const time_point_sec& end )const;
 
      vector<limit_order_object>        get_account_limit_orders( const string& name_or_id,
                                            const string& base,
                                            const string& quote,
                                            uint32_t limit = 101,
                                            const optional<limit_order_id_type>& ostart_id = {},
                                            const optional<price>& ostart_price = optional<price>() )const;
 
      vector<limit_order_object>        get_limit_orders( const string& a, const string& b, uint32_t limit )const;
 
      vector<call_order_object>         get_call_orders( const string& asset_symbol_or_id, uint32_t limit )const;
 
      vector<force_settlement_object>   get_settle_orders( const string& a, uint32_t limit )const;
 
      vector<collateral_bid_object> get_collateral_bids( const string& asset_symbol_or_id, uint32_t limit = 100,
                                                         uint32_t start = 0 )const;
 
      global_property_object            get_global_properties() const;
 
      account_history_operation_detail get_account_history_by_operations( const string& account_name_or_id,
                                                                          const flat_set<uint16_t>& operation_types,
                                                                          uint32_t start, uint32_t limit )const;
 
      dynamic_global_property_object    get_dynamic_global_properties() const;
 
      account_object                    get_account( const string& account_name_or_id ) const;
 
      extended_asset_object             get_asset( const string& asset_symbol_or_id ) const;
 
      asset_bitasset_data_object        get_bitasset_data( const string& asset_symbol_or_id )const;
 
      optional<variant>                 get_htlc( const htlc_id_type& htlc_id ) const;
 
      account_id_type                   get_account_id( const string& account_name_or_id ) const;
 
      string                            get_account_name( const string& account_name_or_id ) const
      { return get_account( account_name_or_id ).name; }
 
      asset_id_type                     get_asset_id( const string& asset_symbol_or_id ) const;
 
      string                            get_asset_symbol( const string& asset_symbol_or_id ) const
      { return get_asset( asset_symbol_or_id ).symbol; }
 
      string                            get_asset_name( const string& asset_symbol_or_id ) const
      { return get_asset_symbol( asset_symbol_or_id ); }
 
      variant                           get_object( const object_id_type& id ) const;
 
      string                            get_wallet_filename() const;
 
      string                            get_private_key( const public_key_type& pubkey )const;
 
      transaction_handle_type begin_builder_transaction()const;
      void add_operation_to_builder_transaction( transaction_handle_type transaction_handle,
                                                 const operation& op )const;
      void replace_operation_in_builder_transaction( transaction_handle_type handle,
                                                     uint32_t operation_index,
                                                     const operation& new_op )const;
      asset set_fees_on_builder_transaction( transaction_handle_type handle,
                                             const string& fee_asset = GRAPHENE_SYMBOL )const;
      transaction preview_builder_transaction( transaction_handle_type handle )const;
      signed_transaction sign_builder_transaction( transaction_handle_type transaction_handle,
                                                   bool broadcast = true )const;
 
      signed_transaction sign_builder_transaction2( transaction_handle_type transaction_handle,
                                            const vector<public_key_type>& signing_keys = vector<public_key_type>(),
                                            bool broadcast = true )const;
 
      pair<transaction_id_type,signed_transaction> broadcast_transaction( const signed_transaction& tx )const;
 
      signed_transaction propose_builder_transaction(
          transaction_handle_type handle,
          const time_point_sec& expiration = time_point::now() + fc::minutes(1),
          uint32_t review_period_seconds = 0,
          bool broadcast = true
         )const;
 
      signed_transaction propose_builder_transaction2(
         transaction_handle_type handle,
         const string& account_name_or_id,
         const time_point_sec& expiration = time_point::now() + fc::minutes(1),
         uint32_t review_period_seconds = 0,
         bool broadcast = true
        )const;
 
      void remove_builder_transaction(transaction_handle_type handle)const;
 
      bool    is_new()const;
 
      bool    is_locked()const;
 
      void    lock()const;
 
      void    unlock( const string& password )const;
 
      void    set_password( const string& password )const;
 
      map<public_key_type, string> dump_private_keys()const;
 
      string  help()const;
 
      string  gethelp( const string& method )const;
 
      bool    load_wallet_file( const string& wallet_filename = "" )const;
 
      void    quit()const;
 
      void    save_wallet_file( const string& wallet_filename = "" )const;
 
      void    set_wallet_filename( const string& wallet_filename )const;
 
      brain_key_info suggest_brain_key()const;
 
     vector<brain_key_info> derive_owner_keys_from_brain_key( const string& brain_key,
                                                              uint32_t number_of_desired_keys = 1 ) const;
 
     bool is_public_key_registered( const string& public_key ) const;
 
      string serialize_transaction( const signed_transaction& tx ) const;
 
      bool import_key( const string& account_name_or_id, const string& wif_key )const;
 
      map<string, bool, std::less<>> import_accounts( const string& filename, const string& password )const;
 
      bool import_account_keys( const string& filename, const string& password,
                                const string& src_account_name, const string& dest_account_name )const;
 
      vector< signed_transaction > import_balance( const string& account_name_or_id, const vector<string>& wif_keys,
                                                   bool broadcast )const;
 
      string normalize_brain_key( const string& s ) const;
 
      signed_transaction register_account( const string& name,
                                           const public_key_type& owner,
                                           const public_key_type& active,
                                           const string& registrar_account,
                                           const string& referrer_account,
                                           uint32_t referrer_percent,
                                           bool broadcast = false )const;
 
      signed_transaction upgrade_account( const string& account_name_or_id, bool broadcast )const;
 
      signed_transaction create_account_with_brain_key( const string& brain_key,
                                                        const string& account_name,
                                                        const string& registrar_account,
                                                        const string& referrer_account,
                                                        bool broadcast = false )const;
 
      signed_transaction transfer( const string& from,
                                   const string& to,
                                   const string& amount,
                                   const string& asset_symbol_or_id,
                                   const string& memo,
                                   bool broadcast = false )const;
 
      pair<transaction_id_type,signed_transaction> transfer2( const string& from,
                                                              const string& to,
                                                              const string& amount,
                                                              const string& asset_symbol_or_id,
                                                              const string& memo ) const {
         auto trx = transfer( from, to, amount, asset_symbol_or_id, memo, true );
         return std::make_pair(trx.id(),trx);
      }
 
 
      transaction_id_type get_transaction_id( const signed_transaction& trx )const { return trx.id(); }
 
 
      memo_data sign_memo( const string& from, const string& to, const string& memo )const;
 
      string read_memo( const memo_data& memo )const;
 
 
      signed_message sign_message( const string& signer, const string& message )const;
 
      bool verify_message( const string& message, const string& account, int32_t block, const string& msg_time,
                           const fc::ecc::compact_signature& sig )const;
 
      bool verify_signed_message( const signed_message& message )const;
 
      bool verify_encapsulated_message( const string& message )const;
 
 
      bool                        set_key_label( const public_key_type& key, const string& label )const;
 
      string                      get_key_label( const public_key_type& key )const;
 
      public_key_type             create_blind_account( const string& label, const string& brain_key )const;
 
      vector<asset>                get_blind_balances( const string& key_or_label )const;
      map<string, public_key_type, std::less<>> get_blind_accounts()const;
      map<string, public_key_type, std::less<>> get_my_blind_accounts()const;
      public_key_type             get_public_key( const string& label )const;
 
      vector<blind_receipt> blind_history( const string& key_or_account )const;
 
      blind_receipt receive_blind_transfer( const string& confirmation_receipt,
                                            const string& opt_from,
                                            const string& opt_memo )const;
 
      blind_confirmation transfer_to_blind( const string& from_account_name_or_id,
                                            const string& asset_symbol_or_id,
                                            const vector<pair<string, string>>& to_amounts,
                                            bool broadcast = false )const;
 
      blind_confirmation transfer_from_blind( const string& from_blind_account_key_or_label,
                                              const string& to_account_name_or_id,
                                              const string& amount,
                                              const string& asset_symbol_or_id,
                                              bool broadcast = false )const;
 
      blind_confirmation blind_transfer( const string& from_key_or_label,
                                         const string& to_key_or_label,
                                         const string& amount,
                                         const string& symbol_or_id,
                                         bool broadcast = false )const;
 
      signed_transaction sell_asset( const string& seller_account,
                                     const string& amount_to_sell,
                                     const string& symbol_or_id_to_sell,
                                     const string& min_to_receive,
                                     const string& symbol_or_id_to_receive,
                                     uint32_t timeout_sec = 0,
                                     bool     fill_or_kill = false,
                                     bool     broadcast = false )const;
 
      signed_transaction borrow_asset( const string& borrower, const string& amount_to_borrow,
                                       const string& asset_symbol_or_id,
                                       const string& amount_of_collateral, bool broadcast = false )const;
 
      signed_transaction borrow_asset_ext( const string& borrower, const string& amount_to_borrow,
                                           const string& asset_symbol_or_id,
                                           const string& amount_of_collateral,
                                           const call_order_update_operation::extensions_type& extensions,
                                           bool broadcast = false )const;
 
      signed_transaction cancel_order( const limit_order_id_type& order_id, bool broadcast = false ) const;
 
      signed_transaction create_asset( const string& issuer,
                                       const string& symbol,
                                       uint8_t precision,
                                       const asset_options& common,
                                       const optional<bitasset_options>& bitasset_opts,
                                       bool broadcast = false )const;
 
      signed_transaction issue_asset( const string& to_account, const string& amount,
                                      const string& symbol_or_id,
                                      const string& memo,
                                      bool broadcast = false )const;
 
      signed_transaction update_asset( const string& symbol_or_id,
                                       const optional<string>& new_issuer,
                                       const asset_options& new_options,
                                       bool broadcast = false )const;
 
      signed_transaction update_asset_issuer( const string& symbol_or_id,
                                              const string& new_issuer,
                                              bool broadcast = false )const;
 
      signed_transaction update_bitasset( const string& symbol_or_id,
                                          const bitasset_options& new_options,
                                          bool broadcast = false )const;
 
      signed_transaction update_asset_feed_producers( const string& symbol_or_id,
                                                      const flat_set<string>& new_feed_producers,
                                                      bool broadcast = false )const;
 
      signed_transaction publish_asset_feed( const string& publishing_account,
                                             const string& symbol_or_id,
                                             const price_feed& feed,
                                             bool broadcast = false )const;
 
      signed_transaction fund_asset_fee_pool( const string& from,
                                              const string& symbol_or_id,
                                              const string& amount,
                                              bool broadcast = false )const;
 
      signed_transaction claim_asset_fee_pool( const string& symbol_or_id,
                                               const string& amount,
                                               bool broadcast = false )const;
 
      signed_transaction reserve_asset( const string& from,
                                        const string& amount,
                                        const string& symbol_or_id,
                                        bool broadcast = false )const;
 
      signed_transaction global_settle_asset( const string& symbol_or_id,
                                              const price& settle_price,
                                              bool broadcast = false )const;
 
      signed_transaction settle_asset( const string& account_to_settle,
                                       const string& amount_to_settle,
                                       const string& symbol_or_id,
                                       bool broadcast = false )const;
 
      signed_transaction bid_collateral( const string& bidder, const string& debt_amount,
                                         const string& debt_symbol_or_id,
                                         const string& additional_collateral, bool broadcast = false )const;
 
      signed_transaction whitelist_account( const string& authorizing_account,
                                            const string& account_to_list,
                                            account_whitelist_operation::account_listing new_listing_status,
                                            bool broadcast = false )const;
 
      signed_transaction create_committee_member( const string& owner_account,
                                                  const string& url,
                                                  bool broadcast = false )const;
 
      map<string, witness_id_type, std::less<>> list_witnesses( const string& lowerbound, uint32_t limit )const;
 
      map<string, committee_member_id_type, std::less<>> list_committee_members(
            const string& lowerbound, uint32_t limit )const;
 
      witness_object get_witness( const string& owner_account )const;
 
      committee_member_object get_committee_member( const string& owner_account )const;
 
      signed_transaction create_witness( const string& owner_account,
                                         const string& url,
                                         bool broadcast = false )const;
 
      signed_transaction update_witness( const string& witness_name,
                                         const string& url,
                                         const string& block_signing_key,
                                         bool broadcast = false )const;
 
 
      signed_transaction create_worker(
         const string& owner_account,
         const time_point_sec& work_begin_date,
         const time_point_sec& work_end_date,
         const share_type& daily_pay,
         const string& name,
         const string& url,
         const variant& worker_settings,
         bool broadcast = false
         )const;
 
      signed_transaction update_worker_votes(
         const string& account,
         const worker_vote_delta& delta,
         bool broadcast = false
         )const;
 
      signed_transaction htlc_create( const string& source, const string& destination,
            const string& amount, const string& asset_symbol_or_id, const string& hash_algorithm,
            const string& preimage_hash, uint32_t preimage_size,
            uint32_t claim_period_seconds, const string& memo, bool broadcast = false ) const;
 
      /****
       * Update a hashed time lock contract
       *
       * @param htlc_id The object identifier of the HTLC on the blockchain
       * @param issuer Who is performing this operation (and paying the fee)
       * @param preimage the preimage that should evaluate to the preimage_hash
       * @return the signed transaction
       */
      signed_transaction htlc_redeem( const htlc_id_type& htlc_id, const string& issuer, const string& preimage,
            bool broadcast = false ) const;
 
      /*****
       * Increase the timelock on an existing HTLC
       *
       * @param htlc_id The object identifier of the HTLC on the blockchain
       * @param issuer Who is performing this operation (and paying the fee)
       * @param seconds_to_add how many seconds to add to the existing timelock
       * @param broadcast true to broadcast to the network
       * @return the signed transaction
       */
      signed_transaction htlc_extend( const htlc_id_type& htlc_id, const string& issuer, uint32_t seconds_to_add,
            bool broadcast = false ) const;
 
      vector< vesting_balance_object_with_info > get_vesting_balances( const string& account_name )const;
 
      signed_transaction withdraw_vesting(
         const string& witness_name,
         const string& amount,
         const string& asset_symbol_or_id,
         bool broadcast = false )const;
 
      signed_transaction vote_for_committee_member( const string& voting_account,
                                                    const string& committee_member,
                                                    bool approve,
                                                    bool broadcast = false )const;
 
      signed_transaction vote_for_witness( const string& voting_account,
                                           const string& witness,
                                           bool approve,
                                           bool broadcast = false )const;
 
      signed_transaction set_voting_proxy( const string& account_to_modify,
                                           const optional<string>& voting_account,
                                           bool broadcast = false )const;
 
      signed_transaction set_desired_witness_and_committee_member_count( const string& account_to_modify,
                                                                uint16_t desired_number_of_witnesses,
                                                                uint16_t desired_number_of_committee_members,
                                                                bool broadcast = false )const;
 
      signed_transaction sign_transaction( const signed_transaction& tx, bool broadcast = false )const;
 
      signed_transaction sign_transaction2( const signed_transaction& tx,
                                            const vector<public_key_type>& signing_keys = vector<public_key_type>(),
                                            bool broadcast = true )const;
 
 
      flat_set<public_key_type> get_transaction_signers( const signed_transaction& tx ) const;
 
      vector<flat_set<account_id_type>> get_key_references( const vector<public_key_type>& keys ) const;
 
      operation get_prototype_operation( const string& operation_type )const;
 
      signed_transaction propose_parameter_change(
         const string& proposing_account,
         const time_point_sec& expiration_time,
         const variant_object& changed_values,
         bool broadcast = false )const;
 
      signed_transaction propose_fee_change(
         const string& proposing_account,
         const time_point_sec& expiration_time,
         const variant_object& changed_values,
         bool broadcast = false )const;
 
      signed_transaction approve_proposal(
         const string& fee_paying_account,
         const string& proposal_id,
         const approval_delta& delta,
         bool broadcast /* = false */
         )const;
 
      order_book get_order_book( const string& base, const string& quote, uint32_t limit = 50 )const;
 
      signed_transaction add_transaction_signature( const signed_transaction& tx,
                                                    bool broadcast = false )const;
 
      void dbg_make_uia( const string& creator, const string& symbol )const;
      void dbg_make_mia( const string& creator, const string& symbol )const;
      void dbg_push_blocks( const string& src_filename, uint32_t count )const;
      void dbg_generate_blocks( const string& debug_wif_key, uint32_t count )const;
      void dbg_stream_json_objects( const string& filename )const;
      void dbg_update_object( const variant_object& update )const;
 
      void flood_network( const string& prefix, uint32_t number_of_transactions )const;
 
      void network_add_nodes( const vector<string>& nodes )const;
      vector< variant > network_get_connected_peers()const;
 
      blind_confirmation blind_transfer_help( const string& from_key_or_label,
                                              const string& to_key_or_label,
                                              const string& amount,
                                              const string& symbol,
                                              bool broadcast = false,
                                              bool to_temp = false )const;
 
 
      std::map< string, std::function< string( const variant&, const fc::variants& ) >, std::less<> >
            get_result_formatters() const;
 
      void encrypt_keys()const;
 
      signed_transaction account_store_map( const string& account, const string& catalog, bool is_to_remove,
            const flat_map<string, optional<string>>& key_values, bool broadcast )const;
 
      vector<account_storage_object> get_account_storage( const string& account, const string& catalog )const;
 
};
 
} }
 
extern template class fc::api<graphene::wallet::wallet_api>;
 
FC_API( graphene::wallet::wallet_api,
        (help)
        (gethelp)
        (info)
        (about)
        (begin_builder_transaction)
        (add_operation_to_builder_transaction)
        (replace_operation_in_builder_transaction)
        (set_fees_on_builder_transaction)
        (preview_builder_transaction)
        (sign_builder_transaction)
        (sign_builder_transaction2)
        (broadcast_transaction)
        (propose_builder_transaction)
        (propose_builder_transaction2)
        (remove_builder_transaction)
        (is_new)
        (is_locked)
        (lock)(unlock)(set_password)
        (dump_private_keys)
        (list_my_accounts)
        (list_accounts)
        (list_account_balances)
        (list_assets)
        (get_asset_count)
        (import_key)
        (import_accounts)
        (import_account_keys)
        (import_balance)
        (suggest_brain_key)
        (derive_owner_keys_from_brain_key)
        (register_account)
        (upgrade_account)
        (create_account_with_brain_key)
        (sell_asset)
        (borrow_asset)
        (borrow_asset_ext)
        (cancel_order)
        (transfer)
        (transfer2)
        (get_transaction_id)
        (create_asset)
        (update_asset)
        (update_asset_issuer)
        (update_bitasset)
        (get_htlc)
        (update_asset_feed_producers)
        (publish_asset_feed)
        (issue_asset)
        (get_asset)
        (get_asset_id)
        (get_asset_name)
        (get_asset_symbol)
        (get_bitasset_data)
        (fund_asset_fee_pool)
        (claim_asset_fee_pool)
        (reserve_asset)
        (global_settle_asset)
        (settle_asset)
        (bid_collateral)
        (whitelist_account)
        (create_committee_member)
        (get_witness)
        (get_committee_member)
        (list_witnesses)
        (list_committee_members)
        (create_witness)
        (update_witness)
        (create_worker)
        (update_worker_votes)
        (htlc_create)
        (htlc_redeem)
        (htlc_extend)
        (get_vesting_balances)
        (withdraw_vesting)
        (vote_for_committee_member)
        (vote_for_witness)
        (set_voting_proxy)
        (set_desired_witness_and_committee_member_count)
        (get_account)
        (get_account_id)
        (get_account_name)
        (get_block)
        (get_account_count)
        (get_account_history)
        (get_relative_account_history)
        (get_account_history_by_operations)
        (get_collateral_bids)
        (is_public_key_registered)
        (get_full_account)
        (get_market_history)
        (get_global_properties)
        (get_dynamic_global_properties)
        (get_object)
        (get_private_key)
        (load_wallet_file)
        (normalize_brain_key)
        (get_account_limit_orders)
        (get_limit_orders)
        (get_call_orders)
        (get_settle_orders)
        (save_wallet_file)
        (serialize_transaction)
        (sign_transaction)
        (sign_transaction2)
        (add_transaction_signature)
        (get_transaction_signers)
        (get_key_references)
        (get_prototype_operation)
        (propose_parameter_change)
        (propose_fee_change)
        (approve_proposal)
        (dbg_make_uia)
        (dbg_make_mia)
        (dbg_push_blocks)
        (dbg_generate_blocks)
        (dbg_stream_json_objects)
        (dbg_update_object)
        (flood_network)
        (network_add_nodes)
        (network_get_connected_peers)
        (sign_memo)
        (read_memo)
        (sign_message)
        (verify_message)
        (verify_signed_message)
        (verify_encapsulated_message)
        (set_key_label)
        (get_key_label)
        (get_public_key)
        (get_blind_accounts)
        (get_my_blind_accounts)
        (get_blind_balances)
        (create_blind_account)
        (transfer_to_blind)
        (transfer_from_blind)
        (blind_transfer)
        (blind_history)
        (receive_blind_transfer)
        (get_order_book)
        (account_store_map)
        (get_account_storage)
        (quit)
      )