Merge pull request #1004 from GolosChain/golos-v0.19.0

Golos v0.19.0

Author: afalaleev

CMakeLists.txt

@@ -170,7 +170,7 @@ else(WIN32) # Apple AND Linux
     else(APPLE)
         # Linux Specific Options Here
         message(STATUS "Configuring Golos on Linux")
-        set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} -std=c++14 -Wall")
+        set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} -std=c++14 -Wall -Wno-deprecated-declarations")
         set(rt_library rt)
         set(pthread_library pthread)
         if(NOT DEFINED crypto_library)

libraries/api/account_api_object.cpp

@@ -16,7 +16,9 @@ account_api_object::account_api_object(const account_object& a, const golos::cha
         last_owner_proved(a.last_owner_proved), last_active_proved(a.last_active_proved),
         recovery_account(a.recovery_account), reset_account(a.reset_account),
         last_account_recovery(a.last_account_recovery), comment_count(a.comment_count),
-        lifetime_vote_count(a.lifetime_vote_count), post_count(a.post_count), can_vote(a.can_vote),
+        lifetime_vote_count(a.lifetime_vote_count), post_count(a.post_count),
+        posts_capacity(a.posts_capacity), comments_capacity(a.comments_capacity), voting_capacity(a.voting_capacity),
+        can_vote(a.can_vote),
         voting_power(a.voting_power), last_vote_time(a.last_vote_time),
         balance(a.balance), savings_balance(a.savings_balance),
         sbd_balance(a.sbd_balance), sbd_seconds(a.sbd_seconds),
@@ -26,7 +28,8 @@ account_api_object::account_api_object(const account_object& a, const golos::cha
         savings_sbd_seconds_last_update(a.savings_sbd_seconds_last_update),
         savings_sbd_last_interest_payment(a.savings_sbd_last_interest_payment),
         savings_withdraw_requests(a.savings_withdraw_requests),
-        curation_rewards(a.curation_rewards), posting_rewards(a.posting_rewards),
+        benefaction_rewards(a.benefaction_rewards), curation_rewards(a.curation_rewards),
+        delegation_rewards(a.delegation_rewards), posting_rewards(a.posting_rewards),
         vesting_shares(a.vesting_shares),
         delegated_vesting_shares(a.delegated_vesting_shares), received_vesting_shares(a.received_vesting_shares),
         vesting_withdraw_rate(a.vesting_withdraw_rate), next_vesting_withdrawal(a.next_vesting_withdrawal),
@@ -68,6 +71,13 @@ account_api_object::account_api_object(const account_object& a, const golos::cha
         lifetime_market_bandwidth = market->lifetime_bandwidth;
         last_market_bandwidth_update = market->last_bandwidth_update;
     }
+
+    if (db.head_block_time() < a.referral_end_date) {
+        referrer_account = a.referrer_account;
+        referrer_interest_rate = a.referrer_interest_rate;
+        referral_end_date = a.referral_end_date;
+        referral_break_fee = a.referral_break_fee;
+    }
 }
 
 account_api_object::account_api_object() = default;

libraries/api/chain_api_properties.cpp

@@ -15,6 +15,26 @@ namespace golos { namespace api {
             create_account_delegation_time = src.create_account_delegation_time;
             min_delegation = src.min_delegation;
         }
+        if (db.has_hardfork(STEEMIT_HARDFORK_0_19)) {
+            max_referral_interest_rate = src.max_referral_interest_rate;
+            max_referral_term_sec = src.max_referral_term_sec;
+            min_referral_break_fee = src.min_referral_break_fee;
+            max_referral_break_fee = src.max_referral_break_fee;
+            posts_window = src.posts_window;
+            posts_per_window = src.posts_per_window;
+            comments_window = src.comments_window;
+            comments_per_window = src.comments_per_window;
+            votes_window = src.votes_window;
+            votes_per_window = src.votes_per_window;
+            auction_window_size = src.auction_window_size;
+            max_delegated_vesting_interest_rate = src.max_delegated_vesting_interest_rate;
+            custom_ops_bandwidth_multiplier = src.custom_ops_bandwidth_multiplier;
+            min_curation_percent = src.min_curation_percent;
+            max_curation_percent = src.max_curation_percent;
+            curation_reward_curve = src.curation_reward_curve;
+            allow_distribute_auction_reward = src.allow_distribute_auction_reward;
+            allow_return_auction_reward_to_fund = src.allow_return_auction_reward_to_fund;
+        }
     }
 
 } } // golos::api

libraries/api/discussion_helper.cpp

@@ -2,6 +2,7 @@
 #include <golos/api/comment_api_object.hpp>
 #include <golos/chain/account_object.hpp>
 #include <golos/chain/steem_objects.hpp>
