492 lines
19 KiB
C++
492 lines
19 KiB
C++
/*
|
|
* Copyright (c) 2015, Cryptonomex, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This source code is provided for evaluation in private test networks only, until September 8, 2015. After this date, this license expires and
|
|
* the code may not be used, modified or distributed for any purpose. Redistribution and use in source and binary forms, with or without modification,
|
|
* are permitted until September 8, 2015, provided that the following conditions are met:
|
|
*
|
|
* 1. The code and/or derivative works are used only for private test networks consisting of no more than 10 P2P nodes.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
|
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* 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.
|
|
*/
|
|
|
|
#include <bitset>
|
|
#include <iostream>
|
|
|
|
#include <boost/test/unit_test.hpp>
|
|
|
|
#include <graphene/chain/database.hpp>
|
|
#include <graphene/chain/protocol/protocol.hpp>
|
|
#include <graphene/chain/account_object.hpp>
|
|
#include <graphene/chain/proposal_object.hpp>
|
|
#include <graphene/chain/witness_schedule_object.hpp>
|
|
#include <graphene/chain/vesting_balance_object.hpp>
|
|
|
|
#include <fc/crypto/digest.hpp>
|
|
|
|
#include "../common/database_fixture.hpp"
|
|
|
|
using namespace graphene::chain;
|
|
|
|
BOOST_AUTO_TEST_SUITE(block_tests)
|
|
|
|
BOOST_FIXTURE_TEST_CASE( update_account_keys, database_fixture )
|
|
{
|
|
try
|
|
{
|
|
const asset_object& core = asset_id_type()(db);
|
|
uint32_t skip_flags =
|
|
database::skip_transaction_dupe_check
|
|
| database::skip_delegate_signature
|
|
| database::skip_transaction_signatures
|
|
| database::skip_authority_check
|
|
;
|
|
|
|
// Sam is the creator of accounts
|
|
private_key_type committee_key = delegate_priv_key;
|
|
private_key_type sam_key = generate_private_key("sam");
|
|
|
|
//
|
|
// A = old key set
|
|
// B = new key set
|
|
//
|
|
// we measure how many times we test following four cases:
|
|
//
|
|
// A-B B-A
|
|
// alice case_count[0] A == B empty empty
|
|
// bob case_count[1] A < B empty nonempty
|
|
// charlie case_count[2] B < A nonempty empty
|
|
// dan case_count[3] A nc B nonempty nonempty
|
|
//
|
|
// and assert that all four cases were tested at least once
|
|
//
|
|
account_object sam_account_object = create_account( "sam", sam_key );
|
|
|
|
//Get a sane head block time
|
|
generate_block( skip_flags );
|
|
|
|
db.modify(db.get_global_properties(), [](global_property_object& p) {
|
|
p.parameters.committee_proposal_review_period = fc::hours(1).to_seconds();
|
|
});
|
|
|
|
transaction tx;
|
|
processed_transaction ptx;
|
|
|
|
account_object committee_account_object = committee_account(db);
|
|
// transfer from committee account to Sam account
|
|
transfer(committee_account_object, sam_account_object, core.amount(100000));
|
|
|
|
const int num_keys = 5;
|
|
vector< private_key_type > numbered_private_keys;
|
|
vector< vector< public_key_type > > numbered_key_id;
|
|
numbered_private_keys.reserve( num_keys );
|
|
numbered_key_id.push_back( vector<public_key_type>() );
|
|
numbered_key_id.push_back( vector<public_key_type>() );
|
|
|
|
for( int i=0; i<num_keys; i++ )
|
|
{
|
|
private_key_type privkey = generate_private_key(
|
|
std::string("key_") + std::to_string(i));
|
|
public_key_type pubkey = privkey.get_public_key();
|
|
address addr( pubkey );
|
|
|
|
numbered_private_keys.push_back( privkey );
|
|
numbered_key_id[0].push_back( pubkey );
|
|
//numbered_key_id[1].push_back( addr );
|
|
}
|
|
|
|
// each element of possible_key_sched is a list of exactly num_keys
|
|
// indices into numbered_key_id[use_address]. they are defined
|
|
// by repeating selected elements of
|
|
// numbered_private_keys given by a different selector.
|
|
vector< vector< int > > possible_key_sched;
|
|
const int num_key_sched = (1 << num_keys)-1;
|
|
possible_key_sched.reserve( num_key_sched );
|
|
|
|
for( int s=1; s<=num_key_sched; s++ )
|
|
{
|
|
vector< int > v;
|
|
int i = 0;
|
|
v.reserve( num_keys );
|
|
while( v.size() < num_keys )
|
|
{
|
|
if( s & (1 << i) )
|
|
v.push_back( i );
|
|
i++;
|
|
if( i >= num_keys )
|
|
i = 0;
|
|
}
|
|
possible_key_sched.push_back( v );
|
|
}
|
|
|
|
// we can only undo in blocks
|
|
generate_block( skip_flags );
|
|
|
|
std::cout << "update_account_keys: this test will take a few minutes...\n";
|
|
for( int use_addresses=0; use_addresses<2; use_addresses++ )
|
|
{
|
|
vector< public_key_type > key_ids = numbered_key_id[ use_addresses ];
|
|
for( int num_owner_keys=1; num_owner_keys<=2; num_owner_keys++ )
|
|
{
|
|
for( int num_active_keys=1; num_active_keys<=2; num_active_keys++ )
|
|
{
|
|
std::cout << use_addresses << num_owner_keys << num_active_keys << "\n";
|
|
for( const vector< int >& key_sched_before : possible_key_sched )
|
|
{
|
|
auto it = key_sched_before.begin();
|
|
vector< const private_key_type* > owner_privkey;
|
|
vector< const public_key_type* > owner_keyid;
|
|
owner_privkey.reserve( num_owner_keys );
|
|
|
|
trx.clear();
|
|
account_create_operation create_op;
|
|
create_op.name = "alice";
|
|
|
|
for( int owner_index=0; owner_index<num_owner_keys; owner_index++ )
|
|
{
|
|
int i = *(it++);
|
|
create_op.owner.key_auths[ key_ids[ i ] ] = 1;
|
|
owner_privkey.push_back( &numbered_private_keys[i] );
|
|
owner_keyid.push_back( &key_ids[ i ] );
|
|
}
|
|
// size() < num_owner_keys is possible when some keys are duplicates
|
|
create_op.owner.weight_threshold = create_op.owner.key_auths.size();
|
|
|
|
for( int active_index=0; active_index<num_active_keys; active_index++ )
|
|
create_op.active.key_auths[ key_ids[ *(it++) ] ] = 1;
|
|
// size() < num_active_keys is possible when some keys are duplicates
|
|
create_op.active.weight_threshold = create_op.active.key_auths.size();
|
|
|
|
create_op.options.memo_key = key_ids[ *(it++) ] ;
|
|
create_op.registrar = sam_account_object.id;
|
|
trx.operations.push_back( create_op );
|
|
// trx.sign( sam_key );
|
|
wdump( (trx) );
|
|
|
|
processed_transaction ptx_create = db.push_transaction( trx,
|
|
database::skip_transaction_dupe_check |
|
|
database::skip_transaction_signatures |
|
|
database::skip_authority_check
|
|
);
|
|
account_id_type alice_account_id =
|
|
ptx_create.operation_results[0]
|
|
.get< object_id_type >();
|
|
|
|
generate_block( skip_flags );
|
|
for( const vector< int >& key_sched_after : possible_key_sched )
|
|
{
|
|
auto it = key_sched_after.begin();
|
|
|
|
trx.clear();
|
|
account_update_operation update_op;
|
|
update_op.account = alice_account_id;
|
|
update_op.owner = authority();
|
|
update_op.active = authority();
|
|
update_op.new_options = create_op.options;
|
|
|
|
for( int owner_index=0; owner_index<num_owner_keys; owner_index++ )
|
|
update_op.owner->key_auths[ key_ids[ *(it++) ] ] = 1;
|
|
// size() < num_owner_keys is possible when some keys are duplicates
|
|
update_op.owner->weight_threshold = update_op.owner->key_auths.size();
|
|
for( int active_index=0; active_index<num_active_keys; active_index++ )
|
|
update_op.active->key_auths[ key_ids[ *(it++) ] ] = 1;
|
|
// size() < num_active_keys is possible when some keys are duplicates
|
|
update_op.active->weight_threshold = update_op.active->key_auths.size();
|
|
FC_ASSERT( update_op.new_options.valid() );
|
|
update_op.new_options->memo_key = key_ids[ *(it++) ] ;
|
|
|
|
trx.operations.push_back( update_op );
|
|
for( int i=0; i<int(create_op.owner.weight_threshold); i++)
|
|
{
|
|
trx.sign( *owner_privkey[i] );
|
|
if( i < int(create_op.owner.weight_threshold-1) )
|
|
{
|
|
GRAPHENE_REQUIRE_THROW(db.push_transaction(trx), fc::exception);
|
|
}
|
|
else
|
|
{
|
|
db.push_transaction( trx,
|
|
database::skip_transaction_dupe_check |
|
|
database::skip_transaction_signatures );
|
|
}
|
|
}
|
|
verify_account_history_plugin_index();
|
|
generate_block( skip_flags );
|
|
|
|
verify_account_history_plugin_index();
|
|
db.pop_block();
|
|
verify_account_history_plugin_index();
|
|
}
|
|
db.pop_block();
|
|
verify_account_history_plugin_index();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch( const fc::exception& e )
|
|
{
|
|
edump( (e.to_detail_string()) );
|
|
throw;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
* always a chance that the last delegate of one round will be the
|
|
* first delegate of the next round.
|
|
*
|
|
* This means that when we shuffle delegates we need to make sure
|
|
* that there is at least N/2 delegates between consecutive turns
|
|
* of the same delegate. This means that durring the random
|
|
* shuffle we need to restrict the placement of delegates to maintain
|
|
* this invariant.
|
|
*
|
|
* This test checks the requirement using Monte Carlo approach
|
|
* (produce lots of blocks and check the invariant holds).
|
|
*/
|
|
BOOST_FIXTURE_TEST_CASE( witness_order_mc_test, database_fixture )
|
|
{
|
|
try {
|
|
size_t num_witnesses = db.get_global_properties().active_witnesses.size();
|
|
size_t dmin = num_witnesses >> 1;
|
|
|
|
vector< witness_id_type > cur_round;
|
|
vector< witness_id_type > full_schedule;
|
|
// if we make the maximum witness count testable,
|
|
// we'll need to enlarge this.
|
|
std::bitset< 0x40 > witness_seen;
|
|
size_t total_blocks = 1000000;
|
|
|
|
cur_round.reserve( num_witnesses );
|
|
full_schedule.reserve( total_blocks );
|
|
cur_round.push_back( db.get_dynamic_global_properties().current_witness );
|
|
|
|
// we assert so the test doesn't continue, which would
|
|
// corrupt memory
|
|
assert( num_witnesses <= witness_seen.size() );
|
|
|
|
while( full_schedule.size() < total_blocks )
|
|
{
|
|
if( (db.head_block_num() & 0x3FFF) == 0 )
|
|
{
|
|
wdump( (db.head_block_num()) );
|
|
}
|
|
witness_id_type wid = db.get_scheduled_witness( 1 ).first;
|
|
full_schedule.push_back( wid );
|
|
cur_round.push_back( wid );
|
|
if( cur_round.size() == num_witnesses )
|
|
{
|
|
// check that the current round contains exactly 1 copy
|
|
// of each witness
|
|
witness_seen.reset();
|
|
for( const witness_id_type& w : cur_round )
|
|
{
|
|
uint64_t inst = w.instance.value;
|
|
BOOST_CHECK( !witness_seen.test( inst ) );
|
|
assert( !witness_seen.test( inst ) );
|
|
witness_seen.set( inst );
|
|
}
|
|
cur_round.clear();
|
|
}
|
|
generate_block();
|
|
}
|
|
|
|
for( size_t i=0,m=full_schedule.size(); i<m; i++ )
|
|
{
|
|
for( size_t j=i+1,n=std::min( m, i+dmin ); j<n; j++ )
|
|
{
|
|
BOOST_CHECK( full_schedule[i] != full_schedule[j] );
|
|
assert( full_schedule[i] != full_schedule[j] );
|
|
}
|
|
}
|
|
|
|
} catch (fc::exception& e) {
|
|
edump((e.to_detail_string()));
|
|
throw;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
* always a chance that the last delegate of one round will be the
|
|
* first delegate of the next round.
|
|
*
|
|
* This means that when we shuffle delegates we need to make sure
|
|
* that there is at least N/2 delegates between consecutive turns
|
|
* of the same delegate. This means that durring the random
|
|
* shuffle we need to restrict the placement of delegates to maintain
|
|
* this invariant.
|
|
*
|
|
* This test checks the requirement using Monte Carlo approach
|
|
* (produce lots of blocks and check the invariant holds).
|
|
*/
|
|
BOOST_FIXTURE_TEST_CASE( generic_scheduler_mc_test, database_fixture )
|
|
{
|
|
try {
|
|
size_t num_witnesses = db.get_global_properties().active_witnesses.size();
|
|
size_t dmin = num_witnesses >> 1;
|
|
witness_scheduler_rng rng(
|
|
// - - - - + - - - - 1 - - - - + - - - - 2 - - - - + - - -
|
|
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
|
|
);
|
|
witness_scheduler scheduler;
|
|
vector< witness_id_type > witness_ids;
|
|
|
|
witness_ids.reserve( num_witnesses );
|
|
for( size_t i=0; i<num_witnesses; i++ )
|
|
witness_ids.push_back( witness_id_type(i) );
|
|
|
|
scheduler._min_token_count = num_witnesses / 2;
|
|
|
|
scheduler.insert_all( witness_ids );
|
|
for( size_t i=0; i<num_witnesses; i++ )
|
|
scheduler.produce_schedule( rng );
|
|
|
|
vector< witness_id_type > cur_round;
|
|
vector< witness_id_type > full_schedule;
|
|
// if we make the maximum witness count testable,
|
|
// we'll need to enlarge this.
|
|
std::bitset< 0x40 > witness_seen;
|
|
size_t total_blocks = 1000000;
|
|
|
|
cur_round.reserve( num_witnesses );
|
|
full_schedule.reserve( total_blocks );
|
|
|
|
// we assert so the test doesn't continue, which would
|
|
// corrupt memory
|
|
assert( num_witnesses <= witness_seen.size() );
|
|
|
|
while( full_schedule.size() < total_blocks )
|
|
{
|
|
scheduler.produce_schedule( rng );
|
|
witness_id_type wid = scheduler.consume_schedule();
|
|
full_schedule.push_back( wid );
|
|
cur_round.push_back( wid );
|
|
if( cur_round.size() == num_witnesses )
|
|
{
|
|
// check that the current round contains exactly 1 copy
|
|
// of each witness
|
|
witness_seen.reset();
|
|
for( const witness_id_type& w : cur_round )
|
|
{
|
|
uint64_t inst = w.instance.value;
|
|
BOOST_CHECK( !witness_seen.test( inst ) );
|
|
assert( !witness_seen.test( inst ) );
|
|
witness_seen.set( inst );
|
|
}
|
|
cur_round.clear();
|
|
}
|
|
}
|
|
|
|
for( size_t i=0,m=full_schedule.size(); i<m; i++ )
|
|
{
|
|
for( size_t j=i+1,n=std::min( m, i+dmin ); j<n; j++ )
|
|
{
|
|
BOOST_CHECK( full_schedule[i] != full_schedule[j] );
|
|
assert( full_schedule[i] != full_schedule[j] );
|
|
}
|
|
}
|
|
|
|
} catch (fc::exception& e) {
|
|
edump((e.to_detail_string()));
|
|
throw;
|
|
}
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE( tapos_rollover, database_fixture )
|
|
{
|
|
try
|
|
{
|
|
ACTORS((alice)(bob));
|
|
const auto& core = asset_id_type()(db);
|
|
|
|
BOOST_TEST_MESSAGE( "Give Alice some money" );
|
|
transfer(committee_account, alice_id, asset(10000));
|
|
generate_block();
|
|
|
|
BOOST_TEST_MESSAGE( "Generate up to block 0xFF00" );
|
|
generate_blocks( 0xFF00 );
|
|
signed_transaction xfer_tx;
|
|
|
|
BOOST_TEST_MESSAGE( "Transfer money at/about 0xFF00" );
|
|
transfer_operation xfer_op;
|
|
xfer_op.from = alice_id;
|
|
xfer_op.to = bob_id;
|
|
xfer_op.amount = asset(1000);
|
|
|
|
xfer_tx.operations.push_back( xfer_op );
|
|
xfer_tx.set_expiration( db.head_block_id(), 0x1000 );
|
|
sign( xfer_tx, alice_private_key );
|
|
PUSH_TX( db, xfer_tx, 0 );
|
|
generate_block();
|
|
|
|
BOOST_TEST_MESSAGE( "Sign new tx's" );
|
|
xfer_tx.set_expiration( db.head_block_id(), 0x1000 );
|
|
xfer_tx.signatures.clear();
|
|
sign( xfer_tx, alice_private_key );
|
|
|
|
BOOST_TEST_MESSAGE( "Generate up to block 0x10010" );
|
|
generate_blocks( 0x110 );
|
|
|
|
BOOST_TEST_MESSAGE( "Transfer at/about block 0x10010 using reference block at/about 0xFF00" );
|
|
PUSH_TX( db, xfer_tx, 0 );
|
|
generate_block();
|
|
}
|
|
catch (fc::exception& e)
|
|
{
|
|
edump((e.to_detail_string()));
|
|
throw;
|
|
}
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE(bulk_discount, database_fixture)
|
|
{ try {
|
|
ACTOR(nathan);
|
|
// Give nathan ALLLLLL the money!
|
|
transfer(GRAPHENE_COMMITTEE_ACCOUNT, nathan_id, db.get_balance(GRAPHENE_COMMITTEE_ACCOUNT, asset_id_type()));
|
|
enable_fees();//GRAPHENE_BLOCKCHAIN_PRECISION*10);
|
|
upgrade_to_lifetime_member(nathan_id);
|
|
share_type new_fees;
|
|
while( nathan_id(db).statistics(db).lifetime_fees_paid + new_fees < GRAPHENE_DEFAULT_BULK_DISCOUNT_THRESHOLD_MIN )
|
|
{
|
|
transfer(nathan_id, GRAPHENE_COMMITTEE_ACCOUNT, asset(1));
|
|
new_fees += db.current_fee_schedule().calculate_fee(transfer_operation()).amount;
|
|
}
|
|
generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
|
|
enable_fees();//GRAPHENE_BLOCKCHAIN_PRECISION*10);
|
|
auto old_cashback = nathan_id(db).cashback_balance(db).balance;
|
|
|
|
transfer(nathan_id, GRAPHENE_COMMITTEE_ACCOUNT, asset(1));
|
|
generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
|
|
enable_fees();//GRAPHENE_BLOCKCHAIN_PRECISION*10);
|
|
|
|
BOOST_CHECK_EQUAL(nathan_id(db).cashback_balance(db).balance.amount.value,
|
|
old_cashback.amount.value + GRAPHENE_BLOCKCHAIN_PRECISION * 8);
|
|
|
|
new_fees = 0;
|
|
while( nathan_id(db).statistics(db).lifetime_fees_paid + new_fees < GRAPHENE_DEFAULT_BULK_DISCOUNT_THRESHOLD_MAX )
|
|
{
|
|
transfer(nathan_id, GRAPHENE_COMMITTEE_ACCOUNT, asset(1));
|
|
new_fees += db.current_fee_schedule().calculate_fee(transfer_operation()).amount;
|
|
}
|
|
generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
|
|
enable_fees();//GRAPHENE_BLOCKCHAIN_PRECISION*10);
|
|
old_cashback = nathan_id(db).cashback_balance(db).balance;
|
|
|
|
transfer(nathan_id, GRAPHENE_COMMITTEE_ACCOUNT, asset(1));
|
|
generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
|
|
|
|
BOOST_CHECK_EQUAL(nathan_id(db).cashback_balance(db).balance.amount.value,
|
|
old_cashback.amount.value + GRAPHENE_BLOCKCHAIN_PRECISION * 9);
|
|
} FC_LOG_AND_RETHROW() }
|
|
|
|
BOOST_AUTO_TEST_SUITE_END()
|