Merge release to master for 3.1.0

CMakeLists.txt

@@ -23,7 +23,7 @@ endif()
 list( APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules" )
 
 set(CMAKE_EXPORT_COMPILE_COMMANDS "ON")
-set(GRAPHENE_EGENESIS_JSON "${CMAKE_CURRENT_SOURCE_DIR}/genesis.json" )
+set(GRAPHENE_EGENESIS_JSON "${CMAKE_CURRENT_SOURCE_DIR}/libraries/egenesis/genesis.json" )
 
 #set (ENABLE_INSTALLER 1)
 #set (USE_PCH 1)
@@ -80,6 +80,7 @@ if( WIN32 )
     set(CRYPTO_LIB)
 
     if( MSVC )
+	add_definitions(-DWIN32_LEAN_AND_MEAN)
         #looks like this flag can have different default on some machines.
         SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} /SAFESEH:NO")
         SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SAFESEH:NO")

libraries/app/api.cpp

@@ -317,7 +317,8 @@ namespace graphene { namespace app {
     {
        FC_ASSERT( _app.chain_database() );
        const auto& db = *_app.chain_database();
-       FC_ASSERT( limit <= 100 );
+       uint64_t api_limit_get_account_history=_app.get_options().api_limit_get_account_history;
+       FC_ASSERT( limit <= api_limit_get_account_history );
        vector<operation_history_object> result;
        account_id_type account;
        try {
@@ -353,7 +354,8 @@ namespace graphene { namespace app {
     {
        FC_ASSERT( _app.chain_database() );
        const auto& db = *_app.chain_database();
-       FC_ASSERT( limit <= 100 );
+       uint64_t api_limit_get_account_history_operations=_app.get_options().api_limit_get_account_history_operations;
+       FC_ASSERT(limit <= api_limit_get_account_history_operations);
        vector<operation_history_object> result;
        account_id_type account;
        try {
@@ -392,7 +394,8 @@ namespace graphene { namespace app {
     {
        FC_ASSERT( _app.chain_database() );
        const auto& db = *_app.chain_database();
-       FC_ASSERT(limit <= 100);
+       uint64_t api_limit_get_relative_account_history=_app.get_options().api_limit_get_relative_account_history;
+       FC_ASSERT(limit <= api_limit_get_relative_account_history);
        vector<operation_history_object> result;
        account_id_type account;
        try {
@@ -431,7 +434,8 @@ namespace graphene { namespace app {
 
     history_operation_detail history_api::get_account_history_by_operations(const std::string account_id_or_name, vector<uint16_t> operation_types, uint32_t start, unsigned limit)
     {
-       FC_ASSERT(limit <= 100);
+       uint64_t api_limit_get_account_history_by_operations=_app.get_options().api_limit_get_account_history_by_operations;
+       FC_ASSERT(limit <= api_limit_get_account_history_by_operations);
        history_operation_detail result;
        vector<operation_history_object> objs = get_relative_account_history(account_id_or_name, start, limit, limit + start - 1);
        std::for_each(objs.begin(), objs.end(), [&](const operation_history_object &o) {
@@ -530,16 +534,16 @@ namespace graphene { namespace app {
 
     // asset_api
     asset_api::asset_api(graphene::app::application& app) :
-         _db( *app.chain_database()), 
-         database_api( std::ref(*app.chain_database()), &(app.get_options()) 
+         _app(app),
+         _db( *app.chain_database()),
+         database_api( std::ref(*app.chain_database()), &(app.get_options())
          ) { }
     asset_api::~asset_api() { }
 
     vector<account_asset_balance> asset_api::get_asset_holders( std::string asset, uint32_t start, uint32_t limit ) const {
-      FC_ASSERT(limit <= 100);
-
+      uint64_t api_limit_get_asset_holders=_app.get_options().api_limit_get_asset_holders;
+      FC_ASSERT(limit <= api_limit_get_asset_holders);
       asset_id_type asset_id = database_api.get_asset_id_from_string( asset );
-
       const auto& bal_idx = _db.get_index_type< account_balance_index >().indices().get< by_asset_balance >();
       auto range = bal_idx.equal_range( boost::make_tuple( asset_id ) );
 
@@ -571,7 +575,6 @@ namespace graphene { namespace app {
     }
     // get number of asset holders.
     int asset_api::get_asset_holders_count( std::string asset ) const {
-
       const auto& bal_idx = _db.get_index_type< account_balance_index >().indices().get< by_asset_balance >();
       asset_id_type asset_id = database_api.get_asset_id_from_string( asset );      
       auto range = bal_idx.equal_range( boost::make_tuple( asset_id ) );
@@ -582,9 +585,7 @@ namespace graphene { namespace app {
     }
     // function to get vector of system assets with holders count.
     vector<asset_holders> asset_api::get_all_asset_holders() const {
-
       vector<asset_holders> result;
-
       vector<asset_id_type> total_assets;
       for( const asset_object& asset_obj : _db.get_index_type<asset_index>().indices() )
       {
@@ -622,8 +623,9 @@ namespace graphene { namespace app {
                                                                optional<price> start,
                                                                uint32_t limit )const
    {
-      FC_ASSERT( limit <= 101 );
-      auto plugin = _app.get_plugin<grouped_orders_plugin>( "grouped_orders" );
+      uint64_t api_limit_get_grouped_limit_orders=_app.get_options().api_limit_get_grouped_limit_orders;
+      FC_ASSERT( limit <= api_limit_get_grouped_limit_orders );
+      auto plugin = _app.get_plugin<graphene::grouped_orders::grouped_orders_plugin>( "grouped_orders" );
       FC_ASSERT( plugin );
       const auto& limit_groups = plugin->limit_order_groups();
       vector< limit_order_group > result;

libraries/app/application.cpp

@@ -81,7 +81,7 @@ namespace detail {
       auto nathan_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("nathan")));
       dlog("Allocating all stake to ${key}", ("key", utilities::key_to_wif(nathan_key)));
       graphene::chain::genesis_state_type initial_state;
-      initial_state.initial_parameters.current_fees = fee_schedule::get_default();//->set_all_fees(GRAPHENE_BLOCKCHAIN_PRECISION);
+      initial_state.initial_parameters.get_mutable_fees() = fee_schedule::get_default();
       initial_state.initial_active_witnesses = GRAPHENE_DEFAULT_MIN_WITNESS_COUNT;
       initial_state.initial_timestamp = time_point_sec(time_point::now().sec_since_epoch() /
             initial_state.initial_parameters.block_interval *
@@ -316,6 +316,35 @@ void application_impl::set_dbg_init_key( graphene::chain::genesis_state_type& ge
       genesis.initial_witness_candidates[i].block_signing_key = init_pubkey;
 }
 
+
+
+void application_impl::set_api_limit() {
+   if (_options->count("api-limit-get-account-history-operations")) {
+      _app_options.api_limit_get_account_history_operations = _options->at("api-limit-get-account-history-operations").as<uint64_t>();
+   }
+   if(_options->count("api-limit-get-account-history")){
+      _app_options.api_limit_get_account_history = _options->at("api-limit-get-account-history").as<uint64_t>();
+   }
+   if(_options->count("api-limit-get-grouped-limit-orders")){
+      _app_options.api_limit_get_grouped_limit_orders = _options->at("api-limit-get-grouped-limit-orders").as<uint64_t>();
+   }
+   if(_options->count("api-limit-get-relative-account-history")){
+       _app_options.api_limit_get_relative_account_history = _options->at("api-limit-get-relative-account-history").as<uint64_t>();
+   }
+   if(_options->count("api-limit-get-account-history-by-operations")){
+       _app_options.api_limit_get_account_history_by_operations = _options->at("api-limit-get-account-history-by-operations").as<uint64_t>();
+   }
+   if(_options->count("api-limit-get-asset-holders")){
+       _app_options.api_limit_get_asset_holders = _options->at("api-limit-get-asset-holders").as<uint64_t>();
+   }
+	if(_options->count("api-limit-get-key-references")){
+		_app_options.api_limit_get_key_references = _options->at("api-limit-get-key-references").as<uint64_t>();
+	}
+   if(_options->count("api-limit-get-htlc-by")) {
+      _app_options.api_limit_get_htlc_by = _options->at("api-limit-get-htlc-by").as<uint64_t>();
+   }
+}
+
 void application_impl::startup()
 { try {
    fc::create_directories(_data_dir / "blockchain");
@@ -437,6 +466,8 @@ void application_impl::startup()
    if ( _options->count("enable-subscribe-to-all") )
       _app_options.enable_subscribe_to_all = _options->at( "enable-subscribe-to-all" ).as<bool>();
 
+   set_api_limit();
+
    if( _active_plugins.find( "market_history" ) != _active_plugins.end() )
       _app_options.has_market_history_plugin = true;
 
@@ -975,6 +1006,20 @@ void application::set_program_options(boost::program_options::options_descriptio
          ("enable-standby-votes-tracking", bpo::value<bool>()->implicit_value(true),
           "Whether to enable tracking of votes of standby witnesses and committee members. "
           "Set it to true to provide accurate data to API clients, set to false for slightly better performance.")
+         ("api-limit-get-account-history-operations",boost::program_options::value<uint64_t>()->default_value(100),
+          "For history_api::get_account_history_operations to set its default limit value as 100")
+         ("api-limit-get-account-history",boost::program_options::value<uint64_t>()->default_value(100),
+          "For history_api::get_account_history to set its default limit value as 100")
+         ("api-limit-get-grouped-limit-orders",boost::program_options::value<uint64_t>()->default_value(101),
+          "For orders_api::get_grouped_limit_orders to set its default limit value as 101")
+         ("api-limit-get-relative-account-history",boost::program_options::value<uint64_t>()->default_value(100),
+          "For history_api::get_relative_account_history to set its default limit value as 100")
+         ("api-limit-get-account-history-by-operations",boost::program_options::value<uint64_t>()->default_value(100),
+          "For history_api::get_account_history_by_operations to set its default limit value as 100")
+         ("api-limit-get-asset-holders",boost::program_options::value<uint64_t>()->default_value(100),
+          "For asset_api::get_asset_holders to set its default limit value as 100")
+		   ("api-limit-get-key-references",boost::program_options::value<uint64_t>()->default_value(100),
+		    "For database_api_impl::get_key_references to set its default limit value as 100")
          ;
    command_line_options.add(configuration_file_options);
    command_line_options.add_options()
@@ -1014,6 +1059,18 @@ void application::startup()
    }
 }
 
+void application::set_api_limit()
+{
+   try {
+      my->set_api_limit();
+   } catch ( const fc::exception& e ) {
+      elog( "${e}", ("e",e.to_detail_string()) );
+      throw;
+   } catch ( ... ) {
+      elog( "unexpected exception" );
+      throw;
+   }
+}
 std::shared_ptr<abstract_plugin> application::get_plugin(const string& name) const
 {
    return my->_active_plugins[name];

libraries/app/application_impl.hxx

@@ -41,6 +41,7 @@ class application_impl : public net::node_delegate
       }
 
       void set_dbg_init_key( graphene::chain::genesis_state_type& genesis, const std::string& init_key );
+      void set_api_limit();
 
       void startup();
 
@@ -66,7 +67,7 @@ class application_impl : public net::node_delegate
 
       virtual void handle_transaction(const graphene::net::trx_message& transaction_message) override;
 
-      void handle_message(const graphene::net::message& message_to_process);
+      void handle_message(const graphene::net::message& message_to_process) override;
 
       bool is_included_block(const graphene::chain::block_id_type& block_id);
 

libraries/app/config_util.cpp

@@ -258,11 +258,22 @@ static void create_new_config_file(const fc::path& config_ini_path, const fc::pa
    };
    deduplicator dedup(modify_option_defaults);
    std::ofstream out_cfg(config_ini_path.preferred_string());
+   std::string plugin_header_surrounding( 78, '=' );
    for( const boost::shared_ptr<bpo::option_description> opt : cfg_options.options() )
    {
       const boost::shared_ptr<bpo::option_description> od = dedup.next(opt);
       if( !od ) continue;
 
+      if( od->long_name().find("plugin-cfg-header-") == 0 ) // it's a plugin header
+      {
+         out_cfg << "\n";
+         out_cfg << "# " << plugin_header_surrounding << "\n";
+         out_cfg << "# " << od->description() << "\n";
+         out_cfg << "# " << plugin_header_surrounding << "\n";
+         out_cfg << "\n";
+         continue;
+      }
+
       if( !od->description().empty() )
          out_cfg << "# " << od->description() << "\n";
       boost::any store;
@@ -284,6 +295,10 @@ static void create_new_config_file(const fc::path& config_ini_path, const fc::pa
    }
 
    out_cfg << "\n"
+           << "# " << plugin_header_surrounding << "\n"
+           << "# logging options\n"
+           << "# " << plugin_header_surrounding << "\n"
+           << "#\n"
            << "# Logging configuration is loaded from logging.ini by default.\n"
            << "# If logging.ini exists, logging configuration added in this file will be ignored.\n";
    out_cfg.close();

libraries/app/database_api.cpp

@@ -168,6 +168,11 @@ class database_api_impl : public std::enable_shared_from_this<database_api_impl>
       vector<withdraw_permission_object> get_withdraw_permissions_by_giver(const std::string account_id_or_name, withdraw_permission_id_type start, uint32_t limit)const;
       vector<withdraw_permission_object> get_withdraw_permissions_by_recipient(const std::string account_id_or_name, withdraw_permission_id_type start, uint32_t limit)const;
 
+      // HTLC
+      optional<htlc_object> get_htlc(htlc_id_type id) const;
+      vector<htlc_object> get_htlc_by_from(const std::string account_id_or_name, htlc_id_type start, uint32_t limit) const;
+      vector<htlc_object> get_htlc_by_to(const std::string account_id_or_name, htlc_id_type start, uint32_t limit) const;
+
    //private:
       static string price_to_string( const price& _price, const asset_object& _base, const asset_object& _quote );
 
@@ -668,7 +673,6 @@ dynamic_global_property_object database_api_impl::get_dynamic_global_properties(
 
 vector<vector<account_id_type>> database_api::get_key_references( vector<public_key_type> key )const
 {
-   FC_ASSERT(key.size() <= 100, "Number of keys must be 100 or less");
    return my->get_key_references( key );
 }
 
@@ -677,6 +681,8 @@ vector<vector<account_id_type>> database_api::get_key_references( vector<public_
  */
 vector<vector<account_id_type>> database_api_impl::get_key_references( vector<public_key_type> keys )const
 {
+   uint64_t api_limit_get_key_references=_app_options->api_limit_get_key_references;
+   FC_ASSERT(keys.size() <= api_limit_get_key_references);
    const auto& idx = _db.get_index_type<account_index>();
    const auto& aidx = dynamic_cast<const base_primary_index&>(idx);
    const auto& refs = aidx.get_secondary_index<graphene::chain::account_member_index>();
@@ -968,7 +974,18 @@ std::map<std::string, full_account> database_api_impl::get_full_accounts( const
                        acnt.withdraws.emplace_back(withdraw);
                     });
 
-
+      // get htlcs
+      auto htlc_from_range = _db.get_index_type<htlc_index>().indices().get<by_from_id>().equal_range(account->id);
+      std::for_each(htlc_from_range.first, htlc_from_range.second,
+            [&acnt] (const htlc_object& htlc) {
+               acnt.htlcs.emplace_back(htlc);
+            });
+      auto htlc_to_range = _db.get_index_type<htlc_index>().indices().get<by_to_id>().equal_range(account->id);
+      std::for_each(htlc_to_range.first, htlc_to_range.second,
+            [&acnt] (const htlc_object& htlc) {
+               if ( std::find(acnt.htlcs.begin(), acnt.htlcs.end(), htlc) == acnt.htlcs.end() )
+                  acnt.htlcs.emplace_back(htlc);
+               });
       results[account_name_or_id] = acnt;
    }
    return results;
@@ -2381,6 +2398,74 @@ vector<withdraw_permission_object> database_api_impl::get_withdraw_permissions_b
    return result;
 }
 
+//////////////////////////////////////////////////////////////////////
+//                                                                  //
+//  HTLC                                                            //
+//                                                                  //
+//////////////////////////////////////////////////////////////////////
+
+optional<htlc_object> database_api::get_htlc(htlc_id_type id)const
+{
+   return my->get_htlc(id);
+}
+
+fc::optional<htlc_object> database_api_impl::get_htlc(htlc_id_type id) const
+{
+   auto obj = get_objects( { id }).front();
+   if ( !obj.is_null() )
+   {
+      return fc::optional<htlc_object>(obj.template as<htlc_object>(GRAPHENE_MAX_NESTED_OBJECTS));
+   }
+   return fc::optional<htlc_object>();
+}
+
+vector<htlc_object> database_api::get_htlc_by_from(const std::string account_id_or_name, htlc_id_type start, uint32_t limit)const
+{
+   return my->get_htlc_by_from(account_id_or_name, start, limit);
+}
+
+vector<htlc_object> database_api_impl::get_htlc_by_from(const std::string account_id_or_name, htlc_id_type start, uint32_t limit) const
+{
+   FC_ASSERT( limit <= _app_options->api_limit_get_htlc_by );
+   vector<htlc_object> result;
+
+   const auto& htlc_idx = _db.get_index_type< htlc_index >().indices().get< by_from_id >();
+   auto htlc_index_end = htlc_idx.end();
+   const account_id_type account = get_account_from_string(account_id_or_name)->id;
+   auto htlc_itr = htlc_idx.lower_bound(boost::make_tuple(account, start));
+
+   while(htlc_itr != htlc_index_end && htlc_itr->transfer.from == account && result.size() < limit)
+   {
+      result.push_back(*htlc_itr);
+      ++htlc_itr;
+   }
+   return result;
+}
+
+vector<htlc_object> database_api::get_htlc_by_to(const std::string account_id_or_name, htlc_id_type start, uint32_t limit)const
+{
+   return my->get_htlc_by_to(account_id_or_name, start, limit);
+}
+
+vector<htlc_object> database_api_impl::get_htlc_by_to(const std::string account_id_or_name, htlc_id_type start, uint32_t limit) const
+{
+
+   FC_ASSERT( limit <= _app_options->api_limit_get_htlc_by );
+   vector<htlc_object> result;
+
+   const auto& htlc_idx = _db.get_index_type< htlc_index >().indices().get< by_to_id >();
+   auto htlc_index_end = htlc_idx.end();
+   const account_id_type account = get_account_from_string(account_id_or_name)->id;
+   auto htlc_itr = htlc_idx.lower_bound(boost::make_tuple(account, start));
+
+   while(htlc_itr != htlc_index_end && htlc_itr->transfer.to == account && result.size() < limit)
+   {
+      result.push_back(*htlc_itr);
+      ++htlc_itr;
+   }
+   return result;
+}
+
 //////////////////////////////////////////////////////////////////////
 //                                                                  //
 // Private methods                                                  //

libraries/app/include/graphene/app/api.hpp

@@ -464,6 +464,7 @@ namespace graphene { namespace app {
          vector<asset_holders> get_all_asset_holders() const;
 
       private:
+         graphene::app::application& _app;
          graphene::chain::database& _db;
          graphene::app::database_api database_api;
    };