Peerplays_Blockchain/peerplays_migrated
1
0
Fork 0
Code Issues 35 Pull requests 4 Projects Releases 20 Packages Wiki Activity Actions

Merge branch 'master' of github.com:cryptonomex/graphene

Browse source
This commit is contained in:
Daniel Larimer 2015-07-13 16:23:22 -04:00
commit 0beeac94aa
59 changed files with 656 additions and 629 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
README.md
View file

@ -191,9 +191,9 @@ Questions
Yes. Documentation of the code base, including APIs, can be generated using Doxygen. Simply run `doxygen` in this directory. Yes. Documentation of the code base, including APIs, can be generated using Doxygen. Simply run `doxygen` in this directory.
If both Doxygen and perl are available in your build environment, the CLI wallet's `help` and `gethelp` If both Doxygen and perl are available in your build environment, the CLI wallet's `help` and `gethelp`
commands will display help generated from the doxygen documentation. commands will display help generated from the doxygen documentation.
If your CLI wallet's `help` command displays descriptions without parameter names like If your CLI wallet's `help` command displays descriptions without parameter names like
`signed_transaction transfer(string, string, string, string, string, bool)` `signed_transaction transfer(string, string, string, string, string, bool)`
it means CMake was unable to find Doxygen or perl during configuration. If found, the it means CMake was unable to find Doxygen or perl during configuration. If found, the
output should look like this: output should look like this:
@ -231,8 +231,8 @@ Questions
- The answer to the previous question was really confusing. Can you make it clearer? - The answer to the previous question was really confusing. Can you make it clearer?
All account ID's are of the form `1.2.x`. If you were the 9735th account to be registered, All account ID's are of the form `1.2.x`. If you were the 9735th account to be registered,
your account's ID will be `1.2.9735`. Account `0` is special (it's the "genesis account," your account's ID will be `1.2.9735`. Account `0` is special (it's the "committee account,"
which is controlled by the delegates and has a few abilities and restrictions other accounts which is controlled by the committee members and has a few abilities and restrictions other accounts
do not). do not).
All asset ID's are of the form `1.3.x`. If you were the 29th asset to be registered, All asset ID's are of the form `1.3.x`. If you were the 29th asset to be registered,

2
docs

@ -1 +1 @@
Subproject commit f3012a7328227e90da6ded944c3c4bf2a4ab94a0 Subproject commit 97435c1a622e41e0a5fc1be72aaadea62e1b7adb

38
libraries/app/api.cpp
View file

