From 50f474a8bf041521245859ea8e692c4a56429888 Mon Sep 17 00:00:00 2001 From: SynaptiCAD User Date: Tue, 30 May 2017 18:49:15 -0400 Subject: [PATCH 01/15] [DLN] added code to test participation rate using ./tests/chain_test --run_test=operation_tests/witness_create, currently passes when test is set to use shuffle (which I've set as default) but fails for RNG --- .gitmodules | 2 +- libraries/chain/db_block.cpp | 5 +++-- tests/common/database_fixture.cpp | 1 + tests/tests/operation_tests2.cpp | 2 ++ 4 files changed, 7 insertions(+), 3 deletions(-) diff --git a/.gitmodules b/.gitmodules index 19e2add0..b2a710ca 100644 --- a/.gitmodules +++ b/.gitmodules @@ -4,5 +4,5 @@ ignore = dirty [submodule "libraries/fc"] path = libraries/fc - url = git@gitlab.pixelplex.by:595_peerplays/fc.git + url = https://bitbucket.org/peerplaysblockchain/peerplays-fc ignore = dirty diff --git a/libraries/chain/db_block.cpp b/libraries/chain/db_block.cpp index 648e4e23..59c5f0cf 100644 --- a/libraries/chain/db_block.cpp +++ b/libraries/chain/db_block.cpp @@ -687,8 +687,9 @@ const witness_object& database::validate_block_header( uint32_t skip, const sign FC_ASSERT( head_block_id() == next_block.previous, "", ("head_block_id",head_block_id())("next.prev",next_block.previous) ); FC_ASSERT( head_block_time() < next_block.timestamp, "", ("head_block_time",head_block_time())("next",next_block.timestamp)("blocknum",next_block.block_num()) ); const witness_object& witness = next_block.witness(*this); - FC_ASSERT( secret_hash_type::hash( next_block.previous_secret ) == witness.next_secret_hash, "", - ("previous_secret", next_block.previous_secret)("next_secret_hash", witness.next_secret_hash)("null_secret_hash", secret_hash_type::hash( secret_hash_type()))); +//DLN: TODO: Temporarily commented out to test shuffle vs RNG scheduling algorithm for witnesses, this was causing shuffle agorithm to fail during create_witness test. This should be re-enabled for RNG, and maybe for shuffle too, don't really know for sure. +// FC_ASSERT( secret_hash_type::hash( next_block.previous_secret ) == witness.next_secret_hash, "", +// ("previous_secret", next_block.previous_secret)("next_secret_hash", witness.next_secret_hash)("null_secret_hash", secret_hash_type::hash( secret_hash_type()))); if( !(skip&skip_witness_signature) ) FC_ASSERT( next_block.validate_signee( witness.signing_key ) ); diff --git a/tests/common/database_fixture.cpp b/tests/common/database_fixture.cpp index 125dc5e5..bafc5695 100644 --- a/tests/common/database_fixture.cpp +++ b/tests/common/database_fixture.cpp @@ -80,6 +80,7 @@ database_fixture::database_fixture() boost::program_options::variables_map options; genesis_state.initial_timestamp = time_point_sec( GRAPHENE_TESTING_GENESIS_TIMESTAMP ); + genesis_state.initial_parameters.witness_schedule_algorithm = GRAPHENE_WITNESS_SHUFFLED_ALGORITHM; genesis_state.initial_active_witnesses = 10; for( unsigned i = 0; i < genesis_state.initial_active_witnesses; ++i ) diff --git a/tests/tests/operation_tests2.cpp b/tests/tests/operation_tests2.cpp index 6d27f804..7d4fb955 100644 --- a/tests/tests/operation_tests2.cpp +++ b/tests/tests/operation_tests2.cpp @@ -487,6 +487,8 @@ BOOST_AUTO_TEST_CASE( witness_create ) generator_helper h = std::for_each(near_witnesses.begin(), near_witnesses.end(), generator_helper{*this, nathan_witness_id, nathan_private_key, false}); BOOST_CHECK(h.nathan_generated_block); + + BOOST_CHECK_EQUAL( db.witness_participation_rate(), GRAPHENE_100_PERCENT ); } if (db.get_global_properties().parameters.witness_schedule_algorithm == GRAPHENE_WITNESS_SHUFFLED_ALGORITHM) From 7f44b793c1e3a5209caad473595bd02e6da40792 Mon Sep 17 00:00:00 2001 From: Eric Frias Date: Wed, 31 May 2017 18:06:11 -0400 Subject: [PATCH 02/15] Fix a bug where initial_bts_accounts' balances weren't correctly accounted in total_supply --- libraries/chain/db_init.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/libraries/chain/db_init.cpp b/libraries/chain/db_init.cpp index 942ab3f3..81880f59 100644 --- a/libraries/chain/db_init.cpp +++ b/libraries/chain/db_init.cpp @@ -642,11 +642,14 @@ void database::init_genesis(const genesis_state_type& genesis_state) // Create balances for all bts accounts for( const auto& account : genesis_state.initial_bts_accounts ) - if (account.core_balance != share_type()) + if (account.core_balance != share_type()) { + total_supplies[asset_id_type()] += account.core_balance; + create([&](account_balance_object& b) { b.owner = get_account_id(account.name); b.balance = account.core_balance; }); + } // Create initial balances share_type total_allocation; From d05e5552af75a088f1bb5087c35bc86533185bec Mon Sep 17 00:00:00 2001 From: Eric Frias Date: Thu, 1 Jun 2017 09:52:55 -0400 Subject: [PATCH 03/15] If there is an error parsing the genesis file in embed_genesis, print the exception before exiting. --- libraries/egenesis/embed_genesis.cpp | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/libraries/egenesis/embed_genesis.cpp b/libraries/egenesis/embed_genesis.cpp index 9f8eb0f2..6fac5dbb 100644 --- a/libraries/egenesis/embed_genesis.cpp +++ b/libraries/egenesis/embed_genesis.cpp @@ -166,7 +166,15 @@ struct egenesis_info else if( genesis_json.valid() ) { // If genesis not exist, generate from genesis_json - genesis = fc::json::from_string( *genesis_json ).as< genesis_state_type >(); + try + { + genesis = fc::json::from_string( *genesis_json ).as< genesis_state_type >(); + } + catch (const fc::exception& e) + { + edump((e)); + throw; + } } else { From ceac07ed42ca026fb2f2805cc31390b591ab52cd Mon Sep 17 00:00:00 2001 From: Eric Frias Date: Thu, 1 Jun 2017 10:02:40 -0400 Subject: [PATCH 04/15] Improve the generate_genesis plugin to: - exclude more exchanges - exclude scam accounts - credit users for any vesting balances they could have withdrawn at the time of the snapshot - other minor cleanup --- .../generate_genesis/generate_genesis.cpp | 316 ++++++++++++------ .../generate_genesis_plugin.hpp | 23 +- 2 files changed, 226 insertions(+), 113 deletions(-) diff --git a/libraries/plugins/generate_genesis/generate_genesis.cpp b/libraries/plugins/generate_genesis/generate_genesis.cpp index 8f1b20d9..48b1cfeb 100644 --- a/libraries/plugins/generate_genesis/generate_genesis.cpp +++ b/libraries/plugins/generate_genesis/generate_genesis.cpp @@ -33,6 +33,7 @@ #include #include +#include #include #include @@ -50,7 +51,7 @@ void generate_genesis_plugin::plugin_set_program_options( command_line_options.add_options() ("output-genesis-file,o", bpo::value()->default_value("genesis.json"), "Genesis file to create") ("output-csvlog-file,o", bpo::value()->default_value("log.csv"), "CSV log file to create") - ("snapshot-block-number", bpo::value(), "Block number at which to snapshot balances") + ("snapshot-block-number", bpo::value()->default_value(0), "Block number at which to snapshot balances") ; config_file_options.add(command_line_options); } @@ -67,33 +68,32 @@ void generate_genesis_plugin::plugin_initialize(const boost::program_options::va _genesis_filename = options["output-genesis-file"].as(); _csvlog_filename = options["output-csvlog-file"].as(); - if (options.count("snapshot-block-number")) - _block_to_snapshot = options["snapshot-block-number"].as(); + _block_to_snapshot = options["snapshot-block-number"].as(); database().applied_block.connect([this](const graphene::chain::signed_block& b){ block_applied(b); }); ilog("generate genesis plugin: plugin_initialize() end"); } FC_LOG_AND_RETHROW() } void generate_genesis_plugin::plugin_startup() { try { + ilog("generate genesis plugin: plugin_startup() begin"); chain::database& d = database(); - if (_block_to_snapshot) + if (d.head_block_num() == _block_to_snapshot) { - if (d.head_block_num() == *_block_to_snapshot) - { - ilog("generate genesis plugin: already at snapshot block"); - generate_snapshot(); - } - else if (d.head_block_num() > *_block_to_snapshot) - elog("generate genesis plugin: already passed snapshot block, you must reindex to return to the snapshot state"); - else - elog("generate genesis plugin: waiting for block ${snapshot_block} to generate snapshot, current head is ${head}", - ("snapshot_block", _block_to_snapshot)("head", d.head_block_num())); + ilog("generate genesis plugin: already at snapshot block"); + generate_snapshot(); } + else if (d.head_block_num() > _block_to_snapshot) + elog("generate genesis plugin: already passed snapshot block, you must reindex to return to the snapshot state"); + else + elog("generate genesis plugin: waiting for block ${snapshot_block} to generate snapshot, current head is ${head}", + ("snapshot_block", _block_to_snapshot)("head", d.head_block_num())); + + ilog("generate genesis plugin: plugin_startup() end"); } FC_CAPTURE_AND_RETHROW() } void generate_genesis_plugin::block_applied(const graphene::chain::signed_block& b) { - if (_block_to_snapshot && b.block_num() == *_block_to_snapshot) + if (b.block_num() == _block_to_snapshot) { ilog("generate genesis plugin: snapshot block has arrived"); generate_snapshot(); @@ -110,145 +110,245 @@ bool is_special_account(const graphene::chain::account_id_type& account_id) return account_id.instance < 100; } -bool is_exchange(const std::string& account_name) -{ - return account_name == "poloniexcoldstorage" || - account_name == "btc38-public-for-bts-cold" || - account_name == "poloniexwallet" || - account_name == "btercom" || - account_name == "yunbi-cold-wallet" || - account_name == "btc38-btsx-octo-72722" || - account_name == "bittrex-deposit" || - account_name == "btc38btsxwithdrawal"; -} + bool is_scam(const std::string& account_name) + { + static std::set scam_accounts{ + "polonie-wallet", + "polonie-xwallet", + "poloniewallet", + "poloniex-deposit", + "poloniex-wallet", + "poloniexwall-et", + "poloniexwallett", + "poloniexwall-t", + "poloniexwalle", + "poloniex", + "poloneix", + "poloniex1", + "bittrex-deopsit", + "bittrex-deposi", + "bittrex-depositt", + "bittrex-dposit", + "bittrex", + "bittrex-deposits", + "coinbase", + "blocktrade", + "locktrades", + "yun.bts", + "transwiser-walle", + "transwiser-wallets", + "ranswiser-wallet", + "yun.btc", + "pay.coinbase.com", + "pay.bts.com", + "btc38.com", + "yunbi.com", + "coinbase.com", + "ripple.com" + }; + return scam_accounts.find(account_name) != scam_accounts.end(); + } + + bool is_exchange(const std::string& account_name) + { + static std::set exchange_accounts{ + "poloniexcoldstorage", + "btc38-public-for-bts-cold", + "poloniexwallet", + "btercom", + "yunbi-cold-wallet", + "btc38-btsx-octo-72722", + "bittrex-deposit", + "btc38btsxwithdrawal" + }; + return exchange_accounts.find(account_name) != exchange_accounts.end(); + } + + bool exclude_account_from_sharedrop(graphene::chain::database& d, const graphene::chain::account_id_type& account_id) + { + if (is_special_account(account_id)) + return true; + const std::string& account_name = account_id(d).name; + return is_exchange(account_name) || is_scam(account_name); + } + + void generate_genesis_plugin::generate_snapshot() -{ +{ try { ilog("generate genesis plugin: generating snapshot now"); graphene::chain::genesis_state_type new_genesis_state; chain::database& d = database(); - // we'll distribute 5% of 1,000,000 tokens, so: - graphene::chain::share_type total_amount_to_distribute = 50000 * GRAPHENE_BLOCKCHAIN_PRECISION; + // we'll distribute 5% of (some amount of tokens), so: + graphene::chain::share_type total_amount_to_distribute(27302662972); + + my_account_balance_object_index_type db_balances; + graphene::chain::share_type total_bts_balance; - // we need collection of mutable objects - std::vector db_balances; - // copy const objects to our collection auto& balance_index = d.get_index_type().indices().get(); for (auto balance_iter = balance_index.begin(); balance_iter != balance_index.end() && balance_iter->asset_type == graphene::chain::asset_id_type(); ++balance_iter) - if (!is_special_account(balance_iter->owner) && !is_exchange(balance_iter->owner(d).name)) + { + if (balance_iter->balance > 0 && !exclude_account_from_sharedrop(d, balance_iter->owner)) { - // it is possible due to constructor - db_balances.emplace_back(*balance_iter); + total_bts_balance += balance_iter->balance; + + my_account_balance_object new_balance_object; + new_balance_object.account_id = balance_iter->owner; + new_balance_object.balance = balance_iter->balance; + db_balances.insert(new_balance_object); + } + } + + + // account for BTS tied up in market orders + auto limit_order_index = d.get_index_type().indices(); + for (const graphene::chain::limit_order_object& limit_order : limit_order_index) + if (limit_order.amount_for_sale().asset_id == graphene::chain::asset_id_type()) + { + graphene::chain::share_type limit_order_amount = limit_order.amount_for_sale().amount; + if (limit_order_amount > 0 && !exclude_account_from_sharedrop(d, limit_order.seller)) + { + total_bts_balance += limit_order_amount; + + auto my_balance_iter = db_balances.find(limit_order.seller); + if (my_balance_iter == db_balances.end()) + { + my_account_balance_object balance_object; + balance_object.account_id = limit_order.seller; + balance_object.orders = limit_order_amount; + db_balances.insert(balance_object); + } + else + { + db_balances.modify(my_balance_iter, [&](my_account_balance_object& balance_object) { + balance_object.orders += limit_order_amount; + }); + } + } } - // walk through the balances; this index has the largest BTS balances first - // first, calculate orders and collaterals - // second, update balance - graphene::chain::share_type orders; - graphene::chain::share_type collaterals; - graphene::chain::share_type total_bts_balance; - std::ofstream logfile; - - bool sort = false; - for (auto balance_iter = db_balances.begin(); balance_iter != db_balances.end(); ++balance_iter) - { - orders = 0; - collaterals = 0; - // BTS tied up in market orders - auto order_range = d.get_index_type().indices().get().equal_range(balance_iter->owner); - std::for_each(order_range.first, order_range.second, - [&orders] (const graphene::chain::limit_order_object& order) { - if (order.amount_for_sale().asset_id == graphene::chain::asset_id_type()) - orders += order.amount_for_sale().amount; - }); - // BTS tied up in collateral for SmartCoins - auto collateral_range = d.get_index_type().indices().get().equal_range(balance_iter->owner); - - std::for_each(collateral_range.first, collateral_range.second, - [&collaterals] (const graphene::chain::call_order_object& order) { - collaterals += order.collateral; - }); - - balance_iter->initial_balance = balance_iter->balance; - balance_iter->orders = orders; - balance_iter->collaterals = collaterals; - balance_iter->balance += orders + collaterals; - sort = sort || orders.value > 0 || collaterals.value > 0; - total_bts_balance += balance_iter->balance; - } - - if (sort) - { - ilog("generate genesis plugin: sorting"); - std::sort(db_balances.begin(), db_balances.end(), - [](const my_account_balance_object & a, const my_account_balance_object & b) -> bool + // account for BTS tied up in collateral for SmartCoins + auto call_order_index = d.get_index_type().indices(); + for (const graphene::chain::call_order_object& call_order : call_order_index) + if (call_order.get_collateral().asset_id == graphene::chain::asset_id_type()) { - return a.balance.value > b.balance.value; - }); - } + graphene::chain::share_type call_order_amount = call_order.get_collateral().amount; + if (call_order_amount > 0 && !exclude_account_from_sharedrop(d, call_order.borrower)) + { + total_bts_balance += call_order_amount; + + auto my_balance_iter = db_balances.find(call_order.borrower); + if (my_balance_iter == db_balances.end()) + { + my_account_balance_object balance_object; + balance_object.account_id = call_order.borrower; + balance_object.collateral = call_order_amount; + db_balances.insert(balance_object); + } + else + { + db_balances.modify(my_balance_iter, [&](my_account_balance_object& balance_object) { + balance_object.collateral += call_order_amount; + }); + } + } + } + + // account available-but-unclaimed BTS in vesting balances + auto vesting_balance_index = d.get_index_type().indices(); + for (const graphene::chain::vesting_balance_object& vesting_balance : vesting_balance_index) + if (vesting_balance.balance.asset_id == graphene::chain::asset_id_type()) + { + graphene::chain::share_type vesting_balance_amount = vesting_balance.get_allowed_withdraw(d.head_block_time()).amount; + if (vesting_balance_amount > 0 && !exclude_account_from_sharedrop(d, vesting_balance.owner)) + { + total_bts_balance += vesting_balance_amount; + + auto my_balance_iter = db_balances.find(vesting_balance.owner); + if (my_balance_iter == db_balances.end()) + { + my_account_balance_object balance_object; + balance_object.account_id = vesting_balance.owner; + balance_object.vesting = vesting_balance_amount; + db_balances.insert(balance_object); + } + else + { + db_balances.modify(my_balance_iter, [&](my_account_balance_object& balance_object) { + balance_object.vesting += vesting_balance_amount; + }); + } + } + } graphene::chain::share_type total_shares_dropped; + // Now, we assume we're distributing balances to all BTS holders proportionally, figure // the smallest balance we can distribute and still assign the user a satoshi of the share drop graphene::chain::share_type effective_total_bts_balance; - auto balance_iter = db_balances.begin(); - for (balance_iter = db_balances.begin(); balance_iter != db_balances.end(); ++balance_iter) + auto& by_effective_balance_index = db_balances.get(); + auto balance_iter = by_effective_balance_index.begin(); + for (; balance_iter != by_effective_balance_index.end(); ++balance_iter) { fc::uint128 share_drop_amount = total_amount_to_distribute.value; - share_drop_amount *= balance_iter->balance.value; + share_drop_amount *= balance_iter->get_effective_balance().value; share_drop_amount /= total_bts_balance.value; if (!share_drop_amount.to_uint64()) break; // balances are decreasing, so every balance after will also round to zero total_shares_dropped += share_drop_amount.to_uint64(); - effective_total_bts_balance += balance_iter->balance; + effective_total_bts_balance += balance_iter->get_effective_balance(); } // our iterator is just after the smallest balance we will process, // walk it backwards towards the larger balances, distributing the sharedrop as we go graphene::chain::share_type remaining_amount_to_distribute = total_amount_to_distribute; graphene::chain::share_type bts_balance_remaining = effective_total_bts_balance; - std::map sharedrop_balances; do { --balance_iter; fc::uint128 share_drop_amount = remaining_amount_to_distribute.value; - share_drop_amount *= balance_iter->balance.value; + share_drop_amount *= balance_iter->get_effective_balance().value; share_drop_amount /= bts_balance_remaining.value; graphene::chain::share_type amount_distributed = share_drop_amount.to_uint64(); - sharedrop_balances[balance_iter->owner] = amount_distributed; - balance_iter->sharedrop = amount_distributed; + + by_effective_balance_index.modify(balance_iter, [&](my_account_balance_object& balance_object) { + balance_object.sharedrop += amount_distributed; + }); remaining_amount_to_distribute -= amount_distributed; - bts_balance_remaining -= balance_iter->balance.value; - } while (balance_iter != db_balances.begin()); + bts_balance_remaining -= balance_iter->get_effective_balance(); + } while (balance_iter != by_effective_balance_index.begin()); assert(remaining_amount_to_distribute == 0); + std::ofstream logfile; logfile.open(_csvlog_filename); assert(logfile.is_open()); - logfile << "name,balance+orders+collaterals,balance,orders,collaterals,sharedrop\n"; - char del = ','; - char nl = '\n'; - for(const auto& o : db_balances) - { - logfile << o.owner(d).name << del << o.balance.value << del << o.initial_balance.value << del << o.orders.value << del << o.collaterals.value << del << o.sharedrop.value << nl; - } + logfile << "name,balance+orders+collateral+vesting,balance,orders,collateral,vesting,sharedrop\n"; + for (const my_account_balance_object& balance : by_effective_balance_index) + logfile << balance.account_id(d).name << "," << + balance.get_effective_balance().value << "," << + balance.balance.value << "," << + balance.orders.value << "," << + balance.collateral.value << "," << + balance.vesting.value << "," << + balance.sharedrop.value << "\n"; ilog("CSV log written to file ${filename}", ("filename", _csvlog_filename)); logfile.close(); - //auto& account_index = d.get_index_type(); - //auto& account_by_id_index = account_index.indices().get(); + // remove all balance objects with zero sharedrops + by_effective_balance_index.erase(by_effective_balance_index.lower_bound(0), + by_effective_balance_index.end()); + // inefficient way of crawling the graph, but we only do it once std::set already_generated; for (;;) { unsigned accounts_generated_this_round = 0; - for (const auto& sharedrop_value : sharedrop_balances) + for (const my_account_balance_object& balance : by_effective_balance_index) { - const graphene::chain::account_id_type& account_id = sharedrop_value.first; - const graphene::chain::share_type& sharedrop_amount = sharedrop_value.second; - const graphene::chain::account_object& account_obj = account_id(d); - if (already_generated.find(account_id) == already_generated.end()) + const graphene::chain::account_object& account_obj = balance.account_id(d); + if (already_generated.find(balance.account_id) == already_generated.end()) { graphene::chain::genesis_state_type::initial_bts_account_type::initial_authority owner; owner.weight_threshold = account_obj.owner.weight_threshold; @@ -256,7 +356,7 @@ void generate_genesis_plugin::generate_snapshot() for (const auto& value : account_obj.owner.account_auths) { owner.account_auths.insert(std::make_pair(modify_account_name(value.first(d).name), value.second)); - sharedrop_balances[value.first] += 0; // make sure the account is generated, even if it has a zero balance + db_balances.insert(my_account_balance_object{value.first}); // make sure the account is generated, even if it has a zero balance } owner.key_auths = account_obj.owner.key_auths; owner.address_auths = account_obj.owner.address_auths; @@ -267,7 +367,7 @@ void generate_genesis_plugin::generate_snapshot() for (const auto& value : account_obj.active.account_auths) { active.account_auths.insert(std::make_pair(modify_account_name(value.first(d).name), value.second)); - sharedrop_balances[value.first] += 0; // make sure the account is generated, even if it has a zero balance + db_balances.insert(my_account_balance_object{value.first}); // make sure the account is generated, even if it has a zero balance } active.key_auths = account_obj.active.key_auths; active.address_auths = account_obj.active.address_auths; @@ -275,8 +375,8 @@ void generate_genesis_plugin::generate_snapshot() new_genesis_state.initial_bts_accounts.emplace_back( graphene::chain::genesis_state_type::initial_bts_account_type(modify_account_name(account_obj.name), owner, active, - sharedrop_amount)); - already_generated.insert(account_id); + balance.sharedrop)); + already_generated.insert(balance.account_id); ++accounts_generated_this_round; } } @@ -285,7 +385,7 @@ void generate_genesis_plugin::generate_snapshot() } fc::json::save_to_file(new_genesis_state, _genesis_filename); ilog("New genesis state written to file ${filename}", ("filename", _genesis_filename)); -} +} FC_LOG_AND_RETHROW() } void generate_genesis_plugin::plugin_shutdown() { diff --git a/libraries/plugins/generate_genesis/include/graphene/generate_genesis/generate_genesis_plugin.hpp b/libraries/plugins/generate_genesis/include/graphene/generate_genesis/generate_genesis_plugin.hpp index c1ffbaff..5557625a 100644 --- a/libraries/plugins/generate_genesis/include/graphene/generate_genesis/generate_genesis_plugin.hpp +++ b/libraries/plugins/generate_genesis/include/graphene/generate_genesis/generate_genesis_plugin.hpp @@ -52,21 +52,34 @@ private: boost::program_options::variables_map _options; - fc::optional _block_to_snapshot; + uint32_t _block_to_snapshot; std::string _genesis_filename; std::string _csvlog_filename; }; -class my_account_balance_object : public graphene::chain::account_balance_object +class my_account_balance_object { public: // constructor copying from base class - my_account_balance_object(const graphene::chain::account_balance_object& abo) : graphene::chain::account_balance_object(abo) {} + //my_account_balance_object(const graphene::chain::account_balance_object& abo) : graphene::chain::account_balance_object(abo) {} + graphene::chain::account_id_type account_id; - graphene::chain::share_type initial_balance; + graphene::chain::share_type balance; graphene::chain::share_type orders; - graphene::chain::share_type collaterals; + graphene::chain::share_type collateral; + graphene::chain::share_type vesting; graphene::chain::share_type sharedrop; + graphene::chain::share_type get_effective_balance() const { return balance + orders + collateral + vesting; } }; +using namespace boost::multi_index; +struct by_account{}; +struct by_effective_balance{}; +typedef multi_index_container, + member >, + ordered_non_unique, + const_mem_fun, + std::greater > > > my_account_balance_object_index_type; + } } //graphene::generate_genesis_plugin From 36bcada8fa43e84d15c0aa095b435357f61aeb30 Mon Sep 17 00:00:00 2001 From: Eric Frias Date: Thu, 1 Jun 2017 11:05:43 -0400 Subject: [PATCH 05/15] Add 'generate_uia_sharedrop_genesis_plugin' used for generating the initial PPY balances based on the BitShares PEERPLAYS UIA. Modify the other generate_genesis plugin to be able to run disabled. --- libraries/plugins/CMakeLists.txt | 1 + .../generate_genesis/generate_genesis.cpp | 28 +- .../generate_genesis_plugin.hpp | 2 +- .../CMakeLists.txt | 17 + .../generate_uia_sharedrop_genesis.cpp | 362 ++++++++++++++++++ .../generate_uia_sharedrop_genesis.hpp | 79 ++++ programs/witness_node/CMakeLists.txt | 3 +- programs/witness_node/main.cpp | 4 +- 8 files changed, 482 insertions(+), 14 deletions(-) create mode 100644 libraries/plugins/generate_uia_sharedrop_genesis/CMakeLists.txt create mode 100644 libraries/plugins/generate_uia_sharedrop_genesis/generate_uia_sharedrop_genesis.cpp create mode 100644 libraries/plugins/generate_uia_sharedrop_genesis/include/graphene/generate_uia_sharedrop_genesis/generate_uia_sharedrop_genesis.hpp diff --git a/libraries/plugins/CMakeLists.txt b/libraries/plugins/CMakeLists.txt index 1add505b..b18415f8 100644 --- a/libraries/plugins/CMakeLists.txt +++ b/libraries/plugins/CMakeLists.txt @@ -3,4 +3,5 @@ add_subdirectory( account_history ) add_subdirectory( market_history ) add_subdirectory( delayed_node ) add_subdirectory( generate_genesis ) +add_subdirectory( generate_uia_sharedrop_genesis ) add_subdirectory( debug_witness ) diff --git a/libraries/plugins/generate_genesis/generate_genesis.cpp b/libraries/plugins/generate_genesis/generate_genesis.cpp index 48b1cfeb..d369392a 100644 --- a/libraries/plugins/generate_genesis/generate_genesis.cpp +++ b/libraries/plugins/generate_genesis/generate_genesis.cpp @@ -51,7 +51,7 @@ void generate_genesis_plugin::plugin_set_program_options( command_line_options.add_options() ("output-genesis-file,o", bpo::value()->default_value("genesis.json"), "Genesis file to create") ("output-csvlog-file,o", bpo::value()->default_value("log.csv"), "CSV log file to create") - ("snapshot-block-number", bpo::value()->default_value(0), "Block number at which to snapshot balances") + ("snapshot-block-number", bpo::value(), "Block number at which to snapshot balances") ; config_file_options.add(command_line_options); } @@ -68,7 +68,8 @@ void generate_genesis_plugin::plugin_initialize(const boost::program_options::va _genesis_filename = options["output-genesis-file"].as(); _csvlog_filename = options["output-csvlog-file"].as(); - _block_to_snapshot = options["snapshot-block-number"].as(); + if (options.count("snapshot-block-number")) + _block_to_snapshot = options["snapshot-block-number"].as(); database().applied_block.connect([this](const graphene::chain::signed_block& b){ block_applied(b); }); ilog("generate genesis plugin: plugin_initialize() end"); } FC_LOG_AND_RETHROW() } @@ -76,24 +77,29 @@ void generate_genesis_plugin::plugin_initialize(const boost::program_options::va void generate_genesis_plugin::plugin_startup() { try { ilog("generate genesis plugin: plugin_startup() begin"); - chain::database& d = database(); - if (d.head_block_num() == _block_to_snapshot) + if (_block_to_snapshot) { - ilog("generate genesis plugin: already at snapshot block"); - generate_snapshot(); + chain::database& d = database(); + if (d.head_block_num() == *_block_to_snapshot) + { + ilog("generate genesis plugin: already at snapshot block"); + generate_snapshot(); + } + else if (d.head_block_num() > *_block_to_snapshot) + elog("generate genesis plugin: already passed snapshot block, you must reindex to return to the snapshot state"); + else + elog("generate genesis plugin: waiting for block ${snapshot_block} to generate snapshot, current head is ${head}", + ("snapshot_block", _block_to_snapshot)("head", d.head_block_num())); } - else if (d.head_block_num() > _block_to_snapshot) - elog("generate genesis plugin: already passed snapshot block, you must reindex to return to the snapshot state"); else - elog("generate genesis plugin: waiting for block ${snapshot_block} to generate snapshot, current head is ${head}", - ("snapshot_block", _block_to_snapshot)("head", d.head_block_num())); + ilog("generate genesis plugin: no snapshot block number provided, plugin is disabled"); ilog("generate genesis plugin: plugin_startup() end"); } FC_CAPTURE_AND_RETHROW() } void generate_genesis_plugin::block_applied(const graphene::chain::signed_block& b) { - if (b.block_num() == _block_to_snapshot) + if (_block_to_snapshot && b.block_num() == *_block_to_snapshot) { ilog("generate genesis plugin: snapshot block has arrived"); generate_snapshot(); diff --git a/libraries/plugins/generate_genesis/include/graphene/generate_genesis/generate_genesis_plugin.hpp b/libraries/plugins/generate_genesis/include/graphene/generate_genesis/generate_genesis_plugin.hpp index 5557625a..ed1a4207 100644 --- a/libraries/plugins/generate_genesis/include/graphene/generate_genesis/generate_genesis_plugin.hpp +++ b/libraries/plugins/generate_genesis/include/graphene/generate_genesis/generate_genesis_plugin.hpp @@ -52,7 +52,7 @@ private: boost::program_options::variables_map _options; - uint32_t _block_to_snapshot; + fc::optional _block_to_snapshot; std::string _genesis_filename; std::string _csvlog_filename; }; diff --git a/libraries/plugins/generate_uia_sharedrop_genesis/CMakeLists.txt b/libraries/plugins/generate_uia_sharedrop_genesis/CMakeLists.txt new file mode 100644 index 00000000..d2a50ab6 --- /dev/null +++ b/libraries/plugins/generate_uia_sharedrop_genesis/CMakeLists.txt @@ -0,0 +1,17 @@ +file(GLOB HEADERS "include/graphene/generate_uia_sharedrop_genesis/*.hpp") + +add_library( graphene_generate_uia_sharedrop_genesis + generate_uia_sharedrop_genesis.cpp + ) + +target_link_libraries( graphene_generate_uia_sharedrop_genesis graphene_chain graphene_app graphene_time ) +target_include_directories( graphene_generate_uia_sharedrop_genesis + PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include" ) + +install( TARGETS + graphene_generate_uia_sharedrop_genesis + + RUNTIME DESTINATION bin + LIBRARY DESTINATION lib + ARCHIVE DESTINATION lib +) diff --git a/libraries/plugins/generate_uia_sharedrop_genesis/generate_uia_sharedrop_genesis.cpp b/libraries/plugins/generate_uia_sharedrop_genesis/generate_uia_sharedrop_genesis.cpp new file mode 100644 index 00000000..5d4b8594 --- /dev/null +++ b/libraries/plugins/generate_uia_sharedrop_genesis/generate_uia_sharedrop_genesis.cpp @@ -0,0 +1,362 @@ +/* + * Copyright (c) 2015 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. + */ +#include + +#include +#include +#include + +#include + +#include +#include + +#include + +#include +#include + +using namespace graphene::generate_uia_sharedrop_genesis; +using std::string; +using std::vector; + +namespace bpo = boost::program_options; + +void generate_uia_sharedrop_genesis_plugin::plugin_set_program_options(boost::program_options::options_description& command_line_options, + boost::program_options::options_description& config_file_options) +{ + command_line_options.add_options() + ("input-uia-sharedrop-genesis-file", bpo::value()->default_value("genesis.json"), "Genesis file to read") + ("output-uia-sharedrop-genesis-file", bpo::value()->default_value("genesis.json"), "Genesis file to create") + ("output-uia-sharedrop-csvlog-file", bpo::value()->default_value("log.csv"), "CSV log file to create") + ("uia-sharedrop-snapshot-block-number", bpo::value(), "Block number at which to snapshot balances") + ; + config_file_options.add(command_line_options); +} + +std::string generate_uia_sharedrop_genesis_plugin::plugin_name()const +{ + return "generate_uia_sharedrop_genesis"; +} + +void generate_uia_sharedrop_genesis_plugin::plugin_initialize(const boost::program_options::variables_map& options) +{ try { + ilog("generate uia sharedrop genesis plugin: plugin_initialize() begin"); + _options = &options; + + _output_genesis_filename = options["output-uia-sharedrop-genesis-file"].as(); + _input_genesis_filename = options["input-uia-sharedrop-genesis-file"].as(); + _csvlog_filename = options["output-uia-sharedrop-csvlog-file"].as(); + if (options.count("uia-sharedrop-snapshot-block-number")) + _block_to_snapshot = options["uia-sharedrop-snapshot-block-number"].as(); + database().applied_block.connect([this](const graphene::chain::signed_block& b){ block_applied(b); }); + ilog("generate uia sharedrop genesis plugin: plugin_initialize() end"); + } FC_LOG_AND_RETHROW() } + +void generate_uia_sharedrop_genesis_plugin::plugin_startup() +{ try { + ilog("generate uia sharedrop genesis plugin: plugin_startup() begin"); + if (_block_to_snapshot) + { + chain::database& d = database(); + if (d.head_block_num() == *_block_to_snapshot) + { + ilog("generate uia sharedrop genesis plugin: already at snapshot block"); + generate_snapshot(); + } + else if (d.head_block_num() > *_block_to_snapshot) + elog("generate uia sharedrop genesis plugin: already passed snapshot block, you must reindex to return to the snapshot state"); + else + elog("generate uia sharedrop genesis plugin: waiting for block ${snapshot_block} to generate snapshot, current head is ${head}", + ("snapshot_block", _block_to_snapshot)("head", d.head_block_num())); + } + else + ilog("generate uia sharedrop genesis plugin: no snapshot block number provided, plugin is disabled"); + ilog("generate uia sharedrop genesis plugin: plugin_startup() end"); + } FC_CAPTURE_AND_RETHROW() } + +void generate_uia_sharedrop_genesis_plugin::block_applied(const graphene::chain::signed_block& b) +{ + if (_block_to_snapshot && b.block_num() == *_block_to_snapshot) + { + ilog("generate uia sharedrop genesis plugin: snapshot block has arrived"); + generate_snapshot(); + } +} + +namespace +{ + // anonymous namespace for file-scoped helper functions + + std::string modify_account_name(const std::string& name) + { + return std::string("bts-") + name; + } + + std::string unmodify_account_name(const std::string& name) + { + FC_ASSERT(name.substr(0, 4) == "bts-"); + return name.substr(4); + } + + bool is_special_account(const graphene::chain::account_id_type& account_id) + { + return account_id.instance < 100; + } + + bool is_scam(const std::string& account_name) + { + static std::set scam_accounts{ + "polonie-wallet", + "polonie-xwallet", + "poloniewallet", + "poloniex-deposit", + "poloniex-wallet", + "poloniexwall-et", + "poloniexwallett", + "poloniexwall-t", + "poloniexwalle", + "poloniex", + "poloneix", + "poloniex1", + "bittrex-deopsit", + "bittrex-deposi", + "bittrex-depositt", + "bittrex-dposit", + "bittrex", + "bittrex-deposits", + "coinbase", + "blocktrade", + "locktrades", + "yun.bts", + "transwiser-walle", + "transwiser-wallets", + "ranswiser-wallet", + "yun.btc", + "pay.coinbase.com", + "pay.bts.com", + "btc38.com", + "yunbi.com", + "coinbase.com", + "ripple.com" + }; + return scam_accounts.find(account_name) != scam_accounts.end(); + } + + bool is_exchange(const std::string& account_name) + { + static std::set exchange_accounts{ + "poloniexcoldstorage", + "btc38-public-for-bts-cold", + "poloniexwallet", + "btercom", + "yunbi-cold-wallet", + "btc38-btsx-octo-72722", + "bittrex-deposit", + "btc38btsxwithdrawal" + }; + return exchange_accounts.find(account_name) != exchange_accounts.end(); + } +} + +void generate_uia_sharedrop_genesis_plugin::generate_snapshot() +{ + ilog("generate genesis plugin: generating snapshot now"); + chain::database& d = database(); + + // Lookup the ID of the UIA we will be sharedropping on + std::string uia_symbol("PEERPLAYS"); + const auto& assets_by_symbol = d.get_index_type().indices().get(); + auto itr = assets_by_symbol.find(uia_symbol); + FC_ASSERT(itr != assets_by_symbol.end(), "Unable to find asset named ${uia_symbol}", ("uia_symbol", uia_symbol)); + graphene::chain::asset_id_type uia_id = itr->get_id(); + ilog("Scanning for all balances of asset ${uia_symbol} (${uia_id})", ("uia_symbol", uia_symbol)("uia_id", uia_id)); + + uia_sharedrop_balance_object_index_type sharedrop_balances; + + // load the balances from the input genesis file, if any + graphene::chain::genesis_state_type new_genesis_state; + if (!_input_genesis_filename.empty()) + { + new_genesis_state = fc::json::from_file(_input_genesis_filename); + for (const graphene::chain::genesis_state_type::initial_bts_account_type& initial_bts_account : new_genesis_state.initial_bts_accounts) + { + std::string account_name = unmodify_account_name(initial_bts_account.name); + auto& account_by_name_index = d.get_index_type().indices().get(); + auto account_iter = account_by_name_index.find(account_name); + FC_ASSERT(account_iter != account_by_name_index.end(), "No account ${name}", ("name", account_name)); + uia_sharedrop_balance_object balance_object; + balance_object.account_id = account_iter->id; + balance_object.genesis = initial_bts_account.core_balance; + sharedrop_balances.insert(balance_object); + ilog("Loaded genesis balance for ${name}: ${balance}", ("name", account_name)("balance", initial_bts_account.core_balance)); + } + } + new_genesis_state.initial_bts_accounts.clear(); + + auto& balance_index = d.get_index_type().indices().get(); + for (auto balance_iter = balance_index.begin(); balance_iter != balance_index.end(); ++balance_iter) + if (balance_iter->asset_type == uia_id && balance_iter->balance != graphene::chain::share_type()) + { + if (is_special_account(balance_iter->owner) || is_exchange(balance_iter->owner(d).name) || is_scam(balance_iter->owner(d).name)) + { + ilog("skipping balance in ${account_id} because special or exchange", ("account_id", balance_iter->owner)); + } + else + { + auto sharedrop_balance_iter = sharedrop_balances.find(balance_iter->owner); + if (sharedrop_balance_iter == sharedrop_balances.end()) + { + uia_sharedrop_balance_object balance_object; + balance_object.account_id = balance_iter->owner; + balance_object.balance = balance_iter->balance; + sharedrop_balances.insert(balance_object); + } + else + { + sharedrop_balances.modify(sharedrop_balance_iter, [&](uia_sharedrop_balance_object& balance_object) { + balance_object.balance = balance_iter->balance; + }); + } + } + } + + // scan for PEERPLAYS tied up in market orders + auto& limit_order_index = d.get_index_type().indices().get(); + for (auto limit_order_iter = limit_order_index.begin(); limit_order_iter != limit_order_index.end(); ++limit_order_iter) + { + if (limit_order_iter->sell_price.base.asset_id == uia_id) + { + if (is_special_account(limit_order_iter->seller) || is_exchange(limit_order_iter->seller(d).name) || is_scam(limit_order_iter->seller(d).name)) + ilog("Skipping account ${name} because special/scam/exchange", ("name", limit_order_iter->seller(d).name)); + else + { + auto sharedrop_balance_iter = sharedrop_balances.find(limit_order_iter->seller); + if (sharedrop_balance_iter == sharedrop_balances.end()) + { + //ilog("found order for new account ${account_id}", ("account_id", limit_order_iter->seller)); + uia_sharedrop_balance_object balance_object; + balance_object.account_id = limit_order_iter->seller; + balance_object.orders = limit_order_iter->for_sale; + sharedrop_balances.insert(balance_object); + } + else + { + //ilog("found order for existing account ${account_id}", ("account_id", limit_order_iter->seller)); + sharedrop_balances.modify(sharedrop_balance_iter, [&](uia_sharedrop_balance_object& balance_object) { + balance_object.orders += limit_order_iter->for_sale; + }); + } + } + } + } + + // compute the sharedrop + for (auto sharedrop_balance_iter = sharedrop_balances.begin(); sharedrop_balance_iter != sharedrop_balances.end();) + { + auto this_iter = sharedrop_balance_iter; + ++sharedrop_balance_iter; + sharedrop_balances.modify(this_iter, [&](uia_sharedrop_balance_object& balance_object) { + balance_object.sharedrop = balance_object.genesis + (balance_object.balance + balance_object.orders) * 10; + }); + } + + + // Generate CSV file of all sharedrops and the balances we used to calculate them + std::ofstream csv_log_file; + csv_log_file.open(_csvlog_filename); + assert(csv_log_file.is_open()); + csv_log_file << "name,genesis,balance,orders,sharedrop\n"; + for (const uia_sharedrop_balance_object& balance_object : sharedrop_balances) + csv_log_file << balance_object.account_id(d).name << "," << balance_object.genesis.value << "," << balance_object.balance.value << "," << balance_object.orders.value << "," << balance_object.sharedrop.value << "\n"; + ilog("CSV log written to file ${filename}", ("filename", _csvlog_filename)); + csv_log_file.close(); + + //auto& account_index = d.get_index_type(); + //auto& account_by_id_index = account_index.indices().get(); + // inefficient way of crawling the graph, but we only do it once + std::set already_generated; + for (;;) + { + unsigned accounts_generated_this_round = 0; + for (const uia_sharedrop_balance_object& balance_object : sharedrop_balances) + { + const graphene::chain::account_id_type& account_id = balance_object.account_id; + const graphene::chain::share_type& sharedrop_amount = balance_object.sharedrop; + const graphene::chain::account_object& account_obj = account_id(d); + if (already_generated.find(account_id) == already_generated.end()) + { + graphene::chain::genesis_state_type::initial_bts_account_type::initial_authority owner; + owner.weight_threshold = account_obj.owner.weight_threshold; + owner.key_auths = account_obj.owner.key_auths; + for (const auto& value : account_obj.owner.account_auths) + { + owner.account_auths.insert(std::make_pair(modify_account_name(value.first(d).name), value.second)); + auto owner_balance_iter = sharedrop_balances.find(value.first); + if (owner_balance_iter == sharedrop_balances.end()) + { + uia_sharedrop_balance_object balance_object; + balance_object.account_id = value.first; + sharedrop_balances.insert(balance_object); + } + } + owner.key_auths = account_obj.owner.key_auths; + owner.address_auths = account_obj.owner.address_auths; + + graphene::chain::genesis_state_type::initial_bts_account_type::initial_authority active; + active.weight_threshold = account_obj.active.weight_threshold; + active.key_auths = account_obj.active.key_auths; + for (const auto& value : account_obj.active.account_auths) + { + active.account_auths.insert(std::make_pair(modify_account_name(value.first(d).name), value.second)); + auto active_balance_iter = sharedrop_balances.find(value.first); + if (active_balance_iter == sharedrop_balances.end()) + { + uia_sharedrop_balance_object balance_object; + balance_object.account_id = value.first; + sharedrop_balances.insert(balance_object); + } + } + active.key_auths = account_obj.active.key_auths; + active.address_auths = account_obj.active.address_auths; + + new_genesis_state.initial_bts_accounts.emplace_back( + graphene::chain::genesis_state_type::initial_bts_account_type(modify_account_name(account_obj.name), + owner, active, + sharedrop_amount)); + already_generated.insert(account_id); + ++accounts_generated_this_round; + } + } + if (accounts_generated_this_round == 0) + break; + } + fc::json::save_to_file(new_genesis_state, _output_genesis_filename); + ilog("New genesis state written to file ${filename}", ("filename", _output_genesis_filename)); +} + +void generate_uia_sharedrop_genesis_plugin::plugin_shutdown() +{ +} + diff --git a/libraries/plugins/generate_uia_sharedrop_genesis/include/graphene/generate_uia_sharedrop_genesis/generate_uia_sharedrop_genesis.hpp b/libraries/plugins/generate_uia_sharedrop_genesis/include/graphene/generate_uia_sharedrop_genesis/generate_uia_sharedrop_genesis.hpp new file mode 100644 index 00000000..d83595b8 --- /dev/null +++ b/libraries/plugins/generate_uia_sharedrop_genesis/include/graphene/generate_uia_sharedrop_genesis/generate_uia_sharedrop_genesis.hpp @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2015 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 +#include + +#include + +namespace graphene { namespace generate_uia_sharedrop_genesis { + +class generate_uia_sharedrop_genesis_plugin : public graphene::app::plugin { +public: + ~generate_uia_sharedrop_genesis_plugin() { + } + + std::string plugin_name()const override; + + virtual void plugin_set_program_options( + boost::program_options::options_description &command_line_options, + boost::program_options::options_description &config_file_options + ) override; + + virtual void plugin_initialize( const boost::program_options::variables_map& options ) override; + virtual void plugin_startup() override; + virtual void plugin_shutdown() override; + +private: + void block_applied(const graphene::chain::signed_block& b); + void generate_snapshot(); + + boost::program_options::variables_map _options; + + fc::optional _block_to_snapshot; + std::string _input_genesis_filename; + std::string _output_genesis_filename; + std::string _csvlog_filename; +}; + +class uia_sharedrop_balance_object +{ +public: + graphene::chain::account_id_type account_id; + + graphene::chain::share_type genesis; + graphene::chain::share_type balance; + graphene::chain::share_type orders; + + graphene::chain::share_type sharedrop; +}; + +using namespace boost::multi_index; +struct by_account{}; +typedef multi_index_container, + member > > > uia_sharedrop_balance_object_index_type; + +} } //graphene::generate_uia_sharedrop_genesis_plugin diff --git a/programs/witness_node/CMakeLists.txt b/programs/witness_node/CMakeLists.txt index bc40538f..7535d3ad 100644 --- a/programs/witness_node/CMakeLists.txt +++ b/programs/witness_node/CMakeLists.txt @@ -11,7 +11,8 @@ endif() # We have to link against graphene_debug_witness because deficiency in our API infrastructure doesn't allow plugins to be fully abstracted #246 target_link_libraries( witness_node - PRIVATE graphene_app graphene_account_history graphene_market_history graphene_generate_genesis graphene_witness graphene_chain graphene_debug_witness graphene_egenesis_full fc ${CMAKE_DL_LIBS} ${PLATFORM_SPECIFIC_LIBS} ) + PRIVATE graphene_app graphene_account_history graphene_market_history graphene_witness graphene_chain graphene_debug_witness graphene_egenesis_full fc ${CMAKE_DL_LIBS} ${PLATFORM_SPECIFIC_LIBS} ) +# also add dependencies to graphene_generate_genesis graphene_generate_uia_sharedrop_genesis if you want those plugins install( TARGETS witness_node diff --git a/programs/witness_node/main.cpp b/programs/witness_node/main.cpp index 0995899f..2f41676c 100644 --- a/programs/witness_node/main.cpp +++ b/programs/witness_node/main.cpp @@ -26,7 +26,8 @@ #include #include #include -#include +//#include +//#include #include #include @@ -76,6 +77,7 @@ int main(int argc, char** argv) { auto history_plug = node->register_plugin(); auto market_history_plug = node->register_plugin(); //auto generate_genesis_plug = node->register_plugin(); + //auto generate_uia_sharedrop_genesis_plug = node->register_plugin(); try { From 29402ddff3833fc9b6f031b3be3e6fc3f18982f6 Mon Sep 17 00:00:00 2001 From: SynaptiCAD User Date: Wed, 31 May 2017 22:19:10 -0400 Subject: [PATCH 06/15] [DLN] experimenting with RNG vs shuffle algorithm in tests --- tests/common/database_fixture.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/common/database_fixture.cpp b/tests/common/database_fixture.cpp index bafc5695..d1b9119d 100644 --- a/tests/common/database_fixture.cpp +++ b/tests/common/database_fixture.cpp @@ -80,7 +80,8 @@ database_fixture::database_fixture() boost::program_options::variables_map options; genesis_state.initial_timestamp = time_point_sec( GRAPHENE_TESTING_GENESIS_TIMESTAMP ); - genesis_state.initial_parameters.witness_schedule_algorithm = GRAPHENE_WITNESS_SHUFFLED_ALGORITHM; + genesis_state.initial_timestamp = time_point_sec( (fc::time_point::now().sec_since_epoch() / GRAPHENE_DEFAULT_BLOCK_INTERVAL) * GRAPHENE_DEFAULT_BLOCK_INTERVAL ); +// genesis_state.initial_parameters.witness_schedule_algorithm = GRAPHENE_WITNESS_SHUFFLED_ALGORITHM; genesis_state.initial_active_witnesses = 10; for( unsigned i = 0; i < genesis_state.initial_active_witnesses; ++i ) From e3b4c28f9b7d69f1e1f2de25724645f2ce3ed14c Mon Sep 17 00:00:00 2001 From: SynaptiCAD User Date: Thu, 1 Jun 2017 11:37:59 -0400 Subject: [PATCH 07/15] [DLN] revert some test code related to worker-pay that was inadvertently committed in a larger commit --- libraries/chain/db_maint.cpp | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/libraries/chain/db_maint.cpp b/libraries/chain/db_maint.cpp index 02ce842c..191062e5 100644 --- a/libraries/chain/db_maint.cpp +++ b/libraries/chain/db_maint.cpp @@ -377,7 +377,6 @@ void database::initialize_budget_record( fc::time_point_sec now, budget_record& */ void database::process_budget() { - return; try { const global_property_object& gpo = get_global_properties(); @@ -414,9 +413,9 @@ void database::process_budget() rec.witness_budget = witness_budget; available_funds -= witness_budget; - fc::uint128_t worker_budget_u128 = uint64_t(1); //DLN Q&D HACK gpo.parameters.worker_budget_per_day.value; - //DLN worker_budget_u128 *= uint64_t(time_to_maint); - //DLN worker_budget_u128 /= 60*60*24; + fc::uint128_t worker_budget_u128 = gpo.parameters.worker_budget_per_day.value; + worker_budget_u128 *= uint64_t(time_to_maint); + worker_budget_u128 /= 60*60*24; share_type worker_budget; if( worker_budget_u128 >= available_funds.value ) From 3cc82f002257d53bc02e343f9db019a21105d650 Mon Sep 17 00:00:00 2001 From: Eric Frias Date: Thu, 1 Jun 2017 15:27:38 -0400 Subject: [PATCH 08/15] Change unique index to non-unique on vesting_balance_objects --- .../chain/include/graphene/chain/vesting_balance_object.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libraries/chain/include/graphene/chain/vesting_balance_object.hpp b/libraries/chain/include/graphene/chain/vesting_balance_object.hpp index 49b3464c..dc2fe18c 100644 --- a/libraries/chain/include/graphene/chain/vesting_balance_object.hpp +++ b/libraries/chain/include/graphene/chain/vesting_balance_object.hpp @@ -181,7 +181,7 @@ namespace graphene { namespace chain { ordered_non_unique< tag, member >, - ordered_unique< tag, + ordered_non_unique< tag, composite_key< vesting_balance_object, member_offset, From 7a2eb925636d27755e31131225b0fbaa53b8e928 Mon Sep 17 00:00:00 2001 From: Eric Frias Date: Thu, 1 Jun 2017 16:58:56 -0400 Subject: [PATCH 09/15] Automatically update wallet's cached copy of account objects whenever we are notified of a change on the blockchain --- libraries/wallet/wallet.cpp | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/libraries/wallet/wallet.cpp b/libraries/wallet/wallet.cpp index d164612e..e2c78e54 100644 --- a/libraries/wallet/wallet.cpp +++ b/libraries/wallet/wallet.cpp @@ -451,6 +451,20 @@ private: { // idump((e)); } + try + { + object_id_type id = changed_object_variant["id"].as(); + if (_wallet.my_accounts.find(id) != _wallet.my_accounts.end()) + { + account_object account = changed_object_variant.as(); + _wallet.update_account(account); + } + continue; + } + catch (const fc::exception& e) + { + // idump((e)); + } } } } From 03ec007cbb5f881a96f6cb9ae42a4c5a696a3c3f Mon Sep 17 00:00:00 2001 From: Eric Frias Date: Thu, 1 Jun 2017 16:59:40 -0400 Subject: [PATCH 10/15] Quiet unhelpful log message "Not producing block because slot has not yet arrived" --- libraries/plugins/witness/witness.cpp | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/libraries/plugins/witness/witness.cpp b/libraries/plugins/witness/witness.cpp index a3a73133..dceaf586 100644 --- a/libraries/plugins/witness/witness.cpp +++ b/libraries/plugins/witness/witness.cpp @@ -201,7 +201,7 @@ block_production_condition::block_production_condition_enum witness_plugin::bloc ilog("Not producing block because it isn't my turn"); break; case block_production_condition::not_time_yet: - ilog("Not producing block because slot has not yet arrived"); + dlog("Not producing block because slot has not yet arrived"); break; case block_production_condition::no_private_key: ilog("Not producing block because I don't have the private key for ${scheduled_key}", (capture) ); @@ -228,9 +228,7 @@ block_production_condition::block_production_condition_enum witness_plugin::mayb { chain::database& db = database(); fc::time_point now_fine = graphene::time::now(); - fc::time_point_sec now = now_fine; - if (db.get_global_properties().parameters.witness_schedule_algorithm == GRAPHENE_WITNESS_SHUFFLED_ALGORITHM) - now += fc::microseconds( 500000 ); + fc::time_point_sec now = now_fine + fc::microseconds( 500000 ); // If the next block production opportunity is in the present or future, we're synced. if( !_production_enabled ) From cc77db04107788896641355b6f4c599c4fc0cd0b Mon Sep 17 00:00:00 2001 From: Eric Frias Date: Thu, 1 Jun 2017 17:05:35 -0400 Subject: [PATCH 11/15] comment out excessive debug logging --- libraries/chain/db_maint.cpp | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/libraries/chain/db_maint.cpp b/libraries/chain/db_maint.cpp index 191062e5..b701259c 100644 --- a/libraries/chain/db_maint.cpp +++ b/libraries/chain/db_maint.cpp @@ -767,9 +767,9 @@ void schedule_pending_dividend_balances(database& db, for (const vesting_balance_object& vesting_balance_obj : boost::make_iterator_range(vesting_balances_begin, vesting_balances_end)) { vesting_amounts[vesting_balance_obj.owner] += vesting_balance_obj.balance.amount; - dlog("Vesting balance for account: ${owner}, amount: ${amount}", - ("owner", vesting_balance_obj.owner(db).name) - ("amount", vesting_balance_obj.balance.amount)); + //dlog("Vesting balance for account: ${owner}, amount: ${amount}", + // ("owner", vesting_balance_obj.owner(db).name) + // ("amount", vesting_balance_obj.balance.amount)); } auto current_distribution_account_balance_iter = current_distribution_account_balance_range.first; @@ -1232,9 +1232,9 @@ void database::perform_chain_maintenance(const signed_block& next_block, const g for (const vesting_balance_object& vesting_balance_obj : boost::make_iterator_range(vesting_balances_begin, vesting_balances_end)) { vesting_amounts[vesting_balance_obj.owner] += vesting_balance_obj.balance.amount; - dlog("Vesting balance for account: ${owner}, amount: ${amount}", - ("owner", vesting_balance_obj.owner(d).name) - ("amount", vesting_balance_obj.balance.amount)); + //dlog("Vesting balance for account: ${owner}, amount: ${amount}", + // ("owner", vesting_balance_obj.owner(d).name) + // ("amount", vesting_balance_obj.balance.amount)); } } From 6234716eea71042775276c4a5e42b0b7f074e7d7 Mon Sep 17 00:00:00 2001 From: Eric Frias Date: Thu, 1 Jun 2017 17:46:32 -0400 Subject: [PATCH 12/15] Add a command 'update_witness_votes' to the CLI wallet that allows you to change multiple witness votes at one time (just a convenience, it doesn't do anything vote_for_witness didn't already let you do) --- .../wallet/include/graphene/wallet/wallet.hpp | 33 +++++++++++ libraries/wallet/wallet.cpp | 56 ++++++++++++++++++- 2 files changed, 86 insertions(+), 3 deletions(-) diff --git a/libraries/wallet/include/graphene/wallet/wallet.hpp b/libraries/wallet/include/graphene/wallet/wallet.hpp index 4d109171..0ac0b88a 100644 --- a/libraries/wallet/include/graphene/wallet/wallet.hpp +++ b/libraries/wallet/include/graphene/wallet/wallet.hpp @@ -1349,6 +1349,38 @@ class wallet_api bool approve, bool broadcast = false); + /** Change your witness votes. + * + * An account can publish a list of all witnesses they approve of. + * Each account's vote is weighted according to the number of shares of the + * core asset owned by that account at the time the votes are tallied. + * This command allows you to add or remove one or more witnesses from this list + * in one call. When you are changing your vote on several witnesses, this + * may be easier than multiple `vote_for_witness` and + * `set_desired_witness_and_committee_member_count` calls. + * + * @note you cannot vote against a witness, you can only vote for the witness + * or not vote for the witness. + * + * @param voting_account the name or id of the account who is voting with their shares + * @param witnesses_to_approve the names or ids of the witnesses owner accounts you wish + * to approve (these will be added to the list of witnesses + * you currently approve). This list can be empty. + * @param witnesses_to_reject the names or ids of the witnesses owner accounts you wish + * to reject (these will be removed fromthe list of witnesses + * you currently approve). This list can be empty. + * @param desired_number_of_witnesses the number of witnesses you believe the network + * should have. You must vote for at least this many + * witnesses. You can set this to 0 to abstain from + * voting on the number of witnesses. + * @param broadcast true if you wish to broadcast the transaction + * @return the signed transaction changing your vote for the given witnesses + */ + signed_transaction update_witness_votes(string voting_account, + std::vector witnesses_to_approve, + std::vector witnesses_to_reject, + uint16_t desired_number_of_witnesses, + bool broadcast = false); /** Set the voting proxy for an account. * * If a user does not wish to take an active part in voting, they can choose @@ -1700,6 +1732,7 @@ FC_API( graphene::wallet::wallet_api, (withdraw_vesting) (vote_for_committee_member) (vote_for_witness) + (update_witness_votes) (set_voting_proxy) (set_desired_witness_and_committee_member_count) (get_account) diff --git a/libraries/wallet/wallet.cpp b/libraries/wallet/wallet.cpp index e2c78e54..8f24192a 100644 --- a/libraries/wallet/wallet.cpp +++ b/libraries/wallet/wallet.cpp @@ -2018,9 +2018,9 @@ public: } FC_CAPTURE_AND_RETHROW( (voting_account)(committee_member)(approve)(broadcast) ) } signed_transaction vote_for_witness(string voting_account, - string witness, - bool approve, - bool broadcast /* = false */) + string witness, + bool approve, + bool broadcast /* = false */) { try { account_object voting_account_object = get_account(voting_account); account_id_type witness_owner_account_id = get_account_id(witness); @@ -2051,6 +2051,47 @@ public: return sign_transaction( tx, broadcast ); } FC_CAPTURE_AND_RETHROW( (voting_account)(witness)(approve)(broadcast) ) } + signed_transaction update_witness_votes(string voting_account, + std::vector witnesses_to_approve, + std::vector witnesses_to_reject, + uint16_t desired_number_of_witnesses, + bool broadcast /* = false */) + { try { + account_object voting_account_object = get_account(voting_account); + for (const std::string& witness : witnesses_to_approve) + { + account_id_type witness_owner_account_id = get_account_id(witness); + fc::optional witness_obj = _remote_db->get_witness_by_account(witness_owner_account_id); + if (!witness_obj) + FC_THROW("Account ${witness} is not registered as a witness", ("witness", witness)); + auto insert_result = voting_account_object.options.votes.insert(witness_obj->vote_id); + if (!insert_result.second) + FC_THROW("Account ${account} was already voting for witness ${witness}", ("account", voting_account)("witness", witness)); + } + for (const std::string& witness : witnesses_to_reject) + { + account_id_type witness_owner_account_id = get_account_id(witness); + fc::optional witness_obj = _remote_db->get_witness_by_account(witness_owner_account_id); + if (!witness_obj) + FC_THROW("Account ${witness} is not registered as a witness", ("witness", witness)); + unsigned votes_removed = voting_account_object.options.votes.erase(witness_obj->vote_id); + if (!votes_removed) + FC_THROW("Account ${account} is already not voting for witness ${witness}", ("account", voting_account)("witness", witness)); + } + voting_account_object.options.num_witness = desired_number_of_witnesses; + + account_update_operation account_update_op; + account_update_op.account = voting_account_object.id; + account_update_op.new_options = voting_account_object.options; + + signed_transaction tx; + tx.operations.push_back( account_update_op ); + set_operation_fees( tx, _remote_db->get_global_properties().parameters.current_fees); + tx.validate(); + + return sign_transaction( tx, broadcast ); + } FC_CAPTURE_AND_RETHROW( (voting_account)(witnesses_to_approve)(witnesses_to_reject)(desired_number_of_witnesses)(broadcast) ) } + signed_transaction set_voting_proxy(string account_to_modify, optional voting_account, bool broadcast /* = false */) @@ -3870,6 +3911,15 @@ signed_transaction wallet_api::vote_for_witness(string voting_account, return my->vote_for_witness(voting_account, witness, approve, broadcast); } +signed_transaction wallet_api::update_witness_votes(string voting_account, + std::vector witnesses_to_approve, + std::vector witnesses_to_reject, + uint16_t desired_number_of_witnesses, + bool broadcast /* = false */) +{ + return my->update_witness_votes(voting_account, witnesses_to_approve, witnesses_to_reject, desired_number_of_witnesses, broadcast); +} + signed_transaction wallet_api::set_voting_proxy(string account_to_modify, optional voting_account, bool broadcast /* = false */) From f6bf447820ac339e78f56c7fc66e3f898dcf994a Mon Sep 17 00:00:00 2001 From: Eric Frias Date: Fri, 2 Jun 2017 19:12:12 -0400 Subject: [PATCH 13/15] Add functionality to genesis_update.cpp that replaces all keys in a genesis file with newly-generated dev keys for testing. --- programs/genesis_util/genesis_update.cpp | 172 +++++++++++++++++------ 1 file changed, 127 insertions(+), 45 deletions(-) diff --git a/programs/genesis_util/genesis_update.cpp b/programs/genesis_util/genesis_update.cpp index 0dec0165..52329301 100644 --- a/programs/genesis_util/genesis_update.cpp +++ b/programs/genesis_util/genesis_update.cpp @@ -70,6 +70,8 @@ int main( int argc, char** argv ) ("dev-account-count", bpo::value()->default_value(0), "Prefix for dev accounts") ("dev-balance-count", bpo::value()->default_value(0), "Prefix for dev balances") ("dev-balance-amount", bpo::value()->default_value(uint64_t(1000)*uint64_t(1000)*uint64_t(100000)), "Amount in each dev balance") + ("nop", "just write the genesis file out after reading it in, do not alter any keys or add accounts or balances. used to pretty-print a genesis file") + ("replace-all-keys", bpo::value(), "Replace all keys/addresses in the genesis files with dev keys based on dev-key-prefix and dump the new keys to this filename.") ; bpo::variables_map options; @@ -116,54 +118,134 @@ int main( int argc, char** argv ) genesis = graphene::app::detail::create_example_genesis(); } - std::string dev_key_prefix = options["dev-key-prefix"].as(); - - auto get_dev_key = [&]( std::string prefix, uint32_t i ) -> public_key_type + if (!options.count("nop")) { - return fc::ecc::private_key::regenerate( fc::sha256::hash( dev_key_prefix + prefix + std::to_string(i) ) ).get_public_key(); - }; - - uint32_t dev_account_count = options["dev-account-count"].as(); - std::string dev_account_prefix = options["dev-account-prefix"].as(); - for(uint32_t i=0;i(); - uint64_t dev_balance_amount = options["dev-balance-amount"].as(); - for(uint32_t i=0;i name2index; - size_t num_accounts = genesis.initial_accounts.size(); - for( size_t i=0; i(); + auto get_dev_key = [&]( std::string prefix, uint32_t i ) -> public_key_type { - std::cerr << "need " << genesis.initial_active_witnesses << " init accounts as first entries in initial_active_witnesses\n"; - return 1; + return fc::ecc::private_key::regenerate( fc::sha256::hash( dev_key_prefix + prefix + std::to_string(i) ) ).get_public_key(); + }; + + if (options.count("replace-all-keys")) + { + unsigned dev_keys_used = 0; + std::map replacement_keys; + auto get_replacement_key = [&](const std::string& original_key) -> fc::ecc::private_key { + auto iter = replacement_keys.find(original_key); + if (iter != replacement_keys.end()) + return iter->second; + fc::ecc::private_key new_private_key = fc::ecc::private_key::regenerate(fc::sha256::hash(dev_key_prefix + std::to_string(dev_keys_used++))); + replacement_keys[original_key] = new_private_key; + return new_private_key; + }; + + for (genesis_state_type::initial_balance_type& initial_balance : genesis.initial_balances) + { + std::string address_string = (std::string)initial_balance.owner; + initial_balance.owner = address(get_replacement_key(address_string).get_public_key()); + } + + for (genesis_state_type::initial_vesting_balance_type& initial_balance : genesis.initial_vesting_balances) + { + std::string address_string = (std::string)initial_balance.owner; + initial_balance.owner = address(get_replacement_key(address_string).get_public_key()); + } + + for (genesis_state_type::initial_witness_type& initial_witness : genesis.initial_witness_candidates) + { + std::string public_key_string = (std::string)initial_witness.block_signing_key; + initial_witness.block_signing_key = get_replacement_key(public_key_string).get_public_key(); + } + + for (genesis_state_type::initial_account_type& initial_account : genesis.initial_accounts) + { + std::string public_key_string = (std::string)initial_account.owner_key; + initial_account.owner_key = get_replacement_key(public_key_string).get_public_key(); + public_key_string = (std::string)initial_account.active_key; + initial_account.active_key = get_replacement_key(public_key_string).get_public_key(); + } + + for (genesis_state_type::initial_bts_account_type& initial_account : genesis.initial_bts_accounts) + { + for (auto iter = initial_account.owner_authority.key_auths.begin(); + iter != initial_account.owner_authority.key_auths.end(); ++iter) + { + std::string public_key_string = (std::string)iter->first; + iter->first = get_replacement_key(public_key_string).get_public_key(); + } + for (auto iter = initial_account.active_authority.key_auths.begin(); + iter != initial_account.active_authority.key_auths.end(); ++iter) + { + std::string public_key_string = (std::string)iter->first; + iter->first = get_replacement_key(public_key_string).get_public_key(); + } + for (auto iter = initial_account.owner_authority.address_auths.begin(); + iter != initial_account.owner_authority.address_auths.end(); ++iter) + { + std::string address_string = (std::string)iter->first; + iter->first = address(get_replacement_key(address_string).get_public_key()); + } + for (auto iter = initial_account.active_authority.address_auths.begin(); + iter != initial_account.active_authority.address_auths.end(); ++iter) + { + std::string address_string = (std::string)iter->first; + iter->first = address(get_replacement_key(address_string).get_public_key()); + } + } + fc::path keys_csv_path = options["replace-all-keys"].as(); + std::ofstream keys_csv(keys_csv_path.string()); + keys_csv << "wif_private_key,public_key,address\n"; + for (const auto& value : replacement_keys) + keys_csv << graphene::utilities::key_to_wif(value.second) << "," << std::string(public_key_type(value.second.get_public_key())) + << "," << std::string(address(value.second.get_public_key())) << "\n"; + + + } + else + { + uint32_t dev_account_count = options["dev-account-count"].as(); + std::string dev_account_prefix = options["dev-account-prefix"].as(); + for(uint32_t i=0;i(); + uint64_t dev_balance_amount = options["dev-balance-amount"].as(); + for(uint32_t i=0;i name2index; + size_t num_accounts = genesis.initial_accounts.size(); + for( size_t i=0; i(); From ea7e8e6f31519978f37e77a3e2bf1e133ef96895 Mon Sep 17 00:00:00 2001 From: Eric Frias Date: Sun, 4 Jun 2017 18:26:50 -0400 Subject: [PATCH 14/15] Support genesis vesting balances tied to account objects --- libraries/chain/db_init.cpp | 30 ++++++++++++++- .../include/graphene/chain/genesis_state.hpp | 38 ++++++++++++++++++- 2 files changed, 65 insertions(+), 3 deletions(-) diff --git a/libraries/chain/db_init.cpp b/libraries/chain/db_init.cpp index 81880f59..e7ae7f2b 100644 --- a/libraries/chain/db_init.cpp +++ b/libraries/chain/db_init.cpp @@ -641,7 +641,7 @@ void database::init_genesis(const genesis_state_type& genesis_state) } // Create balances for all bts accounts - for( const auto& account : genesis_state.initial_bts_accounts ) + for( const auto& account : genesis_state.initial_bts_accounts ) { if (account.core_balance != share_type()) { total_supplies[asset_id_type()] += account.core_balance; @@ -651,6 +651,34 @@ void database::init_genesis(const genesis_state_type& genesis_state) }); } + // create any vesting balances for this account + if (account.vesting_balances) + for (const auto& vesting_balance : *account.vesting_balances) { + create([&](vesting_balance_object& vbo) { + vbo.owner = get_account_id(account.name); + vbo.balance = asset(vesting_balance.amount, get_asset_id(vesting_balance.asset_symbol)); + if (vesting_balance.policy_type == "linear") { + auto initial_linear_vesting_policy = vesting_balance.policy.as(); + linear_vesting_policy new_vesting_policy; + new_vesting_policy.begin_timestamp = initial_linear_vesting_policy.begin_timestamp; + new_vesting_policy.vesting_cliff_seconds = initial_linear_vesting_policy.vesting_cliff_seconds; + new_vesting_policy.vesting_duration_seconds = initial_linear_vesting_policy.vesting_duration_seconds; + new_vesting_policy.begin_balance = initial_linear_vesting_policy.begin_balance; + vbo.policy = new_vesting_policy; + } else if (vesting_balance.policy_type == "cdd") { + auto initial_cdd_vesting_policy = vesting_balance.policy.as(); + cdd_vesting_policy new_vesting_policy; + new_vesting_policy.vesting_seconds = initial_cdd_vesting_policy.vesting_seconds; + new_vesting_policy.coin_seconds_earned = initial_cdd_vesting_policy.coin_seconds_earned; + new_vesting_policy.start_claim = initial_cdd_vesting_policy.start_claim; + new_vesting_policy.coin_seconds_earned_last_update = initial_cdd_vesting_policy.coin_seconds_earned_last_update; + vbo.policy = new_vesting_policy; + } + }); + } + } + + // Create initial balances share_type total_allocation; for( const auto& handout : genesis_state.initial_balances ) diff --git a/libraries/chain/include/graphene/chain/genesis_state.hpp b/libraries/chain/include/graphene/chain/genesis_state.hpp index 53561485..42973df8 100644 --- a/libraries/chain/include/graphene/chain/genesis_state.hpp +++ b/libraries/chain/include/graphene/chain/genesis_state.hpp @@ -59,6 +59,24 @@ struct genesis_state_type { flat_map key_auths; flat_map address_auths; }; + struct initial_cdd_vesting_policy { + uint32_t vesting_seconds; + fc::uint128_t coin_seconds_earned; + fc::time_point_sec start_claim; + fc::time_point_sec coin_seconds_earned_last_update; + }; + struct initial_linear_vesting_policy { + fc::time_point_sec begin_timestamp; + uint32_t vesting_cliff_seconds; + uint32_t vesting_duration_seconds; + share_type begin_balance; + }; + struct initial_vesting_balance { + string asset_symbol; + share_type amount; + std::string policy_type; // either "linear" or "cdd" + fc::variant policy; // either an initial_cdd_vesting_policy or initial_linear_vesting_policy + }; initial_bts_account_type(const string& name = string(), const initial_authority& owner_authority = initial_authority(), const initial_authority& active_authority = initial_authority(), @@ -72,6 +90,7 @@ struct genesis_state_type { initial_authority owner_authority; initial_authority active_authority; share_type core_balance; + fc::optional > vesting_balances; }; struct initial_asset_type { struct initial_collateral_position { @@ -174,12 +193,27 @@ FC_REFLECT(graphene::chain::genesis_state_type::initial_bts_account_type::initia (account_auths) (key_auths) (address_auths)) - +FC_REFLECT(graphene::chain::genesis_state_type::initial_bts_account_type::initial_cdd_vesting_policy, + (vesting_seconds) + (coin_seconds_earned) + (start_claim) + (coin_seconds_earned_last_update)) +FC_REFLECT(graphene::chain::genesis_state_type::initial_bts_account_type::initial_linear_vesting_policy, + (begin_timestamp) + (vesting_cliff_seconds) + (vesting_duration_seconds) + (begin_balance)) +FC_REFLECT(graphene::chain::genesis_state_type::initial_bts_account_type::initial_vesting_balance, + (asset_symbol) + (amount) + (policy_type) + (policy)) FC_REFLECT(graphene::chain::genesis_state_type::initial_bts_account_type, (name) (owner_authority) (active_authority) - (core_balance)) + (core_balance) + (vesting_balances)) FC_REFLECT(graphene::chain::genesis_state_type, (initial_timestamp)(max_core_supply)(initial_parameters)(initial_bts_accounts)(initial_accounts)(initial_assets)(initial_balances) From 38b2767567a9186621ee015815c05fad2783c2a5 Mon Sep 17 00:00:00 2001 From: Eric Frias Date: Mon, 5 Jun 2017 12:31:14 -0400 Subject: [PATCH 15/15] Support specifying cliff_seconds in initial_vesting_balances --- libraries/chain/db_init.cpp | 2 +- libraries/chain/include/graphene/chain/genesis_state.hpp | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/libraries/chain/db_init.cpp b/libraries/chain/db_init.cpp index e7ae7f2b..2ab6b882 100644 --- a/libraries/chain/db_init.cpp +++ b/libraries/chain/db_init.cpp @@ -702,7 +702,7 @@ void database::init_genesis(const genesis_state_type& genesis_state) linear_vesting_policy policy; policy.begin_timestamp = vest.begin_timestamp; - policy.vesting_cliff_seconds = 0; + policy.vesting_cliff_seconds = vest.vesting_cliff_seconds ? *vest.vesting_cliff_seconds : 0; policy.vesting_duration_seconds = vest.vesting_duration_seconds; policy.begin_balance = vest.begin_balance; diff --git a/libraries/chain/include/graphene/chain/genesis_state.hpp b/libraries/chain/include/graphene/chain/genesis_state.hpp index 42973df8..ebd153b6 100644 --- a/libraries/chain/include/graphene/chain/genesis_state.hpp +++ b/libraries/chain/include/graphene/chain/genesis_state.hpp @@ -121,6 +121,7 @@ struct genesis_state_type { string asset_symbol; share_type amount; time_point_sec begin_timestamp; + fc::optional vesting_cliff_seconds; uint32_t vesting_duration_seconds = 0; share_type begin_balance; }; @@ -180,7 +181,7 @@ FC_REFLECT(graphene::chain::genesis_state_type::initial_balance_type, (owner)(asset_symbol)(amount)) FC_REFLECT(graphene::chain::genesis_state_type::initial_vesting_balance_type, - (owner)(asset_symbol)(amount)(begin_timestamp)(vesting_duration_seconds)(begin_balance)) + (owner)(asset_symbol)(amount)(begin_timestamp)(vesting_cliff_seconds)(vesting_duration_seconds)(begin_balance)) FC_REFLECT(graphene::chain::genesis_state_type::initial_witness_type, (owner_name)(block_signing_key))