From be6ad130d926a5cdb9fe0447c2dcf3ff077d45a7 Mon Sep 17 00:00:00 2001 From: Eric Frias Date: Fri, 26 Aug 2016 11:29:37 -0400 Subject: [PATCH] Code cleanups -- renaming variables, adding comments, fix one bug with override transfers and dividend assets --- docs | 2 +- libraries/app/database_api.cpp | 2 +- .../app/include/graphene/app/full_account.hpp | 2 +- libraries/chain/db_init.cpp | 4 +- libraries/chain/db_maint.cpp | 68 +++++++++---------- .../include/graphene/chain/account_object.hpp | 36 +++++----- .../include/graphene/chain/asset_object.hpp | 16 ++--- .../include/graphene/chain/protocol/types.hpp | 8 +-- tests/common/database_fixture.cpp | 4 +- 9 files changed, 71 insertions(+), 71 deletions(-) diff --git a/docs b/docs index cdc8ea81..97435c1a 160000 --- a/docs +++ b/docs @@ -1 +1 @@ -Subproject commit cdc8ea8133a999afef8051700a4ce8edb0988ec4 +Subproject commit 97435c1a622e41e0a5fc1be72aaadea62e1b7adb diff --git a/libraries/app/database_api.cpp b/libraries/app/database_api.cpp index 42a0b641..dc8c4dfc 100644 --- a/libraries/app/database_api.cpp +++ b/libraries/app/database_api.cpp @@ -607,7 +607,7 @@ std::map database_api_impl::get_full_accounts( const }); auto pending_payouts_range = - _db.get_index_type().indices().get().equal_range(boost::make_tuple(account->id)); + _db.get_index_type().indices().get().equal_range(boost::make_tuple(account->id)); std::copy(pending_payouts_range.first, pending_payouts_range.second, std::back_inserter(acnt.pending_dividend_payments)); diff --git a/libraries/app/include/graphene/app/full_account.hpp b/libraries/app/include/graphene/app/full_account.hpp index 787207ef..0d94348f 100644 --- a/libraries/app/include/graphene/app/full_account.hpp +++ b/libraries/app/include/graphene/app/full_account.hpp @@ -44,7 +44,7 @@ namespace graphene { namespace app { vector limit_orders; vector call_orders; vector proposals; - vector pending_dividend_payments; + vector pending_dividend_payments; }; } } diff --git a/libraries/chain/db_init.cpp b/libraries/chain/db_init.cpp index 8e0372ba..325d7862 100644 --- a/libraries/chain/db_init.cpp +++ b/libraries/chain/db_init.cpp @@ -218,8 +218,8 @@ void database::initialize_indexes() add_index< primary_index< buyback_index > >(); add_index< primary_index< simple_index< fba_accumulator_object > > >(); - add_index< primary_index >(); - add_index< primary_index >(); + add_index< primary_index >(); + add_index< primary_index >(); } void database::init_genesis(const genesis_state_type& genesis_state) diff --git a/libraries/chain/db_maint.cpp b/libraries/chain/db_maint.cpp index 9f418d3e..3684c37f 100644 --- a/libraries/chain/db_maint.cpp +++ b/libraries/chain/db_maint.cpp @@ -726,8 +726,8 @@ void schedule_pending_dividend_balances(database& db, const asset_dividend_data_object& dividend_data, const fc::time_point_sec& current_head_block_time, const account_balance_index& balance_index, - const distributed_dividend_balance_object_index& distributed_dividend_balance_index, - const pending_dividend_payout_balance_object_index& pending_payout_balance_index) + const total_distributed_dividend_balance_object_index& distributed_dividend_balance_index, + const pending_dividend_payout_balance_for_holder_object_index& pending_payout_balance_index) { dlog("Processing dividend payments for dividend holder asset type ${holder_asset} at time ${t}", ("holder_asset", dividend_holder_asset_obj.symbol)("t", db.head_block_time())); @@ -757,6 +757,15 @@ void schedule_pending_dividend_balances(database& db, ("current", std::distance(current_distribution_account_balance_range.first, current_distribution_account_balance_range.second)) ("previous", std::distance(previous_distribution_account_balance_range.first, previous_distribution_account_balance_range.second))); + // when we pay out the dividends to the holders, we need to know the total balance of the dividend asset in all + // accounts other than the distribution account (it would be silly to distribute dividends back to + // the distribution account) + share_type total_balance_of_dividend_asset; + for (const account_balance_object& holder_balance_object : boost::make_iterator_range(holder_balances_begin, holder_balances_end)) + if (holder_balance_object.owner != dividend_data.dividend_distribution_account) + total_balance_of_dividend_asset += holder_balance_object.balance; + + // loop through all of the assets currently or previously held in the distribution account while (current_distribution_account_balance_iter != current_distribution_account_balance_range.second || previous_distribution_account_balance_iter != previous_distribution_account_balance_range.second) @@ -771,6 +780,7 @@ void schedule_pending_dividend_balances(database& db, if (previous_distribution_account_balance_iter == previous_distribution_account_balance_range.second || current_distribution_account_balance_iter->asset_type < previous_distribution_account_balance_iter->dividend_payout_asset_type) { + // there are no more previous balances or there is no previous balance for this particular asset type payout_asset_type = current_distribution_account_balance_iter->asset_type; current_balance = current_distribution_account_balance_iter->balance; idump((payout_asset_type)(current_balance)); @@ -778,12 +788,14 @@ void schedule_pending_dividend_balances(database& db, else if (current_distribution_account_balance_iter == current_distribution_account_balance_range.second || previous_distribution_account_balance_iter->dividend_payout_asset_type < current_distribution_account_balance_iter->asset_type) { + // there are no more current balances or there is no current balance for this particular previous asset type payout_asset_type = previous_distribution_account_balance_iter->dividend_payout_asset_type; previous_balance = previous_distribution_account_balance_iter->balance_at_last_maintenance_interval; idump((payout_asset_type)(previous_balance)); } else { + // we have both a previous and a current balance for this asset type payout_asset_type = current_distribution_account_balance_iter->asset_type; current_balance = current_distribution_account_balance_iter->balance; previous_balance = previous_distribution_account_balance_iter->balance_at_last_maintenance_interval; @@ -872,19 +884,12 @@ void schedule_pending_dividend_balances(database& db, delta_balance -= total_fee_per_asset_in_payout_asset; } - // we need to pay out the remaining delta_balance to shareholders proportional to their stake - // so find out what the total stake - share_type total_balance_of_dividend_asset; - for (const account_balance_object& holder_balance_object : boost::make_iterator_range(holder_balances_begin, holder_balances_end)) - if (holder_balance_object.owner != dividend_data.dividend_distribution_account) - total_balance_of_dividend_asset += holder_balance_object.balance; - dlog("There are ${count} holders of the dividend-paying asset, with a total balance of ${total}", ("count", holder_account_count) ("total", total_balance_of_dividend_asset)); share_type remaining_amount_to_distribute = delta_balance; - // credit each account with their portion + // credit each account with their portion, don't send any back to the dividend distribution account for (const account_balance_object& holder_balance_object : boost::make_iterator_range(holder_balances_begin, holder_balances_end)) if (holder_balance_object.owner != dividend_data.dividend_distribution_account && holder_balance_object.balance.value) @@ -903,14 +908,14 @@ void schedule_pending_dividend_balances(database& db, auto pending_payout_iter = pending_payout_balance_index.indices().get().find(boost::make_tuple(dividend_holder_asset_obj.id, payout_asset_type, holder_balance_object.owner)); if (pending_payout_iter == pending_payout_balance_index.indices().get().end()) - db.create( [&]( pending_dividend_payout_balance_object& obj ){ + db.create( [&]( pending_dividend_payout_balance_for_holder_object& obj ){ obj.owner = holder_balance_object.owner; obj.dividend_holder_asset_type = dividend_holder_asset_obj.id; obj.dividend_payout_asset_type = payout_asset_type; obj.pending_balance = shares_to_credit; }); else - db.modify(*pending_payout_iter, [&]( pending_dividend_payout_balance_object& pending_balance ){ + db.modify(*pending_payout_iter, [&]( pending_dividend_payout_balance_for_holder_object& pending_balance ){ pending_balance.pending_balance += shares_to_credit; }); } @@ -926,13 +931,13 @@ void schedule_pending_dividend_balances(database& db, share_type distributed_amount = delta_balance - remaining_amount_to_distribute; if (previous_distribution_account_balance_iter == previous_distribution_account_balance_range.second || previous_distribution_account_balance_iter->dividend_payout_asset_type != payout_asset_type) - db.create( [&]( distributed_dividend_balance_object& obj ){ + db.create( [&]( total_distributed_dividend_balance_object& obj ){ obj.dividend_holder_asset_type = dividend_holder_asset_obj.id; obj.dividend_payout_asset_type = payout_asset_type; obj.balance_at_last_maintenance_interval = distributed_amount; }); else - db.modify(*previous_distribution_account_balance_iter, [&]( distributed_dividend_balance_object& obj ){ + db.modify(*previous_distribution_account_balance_iter, [&]( total_distributed_dividend_balance_object& obj ){ obj.balance_at_last_maintenance_interval += distributed_amount; }); } @@ -947,18 +952,18 @@ void schedule_pending_dividend_balances(database& db, { // some amount of the asset has been withdrawn from the dividend_distribution_account, // meaning the current pending payout balances will add up to more than our current balance. - // This should be extremely rare. + // This should be extremely rare (caused by an override transfer by the asset owner). // Reduce all pending payouts proportionally share_type total_pending_balances; auto pending_payouts_range = pending_payout_balance_index.indices().get().equal_range(boost::make_tuple(dividend_holder_asset_obj.id, payout_asset_type)); - for (const pending_dividend_payout_balance_object& pending_balance_object : boost::make_iterator_range(pending_payouts_range.first, pending_payouts_range.second)) + for (const pending_dividend_payout_balance_for_holder_object& pending_balance_object : boost::make_iterator_range(pending_payouts_range.first, pending_payouts_range.second)) total_pending_balances += pending_balance_object.pending_balance; share_type remaining_amount_to_recover = -delta_balance; share_type remaining_pending_balances = total_pending_balances; - for (const pending_dividend_payout_balance_object& pending_balance_object : boost::make_iterator_range(pending_payouts_range.first, pending_payouts_range.second)) + for (const pending_dividend_payout_balance_for_holder_object& pending_balance_object : boost::make_iterator_range(pending_payouts_range.first, pending_payouts_range.second)) { fc::uint128_t amount_to_debit(remaining_amount_to_recover.value); amount_to_debit *= pending_balance_object.pending_balance.value; @@ -968,22 +973,17 @@ void schedule_pending_dividend_balances(database& db, remaining_amount_to_recover -= shares_to_debit; remaining_pending_balances -= pending_balance_object.pending_balance; - db.modify(pending_balance_object, [&]( pending_dividend_payout_balance_object& pending_balance ){ + db.modify(pending_balance_object, [&]( pending_dividend_payout_balance_for_holder_object& pending_balance ){ pending_balance.pending_balance -= shares_to_debit; }); } - if (previous_distribution_account_balance_iter == previous_distribution_account_balance_range.second || - previous_distribution_account_balance_iter->dividend_payout_asset_type != payout_asset_type) - db.create( [&]( distributed_dividend_balance_object& obj ){ - obj.dividend_holder_asset_type = dividend_holder_asset_obj.id; - obj.dividend_payout_asset_type = payout_asset_type; - obj.balance_at_last_maintenance_interval = 0; - }); - else - db.modify(*previous_distribution_account_balance_iter, [&]( distributed_dividend_balance_object& obj ){ - obj.balance_at_last_maintenance_interval = 0; - }); + // if we're here, we know there must be a previous balance, so just adjust it by the + // amount we just reclaimed + db.modify(*previous_distribution_account_balance_iter, [&]( total_distributed_dividend_balance_object& obj ){ + obj.balance_at_last_maintenance_interval += delta_balance; + assert(obj.balance_at_last_maintenance_interval == current_balance); + }); } // end if deposit was large enough to distribute } catch (const fc::exception& e) @@ -1016,8 +1016,8 @@ void process_dividend_assets(database& db) ilog("In process_dividend_assets time ${time}", ("time", db.head_block_time())); const account_balance_index& balance_index = db.get_index_type(); - const distributed_dividend_balance_object_index& distributed_dividend_balance_index = db.get_index_type(); - const pending_dividend_payout_balance_object_index& pending_payout_balance_index = db.get_index_type(); + const total_distributed_dividend_balance_object_index& distributed_dividend_balance_index = db.get_index_type(); + const pending_dividend_payout_balance_for_holder_object_index& pending_payout_balance_index = db.get_index_type(); // TODO: switch to iterating over only dividend assets (generalize the by_type index) for( const asset_object& dividend_holder_asset_obj : db.get_index_type().indices() ) @@ -1073,7 +1073,7 @@ void process_dividend_assets(database& db) for (auto pending_balance_object_iter = pending_payouts_range.first; pending_balance_object_iter != pending_payouts_range.second; ) { - const pending_dividend_payout_balance_object& pending_balance_object = *pending_balance_object_iter; + const pending_dividend_payout_balance_for_holder_object& pending_balance_object = *pending_balance_object_iter; if (last_holder_account_id && *last_holder_account_id != pending_balance_object.owner) { @@ -1102,7 +1102,7 @@ void process_dividend_assets(database& db) last_holder_account_id = pending_balance_object.owner; amounts_paid_out_by_asset[pending_balance_object.dividend_payout_asset_type] += pending_balance_object.pending_balance; - db.modify(pending_balance_object, [&]( pending_dividend_payout_balance_object& pending_balance ){ + db.modify(pending_balance_object, [&]( pending_dividend_payout_balance_for_holder_object& pending_balance ){ pending_balance.pending_balance = 0; }); } @@ -1135,7 +1135,7 @@ void process_dividend_assets(database& db) asset_paid_out)); assert(distributed_balance_iter != distributed_dividend_balance_index.indices().get().end()); if (distributed_balance_iter != distributed_dividend_balance_index.indices().get().end()) - db.modify(*distributed_balance_iter, [&]( distributed_dividend_balance_object& obj ){ + db.modify(*distributed_balance_iter, [&]( total_distributed_dividend_balance_object& obj ){ obj.balance_at_last_maintenance_interval -= amount_paid_out; // now they've been paid out, reset to zero }); diff --git a/libraries/chain/include/graphene/chain/account_object.hpp b/libraries/chain/include/graphene/chain/account_object.hpp index 1b65957c..9f51de7c 100644 --- a/libraries/chain/include/graphene/chain/account_object.hpp +++ b/libraries/chain/include/graphene/chain/account_object.hpp @@ -318,11 +318,11 @@ namespace graphene { namespace chain { * @ingroup object * */ - class pending_dividend_payout_balance_object : public abstract_object + class pending_dividend_payout_balance_for_holder_object : public abstract_object { public: static const uint8_t space_id = implementation_ids; - static const uint8_t type_id = impl_pending_dividend_payout_balance_object_type; + static const uint8_t type_id = impl_pending_dividend_payout_balance_for_holder_object_type; account_id_type owner; asset_id_type dividend_holder_asset_type; @@ -397,40 +397,40 @@ namespace graphene { namespace chain { * @ingroup object_index */ typedef multi_index_container< - pending_dividend_payout_balance_object, + pending_dividend_payout_balance_for_holder_object, indexed_by< ordered_unique< tag, member< object, object_id_type, &object::id > >, ordered_unique< tag, composite_key< - pending_dividend_payout_balance_object, - member, - member, - member + pending_dividend_payout_balance_for_holder_object, + member, + member, + member > >, ordered_unique< tag, composite_key< - pending_dividend_payout_balance_object, - member, - member, - member + pending_dividend_payout_balance_for_holder_object, + member, + member, + member > >, ordered_unique< tag, composite_key< - pending_dividend_payout_balance_object, - member, - member, - member + pending_dividend_payout_balance_for_holder_object, + member, + member, + member > > > - > pending_dividend_payout_balance_object_multi_index_type; + > pending_dividend_payout_balance_for_holder_object_multi_index_type; /** * @ingroup object_index */ - typedef generic_index pending_dividend_payout_balance_object_index; + typedef generic_index pending_dividend_payout_balance_for_holder_object_index; }} @@ -460,7 +460,7 @@ FC_REFLECT_DERIVED( graphene::chain::account_statistics_object, (pending_fees)(pending_vested_fees) ) -FC_REFLECT_DERIVED( graphene::chain::pending_dividend_payout_balance_object, +FC_REFLECT_DERIVED( graphene::chain::pending_dividend_payout_balance_for_holder_object, (graphene::db::object), (owner)(dividend_holder_asset_type)(dividend_payout_asset_type)(pending_balance) ) diff --git a/libraries/chain/include/graphene/chain/asset_object.hpp b/libraries/chain/include/graphene/chain/asset_object.hpp index c284e0f7..70f8443d 100644 --- a/libraries/chain/include/graphene/chain/asset_object.hpp +++ b/libraries/chain/include/graphene/chain/asset_object.hpp @@ -304,7 +304,7 @@ namespace graphene { namespace chain { // pending dividend payouts were calculated (last maintenance interval). // At each maintenance interval, we will compare the current balance to the // balance stored here to see how much was deposited during that interval. - class distributed_dividend_balance_object : public abstract_object + class total_distributed_dividend_balance_object : public abstract_object { public: static const uint8_t space_id = implementation_ids; @@ -316,19 +316,19 @@ namespace graphene { namespace chain { }; struct by_dividend_payout_asset{}; typedef multi_index_container< - distributed_dividend_balance_object, + total_distributed_dividend_balance_object, indexed_by< ordered_unique< tag, member< object, object_id_type, &object::id > >, ordered_unique< tag, composite_key< - distributed_dividend_balance_object, - member, - member + total_distributed_dividend_balance_object, + member, + member > > > - > distributed_dividend_balance_object_multi_index_type; - typedef generic_index distributed_dividend_balance_object_index; + > total_distributed_dividend_balance_object_multi_index_type; + typedef generic_index total_distributed_dividend_balance_object_index; @@ -355,7 +355,7 @@ FC_REFLECT_DERIVED( graphene::chain::asset_dividend_data_object, (graphene::db:: (dividend_distribution_account) ) -FC_REFLECT_DERIVED( graphene::chain::distributed_dividend_balance_object, (graphene::db::object), +FC_REFLECT_DERIVED( graphene::chain::total_distributed_dividend_balance_object, (graphene::db::object), (dividend_holder_asset_type) (dividend_payout_asset_type) (balance_at_last_maintenance_interval) diff --git a/libraries/chain/include/graphene/chain/protocol/types.hpp b/libraries/chain/include/graphene/chain/protocol/types.hpp index 948e22d9..402f12a3 100644 --- a/libraries/chain/include/graphene/chain/protocol/types.hpp +++ b/libraries/chain/include/graphene/chain/protocol/types.hpp @@ -157,7 +157,7 @@ namespace graphene { namespace chain { impl_buyback_object_type, impl_fba_accumulator_object_type, impl_asset_dividend_data_type, - impl_pending_dividend_payout_balance_object_type, + impl_pending_dividend_payout_balance_for_holder_object_type, impl_distributed_dividend_balance_data_type }; @@ -211,14 +211,14 @@ namespace graphene { namespace chain { class buyback_object; class fba_accumulator_object; class asset_dividend_data_object; - class pending_dividend_payout_balance_object; + class pending_dividend_payout_balance_for_holder_object; typedef object_id< implementation_ids, impl_global_property_object_type, global_property_object> global_property_id_type; typedef object_id< implementation_ids, impl_dynamic_global_property_object_type, dynamic_global_property_object> dynamic_global_property_id_type; typedef object_id< implementation_ids, impl_asset_dynamic_data_type, asset_dynamic_data_object> asset_dynamic_data_id_type; typedef object_id< implementation_ids, impl_asset_bitasset_data_type, asset_bitasset_data_object> asset_bitasset_data_id_type; typedef object_id< implementation_ids, impl_asset_dividend_data_type, asset_dividend_data_object> asset_dividend_data_id_type; - typedef object_id< implementation_ids, impl_pending_dividend_payout_balance_object_type, pending_dividend_payout_balance_object> pending_dividend_payout_balance_object_type; + typedef object_id< implementation_ids, impl_pending_dividend_payout_balance_for_holder_object_type, pending_dividend_payout_balance_for_holder_object> pending_dividend_payout_balance_for_holder_object_type; typedef object_id< implementation_ids, impl_account_balance_object_type, account_balance_object> account_balance_id_type; typedef object_id< implementation_ids, impl_account_statistics_object_type,account_statistics_object> account_statistics_id_type; typedef object_id< implementation_ids, impl_transaction_object_type, transaction_object> transaction_obj_id_type; @@ -367,7 +367,7 @@ FC_REFLECT_ENUM( graphene::chain::impl_object_type, (impl_buyback_object_type) (impl_fba_accumulator_object_type) (impl_asset_dividend_data_type) - (impl_pending_dividend_payout_balance_object_type) + (impl_pending_dividend_payout_balance_for_holder_object_type) (impl_distributed_dividend_balance_data_type) ) diff --git a/tests/common/database_fixture.cpp b/tests/common/database_fixture.cpp index a69bfc30..6ecce113 100644 --- a/tests/common/database_fixture.cpp +++ b/tests/common/database_fixture.cpp @@ -1040,8 +1040,8 @@ int64_t database_fixture::get_dividend_pending_payout_balance(asset_id_type divi account_id_type dividend_holder_account_id, asset_id_type dividend_payout_asset_type) const { - const pending_dividend_payout_balance_object_index& pending_payout_balance_index = - db.get_index_type(); + const pending_dividend_payout_balance_for_holder_object_index& pending_payout_balance_index = + db.get_index_type(); auto pending_payout_iter = pending_payout_balance_index.indices().get().find(boost::make_tuple(dividend_holder_asset_type, dividend_payout_asset_type, dividend_holder_account_id)); if (pending_payout_iter == pending_payout_balance_index.indices().get().end())