@ -247,9 +247,9 @@ namespace graphene { namespace app {
return result; return result;
} }
fc::optional<delegate_object> database_api::get_delegate_by_account(account_id_type account) const fc::optional<committee_member_object> database_api::get_committee_member_by_account(account_id_type account) const
{ {
const auto& idx = _db.get_index_type<delegate_index>().indices().get<by_account>(); const auto& idx = _db.get_index_type<committee_member_index>().indices().get<by_account>();
auto itr = idx.find(account); auto itr = idx.find(account);
if( itr != idx.end() ) if( itr != idx.end() )
return *itr; return *itr;
@ -293,27 +293,27 @@ namespace graphene { namespace app {
return witnesses_by_account_name; return witnesses_by_account_name;
} }
map<string, delegate_id_type> database_api::lookup_delegate_accounts(const string& lower_bound_name, uint32_t limit)const map<string, committee_member_id_type> database_api::lookup_committee_member_accounts(const string& lower_bound_name, uint32_t limit)const
{ {
FC_ASSERT( limit <= 1000 ); FC_ASSERT( limit <= 1000 );
const auto& delegates_by_id = _db.get_index_type<delegate_index>().indices().get<by_id>(); const auto& committee_members_by_id = _db.get_index_type<committee_member_index>().indices().get<by_id>();
// we want to order delegates by account name, but that name is in the account object // we want to order committee_members by account name, but that name is in the account object
// so the delegate_index doesn't have a quick way to access it. // so the committee_member_index doesn't have a quick way to access it.
// get all the names and look them all up, sort them, then figure out what // get all the names and look them all up, sort them, then figure out what
// records to return. This could be optimized, but we expect the // records to return. This could be optimized, but we expect the
// number of delegates to be few and the frequency of calls to be rare // number of committee_members to be few and the frequency of calls to be rare
std::map<std::string, delegate_id_type> delegates_by_account_name; std::map<std::string, committee_member_id_type> committee_members_by_account_name;
for (const delegate_object& delegate : delegates_by_id) for (const committee_member_object& committee_member : committee_members_by_id)
if (auto account_iter = _db.find(delegate.delegate_account)) if (auto account_iter = _db.find(committee_member.committee_member_account))
if (account_iter->name >= lower_bound_name) // we can ignore anything below lower_bound_name if (account_iter->name >= lower_bound_name) // we can ignore anything below lower_bound_name
delegates_by_account_name.insert(std::make_pair(account_iter->name, delegate.id)); committee_members_by_account_name.insert(std::make_pair(account_iter->name, committee_member.id));
auto end_iter = delegates_by_account_name.begin(); auto end_iter = committee_members_by_account_name.begin();
while (end_iter != delegates_by_account_name.end() && limit--) while (end_iter != committee_members_by_account_name.end() && limit--)
++end_iter; ++end_iter;
delegates_by_account_name.erase(end_iter, delegates_by_account_name.end()); committee_members_by_account_name.erase(end_iter, committee_members_by_account_name.end());
return delegates_by_account_name; return committee_members_by_account_name;
} }
vector<optional<witness_object>> database_api::get_witnesses(const vector<witness_id_type>& witness_ids)const vector<optional<witness_object>> database_api::get_witnesses(const vector<witness_id_type>& witness_ids)const
@ -328,11 +328,11 @@ namespace graphene { namespace app {
return result; return result;
} }
vector<optional<delegate_object>> database_api::get_delegates(const vector<delegate_id_type>& delegate_ids)const vector<optional<committee_member_object>> database_api::get_committee_members(const vector<committee_member_id_type>& committee_member_ids)const
{ {
vector<optional<delegate_object>> result; result.reserve(delegate_ids.size()); vector<optional<committee_member_object>> result; result.reserve(committee_member_ids.size());
std::transform(delegate_ids.begin(), delegate_ids.end(), std::back_inserter(result), std::transform(committee_member_ids.begin(), committee_member_ids.end(), std::back_inserter(result),
[this](delegate_id_type id) -> optional<delegate_object> { [this](committee_member_id_type id) -> optional<committee_member_object> {
if(auto o = _db.find(id)) if(auto o = _db.find(id))
return *o; return *o;
return {}; return {};

30
libraries/app/include/graphene/app/api.hpp
View file

@ -22,7 +22,7 @@
#include <graphene/chain/operation_history_object.hpp> #include <graphene/chain/operation_history_object.hpp>
#include <graphene/chain/asset_object.hpp> #include <graphene/chain/asset_object.hpp>
#include <graphene/chain/market_evaluator.hpp> #include <graphene/chain/market_evaluator.hpp>
#include <graphene/chain/delegate_object.hpp> #include <graphene/chain/committee_member_object.hpp>
#include <graphene/chain/witness_object.hpp> #include <graphene/chain/witness_object.hpp>
#include <graphene/chain/proposal_object.hpp> #include <graphene/chain/proposal_object.hpp>
#include <graphene/chain/balance_object.hpp> #include <graphene/chain/balance_object.hpp>
@ -170,11 +170,11 @@ namespace graphene { namespace app {
vector<asset_object> list_assets(const string& lower_bound_symbol, uint32_t limit)const; vector<asset_object> list_assets(const string& lower_bound_symbol, uint32_t limit)const;
/** /**
* @brief Get the delegate owned by a given account * @brief Get the committee_member owned by a given account
* @param account The ID of the account whose delegate should be retrieved * @param account The ID of the account whose committee_member should be retrieved
* @return The delegate object, or null if the account does not have a delegate * @return The committee_member object, or null if the account does not have a committee_member
*/ */
fc::optional<delegate_object> get_delegate_by_account(account_id_type account)const; fc::optional<committee_member_object> get_committee_member_by_account(account_id_type account)const;
/** /**
* @brief Get the witness owned by a given account * @brief Get the witness owned by a given account
* @param account The ID of the account whose witness should be retrieved * @param account The ID of the account whose witness should be retrieved
@ -196,12 +196,12 @@ namespace graphene { namespace app {
map<string, witness_id_type> lookup_witness_accounts(const string& lower_bound_name, uint32_t limit)const; map<string, witness_id_type> lookup_witness_accounts(const string& lower_bound_name, uint32_t limit)const;
/** /**
* @brief Get names and IDs for registered delegates * @brief Get names and IDs for registered committee_members
* @param lower_bound_name Lower bound of the first name to return * @param lower_bound_name Lower bound of the first name to return
* @param limit Maximum number of results to return -- must not exceed 1000 * @param limit Maximum number of results to return -- must not exceed 1000
* @return Map of delegate names to corresponding IDs * @return Map of committee_member names to corresponding IDs
*/ */
map<string, delegate_id_type> lookup_delegate_accounts(const string& lower_bound_name, uint32_t limit)const; map<string, committee_member_id_type> lookup_committee_member_accounts(const string& lower_bound_name, uint32_t limit)const;
/** /**
* @brief Get a list of witnesses by ID * @brief Get a list of witnesses by ID
@ -213,13 +213,13 @@ namespace graphene { namespace app {
vector<optional<witness_object>> get_witnesses(const vector<witness_id_type>& witness_ids)const; vector<optional<witness_object>> get_witnesses(const vector<witness_id_type>& witness_ids)const;
/** /**
* @brief Get a list of delegates by ID * @brief Get a list of committee_members by ID
* @param delegate_ids IDs of the delegates to retrieve * @param committee_member_ids IDs of the committee_members to retrieve
* @return The delegates corresponding to the provided IDs * @return The committee_members corresponding to the provided IDs
* *
* This function has semantics identical to @ref get_objects * This function has semantics identical to @ref get_objects
*/ */
vector<optional<delegate_object>> get_delegates(const vector<delegate_id_type>& delegate_ids)const; vector<optional<committee_member_object>> get_committee_members(const vector<committee_member_id_type>& committee_member_ids)const;
/** /**
* @group Push Notification Methods * @group Push Notification Methods
@ -471,13 +471,13 @@ FC_API(graphene::app::database_api,
(get_call_orders) (get_call_orders)
(get_settle_orders) (get_settle_orders)
(list_assets) (list_assets)
(get_delegate_by_account) (get_committee_member_by_account)
(get_witnesses) (get_witnesses)
(get_delegates) (get_committee_members)
(get_witness_by_account) (get_witness_by_account)
(get_witness_count) (get_witness_count)
(lookup_witness_accounts) (lookup_witness_accounts)
(lookup_delegate_accounts) (lookup_committee_member_accounts)
(subscribe_to_objects) (subscribe_to_objects)
(unsubscribe_from_objects) (unsubscribe_from_objects)
(subscribe_to_market) (subscribe_to_market)

4
libraries/chain/CMakeLists.txt
View file

@ -8,7 +8,7 @@ add_library( graphene_chain
protocol/assert.cpp protocol/assert.cpp
protocol/account.cpp protocol/account.cpp
protocol/transfer.cpp protocol/transfer.cpp
protocol/delegate.cpp protocol/committee_member.cpp
protocol/witness.cpp protocol/witness.cpp
protocol/market.cpp protocol/market.cpp
protocol/proposal.cpp protocol/proposal.cpp
@ -29,7 +29,7 @@ add_library( graphene_chain
account_evaluator.cpp account_evaluator.cpp
assert_evaluator.cpp assert_evaluator.cpp
witness_evaluator.cpp witness_evaluator.cpp
delegate_evaluator.cpp committee_member_evaluator.cpp
asset_evaluator.cpp asset_evaluator.cpp
transfer_evaluator.cpp transfer_evaluator.cpp
proposal_evaluator.cpp proposal_evaluator.cpp

4
libraries/chain/asset_evaluator.cpp
View file

@ -325,7 +325,7 @@ void_result asset_update_feed_producers_evaluator::do_evaluate(const asset_updat
const asset_object& a = o.asset_to_update(d); const asset_object& a = o.asset_to_update(d);
FC_ASSERT(a.is_market_issued(), "Cannot update feed producers on a non-BitAsset."); FC_ASSERT(a.is_market_issued(), "Cannot update feed producers on a non-BitAsset.");
FC_ASSERT(a.issuer != account_id_type(), "Cannot set feed producers on a genesis-issued asset."); FC_ASSERT(a.issuer != GRAPHENE_COMMITTEE_ACCOUNT, "Cannot set feed producers on a committee-issued asset.");
const asset_bitasset_data_object& b = a.bitasset_data(d); const asset_bitasset_data_object& b = a.bitasset_data(d);
bitasset_to_update = &b; bitasset_to_update = &b;
@ -450,7 +450,7 @@ void_result asset_publish_feeds_evaluator::do_evaluate(const asset_publish_feed_
//Verify that the publisher is authoritative to publish a feed //Verify that the publisher is authoritative to publish a feed
if( base.issuer == account_id_type() ) if( base.issuer == account_id_type() )
{ {
//It's a delegate-fed asset. Verify that publisher is an active delegate or witness. //It's a committee_member-fed asset. Verify that publisher is an active committee_member or witness.
FC_ASSERT(d.get(GRAPHENE_COMMITTEE_ACCOUNT).active.account_auths.count(o.publisher) || FC_ASSERT(d.get(GRAPHENE_COMMITTEE_ACCOUNT).active.account_auths.count(o.publisher) ||
d.get_global_properties().witness_accounts.count(o.publisher)); d.get_global_properties().witness_accounts.count(o.publisher));
} else { } else {

18
libraries/chain/delegate_evaluator.cpp → libraries/chain/committee_member_evaluator.cpp
View file

@ -15,8 +15,8 @@
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <graphene/chain/delegate_evaluator.hpp> #include <graphene/chain/committee_member_evaluator.hpp>
#include <graphene/chain/delegate_object.hpp> #include <graphene/chain/committee_member_object.hpp>
#include <graphene/chain/database.hpp> #include <graphene/chain/database.hpp>
#include <graphene/chain/account_object.hpp> #include <graphene/chain/account_object.hpp>
#include <graphene/chain/protocol/fee_schedule.hpp> #include <graphene/chain/protocol/fee_schedule.hpp>
@ -24,21 +24,21 @@
namespace graphene { namespace chain { namespace graphene { namespace chain {
void_result delegate_create_evaluator::do_evaluate( const delegate_create_operation& op ) void_result committee_member_create_evaluator::do_evaluate( const committee_member_create_operation& op )
{ try { { try {
FC_ASSERT(db().get(op.delegate_account).is_lifetime_member()); FC_ASSERT(db().get(op.committee_member_account).is_lifetime_member());
return void_result(); return void_result();
} FC_CAPTURE_AND_RETHROW( (op) ) } } FC_CAPTURE_AND_RETHROW( (op) ) }
object_id_type delegate_create_evaluator::do_apply( const delegate_create_operation& op ) object_id_type committee_member_create_evaluator::do_apply( const committee_member_create_operation& op )
{ try { { try {
vote_id_type vote_id; vote_id_type vote_id;
db().modify(db().get_global_properties(), [&vote_id](global_property_object& p) { db().modify(db().get_global_properties(), [&vote_id](global_property_object& p) {
vote_id = p.get_next_vote_id(vote_id_type::committee); vote_id = p.get_next_vote_id(vote_id_type::committee);
}); });
const auto& new_del_object = db().create<delegate_object>( [&]( delegate_object& obj ){ const auto& new_del_object = db().create<committee_member_object>( [&]( committee_member_object& obj ){
obj.delegate_account = op.delegate_account; obj.committee_member_account = op.committee_member_account;
obj.vote_id = vote_id; obj.vote_id = vote_id;
obj.url = op.url; obj.url = op.url;
}); });
@ -47,14 +47,14 @@ object_id_type delegate_create_evaluator::do_apply( const delegate_create_operat
void_result delegate_update_global_parameters_evaluator::do_evaluate(const delegate_update_global_parameters_operation& o) void_result committee_member_update_global_parameters_evaluator::do_evaluate(const committee_member_update_global_parameters_operation& o)
{ try { { try {
FC_ASSERT(trx_state->_is_proposed_trx); FC_ASSERT(trx_state->_is_proposed_trx);
return void_result(); return void_result();
} FC_CAPTURE_AND_RETHROW( (o) ) } } FC_CAPTURE_AND_RETHROW( (o) ) }
void_result delegate_update_global_parameters_evaluator::do_apply(const delegate_update_global_parameters_operation& o) void_result committee_member_update_global_parameters_evaluator::do_apply(const committee_member_update_global_parameters_operation& o)
{ try { { try {
db().modify(db().get_global_properties(), [&o](global_property_object& p) { db().modify(db().get_global_properties(), [&o](global_property_object& p) {
p.pending_parameters = o.new_parameters; p.pending_parameters = o.new_parameters;

6
libraries/chain/db_block.cpp
View file

@ -271,7 +271,7 @@ signed_block database::_generate_block(
const auto& witness_obj = witness_id(*this); const auto& witness_obj = witness_id(*this);
if( !(skip & skip_delegate_signature) ) if( !(skip & skip_witness_signature) )
FC_ASSERT( witness_obj.signing_key == block_signing_private_key.get_public_key() ); FC_ASSERT( witness_obj.signing_key == block_signing_private_key.get_public_key() );
_pending_block.timestamp = when; _pending_block.timestamp = when;
@ -297,7 +297,7 @@ signed_block database::_generate_block(
_pending_block.transaction_merkle_root = _pending_block.calculate_merkle_root(); _pending_block.transaction_merkle_root = _pending_block.calculate_merkle_root();
_pending_block.witness = witness_id; _pending_block.witness = witness_id;
if( !(skip & skip_delegate_signature) ) _pending_block.sign( block_signing_private_key ); if( !(skip & skip_witness_signature) ) _pending_block.sign( block_signing_private_key );
FC_ASSERT( fc::raw::pack_size(_pending_block) <= get_global_properties().parameters.maximum_block_size ); FC_ASSERT( fc::raw::pack_size(_pending_block) <= get_global_properties().parameters.maximum_block_size );
signed_block tmp = _pending_block; signed_block tmp = _pending_block;
@ -645,7 +645,7 @@ const witness_object& database::validate_block_header( uint32_t skip, const sign
const witness_object& witness = next_block.witness(*this); const witness_object& witness = next_block.witness(*this);
FC_ASSERT( secret_hash_type::hash( next_block.previous_secret ) == witness.next_secret_hash, "", 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)); ("previous_secret", next_block.previous_secret)("next_secret_hash", witness.next_secret_hash));
if( !(skip&skip_delegate_signature) ) FC_ASSERT( next_block.validate_signee( witness.signing_key ) ); if( !(skip&skip_witness_signature) ) FC_ASSERT( next_block.validate_signee( witness.signing_key ) );
uint32_t slot_num = get_slot_at_time( next_block.timestamp ); uint32_t slot_num = get_slot_at_time( next_block.timestamp );
FC_ASSERT( slot_num > 0 ); FC_ASSERT( slot_num > 0 );

18
libraries/chain/db_init.cpp
View file

@ -21,7 +21,7 @@
#include <graphene/chain/account_object.hpp> #include <graphene/chain/account_object.hpp>
#include <graphene/chain/asset_object.hpp> #include <graphene/chain/asset_object.hpp>
#include <graphene/chain/block_summary_object.hpp> #include <graphene/chain/block_summary_object.hpp>
#include <graphene/chain/delegate_object.hpp> #include <graphene/chain/committee_member_object.hpp>
#include <graphene/chain/global_property_object.hpp> #include <graphene/chain/global_property_object.hpp>
#include <graphene/chain/balance_object.hpp> #include <graphene/chain/balance_object.hpp>
#include <graphene/chain/proposal_object.hpp> #include <graphene/chain/proposal_object.hpp>
@ -35,7 +35,7 @@
#include <graphene/chain/asset_evaluator.hpp> #include <graphene/chain/asset_evaluator.hpp>
#include <graphene/chain/assert_evaluator.hpp> #include <graphene/chain/assert_evaluator.hpp>
#include <graphene/chain/custom_evaluator.hpp> #include <graphene/chain/custom_evaluator.hpp>
#include <graphene/chain/delegate_evaluator.hpp> #include <graphene/chain/committee_member_evaluator.hpp>
#include <graphene/chain/market_evaluator.hpp> #include <graphene/chain/market_evaluator.hpp>
#include <graphene/chain/proposal_evaluator.hpp> #include <graphene/chain/proposal_evaluator.hpp>
#include <graphene/chain/transfer_evaluator.hpp> #include <graphene/chain/transfer_evaluator.hpp>
@ -75,8 +75,8 @@ const uint8_t block_summary_object::type_id;
const uint8_t call_order_object::space_id; const uint8_t call_order_object::space_id;
const uint8_t call_order_object::type_id; const uint8_t call_order_object::type_id;
const uint8_t delegate_object::space_id; const uint8_t committee_member_object::space_id;
const uint8_t delegate_object::type_id; const uint8_t committee_member_object::type_id;
const uint8_t force_settlement_object::space_id; const uint8_t force_settlement_object::space_id;
const uint8_t force_settlement_object::type_id; const uint8_t force_settlement_object::type_id;
@ -119,8 +119,8 @@ void database::initialize_evaluators()
register_evaluator<account_update_evaluator>(); register_evaluator<account_update_evaluator>();
register_evaluator<account_upgrade_evaluator>(); register_evaluator<account_upgrade_evaluator>();
register_evaluator<account_whitelist_evaluator>(); register_evaluator<account_whitelist_evaluator>();
register_evaluator<delegate_create_evaluator>(); register_evaluator<committee_member_create_evaluator>();
register_evaluator<delegate_update_global_parameters_evaluator>(); register_evaluator<committee_member_update_global_parameters_evaluator>();
register_evaluator<custom_evaluator>(); register_evaluator<custom_evaluator>();
register_evaluator<asset_create_evaluator>(); register_evaluator<asset_create_evaluator>();
register_evaluator<asset_issue_evaluator>(); register_evaluator<asset_issue_evaluator>();
@ -165,7 +165,7 @@ void database::initialize_indexes()
acnt_index->add_secondary_index<account_member_index>(); acnt_index->add_secondary_index<account_member_index>();
acnt_index->add_secondary_index<account_referrer_index>(); acnt_index->add_secondary_index<account_referrer_index>();
add_index< primary_index<delegate_index> >(); add_index< primary_index<committee_member_index> >();
add_index< primary_index<witness_index> >(); add_index< primary_index<witness_index> >();
add_index< primary_index<limit_order_index > >(); add_index< primary_index<limit_order_index > >();
add_index< primary_index<call_order_index > >(); add_index< primary_index<call_order_index > >();
@ -476,8 +476,8 @@ void database::init_genesis(const genesis_state_type& genesis_state)
// Create initial committee members // Create initial committee members
std::for_each(genesis_state.initial_committee_candidates.begin(), genesis_state.initial_committee_candidates.end(), std::for_each(genesis_state.initial_committee_candidates.begin(), genesis_state.initial_committee_candidates.end(),
[&](const genesis_state_type::initial_committee_member_type& member) { [&](const genesis_state_type::initial_committee_member_type& member) {
delegate_create_operation op; committee_member_create_operation op;
op.delegate_account = get_account_id(member.owner_name); op.committee_member_account = get_account_id(member.owner_name);
apply_operation(genesis_eval_state, op); apply_operation(genesis_eval_state, op);
}); });

30
libraries/chain/db_maint.cpp
View file

@ -20,7 +20,7 @@
#include <graphene/chain/account_object.hpp> #include <graphene/chain/account_object.hpp>
#include <graphene/chain/asset_object.hpp> #include <graphene/chain/asset_object.hpp>
#include <graphene/chain/delegate_object.hpp> #include <graphene/chain/committee_member_object.hpp>
#include <graphene/chain/global_property_object.hpp> #include <graphene/chain/global_property_object.hpp>
#include <graphene/chain/vesting_balance_object.hpp> #include <graphene/chain/vesting_balance_object.hpp>
#include <graphene/chain/witness_object.hpp> #include <graphene/chain/witness_object.hpp>
@ -191,21 +191,21 @@ void database::update_active_witnesses()
}); });
} FC_CAPTURE_AND_RETHROW() } } FC_CAPTURE_AND_RETHROW() }
void database::update_active_delegates() void database::update_active_committee_members()
{ try { { try {
assert( _committee_count_histogram_buffer.size() > 0 ); assert( _committee_count_histogram_buffer.size() > 0 );
uint64_t stake_target = _total_voting_stake / 2; uint64_t stake_target = _total_voting_stake / 2;
uint64_t stake_tally = _committee_count_histogram_buffer[0]; uint64_t stake_tally = _committee_count_histogram_buffer[0];
size_t delegate_count = 0; size_t committee_member_count = 0;
if( stake_target > 0 ) if( stake_target > 0 )
while( (delegate_count < _committee_count_histogram_buffer.size() - 1) while( (committee_member_count < _committee_count_histogram_buffer.size() - 1)
&& (stake_tally <= stake_target) ) && (stake_tally <= stake_target) )
stake_tally += _committee_count_histogram_buffer[++delegate_count]; stake_tally += _committee_count_histogram_buffer[++committee_member_count];
auto delegates = sort_votable_objects<delegate_index>(std::max(delegate_count*2+1, (size_t)GRAPHENE_MIN_DELEGATE_COUNT)); auto committee_members = sort_votable_objects<committee_member_index>(std::max(committee_member_count*2+1, (size_t)GRAPHENE_MIN_COMMITTEE_MEMBER_COUNT));
// Update genesis authorities // Update committee authorities
if( !delegates.empty() ) if( !committee_members.empty() )
{ {
modify(get(GRAPHENE_COMMITTEE_ACCOUNT), [&](account_object& a) { modify(get(GRAPHENE_COMMITTEE_ACCOUNT), [&](account_object& a) {
uint64_t total_votes = 0; uint64_t total_votes = 0;
@ -213,9 +213,9 @@ void database::update_active_delegates()
a.active.weight_threshold = 0; a.active.weight_threshold = 0;
a.active.clear(); a.active.clear();
for( const delegate_object& del : delegates ) for( const committee_member_object& del : committee_members )
{ {
weights.emplace(del.delegate_account, _vote_tally_buffer[del.vote_id]); weights.emplace(del.committee_member_account, _vote_tally_buffer[del.vote_id]);
total_votes += _vote_tally_buffer[del.vote_id]; total_votes += _vote_tally_buffer[del.vote_id];
} }
@ -238,10 +238,10 @@ void database::update_active_delegates()
}); });
} }
modify(get_global_properties(), [&](global_property_object& gp) { modify(get_global_properties(), [&](global_property_object& gp) {
gp.active_delegates.clear(); gp.active_committee_members.clear();
std::transform(delegates.begin(), delegates.end(), std::transform(committee_members.begin(), committee_members.end(),
std::inserter(gp.active_delegates, gp.active_delegates.begin()), std::inserter(gp.active_committee_members, gp.active_committee_members.begin()),
[](const delegate_object& d) { return d.id; }); [](const committee_member_object& d) { return d.id; });
}); });
} FC_CAPTURE_AND_RETHROW() } } FC_CAPTURE_AND_RETHROW() }
@ -457,7 +457,7 @@ void database::perform_chain_maintenance(const signed_block& next_block, const g
c(_vote_tally_buffer); c(_vote_tally_buffer);
update_active_witnesses(); update_active_witnesses();
update_active_delegates(); update_active_committee_members();
modify(gpo, [this](global_property_object& p) { modify(gpo, [this](global_property_object& p) {
// Remove scaling of account registration fee // Remove scaling of account registration fee

2
libraries/chain/db_management.cpp
View file

@ -51,7 +51,7 @@ void database::reindex(fc::path data_dir, const genesis_state_type& initial_allo
//_undo_db.disable(); //_undo_db.disable();
for( uint32_t i = 1; i <= last_block_num; ++i ) for( uint32_t i = 1; i <= last_block_num; ++i )
{ {
apply_block(*_block_id_to_block.fetch_by_number(i), skip_delegate_signature | apply_block(*_block_id_to_block.fetch_by_number(i), skip_witness_signature |
skip_transaction_signatures | skip_transaction_signatures |
skip_undo_block | skip_undo_block |
skip_undo_transaction | skip_undo_transaction |

2
libraries/chain/evaluator.cpp
View file

@ -22,7 +22,7 @@
#include <graphene/chain/asset_object.hpp> #include <graphene/chain/asset_object.hpp>
#include <graphene/chain/account_object.hpp> #include <graphene/chain/account_object.hpp>
#include <graphene/chain/delegate_object.hpp> #include <graphene/chain/committee_member_object.hpp>
#include <graphene/chain/market_evaluator.hpp> #include <graphene/chain/market_evaluator.hpp>
#include <graphene/chain/protocol/fee_schedule.hpp> #include <graphene/chain/protocol/fee_schedule.hpp>

6
libraries/chain/include/graphene/chain/account_object.hpp
View file

@ -108,7 +108,7 @@ namespace graphene { namespace chain {
* @ingroup protocol * @ingroup protocol
* *
* Accounts are the primary unit of authority on the graphene system. Users must have an account in order to use * Accounts are the primary unit of authority on the graphene system. Users must have an account in order to use
* assets, trade in the markets, vote for delegates, etc. * assets, trade in the markets, vote for committee_members, etc.
*/ */
class account_object : public graphene::db::annotated_object<account_object> class account_object : public graphene::db::annotated_object<account_object>
{ {
@ -231,7 +231,7 @@ namespace graphene { namespace chain {
static const uint8_t type_id = meta_account_object_type; static const uint8_t type_id = meta_account_object_type;
public_key_type memo_key; public_key_type memo_key;
delegate_id_type delegate_id; // optional committee_member_id_type committee_member_id; // optional
}; };
/** /**
@ -334,7 +334,7 @@ FC_REFLECT_DERIVED( graphene::chain::account_balance_object,
FC_REFLECT_DERIVED( graphene::chain::meta_account_object, FC_REFLECT_DERIVED( graphene::chain::meta_account_object,
(graphene::db::object), (graphene::db::object),
(memo_key)(delegate_id) ) (memo_key)(committee_member_id) )
FC_REFLECT_DERIVED( graphene::chain::account_statistics_object, (graphene::chain::object), FC_REFLECT_DERIVED( graphene::chain::account_statistics_object, (graphene::chain::object),
(most_recent_op) (most_recent_op)

4
libraries/chain/include/graphene/chain/asset_object.hpp
View file

@ -167,8 +167,8 @@ namespace graphene { namespace chain {
/// The tunable options for BitAssets are stored in this field. /// The tunable options for BitAssets are stored in this field.
bitasset_options options; bitasset_options options;
/// Feeds published for this asset. If issuer is not genesis, the keys in this map are the feed publishing /// Feeds published for this asset. If issuer is not committee, the keys in this map are the feed publishing
/// accounts; otherwise, the feed publishers are the currently active delegates and witnesses and this map /// accounts; otherwise, the feed publishers are the currently active committee_members and witnesses and this map
/// should be treated as an implementation detail. The timestamp on each feed is the time it was published. /// should be treated as an implementation detail. The timestamp on each feed is the time it was published.
flat_map<account_id_type, pair<time_point_sec,price_feed>> feeds; flat_map<account_id_type, pair<time_point_sec,price_feed>> feeds;
/// This is the currently active price feed, calculated as the median of values from the currently active /// This is the currently active price feed, calculated as the median of values from the currently active

18
libraries/chain/include/graphene/chain/delegate_evaluator.hpp → libraries/chain/include/graphene/chain/committee_member_evaluator.hpp
View file

@ -17,26 +17,26 @@
*/ */
#pragma once #pragma once
#include <graphene/chain/evaluator.hpp> #include <graphene/chain/evaluator.hpp>
#include <graphene/chain/delegate_object.hpp> #include <graphene/chain/committee_member_object.hpp>
namespace graphene { namespace chain { namespace graphene { namespace chain {
class delegate_create_evaluator : public evaluator<delegate_create_evaluator> class committee_member_create_evaluator : public evaluator<committee_member_create_evaluator>
{ {
public: public:
typedef delegate_create_operation operation_type; typedef committee_member_create_operation operation_type;
void_result do_evaluate( const delegate_create_operation& o ); void_result do_evaluate( const committee_member_create_operation& o );
object_id_type do_apply( const delegate_create_operation& o ); object_id_type do_apply( const committee_member_create_operation& o );
}; };
class delegate_update_global_parameters_evaluator : public evaluator<delegate_update_global_parameters_evaluator> class committee_member_update_global_parameters_evaluator : public evaluator<committee_member_update_global_parameters_evaluator>
{ {
public: public:
typedef delegate_update_global_parameters_operation operation_type; typedef committee_member_update_global_parameters_operation operation_type;
void_result do_evaluate( const delegate_update_global_parameters_operation& o ); void_result do_evaluate( const committee_member_update_global_parameters_operation& o );
void_result do_apply( const delegate_update_global_parameters_operation& o ); void_result do_apply( const committee_member_update_global_parameters_operation& o );
}; };

30
libraries/chain/include/graphene/chain/delegate_object.hpp → libraries/chain/include/graphene/chain/committee_member_object.hpp
View file

@ -26,41 +26,41 @@ namespace graphene { namespace chain {
class account_object; class account_object;
/** /**
* @brief tracks information about a delegate account. * @brief tracks information about a committee_member account.
* @ingroup object * @ingroup object
* *
* A delegate is responsible for setting blockchain parameters and has * A committee_member is responsible for setting blockchain parameters and has
* dynamic multi-sig control over the genesis account. The current set of * dynamic multi-sig control over the committee account. The current set of
* active delegates has control. * active committee_members has control.
* *
* Delegates were separated into a separate object to make iterating over * committee_members were separated into a separate object to make iterating over
* the set of delegate easy. * the set of committee_member easy.
*/ */
class delegate_object : public abstract_object<delegate_object> class committee_member_object : public abstract_object<committee_member_object>
{ {
public: public:
static const uint8_t space_id = protocol_ids; static const uint8_t space_id = protocol_ids;
static const uint8_t type_id = delegate_object_type; static const uint8_t type_id = committee_member_object_type;
account_id_type delegate_account; account_id_type committee_member_account;
vote_id_type vote_id; vote_id_type vote_id;
string url; string url;
}; };
struct by_account; struct by_account;
using delegate_multi_index_type = multi_index_container< using committee_member_multi_index_type = multi_index_container<
delegate_object, committee_member_object,
indexed_by< indexed_by<
ordered_unique< tag<by_id>, ordered_unique< tag<by_id>,
member<object, object_id_type, &object::id> member<object, object_id_type, &object::id>
>, >,
hashed_unique< tag<by_account>, hashed_unique< tag<by_account>,
member<delegate_object, account_id_type, &delegate_object::delegate_account> member<committee_member_object, account_id_type, &committee_member_object::committee_member_account>
> >
> >
>; >;
using delegate_index = generic_index<delegate_object, delegate_multi_index_type>; using committee_member_index = generic_index<committee_member_object, committee_member_multi_index_type>;
} } // graphene::chain } } // graphene::chain
FC_REFLECT_DERIVED( graphene::chain::delegate_object, (graphene::db::object), FC_REFLECT_DERIVED( graphene::chain::committee_member_object, (graphene::db::object),
(delegate_account)(vote_id)(url) ) (committee_member_account)(vote_id)(url) )

4
libraries/chain/include/graphene/chain/config.hpp
View file

@ -32,9 +32,9 @@
#define GRAPHENE_MAX_PAY_RATE 10000 /* 100% */ #define GRAPHENE_MAX_PAY_RATE 10000 /* 100% */
#define GRAPHENE_MAX_SIG_CHECK_DEPTH 2 #define GRAPHENE_MAX_SIG_CHECK_DEPTH 2
#define GRAPHENE_MIN_WITNESS_COUNT 10 #define GRAPHENE_MIN_WITNESS_COUNT 10
#define GRAPHENE_MIN_DELEGATE_COUNT 10 #define GRAPHENE_MIN_COMMITTEE_MEMBER_COUNT 10
/** /**
* Don't allow the delegates to publish a limit that would * Don't allow the committee_members to publish a limit that would
* make the network unable to operate. * make the network unable to operate.
*/ */
#define GRAPHENE_MIN_TRANSACTION_SIZE_LIMIT 1024 #define GRAPHENE_MIN_TRANSACTION_SIZE_LIMIT 1024

26
libraries/chain/include/graphene/chain/database.hpp
View file

@ -79,18 +79,18 @@ namespace graphene { namespace chain {
enum validation_steps enum validation_steps
{ {
skip_nothing = 0x00, skip_nothing = 0,
skip_delegate_signature = 0x01, ///< used while reindexing skip_witness_signature = 1 << 0, ///< used while reindexing
skip_transaction_signatures = 0x02, ///< used by non-witness nodes skip_transaction_signatures = 1 << 1, ///< used by non-witness nodes
skip_undo_block = 0x04, ///< used while reindexing skip_undo_block = 1 << 2, ///< used while reindexing
skip_undo_transaction = 0x08, ///< used while applying block skip_undo_transaction = 1 << 3, ///< used while applying block
skip_transaction_dupe_check = 0x10, ///< used while reindexing skip_transaction_dupe_check = 1 << 4, ///< used while reindexing
skip_fork_db = 0x20, ///< used while reindexing skip_fork_db = 1 << 5, ///< used while reindexing
skip_block_size_check = 0x40, ///< used when applying locally generated transactions skip_block_size_check = 1 << 6, ///< used when applying locally generated transactions
skip_tapos_check = 0x80, ///< used while reindexing -- note this skips expiration check as well skip_tapos_check = 1 << 7, ///< used while reindexing -- note this skips expiration check as well
skip_authority_check = 0x100, ///< used while reindexing -- disables any checking of authority on transactions skip_authority_check = 1 << 8, ///< used while reindexing -- disables any checking of authority on transactions
skip_merkle_check = 0x200, ///< used while reindexing skip_merkle_check = 1 << 9, ///< used while reindexing
skip_assert_evaluation = 0x400 ///< used while reindexing skip_assert_evaluation = 1 << 10 ///< used while reindexing
}; };
/** /**
@ -441,7 +441,7 @@ namespace graphene { namespace chain {
void pay_workers( share_type& budget ); void pay_workers( share_type& budget );
void perform_chain_maintenance(const signed_block& next_block, const global_property_object& global_props); void perform_chain_maintenance(const signed_block& next_block, const global_property_object& global_props);
void update_active_witnesses(); void update_active_witnesses();
void update_active_delegates(); void update_active_committee_members();
template<class... Types> template<class... Types>
void perform_account_maintenance(std::tuple<Types...> helpers); void perform_account_maintenance(std::tuple<Types...> helpers);

16
libraries/chain/include/graphene/chain/exceptions.hpp
View file

@ -100,7 +100,7 @@ namespace graphene { namespace chain {
//GRAPHENE_DECLARE_OP_BASE_EXCEPTIONS( asset_settle ); //GRAPHENE_DECLARE_OP_BASE_EXCEPTIONS( asset_settle );
//GRAPHENE_DECLARE_OP_BASE_EXCEPTIONS( asset_global_settle ); //GRAPHENE_DECLARE_OP_BASE_EXCEPTIONS( asset_global_settle );
//GRAPHENE_DECLARE_OP_BASE_EXCEPTIONS( asset_publish_feed ); //GRAPHENE_DECLARE_OP_BASE_EXCEPTIONS( asset_publish_feed );
//GRAPHENE_DECLARE_OP_BASE_EXCEPTIONS( delegate_create ); //GRAPHENE_DECLARE_OP_BASE_EXCEPTIONS( committee_member_create );
//GRAPHENE_DECLARE_OP_BASE_EXCEPTIONS( witness_create ); //GRAPHENE_DECLARE_OP_BASE_EXCEPTIONS( witness_create );
//GRAPHENE_DECLARE_OP_BASE_EXCEPTIONS( witness_withdraw_pay ); //GRAPHENE_DECLARE_OP_BASE_EXCEPTIONS( witness_withdraw_pay );
@ -154,7 +154,7 @@ namespace graphene { namespace chain {
FC_DECLARE_DERIVED_EXCEPTION( time_in_past, graphene::chain::chain_exception, 30018, "time is in the past" ) FC_DECLARE_DERIVED_EXCEPTION( time_in_past, graphene::chain::chain_exception, 30018, "time is in the past" )
FC_DECLARE_DERIVED_EXCEPTION( time_in_future, graphene::chain::chain_exception, 30019, "time is in the future" ) FC_DECLARE_DERIVED_EXCEPTION( time_in_future, graphene::chain::chain_exception, 30019, "time is in the future" )
FC_DECLARE_DERIVED_EXCEPTION( invalid_block_digest, graphene::chain::chain_exception, 30020, "invalid block digest" ) FC_DECLARE_DERIVED_EXCEPTION( invalid_block_digest, graphene::chain::chain_exception, 30020, "invalid block digest" )
FC_DECLARE_DERIVED_EXCEPTION( invalid_delegate_signee, graphene::chain::chain_exception, 30021, "invalid delegate signee" ) FC_DECLARE_DERIVED_EXCEPTION( invalid_committee_member_signee, graphene::chain::chain_exception, 30021, "invalid committee_member signee" )
FC_DECLARE_DERIVED_EXCEPTION( failed_checkpoint_verification, graphene::chain::chain_exception, 30022, "failed checkpoint verification" ) FC_DECLARE_DERIVED_EXCEPTION( failed_checkpoint_verification, graphene::chain::chain_exception, 30022, "failed checkpoint verification" )
FC_DECLARE_DERIVED_EXCEPTION( wrong_chain_id, graphene::chain::chain_exception, 30023, "wrong chain id" ) FC_DECLARE_DERIVED_EXCEPTION( wrong_chain_id, graphene::chain::chain_exception, 30023, "wrong chain id" )
FC_DECLARE_DERIVED_EXCEPTION( unknown_block, graphene::chain::chain_exception, 30024, "unknown block" ) FC_DECLARE_DERIVED_EXCEPTION( unknown_block, graphene::chain::chain_exception, 30024, "unknown block" )
@ -162,14 +162,14 @@ namespace graphene { namespace chain {
FC_DECLARE_EXCEPTION( evaluation_error, 31000, "Evaluation Error" ) FC_DECLARE_EXCEPTION( evaluation_error, 31000, "Evaluation Error" )
FC_DECLARE_DERIVED_EXCEPTION( negative_deposit, graphene::chain::evaluation_error, 31001, "negative deposit" ) FC_DECLARE_DERIVED_EXCEPTION( negative_deposit, graphene::chain::evaluation_error, 31001, "negative deposit" )
FC_DECLARE_DERIVED_EXCEPTION( not_a_delegate, graphene::chain::evaluation_error, 31002, "not a delegate" ) FC_DECLARE_DERIVED_EXCEPTION( not_a_committee_member, graphene::chain::evaluation_error, 31002, "not a committee_member" )
FC_DECLARE_DERIVED_EXCEPTION( unknown_balance_record, graphene::chain::evaluation_error, 31003, "unknown balance record" ) FC_DECLARE_DERIVED_EXCEPTION( unknown_balance_record, graphene::chain::evaluation_error, 31003, "unknown balance record" )
FC_DECLARE_DERIVED_EXCEPTION( insufficient_funds, graphene::chain::evaluation_error, 31004, "insufficient funds" ) FC_DECLARE_DERIVED_EXCEPTION( insufficient_funds, graphene::chain::evaluation_error, 31004, "insufficient funds" )
FC_DECLARE_DERIVED_EXCEPTION( missing_signature, graphene::chain::evaluation_error, 31005, "missing signature" ) FC_DECLARE_DERIVED_EXCEPTION( missing_signature, graphene::chain::evaluation_error, 31005, "missing signature" )
FC_DECLARE_DERIVED_EXCEPTION( invalid_claim_password, graphene::chain::evaluation_error, 31006, "invalid claim password" ) FC_DECLARE_DERIVED_EXCEPTION( invalid_claim_password, graphene::chain::evaluation_error, 31006, "invalid claim password" )
FC_DECLARE_DERIVED_EXCEPTION( invalid_withdraw_condition, graphene::chain::evaluation_error, 31007, "invalid withdraw condition" ) FC_DECLARE_DERIVED_EXCEPTION( invalid_withdraw_condition, graphene::chain::evaluation_error, 31007, "invalid withdraw condition" )
FC_DECLARE_DERIVED_EXCEPTION( negative_withdraw, graphene::chain::evaluation_error, 31008, "negative withdraw" ) FC_DECLARE_DERIVED_EXCEPTION( negative_withdraw, graphene::chain::evaluation_error, 31008, "negative withdraw" )
FC_DECLARE_DERIVED_EXCEPTION( not_an_active_delegate, graphene::chain::evaluation_error, 31009, "not an active delegate" ) FC_DECLARE_DERIVED_EXCEPTION( not_an_active_committee_member, graphene::chain::evaluation_error, 31009, "not an active committee_member" )
FC_DECLARE_DERIVED_EXCEPTION( expired_transaction, graphene::chain::evaluation_error, 31010, "expired transaction" ) FC_DECLARE_DERIVED_EXCEPTION( expired_transaction, graphene::chain::evaluation_error, 31010, "expired transaction" )
FC_DECLARE_DERIVED_EXCEPTION( invalid_transaction_expiration, graphene::chain::evaluation_error, 31011, "invalid transaction expiration" ) FC_DECLARE_DERIVED_EXCEPTION( invalid_transaction_expiration, graphene::chain::evaluation_error, 31011, "invalid transaction expiration" )
FC_DECLARE_DERIVED_EXCEPTION( oversized_transaction, graphene::chain::evaluation_error, 31012, "transaction exceeded the maximum transaction size" ) FC_DECLARE_DERIVED_EXCEPTION( oversized_transaction, graphene::chain::evaluation_error, 31012, "transaction exceeded the maximum transaction size" )
@ -184,11 +184,11 @@ namespace graphene { namespace chain {
FC_DECLARE_DERIVED_EXCEPTION( account_key_in_use, graphene::chain::evaluation_error, 32008, "account key already in use" ) FC_DECLARE_DERIVED_EXCEPTION( account_key_in_use, graphene::chain::evaluation_error, 32008, "account key already in use" )
FC_DECLARE_DERIVED_EXCEPTION( account_retracted, graphene::chain::evaluation_error, 32009, "account retracted" ) FC_DECLARE_DERIVED_EXCEPTION( account_retracted, graphene::chain::evaluation_error, 32009, "account retracted" )
FC_DECLARE_DERIVED_EXCEPTION( unknown_parent_account_name, graphene::chain::evaluation_error, 32010, "unknown parent account name" ) FC_DECLARE_DERIVED_EXCEPTION( unknown_parent_account_name, graphene::chain::evaluation_error, 32010, "unknown parent account name" )
FC_DECLARE_DERIVED_EXCEPTION( unknown_delegate_slate, graphene::chain::evaluation_error, 32011, "unknown delegate slate" ) FC_DECLARE_DERIVED_EXCEPTION( unknown_committee_member_slate, graphene::chain::evaluation_error, 32011, "unknown committee_member slate" )
FC_DECLARE_DERIVED_EXCEPTION( too_may_delegates_in_slate, graphene::chain::evaluation_error, 32012, "too many delegates in slate" ) FC_DECLARE_DERIVED_EXCEPTION( too_may_committee_members_in_slate, graphene::chain::evaluation_error, 32012, "too many committee_members in slate" )
FC_DECLARE_DERIVED_EXCEPTION( pay_balance_remaining, graphene::chain::evaluation_error, 32013, "pay balance remaining" ) FC_DECLARE_DERIVED_EXCEPTION( pay_balance_remaining, graphene::chain::evaluation_error, 32013, "pay balance remaining" )
FC_DECLARE_DERIVED_EXCEPTION( not_a_delegate_signature, graphene::chain::evaluation_error, 33002, "not delegates signature" ) FC_DECLARE_DERIVED_EXCEPTION( not_a_committee_member_signature, graphene::chain::evaluation_error, 33002, "not committee_members signature" )
FC_DECLARE_DERIVED_EXCEPTION( invalid_precision, graphene::chain::evaluation_error, 35001, "invalid precision" ) FC_DECLARE_DERIVED_EXCEPTION( invalid_precision, graphene::chain::evaluation_error, 35001, "invalid precision" )
FC_DECLARE_DERIVED_EXCEPTION( invalid_asset_symbol, graphene::chain::evaluation_error, 35002, "invalid asset symbol" ) FC_DECLARE_DERIVED_EXCEPTION( invalid_asset_symbol, graphene::chain::evaluation_error, 35002, "invalid asset symbol" )
@ -202,7 +202,7 @@ namespace graphene { namespace chain {
FC_DECLARE_DERIVED_EXCEPTION( not_user_issued, graphene::chain::evaluation_error, 35010, "not user issued" ) FC_DECLARE_DERIVED_EXCEPTION( not_user_issued, graphene::chain::evaluation_error, 35010, "not user issued" )
FC_DECLARE_DERIVED_EXCEPTION( invalid_asset_name, graphene::chain::evaluation_error, 35011, "invalid asset name" ) FC_DECLARE_DERIVED_EXCEPTION( invalid_asset_name, graphene::chain::evaluation_error, 35011, "invalid asset name" )
FC_DECLARE_DERIVED_EXCEPTION( delegate_vote_limit, graphene::chain::evaluation_error, 36001, "delegate_vote_limit" ) FC_DECLARE_DERIVED_EXCEPTION( committee_member_vote_limit, graphene::chain::evaluation_error, 36001, "committee_member_vote_limit" )
FC_DECLARE_DERIVED_EXCEPTION( insufficient_fee, graphene::chain::evaluation_error, 36002, "insufficient fee" ) FC_DECLARE_DERIVED_EXCEPTION( insufficient_fee, graphene::chain::evaluation_error, 36002, "insufficient fee" )
FC_DECLARE_DERIVED_EXCEPTION( negative_fee, graphene::chain::evaluation_error, 36003, "negative fee" ) FC_DECLARE_DERIVED_EXCEPTION( negative_fee, graphene::chain::evaluation_error, 36003, "negative fee" )
FC_DECLARE_DERIVED_EXCEPTION( missing_deposit, graphene::chain::evaluation_error, 36004, "missing deposit" ) FC_DECLARE_DERIVED_EXCEPTION( missing_deposit, graphene::chain::evaluation_error, 36004, "missing deposit" )

10
libraries/chain/include/graphene/chain/global_property_object.hpp
View file

@ -24,11 +24,11 @@ namespace graphene { namespace chain {
/** /**
* @class global_property_object * @class global_property_object
* @brief Maintains global state information (delegate list, current fees) * @brief Maintains global state information (committee_member list, current fees)
* @ingroup object * @ingroup object
* @ingroup implementation * @ingroup implementation
* *
* This is an implementation detail. The values here are set by delegates to tune the blockchain parameters. * This is an implementation detail. The values here are set by committee_members to tune the blockchain parameters.
*/ */
class global_property_object : public graphene::db::abstract_object<global_property_object> class global_property_object : public graphene::db::abstract_object<global_property_object>
{ {
@ -40,7 +40,7 @@ namespace graphene { namespace chain {
optional<chain_parameters> pending_parameters; optional<chain_parameters> pending_parameters;
uint32_t next_available_vote_id = 0; uint32_t next_available_vote_id = 0;
vector<delegate_id_type> active_delegates; // updated once per maintenance interval vector<committee_member_id_type> active_committee_members; // updated once per maintenance interval
flat_set<witness_id_type> active_witnesses; // updated once per maintenance interval flat_set<witness_id_type> active_witnesses; // updated once per maintenance interval
// n.b. witness scheduling is done by witness_schedule object // n.b. witness scheduling is done by witness_schedule object
flat_set<account_id_type> witness_accounts; // updated once per maintenance interval flat_set<account_id_type> witness_accounts; // updated once per maintenance interval
@ -54,7 +54,7 @@ namespace graphene { namespace chain {
/** /**
* @class dynamic_global_property_object * @class dynamic_global_property_object
* @brief Maintains global state information (delegate list, current fees) * @brief Maintains global state information (committee_member list, current fees)
* @ingroup object * @ingroup object
* @ingroup implementation * @ingroup implementation
* *
@ -102,7 +102,7 @@ FC_REFLECT_DERIVED( graphene::chain::global_property_object, (graphene::db::obje
(parameters) (parameters)
(pending_parameters) (pending_parameters)
(next_available_vote_id) (next_available_vote_id)
(active_delegates) (active_committee_members)
(active_witnesses) (active_witnesses)
(chain_id) (chain_id)
) )

4
libraries/chain/include/graphene/chain/protocol/asset_ops.hpp
View file

@ -282,7 +282,7 @@ namespace graphene { namespace chain {
* This operation is used to specify which accounts may produce feeds for a given BitAsset. * This operation is used to specify which accounts may produce feeds for a given BitAsset.
* *
* @pre @ref issuer MUST be an existing account, and MUST match asset_object::issuer on @ref asset_to_update * @pre @ref issuer MUST be an existing account, and MUST match asset_object::issuer on @ref asset_to_update
* @pre @ref issuer MUST NOT be the genesis account * @pre @ref issuer MUST NOT be the committee account
* @pre @ref asset_to_update MUST be a BitAsset, i.e. @ref asset_object::is_market_issued() returns true * @pre @ref asset_to_update MUST be a BitAsset, i.e. @ref asset_object::is_market_issued() returns true
* @pre @ref fee MUST be nonnegative, and @ref issuer MUST have a sufficient balance to pay it * @pre @ref fee MUST be nonnegative, and @ref issuer MUST have a sufficient balance to pay it
* @pre Cardinality of @ref new_feed_producers MUST NOT exceed @ref chain_parameters::maximum_asset_feed_publishers * @pre Cardinality of @ref new_feed_producers MUST NOT exceed @ref chain_parameters::maximum_asset_feed_publishers
@ -311,7 +311,7 @@ namespace graphene { namespace chain {
* *
* Price feed providers use this operation to publish their price feeds for market-issued assets. A price feed is * Price feed providers use this operation to publish their price feeds for market-issued assets. A price feed is
* used to tune the market for a particular market-issued asset. For each value in the feed, the median across all * used to tune the market for a particular market-issued asset. For each value in the feed, the median across all
* delegate feeds for that asset is calculated and the market for the asset is configured with the median of that * committee_member feeds for that asset is calculated and the market for the asset is configured with the median of that
* value. * value.
* *
* The feed in the operation contains three prices: a call price limit, a short price limit, and a settlement price. * The feed in the operation contains three prices: a call price limit, a short price limit, and a settlement price.

6
libraries/chain/include/graphene/chain/protocol/chain_parameters.hpp
View file

@ -36,7 +36,7 @@ namespace graphene { namespace chain {
smart_ref<fee_schedule> current_fees; ///< current schedule of fees smart_ref<fee_schedule> current_fees; ///< current schedule of fees
uint8_t block_interval = GRAPHENE_DEFAULT_BLOCK_INTERVAL; ///< interval in seconds between blocks uint8_t block_interval = GRAPHENE_DEFAULT_BLOCK_INTERVAL; ///< interval in seconds between blocks
uint32_t maintenance_interval = GRAPHENE_DEFAULT_MAINTENANCE_INTERVAL; ///< interval in sections between blockchain maintenance events uint32_t maintenance_interval = GRAPHENE_DEFAULT_MAINTENANCE_INTERVAL; ///< interval in sections between blockchain maintenance events
uint32_t committee_proposal_review_period = GRAPHENE_DEFAULT_COMMITTEE_PROPOSAL_REVIEW_PERIOD_SEC; ///< minimum time in seconds that a proposed transaction requiring genesis authority may not be signed, prior to expiration uint32_t committee_proposal_review_period = GRAPHENE_DEFAULT_COMMITTEE_PROPOSAL_REVIEW_PERIOD_SEC; ///< minimum time in seconds that a proposed transaction requiring committee authority may not be signed, prior to expiration
uint32_t maximum_transaction_size = GRAPHENE_DEFAULT_MAX_TRANSACTION_SIZE; ///< maximum allowable size in bytes for a transaction uint32_t maximum_transaction_size = GRAPHENE_DEFAULT_MAX_TRANSACTION_SIZE; ///< maximum allowable size in bytes for a transaction
uint32_t maximum_block_size = GRAPHENE_DEFAULT_MAX_BLOCK_SIZE; ///< maximum allowable size in bytes for a block uint32_t maximum_block_size = GRAPHENE_DEFAULT_MAX_BLOCK_SIZE; ///< maximum allowable size in bytes for a block
uint32_t maximum_undo_history = GRAPHENE_DEFAULT_MAX_UNDO_HISTORY; ///< maximum number of undo states to keep in RAM uint32_t maximum_undo_history = GRAPHENE_DEFAULT_MAX_UNDO_HISTORY; ///< maximum number of undo states to keep in RAM
@ -45,7 +45,7 @@ namespace graphene { namespace chain {
uint8_t maximum_asset_whitelist_authorities = GRAPHENE_DEFAULT_MAX_ASSET_WHITELIST_AUTHORITIES; ///< maximum number of accounts which an asset may list as authorities for its whitelist OR blacklist uint8_t maximum_asset_whitelist_authorities = GRAPHENE_DEFAULT_MAX_ASSET_WHITELIST_AUTHORITIES; ///< maximum number of accounts which an asset may list as authorities for its whitelist OR blacklist
uint8_t maximum_asset_feed_publishers = GRAPHENE_DEFAULT_MAX_ASSET_FEED_PUBLISHERS; ///< the maximum number of feed publishers for a given asset uint8_t maximum_asset_feed_publishers = GRAPHENE_DEFAULT_MAX_ASSET_FEED_PUBLISHERS; ///< the maximum number of feed publishers for a given asset
uint16_t maximum_witness_count = GRAPHENE_DEFAULT_MAX_WITNESSES; ///< maximum number of active witnesses uint16_t maximum_witness_count = GRAPHENE_DEFAULT_MAX_WITNESSES; ///< maximum number of active witnesses
uint16_t maximum_committee_count = GRAPHENE_DEFAULT_MAX_COMMITTEE; ///< maximum number of active delegates uint16_t maximum_committee_count = GRAPHENE_DEFAULT_MAX_COMMITTEE; ///< maximum number of active committee_members
uint16_t maximum_authority_membership = GRAPHENE_DEFAULT_MAX_AUTHORITY_MEMBERSHIP; ///< largest number of keys/accounts an authority can have uint16_t maximum_authority_membership = GRAPHENE_DEFAULT_MAX_AUTHORITY_MEMBERSHIP; ///< largest number of keys/accounts an authority can have
uint16_t reserve_percent_of_fee = GRAPHENE_DEFAULT_BURN_PERCENT_OF_FEE; ///< the percentage of the network's allocation of a fee that is taken out of circulation uint16_t reserve_percent_of_fee = GRAPHENE_DEFAULT_BURN_PERCENT_OF_FEE; ///< the percentage of the network's allocation of a fee that is taken out of circulation
uint16_t network_percent_of_fee = GRAPHENE_DEFAULT_NETWORK_PERCENT_OF_FEE; ///< percent of transaction fees paid to network uint16_t network_percent_of_fee = GRAPHENE_DEFAULT_NETWORK_PERCENT_OF_FEE; ///< percent of transaction fees paid to network
@ -89,7 +89,7 @@ namespace graphene { namespace chain {
FC_ASSERT( maximum_time_until_expiration > block_interval, FC_ASSERT( maximum_time_until_expiration > block_interval,
"Maximum transaction expiration time must be greater than a block interval" ); "Maximum transaction expiration time must be greater than a block interval" );
FC_ASSERT( maximum_proposal_lifetime - committee_proposal_review_period > block_interval, FC_ASSERT( maximum_proposal_lifetime - committee_proposal_review_period > block_interval,
"Genesis proposal review period must be less than the maximum proposal lifetime" ); "Committee proposal review period must be less than the maximum proposal lifetime" );
} }
}; };

59
libraries/chain/include/graphene/chain/protocol/committee_member.hpp Normal file
View file

@ -0,0 +1,59 @@
#pragma once
#include <graphene/chain/protocol/base.hpp>
#include <graphene/chain/protocol/chain_parameters.hpp>
namespace graphene { namespace chain {
/**
* @brief Create a committee_member object, as a bid to hold a committee_member seat on the network.
* @ingroup operations
*
* Accounts which wish to become committee_members may use this operation to create a committee_member object which stakeholders may
* vote on to approve its position as a committee_member.
*/
struct committee_member_create_operation : public base_operation
{
struct fee_parameters_type { uint64_t fee = 5000 * GRAPHENE_BLOCKCHAIN_PRECISION; };
asset fee;
/// The account which owns the committee_member. This account pays the fee for this operation.
account_id_type committee_member_account;
string url;
account_id_type fee_payer()const { return committee_member_account; }
void validate()const;
};
/**
* @brief Used by committee_members to update the global parameters of the blockchain.
* @ingroup operations
*
* This operation allows the committee_members to update the global parameters on the blockchain. These control various
* tunable aspects of the chain, including block and maintenance intervals, maximum data sizes, the fees charged by
* the network, etc.
*
* This operation may only be used in a proposed transaction, and a proposed transaction which contains this
* operation must have a review period specified in the current global parameters before it may be accepted.
*/
struct committee_member_update_global_parameters_operation : public base_operation
{
struct fee_parameters_type { uint64_t fee = GRAPHENE_BLOCKCHAIN_PRECISION; };
asset fee;
chain_parameters new_parameters;
account_id_type fee_payer()const { return account_id_type(); }
void validate()const;
};
/// TODO: committee_member_resign_operation : public base_operation
} } // graphene::chain
FC_REFLECT( graphene::chain::committee_member_create_operation::fee_parameters_type, (fee) )
FC_REFLECT( graphene::chain::committee_member_update_global_parameters_operation::fee_parameters_type, (fee) )
FC_REFLECT( graphene::chain::committee_member_create_operation,
(fee)(committee_member_account)(url) )
FC_REFLECT( graphene::chain::committee_member_update_global_parameters_operation, (fee)(new_parameters) );

59
libraries/chain/include/graphene/chain/protocol/delegate.hpp
View file

@ -1,59 +0,0 @@
#pragma once
#include <graphene/chain/protocol/base.hpp>
#include <graphene/chain/protocol/chain_parameters.hpp>
namespace graphene { namespace chain {
/**
* @brief Create a delegate object, as a bid to hold a delegate seat on the network.
* @ingroup operations
*
* Accounts which wish to become delegates may use this operation to create a delegate object which stakeholders may
* vote on to approve its position as a delegate.
*/
struct delegate_create_operation : public base_operation
{
struct fee_parameters_type { uint64_t fee = 5000 * GRAPHENE_BLOCKCHAIN_PRECISION; };
asset fee;
/// The account which owns the delegate. This account pays the fee for this operation.
account_id_type delegate_account;
string url;
account_id_type fee_payer()const { return delegate_account; }
void validate()const;
};
/**
* @brief Used by delegates to update the global parameters of the blockchain.
* @ingroup operations
*
* This operation allows the delegates to update the global parameters on the blockchain. These control various
* tunable aspects of the chain, including block and maintenance intervals, maximum data sizes, the fees charged by
* the network, etc.
*
* This operation may only be used in a proposed transaction, and a proposed transaction which contains this
* operation must have a review period specified in the current global parameters before it may be accepted.
*/
struct delegate_update_global_parameters_operation : public base_operation
{
struct fee_parameters_type { uint64_t fee = GRAPHENE_BLOCKCHAIN_PRECISION; };
asset fee;
chain_parameters new_parameters;
account_id_type fee_payer()const { return account_id_type(); }
void validate()const;
};
/// TODO: delegate_resign_operation : public base_operation
} } // graphene::chain
FC_REFLECT( graphene::chain::delegate_create_operation::fee_parameters_type, (fee) )
FC_REFLECT( graphene::chain::delegate_update_global_parameters_operation::fee_parameters_type, (fee) )
FC_REFLECT( graphene::chain::delegate_create_operation,
(fee)(delegate_account)(url) )
FC_REFLECT( graphene::chain::delegate_update_global_parameters_operation, (fee)(new_parameters) );

6
libraries/chain/include/graphene/chain/protocol/operations.hpp
View file

@ -6,7 +6,7 @@
#include <graphene/chain/protocol/asset_ops.hpp> #include <graphene/chain/protocol/asset_ops.hpp>
#include <graphene/chain/protocol/balance.hpp> #include <graphene/chain/protocol/balance.hpp>
#include <graphene/chain/protocol/custom.hpp> #include <graphene/chain/protocol/custom.hpp>
#include <graphene/chain/protocol/delegate.hpp> #include <graphene/chain/protocol/committee_member.hpp>
#include <graphene/chain/protocol/market.hpp> #include <graphene/chain/protocol/market.hpp>
#include <graphene/chain/protocol/proposal.hpp> #include <graphene/chain/protocol/proposal.hpp>
#include <graphene/chain/protocol/transfer.hpp> #include <graphene/chain/protocol/transfer.hpp>
@ -52,8 +52,8 @@ namespace graphene { namespace chain {
withdraw_permission_update_operation, withdraw_permission_update_operation,
withdraw_permission_claim_operation, withdraw_permission_claim_operation,
withdraw_permission_delete_operation, withdraw_permission_delete_operation,
delegate_create_operation, committee_member_create_operation,
delegate_update_global_parameters_operation, committee_member_update_global_parameters_operation,
vesting_balance_create_operation, vesting_balance_create_operation,
vesting_balance_withdraw_operation, vesting_balance_withdraw_operation,
worker_create_operation, worker_create_operation,

4
libraries/chain/include/graphene/chain/protocol/proposal.hpp
View file

@ -57,9 +57,9 @@ namespace graphene { namespace chain {
optional<uint32_t> review_period_seconds; optional<uint32_t> review_period_seconds;
extensions_type extensions; extensions_type extensions;
/// Constructs a proposal_create_operation suitable for genesis proposals, with fee, expiration time and review /// Constructs a proposal_create_operation suitable for committee proposals, with fee, expiration time and review
/// period set appropriately. /// period set appropriately.
static proposal_create_operation genesis_proposal(const chain_parameters& param, fc::time_point_sec head_block_time ); static proposal_create_operation committee_proposal(const chain_parameters& param, fc::time_point_sec head_block_time );
account_id_type fee_payer()const { return fee_paying_account; } account_id_type fee_payer()const { return fee_paying_account; }
void validate()const; void validate()const;

14
libraries/chain/include/graphene/chain/protocol/types.hpp
View file

@ -112,7 +112,7 @@ namespace graphene { namespace chain {
account_object_type, account_object_type,
asset_object_type, asset_object_type,
force_settlement_object_type, force_settlement_object_type,
delegate_object_type, committee_member_object_type,
witness_object_type, witness_object_type,
limit_order_object_type, limit_order_object_type,
call_order_object_type, call_order_object_type,
@ -133,7 +133,7 @@ namespace graphene { namespace chain {
impl_index_meta_object_type, impl_index_meta_object_type,
impl_asset_dynamic_data_type, impl_asset_dynamic_data_type,
impl_asset_bitasset_data_type, impl_asset_bitasset_data_type,
impl_delegate_feeds_object_type, impl_committee_member_feeds_object_type,
impl_account_balance_object_type, impl_account_balance_object_type,
impl_account_statistics_object_type, impl_account_statistics_object_type,
impl_account_debt_object_type, impl_account_debt_object_type,
@ -155,7 +155,7 @@ namespace graphene { namespace chain {
//typedef fc::unsigned_int object_id_type; //typedef fc::unsigned_int object_id_type;
//typedef uint64_t object_id_type; //typedef uint64_t object_id_type;
class account_object; class account_object;
class delegate_object; class committee_member_object;
class witness_object; class witness_object;
class asset_object; class asset_object;
class force_settlement_object; class force_settlement_object;
@ -173,7 +173,7 @@ namespace graphene { namespace chain {
typedef object_id< protocol_ids, account_object_type, account_object> account_id_type; typedef object_id< protocol_ids, account_object_type, account_object> account_id_type;
typedef object_id< protocol_ids, asset_object_type, asset_object> asset_id_type; typedef object_id< protocol_ids, asset_object_type, asset_object> asset_id_type;
typedef object_id< protocol_ids, force_settlement_object_type, force_settlement_object> force_settlement_id_type; typedef object_id< protocol_ids, force_settlement_object_type, force_settlement_object> force_settlement_id_type;
typedef object_id< protocol_ids, delegate_object_type, delegate_object> delegate_id_type; typedef object_id< protocol_ids, committee_member_object_type, committee_member_object> committee_member_id_type;
typedef object_id< protocol_ids, witness_object_type, witness_object> witness_id_type; typedef object_id< protocol_ids, witness_object_type, witness_object> witness_id_type;
typedef object_id< protocol_ids, limit_order_object_type, limit_order_object> limit_order_id_type; typedef object_id< protocol_ids, limit_order_object_type, limit_order_object> limit_order_id_type;
typedef object_id< protocol_ids, call_order_object_type, call_order_object> call_order_id_type; typedef object_id< protocol_ids, call_order_object_type, call_order_object> call_order_id_type;
@ -365,7 +365,7 @@ FC_REFLECT_ENUM( graphene::chain::object_type,
(account_object_type) (account_object_type)
(force_settlement_object_type) (force_settlement_object_type)
(asset_object_type) (asset_object_type)
(delegate_object_type) (committee_member_object_type)
(witness_object_type) (witness_object_type)
(limit_order_object_type) (limit_order_object_type)
(call_order_object_type) (call_order_object_type)
@ -384,7 +384,7 @@ FC_REFLECT_ENUM( graphene::chain::impl_object_type,
(impl_index_meta_object_type) (impl_index_meta_object_type)
(impl_asset_dynamic_data_type) (impl_asset_dynamic_data_type)
(impl_asset_bitasset_data_type) (impl_asset_bitasset_data_type)
(impl_delegate_feeds_object_type) (impl_committee_member_feeds_object_type)
(impl_account_balance_object_type) (impl_account_balance_object_type)
(impl_account_statistics_object_type) (impl_account_statistics_object_type)
(impl_account_debt_object_type) (impl_account_debt_object_type)
@ -401,7 +401,7 @@ FC_REFLECT_TYPENAME( graphene::chain::share_type )
FC_REFLECT_TYPENAME( graphene::chain::account_id_type ) FC_REFLECT_TYPENAME( graphene::chain::account_id_type )
FC_REFLECT_TYPENAME( graphene::chain::asset_id_type ) FC_REFLECT_TYPENAME( graphene::chain::asset_id_type )
FC_REFLECT_TYPENAME( graphene::chain::force_settlement_id_type ) FC_REFLECT_TYPENAME( graphene::chain::force_settlement_id_type )
FC_REFLECT_TYPENAME( graphene::chain::delegate_id_type ) FC_REFLECT_TYPENAME( graphene::chain::committee_member_id_type )
FC_REFLECT_TYPENAME( graphene::chain::witness_id_type ) FC_REFLECT_TYPENAME( graphene::chain::witness_id_type )
FC_REFLECT_TYPENAME( graphene::chain::limit_order_id_type ) FC_REFLECT_TYPENAME( graphene::chain::limit_order_id_type )
FC_REFLECT_TYPENAME( graphene::chain::call_order_id_type ) FC_REFLECT_TYPENAME( graphene::chain::call_order_id_type )

2
libraries/chain/include/graphene/chain/protocol/witness.hpp
View file

@ -15,7 +15,7 @@ namespace graphene { namespace chain {
struct fee_parameters_type { uint64_t fee = 5000 * GRAPHENE_BLOCKCHAIN_PRECISION; }; struct fee_parameters_type { uint64_t fee = 5000 * GRAPHENE_BLOCKCHAIN_PRECISION; };
asset fee; asset fee;
/// The account which owns the delegate. This account pays the fee for this operation. /// The account which owns the witness. This account pays the fee for this operation.
account_id_type witness_account; account_id_type witness_account;
string url; string url;
public_key_type block_signing_key; public_key_type block_signing_key;

2
libraries/chain/proposal_evaluator.cpp
View file

@ -35,7 +35,7 @@ void_result proposal_create_evaluator::do_evaluate(const proposal_create_operati
"Proposal review period must be less than its overall lifetime." ); "Proposal review period must be less than its overall lifetime." );
{ {
// If we're dealing with the genesis authority, make sure this transaction has a sufficient review period. // If we're dealing with the committee authority, make sure this transaction has a sufficient review period.
flat_set<account_id_type> auths; flat_set<account_id_type> auths;
vector<authority> other; vector<authority> other;
for( auto& op : o.proposed_ops ) for( auto& op : o.proposed_ops )

6
libraries/chain/protocol/delegate.cpp → libraries/chain/protocol/committee_member.cpp
View file

@ -1,15 +1,15 @@
/* Copyright (C) Cryptonomex, Inc - All Rights Reserved **/ /* Copyright (C) Cryptonomex, Inc - All Rights Reserved **/
#include <graphene/chain/protocol/delegate.hpp> #include <graphene/chain/protocol/committee_member.hpp>
namespace graphene { namespace chain { namespace graphene { namespace chain {
void delegate_create_operation::validate()const void committee_member_create_operation::validate()const
{ {
FC_ASSERT( fee.amount >= 0 ); FC_ASSERT( fee.amount >= 0 );
FC_ASSERT(url.size() < GRAPHENE_MAX_URL_LENGTH ); FC_ASSERT(url.size() < GRAPHENE_MAX_URL_LENGTH );
} }
void delegate_update_global_parameters_operation::validate() const void committee_member_update_global_parameters_operation::validate() const
{ {
FC_ASSERT( fee.amount >= 0 ); FC_ASSERT( fee.amount >= 0 );
new_parameters.validate(); new_parameters.validate();

2
libraries/chain/protocol/proposal.cpp
View file

@ -4,7 +4,7 @@
namespace graphene { namespace chain { namespace graphene { namespace chain {
proposal_create_operation proposal_create_operation::genesis_proposal(const chain_parameters& global_params, fc::time_point_sec head_block_time ) proposal_create_operation proposal_create_operation::committee_proposal(const chain_parameters& global_params, fc::time_point_sec head_block_time )
{ {
proposal_create_operation op; proposal_create_operation op;
op.expiration_time = head_block_time + global_params.maximum_proposal_lifetime; op.expiration_time = head_block_time + global_params.maximum_proposal_lifetime;

2
libraries/chain/transaction_evaluation_state.cpp
View file

@ -18,7 +18,7 @@
#include <graphene/chain/transaction_evaluation_state.hpp> #include <graphene/chain/transaction_evaluation_state.hpp>
#include <graphene/chain/account_object.hpp> #include <graphene/chain/account_object.hpp>
#include <graphene/chain/asset_object.hpp> #include <graphene/chain/asset_object.hpp>
#include <graphene/chain/delegate_object.hpp> #include <graphene/chain/committee_member_object.hpp>
#include <graphene/chain/database.hpp> #include <graphene/chain/database.hpp>
#include <graphene/chain/exceptions.hpp> #include <graphene/chain/exceptions.hpp>

2
libraries/chain/witness_evaluator.cpp
View file

@ -17,7 +17,7 @@
*/ */
#include <graphene/chain/witness_evaluator.hpp> #include <graphene/chain/witness_evaluator.hpp>
#include <graphene/chain/witness_object.hpp> #include <graphene/chain/witness_object.hpp>
#include <graphene/chain/delegate_object.hpp> #include <graphene/chain/committee_member_object.hpp>
#include <graphene/chain/account_object.hpp> #include <graphene/chain/account_object.hpp>
#include <graphene/chain/database.hpp> #include <graphene/chain/database.hpp>

2
libraries/fc

@ -1 +1 @@
Subproject commit 2ef7583f90b8593511dda23133ed5600f5add392 Subproject commit 0391665471b4dffb7af951853a777565a7ae9a74

5
libraries/net/include/graphene/net/config.hpp
View file

@ -25,12 +25,12 @@
* used for automated testing (creating artificial net splits, * used for automated testing (creating artificial net splits,
* tracking where messages came from and when) * tracking where messages came from and when)
*/ */
#define ENABLE_P2P_DEBUGGING_API 1 #define ENABLE_P2P_DEBUGGING_API 1
/** /**
* 2MiB * 2MiB
*/ */
#define MAX_MESSAGE_SIZE 1024*1024*2 #define MAX_MESSAGE_SIZE 1024*1024*2
#define GRAPHENE_NET_DEFAULT_PEER_CONNECTION_RETRY_TIME 30 // seconds #define GRAPHENE_NET_DEFAULT_PEER_CONNECTION_RETRY_TIME 30 // seconds
/** /**
@ -47,7 +47,6 @@
#define GRAPHENE_NET_TEST_P2P_PORT 1700 #define GRAPHENE_NET_TEST_P2P_PORT 1700
#define GRAPHENE_NET_DEFAULT_P2P_PORT 1776 #define GRAPHENE_NET_DEFAULT_P2P_PORT 1776
#define GRAPHENE_NET_DEFAULT_DESIRED_CONNECTIONS 20 #define GRAPHENE_NET_DEFAULT_DESIRED_CONNECTIONS 20
#define GRAPHENE_NET_DELEGATE_DESIRED_CONNECTIONS 50
#define GRAPHENE_NET_DEFAULT_MAX_CONNECTIONS 200 #define GRAPHENE_NET_DEFAULT_MAX_CONNECTIONS 200
#define GRAPHENE_NET_MAXIMUM_QUEUED_MESSAGES_IN_BYTES (1024 * 1024) #define GRAPHENE_NET_MAXIMUM_QUEUED_MESSAGES_IN_BYTES (1024 * 1024)

8
libraries/net/node.cpp
View file

@ -1431,16 +1431,16 @@ namespace graphene { namespace net { namespace detail {
{ {
_average_network_usage_second_counter = 0; _average_network_usage_second_counter = 0;
++_average_network_usage_minute_counter; ++_average_network_usage_minute_counter;
uint32_t average_read_this_minute = (uint32_t)boost::accumulate(_average_network_read_speed_seconds, UINT64_C(0)) / (uint32_t)_average_network_read_speed_seconds.size(); uint32_t average_read_this_minute = (uint32_t)boost::accumulate(_average_network_read_speed_seconds, uint64_t(0)) / (uint32_t)_average_network_read_speed_seconds.size();
_average_network_read_speed_minutes.push_back(average_read_this_minute); _average_network_read_speed_minutes.push_back(average_read_this_minute);
uint32_t average_written_this_minute = (uint32_t)boost::accumulate(_average_network_write_speed_seconds, UINT64_C(0)) / (uint32_t)_average_network_write_speed_seconds.size(); uint32_t average_written_this_minute = (uint32_t)boost::accumulate(_average_network_write_speed_seconds, uint64_t(0)) / (uint32_t)_average_network_write_speed_seconds.size();
_average_network_write_speed_minutes.push_back(average_written_this_minute); _average_network_write_speed_minutes.push_back(average_written_this_minute);
if (_average_network_usage_minute_counter >= 60) if (_average_network_usage_minute_counter >= 60)
{ {
_average_network_usage_minute_counter = 0; _average_network_usage_minute_counter = 0;
uint32_t average_read_this_hour = (uint32_t)boost::accumulate(_average_network_read_speed_minutes, UINT64_C(0)) / (uint32_t)_average_network_read_speed_minutes.size(); uint32_t average_read_this_hour = (uint32_t)boost::accumulate(_average_network_read_speed_minutes, uint64_t(0)) / (uint32_t)_average_network_read_speed_minutes.size();
_average_network_read_speed_hours.push_back(average_read_this_hour); _average_network_read_speed_hours.push_back(average_read_this_hour);
uint32_t average_written_this_hour = (uint32_t)boost::accumulate(_average_network_write_speed_minutes, UINT64_C(0)) / (uint32_t)_average_network_write_speed_minutes.size(); uint32_t average_written_this_hour = (uint32_t)boost::accumulate(_average_network_write_speed_minutes, uint64_t(0)) / (uint32_t)_average_network_write_speed_minutes.size();
_average_network_write_speed_hours.push_back(average_written_this_hour); _average_network_write_speed_hours.push_back(average_written_this_hour);
} }
} }

2
libraries/plugins/witness/CMakeLists.txt
View file

@ -1,4 +1,4 @@
file(GLOB HEADERS "include/graphene/delegate/*.hpp") file(GLOB HEADERS "include/graphene/witness/*.hpp")
add_library( graphene_witness add_library( graphene_witness
witness.cpp witness.cpp

2
libraries/plugins/witness/include/graphene/witness/witness.hpp
View file

@ -64,4 +64,4 @@ private:
fc::future<void> _block_production_task; fc::future<void> _block_production_task;
}; };
} } //graphene::delegate } } //graphene::witness_plugin

4
libraries/plugins/witness/witness.cpp
View file

@ -150,7 +150,7 @@ void witness_plugin::plugin_shutdown()
void witness_plugin::schedule_next_production(const graphene::chain::chain_parameters& global_parameters) void witness_plugin::schedule_next_production(const graphene::chain::chain_parameters& global_parameters)
{ {
//Get next production time for *any* delegate //Get next production time for *any* witness
auto block_interval = global_parameters.block_interval; auto block_interval = global_parameters.block_interval;
fc::time_point next_block_time = fc::time_point_sec() + fc::time_point next_block_time = fc::time_point_sec() +
(graphene::time::now().sec_since_epoch() / block_interval + 1) * block_interval; (graphene::time::now().sec_since_epoch() / block_interval + 1) * block_interval;
@ -158,7 +158,7 @@ void witness_plugin::schedule_next_production(const graphene::chain::chain_param
if( graphene::time::ntp_time().valid() ) if( graphene::time::ntp_time().valid() )
next_block_time -= graphene::time::ntp_error(); next_block_time -= graphene::time::ntp_error();
//Sleep until the next production time for *any* delegate //Sleep until the next production time for *any* witness
_block_production_task = fc::schedule([this]{block_production_loop();}, _block_production_task = fc::schedule([this]{block_production_loop();},
next_block_time, "Witness Block Production"); next_block_time, "Witness Block Production");
} }

6
libraries/wallet/cache.cpp
View file

@ -18,7 +18,7 @@
#include <graphene/chain/account_object.hpp> #include <graphene/chain/account_object.hpp>
#include <graphene/chain/asset_object.hpp> #include <graphene/chain/asset_object.hpp>
#include <graphene/chain/delegate_object.hpp> #include <graphene/chain/committee_member_object.hpp>
#include <graphene/chain/witness_object.hpp> #include <graphene/chain/witness_object.hpp>
#include <graphene/chain/market_evaluator.hpp> #include <graphene/chain/market_evaluator.hpp>
#include <graphene/chain/proposal_object.hpp> #include <graphene/chain/proposal_object.hpp>
@ -62,8 +62,8 @@ object* create_object( const variant& v )
return create_object_of_type< asset_object >( v ); return create_object_of_type< asset_object >( v );
case force_settlement_object_type: case force_settlement_object_type:
return create_object_of_type< force_settlement_object >( v ); return create_object_of_type< force_settlement_object >( v );
case delegate_object_type: case committee_member_object_type:
return create_object_of_type< delegate_object >( v ); return create_object_of_type< committee_member_object >( v );
case witness_object_type: case witness_object_type:
return create_object_of_type< witness_object >( v ); return create_object_of_type< witness_object >( v );
case limit_order_object_type: case limit_order_object_type:

94
libraries/wallet/include/graphene/wallet/wallet.hpp
View file

@ -182,7 +182,7 @@ class wallet_api
/** Returns the block chain's slowly-changing settings. /** Returns the block chain's slowly-changing settings.
* This object contains all of the properties of the blockchain that are fixed * This object contains all of the properties of the blockchain that are fixed
* or that change only once per maintenance interval (daily) such as the * or that change only once per maintenance interval (daily) such as the
* current list of witnesses, delegates, block interval, etc. * current list of witnesses, committee_members, block interval, etc.
* @see \c get_dynamic_global_properties() for frequently changing properties * @see \c get_dynamic_global_properties() for frequently changing properties
* @returns the global properties * @returns the global properties
*/ */
@ -686,7 +686,7 @@ class wallet_api
* *
* Price feed providers use this command to publish their price feeds for market-issued assets. A price feed is * Price feed providers use this command to publish their price feeds for market-issued assets. A price feed is
* used to tune the market for a particular market-issued asset. For each value in the feed, the median across all * used to tune the market for a particular market-issued asset. For each value in the feed, the median across all
* delegate feeds for that asset is calculated and the market for the asset is configured with the median of that * committee_member feeds for that asset is calculated and the market for the asset is configured with the median of that
* value. * value.
* *
* The feed object in this command contains three prices: a call price limit, a short price limit, and a settlement price. * The feed object in this command contains three prices: a call price limit, a short price limit, and a settlement price.
@ -807,17 +807,17 @@ class wallet_api
account_whitelist_operation::account_listing new_listing_status, account_whitelist_operation::account_listing new_listing_status,
bool broadcast = false); bool broadcast = false);
/** Creates a delegate object owned by the given account. /** Creates a committee_member object owned by the given account.
* *
* An account can have at most one delegate object. * An account can have at most one committee_member object.
* *
* @param owner_account the name or id of the account which is creating the delegate * @param owner_account the name or id of the account which is creating the committee_member
* @param url a URL to include in the delegate record in the blockchain. Clients may * @param url a URL to include in the committee_member record in the blockchain. Clients may
* display this when showing a list of delegates. May be blank. * display this when showing a list of committee_members. May be blank.
* @param broadcast true to broadcast the transaction on the network * @param broadcast true to broadcast the transaction on the network
* @returns the signed transaction registering a delegate * @returns the signed transaction registering a committee_member
*/ */
signed_transaction create_delegate(string owner_account, signed_transaction create_committee_member(string owner_account,
string url, string url,
bool broadcast = false); bool broadcast = false);
@ -836,20 +836,20 @@ class wallet_api
*/ */
map<string,witness_id_type> list_witnesses(const string& lowerbound, uint32_t limit); map<string,witness_id_type> list_witnesses(const string& lowerbound, uint32_t limit);
/** Lists all delegates registered in the blockchain. /** Lists all committee_members registered in the blockchain.
* This returns a list of all account names that own delegates, and the associated delegate id, * This returns a list of all account names that own committee_members, and the associated committee_member id,
* sorted by name. This lists delegates whether they are currently voted in or not. * sorted by name. This lists committee_members whether they are currently voted in or not.
* *
* Use the \c lowerbound and limit parameters to page through the list. To retrieve all delegates, * Use the \c lowerbound and limit parameters to page through the list. To retrieve all committee_members,
* start by setting \c lowerbound to the empty string \c "", and then each iteration, pass * start by setting \c lowerbound to the empty string \c "", and then each iteration, pass
* the last delegate name returned as the \c lowerbound for the next \c list_delegates() call. * the last committee_member name returned as the \c lowerbound for the next \c list_committee_members() call.
* *
* @param lowerbound the name of the first delegate to return. If the named delegate does not exist, * @param lowerbound the name of the first committee_member to return. If the named committee_member does not exist,
* the list will start at the delegate that comes after \c lowerbound * the list will start at the committee_member that comes after \c lowerbound
* @param limit the maximum number of delegates to return (max: 1000) * @param limit the maximum number of committee_members to return (max: 1000)
* @returns a list of delegates mapping delegate names to delegate ids * @returns a list of committee_members mapping committee_member names to committee_member ids
*/ */
map<string, delegate_id_type> list_delegates(const string& lowerbound, uint32_t limit); map<string, committee_member_id_type> list_committee_members(const string& lowerbound, uint32_t limit);
/** Returns information about the given witness. /** Returns information about the given witness.
* @param owner_account the name or id of the witness account owner, or the id of the witness * @param owner_account the name or id of the witness account owner, or the id of the witness
@ -857,11 +857,11 @@ class wallet_api
*/ */
witness_object get_witness(string owner_account); witness_object get_witness(string owner_account);
/** Returns information about the given delegate. /** Returns information about the given committee_member.
* @param owner_account the name or id of the delegate account owner, or the id of the delegate * @param owner_account the name or id of the committee_member account owner, or the id of the committee_member
* @returns the information about the delegate stored in the block chain * @returns the information about the committee_member stored in the block chain
*/ */
delegate_object get_delegate(string owner_account); committee_member_object get_committee_member(string owner_account);
/** Creates a witness object owned by the given account. /** Creates a witness object owned by the given account.
* *
@ -877,25 +877,25 @@ class wallet_api
string url, string url,
bool broadcast = false); bool broadcast = false);
/** Vote for a given delegate. /** Vote for a given committee_member.
* *
* An account can publish a list of all delegatees they approve of. This * An account can publish a list of all committee_memberes they approve of. This
* command allows you to add or remove delegatees from this list. * command allows you to add or remove committee_memberes from this list.
* Each account's vote is weighted according to the number of shares of the * 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. * core asset owned by that account at the time the votes are tallied.
* *
* @note you cannot vote against a delegate, you can only vote for the delegate * @note you cannot vote against a committee_member, you can only vote for the committee_member
* or not vote for the delegate. * or not vote for the committee_member.
* *
* @param voting_account the name or id of the account who is voting with their shares * @param voting_account the name or id of the account who is voting with their shares
* @param delegate the name or id of the delegate' owner account * @param committee_member the name or id of the committee_member' owner account
* @param approve true if you wish to vote in favor of that delegate, false to * @param approve true if you wish to vote in favor of that committee_member, false to
* remove your vote in favor of that delegate * remove your vote in favor of that committee_member
* @param broadcast true if you wish to broadcast the transaction * @param broadcast true if you wish to broadcast the transaction
* @return the signed transaction changing your vote for the given delegate * @return the signed transaction changing your vote for the given committee_member
*/ */
signed_transaction vote_for_delegate(string voting_account, signed_transaction vote_for_committee_member(string voting_account,
string delegate, string committee_member,
bool approve, bool approve,
bool broadcast = false); bool broadcast = false);
@ -943,13 +943,13 @@ class wallet_api
optional<string> voting_account, optional<string> voting_account,
bool broadcast = false); bool broadcast = false);
/** Set your vote for the number of witnesses and delegates in the system. /** Set your vote for the number of witnesses and committee_members in the system.
* *
* Each account can voice their opinion on how many delegates and how many * Each account can voice their opinion on how many committee_members and how many
* witnesses there should be in the active delegate/active witness list. These * witnesses there should be in the active committee_member/active witness list. These
* are independent of each other. You must vote your approval of at least as many * are independent of each other. You must vote your approval of at least as many
* delegates or witnesses as you claim there should be (you can't say that there should * committee_members or witnesses as you claim there should be (you can't say that there should
* be 20 delegates but only vote for 10). * be 20 committee_members but only vote for 10).
* *
* There are maximum values for each set in the blockchain parameters (currently * There are maximum values for each set in the blockchain parameters (currently
* defaulting to 1001). * defaulting to 1001).
@ -958,14 +958,14 @@ class wallet_api
* set, your preferences will be ignored. * set, your preferences will be ignored.
* *
* @param account_to_modify the name or id of the account to update * @param account_to_modify the name or id of the account to update
* @param number_of_delegates the number * @param number_of_committee_members the number
* *
* @param broadcast true if you wish to broadcast the transaction * @param broadcast true if you wish to broadcast the transaction
* @return the signed transaction changing your vote proxy settings * @return the signed transaction changing your vote proxy settings
*/ */
signed_transaction set_desired_witness_and_delegate_count(string account_to_modify, signed_transaction set_desired_witness_and_committee_member_count(string account_to_modify,
uint16_t desired_number_of_witnesses, uint16_t desired_number_of_witnesses,
uint16_t desired_number_of_delegates, uint16_t desired_number_of_committee_members,
bool broadcast = false); bool broadcast = false);
/** Signs a transaction. /** Signs a transaction.
@ -1070,16 +1070,16 @@ FC_API( graphene::wallet::wallet_api,
(global_settle_asset) (global_settle_asset)
(settle_asset) (settle_asset)
(whitelist_account) (whitelist_account)
(create_delegate) (create_committee_member)
(get_witness) (get_witness)
(get_delegate) (get_committee_member)
(list_witnesses) (list_witnesses)
(list_delegates) (list_committee_members)
(create_witness) (create_witness)
(vote_for_delegate) (vote_for_committee_member)
(vote_for_witness) (vote_for_witness)
(set_voting_proxy) (set_voting_proxy)
(set_desired_witness_and_delegate_count) (set_desired_witness_and_committee_member_count)
(get_account) (get_account)
(get_account_id) (get_account_id)
(get_block) (get_block)

112
libraries/wallet/wallet.cpp
View file

@ -400,7 +400,7 @@ public:
result["next_maintenance_time"] = fc::get_approximate_relative_time_string(dynamic_props.next_maintenance_time); result["next_maintenance_time"] = fc::get_approximate_relative_time_string(dynamic_props.next_maintenance_time);
result["chain_id"] = global_props.chain_id; result["chain_id"] = global_props.chain_id;
result["active_witnesses"] = global_props.active_witnesses; result["active_witnesses"] = global_props.active_witnesses;
result["active_delegates"] = global_props.active_delegates; result["active_committee_members"] = global_props.active_committee_members;
result["entropy"] = dynamic_props.random; result["entropy"] = dynamic_props.random;
return result; return result;
} }
@ -1117,18 +1117,18 @@ public:
return sign_transaction( tx, broadcast ); return sign_transaction( tx, broadcast );
} FC_CAPTURE_AND_RETHROW( (authorizing_account)(account_to_list)(new_listing_status)(broadcast) ) } } FC_CAPTURE_AND_RETHROW( (authorizing_account)(account_to_list)(new_listing_status)(broadcast) ) }
signed_transaction create_delegate(string owner_account, string url, signed_transaction create_committee_member(string owner_account, string url,
bool broadcast /* = false */) bool broadcast /* = false */)
{ try { { try {
delegate_create_operation delegate_create_op; committee_member_create_operation committee_member_create_op;
delegate_create_op.delegate_account = get_account_id(owner_account); committee_member_create_op.committee_member_account = get_account_id(owner_account);
delegate_create_op.url = url; committee_member_create_op.url = url;
if (_remote_db->get_delegate_by_account(delegate_create_op.delegate_account)) if (_remote_db->get_committee_member_by_account(committee_member_create_op.committee_member_account))
FC_THROW("Account ${owner_account} is already a delegate", ("owner_account", owner_account)); FC_THROW("Account ${owner_account} is already a committee_member", ("owner_account", owner_account));
signed_transaction tx; signed_transaction tx;
tx.operations.push_back( delegate_create_op ); tx.operations.push_back( committee_member_create_op );
set_operation_fees( tx, _remote_db->get_global_properties().parameters.current_fees); set_operation_fees( tx, _remote_db->get_global_properties().parameters.current_fees);
tx.validate(); tx.validate();
@ -1170,19 +1170,19 @@ public:
FC_CAPTURE_AND_RETHROW( (owner_account) ) FC_CAPTURE_AND_RETHROW( (owner_account) )
} }
delegate_object get_delegate(string owner_account) committee_member_object get_committee_member(string owner_account)
{ {
try try
{ {
fc::optional<delegate_id_type> delegate_id = maybe_id<delegate_id_type>(owner_account); fc::optional<committee_member_id_type> committee_member_id = maybe_id<committee_member_id_type>(owner_account);
if (delegate_id) if (committee_member_id)
{ {
std::vector<delegate_id_type> ids_to_get; std::vector<committee_member_id_type> ids_to_get;
ids_to_get.push_back(*delegate_id); ids_to_get.push_back(*committee_member_id);
std::vector<fc::optional<delegate_object>> delegate_objects = _remote_db->get_delegates(ids_to_get); std::vector<fc::optional<committee_member_object>> committee_member_objects = _remote_db->get_committee_members(ids_to_get);
if (delegate_objects.front()) if (committee_member_objects.front())
return *delegate_objects.front(); return *committee_member_objects.front();
FC_THROW("No delegate is registered for id ${id}", ("id", owner_account)); FC_THROW("No committee_member is registered for id ${id}", ("id", owner_account));
} }
else else
{ {
@ -1190,15 +1190,15 @@ public:
try try
{ {
account_id_type owner_account_id = get_account_id(owner_account); account_id_type owner_account_id = get_account_id(owner_account);
fc::optional<delegate_object> delegate = _remote_db->get_delegate_by_account(owner_account_id); fc::optional<committee_member_object> committee_member = _remote_db->get_committee_member_by_account(owner_account_id);
if (delegate) if (committee_member)
return *delegate; return *committee_member;
else else
FC_THROW("No delegate is registered for account ${account}", ("account", owner_account)); FC_THROW("No committee_member is registered for account ${account}", ("account", owner_account));
} }
catch (const fc::exception&) catch (const fc::exception&)
{ {
FC_THROW("No account or delegate named ${account}", ("account", owner_account)); FC_THROW("No account or committee_member named ${account}", ("account", owner_account));
} }
} }
} }
@ -1238,27 +1238,27 @@ public:
return sign_transaction( tx, broadcast ); return sign_transaction( tx, broadcast );
} FC_CAPTURE_AND_RETHROW( (owner_account)(broadcast) ) } } FC_CAPTURE_AND_RETHROW( (owner_account)(broadcast) ) }
signed_transaction vote_for_delegate(string voting_account, signed_transaction vote_for_committee_member(string voting_account,
string delegate, string committee_member,
bool approve, bool approve,
bool broadcast /* = false */) bool broadcast /* = false */)
{ try { { try {
account_object voting_account_object = get_account(voting_account); account_object voting_account_object = get_account(voting_account);
account_id_type delegate_owner_account_id = get_account_id(delegate); account_id_type committee_member_owner_account_id = get_account_id(committee_member);
fc::optional<delegate_object> delegate_obj = _remote_db->get_delegate_by_account(delegate_owner_account_id); fc::optional<committee_member_object> committee_member_obj = _remote_db->get_committee_member_by_account(committee_member_owner_account_id);
if (!delegate_obj) if (!committee_member_obj)
FC_THROW("Account ${delegate} is not registered as a delegate", ("delegate", delegate)); FC_THROW("Account ${committee_member} is not registered as a committee_member", ("committee_member", committee_member));
if (approve) if (approve)
{ {
auto insert_result = voting_account_object.options.votes.insert(delegate_obj->vote_id); auto insert_result = voting_account_object.options.votes.insert(committee_member_obj->vote_id);
if (!insert_result.second) if (!insert_result.second)
FC_THROW("Account ${account} was already voting for delegate ${delegate}", ("account", voting_account)("delegate", delegate)); FC_THROW("Account ${account} was already voting for committee_member ${committee_member}", ("account", voting_account)("committee_member", committee_member));
} }
else else
{ {
unsigned votes_removed = voting_account_object.options.votes.erase(delegate_obj->vote_id); unsigned votes_removed = voting_account_object.options.votes.erase(committee_member_obj->vote_id);
if (!votes_removed) if (!votes_removed)
FC_THROW("Account ${account} is already not voting for delegate ${delegate}", ("account", voting_account)("delegate", delegate)); FC_THROW("Account ${account} is already not voting for committee_member ${committee_member}", ("account", voting_account)("committee_member", committee_member));
} }
account_update_operation account_update_op; account_update_operation account_update_op;
account_update_op.account = voting_account_object.id; account_update_op.account = voting_account_object.id;
@ -1270,7 +1270,7 @@ public:
tx.validate(); tx.validate();
return sign_transaction( tx, broadcast ); return sign_transaction( tx, broadcast );
} FC_CAPTURE_AND_RETHROW( (voting_account)(delegate)(approve)(broadcast) ) } } FC_CAPTURE_AND_RETHROW( (voting_account)(committee_member)(approve)(broadcast) ) }
signed_transaction vote_for_witness(string voting_account, signed_transaction vote_for_witness(string voting_account,
string witness, string witness,
@ -1337,19 +1337,19 @@ public:
return sign_transaction( tx, broadcast ); return sign_transaction( tx, broadcast );
} FC_CAPTURE_AND_RETHROW( (account_to_modify)(voting_account)(broadcast) ) } } FC_CAPTURE_AND_RETHROW( (account_to_modify)(voting_account)(broadcast) ) }
signed_transaction set_desired_witness_and_delegate_count(string account_to_modify, signed_transaction set_desired_witness_and_committee_member_count(string account_to_modify,
uint16_t desired_number_of_witnesses, uint16_t desired_number_of_witnesses,
uint16_t desired_number_of_delegates, uint16_t desired_number_of_committee_members,
bool broadcast /* = false */) bool broadcast /* = false */)
{ try { { try {
account_object account_object_to_modify = get_account(account_to_modify); account_object account_object_to_modify = get_account(account_to_modify);
if (account_object_to_modify.options.num_witness == desired_number_of_witnesses && if (account_object_to_modify.options.num_witness == desired_number_of_witnesses &&
account_object_to_modify.options.num_committee == desired_number_of_delegates) account_object_to_modify.options.num_committee == desired_number_of_committee_members)
FC_THROW("Account ${account} is already voting for ${witnesses} witnesses and ${delegates} delegates", FC_THROW("Account ${account} is already voting for ${witnesses} witnesses and ${committee_members} committee_members",
("account", account_to_modify)("witnesses", desired_number_of_witnesses)("delegates",desired_number_of_witnesses)); ("account", account_to_modify)("witnesses", desired_number_of_witnesses)("committee_members",desired_number_of_witnesses));
account_object_to_modify.options.num_witness = desired_number_of_witnesses; account_object_to_modify.options.num_witness = desired_number_of_witnesses;
account_object_to_modify.options.num_committee = desired_number_of_delegates; account_object_to_modify.options.num_committee = desired_number_of_committee_members;
account_update_operation account_update_op; account_update_operation account_update_op;
account_update_op.account = account_object_to_modify.id; account_update_op.account = account_object_to_modify.id;
@ -1361,7 +1361,7 @@ public:
tx.validate(); tx.validate();
return sign_transaction( tx, broadcast ); return sign_transaction( tx, broadcast );
} FC_CAPTURE_AND_RETHROW( (account_to_modify)(desired_number_of_witnesses)(desired_number_of_delegates)(broadcast) ) } } FC_CAPTURE_AND_RETHROW( (account_to_modify)(desired_number_of_witnesses)(desired_number_of_committee_members)(broadcast) ) }
signed_transaction sign_transaction(signed_transaction tx, bool broadcast = false) signed_transaction sign_transaction(signed_transaction tx, bool broadcast = false)
{ {
@ -2095,10 +2095,10 @@ signed_transaction wallet_api::whitelist_account(string authorizing_account,
return my->whitelist_account(authorizing_account, account_to_list, new_listing_status, broadcast); return my->whitelist_account(authorizing_account, account_to_list, new_listing_status, broadcast);
} }
signed_transaction wallet_api::create_delegate(string owner_account, string url, signed_transaction wallet_api::create_committee_member(string owner_account, string url,
bool broadcast /* = false */) bool broadcast /* = false */)
{ {
return my->create_delegate(owner_account, url, broadcast); return my->create_committee_member(owner_account, url, broadcast);
} }
map<string,witness_id_type> wallet_api::list_witnesses(const string& lowerbound, uint32_t limit) map<string,witness_id_type> wallet_api::list_witnesses(const string& lowerbound, uint32_t limit)
@ -2106,9 +2106,9 @@ map<string,witness_id_type> wallet_api::list_witnesses(const string& lowerbound,
return my->_remote_db->lookup_witness_accounts(lowerbound, limit); return my->_remote_db->lookup_witness_accounts(lowerbound, limit);
} }
map<string,delegate_id_type> wallet_api::list_delegates(const string& lowerbound, uint32_t limit) map<string,committee_member_id_type> wallet_api::list_committee_members(const string& lowerbound, uint32_t limit)
{ {
return my->_remote_db->lookup_delegate_accounts(lowerbound, limit); return my->_remote_db->lookup_committee_member_accounts(lowerbound, limit);
} }
witness_object wallet_api::get_witness(string owner_account) witness_object wallet_api::get_witness(string owner_account)
@ -2116,9 +2116,9 @@ witness_object wallet_api::get_witness(string owner_account)
return my->get_witness(owner_account); return my->get_witness(owner_account);
} }
delegate_object wallet_api::get_delegate(string owner_account) committee_member_object wallet_api::get_committee_member(string owner_account)
{ {
return my->get_delegate(owner_account); return my->get_committee_member(owner_account);
} }
signed_transaction wallet_api::create_witness(string owner_account, signed_transaction wallet_api::create_witness(string owner_account,
@ -2128,12 +2128,12 @@ signed_transaction wallet_api::create_witness(string owner_account,
return my->create_witness(owner_account, url, broadcast); return my->create_witness(owner_account, url, broadcast);
} }
signed_transaction wallet_api::vote_for_delegate(string voting_account, signed_transaction wallet_api::vote_for_committee_member(string voting_account,
string witness, string witness,
bool approve, bool approve,
bool broadcast /* = false */) bool broadcast /* = false */)
{ {
return my->vote_for_delegate(voting_account, witness, approve, broadcast); return my->vote_for_committee_member(voting_account, witness, approve, broadcast);
} }
signed_transaction wallet_api::vote_for_witness(string voting_account, signed_transaction wallet_api::vote_for_witness(string voting_account,
@ -2151,13 +2151,13 @@ signed_transaction wallet_api::set_voting_proxy(string account_to_modify,
return my->set_voting_proxy(account_to_modify, voting_account, broadcast); return my->set_voting_proxy(account_to_modify, voting_account, broadcast);
} }
signed_transaction wallet_api::set_desired_witness_and_delegate_count(string account_to_modify, signed_transaction wallet_api::set_desired_witness_and_committee_member_count(string account_to_modify,
uint16_t desired_number_of_witnesses, uint16_t desired_number_of_witnesses,
uint16_t desired_number_of_delegates, uint16_t desired_number_of_committee_members,
bool broadcast /* = false */) bool broadcast /* = false */)
{ {
return my->set_desired_witness_and_delegate_count(account_to_modify, desired_number_of_witnesses, return my->set_desired_witness_and_committee_member_count(account_to_modify, desired_number_of_witnesses,
desired_number_of_delegates, broadcast); desired_number_of_committee_members, broadcast);
} }
void wallet_api::set_wallet_filename(string wallet_filename) void wallet_api::set_wallet_filename(string wallet_filename)
@ -2186,14 +2186,14 @@ operation wallet_api::get_prototype_operation(string operation_name)
return graphene::chain::account_upgrade_operation(); return graphene::chain::account_upgrade_operation();
if (operation_name == "account_transfer_operation") if (operation_name == "account_transfer_operation")
return graphene::chain::account_transfer_operation(); return graphene::chain::account_transfer_operation();
if (operation_name == "delegate_create_operation") if (operation_name == "committee_member_create_operation")
return graphene::chain::delegate_create_operation(); return graphene::chain::committee_member_create_operation();
if (operation_name == "witness_create_operation") if (operation_name == "witness_create_operation")
return graphene::chain::witness_create_operation(); return graphene::chain::witness_create_operation();
if (operation_name == "witness_withdraw_pay_operation") if (operation_name == "witness_withdraw_pay_operation")
return graphene::chain::witness_withdraw_pay_operation(); return graphene::chain::witness_withdraw_pay_operation();
if (operation_name == "delegate_update_global_parameters_operation") if (operation_name == "committee_member_update_global_parameters_operation")
return graphene::chain::delegate_update_global_parameters_operation(); return graphene::chain::committee_member_update_global_parameters_operation();
if (operation_name == "transfer_operation") if (operation_name == "transfer_operation")
return graphene::chain::transfer_operation(); return graphene::chain::transfer_operation();
if (operation_name == "override_transfer_operation") if (operation_name == "override_transfer_operation")

4
programs/cli_full_wallet/main.cpp
View file

@ -132,9 +132,9 @@ int main( int argc, char** argv )
//fc::configure_logging( cfg ); //fc::configure_logging( cfg );
fc::ecc::private_key genesis_private_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key"))); fc::ecc::private_key committee_private_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")));
idump( (key_to_wif( genesis_private_key ) ) ); idump( (key_to_wif( committee_private_key ) ) );
fc::ecc::private_key nathan_private_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("nathan"))); fc::ecc::private_key nathan_private_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("nathan")));
idump( (key_to_wif( nathan_private_key ) ) ); idump( (key_to_wif( nathan_private_key ) ) );

4
programs/cli_wallet/main.cpp
View file

@ -105,9 +105,9 @@ int main( int argc, char** argv )
//fc::configure_logging( cfg ); //fc::configure_logging( cfg );
fc::ecc::private_key genesis_private_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key"))); fc::ecc::private_key committee_private_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")));
idump( (key_to_wif( genesis_private_key ) ) ); idump( (key_to_wif( committee_private_key ) ) );
fc::ecc::private_key nathan_private_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("nathan"))); fc::ecc::private_key nathan_private_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("nathan")));
public_key_type nathan_pub_key = nathan_private_key.get_public_key(); public_key_type nathan_pub_key = nathan_private_key.get_public_key();

25
programs/light_client/ClientDataModel.cpp
View file

@ -10,7 +10,7 @@ using namespace graphene::app;
ChainDataModel::ChainDataModel( fc::thread& t, QObject* parent ) ChainDataModel::ChainDataModel( fc::thread& t, QObject* parent )
:QObject(parent),m_thread(&t){} :QObject(parent),m_thread(&t){}
Account* ChainDataModel::getAccount(qint64 id) Account* ChainDataModel::getAccount(qint64 id)
{ {
auto itr = m_accounts.find( id ); auto itr = m_accounts.find( id );
if( itr != m_accounts.end() ) if( itr != m_accounts.end() )
@ -22,7 +22,7 @@ Account* ChainDataModel::getAccount(qint64 id)
auto insert_result = m_accounts.insert( acct ); auto insert_result = m_accounts.insert( acct );
/** execute in app thread */ /** execute in app thread */
m_thread->async( [=](){ m_thread->async( [=](){
try { try {
auto result = m_db_api->get_accounts( {account_id_type(id)} ); auto result = m_db_api->get_accounts( {account_id_type(id)} );
if( result.size() && result.front().valid() ) if( result.size() && result.front().valid() )
@ -30,7 +30,7 @@ Account* ChainDataModel::getAccount(qint64 id)
QString name = QString::fromStdString( result.front()->name ); QString name = QString::fromStdString( result.front()->name );
/** execute in main */ /** execute in main */
Q_EMIT queueExecute( [=](){ Q_EMIT queueExecute( [=](){
this->m_accounts.modify( insert_result.first, this->m_accounts.modify( insert_result.first,
[=]( Account* a ){ a->setProperty("name", name ); } [=]( Account* a ){ a->setProperty("name", name ); }
); );
}); });
@ -43,9 +43,10 @@ Account* ChainDataModel::getAccount(qint64 id)
m_accounts.erase( insert_result.first ); m_accounts.erase( insert_result.first );
}); });
} }
} }
catch ( const fc::exception& e ) catch ( const fc::exception& e )
{ {
edump((e.to_detail_string()));
Q_EMIT exceptionThrown( QString::fromStdString(e.to_string()) ); Q_EMIT exceptionThrown( QString::fromStdString(e.to_string()) );
} }
}); });
@ -53,7 +54,7 @@ Account* ChainDataModel::getAccount(qint64 id)
return acct; return acct;
} }
Account* ChainDataModel::getAccount(QString name) Account* ChainDataModel::getAccount(QString name)
{ {
auto itr = m_accounts.get<::by_name>().find(name); auto itr = m_accounts.get<::by_name>().find(name);
if( itr != m_accounts.get<::by_name>().end() ) if( itr != m_accounts.get<::by_name>().end() )
@ -61,23 +62,22 @@ Account* ChainDataModel::getAccount(QString name)
return *itr; return *itr;
} }
auto acct = new Account(this); auto acct = new Account(this);
acct->setProperty("id", --m_account_query_num ); acct->setProperty("id", --m_account_query_num );
acct->setProperty("name", name); acct->setProperty("name", name);
auto insert_result = m_accounts.insert( acct ); auto insert_result = m_accounts.insert( acct );
/** execute in app thread */ /** execute in app thread */
m_thread->async( [=](){ m_thread->async( [=](){
try { try {
auto result = m_db_api->lookup_account_names( {name.toStdString()} ); auto result = m_db_api->lookup_account_names( {name.toStdString()} );
if( result.size() && result.front().valid() ) if( result.size() && result.front().valid() )
{ {
/** execute in main */ /** execute in main */
Q_EMIT queueExecute( [=](){ Q_EMIT queueExecute( [=](){
this->m_accounts.modify( insert_result.first, this->m_accounts.modify( insert_result.first,
[=]( Account* a ){ [=]( Account* a ){
a->setProperty("id", result.front()->id.instance() ); a->setProperty("id", result.front()->id.instance() );
} }
); );
}); });
@ -90,14 +90,15 @@ Account* ChainDataModel::getAccount(QString name)
m_accounts.erase( insert_result.first ); m_accounts.erase( insert_result.first );
}); });
} }
} }
catch ( const fc::exception& e ) catch ( const fc::exception& e )
{ {
edump((e.to_detail_string()));
Q_EMIT exceptionThrown( QString::fromStdString(e.to_string()) ); Q_EMIT exceptionThrown( QString::fromStdString(e.to_string()) );
} }
}); });
return nullptr; return acct;
} }
QQmlListProperty<Balance> Account::balances() QQmlListProperty<Balance> Account::balances()

10
programs/light_client/ClientDataModel.hpp
View file

@ -47,8 +47,8 @@ class Balance : public QObject {
class Account : public QObject { class Account : public QObject {
Q_OBJECT Q_OBJECT
Q_PROPERTY(QString name MEMBER name) Q_PROPERTY(QString name MEMBER name NOTIFY nameChanged)
Q_PROPERTY(qint64 id MEMBER id) Q_PROPERTY(qint64 id MEMBER id NOTIFY idChanged)
Q_PROPERTY(QQmlListProperty<Balance> balances READ balances) Q_PROPERTY(QQmlListProperty<Balance> balances READ balances)
QString name; QString name;
@ -63,9 +63,13 @@ public:
qint64 getId()const { return id; } qint64 getId()const { return id; }
QQmlListProperty<Balance> balances(); QQmlListProperty<Balance> balances();
signals:
void nameChanged();
void idChanged();
}; };
struct by_id; struct by_id;
struct by_name; struct by_name;
/** /**
* @ingroup object_index * @ingroup object_index

38
programs/light_client/qml/main.qml
View file

@ -38,13 +38,41 @@ ApplicationWindow {
id: appSettings id: appSettings
category: "appSettings" category: "appSettings"
} }
Connections {
target: app
onExceptionThrown: console.log("Exception from app: " + message)
}
Button { Column {
text: "Transfer"
anchors.centerIn: parent anchors.centerIn: parent
onClicked: formBox.showForm(Qt.createComponent("TransferForm.qml"), function() { Button {
console.log("Closed form") text: "Transfer"
}) onClicked: formBox.showForm(Qt.createComponent("TransferForm.qml"), function() {
console.log("Closed form")
})
}
TextField {
id: nameField
onAccepted: lookupButton.clicked()
focus: true
}
Button {
id: lookupButton
text: "Lookup"
onClicked: {
var acct = app.model.getAccount(nameField.text)
// @disable-check M126
if (acct == null)
console.log("Got back null account")
else if (acct.id >= 0)
console.log(JSON.stringify(acct))
else
console.log("Waiting for result...")
acct.idChanged.connect(function(loadedAcct) {
console.log(JSON.stringify(loadedAcct))
})
}
}
} }
FormBox { FormBox {

4
tests/app/main.cpp
View file

@ -68,7 +68,7 @@ BOOST_AUTO_TEST_CASE( two_node_network )
ilog("Connected!"); ilog("Connected!");
fc::ecc::private_key nathan_key = fc::ecc::private_key::generate(); fc::ecc::private_key nathan_key = fc::ecc::private_key::generate();
fc::ecc::private_key genesis_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("nathan"))); fc::ecc::private_key committee_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("nathan")));
graphene::chain::signed_transaction trx; graphene::chain::signed_transaction trx;
trx.set_expiration(now + fc::seconds(30)); trx.set_expiration(now + fc::seconds(30));
std::shared_ptr<chain::database> db2 = app2.chain_database(); std::shared_ptr<chain::database> db2 = app2.chain_database();
@ -89,7 +89,7 @@ BOOST_AUTO_TEST_CASE( two_node_network )
now += GRAPHENE_DEFAULT_BLOCK_INTERVAL; now += GRAPHENE_DEFAULT_BLOCK_INTERVAL;
app2.p2p_node()->broadcast(graphene::net::block_message(db2->generate_block(now, app2.p2p_node()->broadcast(graphene::net::block_message(db2->generate_block(now,
db2->get_scheduled_witness(1).first, db2->get_scheduled_witness(1).first,
genesis_key, committee_key,
database::skip_nothing))); database::skip_nothing)));
fc::usleep(fc::milliseconds(500)); fc::usleep(fc::milliseconds(500));

6
tests/benchmarks/genesis_allocation.cpp
View file

@ -83,9 +83,9 @@ BOOST_AUTO_TEST_CASE( genesis_and_persistence_bench )
BOOST_CHECK(db.get_balance(account_id_type(i), asset_id_type()).amount == GRAPHENE_MAX_SHARE_SUPPLY / account_count); BOOST_CHECK(db.get_balance(account_id_type(i), asset_id_type()).amount == GRAPHENE_MAX_SHARE_SUPPLY / account_count);
int blocks_out = 0; int blocks_out = 0;
auto delegate_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")) ); auto witness_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")) );
auto aw = db.get_global_properties().active_witnesses; auto aw = db.get_global_properties().active_witnesses;
auto b = db.generate_block( db.get_slot_time( 1 ), db.get_scheduled_witness( 1 ).first, delegate_priv_key, ~0 ); auto b = db.generate_block( db.get_slot_time( 1 ), db.get_scheduled_witness( 1 ).first, witness_priv_key, ~0 );
start_time = fc::time_point::now(); start_time = fc::time_point::now();
/* TODO: get this buliding again /* TODO: get this buliding again
@ -96,7 +96,7 @@ BOOST_AUTO_TEST_CASE( genesis_and_persistence_bench )
db.push_transaction(trx, ~0); db.push_transaction(trx, ~0);
aw = db.get_global_properties().active_witnesses; aw = db.get_global_properties().active_witnesses;
b = db.generate_block( db.get_slot_time( 1 ), db.get_scheduled_witness( 1 ).first, delegate_priv_key, ~0 ); b = db.generate_block( db.get_slot_time( 1 ), db.get_scheduled_witness( 1 ).first, witness_priv_key, ~0 );
} }
*/ */
ilog("Pushed ${c} blocks (1 op each, no validation) in ${t} milliseconds.", ilog("Pushed ${c} blocks (1 op each, no validation) in ${t} milliseconds.",

52
tests/common/database_fixture.cpp
View file

@ -25,7 +25,7 @@
#include <graphene/chain/account_object.hpp> #include <graphene/chain/account_object.hpp>
#include <graphene/chain/asset_object.hpp> #include <graphene/chain/asset_object.hpp>
#include <graphene/chain/delegate_object.hpp> #include <graphene/chain/committee_member_object.hpp>
#include <graphene/chain/market_evaluator.hpp> #include <graphene/chain/market_evaluator.hpp>
#include <graphene/chain/vesting_balance_object.hpp> #include <graphene/chain/vesting_balance_object.hpp>
#include <graphene/chain/witness_object.hpp> #include <graphene/chain/witness_object.hpp>
@ -62,7 +62,7 @@ database_fixture::database_fixture()
} }
auto ahplugin = app.register_plugin<graphene::account_history::account_history_plugin>(); auto ahplugin = app.register_plugin<graphene::account_history::account_history_plugin>();
auto mhplugin = app.register_plugin<graphene::market_history::market_history_plugin>(); auto mhplugin = app.register_plugin<graphene::market_history::market_history_plugin>();
delegate_pub_key = delegate_priv_key.get_public_key(); init_account_pub_key = init_account_priv_key.get_public_key();
boost::program_options::variables_map options; boost::program_options::variables_map options;
@ -79,11 +79,11 @@ database_fixture::database_fixture()
{ {
auto name = "init"+fc::to_string(i); auto name = "init"+fc::to_string(i);
genesis_state.initial_accounts.emplace_back(name, genesis_state.initial_accounts.emplace_back(name,
delegate_priv_key.get_public_key(), init_account_priv_key.get_public_key(),
delegate_priv_key.get_public_key(), init_account_priv_key.get_public_key(),
true); true);
genesis_state.initial_committee_candidates.push_back({name}); genesis_state.initial_committee_candidates.push_back({name});
genesis_state.initial_witness_candidates.push_back({name, delegate_priv_key.get_public_key()}); genesis_state.initial_witness_candidates.push_back({name, init_account_priv_key.get_public_key()});
} }
genesis_state.initial_parameters.current_fees->zero_all_fees(); genesis_state.initial_parameters.current_fees->zero_all_fees();
db.init_genesis(genesis_state); db.init_genesis(genesis_state);
@ -120,9 +120,9 @@ database_fixture::~database_fixture()
fc::ecc::private_key database_fixture::generate_private_key(string seed) fc::ecc::private_key database_fixture::generate_private_key(string seed)
{ {
static const fc::ecc::private_key genesis = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key"))); static const fc::ecc::private_key committee = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")));
if( seed == "null_key" ) if( seed == "null_key" )
return genesis; return committee;
return fc::ecc::private_key::regenerate(fc::sha256::hash(seed)); return fc::ecc::private_key::regenerate(fc::sha256::hash(seed));
} }
@ -315,7 +315,7 @@ void database_fixture::generate_blocks(fc::time_point_sec timestamp, bool miss_i
generate_block(); generate_block();
auto slots_to_miss = db.get_slot_at_time(timestamp) - 1; auto slots_to_miss = db.get_slot_at_time(timestamp) - 1;
if( slots_to_miss <= 0 ) return; if( slots_to_miss <= 0 ) return;
generate_block(~0, delegate_priv_key, slots_to_miss); generate_block(~0, init_account_priv_key, slots_to_miss);
return; return;
} }
while( db.head_block_time() < timestamp ) while( db.head_block_time() < timestamp )
@ -335,15 +335,15 @@ account_create_operation database_fixture::make_account(
create_account.active = authority(321, key, 321); create_account.active = authority(321, key, 321);
create_account.options.memo_key = key; create_account.options.memo_key = key;
auto& active_delegates = db.get_global_properties().active_delegates; auto& active_committee_members = db.get_global_properties().active_committee_members;
if( active_delegates.size() > 0 ) if( active_committee_members.size() > 0 )
{ {
set<vote_id_type> votes; set<vote_id_type> votes;
votes.insert(active_delegates[rand() % active_delegates.size()](db).vote_id); votes.insert(active_committee_members[rand() % active_committee_members.size()](db).vote_id);
votes.insert(active_delegates[rand() % active_delegates.size()](db).vote_id); votes.insert(active_committee_members[rand() % active_committee_members.size()](db).vote_id);
votes.insert(active_delegates[rand() % active_delegates.size()](db).vote_id); votes.insert(active_committee_members[rand() % active_committee_members.size()](db).vote_id);
votes.insert(active_delegates[rand() % active_delegates.size()](db).vote_id); votes.insert(active_committee_members[rand() % active_committee_members.size()](db).vote_id);
votes.insert(active_delegates[rand() % active_delegates.size()](db).vote_id); votes.insert(active_committee_members[rand() % active_committee_members.size()](db).vote_id);
create_account.options.votes = flat_set<vote_id_type>(votes.begin(), votes.end()); create_account.options.votes = flat_set<vote_id_type>(votes.begin(), votes.end());
} }
create_account.options.num_committee = create_account.options.votes.size(); create_account.options.num_committee = create_account.options.votes.size();
@ -373,15 +373,15 @@ account_create_operation database_fixture::make_account(
create_account.active = authority(321, key, 321); create_account.active = authority(321, key, 321);
create_account.options.memo_key = key; create_account.options.memo_key = key;
const vector<delegate_id_type>& active_delegates = db.get_global_properties().active_delegates; const vector<committee_member_id_type>& active_committee_members = db.get_global_properties().active_committee_members;
if( active_delegates.size() > 0 ) if( active_committee_members.size() > 0 )
{ {
set<vote_id_type> votes; set<vote_id_type> votes;
votes.insert(active_delegates[rand() % active_delegates.size()](db).vote_id); votes.insert(active_committee_members[rand() % active_committee_members.size()](db).vote_id);
votes.insert(active_delegates[rand() % active_delegates.size()](db).vote_id); votes.insert(active_committee_members[rand() % active_committee_members.size()](db).vote_id);
votes.insert(active_delegates[rand() % active_delegates.size()](db).vote_id); votes.insert(active_committee_members[rand() % active_committee_members.size()](db).vote_id);
votes.insert(active_delegates[rand() % active_delegates.size()](db).vote_id); votes.insert(active_committee_members[rand() % active_committee_members.size()](db).vote_id);
votes.insert(active_delegates[rand() % active_delegates.size()](db).vote_id); votes.insert(active_committee_members[rand() % active_committee_members.size()](db).vote_id);
create_account.options.votes = flat_set<vote_id_type>(votes.begin(), votes.end()); create_account.options.votes = flat_set<vote_id_type>(votes.begin(), votes.end());
} }
create_account.options.num_committee = create_account.options.votes.size(); create_account.options.num_committee = create_account.options.votes.size();
@ -568,15 +568,15 @@ const account_object& database_fixture::create_account(
FC_CAPTURE_AND_RETHROW( (name)(registrar_id)(referrer_id) ) FC_CAPTURE_AND_RETHROW( (name)(registrar_id)(referrer_id) )
} }
const delegate_object& database_fixture::create_delegate( const account_object& owner ) const committee_member_object& database_fixture::create_committee_member( const account_object& owner )
{ {
delegate_create_operation op; committee_member_create_operation op;
op.delegate_account = owner.id; op.committee_member_account = owner.id;
trx.operations.push_back(op); trx.operations.push_back(op);
trx.validate(); trx.validate();
processed_transaction ptx = db.push_transaction(trx, ~0); processed_transaction ptx = db.push_transaction(trx, ~0);
trx.operations.clear(); trx.operations.clear();
return db.get<delegate_object>(ptx.operation_results[0].get<object_id_type>()); return db.get<committee_member_object>(ptx.operation_results[0].get<object_id_type>());
} }
const witness_object&database_fixture::create_witness(account_id_type owner, const fc::ecc::private_key& signing_private_key) const witness_object&database_fixture::create_witness(account_id_type owner, const fc::ecc::private_key& signing_private_key)

10
tests/common/database_fixture.hpp
View file

@ -141,11 +141,11 @@ struct database_fixture {
genesis_state_type genesis_state; genesis_state_type genesis_state;
chain::database &db; chain::database &db;
signed_transaction trx; signed_transaction trx;
public_key_type genesis_key; public_key_type committee_key;
account_id_type genesis_account; account_id_type committee_account;
fc::ecc::private_key private_key = fc::ecc::private_key::generate(); fc::ecc::private_key private_key = fc::ecc::private_key::generate();
fc::ecc::private_key delegate_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")) ); fc::ecc::private_key init_account_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")) );
public_key_type delegate_pub_key; public_key_type init_account_pub_key;
optional<fc::temp_directory> data_dir; optional<fc::temp_directory> data_dir;
bool skip_key_index_test = false; bool skip_key_index_test = false;
@ -243,7 +243,7 @@ struct database_fixture {
uint8_t referrer_percent = 100 uint8_t referrer_percent = 100
); );
const delegate_object& create_delegate( const account_object& owner ); const committee_member_object& create_committee_member( const account_object& owner );
const witness_object& create_witness(account_id_type owner, const witness_object& create_witness(account_id_type owner,
const fc::ecc::private_key& signing_private_key = generate_private_key("null_key")); const fc::ecc::private_key& signing_private_key = generate_private_key("null_key"));
const witness_object& create_witness(const account_object& owner, const witness_object& create_witness(const account_object& owner,

40
tests/intense/block_tests.cpp
View file

@ -43,13 +43,13 @@ BOOST_FIXTURE_TEST_CASE( update_account_keys, database_fixture )
const asset_object& core = asset_id_type()(db); const asset_object& core = asset_id_type()(db);
uint32_t skip_flags = uint32_t skip_flags =
database::skip_transaction_dupe_check database::skip_transaction_dupe_check
| database::skip_delegate_signature | database::skip_witness_signature
| database::skip_transaction_signatures | database::skip_transaction_signatures
| database::skip_authority_check | database::skip_authority_check
; ;
// Sam is the creator of accounts // Sam is the creator of accounts
private_key_type genesis_key = delegate_priv_key; private_key_type committee_key = init_account_priv_key;
private_key_type sam_key = generate_private_key("sam"); private_key_type sam_key = generate_private_key("sam");
// //
@ -78,9 +78,9 @@ BOOST_FIXTURE_TEST_CASE( update_account_keys, database_fixture )
transaction tx; transaction tx;
processed_transaction ptx; processed_transaction ptx;
account_object genesis_account_object = genesis_account(db); account_object committee_account_object = committee_account(db);
// transfer from genesis account to Sam account // transfer from committee account to Sam account
transfer(genesis_account_object, sam_account_object, core.amount(100000)); transfer(committee_account_object, sam_account_object, core.amount(100000));
const int num_keys = 5; const int num_keys = 5;
vector< private_key_type > numbered_private_keys; vector< private_key_type > numbered_private_keys;
@ -239,14 +239,14 @@ BOOST_FIXTURE_TEST_CASE( update_account_keys, database_fixture )
/** /**
* To have a secure random number we need to ensure that the same * To have a secure random number we need to ensure that the same
* delegate does not get to produce two blocks in a row. There is * witness does not get to produce two blocks in a row. There is
* always a chance that the last delegate of one round will be the * always a chance that the last witness of one round will be the
* first delegate of the next round. * first witness of the next round.
* *
* This means that when we shuffle delegates we need to make sure * This means that when we shuffle witness we need to make sure
* that there is at least N/2 delegates between consecutive turns * that there is at least N/2 witness between consecutive turns
* of the same delegate. This means that durring the random * of the same witness. This means that durring the random
* shuffle we need to restrict the placement of delegates to maintain * shuffle we need to restrict the placement of witness to maintain
* this invariant. * this invariant.
* *
* This test checks the requirement using Monte Carlo approach * This test checks the requirement using Monte Carlo approach
@ -316,14 +316,14 @@ BOOST_FIXTURE_TEST_CASE( witness_order_mc_test, database_fixture )
/** /**
* To have a secure random number we need to ensure that the same * To have a secure random number we need to ensure that the same
* delegate does not get to produce two blocks in a row. There is * witness does not get to produce two blocks in a row. There is
* always a chance that the last delegate of one round will be the * always a chance that the last witness of one round will be the
* first delegate of the next round. * first witness of the next round.
* *
* This means that when we shuffle delegates we need to make sure * This means that when we shuffle witness we need to make sure
* that there is at least N/2 delegates between consecutive turns * that there is at least N/2 witness between consecutive turns
* of the same delegate. This means that durring the random * of the same witness. This means that durring the random
* shuffle we need to restrict the placement of delegates to maintain * shuffle we need to restrict the placement of witness to maintain
* this invariant. * this invariant.
* *
* This test checks the requirement using Monte Carlo approach * This test checks the requirement using Monte Carlo approach
@ -410,7 +410,7 @@ BOOST_FIXTURE_TEST_CASE( tapos_rollover, database_fixture )
const auto& core = asset_id_type()(db); const auto& core = asset_id_type()(db);
BOOST_TEST_MESSAGE( "Give Alice some money" ); BOOST_TEST_MESSAGE( "Give Alice some money" );
transfer(genesis_account, alice_id, asset(10000)); transfer(committee_account, alice_id, asset(10000));
generate_block(); generate_block();
BOOST_TEST_MESSAGE( "Generate up to block 0xFF00" ); BOOST_TEST_MESSAGE( "Generate up to block 0xFF00" );

5
tests/performance/performance_tests.cpp
View file

@ -5,7 +5,6 @@
#include <graphene/chain/account_object.hpp> #include <graphene/chain/account_object.hpp>
#include <graphene/chain/asset_object.hpp> #include <graphene/chain/asset_object.hpp>
#include <graphene/chain/delegate_object.hpp>
#include <graphene/chain/proposal_object.hpp> #include <graphene/chain/proposal_object.hpp>
#include <graphene/db/simple_index.hpp> #include <graphene/db/simple_index.hpp>
@ -34,12 +33,12 @@ BOOST_AUTO_TEST_CASE( transfer_benchmark )
{ {
fc::ecc::private_key nathan_key = fc::ecc::private_key::generate(); fc::ecc::private_key nathan_key = fc::ecc::private_key::generate();
const key_object& key = register_key(nathan_key.get_public_key()); const key_object& key = register_key(nathan_key.get_public_key());
const auto& genesis = account_id_type()(db); const auto& committee_account = account_id_type()(db);
auto start = fc::time_point::now(); auto start = fc::time_point::now();
for( uint32_t i = 0; i < 1000*1000; ++i ) for( uint32_t i = 0; i < 1000*1000; ++i )
{ {
const auto& a = create_account("a"+fc::to_string(i), key.id); const auto& a = create_account("a"+fc::to_string(i), key.id);
transfer( genesis, a, asset(1000) ); transfer( committee_account, a, asset(1000) );
} }
auto end = fc::time_point::now(); auto end = fc::time_point::now();
auto elapsed = end - start; auto elapsed = end - start;

98
tests/tests/authority_tests.cpp
View file

@ -24,7 +24,7 @@
#include <graphene/chain/account_object.hpp> #include <graphene/chain/account_object.hpp>
#include <graphene/chain/asset_object.hpp> #include <graphene/chain/asset_object.hpp>
#include <graphene/chain/delegate_object.hpp> #include <graphene/chain/committee_member_object.hpp>
#include <graphene/chain/proposal_object.hpp> #include <graphene/chain/proposal_object.hpp>
#include <graphene/db/simple_index.hpp> #include <graphene/db/simple_index.hpp>
@ -238,7 +238,7 @@ BOOST_AUTO_TEST_CASE( recursive_accounts )
BOOST_CHECK_EQUAL(get_balance(child, core), old_balance - 2000); BOOST_CHECK_EQUAL(get_balance(child, core), old_balance - 2000);
trx.clear(); trx.clear();
BOOST_TEST_MESSAGE( "Update grandparent account authority to be genesis account" ); BOOST_TEST_MESSAGE( "Update grandparent account authority to be committee account" );
{ {
account_update_operation op; account_update_operation op;
op.account = grandparent.id; op.account = grandparent.id;
@ -254,7 +254,7 @@ BOOST_AUTO_TEST_CASE( recursive_accounts )
trx.operations.push_back(op); trx.operations.push_back(op);
sign(trx, parent2_key); sign(trx, parent2_key);
sign(trx, grandparent_key); sign(trx, grandparent_key);
sign(trx, delegate_priv_key); sign(trx, init_account_priv_key);
//Fails due to recursion depth. //Fails due to recursion depth.
GRAPHENE_CHECK_THROW(PUSH_TX( db, trx, database::skip_transaction_dupe_check ), fc::exception); GRAPHENE_CHECK_THROW(PUSH_TX( db, trx, database::skip_transaction_dupe_check ), fc::exception);
BOOST_TEST_MESSAGE( "verify child key can override recursion checks" ); BOOST_TEST_MESSAGE( "verify child key can override recursion checks" );
@ -293,12 +293,12 @@ BOOST_AUTO_TEST_CASE( proposed_single_account )
try { try {
INVOKE(any_two_of_three); INVOKE(any_two_of_three);
fc::ecc::private_key genesis_key = delegate_priv_key; fc::ecc::private_key committee_key = init_account_priv_key;
fc::ecc::private_key nathan_key1 = fc::ecc::private_key::regenerate(fc::digest("key1")); fc::ecc::private_key nathan_key1 = fc::ecc::private_key::regenerate(fc::digest("key1"));
fc::ecc::private_key nathan_key2 = fc::ecc::private_key::regenerate(fc::digest("key2")); fc::ecc::private_key nathan_key2 = fc::ecc::private_key::regenerate(fc::digest("key2"));
fc::ecc::private_key nathan_key3 = fc::ecc::private_key::regenerate(fc::digest("key3")); fc::ecc::private_key nathan_key3 = fc::ecc::private_key::regenerate(fc::digest("key3"));
const account_object& moneyman = create_account("moneyman", delegate_pub_key); const account_object& moneyman = create_account("moneyman", init_account_pub_key);
const account_object& nathan = get_account("nathan"); const account_object& nathan = get_account("nathan");
const asset_object& core = asset_id_type()(db); const asset_object& core = asset_id_type()(db);
@ -340,7 +340,7 @@ BOOST_AUTO_TEST_CASE( proposed_single_account )
trx.set_expiration(db.head_block_id()); trx.set_expiration(db.head_block_id());
//idump((moneyman)); //idump((moneyman));
trx.sign( delegate_priv_key ); trx.sign( init_account_priv_key );
const proposal_object& proposal = db.get<proposal_object>(PUSH_TX( db, trx ).operation_results.front().get<object_id_type>()); const proposal_object& proposal = db.get<proposal_object>(PUSH_TX( db, trx ).operation_results.front().get<object_id_type>());
BOOST_CHECK_EQUAL(proposal.required_active_approvals.size(), 1); BOOST_CHECK_EQUAL(proposal.required_active_approvals.size(), 1);
@ -355,14 +355,14 @@ BOOST_AUTO_TEST_CASE( proposed_single_account )
pup.active_approvals_to_add.insert(nathan.id); pup.active_approvals_to_add.insert(nathan.id);
trx.operations = {pup}; trx.operations = {pup};
trx.sign( genesis_key ); trx.sign( committee_key );
//Genesis may not add nathan's approval. //committee may not add nathan's approval.
GRAPHENE_CHECK_THROW(PUSH_TX( db, trx ), fc::exception); GRAPHENE_CHECK_THROW(PUSH_TX( db, trx ), fc::exception);
pup.active_approvals_to_add.clear(); pup.active_approvals_to_add.clear();
pup.active_approvals_to_add.insert(account_id_type()); pup.active_approvals_to_add.insert(account_id_type());
trx.operations = {pup}; trx.operations = {pup};
trx.sign( genesis_key ); trx.sign( committee_key );
//Genesis has no stake in the transaction. //committee has no stake in the transaction.
GRAPHENE_CHECK_THROW(PUSH_TX( db, trx ), fc::exception); GRAPHENE_CHECK_THROW(PUSH_TX( db, trx ), fc::exception);
trx.signatures.clear(); trx.signatures.clear();
@ -382,11 +382,11 @@ BOOST_AUTO_TEST_CASE( proposed_single_account )
} }
} }
/// Verify that genesis authority cannot be invoked in a normal transaction /// Verify that committee authority cannot be invoked in a normal transaction
BOOST_AUTO_TEST_CASE( genesis_authority ) BOOST_AUTO_TEST_CASE( committee_authority )
{ try { { try {
fc::ecc::private_key nathan_key = fc::ecc::private_key::generate(); fc::ecc::private_key nathan_key = fc::ecc::private_key::generate();
fc::ecc::private_key genesis_key = delegate_priv_key; fc::ecc::private_key committee_key = init_account_priv_key;
const account_object nathan = create_account("nathan", nathan_key.get_public_key()); const account_object nathan = create_account("nathan", nathan_key.get_public_key());
const auto& global_params = db.get_global_properties().parameters; const auto& global_params = db.get_global_properties().parameters;
@ -398,12 +398,12 @@ BOOST_AUTO_TEST_CASE( genesis_authority )
p.parameters.committee_proposal_review_period = fc::days(1).to_seconds(); p.parameters.committee_proposal_review_period = fc::days(1).to_seconds();
}); });
BOOST_TEST_MESSAGE( "transfering 100000 CORE to nathan, signing with genesis key" ); BOOST_TEST_MESSAGE( "transfering 100000 CORE to nathan, signing with committee key" );
transfer_operation top; transfer_operation top;
top.to = nathan.id; top.to = nathan.id;
top.amount = asset(100000); top.amount = asset(100000);
trx.operations.push_back(top); trx.operations.push_back(top);
sign(trx, genesis_key); sign(trx, committee_key);
GRAPHENE_CHECK_THROW(PUSH_TX( db, trx ), fc::exception); GRAPHENE_CHECK_THROW(PUSH_TX( db, trx ), fc::exception);
auto sign = [&] { trx.signatures.clear(); trx.sign(nathan_key); }; auto sign = [&] { trx.signatures.clear(); trx.sign(nathan_key); };
@ -446,7 +446,7 @@ BOOST_AUTO_TEST_CASE( genesis_authority )
uop.fee_paying_account = GRAPHENE_TEMP_ACCOUNT; uop.fee_paying_account = GRAPHENE_TEMP_ACCOUNT;
uop.proposal = prop.id; uop.proposal = prop.id;
uop.key_approvals_to_add.emplace(genesis_key.get_public_key()); uop.key_approvals_to_add.emplace(committee_key.get_public_key());
/* /*
uop.key_approvals_to_add.emplace(1); uop.key_approvals_to_add.emplace(1);
uop.key_approvals_to_add.emplace(2); uop.key_approvals_to_add.emplace(2);
@ -456,16 +456,16 @@ BOOST_AUTO_TEST_CASE( genesis_authority )
uop.key_approvals_to_add.emplace(6); uop.key_approvals_to_add.emplace(6);
*/ */
trx.operations.push_back(uop); trx.operations.push_back(uop);
trx.sign(genesis_key); trx.sign(committee_key);
db.push_transaction(trx); db.push_transaction(trx);
BOOST_CHECK_EQUAL(get_balance(nathan, asset_id_type()(db)), 0); BOOST_CHECK_EQUAL(get_balance(nathan, asset_id_type()(db)), 0);
BOOST_CHECK(db.get<proposal_object>(prop.id).is_authorized_to_execute(db)); BOOST_CHECK(db.get<proposal_object>(prop.id).is_authorized_to_execute(db));
generate_blocks(*prop.review_period_time); generate_blocks(*prop.review_period_time);
uop.key_approvals_to_add.clear(); uop.key_approvals_to_add.clear();
uop.key_approvals_to_add.insert(genesis_key.get_public_key()); // was 7 uop.key_approvals_to_add.insert(committee_key.get_public_key()); // was 7
trx.operations.back() = uop; trx.operations.back() = uop;
trx.sign( genesis_key); trx.sign( committee_key);
// Should throw because the transaction is now in review. // Should throw because the transaction is now in review.
GRAPHENE_CHECK_THROW(PUSH_TX( db, trx ), fc::exception); GRAPHENE_CHECK_THROW(PUSH_TX( db, trx ), fc::exception);
@ -473,18 +473,18 @@ BOOST_AUTO_TEST_CASE( genesis_authority )
BOOST_CHECK_EQUAL(get_balance(nathan, asset_id_type()(db)), 100000); BOOST_CHECK_EQUAL(get_balance(nathan, asset_id_type()(db)), 100000);
} FC_LOG_AND_RETHROW() } } FC_LOG_AND_RETHROW() }
BOOST_FIXTURE_TEST_CASE( fired_delegates, database_fixture ) BOOST_FIXTURE_TEST_CASE( fired_committee_members, database_fixture )
{ try { { try {
generate_block(); generate_block();
fc::ecc::private_key genesis_key = delegate_priv_key; fc::ecc::private_key committee_key = init_account_priv_key;
fc::ecc::private_key delegate_key = fc::ecc::private_key::generate(); fc::ecc::private_key committee_member_key = fc::ecc::private_key::generate();
//Meet nathan. He has a little money. //Meet nathan. He has a little money.
const account_object* nathan = &create_account("nathan"); const account_object* nathan = &create_account("nathan");
transfer(account_id_type()(db), *nathan, asset(5000)); transfer(account_id_type()(db), *nathan, asset(5000));
generate_block(); generate_block();
nathan = &get_account("nathan"); nathan = &get_account("nathan");
flat_set<vote_id_type> delegates; flat_set<vote_id_type> committee_members;
db.modify(db.get_global_properties(), [](global_property_object& p) { db.modify(db.get_global_properties(), [](global_property_object& p) {
// Turn the review period WAY down, so it doesn't take long to produce blocks to that point in simulated time. // Turn the review period WAY down, so it doesn't take long to produce blocks to that point in simulated time.
@ -493,13 +493,13 @@ BOOST_FIXTURE_TEST_CASE( fired_delegates, database_fixture )
for( int i = 0; i < 15; ++i ) for( int i = 0; i < 15; ++i )
{ {
const auto& account = create_account("delegate" + fc::to_string(i+1), delegate_key.get_public_key()); const auto& account = create_account("committee-member" + fc::to_string(i+1), committee_member_key.get_public_key());
upgrade_to_lifetime_member(account); upgrade_to_lifetime_member(account);
delegates.insert(create_delegate(account).vote_id); committee_members.insert(create_committee_member(account).vote_id);
} }
//A proposal is created to give nathan lots more money. //A proposal is created to give nathan lots more money.
proposal_create_operation pop = proposal_create_operation::genesis_proposal(db.get_global_properties().parameters, db.head_block_time()); proposal_create_operation pop = proposal_create_operation::committee_proposal(db.get_global_properties().parameters, db.head_block_time());
pop.fee_paying_account = GRAPHENE_TEMP_ACCOUNT; pop.fee_paying_account = GRAPHENE_TEMP_ACCOUNT;
pop.expiration_time = db.head_block_time() + *pop.review_period_seconds * 3; pop.expiration_time = db.head_block_time() + *pop.review_period_seconds * 3;
@ -512,11 +512,11 @@ BOOST_FIXTURE_TEST_CASE( fired_delegates, database_fixture )
proposal_id_type pid = prop.id; proposal_id_type pid = prop.id;
BOOST_CHECK(!pid(db).is_authorized_to_execute(db)); BOOST_CHECK(!pid(db).is_authorized_to_execute(db));
//Genesis key approves of the proposal. //committee key approves of the proposal.
proposal_update_operation uop; proposal_update_operation uop;
uop.fee_paying_account = GRAPHENE_TEMP_ACCOUNT; uop.fee_paying_account = GRAPHENE_TEMP_ACCOUNT;
uop.proposal = pid; uop.proposal = pid;
uop.key_approvals_to_add.emplace(delegate_pub_key); uop.key_approvals_to_add.emplace(init_account_pub_key);
/* TODO: what should this really be? /* TODO: what should this really be?
uop.key_approvals_to_add.emplace(2); uop.key_approvals_to_add.emplace(2);
uop.key_approvals_to_add.emplace(3); uop.key_approvals_to_add.emplace(3);
@ -528,7 +528,7 @@ BOOST_FIXTURE_TEST_CASE( fired_delegates, database_fixture )
uop.key_approvals_to_add.emplace(9); uop.key_approvals_to_add.emplace(9);
*/ */
trx.operations.back() = uop; trx.operations.back() = uop;
trx.sign(genesis_key); trx.sign(committee_key);
PUSH_TX( db, trx ); PUSH_TX( db, trx );
BOOST_CHECK(pid(db).is_authorized_to_execute(db)); BOOST_CHECK(pid(db).is_authorized_to_execute(db));
@ -545,11 +545,11 @@ BOOST_FIXTURE_TEST_CASE( fired_delegates, database_fixture )
BOOST_CHECK_EQUAL(get_balance(*nathan, asset_id_type()(db)), 5000); BOOST_CHECK_EQUAL(get_balance(*nathan, asset_id_type()(db)), 5000);
{ {
//Oh noes! Nathan votes for a whole new slate of delegates! //Oh noes! Nathan votes for a whole new slate of committee_members!
account_update_operation op; account_update_operation op;
op.account = nathan->id; op.account = nathan->id;
op.new_options = nathan->options; op.new_options = nathan->options;
op.new_options->votes = delegates; op.new_options->votes = committee_members;
trx.operations.push_back(op); trx.operations.push_back(op);
trx.set_expiration(db.head_block_time() + GRAPHENE_DEFAULT_MAX_TIME_UNTIL_EXPIRATION); trx.set_expiration(db.head_block_time() + GRAPHENE_DEFAULT_MAX_TIME_UNTIL_EXPIRATION);
PUSH_TX( db, trx, ~0 ); PUSH_TX( db, trx, ~0 );
@ -558,9 +558,9 @@ BOOST_FIXTURE_TEST_CASE( fired_delegates, database_fixture )
// still no money // still no money
BOOST_CHECK_EQUAL(get_balance(*nathan, asset_id_type()(db)), 5000); BOOST_CHECK_EQUAL(get_balance(*nathan, asset_id_type()(db)), 5000);
//Time passes... the set of active delegates gets updated. //Time passes... the set of active committee_members gets updated.
generate_blocks(maintenance_time); generate_blocks(maintenance_time);
//The proposal is no longer authorized, because the active delegates got changed. //The proposal is no longer authorized, because the active committee_members got changed.
BOOST_CHECK(!pid(db).is_authorized_to_execute(db)); BOOST_CHECK(!pid(db).is_authorized_to_execute(db));
// still no money // still no money
BOOST_CHECK_EQUAL(get_balance(*nathan, asset_id_type()(db)), 5000); BOOST_CHECK_EQUAL(get_balance(*nathan, asset_id_type()(db)), 5000);
@ -882,17 +882,17 @@ BOOST_FIXTURE_TEST_CASE( max_authority_membership, database_fixture )
transaction tx; transaction tx;
processed_transaction ptx; processed_transaction ptx;
private_key_type genesis_key = delegate_priv_key; private_key_type committee_key = init_account_priv_key;
// Sam is the creator of accounts // Sam is the creator of accounts
private_key_type sam_key = generate_private_key("sam"); private_key_type sam_key = generate_private_key("sam");
account_object sam_account_object = create_account( "sam", sam_key ); account_object sam_account_object = create_account( "sam", sam_key );
upgrade_to_lifetime_member(sam_account_object); upgrade_to_lifetime_member(sam_account_object);
account_object genesis_account_object = genesis_account(db); account_object committee_account_object = committee_account(db);
const asset_object& core = asset_id_type()(db); const asset_object& core = asset_id_type()(db);
transfer(genesis_account_object, sam_account_object, core.amount(100000)); transfer(committee_account_object, sam_account_object, core.amount(100000));
// have Sam create some keys // have Sam create some keys
@ -968,13 +968,13 @@ BOOST_FIXTURE_TEST_CASE( bogus_signature, database_fixture )
{ {
try try
{ {
private_key_type genesis_key = delegate_priv_key; private_key_type committee_key = init_account_priv_key;
// Sam is the creator of accounts // Sam is the creator of accounts
private_key_type alice_key = generate_private_key("alice"); private_key_type alice_key = generate_private_key("alice");
private_key_type bob_key = generate_private_key("bob"); private_key_type bob_key = generate_private_key("bob");
private_key_type charlie_key = generate_private_key("charlie"); private_key_type charlie_key = generate_private_key("charlie");
account_object genesis_account_object = genesis_account(db); account_object committee_account_object = committee_account(db);
account_object alice_account_object = create_account( "alice", alice_key ); account_object alice_account_object = create_account( "alice", alice_key );
account_object bob_account_object = create_account( "bob", bob_key ); account_object bob_account_object = create_account( "bob", bob_key );
account_object charlie_account_object = create_account( "charlie", charlie_key ); account_object charlie_account_object = create_account( "charlie", charlie_key );
@ -987,7 +987,7 @@ BOOST_FIXTURE_TEST_CASE( bogus_signature, database_fixture )
// send from Sam -> Alice, signed by Sam // send from Sam -> Alice, signed by Sam
const asset_object& core = asset_id_type()(db); const asset_object& core = asset_id_type()(db);
transfer(genesis_account_object, alice_account_object, core.amount(100000)); transfer(committee_account_object, alice_account_object, core.amount(100000));
transfer_operation xfer_op; transfer_operation xfer_op;
xfer_op.from = alice_account_object.id; xfer_op.from = alice_account_object.id;
@ -1032,8 +1032,8 @@ BOOST_FIXTURE_TEST_CASE( voting_account, database_fixture )
ACTORS((nathan)(vikram)); ACTORS((nathan)(vikram));
upgrade_to_lifetime_member(nathan_id); upgrade_to_lifetime_member(nathan_id);
upgrade_to_lifetime_member(vikram_id); upgrade_to_lifetime_member(vikram_id);
delegate_id_type nathan_delegate = create_delegate(nathan_id(db)).id; committee_member_id_type nathan_committee_member = create_committee_member(nathan_id(db)).id;
delegate_id_type vikram_delegate = create_delegate(vikram_id(db)).id; committee_member_id_type vikram_committee_member = create_committee_member(vikram_id(db)).id;
//wdump((db.get_balance(account_id_type(), asset_id_type()))); //wdump((db.get_balance(account_id_type(), asset_id_type())));
generate_block(); generate_block();
@ -1047,7 +1047,7 @@ BOOST_FIXTURE_TEST_CASE( voting_account, database_fixture )
op.account = nathan_id; op.account = nathan_id;
op.new_options = nathan_id(db).options; op.new_options = nathan_id(db).options;
op.new_options->voting_account = vikram_id; op.new_options->voting_account = vikram_id;
op.new_options->votes = flat_set<vote_id_type>{nathan_delegate(db).vote_id}; op.new_options->votes = flat_set<vote_id_type>{nathan_committee_member(db).vote_id};
op.new_options->num_committee = 1; op.new_options->num_committee = 1;
trx.operations.push_back(op); trx.operations.push_back(op);
trx.sign(nathan_private_key); trx.sign(nathan_private_key);
@ -1058,7 +1058,7 @@ BOOST_FIXTURE_TEST_CASE( voting_account, database_fixture )
account_update_operation op; account_update_operation op;
op.account = vikram_id; op.account = vikram_id;
op.new_options = vikram_id(db).options; op.new_options = vikram_id(db).options;
op.new_options->votes.insert(vikram_delegate(db).vote_id); op.new_options->votes.insert(vikram_committee_member(db).vote_id);
op.new_options->num_committee = 11; op.new_options->num_committee = 11;
trx.operations.push_back(op); trx.operations.push_back(op);
trx.sign(vikram_private_key); trx.sign(vikram_private_key);
@ -1073,12 +1073,12 @@ BOOST_FIXTURE_TEST_CASE( voting_account, database_fixture )
} }
generate_blocks(db.get_dynamic_global_properties().next_maintenance_time + GRAPHENE_DEFAULT_BLOCK_INTERVAL); generate_blocks(db.get_dynamic_global_properties().next_maintenance_time + GRAPHENE_DEFAULT_BLOCK_INTERVAL);
BOOST_CHECK(std::find(db.get_global_properties().active_delegates.begin(), BOOST_CHECK(std::find(db.get_global_properties().active_committee_members.begin(),
db.get_global_properties().active_delegates.end(), db.get_global_properties().active_committee_members.end(),
nathan_delegate) == db.get_global_properties().active_delegates.end()); nathan_committee_member) == db.get_global_properties().active_committee_members.end());
BOOST_CHECK(std::find(db.get_global_properties().active_delegates.begin(), BOOST_CHECK(std::find(db.get_global_properties().active_committee_members.begin(),
db.get_global_properties().active_delegates.end(), db.get_global_properties().active_committee_members.end(),
vikram_delegate) != db.get_global_properties().active_delegates.end()); vikram_committee_member) != db.get_global_properties().active_committee_members.end());
} FC_LOG_AND_RETHROW() } } FC_LOG_AND_RETHROW() }
BOOST_AUTO_TEST_SUITE_END() BOOST_AUTO_TEST_SUITE_END()

1
tests/tests/basic_tests.cpp
View file

@ -23,7 +23,6 @@
#include <graphene/chain/account_object.hpp> #include <graphene/chain/account_object.hpp>
#include <graphene/chain/asset_object.hpp> #include <graphene/chain/asset_object.hpp>
#include <graphene/chain/delegate_object.hpp>
#include <graphene/chain/witness_scheduler_rng.hpp> #include <graphene/chain/witness_scheduler_rng.hpp>
#include <graphene/chain/exceptions.hpp> #include <graphene/chain/exceptions.hpp>

148
tests/tests/block_tests.cpp
View file

@ -21,7 +21,7 @@
#include <graphene/chain/database.hpp> #include <graphene/chain/database.hpp>
#include <graphene/chain/account_object.hpp> #include <graphene/chain/account_object.hpp>
#include <graphene/chain/delegate_object.hpp> #include <graphene/chain/committee_member_object.hpp>
#include <graphene/chain/proposal_object.hpp> #include <graphene/chain/proposal_object.hpp>
#include <graphene/chain/market_evaluator.hpp> #include <graphene/chain/market_evaluator.hpp>
#include <graphene/chain/witness_schedule_object.hpp> #include <graphene/chain/witness_schedule_object.hpp>
@ -39,17 +39,17 @@ genesis_state_type make_genesis() {
genesis_state.initial_timestamp = time_point_sec( GRAPHENE_TESTING_GENESIS_TIMESTAMP ); genesis_state.initial_timestamp = time_point_sec( GRAPHENE_TESTING_GENESIS_TIMESTAMP );
auto delegate_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key"))); auto init_account_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")));
genesis_state.initial_active_witnesses = 10; genesis_state.initial_active_witnesses = 10;
for( int i = 0; i < genesis_state.initial_active_witnesses; ++i ) for( int i = 0; i < genesis_state.initial_active_witnesses; ++i )
{ {
auto name = "init"+fc::to_string(i); auto name = "init"+fc::to_string(i);
genesis_state.initial_accounts.emplace_back(name, genesis_state.initial_accounts.emplace_back(name,
delegate_priv_key.get_public_key(), init_account_priv_key.get_public_key(),
delegate_priv_key.get_public_key(), init_account_priv_key.get_public_key(),
true); true);
genesis_state.initial_committee_candidates.push_back({name}); genesis_state.initial_committee_candidates.push_back({name});
genesis_state.initial_witness_candidates.push_back({name, delegate_priv_key.get_public_key()}); genesis_state.initial_witness_candidates.push_back({name, init_account_priv_key.get_public_key()});
} }
genesis_state.initial_parameters.current_fees->zero_all_fees(); genesis_state.initial_parameters.current_fees->zero_all_fees();
return genesis_state; return genesis_state;
@ -126,11 +126,11 @@ BOOST_AUTO_TEST_CASE( generate_empty_blocks )
now += GRAPHENE_DEFAULT_BLOCK_INTERVAL; now += GRAPHENE_DEFAULT_BLOCK_INTERVAL;
// TODO: Don't generate this here // TODO: Don't generate this here
auto delegate_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")) ); auto init_account_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")) );
{ {
database db; database db;
db.open(data_dir.path(), make_genesis ); db.open(data_dir.path(), make_genesis );
b = db.generate_block(now, db.get_scheduled_witness(1).first, delegate_priv_key, database::skip_nothing); b = db.generate_block(now, db.get_scheduled_witness(1).first, init_account_priv_key, database::skip_nothing);
for( uint32_t i = 1; i < 200; ++i ) for( uint32_t i = 1; i < 200; ++i )
{ {
@ -139,7 +139,7 @@ BOOST_AUTO_TEST_CASE( generate_empty_blocks )
now += db.block_interval(); now += db.block_interval();
witness_id_type cur_witness = db.get_scheduled_witness(1).first; witness_id_type cur_witness = db.get_scheduled_witness(1).first;
BOOST_CHECK( cur_witness != prev_witness ); BOOST_CHECK( cur_witness != prev_witness );
b = db.generate_block(now, cur_witness, delegate_priv_key, database::skip_nothing); b = db.generate_block(now, cur_witness, init_account_priv_key, database::skip_nothing);
BOOST_CHECK( b.witness == cur_witness ); BOOST_CHECK( b.witness == cur_witness );
} }
db.close(); db.close();
@ -155,7 +155,7 @@ BOOST_AUTO_TEST_CASE( generate_empty_blocks )
now += db.block_interval(); now += db.block_interval();
witness_id_type cur_witness = db.get_scheduled_witness(1).first; witness_id_type cur_witness = db.get_scheduled_witness(1).first;
BOOST_CHECK( cur_witness != prev_witness ); BOOST_CHECK( cur_witness != prev_witness );
b = db.generate_block(now, cur_witness, delegate_priv_key, database::skip_nothing); b = db.generate_block(now, cur_witness, init_account_priv_key, database::skip_nothing);
} }
BOOST_CHECK_EQUAL( db.head_block_num(), 400 ); BOOST_CHECK_EQUAL( db.head_block_num(), 400 );
} }
@ -174,11 +174,11 @@ BOOST_AUTO_TEST_CASE( undo_block )
db.open(data_dir.path(), make_genesis); db.open(data_dir.path(), make_genesis);
fc::time_point_sec now( GRAPHENE_TESTING_GENESIS_TIMESTAMP ); fc::time_point_sec now( GRAPHENE_TESTING_GENESIS_TIMESTAMP );
auto delegate_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")) ); auto init_account_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")) );
for( uint32_t i = 0; i < 5; ++i ) for( uint32_t i = 0; i < 5; ++i )
{ {
now += db.block_interval(); now += db.block_interval();
auto b = db.generate_block( now, db.get_scheduled_witness( 1 ).first, delegate_priv_key, database::skip_nothing ); auto b = db.generate_block( now, db.get_scheduled_witness( 1 ).first, init_account_priv_key, database::skip_nothing );
} }
BOOST_CHECK( db.head_block_num() == 5 ); BOOST_CHECK( db.head_block_num() == 5 );
db.pop_block(); db.pop_block();
@ -193,7 +193,7 @@ BOOST_AUTO_TEST_CASE( undo_block )
for( uint32_t i = 0; i < 5; ++i ) for( uint32_t i = 0; i < 5; ++i )
{ {
now += db.block_interval(); now += db.block_interval();
auto b = db.generate_block( now, db.get_scheduled_witness( 1 ).first, delegate_priv_key, database::skip_nothing ); auto b = db.generate_block( now, db.get_scheduled_witness( 1 ).first, init_account_priv_key, database::skip_nothing );
} }
BOOST_CHECK( db.head_block_num() == 7 ); BOOST_CHECK( db.head_block_num() == 7 );
} }
@ -215,11 +215,11 @@ BOOST_AUTO_TEST_CASE( fork_blocks )
database db2; database db2;
db2.open(data_dir2.path(), make_genesis); db2.open(data_dir2.path(), make_genesis);
auto delegate_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")) ); auto init_account_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")) );
for( uint32_t i = 0; i < 10; ++i ) for( uint32_t i = 0; i < 10; ++i )
{ {
now += db1.block_interval(); now += db1.block_interval();
auto b = db1.generate_block(now, db1.get_scheduled_witness(1).first, delegate_priv_key, database::skip_nothing); auto b = db1.generate_block(now, db1.get_scheduled_witness(1).first, init_account_priv_key, database::skip_nothing);
try { try {
PUSH_BLOCK( db2, b ); PUSH_BLOCK( db2, b );
} FC_CAPTURE_AND_RETHROW( ("db2") ); } FC_CAPTURE_AND_RETHROW( ("db2") );
@ -227,13 +227,13 @@ BOOST_AUTO_TEST_CASE( fork_blocks )
for( uint32_t i = 10; i < 13; ++i ) for( uint32_t i = 10; i < 13; ++i )
{ {
now += db1.block_interval(); now += db1.block_interval();
auto b = db1.generate_block(now, db1.get_scheduled_witness(1).first, delegate_priv_key, database::skip_nothing); auto b = db1.generate_block(now, db1.get_scheduled_witness(1).first, init_account_priv_key, database::skip_nothing);
} }
string db1_tip = db1.head_block_id().str(); string db1_tip = db1.head_block_id().str();
for( uint32_t i = 13; i < 16; ++i ) for( uint32_t i = 13; i < 16; ++i )
{ {
now += db2.block_interval(); now += db2.block_interval();
auto b = db2.generate_block(now, db2.get_scheduled_witness(db2.get_slot_at_time(now)).first, delegate_priv_key, database::skip_nothing); auto b = db2.generate_block(now, db2.get_scheduled_witness(db2.get_slot_at_time(now)).first, init_account_priv_key, database::skip_nothing);
// notify both databases of the new block. // notify both databases of the new block.
// only db2 should switch to the new fork, db1 should not // only db2 should switch to the new fork, db1 should not
PUSH_BLOCK( db1, b ); PUSH_BLOCK( db1, b );
@ -248,11 +248,11 @@ BOOST_AUTO_TEST_CASE( fork_blocks )
BOOST_CHECK_EQUAL(db2.head_block_num(), 13); BOOST_CHECK_EQUAL(db2.head_block_num(), 13);
{ {
now += db2.block_interval(); now += db2.block_interval();
auto b = db2.generate_block(now, db2.get_scheduled_witness(1).first, delegate_priv_key, database::skip_nothing); auto b = db2.generate_block(now, db2.get_scheduled_witness(1).first, init_account_priv_key, database::skip_nothing);
good_block = b; good_block = b;
b.transactions.emplace_back(signed_transaction()); b.transactions.emplace_back(signed_transaction());
b.transactions.back().operations.emplace_back(transfer_operation()); b.transactions.back().operations.emplace_back(transfer_operation());
b.sign(delegate_priv_key); b.sign(init_account_priv_key);
BOOST_CHECK_EQUAL(b.block_num(), 14); BOOST_CHECK_EQUAL(b.block_num(), 14);
GRAPHENE_CHECK_THROW(PUSH_BLOCK( db1, b ), fc::exception); GRAPHENE_CHECK_THROW(PUSH_BLOCK( db1, b ), fc::exception);
} }
@ -278,8 +278,8 @@ BOOST_AUTO_TEST_CASE( undo_pending )
database db; database db;
db.open(data_dir.path(), make_genesis); db.open(data_dir.path(), make_genesis);
auto delegate_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")) ); auto init_account_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")) );
public_key_type delegate_pub_key = delegate_priv_key.get_public_key(); public_key_type init_account_pub_key = init_account_priv_key.get_public_key();
const graphene::db::index& account_idx = db.get_index(protocol_ids, account_object_type); const graphene::db::index& account_idx = db.get_index(protocol_ids, account_object_type);
transfer_operation t; transfer_operation t;
@ -292,7 +292,7 @@ BOOST_AUTO_TEST_CASE( undo_pending )
PUSH_TX( db, trx, ~0 ); PUSH_TX( db, trx, ~0 );
now += db.block_interval(); now += db.block_interval();
auto b = db.generate_block(now, db.get_scheduled_witness(1).first, delegate_priv_key, ~0); auto b = db.generate_block(now, db.get_scheduled_witness(1).first, init_account_priv_key, ~0);
} }
signed_transaction trx; signed_transaction trx;
@ -301,13 +301,13 @@ BOOST_AUTO_TEST_CASE( undo_pending )
account_create_operation cop; account_create_operation cop;
cop.registrar = GRAPHENE_TEMP_ACCOUNT; cop.registrar = GRAPHENE_TEMP_ACCOUNT;
cop.name = "nathan"; cop.name = "nathan";
cop.owner = authority(1, delegate_pub_key, 1); cop.owner = authority(1, init_account_pub_key, 1);
trx.operations.push_back(cop); trx.operations.push_back(cop);
//trx.sign( delegate_priv_key ); //trx.sign( init_account_priv_key );
PUSH_TX( db, trx ); PUSH_TX( db, trx );
now += db.block_interval(); now += db.block_interval();
auto b = db.generate_block(now, db.get_scheduled_witness(1).first, delegate_priv_key, database::skip_nothing); auto b = db.generate_block(now, db.get_scheduled_witness(1).first, init_account_priv_key, database::skip_nothing);
BOOST_CHECK(nathan_id(db).name == "nathan"); BOOST_CHECK(nathan_id(db).name == "nathan");
@ -345,8 +345,8 @@ BOOST_AUTO_TEST_CASE( switch_forks_undo_create )
db2.open(dir2.path(), make_genesis); db2.open(dir2.path(), make_genesis);
fc::time_point_sec now( GRAPHENE_TESTING_GENESIS_TIMESTAMP ); fc::time_point_sec now( GRAPHENE_TESTING_GENESIS_TIMESTAMP );
auto delegate_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")) ); auto init_account_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")) );
public_key_type delegate_pub_key = delegate_priv_key.get_public_key(); public_key_type init_account_pub_key = init_account_priv_key.get_public_key();
const graphene::db::index& account_idx = db1.get_index(protocol_ids, account_object_type); const graphene::db::index& account_idx = db1.get_index(protocol_ids, account_object_type);
signed_transaction trx; signed_transaction trx;
@ -355,23 +355,23 @@ BOOST_AUTO_TEST_CASE( switch_forks_undo_create )
account_create_operation cop; account_create_operation cop;
cop.registrar = GRAPHENE_TEMP_ACCOUNT; cop.registrar = GRAPHENE_TEMP_ACCOUNT;
cop.name = "nathan"; cop.name = "nathan";
cop.owner = authority(1, delegate_pub_key, 1); cop.owner = authority(1, init_account_pub_key, 1);
trx.operations.push_back(cop); trx.operations.push_back(cop);
PUSH_TX( db1, trx ); PUSH_TX( db1, trx );
auto aw = db1.get_global_properties().active_witnesses; auto aw = db1.get_global_properties().active_witnesses;
now += db1.block_interval(); now += db1.block_interval();
auto b = db1.generate_block(now, db1.get_scheduled_witness(1).first, delegate_priv_key, database::skip_nothing); auto b = db1.generate_block(now, db1.get_scheduled_witness(1).first, init_account_priv_key, database::skip_nothing);
BOOST_CHECK(nathan_id(db1).name == "nathan"); BOOST_CHECK(nathan_id(db1).name == "nathan");
now = fc::time_point_sec( GRAPHENE_TESTING_GENESIS_TIMESTAMP ); now = fc::time_point_sec( GRAPHENE_TESTING_GENESIS_TIMESTAMP );
now += db2.block_interval(); now += db2.block_interval();
b = db2.generate_block(now, db2.get_scheduled_witness(1).first, delegate_priv_key, database::skip_nothing); b = db2.generate_block(now, db2.get_scheduled_witness(1).first, init_account_priv_key, database::skip_nothing);
db1.push_block(b); db1.push_block(b);
aw = db2.get_global_properties().active_witnesses; aw = db2.get_global_properties().active_witnesses;
now += db2.block_interval(); now += db2.block_interval();
b = db2.generate_block(now, db2.get_scheduled_witness(1).first, delegate_priv_key, database::skip_nothing); b = db2.generate_block(now, db2.get_scheduled_witness(1).first, init_account_priv_key, database::skip_nothing);
db1.push_block(b); db1.push_block(b);
GRAPHENE_CHECK_THROW(nathan_id(db1), fc::exception); GRAPHENE_CHECK_THROW(nathan_id(db1), fc::exception);
@ -380,7 +380,7 @@ BOOST_AUTO_TEST_CASE( switch_forks_undo_create )
aw = db2.get_global_properties().active_witnesses; aw = db2.get_global_properties().active_witnesses;
now += db2.block_interval(); now += db2.block_interval();
b = db2.generate_block(now, db2.get_scheduled_witness(1).first, delegate_priv_key, database::skip_nothing); b = db2.generate_block(now, db2.get_scheduled_witness(1).first, init_account_priv_key, database::skip_nothing);
db1.push_block(b); db1.push_block(b);
BOOST_CHECK(nathan_id(db1).name == "nathan"); BOOST_CHECK(nathan_id(db1).name == "nathan");
@ -404,8 +404,8 @@ BOOST_AUTO_TEST_CASE( duplicate_transactions )
auto skip_sigs = database::skip_transaction_signatures | database::skip_authority_check; auto skip_sigs = database::skip_transaction_signatures | database::skip_authority_check;
auto delegate_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")) ); auto init_account_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")) );
public_key_type delegate_pub_key = delegate_priv_key.get_public_key(); public_key_type init_account_pub_key = init_account_priv_key.get_public_key();
const graphene::db::index& account_idx = db1.get_index(protocol_ids, account_object_type); const graphene::db::index& account_idx = db1.get_index(protocol_ids, account_object_type);
signed_transaction trx; signed_transaction trx;
@ -413,9 +413,9 @@ BOOST_AUTO_TEST_CASE( duplicate_transactions )
account_id_type nathan_id = account_idx.get_next_id(); account_id_type nathan_id = account_idx.get_next_id();
account_create_operation cop; account_create_operation cop;
cop.name = "nathan"; cop.name = "nathan";
cop.owner = authority(1, delegate_pub_key, 1); cop.owner = authority(1, init_account_pub_key, 1);
trx.operations.push_back(cop); trx.operations.push_back(cop);
trx.sign( delegate_priv_key ); trx.sign( init_account_priv_key );
PUSH_TX( db1, trx, skip_sigs ); PUSH_TX( db1, trx, skip_sigs );
trx = decltype(trx)(); trx = decltype(trx)();
@ -424,13 +424,13 @@ BOOST_AUTO_TEST_CASE( duplicate_transactions )
t.to = nathan_id; t.to = nathan_id;
t.amount = asset(500); t.amount = asset(500);
trx.operations.push_back(t); trx.operations.push_back(t);
trx.sign( delegate_priv_key ); trx.sign( init_account_priv_key );
PUSH_TX( db1, trx, skip_sigs ); PUSH_TX( db1, trx, skip_sigs );
GRAPHENE_CHECK_THROW(PUSH_TX( db1, trx, skip_sigs ), fc::exception); GRAPHENE_CHECK_THROW(PUSH_TX( db1, trx, skip_sigs ), fc::exception);
now += db1.block_interval(); now += db1.block_interval();
auto b = db1.generate_block( now, db1.get_scheduled_witness( 1 ).first, delegate_priv_key, skip_sigs ); auto b = db1.generate_block( now, db1.get_scheduled_witness( 1 ).first, init_account_priv_key, skip_sigs );
PUSH_BLOCK( db2, b, skip_sigs ); PUSH_BLOCK( db2, b, skip_sigs );
GRAPHENE_CHECK_THROW(PUSH_TX( db1, trx, skip_sigs ), fc::exception); GRAPHENE_CHECK_THROW(PUSH_TX( db1, trx, skip_sigs ), fc::exception);
@ -456,12 +456,12 @@ BOOST_AUTO_TEST_CASE( tapos )
const account_object& init1 = *db1.get_index_type<account_index>().indices().get<by_name>().find("init1"); const account_object& init1 = *db1.get_index_type<account_index>().indices().get<by_name>().find("init1");
auto delegate_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")) ); auto init_account_priv_key = fc::ecc::private_key::regenerate(fc::sha256::hash(string("null_key")) );
public_key_type delegate_pub_key = delegate_priv_key.get_public_key(); public_key_type init_account_pub_key = init_account_priv_key.get_public_key();
const graphene::db::index& account_idx = db1.get_index(protocol_ids, account_object_type); const graphene::db::index& account_idx = db1.get_index(protocol_ids, account_object_type);
now += db1.block_interval(); now += db1.block_interval();
auto b = db1.generate_block(now, db1.get_scheduled_witness( 1 ).first, delegate_priv_key, database::skip_nothing); auto b = db1.generate_block(now, db1.get_scheduled_witness( 1 ).first, init_account_priv_key, database::skip_nothing);
signed_transaction trx; signed_transaction trx;
//This transaction must be in the next block after its reference, or it is invalid. //This transaction must be in the next block after its reference, or it is invalid.
@ -471,24 +471,24 @@ BOOST_AUTO_TEST_CASE( tapos )
account_create_operation cop; account_create_operation cop;
cop.registrar = init1.id; cop.registrar = init1.id;
cop.name = "nathan"; cop.name = "nathan";
cop.owner = authority(1, delegate_pub_key, 1); cop.owner = authority(1, init_account_pub_key, 1);
trx.operations.push_back(cop); trx.operations.push_back(cop);
trx.sign(delegate_priv_key); trx.sign(init_account_priv_key);
db1.push_transaction(trx); db1.push_transaction(trx);
now += db1.block_interval(); now += db1.block_interval();
b = db1.generate_block(now, db1.get_scheduled_witness(1).first, delegate_priv_key, database::skip_nothing); b = db1.generate_block(now, db1.get_scheduled_witness(1).first, init_account_priv_key, database::skip_nothing);
trx.clear(); trx.clear();
transfer_operation t; transfer_operation t;
t.to = nathan_id; t.to = nathan_id;
t.amount = asset(50); t.amount = asset(50);
trx.operations.push_back(t); trx.operations.push_back(t);
trx.sign(delegate_priv_key); trx.sign(init_account_priv_key);
//relative_expiration is 1, but ref block is 2 blocks old, so this should fail. //relative_expiration is 1, but ref block is 2 blocks old, so this should fail.
GRAPHENE_REQUIRE_THROW(PUSH_TX( db1, trx, database::skip_transaction_signatures | database::skip_authority_check ), fc::exception); GRAPHENE_REQUIRE_THROW(PUSH_TX( db1, trx, database::skip_transaction_signatures | database::skip_authority_check ), fc::exception);
trx.set_expiration(db1.head_block_id(), 2); trx.set_expiration(db1.head_block_id(), 2);
trx.signatures.clear(); trx.signatures.clear();
trx.sign(delegate_priv_key); trx.sign(init_account_priv_key);
db1.push_transaction(trx, database::skip_transaction_signatures | database::skip_authority_check); db1.push_transaction(trx, database::skip_transaction_signatures | database::skip_authority_check);
} catch (fc::exception& e) { } catch (fc::exception& e) {
edump((e.to_detail_string())); edump((e.to_detail_string()));
@ -507,12 +507,12 @@ BOOST_FIXTURE_TEST_CASE( maintenance_interval, database_fixture )
auto initial_properties = db.get_global_properties(); auto initial_properties = db.get_global_properties();
const account_object& nathan = create_account("nathan"); const account_object& nathan = create_account("nathan");
upgrade_to_lifetime_member(nathan); upgrade_to_lifetime_member(nathan);
const delegate_object nathans_delegate = create_delegate(nathan); const committee_member_object nathans_committee_member = create_committee_member(nathan);
{ {
account_update_operation op; account_update_operation op;
op.account = nathan.id; op.account = nathan.id;
op.new_options = nathan.options; op.new_options = nathan.options;
op.new_options->votes.insert(nathans_delegate.vote_id); op.new_options->votes.insert(nathans_committee_member.vote_id);
trx.operations.push_back(op); trx.operations.push_back(op);
PUSH_TX( db, trx, ~0 ); PUSH_TX( db, trx, ~0 );
trx.operations.clear(); trx.operations.clear();
@ -526,15 +526,15 @@ BOOST_FIXTURE_TEST_CASE( maintenance_interval, database_fixture )
db.head_block_time().sec_since_epoch() + db.get_global_properties().parameters.block_interval); db.head_block_time().sec_since_epoch() + db.get_global_properties().parameters.block_interval);
// shuffling is now handled by the witness_schedule_object. // shuffling is now handled by the witness_schedule_object.
BOOST_CHECK(db.get_global_properties().active_witnesses == initial_properties.active_witnesses); BOOST_CHECK(db.get_global_properties().active_witnesses == initial_properties.active_witnesses);
BOOST_CHECK(db.get_global_properties().active_delegates == initial_properties.active_delegates); BOOST_CHECK(db.get_global_properties().active_committee_members == initial_properties.active_committee_members);
generate_block(); generate_block();
auto new_properties = db.get_global_properties(); auto new_properties = db.get_global_properties();
BOOST_CHECK(new_properties.active_delegates != initial_properties.active_delegates); BOOST_CHECK(new_properties.active_committee_members != initial_properties.active_committee_members);
BOOST_CHECK(std::find(new_properties.active_delegates.begin(), BOOST_CHECK(std::find(new_properties.active_committee_members.begin(),
new_properties.active_delegates.end(), nathans_delegate.id) != new_properties.active_committee_members.end(), nathans_committee_member.id) !=
new_properties.active_delegates.end()); new_properties.active_committee_members.end());
BOOST_CHECK_EQUAL(db.get_dynamic_global_properties().next_maintenance_time.sec_since_epoch(), BOOST_CHECK_EQUAL(db.get_dynamic_global_properties().next_maintenance_time.sec_since_epoch(),
maintenence_time.sec_since_epoch() + new_properties.parameters.maintenance_interval); maintenence_time.sec_since_epoch() + new_properties.parameters.maintenance_interval);
maintenence_time = db.get_dynamic_global_properties().next_maintenance_time; maintenence_time = db.get_dynamic_global_properties().next_maintenance_time;
@ -555,9 +555,9 @@ BOOST_FIXTURE_TEST_CASE( limit_order_expiration, database_fixture )
auto* test = &create_bitasset("TEST"); auto* test = &create_bitasset("TEST");
auto* core = &asset_id_type()(db); auto* core = &asset_id_type()(db);
auto* nathan = &create_account("nathan"); auto* nathan = &create_account("nathan");
auto* genesis = &account_id_type()(db); auto* committee = &account_id_type()(db);
transfer(*genesis, *nathan, core->amount(50000)); transfer(*committee, *nathan, core->amount(50000));
BOOST_CHECK_EQUAL( get_balance(*nathan, *core), 50000 ); BOOST_CHECK_EQUAL( get_balance(*nathan, *core), 50000 );
@ -584,7 +584,7 @@ BOOST_FIXTURE_TEST_CASE( limit_order_expiration, database_fixture )
test = &get_asset("TEST"); test = &get_asset("TEST");
core = &asset_id_type()(db); core = &asset_id_type()(db);
nathan = &get_account("nathan"); nathan = &get_account("nathan");
genesis = &account_id_type()(db); committee = &account_id_type()(db);
BOOST_CHECK(db.find_object(id) == nullptr); BOOST_CHECK(db.find_object(id) == nullptr);
BOOST_CHECK_EQUAL( get_balance(*nathan, *core), 50000 ); BOOST_CHECK_EQUAL( get_balance(*nathan, *core), 50000 );
@ -646,16 +646,16 @@ BOOST_FIXTURE_TEST_CASE( change_block_interval, database_fixture )
BOOST_TEST_MESSAGE( "Creating a proposal to change the block_interval to 1 second" ); BOOST_TEST_MESSAGE( "Creating a proposal to change the block_interval to 1 second" );
{ {
proposal_create_operation cop = proposal_create_operation::genesis_proposal(db.get_global_properties().parameters, db.head_block_time()); proposal_create_operation cop = proposal_create_operation::committee_proposal(db.get_global_properties().parameters, db.head_block_time());
cop.fee_paying_account = GRAPHENE_TEMP_ACCOUNT; cop.fee_paying_account = GRAPHENE_TEMP_ACCOUNT;
cop.expiration_time = db.head_block_time() + *cop.review_period_seconds + 10; cop.expiration_time = db.head_block_time() + *cop.review_period_seconds + 10;
delegate_update_global_parameters_operation uop; committee_member_update_global_parameters_operation uop;
uop.new_parameters.block_interval = 1; uop.new_parameters.block_interval = 1;
cop.proposed_ops.emplace_back(uop); cop.proposed_ops.emplace_back(uop);
trx.operations.push_back(cop); trx.operations.push_back(cop);
db.push_transaction(trx); db.push_transaction(trx);
} }
BOOST_TEST_MESSAGE( "Updating proposal by signing with the delegate private key" ); BOOST_TEST_MESSAGE( "Updating proposal by signing with the committee_member private key" );
{ {
proposal_update_operation uop; proposal_update_operation uop;
uop.fee_paying_account = GRAPHENE_TEMP_ACCOUNT; uop.fee_paying_account = GRAPHENE_TEMP_ACCOUNT;
@ -664,15 +664,15 @@ BOOST_FIXTURE_TEST_CASE( change_block_interval, database_fixture )
get_account("init4").get_id(), get_account("init5").get_id(), get_account("init4").get_id(), get_account("init5").get_id(),
get_account("init6").get_id(), get_account("init7").get_id()}; get_account("init6").get_id(), get_account("init7").get_id()};
trx.operations.push_back(uop); trx.operations.push_back(uop);
trx.sign(delegate_priv_key); trx.sign(init_account_priv_key);
/* /*
trx.sign(get_account("init1").active.get_keys().front(),delegate_priv_key); trx.sign(get_account("init1").active.get_keys().front(),init_account_priv_key);
trx.sign(get_account("init2").active.get_keys().front(),delegate_priv_key); trx.sign(get_account("init2").active.get_keys().front(),init_account_priv_key);
trx.sign(get_account("init3").active.get_keys().front(),delegate_priv_key); trx.sign(get_account("init3").active.get_keys().front(),init_account_priv_key);
trx.sign(get_account("init4").active.get_keys().front(),delegate_priv_key); trx.sign(get_account("init4").active.get_keys().front(),init_account_priv_key);
trx.sign(get_account("init5").active.get_keys().front(),delegate_priv_key); trx.sign(get_account("init5").active.get_keys().front(),init_account_priv_key);
trx.sign(get_account("init6").active.get_keys().front(),delegate_priv_key); trx.sign(get_account("init6").active.get_keys().front(),init_account_priv_key);
trx.sign(get_account("init7").active.get_keys().front(),delegate_priv_key); trx.sign(get_account("init7").active.get_keys().front(),init_account_priv_key);
*/ */
db.push_transaction(trx); db.push_transaction(trx);
BOOST_CHECK(proposal_id_type()(db).is_authorized_to_execute(db)); BOOST_CHECK(proposal_id_type()(db).is_authorized_to_execute(db));
@ -709,8 +709,8 @@ BOOST_FIXTURE_TEST_CASE( unimp_force_settlement, database_fixture )
BOOST_FAIL( "TODO" ); BOOST_FAIL( "TODO" );
/* /*
try { try {
auto private_key = delegate_priv_key; auto private_key = init_account_priv_key;
auto private_key = generate_private_key("genesis"); auto private_key = generate_private_key("committee");
>>>>>>> short_refactor >>>>>>> short_refactor
account_id_type nathan_id = create_account("nathan").get_id(); account_id_type nathan_id = create_account("nathan").get_id();
account_id_type shorter1_id = create_account("shorter1").get_id(); account_id_type shorter1_id = create_account("shorter1").get_id();
@ -840,7 +840,7 @@ BOOST_FIXTURE_TEST_CASE( pop_block_twice, database_fixture )
try try
{ {
uint32_t skip_flags = ( uint32_t skip_flags = (
database::skip_delegate_signature database::skip_witness_signature
| database::skip_transaction_signatures | database::skip_transaction_signatures
| database::skip_authority_check | database::skip_authority_check
); );
@ -848,7 +848,7 @@ BOOST_FIXTURE_TEST_CASE( pop_block_twice, database_fixture )
const asset_object& core = asset_id_type()(db); const asset_object& core = asset_id_type()(db);
// Sam is the creator of accounts // Sam is the creator of accounts
private_key_type genesis_key = delegate_priv_key; private_key_type committee_key = init_account_priv_key;
private_key_type sam_key = generate_private_key("sam"); private_key_type sam_key = generate_private_key("sam");
account_object sam_account_object = create_account("sam", sam_key); account_object sam_account_object = create_account("sam", sam_key);
@ -862,9 +862,9 @@ BOOST_FIXTURE_TEST_CASE( pop_block_twice, database_fixture )
transaction tx; transaction tx;
processed_transaction ptx; processed_transaction ptx;
account_object genesis_account_object = genesis_account(db); account_object committee_account_object = committee_account(db);
// transfer from genesis account to Sam account // transfer from committee account to Sam account
transfer(genesis_account_object, sam_account_object, core.amount(100000)); transfer(committee_account_object, sam_account_object, core.amount(100000));
generate_block(skip_flags); generate_block(skip_flags);
@ -893,7 +893,7 @@ BOOST_FIXTURE_TEST_CASE( witness_scheduler_missed_blocks, database_fixture )
}); });
near_schedule = db.get_near_witness_schedule(); near_schedule = db.get_near_witness_schedule();
generate_block(0, delegate_priv_key, 2); generate_block(0, init_account_priv_key, 2);
BOOST_CHECK(db.get_dynamic_global_properties().current_witness == near_schedule[2]); BOOST_CHECK(db.get_dynamic_global_properties().current_witness == near_schedule[2]);
near_schedule.erase(near_schedule.begin(), near_schedule.begin() + 3); near_schedule.erase(near_schedule.begin(), near_schedule.begin() + 3);

128
tests/tests/operation_tests.cpp
View file

@ -21,7 +21,7 @@
#include <graphene/chain/account_object.hpp> #include <graphene/chain/account_object.hpp>
#include <graphene/chain/asset_object.hpp> #include <graphene/chain/asset_object.hpp>
#include <graphene/chain/database.hpp> #include <graphene/chain/database.hpp>
#include <graphene/chain/delegate_object.hpp> #include <graphene/chain/committee_member_object.hpp>
#include <graphene/chain/market_evaluator.hpp> #include <graphene/chain/market_evaluator.hpp>
#include <graphene/chain/vesting_balance_object.hpp> #include <graphene/chain/vesting_balance_object.hpp>
#include <graphene/chain/withdraw_permission_object.hpp> #include <graphene/chain/withdraw_permission_object.hpp>
@ -72,7 +72,7 @@ BOOST_AUTO_TEST_CASE( call_order_update_test )
const auto& bitusd = create_bitasset("BITUSD"); const auto& bitusd = create_bitasset("BITUSD");
const auto& core = asset_id_type()(db); const auto& core = asset_id_type()(db);
transfer(genesis_account, dan_id, asset(10000000)); transfer(committee_account, dan_id, asset(10000000));
update_feed_producers( bitusd, {sam.id} ); update_feed_producers( bitusd, {sam.id} );
price_feed current_feed; current_feed.settlement_price = bitusd.amount( 100 ) / core.amount(100); price_feed current_feed; current_feed.settlement_price = bitusd.amount( 100 ) / core.amount(100);
@ -162,9 +162,9 @@ BOOST_AUTO_TEST_CASE( margin_call_limit_test )
int64_t init_balance(1000000); int64_t init_balance(1000000);
transfer(genesis_account, buyer_id, asset(init_balance)); transfer(committee_account, buyer_id, asset(init_balance));
transfer(genesis_account, borrower_id, asset(init_balance)); transfer(committee_account, borrower_id, asset(init_balance));
transfer(genesis_account, borrower2_id, asset(init_balance)); transfer(committee_account, borrower2_id, asset(init_balance));
update_feed_producers( bitusd, {feedproducer.id} ); update_feed_producers( bitusd, {feedproducer.id} );
price_feed current_feed; price_feed current_feed;
@ -221,9 +221,9 @@ BOOST_AUTO_TEST_CASE( black_swan )
int64_t init_balance(1000000); int64_t init_balance(1000000);
transfer(genesis_account, buyer_id, asset(init_balance)); transfer(committee_account, buyer_id, asset(init_balance));
transfer(genesis_account, borrower_id, asset(init_balance)); transfer(committee_account, borrower_id, asset(init_balance));
transfer(genesis_account, borrower2_id, asset(init_balance)); transfer(committee_account, borrower2_id, asset(init_balance));
update_feed_producers(bitusd, {feedproducer.id}); update_feed_producers(bitusd, {feedproducer.id});
price_feed current_feed; price_feed current_feed;
@ -267,9 +267,9 @@ BOOST_AUTO_TEST_CASE( prediction_market )
const auto& core = asset_id_type()(db); const auto& core = asset_id_type()(db);
int64_t init_balance(1000000); int64_t init_balance(1000000);
transfer(genesis_account, judge_id, asset(init_balance)); transfer(committee_account, judge_id, asset(init_balance));
transfer(genesis_account, dan_id, asset(init_balance)); transfer(committee_account, dan_id, asset(init_balance));
transfer(genesis_account, nathan_id, asset(init_balance)); transfer(committee_account, nathan_id, asset(init_balance));
BOOST_TEST_MESSAGE( "Require throw for mismatch collateral amounts" ); BOOST_TEST_MESSAGE( "Require throw for mismatch collateral amounts" );
GRAPHENE_REQUIRE_THROW( borrow( dan, pmark.amount(1000), asset(2000) ), fc::exception ); GRAPHENE_REQUIRE_THROW( borrow( dan, pmark.amount(1000), asset(2000) ), fc::exception );
@ -329,7 +329,7 @@ BOOST_AUTO_TEST_CASE( create_account_test )
op.owner = auth_bak; op.owner = auth_bak;
trx.operations.back() = op; trx.operations.back() = op;
trx.sign( delegate_priv_key); trx.sign( init_account_priv_key);
trx.validate(); trx.validate();
PUSH_TX( db, trx, ~0 ); PUSH_TX( db, trx, ~0 );
@ -339,11 +339,11 @@ BOOST_AUTO_TEST_CASE( create_account_test )
BOOST_CHECK(nathan_account.name == "nathan"); BOOST_CHECK(nathan_account.name == "nathan");
BOOST_REQUIRE(nathan_account.owner.num_auths() == 1); BOOST_REQUIRE(nathan_account.owner.num_auths() == 1);
BOOST_CHECK(nathan_account.owner.key_auths.at(genesis_key) == 123); BOOST_CHECK(nathan_account.owner.key_auths.at(committee_key) == 123);
BOOST_REQUIRE(nathan_account.active.num_auths() == 1); BOOST_REQUIRE(nathan_account.active.num_auths() == 1);
BOOST_CHECK(nathan_account.active.key_auths.at(genesis_key) == 321); BOOST_CHECK(nathan_account.active.key_auths.at(committee_key) == 321);
BOOST_CHECK(nathan_account.options.voting_account == account_id_type()); BOOST_CHECK(nathan_account.options.voting_account == account_id_type());
BOOST_CHECK(nathan_account.options.memo_key == genesis_key); BOOST_CHECK(nathan_account.options.memo_key == committee_key);
const account_statistics_object& statistics = nathan_account.statistics(db); const account_statistics_object& statistics = nathan_account.statistics(db);
BOOST_CHECK(statistics.id.space() == implementation_ids); BOOST_CHECK(statistics.id.space() == implementation_ids);
@ -357,38 +357,36 @@ BOOST_AUTO_TEST_CASE( create_account_test )
BOOST_AUTO_TEST_CASE( update_account ) BOOST_AUTO_TEST_CASE( update_account )
{ {
try { try {
const account_object& nathan = create_account("nathan", delegate_pub_key); const account_object& nathan = create_account("nathan", init_account_pub_key);
const fc::ecc::private_key nathan_new_key = fc::ecc::private_key::generate(); const fc::ecc::private_key nathan_new_key = fc::ecc::private_key::generate();
const public_key_type key_id = nathan_new_key.get_public_key(); const public_key_type key_id = nathan_new_key.get_public_key();
const auto& active_delegates = db.get_global_properties().active_delegates; const auto& active_committee_members = db.get_global_properties().active_committee_members;
transfer(account_id_type()(db), nathan, asset(30000)); transfer(account_id_type()(db), nathan, asset(1000000000));
trx.operations.clear(); trx.operations.clear();
account_update_operation op; account_update_operation op;
op.account = nathan.id; op.account = nathan.id;
op.owner = authority(2, key_id, 1, delegate_pub_key, 1); op.owner = authority(2, key_id, 1, init_account_pub_key, 1);
op.active = authority(2, key_id, 1, delegate_pub_key, 1); op.active = authority(2, key_id, 1, init_account_pub_key, 1);
op.new_options = nathan.options; op.new_options = nathan.options;
op.new_options->votes = flat_set<vote_id_type>({active_delegates[0](db).vote_id, active_delegates[5](db).vote_id}); op.new_options->votes = flat_set<vote_id_type>({active_committee_members[0](db).vote_id, active_committee_members[5](db).vote_id});
op.new_options->num_committee = 2; op.new_options->num_committee = 2;
trx.operations.push_back(op); trx.operations.push_back(op);
BOOST_TEST_MESSAGE( "Updating account" ); BOOST_TEST_MESSAGE( "Updating account" );
PUSH_TX( db, trx, ~0 ); PUSH_TX( db, trx, ~0 );
BOOST_CHECK(nathan.options.memo_key == delegate_pub_key); BOOST_CHECK(nathan.options.memo_key == init_account_pub_key);
BOOST_CHECK(nathan.active.weight_threshold == 2); BOOST_CHECK(nathan.active.weight_threshold == 2);
BOOST_CHECK(nathan.active.num_auths() == 2); BOOST_CHECK(nathan.active.num_auths() == 2);
BOOST_CHECK(nathan.active.key_auths.at(key_id) == 1); BOOST_CHECK(nathan.active.key_auths.at(key_id) == 1);
BOOST_CHECK(nathan.active.key_auths.at(delegate_pub_key) == 1); BOOST_CHECK(nathan.active.key_auths.at(init_account_pub_key) == 1);
BOOST_CHECK(nathan.owner.weight_threshold == 2); BOOST_CHECK(nathan.owner.weight_threshold == 2);
BOOST_CHECK(nathan.owner.num_auths() == 2); BOOST_CHECK(nathan.owner.num_auths() == 2);
BOOST_CHECK(nathan.owner.key_auths.at(key_id) == 1); BOOST_CHECK(nathan.owner.key_auths.at(key_id) == 1);
BOOST_CHECK(nathan.owner.key_auths.at(delegate_pub_key) == 1); BOOST_CHECK(nathan.owner.key_auths.at(init_account_pub_key) == 1);
BOOST_CHECK(nathan.options.votes.size() == 2); BOOST_CHECK(nathan.options.votes.size() == 2);
transfer(account_id_type()(db), nathan, asset(3000000));
enable_fees(); enable_fees();
{ {
account_upgrade_operation op; account_upgrade_operation op;
@ -411,12 +409,12 @@ BOOST_AUTO_TEST_CASE( transfer_core_asset )
try { try {
INVOKE(create_account_test); INVOKE(create_account_test);
account_id_type genesis_account; account_id_type committee_account;
asset genesis_balance = db.get_balance(account_id_type(), asset_id_type()); asset committee_balance = db.get_balance(account_id_type(), asset_id_type());
const account_object& nathan_account = *db.get_index_type<account_index>().indices().get<by_name>().find("nathan"); const account_object& nathan_account = *db.get_index_type<account_index>().indices().get<by_name>().find("nathan");
transfer_operation top; transfer_operation top;
top.from = genesis_account; top.from = committee_account;
top.to = nathan_account.id; top.to = nathan_account.id;
top.amount = asset( 10000); top.amount = asset( 10000);
trx.operations.push_back(top); trx.operations.push_back(top);
@ -427,14 +425,14 @@ BOOST_AUTO_TEST_CASE( transfer_core_asset )
PUSH_TX( db, trx, ~0 ); PUSH_TX( db, trx, ~0 );
BOOST_CHECK_EQUAL(get_balance(account_id_type()(db), asset_id_type()(db)), BOOST_CHECK_EQUAL(get_balance(account_id_type()(db), asset_id_type()(db)),
(genesis_balance.amount - 10000 - fee.amount).value); (committee_balance.amount - 10000 - fee.amount).value);
genesis_balance = db.get_balance(account_id_type(), asset_id_type()); committee_balance = db.get_balance(account_id_type(), asset_id_type());
BOOST_CHECK_EQUAL(get_balance(nathan_account, asset_id_type()(db)), 10000); BOOST_CHECK_EQUAL(get_balance(nathan_account, asset_id_type()(db)), 10000);
trx = signed_transaction(); trx = signed_transaction();
top.from = nathan_account.id; top.from = nathan_account.id;
top.to = genesis_account; top.to = committee_account;
top.amount = asset(2000); top.amount = asset(2000);
trx.operations.push_back(top); trx.operations.push_back(top);
@ -445,7 +443,7 @@ BOOST_AUTO_TEST_CASE( transfer_core_asset )
PUSH_TX( db, trx, ~0 ); PUSH_TX( db, trx, ~0 );
BOOST_CHECK_EQUAL(get_balance(nathan_account, asset_id_type()(db)), 8000 - fee.amount.value); BOOST_CHECK_EQUAL(get_balance(nathan_account, asset_id_type()(db)), 8000 - fee.amount.value);
BOOST_CHECK_EQUAL(get_balance(account_id_type()(db), asset_id_type()(db)), genesis_balance.amount.value + 2000); BOOST_CHECK_EQUAL(get_balance(account_id_type()(db), asset_id_type()(db)), committee_balance.amount.value + 2000);
} catch (fc::exception& e) { } catch (fc::exception& e) {
edump((e.to_detail_string())); edump((e.to_detail_string()));
@ -453,23 +451,23 @@ BOOST_AUTO_TEST_CASE( transfer_core_asset )
} }
} }
BOOST_AUTO_TEST_CASE( create_delegate ) BOOST_AUTO_TEST_CASE( create_committee_member )
{ {
try { try {
delegate_create_operation op; committee_member_create_operation op;
op.delegate_account = account_id_type(); op.committee_member_account = account_id_type();
op.fee = asset(); op.fee = asset();
trx.operations.push_back(op); trx.operations.push_back(op);
REQUIRE_THROW_WITH_VALUE(op, delegate_account, account_id_type(99999999)); REQUIRE_THROW_WITH_VALUE(op, committee_member_account, account_id_type(99999999));
REQUIRE_THROW_WITH_VALUE(op, fee, asset(-600)); REQUIRE_THROW_WITH_VALUE(op, fee, asset(-600));
trx.operations.back() = op; trx.operations.back() = op;
delegate_id_type delegate_id = db.get_index_type<primary_index<simple_index<delegate_object>>>().get_next_id(); committee_member_id_type committee_member_id = db.get_index_type<primary_index<simple_index<committee_member_object>>>().get_next_id();
PUSH_TX( db, trx, ~0 ); PUSH_TX( db, trx, ~0 );
const delegate_object& d = delegate_id(db); const committee_member_object& d = committee_member_id(db);
BOOST_CHECK(d.delegate_account == account_id_type()); BOOST_CHECK(d.committee_member_account == account_id_type());
} catch (fc::exception& e) { } catch (fc::exception& e) {
edump((e.to_detail_string())); edump((e.to_detail_string()));
throw; throw;
@ -700,22 +698,22 @@ BOOST_AUTO_TEST_CASE( transfer_uia )
const asset_object& uia = *db.get_index_type<asset_index>().indices().get<by_symbol>().find("TEST"); const asset_object& uia = *db.get_index_type<asset_index>().indices().get<by_symbol>().find("TEST");
const account_object& nathan = *db.get_index_type<account_index>().indices().get<by_name>().find("nathan"); const account_object& nathan = *db.get_index_type<account_index>().indices().get<by_name>().find("nathan");
const account_object& genesis = account_id_type()(db); const account_object& committee = account_id_type()(db);
BOOST_CHECK_EQUAL(get_balance(nathan, uia), 10000000); BOOST_CHECK_EQUAL(get_balance(nathan, uia), 10000000);
transfer_operation top; transfer_operation top;
top.from = nathan.id; top.from = nathan.id;
top.to = genesis.id; top.to = committee.id;
top.amount = uia.amount(5000); top.amount = uia.amount(5000);
trx.operations.push_back(top); trx.operations.push_back(top);
BOOST_TEST_MESSAGE( "Transfering 5000 TEST from nathan to genesis" ); BOOST_TEST_MESSAGE( "Transfering 5000 TEST from nathan to committee" );
PUSH_TX( db, trx, ~0 ); PUSH_TX( db, trx, ~0 );
BOOST_CHECK_EQUAL(get_balance(nathan, uia), 10000000 - 5000); BOOST_CHECK_EQUAL(get_balance(nathan, uia), 10000000 - 5000);
BOOST_CHECK_EQUAL(get_balance(genesis, uia), 5000); BOOST_CHECK_EQUAL(get_balance(committee, uia), 5000);
PUSH_TX( db, trx, ~0 ); PUSH_TX( db, trx, ~0 );
BOOST_CHECK_EQUAL(get_balance(nathan, uia), 10000000 - 10000); BOOST_CHECK_EQUAL(get_balance(nathan, uia), 10000000 - 10000);
BOOST_CHECK_EQUAL(get_balance(genesis, uia), 10000); BOOST_CHECK_EQUAL(get_balance(committee, uia), 10000);
} catch(fc::exception& e) { } catch(fc::exception& e) {
edump((e.to_detail_string())); edump((e.to_detail_string()));
throw; throw;
@ -732,7 +730,7 @@ BOOST_AUTO_TEST_CASE( create_buy_uia_multiple_match_new )
const account_object& buyer_account = create_account( "buyer" ); const account_object& buyer_account = create_account( "buyer" );
const account_object& seller_account = create_account( "seller" ); const account_object& seller_account = create_account( "seller" );
transfer( genesis_account(db), buyer_account, test_asset.amount( 10000 ) ); transfer( committee_account(db), buyer_account, test_asset.amount( 10000 ) );
transfer( nathan_account, seller_account, core_asset.amount(10000) ); transfer( nathan_account, seller_account, core_asset.amount(10000) );
BOOST_CHECK_EQUAL( get_balance( buyer_account, test_asset ), 10000 ); BOOST_CHECK_EQUAL( get_balance( buyer_account, test_asset ), 10000 );
@ -772,7 +770,7 @@ BOOST_AUTO_TEST_CASE( create_buy_exact_match_uia )
const account_object& buyer_account = create_account( "buyer" ); const account_object& buyer_account = create_account( "buyer" );
const account_object& seller_account = create_account( "seller" ); const account_object& seller_account = create_account( "seller" );
transfer( genesis_account(db), seller_account, asset( 10000 ) ); transfer( committee_account(db), seller_account, asset( 10000 ) );
transfer( nathan_account, buyer_account, test_asset.amount(10000) ); transfer( nathan_account, buyer_account, test_asset.amount(10000) );
BOOST_CHECK_EQUAL( get_balance( buyer_account, test_asset ), 10000 ); BOOST_CHECK_EQUAL( get_balance( buyer_account, test_asset ), 10000 );
@ -813,7 +811,7 @@ BOOST_AUTO_TEST_CASE( create_buy_uia_multiple_match_new_reverse )
const account_object& buyer_account = create_account( "buyer" ); const account_object& buyer_account = create_account( "buyer" );
const account_object& seller_account = create_account( "seller" ); const account_object& seller_account = create_account( "seller" );
transfer( genesis_account(db), seller_account, asset( 10000 ) ); transfer( committee_account(db), seller_account, asset( 10000 ) );
transfer( nathan_account, buyer_account, test_asset.amount(10000),test_asset.amount(0) ); transfer( nathan_account, buyer_account, test_asset.amount(10000),test_asset.amount(0) );
BOOST_CHECK_EQUAL( get_balance( buyer_account, test_asset ), 10000 ); BOOST_CHECK_EQUAL( get_balance( buyer_account, test_asset ), 10000 );
@ -853,7 +851,7 @@ BOOST_AUTO_TEST_CASE( create_buy_uia_multiple_match_new_reverse_fract )
const account_object& buyer_account = create_account( "buyer" ); const account_object& buyer_account = create_account( "buyer" );
const account_object& seller_account = create_account( "seller" ); const account_object& seller_account = create_account( "seller" );
transfer( genesis_account(db), seller_account, asset( 30 ) ); transfer( committee_account(db), seller_account, asset( 30 ) );
transfer( nathan_account, buyer_account, test_asset.amount(10000),test_asset.amount(0) ); transfer( nathan_account, buyer_account, test_asset.amount(10000),test_asset.amount(0) );
BOOST_CHECK_EQUAL( get_balance( buyer_account, test_asset ), 10000 ); BOOST_CHECK_EQUAL( get_balance( buyer_account, test_asset ), 10000 );
@ -898,15 +896,15 @@ BOOST_AUTO_TEST_CASE( uia_fees )
const asset_object& test_asset = get_asset("TEST"); const asset_object& test_asset = get_asset("TEST");
const asset_dynamic_data_object& asset_dynamic = test_asset.dynamic_asset_data_id(db); const asset_dynamic_data_object& asset_dynamic = test_asset.dynamic_asset_data_id(db);
const account_object& nathan_account = get_account("nathan"); const account_object& nathan_account = get_account("nathan");
const account_object& genesis_account = account_id_type()(db); const account_object& committee_account = account_id_type()(db);
fund_fee_pool(genesis_account, test_asset, 1000*CORE); fund_fee_pool(committee_account, test_asset, 1000*CORE);
BOOST_CHECK(asset_dynamic.fee_pool == 1000*CORE); BOOST_CHECK(asset_dynamic.fee_pool == 1000*CORE);
transfer_operation op; transfer_operation op;
op.fee = test_asset.amount(0); op.fee = test_asset.amount(0);
op.from = nathan_account.id; op.from = nathan_account.id;
op.to = genesis_account.id; op.to = committee_account.id;
op.amount = test_asset.amount(100); op.amount = test_asset.amount(100);
op.fee = db.current_fee_schedule().calculate_fee( op, test_asset.options.core_exchange_rate ); op.fee = db.current_fee_schedule().calculate_fee( op, test_asset.options.core_exchange_rate );
BOOST_CHECK(op.fee.asset_id == test_asset.id); BOOST_CHECK(op.fee.asset_id == test_asset.id);
@ -919,7 +917,7 @@ BOOST_AUTO_TEST_CASE( uia_fees )
BOOST_CHECK_EQUAL(get_balance(nathan_account, test_asset), BOOST_CHECK_EQUAL(get_balance(nathan_account, test_asset),
(old_balance - fee - test_asset.amount(100)).amount.value); (old_balance - fee - test_asset.amount(100)).amount.value);
BOOST_CHECK_EQUAL(get_balance(genesis_account, test_asset), 100); BOOST_CHECK_EQUAL(get_balance(committee_account, test_asset), 100);
BOOST_CHECK(asset_dynamic.accumulated_fees == fee.amount); BOOST_CHECK(asset_dynamic.accumulated_fees == fee.amount);
BOOST_CHECK(asset_dynamic.fee_pool == 1000*CORE - core_fee.amount); BOOST_CHECK(asset_dynamic.fee_pool == 1000*CORE - core_fee.amount);
@ -927,7 +925,7 @@ BOOST_AUTO_TEST_CASE( uia_fees )
PUSH_TX( db, trx, ~0 ); PUSH_TX( db, trx, ~0 );
BOOST_CHECK_EQUAL(get_balance(nathan_account, test_asset), BOOST_CHECK_EQUAL(get_balance(nathan_account, test_asset),
(old_balance - fee - fee - test_asset.amount(200)).amount.value); (old_balance - fee - fee - test_asset.amount(200)).amount.value);
BOOST_CHECK_EQUAL(get_balance(genesis_account, test_asset), 200); BOOST_CHECK_EQUAL(get_balance(committee_account, test_asset), 200);
BOOST_CHECK(asset_dynamic.accumulated_fees == fee.amount + fee.amount); BOOST_CHECK(asset_dynamic.accumulated_fees == fee.amount + fee.amount);
BOOST_CHECK(asset_dynamic.fee_pool == 1000*CORE - core_fee.amount - core_fee.amount); BOOST_CHECK(asset_dynamic.fee_pool == 1000*CORE - core_fee.amount - core_fee.amount);
@ -936,7 +934,7 @@ BOOST_AUTO_TEST_CASE( uia_fees )
op.amount = asset(20); op.amount = asset(20);
BOOST_CHECK_EQUAL(get_balance(nathan_account, asset_id_type()(db)), 0); BOOST_CHECK_EQUAL(get_balance(nathan_account, asset_id_type()(db)), 0);
transfer(genesis_account, nathan_account, asset(20)); transfer(committee_account, nathan_account, asset(20));
BOOST_CHECK_EQUAL(get_balance(nathan_account, asset_id_type()(db)), 20); BOOST_CHECK_EQUAL(get_balance(nathan_account, asset_id_type()(db)), 20);
trx.operations.emplace_back(std::move(op)); trx.operations.emplace_back(std::move(op));
@ -945,7 +943,7 @@ BOOST_AUTO_TEST_CASE( uia_fees )
BOOST_CHECK_EQUAL(get_balance(nathan_account, asset_id_type()(db)), 0); BOOST_CHECK_EQUAL(get_balance(nathan_account, asset_id_type()(db)), 0);
BOOST_CHECK_EQUAL(get_balance(nathan_account, test_asset), BOOST_CHECK_EQUAL(get_balance(nathan_account, test_asset),
(old_balance - fee - fee - fee - test_asset.amount(200)).amount.value); (old_balance - fee - fee - fee - test_asset.amount(200)).amount.value);
BOOST_CHECK_EQUAL(get_balance(genesis_account, test_asset), 200); BOOST_CHECK_EQUAL(get_balance(committee_account, test_asset), 200);
BOOST_CHECK(asset_dynamic.accumulated_fees == fee.amount.value * 3); BOOST_CHECK(asset_dynamic.accumulated_fees == fee.amount.value * 3);
BOOST_CHECK(asset_dynamic.fee_pool == 1000*CORE - core_fee.amount.value * 3); BOOST_CHECK(asset_dynamic.fee_pool == 1000*CORE - core_fee.amount.value * 3);
} catch (fc::exception& e) { } catch (fc::exception& e) {
@ -960,7 +958,7 @@ BOOST_AUTO_TEST_CASE( cancel_limit_order_test )
const asset_object& test_asset = get_asset( "TEST" ); const asset_object& test_asset = get_asset( "TEST" );
const account_object& buyer_account = create_account( "buyer" ); const account_object& buyer_account = create_account( "buyer" );
transfer( genesis_account(db), buyer_account, asset( 10000 ) ); transfer( committee_account(db), buyer_account, asset( 10000 ) );
BOOST_CHECK_EQUAL( get_balance(buyer_account, asset_id_type()(db)), 10000 ); BOOST_CHECK_EQUAL( get_balance(buyer_account, asset_id_type()(db)), 10000 );
auto sell_order = create_sell_order( buyer_account, asset(1000), test_asset.amount(100+450*1) ); auto sell_order = create_sell_order( buyer_account, asset(1000), test_asset.amount(100+450*1) );
@ -976,7 +974,7 @@ BOOST_AUTO_TEST_CASE( cancel_limit_order_test )
} }
} }
BOOST_AUTO_TEST_CASE( delegate_feeds ) BOOST_AUTO_TEST_CASE( witness_feeds )
{ {
using namespace graphene::chain; using namespace graphene::chain;
try { try {
@ -1021,7 +1019,7 @@ BOOST_AUTO_TEST_CASE( delegate_feeds )
op.publisher = active_witnesses[2]; op.publisher = active_witnesses[2];
op.feed.settlement_price = ~price(asset(GRAPHENE_BLOCKCHAIN_PRECISION),bit_usd.amount(40)); op.feed.settlement_price = ~price(asset(GRAPHENE_BLOCKCHAIN_PRECISION),bit_usd.amount(40));
// But this delegate is an idiot. // But this witness is an idiot.
op.feed.maintenance_collateral_ratio = 1001; op.feed.maintenance_collateral_ratio = 1001;
trx.operations.back() = op; trx.operations.back() = op;
PUSH_TX( db, trx, ~0 ); PUSH_TX( db, trx, ~0 );
@ -1051,7 +1049,7 @@ BOOST_AUTO_TEST_CASE( trade_amount_equals_zero )
const account_object& core_seller = create_account( "shorter1" ); const account_object& core_seller = create_account( "shorter1" );
const account_object& core_buyer = get_account("nathan"); const account_object& core_buyer = get_account("nathan");
transfer( genesis_account(db), core_seller, asset( 100000000 ) ); transfer( committee_account(db), core_seller, asset( 100000000 ) );
BOOST_CHECK_EQUAL(get_balance(core_buyer, core), 0); BOOST_CHECK_EQUAL(get_balance(core_buyer, core), 0);
BOOST_CHECK_EQUAL(get_balance(core_buyer, test), 10000000); BOOST_CHECK_EQUAL(get_balance(core_buyer, test), 10000000);
@ -1109,7 +1107,7 @@ BOOST_AUTO_TEST_CASE( witness_withdraw_pay_test )
generate_block(); generate_block();
// Make an account and upgrade it to prime, so that witnesses get some pay // Make an account and upgrade it to prime, so that witnesses get some pay
create_account("nathan", delegate_pub_key); create_account("nathan", init_account_pub_key);
transfer(account_id_type()(db), get_account("nathan"), asset(20000*CORE)); transfer(account_id_type()(db), get_account("nathan"), asset(20000*CORE));
transfer(account_id_type()(db), get_account("init3"), asset(20*CORE)); transfer(account_id_type()(db), get_account("init3"), asset(20*CORE));
generate_block(); generate_block();
@ -1149,7 +1147,7 @@ BOOST_AUTO_TEST_CASE( witness_withdraw_pay_test )
trx.operations.push_back(uop); trx.operations.push_back(uop);
for( auto& op : trx.operations ) db.current_fee_schedule().set_fee(op); for( auto& op : trx.operations ) db.current_fee_schedule().set_fee(op);
trx.validate(); trx.validate();
trx.sign(delegate_priv_key); trx.sign(init_account_priv_key);
db.push_transaction(trx); db.push_transaction(trx);
trx.clear(); trx.clear();
BOOST_CHECK_EQUAL(get_balance(*nathan, *core), 20000*CORE - account_upgrade_operation::fee_parameters_type().membership_lifetime_fee );; BOOST_CHECK_EQUAL(get_balance(*nathan, *core), 20000*CORE - account_upgrade_operation::fee_parameters_type().membership_lifetime_fee );;
@ -1336,7 +1334,7 @@ BOOST_AUTO_TEST_CASE( vesting_balance_create_test )
const account_object& alice_account = create_account("alice"); const account_object& alice_account = create_account("alice");
const account_object& bob_account = create_account("bob"); const account_object& bob_account = create_account("bob");
transfer(genesis_account(db), alice_account, core.amount(100000)); transfer(committee_account(db), alice_account, core.amount(100000));
op.creator = alice_account.get_id(); op.creator = alice_account.get_id();
op.owner = alice_account.get_id(); op.owner = alice_account.get_id();
@ -1385,7 +1383,7 @@ BOOST_AUTO_TEST_CASE( vesting_balance_withdraw_test )
const account_object& alice_account = create_account( "alice" ); const account_object& alice_account = create_account( "alice" );
const account_object& bob_account = create_account( "bob" ); const account_object& bob_account = create_account( "bob" );
transfer( genesis_account(db), alice_account, core.amount( 1000000 ) ); transfer( committee_account(db), alice_account, core.amount( 1000000 ) );
auto spin_vbo_clock = [&]( const vesting_balance_object& vbo, uint32_t dt_secs ) auto spin_vbo_clock = [&]( const vesting_balance_object& vbo, uint32_t dt_secs )
{ {
@ -1424,7 +1422,7 @@ BOOST_AUTO_TEST_CASE( vesting_balance_withdraw_test )
auto top_up = [&]() auto top_up = [&]()
{ {
trx.clear(); trx.clear();
transfer( genesis_account(db), transfer( committee_account(db),
alice_account, alice_account,
core.amount( 1000000 - db.get_balance( alice_account, core ).amount ) core.amount( 1000000 - db.get_balance( alice_account, core ).amount )
); );

30
tests/tests/operation_tests2.cpp
View file

@ -25,7 +25,7 @@
#include <graphene/chain/account_object.hpp> #include <graphene/chain/account_object.hpp>
#include <graphene/chain/balance_object.hpp> #include <graphene/chain/balance_object.hpp>
#include <graphene/chain/witness_object.hpp> #include <graphene/chain/witness_object.hpp>
#include <graphene/chain/delegate_object.hpp> #include <graphene/chain/committee_member_object.hpp>
#include <graphene/chain/market_evaluator.hpp> #include <graphene/chain/market_evaluator.hpp>
#include <graphene/chain/worker_evaluator.hpp> #include <graphene/chain/worker_evaluator.hpp>
#include <graphene/chain/vesting_balance_object.hpp> #include <graphene/chain/vesting_balance_object.hpp>
@ -413,7 +413,7 @@ BOOST_AUTO_TEST_CASE( witness_create )
trx.clear(); trx.clear();
witness_id_type nathan_witness_id = create_witness(nathan_id, nathan_private_key).id; witness_id_type nathan_witness_id = create_witness(nathan_id, nathan_private_key).id;
// Give nathan some voting stake // Give nathan some voting stake
transfer(genesis_account, nathan_id, asset(10000000)); transfer(committee_account, nathan_id, asset(10000000));
generate_block(); generate_block();
trx.set_expiration(db.head_block_id()); trx.set_expiration(db.head_block_id());
@ -488,9 +488,9 @@ BOOST_AUTO_TEST_CASE( global_settle_test )
feed.maximum_short_squeeze_ratio = 150 * GRAPHENE_COLLATERAL_RATIO_DENOM / 100; feed.maximum_short_squeeze_ratio = 150 * GRAPHENE_COLLATERAL_RATIO_DENOM / 100;
publish_feed( bit_usd_id(db), nathan, feed ); publish_feed( bit_usd_id(db), nathan, feed );
transfer(genesis_account, ben_id, asset(10000)); transfer(committee_account, ben_id, asset(10000));
transfer(genesis_account, valentine_id, asset(10000)); transfer(committee_account, valentine_id, asset(10000));
transfer(genesis_account, dan_id, asset(10000)); transfer(committee_account, dan_id, asset(10000));
borrow(ben, asset(1000, bit_usd_id), asset(1000)); borrow(ben, asset(1000, bit_usd_id), asset(1000));
BOOST_CHECK_EQUAL(get_balance(ben_id, bit_usd_id), 1000); BOOST_CHECK_EQUAL(get_balance(ben_id, bit_usd_id), 1000);
BOOST_CHECK_EQUAL(get_balance(ben_id, asset_id_type()), 9000); BOOST_CHECK_EQUAL(get_balance(ben_id, asset_id_type()), 9000);
@ -597,7 +597,7 @@ BOOST_AUTO_TEST_CASE( worker_pay_test )
INVOKE(worker_create_test); INVOKE(worker_create_test);
GET_ACTOR(nathan); GET_ACTOR(nathan);
generate_blocks(db.get_dynamic_global_properties().next_maintenance_time); generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
transfer(genesis_account, nathan_id, asset(100000)); transfer(committee_account, nathan_id, asset(100000));
{ {
account_update_operation op; account_update_operation op;
@ -710,7 +710,7 @@ BOOST_AUTO_TEST_CASE( refund_worker_test )
BOOST_CHECK(worker.vote_for.type() == vote_id_type::worker); BOOST_CHECK(worker.vote_for.type() == vote_id_type::worker);
BOOST_CHECK(worker.vote_against.type() == vote_id_type::worker); BOOST_CHECK(worker.vote_against.type() == vote_id_type::worker);
transfer(genesis_account, nathan_id, asset(100000)); transfer(committee_account, nathan_id, asset(100000));
{ {
account_update_operation op; account_update_operation op;
@ -783,7 +783,7 @@ BOOST_AUTO_TEST_CASE( burn_worker_test )
BOOST_CHECK(worker.vote_for.type() == vote_id_type::worker); BOOST_CHECK(worker.vote_for.type() == vote_id_type::worker);
BOOST_CHECK(worker.vote_against.type() == vote_id_type::worker); BOOST_CHECK(worker.vote_against.type() == vote_id_type::worker);
transfer(genesis_account, nathan_id, asset(100000)); transfer(committee_account, nathan_id, asset(100000));
{ {
account_update_operation op; account_update_operation op;
@ -826,8 +826,8 @@ BOOST_AUTO_TEST_CASE( unimp_force_settlement_unavailable )
BOOST_FAIL( "TODO - Reimplement this" ); BOOST_FAIL( "TODO - Reimplement this" );
/* /*
try { try {
auto private_key = delegate_priv_key; auto private_key = init_account_priv_key;
auto private_key = generate_private_key("genesis"); auto private_key = generate_private_key("committee");
>>>>>>> short_refactor >>>>>>> short_refactor
account_id_type nathan_id = create_account("nathan").get_id(); account_id_type nathan_id = create_account("nathan").get_id();
account_id_type shorter1_id = create_account("shorter1").get_id(); account_id_type shorter1_id = create_account("shorter1").get_id();
@ -1026,7 +1026,7 @@ BOOST_AUTO_TEST_CASE( balance_object_test )
BOOST_CHECK(db.find_object(balance_id_type(1)) != nullptr); BOOST_CHECK(db.find_object(balance_id_type(1)) != nullptr);
auto slot = db.get_slot_at_time(starting_time); auto slot = db.get_slot_at_time(starting_time);
db.generate_block(starting_time, db.get_scheduled_witness(slot).first, delegate_priv_key, database::skip_nothing); db.generate_block(starting_time, db.get_scheduled_witness(slot).first, init_account_priv_key, database::skip_nothing);
trx.set_expiration(db.head_block_id()); trx.set_expiration(db.head_block_id());
const balance_object& vesting_balance_1 = balance_id_type(2)(db); const balance_object& vesting_balance_1 = balance_id_type(2)(db);
@ -1077,9 +1077,9 @@ BOOST_AUTO_TEST_CASE( balance_object_test )
// Attempting to claim twice within a day // Attempting to claim twice within a day
GRAPHENE_CHECK_THROW(db.push_transaction(trx), balance_claim_claimed_too_often); GRAPHENE_CHECK_THROW(db.push_transaction(trx), balance_claim_claimed_too_often);
db.generate_block(db.get_slot_time(1), db.get_scheduled_witness(1).first, delegate_priv_key, database::skip_nothing); db.generate_block(db.get_slot_time(1), db.get_scheduled_witness(1).first, init_account_priv_key, database::skip_nothing);
slot = db.get_slot_at_time(vesting_balance_1.vesting_policy->begin_timestamp + 60); slot = db.get_slot_at_time(vesting_balance_1.vesting_policy->begin_timestamp + 60);
db.generate_block(db.get_slot_time(slot), db.get_scheduled_witness(slot).first, delegate_priv_key, database::skip_nothing); db.generate_block(db.get_slot_time(slot), db.get_scheduled_witness(slot).first, init_account_priv_key, database::skip_nothing);
trx.set_expiration(db.head_block_id()); trx.set_expiration(db.head_block_id());
op.balance_to_claim = vesting_balance_1.id; op.balance_to_claim = vesting_balance_1.id;
@ -1103,9 +1103,9 @@ BOOST_AUTO_TEST_CASE( balance_object_test )
// Attempting to claim twice within a day // Attempting to claim twice within a day
GRAPHENE_CHECK_THROW(db.push_transaction(trx), balance_claim_claimed_too_often); GRAPHENE_CHECK_THROW(db.push_transaction(trx), balance_claim_claimed_too_often);
db.generate_block(db.get_slot_time(1), db.get_scheduled_witness(1).first, delegate_priv_key, database::skip_nothing); db.generate_block(db.get_slot_time(1), db.get_scheduled_witness(1).first, init_account_priv_key, database::skip_nothing);
slot = db.get_slot_at_time(db.head_block_time() + fc::days(1)); slot = db.get_slot_at_time(db.head_block_time() + fc::days(1));
db.generate_block(db.get_slot_time(slot), db.get_scheduled_witness(slot).first, delegate_priv_key, database::skip_nothing); db.generate_block(db.get_slot_time(slot), db.get_scheduled_witness(slot).first, init_account_priv_key, database::skip_nothing);
trx.set_expiration(db.head_block_id()); trx.set_expiration(db.head_block_id());
op.total_claimed = vesting_balance_2.balance; op.total_claimed = vesting_balance_2.balance;

3
tests/tests/uia_tests.cpp
View file

@ -23,7 +23,6 @@
#include <graphene/chain/account_object.hpp> #include <graphene/chain/account_object.hpp>
#include <graphene/chain/asset_object.hpp> #include <graphene/chain/asset_object.hpp>
#include <graphene/chain/delegate_object.hpp>
#include <fc/crypto/digest.hpp> #include <fc/crypto/digest.hpp>
@ -259,7 +258,7 @@ BOOST_AUTO_TEST_CASE( transfer_whitelist_uia )
BOOST_CHECK(!nathan.is_authorized_asset(advanced)); BOOST_CHECK(!nathan.is_authorized_asset(advanced));
GRAPHENE_REQUIRE_THROW(PUSH_TX( db, trx, ~0 ), fc::exception); GRAPHENE_REQUIRE_THROW(PUSH_TX( db, trx, ~0 ), fc::exception);
//Remove nathan from genesis' whitelist, add him to dan's. This should not authorize him to hold ADVANCED. //Remove nathan from committee's whitelist, add him to dan's. This should not authorize him to hold ADVANCED.
wop.authorizing_account = account_id_type(); wop.authorizing_account = account_id_type();
wop.account_to_list = nathan.id; wop.account_to_list = nathan.id;
wop.new_listing = account_whitelist_operation::no_listing; wop.new_listing = account_whitelist_operation::no_listing;