+#include <golos/chain/curation_info.hpp>
 #include <fc/io/json.hpp>
 #include <boost/algorithm/string.hpp>
 
@@ -34,12 +35,11 @@ namespace golos { namespace api {
 
         discussion create_discussion(const comment_object& o) const ;
 
-        void select_active_votes(
-            std::vector<vote_state>& result, uint32_t& total_count,
-            const std::string& author, const std::string& permlink, uint32_t limit
-        ) const ;
+        std::vector<vote_state> select_active_votes(
+            const std::string& author, const std::string& permlink, uint32_t limit, uint32_t offset
+        ) const;
 
-        share_type get_curator_unclaimed_rewards(const discussion& d, share_type max_rewards) const;
+        std::vector<vote_state> select_active_votes(const comment_curation_info&, uint32_t limit, uint32_t offset) const;
 
         void set_pending_payout(discussion& d) const;
 
@@ -55,10 +55,13 @@ namespace golos { namespace api {
 
         comment_api_object create_comment_api_object(const comment_object& o) const;
 
-        discussion get_discussion(const comment_object& c, uint32_t vote_limit) const;
+        discussion get_discussion(const comment_object& c, uint32_t vote_limit, uint32_t offset) const;
 
         void fill_comment_api_object(const comment_object& o, comment_api_object& d) const;
 
+    private:
+        void distribute_auction_tokens(discussion& d, share_type& curator_tokens, share_type& author_tokens) const;
+
     private:
         golos::chain::database& database_;
         std::function<void(const golos::chain::database&, const account_name_type&, fc::optional<share_type>&)> fill_reputation_;
@@ -102,7 +105,6 @@ namespace golos { namespace api {
         d.children_abs_rshares = o.children_abs_rshares;
         d.cashout_time = o.cashout_time;
         d.max_cashout_time = o.max_cashout_time;
-        d.total_vote_weight = o.total_vote_weight;
         d.reward_weight = o.reward_weight;
         d.net_votes = o.net_votes;
         d.mode = o.mode;
@@ -112,6 +114,9 @@ namespace golos { namespace api {
         d.allow_replies = o.allow_replies;
         d.allow_votes = o.allow_votes;
         d.allow_curation_rewards = o.allow_curation_rewards;
+        d.auction_window_reward_destination = o.auction_window_reward_destination;
+        d.auction_window_size = o.auction_window_size;
+        d.curation_rewards_percent = o.curation_rewards_percent;
 
         for (auto& route : o.beneficiaries) {
             d.beneficiaries.push_back(route);
@@ -129,84 +134,101 @@ namespace golos { namespace api {
     }
 
 // get_discussion
-    discussion discussion_helper::impl::get_discussion(const comment_object& c, uint32_t vote_limit) const {
-        discussion d = create_discussion(c);
+    discussion discussion_helper::impl::get_discussion(const comment_object& comment, uint32_t vote_limit, uint32_t offset) const {
+        discussion d = create_discussion(comment);
         set_url(d);
+
+        d.active_votes_count = comment.total_votes;
+
+        comment_curation_info c{database_, comment, true};
+
+        d.curation_reward_curve = c.curve;
+        d.total_vote_weight = c.total_vote_weight;
+        d.auction_window_weight = c.auction_window_weight;
+        d.votes_in_auction_window_weight = c.votes_in_auction_window_weight;
+        d.active_votes = select_active_votes(c, vote_limit, offset);
+
         set_pending_payout(d);
-        select_active_votes(d.active_votes, d.active_votes_count, d.author, d.permlink, vote_limit);
+
         return d;
     }
 
-    discussion discussion_helper::get_discussion(const comment_object& c, uint32_t vote_limit) const {
-        return pimpl->get_discussion(c, vote_limit);
+    discussion discussion_helper::get_discussion(const comment_object& c, uint32_t vote_limit, uint32_t offset) const {
+        return pimpl->get_discussion(c, vote_limit, offset);
     }
 //
 
 // select_active_votes
-    void discussion_helper::impl::select_active_votes(
-        std::vector<vote_state>& result, uint32_t& total_count,
-        const std::string& author, const std::string& permlink, uint32_t limit
+    std::vector<vote_state> discussion_helper::impl::select_active_votes(
+        const std::string& author, const std::string& permlink, uint32_t limit, uint32_t offset
     ) const {
-        const auto& comment = database().get_comment(author, permlink);
-        const auto& idx = database().get_index<comment_vote_index>().indices().get<by_comment_voter>();
-        comment_object::id_type cid(comment.id);
-        total_count = 0;
-        result.clear();
-        for (auto itr = idx.lower_bound(cid); itr != idx.end() && itr->comment == cid; ++itr, ++total_count) {
-            if (result.size() < limit) {
-                const auto& vo = database().get(itr->voter);
-                vote_state vstate;
-                vstate.voter = vo.name;
-                vstate.weight = itr->weight;
-                vstate.rshares = itr->rshares;
-                vstate.percent = itr->vote_percent;
-                vstate.time = itr->last_update;
-                fill_reputation_(database(), vo.name, vstate.reputation);
-                result.emplace_back(vstate);
-            }
-        }
+        const auto& comment = database_.get_comment(author, permlink);
+        comment_curation_info c{database_, comment, true};
+
+        return select_active_votes(c, limit, offset);
     }
 
-    void discussion_helper::select_active_votes(
-        std::vector<vote_state>& result, uint32_t& total_count,
-        const std::string& author, const std::string& permlink, uint32_t limit
+    std::vector<vote_state> discussion_helper::impl::select_active_votes(
+        const comment_curation_info& c, uint32_t limit, uint32_t offset
     ) const {
-        pimpl->select_active_votes(result, total_count, author, permlink, limit);
-    }
+        offset = std::min(offset, uint32_t(c.vote_list.size()));
+        limit = std::min(limit, uint32_t(c.vote_list.size() - offset));
 
-    share_type discussion_helper::impl::get_curator_unclaimed_rewards(const discussion& d, share_type max_rewards) const {
-        share_type unclaimed_rewards = max_rewards;
-        auto& db = database();
-        try {
-            uint128_t total_weight(d.total_vote_weight);
+        if (limit == 0) {
+            return {};
+        }
 
-            if (d.allow_curation_rewards) {
-                if (d.total_vote_weight > 0) {
-                    const auto &cvidx = db.get_index<comment_vote_index>().indices().get<by_comment_weight_voter>();
-                    for (auto itr = cvidx.lower_bound(d.id); itr != cvidx.end() && itr->comment == d.id; ++itr) {
-                        auto claim = ((max_rewards.value * uint128_t(itr->weight)) / total_weight).to_uint64();
-                        if (claim > 0) { // min_amt is non-zero satoshis
-                            unclaimed_rewards -= claim;
-                        } else {
-                            break;
-                        }
-                    }
-                }
-            } else {
-                unclaimed_rewards = 0;
-            }
+        auto itr = c.vote_list.begin();
+        std::advance(itr, offset);
+
+        std::vector<vote_state> result;
+        result.reserve(limit);
+
+        for (; itr != c.vote_list.end() && result.size() < limit; ++itr) {
+            const auto& vo = database().get(itr->vote->voter);
+            vote_state vstate;
+            vstate.voter = vo.name;
+            vstate.weight = itr->weight;
+            vstate.rshares = itr->vote->rshares;
+            vstate.percent = itr->vote->vote_percent;
+            vstate.time = itr->vote->last_update;
+            fill_reputation_(database(), vo.name, vstate.reputation);
+            result.emplace_back(std::move(vstate));
+        }
+        return result;
+    }
 
-            return unclaimed_rewards;
-        } FC_CAPTURE_AND_RETHROW()
+    std::vector<vote_state> discussion_helper::select_active_votes(
+        const std::string& author, const std::string& permlink, uint32_t limit, uint32_t offset
+    ) const {
+        return pimpl->select_active_votes(author, permlink, limit, offset);
     }
 
 //
 // set_pending_payout
+
+    void discussion_helper::impl::distribute_auction_tokens(discussion& d, share_type& curators_tokens, share_type& author_tokens) const {
+        const auto auction_window_reward = curators_tokens.value * d.auction_window_weight / d.total_vote_weight;
+
+        curators_tokens -= auction_window_reward;
+
+        if (d.auction_window_reward_destination == to_author) {
+            author_tokens += auction_window_reward;
+        } else if (d.auction_window_reward_destination == to_curators &&
+                   d.total_vote_weight != d.votes_in_auction_window_weight + d.auction_window_weight) {
+            curators_tokens += auction_window_reward;
+        }
+    }
+
     void discussion_helper::impl::set_pending_payout(discussion& d) const {
         auto& db = database();
 
         fill_promoted_(db, d);
 
+        if (d.total_vote_weight == 0) {
+            return;
+        }
+
         const auto& props = db.get_dynamic_global_properties();
         const auto& hist = db.get_feed_history();
         asset pot = props.total_reward_fund_steem;
@@ -225,27 +247,25 @@ namespace golos { namespace api {
             r2 *= pot.amount.value;
             r2 /= total_r2;
 
-            uint64_t payout = static_cast<uint64_t>(r2);
+            const share_type reward_tokens = std::min(share_type(r2), d.max_accepted_payout.amount);
 
-            payout = std::min(payout, uint64_t(d.max_accepted_payout.amount.value));
+            share_type curation_tokens = reward_tokens * d.curation_rewards_percent / STEEMIT_100_PERCENT;
 
-            uint128_t reward_tokens = uint128_t(payout);
+            share_type author_tokens = reward_tokens - curation_tokens;
 
-            share_type curation_tokens = ((reward_tokens * db.get_curation_rewards_percent())
-                / STEEMIT_100_PERCENT).to_uint64();
-            auto crs_unclaimed = get_curator_unclaimed_rewards(d, curation_tokens);
-            auto crs_claim = curation_tokens - crs_unclaimed;
-            share_type author_tokens = reward_tokens.to_uint64() - crs_claim;
             if (d.allow_curation_rewards) {
-                d.pending_curator_payout_value = db.to_sbd(asset(crs_claim, STEEM_SYMBOL));
-                d.pending_curator_payout_gests_value = asset(crs_claim, STEEM_SYMBOL) * props.get_vesting_share_price();
+                distribute_auction_tokens(d, curation_tokens, author_tokens);
+
+                d.pending_curator_payout_value = db.to_sbd(asset(curation_tokens, STEEM_SYMBOL));
+                d.pending_curator_payout_gests_value = asset(curation_tokens, STEEM_SYMBOL) * props.get_vesting_share_price();
                 d.pending_payout_value += d.pending_curator_payout_value;
             }
 
             uint32_t benefactor_weights = 0;
             for (auto &b : d.beneficiaries) {
                 benefactor_weights += b.weight;
             }
+
             if (benefactor_weights != 0) {
                 auto total_beneficiary = (author_tokens * benefactor_weights) / STEEMIT_100_PERCENT;
                 author_tokens -= total_beneficiary;
@@ -276,10 +296,6 @@ namespace golos { namespace api {
 
         fill_reputation_(db, d.author, d.author_reputation);
 
-        if (d.parent_author != STEEMIT_ROOT_POST_PARENT) {
-            d.cashout_time = db.calculate_discussion_payout_time(db.get_comment(d.id));
-        }
-
         if (d.body.size() > 1024 * 128) {
             d.body = "body pruned due to size";
         }
@@ -341,7 +357,7 @@ namespace golos { namespace api {
         pimpl = std::make_unique<impl>(db, fill_reputation, fill_promoted, fill_comment_info);
     }
 
-    discussion_helper::~discussion_helper() = default;
+    discussion_helper::~discussion_helper() {}
 
 //
 } } // golos::api

libraries/api/include/golos/api/account_api_object.hpp

@@ -46,6 +46,9 @@ struct account_api_object {
     uint32_t comment_count;
     uint32_t lifetime_vote_count;
     uint32_t post_count;
+    uint16_t posts_capacity;
+    uint16_t comments_capacity;
+    uint16_t voting_capacity;
 
     bool can_vote;
     uint16_t voting_power;
@@ -66,7 +69,9 @@ struct account_api_object {
 
     uint8_t savings_withdraw_requests;
 
-    protocol::share_type curation_rewards;
+    share_type benefaction_rewards;
+    share_type curation_rewards;
+    share_type delegation_rewards;
     share_type posting_rewards;
 
     asset vesting_shares;
@@ -95,6 +100,11 @@ struct account_api_object {
     set<string> witness_votes;
 
     fc::optional<share_type> reputation;
+
+    account_name_type referrer_account;
+    uint16_t referrer_interest_rate = 0;
+    time_point_sec referral_end_date = time_point_sec::min();
+    asset referral_break_fee = asset(0, STEEM_SYMBOL);
 };
 
 } } // golos::api
@@ -109,10 +119,11 @@ FC_REFLECT((golos::api::account_api_object),
     (savings_sbd_seconds)(savings_sbd_seconds_last_update)(savings_sbd_last_interest_payment)
     (savings_withdraw_requests)(vesting_shares)(delegated_vesting_shares)(received_vesting_shares)
     (vesting_withdraw_rate)(next_vesting_withdrawal)(withdrawn)(to_withdraw)(withdraw_routes)
-    (curation_rewards)(posting_rewards)(proxied_vsf_votes)(witnesses_voted_for)
+    (benefaction_rewards)(curation_rewards)(delegation_rewards)(posting_rewards)(proxied_vsf_votes)(witnesses_voted_for)
     (average_bandwidth)(average_market_bandwidth)(lifetime_bandwidth)(lifetime_market_bandwidth)
     (last_bandwidth_update)(last_market_bandwidth_update)
     (last_post)(last_root_post)(post_bandwidth)
-    (witness_votes)(reputation))
+    (witness_votes)(reputation)(posts_capacity)(comments_capacity)(voting_capacity)
+    (referrer_account)(referrer_interest_rate)(referral_end_date)(referral_break_fee))
 
 #endif //GOLOS_ACCOUNT_API_OBJ_HPP