Merge pull request #3391 from nanocurrency/direct_dev_key
Remove nano::genesis class
This commit is contained in:
clemahieu
GitHub
commit
59f9eeca11
38 changed files with 947 additions and 1205 deletions
|
|
@ -17,13 +17,12 @@ TEST (active_transactions, confirm_active)
|
|||
nano::node_flags node_flags;
|
||||
node_flags.disable_request_loop = true;
|
||||
auto & node1 = *system.add_node (node_flags);
|
||||
nano::genesis genesis;
|
||||
auto send = nano::send_block_builder ()
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.destination (nano::public_key ())
|
||||
.balance (nano::dev::genesis_amount - 100)
|
||||
.balance (nano::dev::constants.genesis_amount - 100)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (genesis.hash ()))
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
ASSERT_EQ (nano::process_result::progress, node1.process (*send).code);
|
||||
nano::node_config node_config2 (nano::get_available_port (), system.logging);
|
||||
|
|
@ -49,7 +48,7 @@ TEST (active_transactions, confirm_active)
|
|||
ASSERT_FALSE (peers.empty ());
|
||||
{
|
||||
nano::lock_guard<nano::mutex> guard (node2.rep_crawler.probable_reps_mutex);
|
||||
node2.rep_crawler.probable_reps.emplace (nano::dev::genesis_key.pub, nano::dev::genesis_amount, *peers.begin ());
|
||||
node2.rep_crawler.probable_reps.emplace (nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, *peers.begin ());
|
||||
}
|
||||
ASSERT_TIMELY (5s, election->votes ().size () != 1); // Votes were inserted (except for not_an_account)
|
||||
auto confirm_req_count (election->confirmation_request_count.load ());
|
||||
|
|
@ -89,19 +88,18 @@ TEST (active_transactions, confirm_frontier)
|
|||
ASSERT_FALSE (peers.empty ());
|
||||
{
|
||||
nano::lock_guard<nano::mutex> guard (node2.rep_crawler.probable_reps_mutex);
|
||||
node2.rep_crawler.probable_reps.emplace (nano::dev::genesis_key.pub, nano::dev::genesis_amount, *peers.begin ());
|
||||
node2.rep_crawler.probable_reps.emplace (nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, *peers.begin ());
|
||||
}
|
||||
|
||||
nano::genesis genesis;
|
||||
nano::state_block_builder builder;
|
||||
auto send = builder
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 100)
|
||||
.balance (nano::dev::constants.genesis_amount - 100)
|
||||
.link (nano::public_key ())
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (genesis.hash ()))
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
auto send_copy = builder.make_block ().from (*send).build_shared ();
|
||||
ASSERT_EQ (nano::process_result::progress, node1.process (*send).code);
|
||||
|
|
@ -127,7 +125,6 @@ TEST (active_transactions, keep_local)
|
|||
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
|
||||
auto & node = *system.add_node (node_config);
|
||||
auto & wallet (*system.wallet (0));
|
||||
nano::genesis genesis;
|
||||
//key 1/2 will be managed by the wallet
|
||||
nano::keypair key1, key2, key3, key4, key5, key6;
|
||||
wallet.insert_adhoc (nano::dev::genesis_key.prv);
|
||||
|
|
@ -193,7 +190,7 @@ TEST (active_transactions, inactive_votes_cache)
|
|||
auto send = nano::send_block_builder ()
|
||||
.previous (latest)
|
||||
.destination (key.pub)
|
||||
.balance (nano::dev::genesis_amount - 100)
|
||||
.balance (nano::dev::constants.genesis_amount - 100)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (latest))
|
||||
.build_shared ();
|
||||
|
|
@ -215,7 +212,7 @@ TEST (active_transactions, inactive_votes_cache_non_final)
|
|||
auto send = nano::send_block_builder ()
|
||||
.previous (latest)
|
||||
.destination (key.pub)
|
||||
.balance (nano::dev::genesis_amount - 100)
|
||||
.balance (nano::dev::constants.genesis_amount - 100)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (latest))
|
||||
.build_shared ();
|
||||
|
|
@ -228,7 +225,7 @@ TEST (active_transactions, inactive_votes_cache_non_final)
|
|||
auto election = node.active.election (send->qualified_root ());
|
||||
ASSERT_NE (nullptr, election);
|
||||
ASSERT_FALSE (election->confirmed ());
|
||||
ASSERT_EQ (nano::dev::genesis_amount - 100, election->tally ().begin ()->first);
|
||||
ASSERT_EQ (nano::dev::constants.genesis_amount - 100, election->tally ().begin ()->first);
|
||||
}
|
||||
|
||||
TEST (active_transactions, inactive_votes_cache_fork)
|
||||
|
|
@ -241,14 +238,14 @@ TEST (active_transactions, inactive_votes_cache_fork)
|
|||
auto send1 = builder.make_block ()
|
||||
.previous (latest)
|
||||
.destination (key.pub)
|
||||
.balance (nano::dev::genesis_amount - 100)
|
||||
.balance (nano::dev::constants.genesis_amount - 100)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (latest))
|
||||
.build_shared ();
|
||||
auto send2 = builder.make_block ()
|
||||
.previous (latest)
|
||||
.destination (key.pub)
|
||||
.balance (nano::dev::genesis_amount - 200)
|
||||
.balance (nano::dev::constants.genesis_amount - 200)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (latest))
|
||||
.build_shared ();
|
||||
|
|
@ -285,7 +282,7 @@ TEST (active_transactions, inactive_votes_cache_existing_vote)
|
|||
auto send = builder.send ()
|
||||
.previous (latest)
|
||||
.destination (key.pub)
|
||||
.balance (nano::dev::genesis_amount - 100 * nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - 100 * nano::Gxrb_ratio)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (latest))
|
||||
.build_shared ();
|
||||
|
|
@ -342,7 +339,7 @@ TEST (active_transactions, inactive_votes_cache_multiple_votes)
|
|||
auto send1 = builder.send ()
|
||||
.previous (latest)
|
||||
.destination (key1.pub)
|
||||
.balance (nano::dev::genesis_amount - 100 * nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - 100 * nano::Gxrb_ratio)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (latest))
|
||||
.build_shared ();
|
||||
|
|
@ -394,14 +391,14 @@ TEST (active_transactions, inactive_votes_cache_election_start)
|
|||
auto send1 = send_block_builder.make_block ()
|
||||
.previous (latest)
|
||||
.destination (key1.pub)
|
||||
.balance (nano::dev::genesis_amount - 5000 * nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - 5000 * nano::Gxrb_ratio)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (latest))
|
||||
.build_shared ();
|
||||
auto send2 = send_block_builder.make_block ()
|
||||
.previous (send1->hash ())
|
||||
.destination (key2.pub)
|
||||
.balance (nano::dev::genesis_amount - 10000 * nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - 10000 * nano::Gxrb_ratio)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (send1->hash ()))
|
||||
.build_shared ();
|
||||
|
|
@ -492,17 +489,16 @@ TEST (active_transactions, vote_replays)
|
|||
node_config.enable_voting = false;
|
||||
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
|
||||
auto & node = *system.add_node (node_config);
|
||||
nano::genesis genesis;
|
||||
nano::keypair key;
|
||||
nano::state_block_builder builder;
|
||||
auto send1 = builder.make_block ()
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (genesis.hash ()))
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
ASSERT_NE (nullptr, send1);
|
||||
auto open1 = builder.make_block ()
|
||||
|
|
@ -582,31 +578,27 @@ TEST (active_transactions, dropped_cleanup)
|
|||
flags.disable_request_loop = true;
|
||||
auto & node (*system.add_node (flags));
|
||||
|
||||
nano::genesis genesis;
|
||||
auto block = genesis.open;
|
||||
block->sideband_set (nano::block_sideband (nano::dev::genesis->account (), 0, nano::dev::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0));
|
||||
|
||||
// Add to network filter to ensure proper cleanup after the election is dropped
|
||||
std::vector<uint8_t> block_bytes;
|
||||
{
|
||||
nano::vectorstream stream (block_bytes);
|
||||
block->serialize (stream);
|
||||
nano::dev::genesis->serialize (stream);
|
||||
}
|
||||
ASSERT_FALSE (node.network.publish_filter.apply (block_bytes.data (), block_bytes.size ()));
|
||||
ASSERT_TRUE (node.network.publish_filter.apply (block_bytes.data (), block_bytes.size ()));
|
||||
|
||||
node.block_confirm (block);
|
||||
node.block_confirm (nano::dev::genesis);
|
||||
node.scheduler.flush ();
|
||||
auto election = node.active.election (block->qualified_root ());
|
||||
auto election = node.active.election (nano::dev::genesis->qualified_root ());
|
||||
ASSERT_NE (nullptr, election);
|
||||
|
||||
// Not yet removed
|
||||
ASSERT_TRUE (node.network.publish_filter.apply (block_bytes.data (), block_bytes.size ()));
|
||||
ASSERT_EQ (1, node.active.blocks.count (block->hash ()));
|
||||
ASSERT_EQ (1, node.active.blocks.count (nano::dev::genesis->hash ()));
|
||||
|
||||
// Now simulate dropping the election
|
||||
ASSERT_FALSE (election->confirmed ());
|
||||
node.active.erase (*block);
|
||||
node.active.erase (*nano::dev::genesis);
|
||||
|
||||
// The filter must have been cleared
|
||||
ASSERT_FALSE (node.network.publish_filter.apply (block_bytes.data (), block_bytes.size ()));
|
||||
|
|
@ -615,17 +607,17 @@ TEST (active_transactions, dropped_cleanup)
|
|||
ASSERT_EQ (1, node.stats.count (nano::stat::type::election, nano::stat::detail::election_drop_all));
|
||||
|
||||
// Block cleared from active
|
||||
ASSERT_EQ (0, node.active.blocks.count (block->hash ()));
|
||||
ASSERT_EQ (0, node.active.blocks.count (nano::dev::genesis->hash ()));
|
||||
|
||||
// Repeat test for a confirmed election
|
||||
ASSERT_TRUE (node.network.publish_filter.apply (block_bytes.data (), block_bytes.size ()));
|
||||
node.block_confirm (block);
|
||||
node.block_confirm (nano::dev::genesis);
|
||||
node.scheduler.flush ();
|
||||
election = node.active.election (block->qualified_root ());
|
||||
election = node.active.election (nano::dev::genesis->qualified_root ());
|
||||
ASSERT_NE (nullptr, election);
|
||||
election->force_confirm ();
|
||||
ASSERT_TRUE (election->confirmed ());
|
||||
node.active.erase (*block);
|
||||
node.active.erase (*nano::dev::genesis);
|
||||
|
||||
// The filter should not have been cleared
|
||||
ASSERT_TRUE (node.network.publish_filter.apply (block_bytes.data (), block_bytes.size ()));
|
||||
|
|
@ -634,7 +626,7 @@ TEST (active_transactions, dropped_cleanup)
|
|||
ASSERT_EQ (1, node.stats.count (nano::stat::type::election, nano::stat::detail::election_drop_all));
|
||||
|
||||
// Block cleared from active
|
||||
ASSERT_EQ (0, node.active.blocks.count (block->hash ()));
|
||||
ASSERT_EQ (0, node.active.blocks.count (nano::dev::genesis->hash ()));
|
||||
}
|
||||
|
||||
TEST (active_transactions, republish_winner)
|
||||
|
|
@ -646,17 +638,16 @@ TEST (active_transactions, republish_winner)
|
|||
node_config.peering_port = nano::get_available_port ();
|
||||
auto & node2 = *system.add_node (node_config);
|
||||
|
||||
nano::genesis genesis;
|
||||
nano::keypair key;
|
||||
nano::state_block_builder builder;
|
||||
auto send1 = builder.make_block ()
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (genesis.hash ()))
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
|
||||
node1.process_active (send1);
|
||||
|
|
@ -668,12 +659,12 @@ TEST (active_transactions, republish_winner)
|
|||
{
|
||||
auto fork = builder.make_block ()
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 1 - i)
|
||||
.balance (nano::dev::constants.genesis_amount - 1 - i)
|
||||
.link (key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (genesis.hash ()))
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
node1.process_active (fork);
|
||||
}
|
||||
|
|
@ -684,12 +675,12 @@ TEST (active_transactions, republish_winner)
|
|||
// Process new fork with vote to change winner
|
||||
auto fork = builder.make_block ()
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 2 * nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio)
|
||||
.link (key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (genesis.hash ()))
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
|
||||
node1.process_active (fork);
|
||||
|
|
@ -712,17 +703,16 @@ TEST (active_transactions, fork_filter_cleanup)
|
|||
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
|
||||
auto & node1 (*system.add_node (node_config));
|
||||
|
||||
nano::genesis genesis;
|
||||
nano::keypair key;
|
||||
nano::state_block_builder builder;
|
||||
auto send1 = builder.make_block ()
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (genesis.hash ()))
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
std::vector<uint8_t> block_bytes;
|
||||
{
|
||||
|
|
@ -735,12 +725,12 @@ TEST (active_transactions, fork_filter_cleanup)
|
|||
{
|
||||
auto fork = builder.make_block ()
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 1 - i)
|
||||
.balance (nano::dev::constants.genesis_amount - 1 - i)
|
||||
.link (key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (genesis.hash ()))
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
node1.process_active (fork);
|
||||
node1.block_processor.flush ();
|
||||
|
|
@ -771,12 +761,11 @@ TEST (active_transactions, fork_replacement_tally)
|
|||
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
|
||||
auto & node1 (*system.add_node (node_config));
|
||||
|
||||
nano::genesis genesis;
|
||||
size_t reps_count = 20;
|
||||
size_t const max_blocks = 10;
|
||||
std::vector<nano::keypair> keys (reps_count);
|
||||
auto latest (genesis.hash ());
|
||||
auto balance (nano::dev::genesis_amount);
|
||||
auto latest (nano::dev::genesis->hash ());
|
||||
auto balance (nano::dev::constants.genesis_amount);
|
||||
auto amount (node1.minimum_principal_weight ());
|
||||
nano::state_block_builder builder;
|
||||
|
||||
|
|
@ -942,13 +931,12 @@ TEST (active_transactions, confirm_new)
|
|||
{
|
||||
nano::system system (1);
|
||||
auto & node1 = *system.nodes[0];
|
||||
nano::genesis genesis;
|
||||
auto send = nano::send_block_builder ()
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.destination (nano::public_key ())
|
||||
.balance (nano::dev::genesis_amount - 100)
|
||||
.balance (nano::dev::constants.genesis_amount - 100)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (genesis.hash ()))
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
node1.process_active (send);
|
||||
node1.block_processor.flush ();
|
||||
|
|
@ -970,26 +958,25 @@ TEST (active_transactions, conflicting_block_vote_existing_election)
|
|||
nano::node_flags node_flags;
|
||||
node_flags.disable_request_loop = true;
|
||||
auto & node = *system.add_node (node_flags);
|
||||
nano::genesis genesis;
|
||||
nano::keypair key;
|
||||
nano::state_block_builder builder;
|
||||
auto send = builder.make_block ()
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 100)
|
||||
.balance (nano::dev::constants.genesis_amount - 100)
|
||||
.link (key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (genesis.hash ()))
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
auto fork = builder.make_block ()
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 200)
|
||||
.balance (nano::dev::constants.genesis_amount - 200)
|
||||
.link (key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (genesis.hash ()))
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
auto vote_fork (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits<uint64_t>::max (), fork));
|
||||
|
||||
|
|
@ -1024,7 +1011,7 @@ TEST (active_transactions, activate_account_chain)
|
|||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.link (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 1)
|
||||
.balance (nano::dev::constants.genesis_amount - 1)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build ();
|
||||
|
|
@ -1033,7 +1020,7 @@ TEST (active_transactions, activate_account_chain)
|
|||
.previous (send->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.link (key.pub)
|
||||
.balance (nano::dev::genesis_amount - 2)
|
||||
.balance (nano::dev::constants.genesis_amount - 2)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (send->hash ()))
|
||||
.build ();
|
||||
|
|
@ -1042,7 +1029,7 @@ TEST (active_transactions, activate_account_chain)
|
|||
.previous (send2->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.link (key.pub)
|
||||
.balance (nano::dev::genesis_amount - 3)
|
||||
.balance (nano::dev::constants.genesis_amount - 3)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (send2->hash ()))
|
||||
.build ();
|
||||
|
|
@ -1124,7 +1111,7 @@ TEST (active_transactions, activate_inactive)
|
|||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.link (key.pub)
|
||||
.balance (nano::dev::genesis_amount - 1)
|
||||
.balance (nano::dev::constants.genesis_amount - 1)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
|
|
@ -1133,7 +1120,7 @@ TEST (active_transactions, activate_inactive)
|
|||
.previous (send->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.link (nano::keypair ().pub)
|
||||
.balance (nano::dev::genesis_amount - 2)
|
||||
.balance (nano::dev::constants.genesis_amount - 2)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (send->hash ()))
|
||||
.build_shared ();
|
||||
|
|
@ -1185,7 +1172,7 @@ TEST (active_transactions, pessimistic_elections)
|
|||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.link (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 1)
|
||||
.balance (nano::dev::constants.genesis_amount - 1)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
|
|
@ -1197,7 +1184,7 @@ TEST (active_transactions, pessimistic_elections)
|
|||
.previous (send->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.link (key.pub)
|
||||
.balance (nano::dev::genesis_amount - 2)
|
||||
.balance (nano::dev::constants.genesis_amount - 2)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (send->hash ()))
|
||||
.build ();
|
||||
|
|
@ -1324,7 +1311,7 @@ TEST (active_transactions, list_active)
|
|||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.link (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 1)
|
||||
.balance (nano::dev::constants.genesis_amount - 1)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
|
|
@ -1336,7 +1323,7 @@ TEST (active_transactions, list_active)
|
|||
.previous (send->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.link (key.pub)
|
||||
.balance (nano::dev::genesis_amount - 2)
|
||||
.balance (nano::dev::constants.genesis_amount - 2)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (send->hash ()))
|
||||
.build_shared ();
|
||||
|
|
@ -1379,7 +1366,7 @@ TEST (active_transactions, vacancy)
|
|||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.link (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
|
|
@ -1417,7 +1404,7 @@ TEST (active_transactions, fifo)
|
|||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.link (key0.pub)
|
||||
.balance (nano::dev::genesis_amount - 1)
|
||||
.balance (nano::dev::constants.genesis_amount - 1)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
|
|
@ -1430,7 +1417,7 @@ TEST (active_transactions, fifo)
|
|||
.previous (send0->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.link (key1.pub)
|
||||
.balance (nano::dev::genesis_amount - 2)
|
||||
.balance (nano::dev::constants.genesis_amount - 2)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (send0->hash ()))
|
||||
.build_shared ();
|
||||
|
|
|
|||
|
|
@ -324,14 +324,12 @@ TEST (block_store, genesis)
|
|||
nano::logger_mt logger;
|
||||
auto store = nano::make_store (logger, nano::unique_path ());
|
||||
ASSERT_TRUE (!store->init_error ());
|
||||
nano::genesis genesis;
|
||||
auto hash (genesis.hash ());
|
||||
nano::ledger_cache ledger_cache;
|
||||
auto transaction (store->tx_begin_write ());
|
||||
store->initialize (transaction, ledger_cache);
|
||||
nano::account_info info;
|
||||
ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis->account (), info));
|
||||
ASSERT_EQ (hash, info.head);
|
||||
ASSERT_EQ (nano::dev::genesis->hash (), info.head);
|
||||
auto block1 (store->block.get (transaction, info.head));
|
||||
ASSERT_NE (nullptr, block1);
|
||||
auto receive1 (dynamic_cast<nano::open_block *> (block1.get ()));
|
||||
|
|
@ -342,7 +340,7 @@ TEST (block_store, genesis)
|
|||
nano::confirmation_height_info confirmation_height_info;
|
||||
ASSERT_FALSE (store->confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info));
|
||||
ASSERT_EQ (confirmation_height_info.height, 1);
|
||||
ASSERT_EQ (confirmation_height_info.frontier, hash);
|
||||
ASSERT_EQ (confirmation_height_info.frontier, nano::dev::genesis->hash ());
|
||||
auto dev_pub_text (nano::dev::genesis_key.pub.to_string ());
|
||||
auto dev_pub_account (nano::dev::genesis_key.pub.to_account ());
|
||||
auto dev_prv_text (nano::dev::genesis_key.prv.to_string ());
|
||||
|
|
@ -661,7 +659,6 @@ TEST (mdb_block_store, supported_version_upgrades)
|
|||
}
|
||||
// Check that upgrading from an unsupported version is not supported
|
||||
auto path (nano::unique_path ());
|
||||
nano::genesis genesis;
|
||||
nano::logger_mt logger;
|
||||
{
|
||||
nano::mdb_store store (logger, path);
|
||||
|
|
@ -693,7 +690,7 @@ TEST (mdb_block_store, supported_version_upgrades)
|
|||
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "accounts_v1", MDB_CREATE, &store.accounts_v1_handle));
|
||||
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks_handle));
|
||||
modify_account_info_to_v14 (store, transaction, nano::dev::genesis->account (), 1, nano::dev::genesis->hash ());
|
||||
write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::genesis ().open);
|
||||
write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::dev::genesis);
|
||||
}
|
||||
|
||||
// Upgrade should work
|
||||
|
|
@ -880,7 +877,6 @@ TEST (block_store, cemented_count_cache)
|
|||
auto store = nano::make_store (logger, nano::unique_path ());
|
||||
ASSERT_TRUE (!store->init_error ());
|
||||
auto transaction (store->tx_begin_write ());
|
||||
nano::genesis genesis;
|
||||
nano::ledger_cache ledger_cache;
|
||||
store->initialize (transaction, ledger_cache);
|
||||
ASSERT_EQ (1, ledger_cache.cemented_count);
|
||||
|
|
@ -890,8 +886,6 @@ TEST (block_store, block_random)
|
|||
{
|
||||
nano::logger_mt logger;
|
||||
auto store = nano::make_store (logger, nano::unique_path ());
|
||||
ASSERT_TRUE (!store->init_error ());
|
||||
nano::genesis genesis;
|
||||
{
|
||||
nano::ledger_cache ledger_cache;
|
||||
auto transaction (store->tx_begin_write ());
|
||||
|
|
@ -900,7 +894,7 @@ TEST (block_store, block_random)
|
|||
auto transaction (store->tx_begin_read ());
|
||||
auto block (store->block.random (transaction));
|
||||
ASSERT_NE (nullptr, block);
|
||||
ASSERT_EQ (*block, *genesis.open);
|
||||
ASSERT_EQ (*block, *nano::dev::genesis);
|
||||
}
|
||||
|
||||
TEST (block_store, pruned_random)
|
||||
|
|
@ -908,7 +902,6 @@ TEST (block_store, pruned_random)
|
|||
nano::logger_mt logger;
|
||||
auto store = nano::make_store (logger, nano::unique_path ());
|
||||
ASSERT_TRUE (!store->init_error ());
|
||||
nano::genesis genesis;
|
||||
nano::open_block block (0, 1, 0, nano::keypair ().prv, 0, 0);
|
||||
block.sideband_set ({});
|
||||
auto hash1 (block.hash ());
|
||||
|
|
@ -970,9 +963,8 @@ TEST (block_store, state_block)
|
|||
nano::logger_mt logger;
|
||||
auto store = nano::make_store (logger, nano::unique_path ());
|
||||
ASSERT_FALSE (store->init_error ());
|
||||
nano::genesis genesis;
|
||||
nano::keypair key1;
|
||||
nano::state_block block1 (1, genesis.hash (), 3, 4, 6, key1.prv, key1.pub, 7);
|
||||
nano::state_block block1 (1, nano::dev::genesis->hash (), 3, 4, 6, key1.prv, key1.pub, 7);
|
||||
block1.sideband_set ({});
|
||||
{
|
||||
nano::ledger_cache ledger_cache;
|
||||
|
|
@ -1005,7 +997,6 @@ TEST (mdb_block_store, sideband_height)
|
|||
return;
|
||||
}
|
||||
nano::logger_mt logger;
|
||||
nano::genesis genesis;
|
||||
nano::keypair key1;
|
||||
nano::keypair key2;
|
||||
nano::keypair key3;
|
||||
|
|
@ -1016,17 +1007,17 @@ TEST (mdb_block_store, sideband_height)
|
|||
auto transaction (store.tx_begin_write ());
|
||||
store.initialize (transaction, ledger.cache);
|
||||
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
|
||||
nano::send_block send (genesis.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (genesis.hash ()));
|
||||
nano::send_block send (nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
|
||||
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code);
|
||||
nano::receive_block receive (send.hash (), send.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send.hash ()));
|
||||
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive).code);
|
||||
nano::change_block change (receive.hash (), 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (receive.hash ()));
|
||||
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change).code);
|
||||
nano::state_block state_send1 (nano::dev::genesis_key.pub, change.hash (), 0, nano::dev::genesis_amount - nano::Gxrb_ratio, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (change.hash ()));
|
||||
nano::state_block state_send1 (nano::dev::genesis_key.pub, change.hash (), 0, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (change.hash ()));
|
||||
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_send1).code);
|
||||
nano::state_block state_send2 (nano::dev::genesis_key.pub, state_send1.hash (), 0, nano::dev::genesis_amount - 2 * nano::Gxrb_ratio, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_send1.hash ()));
|
||||
nano::state_block state_send2 (nano::dev::genesis_key.pub, state_send1.hash (), 0, nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_send1.hash ()));
|
||||
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_send2).code);
|
||||
nano::state_block state_send3 (nano::dev::genesis_key.pub, state_send2.hash (), 0, nano::dev::genesis_amount - 3 * nano::Gxrb_ratio, key3.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_send2.hash ()));
|
||||
nano::state_block state_send3 (nano::dev::genesis_key.pub, state_send2.hash (), 0, nano::dev::constants.genesis_amount - 3 * nano::Gxrb_ratio, key3.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_send2.hash ()));
|
||||
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_send3).code);
|
||||
nano::state_block state_open (key1.pub, 0, 0, nano::Gxrb_ratio, state_send1.hash (), key1.prv, key1.pub, *pool.generate (key1.pub));
|
||||
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_open).code);
|
||||
|
|
@ -1040,7 +1031,7 @@ TEST (mdb_block_store, sideband_height)
|
|||
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_receive).code);
|
||||
nano::open_block open (state_send3.hash (), nano::dev::genesis_key.pub, key3.pub, key3.prv, key3.pub, *pool.generate (key3.pub));
|
||||
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code);
|
||||
auto block1 (store.block.get (transaction, genesis.hash ()));
|
||||
auto block1 (store.block.get (transaction, nano::dev::genesis->hash ()));
|
||||
ASSERT_EQ (block1->sideband ().height, 1);
|
||||
auto block2 (store.block.get (transaction, send.hash ()));
|
||||
ASSERT_EQ (block2->sideband ().height, 2);
|
||||
|
|
@ -1271,12 +1262,11 @@ TEST (mdb_block_store, upgrade_v14_v15)
|
|||
}
|
||||
// Extract confirmation height to a separate database
|
||||
auto path (nano::unique_path ());
|
||||
nano::genesis genesis;
|
||||
nano::network_params network_params;
|
||||
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
|
||||
nano::send_block send (genesis.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (genesis.hash ()));
|
||||
nano::state_block epoch (nano::dev::genesis_key.pub, send.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, network_params.ledger.epochs.link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send.hash ()));
|
||||
nano::state_block state_send (nano::dev::genesis_key.pub, epoch.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch.hash ()));
|
||||
nano::send_block send (nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
|
||||
nano::state_block epoch (nano::dev::genesis_key.pub, send.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, network_params.ledger.epochs.link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send.hash ()));
|
||||
nano::state_block state_send (nano::dev::genesis_key.pub, epoch.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch.hash ()));
|
||||
{
|
||||
nano::logger_mt logger;
|
||||
nano::mdb_store store (logger, path);
|
||||
|
|
@ -1289,7 +1279,7 @@ TEST (mdb_block_store, upgrade_v14_v15)
|
|||
nano::confirmation_height_info confirmation_height_info;
|
||||
ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info));
|
||||
ASSERT_EQ (confirmation_height_info.height, 1);
|
||||
ASSERT_EQ (confirmation_height_info.frontier, genesis.hash ());
|
||||
ASSERT_EQ (confirmation_height_info.frontier, nano::dev::genesis->hash ());
|
||||
// These databases get removed after an upgrade, so readd them
|
||||
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "state_v1", MDB_CREATE, &store.state_blocks_v1_handle));
|
||||
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "accounts_v1", MDB_CREATE, &store.accounts_v1_handle));
|
||||
|
|
@ -1309,7 +1299,7 @@ TEST (mdb_block_store, upgrade_v14_v15)
|
|||
|
||||
write_sideband_v14 (store, transaction, state_send, store.state_blocks_v1_handle);
|
||||
write_sideband_v14 (store, transaction, epoch, store.state_blocks_v1_handle);
|
||||
write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *genesis.open);
|
||||
write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::dev::genesis);
|
||||
write_block_w_sideband_v18 (store, store.send_blocks_handle, transaction, send);
|
||||
|
||||
// Remove from blocks table
|
||||
|
|
@ -1347,7 +1337,7 @@ TEST (mdb_block_store, upgrade_v14_v15)
|
|||
nano::confirmation_height_info confirmation_height_info;
|
||||
ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info));
|
||||
ASSERT_EQ (confirmation_height_info.height, 1);
|
||||
ASSERT_EQ (confirmation_height_info.frontier, genesis.hash ());
|
||||
ASSERT_EQ (confirmation_height_info.frontier, nano::dev::genesis->hash ());
|
||||
|
||||
// accounts_v1, state_blocks_v1 & pending_v1 tables should be deleted
|
||||
auto error_get_accounts_v1 (mdb_get (store.env.tx (transaction), store.accounts_v1_handle, nano::mdb_val (nano::dev::genesis->account ()), value));
|
||||
|
|
@ -1385,7 +1375,6 @@ TEST (mdb_block_store, upgrade_v15_v16)
|
|||
auto path (nano::unique_path ());
|
||||
nano::mdb_val value;
|
||||
{
|
||||
nano::genesis genesis;
|
||||
nano::logger_mt logger;
|
||||
nano::mdb_store store (logger, path);
|
||||
nano::stat stats;
|
||||
|
|
@ -1398,7 +1387,7 @@ TEST (mdb_block_store, upgrade_v15_v16)
|
|||
auto weight = ledger.cache.rep_weights.representation_get (nano::dev::genesis->account ());
|
||||
ASSERT_EQ (MDB_SUCCESS, mdb_put (txn, store.representation_handle, nano::mdb_val (nano::dev::genesis->account ()), nano::mdb_val (nano::uint128_union (weight)), 0));
|
||||
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks_handle));
|
||||
write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *genesis.open);
|
||||
write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::dev::genesis);
|
||||
// Lower the database to the previous version
|
||||
store.version.put (transaction, 15);
|
||||
// Confirm the rep weight exists in the database
|
||||
|
|
@ -1428,17 +1417,15 @@ TEST (mdb_block_store, upgrade_v16_v17)
|
|||
// Don't test this in rocksdb mode
|
||||
return;
|
||||
}
|
||||
nano::genesis genesis;
|
||||
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
|
||||
nano::state_block block1 (nano::dev::genesis_key.pub, genesis.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (genesis.hash ()));
|
||||
nano::state_block block2 (nano::dev::genesis_key.pub, block1.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio - 1, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block1.hash ()));
|
||||
nano::state_block block3 (nano::dev::genesis_key.pub, block2.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio - 2, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block2.hash ()));
|
||||
nano::state_block block1 (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
|
||||
nano::state_block block2 (nano::dev::genesis_key.pub, block1.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio - 1, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block1.hash ()));
|
||||
nano::state_block block3 (nano::dev::genesis_key.pub, block2.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio - 2, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block2.hash ()));
|
||||
|
||||
auto code = [&block1, &block2, &block3] (auto confirmation_height, nano::block_hash const & expected_cemented_frontier) {
|
||||
auto path (nano::unique_path ());
|
||||
nano::mdb_val value;
|
||||
{
|
||||
nano::genesis genesis;
|
||||
nano::logger_mt logger;
|
||||
nano::mdb_store store (logger, path);
|
||||
nano::stat stats;
|
||||
|
|
@ -1451,7 +1438,7 @@ TEST (mdb_block_store, upgrade_v16_v17)
|
|||
modify_confirmation_height_to_v15 (store, transaction, nano::dev::genesis->account (), confirmation_height);
|
||||
|
||||
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks_handle));
|
||||
write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *genesis.open);
|
||||
write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::dev::genesis);
|
||||
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "state_blocks", MDB_CREATE, &store.state_blocks_handle));
|
||||
write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, block1);
|
||||
write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, block2);
|
||||
|
|
@ -1479,7 +1466,7 @@ TEST (mdb_block_store, upgrade_v16_v17)
|
|||
};
|
||||
|
||||
code (0, nano::block_hash (0));
|
||||
code (1, genesis.hash ());
|
||||
code (1, nano::dev::genesis->hash ());
|
||||
code (2, block1.hash ());
|
||||
code (3, block2.hash ());
|
||||
code (4, block3.hash ());
|
||||
|
|
@ -1493,22 +1480,21 @@ TEST (mdb_block_store, upgrade_v17_v18)
|
|||
return;
|
||||
}
|
||||
auto path (nano::unique_path ());
|
||||
nano::genesis genesis;
|
||||
nano::keypair key1;
|
||||
nano::keypair key2;
|
||||
nano::keypair key3;
|
||||
nano::network_params network_params;
|
||||
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
|
||||
nano::send_block send_zero (genesis.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (genesis.hash ()));
|
||||
nano::state_block state_receive_zero (nano::dev::genesis_key.pub, send_zero.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount, send_zero.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send_zero.hash ()));
|
||||
nano::state_block epoch (nano::dev::genesis_key.pub, state_receive_zero.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount, network_params.ledger.epochs.link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_receive_zero.hash ()));
|
||||
nano::state_block state_send (nano::dev::genesis_key.pub, epoch.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch.hash ()));
|
||||
nano::state_block state_receive (nano::dev::genesis_key.pub, state_send.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount, state_send.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_send.hash ()));
|
||||
nano::state_block state_change (nano::dev::genesis_key.pub, state_receive.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_receive.hash ()));
|
||||
nano::state_block state_send_change (nano::dev::genesis_key.pub, state_change.hash (), key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_change.hash ()));
|
||||
nano::send_block send_zero (nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
|
||||
nano::state_block state_receive_zero (nano::dev::genesis_key.pub, send_zero.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, send_zero.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send_zero.hash ()));
|
||||
nano::state_block epoch (nano::dev::genesis_key.pub, state_receive_zero.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, network_params.ledger.epochs.link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_receive_zero.hash ()));
|
||||
nano::state_block state_send (nano::dev::genesis_key.pub, epoch.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch.hash ()));
|
||||
nano::state_block state_receive (nano::dev::genesis_key.pub, state_send.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, state_send.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_send.hash ()));
|
||||
nano::state_block state_change (nano::dev::genesis_key.pub, state_receive.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_receive.hash ()));
|
||||
nano::state_block state_send_change (nano::dev::genesis_key.pub, state_change.hash (), key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_change.hash ()));
|
||||
nano::state_block epoch_first (key1.pub, 0, 0, 0, network_params.ledger.epochs.link (nano::epoch::epoch_2), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (key1.pub));
|
||||
nano::state_block state_receive2 (key1.pub, epoch_first.hash (), key1.pub, nano::Gxrb_ratio, state_send_change.hash (), key1.prv, key1.pub, *pool.generate (epoch_first.hash ()));
|
||||
nano::state_block state_send2 (nano::dev::genesis_key.pub, state_send_change.hash (), key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio * 2, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_send_change.hash ()));
|
||||
nano::state_block state_send2 (nano::dev::genesis_key.pub, state_send_change.hash (), key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_send_change.hash ()));
|
||||
nano::state_block state_open (key2.pub, 0, key2.pub, nano::Gxrb_ratio, state_send2.hash (), key2.prv, key2.pub, *pool.generate (key2.pub));
|
||||
nano::state_block state_send_epoch_link (key2.pub, state_open.hash (), key2.pub, 0, network_params.ledger.epochs.link (nano::epoch::epoch_2), key2.prv, key2.pub, *pool.generate (state_open.hash ()));
|
||||
{
|
||||
|
|
@ -1542,7 +1528,7 @@ TEST (mdb_block_store, upgrade_v17_v18)
|
|||
write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, epoch_first);
|
||||
write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, state_send2);
|
||||
write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, state_send_epoch_link);
|
||||
write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *genesis.open);
|
||||
write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::dev::genesis);
|
||||
write_block_w_sideband_v18 (store, store.send_blocks_handle, transaction, send_zero);
|
||||
|
||||
// Replace with the previous sideband version for state blocks
|
||||
|
|
@ -1700,15 +1686,14 @@ TEST (mdb_block_store, upgrade_v18_v19)
|
|||
nano::keypair key1;
|
||||
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
|
||||
nano::network_params network_params;
|
||||
nano::send_block send (nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
|
||||
nano::send_block send (nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
|
||||
nano::receive_block receive (send.hash (), send.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send.hash ()));
|
||||
nano::change_block change (receive.hash (), 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (receive.hash ()));
|
||||
nano::state_block state_epoch (nano::dev::genesis_key.pub, change.hash (), 0, nano::dev::genesis_amount, network_params.ledger.epochs.link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (change.hash ()));
|
||||
nano::state_block state_send (nano::dev::genesis_key.pub, state_epoch.hash (), 0, nano::dev::genesis_amount - nano::Gxrb_ratio, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_epoch.hash ()));
|
||||
nano::state_block state_epoch (nano::dev::genesis_key.pub, change.hash (), 0, nano::dev::constants.genesis_amount, network_params.ledger.epochs.link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (change.hash ()));
|
||||
nano::state_block state_send (nano::dev::genesis_key.pub, state_epoch.hash (), 0, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_epoch.hash ()));
|
||||
nano::state_block state_open (key1.pub, 0, 0, nano::Gxrb_ratio, state_send.hash (), key1.prv, key1.pub, *pool.generate (key1.pub));
|
||||
|
||||
{
|
||||
nano::genesis genesis;
|
||||
nano::logger_mt logger;
|
||||
nano::mdb_store store (logger, path);
|
||||
nano::stat stats;
|
||||
|
|
@ -1732,7 +1717,7 @@ TEST (mdb_block_store, upgrade_v18_v19)
|
|||
ASSERT_FALSE (mdb_dbi_open (txn, "state_blocks", MDB_CREATE, &store.state_blocks_handle));
|
||||
|
||||
// Modify blocks back to the old tables
|
||||
write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *genesis.open);
|
||||
write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::dev::genesis);
|
||||
write_block_w_sideband_v18 (store, store.send_blocks_handle, transaction, send);
|
||||
write_block_w_sideband_v18 (store, store.receive_blocks_handle, transaction, receive);
|
||||
write_block_w_sideband_v18 (store, store.change_blocks_handle, transaction, change);
|
||||
|
|
@ -1790,7 +1775,6 @@ TEST (mdb_block_store, upgrade_v19_v20)
|
|||
return;
|
||||
}
|
||||
auto path (nano::unique_path ());
|
||||
nano::genesis genesis;
|
||||
nano::logger_mt logger;
|
||||
nano::stat stats;
|
||||
{
|
||||
|
|
@ -1820,7 +1804,6 @@ TEST (mdb_block_store, upgrade_v20_v21)
|
|||
return;
|
||||
}
|
||||
auto path (nano::unique_path ());
|
||||
nano::genesis genesis;
|
||||
nano::logger_mt logger;
|
||||
nano::stat stats;
|
||||
{
|
||||
|
|
@ -1867,7 +1850,6 @@ TEST (mdb_block_store, upgrade_backup)
|
|||
|
||||
{
|
||||
nano::logger_mt logger;
|
||||
nano::genesis genesis;
|
||||
nano::mdb_store store (logger, path);
|
||||
auto transaction (store.tx_begin_write ());
|
||||
store.version.put (transaction, 14);
|
||||
|
|
@ -1942,7 +1924,7 @@ TEST (block_store, final_vote)
|
|||
auto store = nano::make_store (logger, path);
|
||||
|
||||
{
|
||||
auto qualified_root = nano::genesis ().open->qualified_root ();
|
||||
auto qualified_root = nano::dev::genesis->qualified_root ();
|
||||
auto transaction (store->tx_begin_write ());
|
||||
store->final_vote.put (transaction, qualified_root, nano::block_hash (2));
|
||||
ASSERT_EQ (store->final_vote.count (transaction), 1);
|
||||
|
|
|
|||
|
|
@ -64,10 +64,9 @@ TEST (bulk_pull, end_not_owned)
|
|||
system.nodes[0]->work_generate_blocking (open);
|
||||
ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (open).code);
|
||||
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
|
||||
nano::genesis genesis;
|
||||
auto req = std::make_unique<nano::bulk_pull> ();
|
||||
req->start = key2.pub;
|
||||
req->end = genesis.hash ();
|
||||
req->end = nano::dev::genesis->hash ();
|
||||
connection->requests.push (std::unique_ptr<nano::message>{});
|
||||
auto request (std::make_shared<nano::bulk_pull_server> (connection, std::move (req)));
|
||||
ASSERT_EQ (request->current, request->request->end);
|
||||
|
|
@ -77,10 +76,9 @@ TEST (bulk_pull, none)
|
|||
{
|
||||
nano::system system (1);
|
||||
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
|
||||
nano::genesis genesis;
|
||||
auto req = std::make_unique<nano::bulk_pull> ();
|
||||
req->start = nano::dev::genesis_key.pub;
|
||||
req->end = genesis.hash ();
|
||||
req->end = nano::dev::genesis->hash ();
|
||||
connection->requests.push (std::unique_ptr<nano::message>{});
|
||||
auto request (std::make_shared<nano::bulk_pull_server> (connection, std::move (req)));
|
||||
auto block (request->get_next ());
|
||||
|
|
@ -107,15 +105,14 @@ TEST (bulk_pull, by_block)
|
|||
{
|
||||
nano::system system (1);
|
||||
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
|
||||
nano::genesis genesis;
|
||||
auto req = std::make_unique<nano::bulk_pull> ();
|
||||
req->start = genesis.hash ();
|
||||
req->start = nano::dev::genesis->hash ();
|
||||
req->end.clear ();
|
||||
connection->requests.push (std::unique_ptr<nano::message>{});
|
||||
auto request (std::make_shared<nano::bulk_pull_server> (connection, std::move (req)));
|
||||
auto block (request->get_next ());
|
||||
ASSERT_NE (nullptr, block);
|
||||
ASSERT_EQ (block->hash (), genesis.hash ());
|
||||
ASSERT_EQ (block->hash (), nano::dev::genesis->hash ());
|
||||
|
||||
block = request->get_next ();
|
||||
ASSERT_EQ (nullptr, block);
|
||||
|
|
@ -125,15 +122,14 @@ TEST (bulk_pull, by_block_single)
|
|||
{
|
||||
nano::system system (1);
|
||||
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
|
||||
nano::genesis genesis;
|
||||
auto req = std::make_unique<nano::bulk_pull> ();
|
||||
req->start = genesis.hash ();
|
||||
req->end = genesis.hash ();
|
||||
req->start = nano::dev::genesis->hash ();
|
||||
req->end = nano::dev::genesis->hash ();
|
||||
connection->requests.push (std::unique_ptr<nano::message>{});
|
||||
auto request (std::make_shared<nano::bulk_pull_server> (connection, std::move (req)));
|
||||
auto block (request->get_next ());
|
||||
ASSERT_NE (nullptr, block);
|
||||
ASSERT_EQ (block->hash (), genesis.hash ());
|
||||
ASSERT_EQ (block->hash (), nano::dev::genesis->hash ());
|
||||
|
||||
block = request->get_next ();
|
||||
ASSERT_EQ (nullptr, block);
|
||||
|
|
@ -143,7 +139,6 @@ TEST (bulk_pull, count_limit)
|
|||
{
|
||||
nano::system system (1);
|
||||
auto node0 (system.nodes[0]);
|
||||
nano::genesis genesis;
|
||||
|
||||
auto send1 (std::make_shared<nano::send_block> (node0->latest (nano::dev::genesis_key.pub), nano::dev::genesis_key.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (node0->latest (nano::dev::genesis_key.pub))));
|
||||
ASSERT_EQ (nano::process_result::progress, node0->process (*send1).code);
|
||||
|
|
@ -248,7 +243,6 @@ TEST (bootstrap_processor, process_state)
|
|||
nano::node_flags node_flags;
|
||||
node_flags.disable_bootstrap_bulk_push_client = true;
|
||||
auto node0 (system.add_node (config, node_flags));
|
||||
nano::genesis genesis;
|
||||
nano::state_block_builder builder;
|
||||
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
|
|
@ -256,7 +250,7 @@ TEST (bootstrap_processor, process_state)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (node0->latest (nano::dev::genesis_key.pub))
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 100)
|
||||
.balance (nano::dev::constants.genesis_amount - 100)
|
||||
.link (nano::dev::genesis_key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (0)
|
||||
|
|
@ -266,7 +260,7 @@ TEST (bootstrap_processor, process_state)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (block1->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount)
|
||||
.balance (nano::dev::constants.genesis_amount)
|
||||
.link (block1->hash ())
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (0)
|
||||
|
|
@ -353,19 +347,18 @@ TEST (bootstrap_processor, DISABLED_pull_requeue_network_error)
|
|||
auto node1 (system.add_node (config, node_flags));
|
||||
config.peering_port = nano::get_available_port ();
|
||||
auto node2 (system.add_node (config, node_flags));
|
||||
nano::genesis genesis;
|
||||
nano::keypair key1;
|
||||
|
||||
nano::state_block_builder builder;
|
||||
|
||||
auto send1 = builder
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (key1.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (genesis.hash ()))
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
|
||||
node1->bootstrap_initiator.bootstrap (node2->network.endpoint ());
|
||||
|
|
@ -377,7 +370,7 @@ TEST (bootstrap_processor, DISABLED_pull_requeue_network_error)
|
|||
nano::unique_lock<nano::mutex> lock (node1->bootstrap_initiator.connections->mutex);
|
||||
ASSERT_FALSE (attempt->stopped);
|
||||
++attempt->pulling;
|
||||
node1->bootstrap_initiator.connections->pulls.emplace_back (nano::dev::genesis_key.pub, send1->hash (), genesis.hash (), attempt->incremental_id);
|
||||
node1->bootstrap_initiator.connections->pulls.emplace_back (nano::dev::genesis_key.pub, send1->hash (), nano::dev::genesis->hash (), attempt->incremental_id);
|
||||
node1->bootstrap_initiator.connections->request_pull (lock);
|
||||
node2->stop ();
|
||||
}
|
||||
|
|
@ -431,7 +424,7 @@ TEST (bootstrap_processor, push_diamond_pruning)
|
|||
ASSERT_EQ (nano::process_result::progress, node1->process (*open).code);
|
||||
// 1st bootstrap
|
||||
node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false);
|
||||
ASSERT_TIMELY (10s, node0->balance (key.pub) == nano::dev::genesis_amount);
|
||||
ASSERT_TIMELY (10s, node0->balance (key.pub) == nano::dev::constants.genesis_amount);
|
||||
// Process more blocks & prune old
|
||||
auto send2 (std::make_shared<nano::send_block> (open->hash (), nano::dev::genesis_key.pub, std::numeric_limits<nano::uint128_t>::max () - 100, key.prv, key.pub, *system.work.generate (open->hash ())));
|
||||
ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code);
|
||||
|
|
@ -486,7 +479,6 @@ TEST (bootstrap_processor, lazy_hash)
|
|||
nano::node_flags node_flags;
|
||||
node_flags.disable_bootstrap_bulk_push_client = true;
|
||||
auto node0 (system.add_node (config, node_flags));
|
||||
nano::genesis genesis;
|
||||
nano::keypair key1;
|
||||
nano::keypair key2;
|
||||
// Generating test chain
|
||||
|
|
@ -495,12 +487,12 @@ TEST (bootstrap_processor, lazy_hash)
|
|||
|
||||
auto send1 = builder
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (key1.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*node0->work_generate_blocking (genesis.hash ()))
|
||||
.work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
auto receive1 = builder
|
||||
.make_block ()
|
||||
|
|
@ -561,7 +553,6 @@ TEST (bootstrap_processor, lazy_hash_bootstrap_id)
|
|||
nano::node_flags node_flags;
|
||||
node_flags.disable_bootstrap_bulk_push_client = true;
|
||||
auto node0 (system.add_node (config, node_flags));
|
||||
nano::genesis genesis;
|
||||
nano::keypair key1;
|
||||
nano::keypair key2;
|
||||
// Generating test chain
|
||||
|
|
@ -570,12 +561,12 @@ TEST (bootstrap_processor, lazy_hash_bootstrap_id)
|
|||
|
||||
auto send1 = builder
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (key1.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*node0->work_generate_blocking (genesis.hash ()))
|
||||
.work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
auto receive1 = builder
|
||||
.make_block ()
|
||||
|
|
@ -638,7 +629,6 @@ TEST (bootstrap_processor, lazy_hash_pruning)
|
|||
node_flags.disable_bootstrap_bulk_push_client = true;
|
||||
node_flags.enable_pruning = true;
|
||||
auto node0 (system.add_node (config, node_flags));
|
||||
nano::genesis genesis;
|
||||
nano::keypair key1;
|
||||
nano::keypair key2;
|
||||
// Generating test chain
|
||||
|
|
@ -647,19 +637,19 @@ TEST (bootstrap_processor, lazy_hash_pruning)
|
|||
|
||||
auto send1 = builder
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (nano::dev::genesis_key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*node0->work_generate_blocking (genesis.hash ()))
|
||||
.work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
auto receive1 = builder
|
||||
.make_block ()
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (send1->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount)
|
||||
.balance (nano::dev::constants.genesis_amount)
|
||||
.link (send1->hash ())
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*node0->work_generate_blocking (send1->hash ()))
|
||||
|
|
@ -669,7 +659,7 @@ TEST (bootstrap_processor, lazy_hash_pruning)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (receive1->hash ())
|
||||
.representative (key1.pub)
|
||||
.balance (nano::dev::genesis_amount)
|
||||
.balance (nano::dev::constants.genesis_amount)
|
||||
.link (0)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*node0->work_generate_blocking (receive1->hash ()))
|
||||
|
|
@ -679,7 +669,7 @@ TEST (bootstrap_processor, lazy_hash_pruning)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (change1->hash ())
|
||||
.representative (key2.pub)
|
||||
.balance (nano::dev::genesis_amount)
|
||||
.balance (nano::dev::constants.genesis_amount)
|
||||
.link (0)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*node0->work_generate_blocking (change1->hash ()))
|
||||
|
|
@ -689,7 +679,7 @@ TEST (bootstrap_processor, lazy_hash_pruning)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (change2->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (key1.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*node0->work_generate_blocking (change2->hash ()))
|
||||
|
|
@ -772,7 +762,6 @@ TEST (bootstrap_processor, lazy_max_pull_count)
|
|||
nano::node_flags node_flags;
|
||||
node_flags.disable_bootstrap_bulk_push_client = true;
|
||||
auto node0 (system.add_node (config, node_flags));
|
||||
nano::genesis genesis;
|
||||
nano::keypair key1;
|
||||
nano::keypair key2;
|
||||
// Generating test chain
|
||||
|
|
@ -781,12 +770,12 @@ TEST (bootstrap_processor, lazy_max_pull_count)
|
|||
|
||||
auto send1 = builder
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (key1.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*node0->work_generate_blocking (genesis.hash ()))
|
||||
.work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
auto receive1 = builder
|
||||
.make_block ()
|
||||
|
|
@ -876,7 +865,6 @@ TEST (bootstrap_processor, lazy_unclear_state_link)
|
|||
node_flags.disable_bootstrap_bulk_push_client = true;
|
||||
node_flags.disable_legacy_bootstrap = true;
|
||||
auto node1 = system.add_node (config, node_flags);
|
||||
nano::genesis genesis;
|
||||
nano::keypair key;
|
||||
// Generating test chain
|
||||
|
||||
|
|
@ -884,12 +872,12 @@ TEST (bootstrap_processor, lazy_unclear_state_link)
|
|||
|
||||
auto send1 = builder
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (genesis.hash ()))
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code);
|
||||
auto send2 = builder
|
||||
|
|
@ -897,7 +885,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (send1->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 2 * nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio)
|
||||
.link (key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (send1->hash ()))
|
||||
|
|
@ -939,7 +927,6 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing)
|
|||
node_flags.disable_bootstrap_bulk_push_client = true;
|
||||
node_flags.disable_legacy_bootstrap = true;
|
||||
auto node1 = system.add_node (config, node_flags);
|
||||
nano::genesis genesis;
|
||||
nano::keypair key, key2;
|
||||
// Generating test chain
|
||||
|
||||
|
|
@ -947,12 +934,12 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing)
|
|||
|
||||
auto send1 = builder
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (genesis.hash ()))
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code);
|
||||
auto open (std::make_shared<nano::open_block> (send1->hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)));
|
||||
|
|
@ -991,7 +978,6 @@ TEST (bootstrap_processor, DISABLED_lazy_destinations)
|
|||
node_flags.disable_bootstrap_bulk_push_client = true;
|
||||
node_flags.disable_legacy_bootstrap = true;
|
||||
auto node1 = system.add_node (config, node_flags);
|
||||
nano::genesis genesis;
|
||||
nano::keypair key1, key2;
|
||||
// Generating test chain
|
||||
|
||||
|
|
@ -999,12 +985,12 @@ TEST (bootstrap_processor, DISABLED_lazy_destinations)
|
|||
|
||||
auto send1 = builder
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (key1.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (genesis.hash ()))
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code);
|
||||
auto send2 = builder
|
||||
|
|
@ -1012,7 +998,7 @@ TEST (bootstrap_processor, DISABLED_lazy_destinations)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (send1->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 2 * nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio)
|
||||
.link (key2.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (send1->hash ()))
|
||||
|
|
@ -1056,7 +1042,6 @@ TEST (bootstrap_processor, lazy_pruning_missing_block)
|
|||
node_flags.disable_legacy_bootstrap = true;
|
||||
node_flags.enable_pruning = true;
|
||||
auto node1 = system.add_node (config, node_flags);
|
||||
nano::genesis genesis;
|
||||
nano::keypair key1, key2;
|
||||
// Generating test chain
|
||||
|
||||
|
|
@ -1064,12 +1049,12 @@ TEST (bootstrap_processor, lazy_pruning_missing_block)
|
|||
|
||||
auto send1 = builder
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (key1.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (genesis.hash ()))
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
node1->process_active (send1);
|
||||
auto send2 = builder
|
||||
|
|
@ -1077,7 +1062,7 @@ TEST (bootstrap_processor, lazy_pruning_missing_block)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (send1->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 2 * nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio)
|
||||
.link (key2.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (send1->hash ()))
|
||||
|
|
@ -1151,7 +1136,6 @@ TEST (bootstrap_processor, lazy_cancel)
|
|||
nano::node_flags node_flags;
|
||||
node_flags.disable_bootstrap_bulk_push_client = true;
|
||||
auto node0 (system.add_node (config, node_flags));
|
||||
nano::genesis genesis;
|
||||
nano::keypair key1;
|
||||
// Generating test chain
|
||||
|
||||
|
|
@ -1159,12 +1143,12 @@ TEST (bootstrap_processor, lazy_cancel)
|
|||
|
||||
auto send1 = builder
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (key1.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*node0->work_generate_blocking (genesis.hash ()))
|
||||
.work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
|
||||
// Start lazy bootstrap with last block in chain known
|
||||
|
|
@ -1190,7 +1174,6 @@ TEST (bootstrap_processor, wallet_lazy_frontier)
|
|||
node_flags.disable_bootstrap_bulk_push_client = true;
|
||||
node_flags.disable_legacy_bootstrap = true;
|
||||
auto node0 = system.add_node (config, node_flags);
|
||||
nano::genesis genesis;
|
||||
nano::keypair key1;
|
||||
nano::keypair key2;
|
||||
// Generating test chain
|
||||
|
|
@ -1199,12 +1182,12 @@ TEST (bootstrap_processor, wallet_lazy_frontier)
|
|||
|
||||
auto send1 = builder
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (key1.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*node0->work_generate_blocking (genesis.hash ()))
|
||||
.work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
auto receive1 = builder
|
||||
.make_block ()
|
||||
|
|
@ -1269,7 +1252,6 @@ TEST (bootstrap_processor, wallet_lazy_pending)
|
|||
node_flags.disable_bootstrap_bulk_push_client = true;
|
||||
node_flags.disable_legacy_bootstrap = true;
|
||||
auto node0 = system.add_node (config, node_flags);
|
||||
nano::genesis genesis;
|
||||
nano::keypair key1;
|
||||
nano::keypair key2;
|
||||
// Generating test chain
|
||||
|
|
@ -1278,12 +1260,12 @@ TEST (bootstrap_processor, wallet_lazy_pending)
|
|||
|
||||
auto send1 = builder
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (key1.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*node0->work_generate_blocking (genesis.hash ()))
|
||||
.work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
auto receive1 = builder
|
||||
.make_block ()
|
||||
|
|
@ -1331,7 +1313,6 @@ TEST (bootstrap_processor, multiple_attempts)
|
|||
nano::node_flags node_flags;
|
||||
node_flags.disable_bootstrap_bulk_push_client = true;
|
||||
auto node1 = system.add_node (config, node_flags);
|
||||
nano::genesis genesis;
|
||||
nano::keypair key1;
|
||||
nano::keypair key2;
|
||||
// Generating test chain
|
||||
|
|
@ -1340,12 +1321,12 @@ TEST (bootstrap_processor, multiple_attempts)
|
|||
|
||||
auto send1 = builder
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (key1.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*node1->work_generate_blocking (genesis.hash ()))
|
||||
.work (*node1->work_generate_blocking (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
auto receive1 = builder
|
||||
.make_block ()
|
||||
|
|
@ -1434,8 +1415,7 @@ TEST (frontier_req, begin)
|
|||
connection->requests.push (std::unique_ptr<nano::message>{});
|
||||
auto request (std::make_shared<nano::frontier_req_server> (connection, std::move (req)));
|
||||
ASSERT_EQ (nano::dev::genesis_key.pub, request->current);
|
||||
nano::genesis genesis;
|
||||
ASSERT_EQ (genesis.hash (), request->frontier);
|
||||
ASSERT_EQ (nano::dev::genesis->hash (), request->frontier);
|
||||
}
|
||||
|
||||
TEST (frontier_req, end)
|
||||
|
|
@ -1455,16 +1435,15 @@ TEST (frontier_req, count)
|
|||
{
|
||||
nano::system system (1);
|
||||
auto node1 = system.nodes[0];
|
||||
nano::genesis genesis;
|
||||
// Public key FB93... after genesis in accounts table
|
||||
nano::keypair key1 ("ED5AE0A6505B14B67435C29FD9FEEBC26F597D147BC92F6D795FFAD7AFD3D967");
|
||||
nano::state_block_builder builder;
|
||||
|
||||
auto send1 = builder
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (key1.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (0)
|
||||
|
|
@ -1529,8 +1508,7 @@ TEST (frontier_req, time_cutoff)
|
|||
connection->requests.push (std::unique_ptr<nano::message>{});
|
||||
auto request (std::make_shared<nano::frontier_req_server> (connection, std::move (req)));
|
||||
ASSERT_EQ (nano::dev::genesis_key.pub, request->current);
|
||||
nano::genesis genesis;
|
||||
ASSERT_EQ (genesis.hash (), request->frontier);
|
||||
ASSERT_EQ (nano::dev::genesis->hash (), request->frontier);
|
||||
// Wait 4 seconds until age of account will be > 3 seconds
|
||||
std::this_thread::sleep_for (std::chrono::milliseconds (4100));
|
||||
auto req2 (std::make_unique<nano::frontier_req> ());
|
||||
|
|
@ -1547,7 +1525,6 @@ TEST (frontier_req, confirmed_frontier)
|
|||
{
|
||||
nano::system system (1);
|
||||
auto node1 = system.nodes[0];
|
||||
nano::genesis genesis;
|
||||
nano::raw_key priv_key;
|
||||
// Public key before genesis in accounts table
|
||||
while (nano::pub_key (priv_key).number () >= nano::dev::genesis_key.pub.number ())
|
||||
|
|
@ -1565,9 +1542,9 @@ TEST (frontier_req, confirmed_frontier)
|
|||
|
||||
auto send1 = builder
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (key_before_genesis.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (0)
|
||||
|
|
@ -1579,7 +1556,7 @@ TEST (frontier_req, confirmed_frontier)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (send1->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 2 * nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio)
|
||||
.link (key_after_genesis.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (0)
|
||||
|
|
@ -1623,7 +1600,7 @@ TEST (frontier_req, confirmed_frontier)
|
|||
connection->requests.push (std::unique_ptr<nano::message>{});
|
||||
auto request (std::make_shared<nano::frontier_req_server> (connection, std::move (req)));
|
||||
ASSERT_EQ (nano::dev::genesis_key.pub, request->current);
|
||||
ASSERT_EQ (genesis.hash (), request->frontier);
|
||||
ASSERT_EQ (nano::dev::genesis->hash (), request->frontier);
|
||||
|
||||
// Request starting with account before genesis (confirmed only)
|
||||
auto connection2 (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node1), node1));
|
||||
|
|
@ -1637,7 +1614,7 @@ TEST (frontier_req, confirmed_frontier)
|
|||
connection2->requests.push (std::unique_ptr<nano::message>{});
|
||||
auto request2 (std::make_shared<nano::frontier_req_server> (connection2, std::move (req2)));
|
||||
ASSERT_EQ (nano::dev::genesis_key.pub, request2->current);
|
||||
ASSERT_EQ (genesis.hash (), request2->frontier);
|
||||
ASSERT_EQ (nano::dev::genesis->hash (), request2->frontier);
|
||||
|
||||
// Request starting with account after genesis (confirmed only)
|
||||
auto connection3 (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node1), node1));
|
||||
|
|
|
|||
|
|
@ -223,13 +223,12 @@ TEST (confirmation_height, gap_bootstrap)
|
|||
nano::node_flags node_flags;
|
||||
node_flags.confirmation_height_processor_mode = mode_a;
|
||||
auto & node1 = *system.add_node (node_flags);
|
||||
nano::genesis genesis;
|
||||
nano::keypair destination;
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::dev::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
node1.work_generate_blocking (*send1);
|
||||
auto send2 (std::make_shared<nano::state_block> (nano::dev::genesis->account (), send1->hash (), nano::dev::genesis->account (), nano::dev::genesis_amount - 2 * nano::Gxrb_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
auto send2 (std::make_shared<nano::state_block> (nano::dev::genesis->account (), send1->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
node1.work_generate_blocking (*send2);
|
||||
auto send3 (std::make_shared<nano::state_block> (nano::dev::genesis->account (), send2->hash (), nano::dev::genesis->account (), nano::dev::genesis_amount - 3 * nano::Gxrb_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
auto send3 (std::make_shared<nano::state_block> (nano::dev::genesis->account (), send2->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - 3 * nano::Gxrb_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
node1.work_generate_blocking (*send3);
|
||||
auto open1 (std::make_shared<nano::open_block> (send1->hash (), destination.pub, destination.pub, destination.prv, destination.pub, 0));
|
||||
node1.work_generate_blocking (*open1);
|
||||
|
|
@ -261,7 +260,7 @@ TEST (confirmation_height, gap_bootstrap)
|
|||
nano::confirmation_height_info confirmation_height_info;
|
||||
ASSERT_FALSE (node1.store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info));
|
||||
ASSERT_EQ (1, confirmation_height_info.height);
|
||||
ASSERT_EQ (genesis.hash (), confirmation_height_info.frontier);
|
||||
ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier);
|
||||
}
|
||||
|
||||
// Now complete the chain where the block comes in on the bootstrap network.
|
||||
|
|
@ -277,7 +276,7 @@ TEST (confirmation_height, gap_bootstrap)
|
|||
nano::confirmation_height_info confirmation_height_info;
|
||||
ASSERT_FALSE (node1.store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info));
|
||||
ASSERT_EQ (1, confirmation_height_info.height);
|
||||
ASSERT_EQ (genesis.hash (), confirmation_height_info.frontier);
|
||||
ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier);
|
||||
ASSERT_TRUE (node1.store.confirmation_height.get (transaction, destination.pub, confirmation_height_info));
|
||||
ASSERT_EQ (0, confirmation_height_info.height);
|
||||
ASSERT_EQ (nano::block_hash (0), confirmation_height_info.frontier);
|
||||
|
|
@ -304,18 +303,17 @@ TEST (confirmation_height, gap_live)
|
|||
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
|
||||
auto node = system.add_node (node_config, node_flags);
|
||||
node_config.peering_port = nano::get_available_port ();
|
||||
node_config.receive_minimum = nano::dev::genesis_amount; // Prevent auto-receive & open1/receive1/receive2 blocks conflicts
|
||||
node_config.receive_minimum = nano::dev::constants.genesis_amount; // Prevent auto-receive & open1/receive1/receive2 blocks conflicts
|
||||
system.add_node (node_config, node_flags);
|
||||
nano::keypair destination;
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
system.wallet (1)->insert_adhoc (destination.prv);
|
||||
|
||||
nano::genesis genesis;
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::dev::genesis_amount - 1, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - 1, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
node->work_generate_blocking (*send1);
|
||||
auto send2 (std::make_shared<nano::state_block> (nano::dev::genesis->account (), send1->hash (), nano::dev::genesis->account (), nano::dev::genesis_amount - 2, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
auto send2 (std::make_shared<nano::state_block> (nano::dev::genesis->account (), send1->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - 2, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
node->work_generate_blocking (*send2);
|
||||
auto send3 (std::make_shared<nano::state_block> (nano::dev::genesis->account (), send2->hash (), nano::dev::genesis->account (), nano::dev::genesis_amount - 3, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
auto send3 (std::make_shared<nano::state_block> (nano::dev::genesis->account (), send2->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - 3, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
node->work_generate_blocking (*send3);
|
||||
|
||||
auto open1 (std::make_shared<nano::open_block> (send1->hash (), destination.pub, destination.pub, destination.prv, destination.pub, 0));
|
||||
|
|
@ -478,10 +476,10 @@ TEST (confirmation_height, send_receive_self)
|
|||
auto node = system.add_node (node_config, node_flags);
|
||||
nano::block_hash latest (node->latest (nano::dev::genesis_key.pub));
|
||||
|
||||
nano::send_block send1 (latest, nano::dev::genesis_key.pub, nano::dev::genesis_amount - 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
nano::send_block send1 (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
nano::receive_block receive1 (send1.hash (), send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ()));
|
||||
nano::send_block send2 (receive1.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive1.hash ()));
|
||||
nano::send_block send3 (send2.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2.hash ()));
|
||||
nano::send_block send2 (receive1.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive1.hash ()));
|
||||
nano::send_block send3 (send2.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2.hash ()));
|
||||
|
||||
nano::receive_block receive2 (send3.hash (), send2.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send3.hash ()));
|
||||
auto receive3 = std::make_shared<nano::receive_block> (receive2.hash (), send3.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive2.hash ()));
|
||||
|
|
@ -543,8 +541,8 @@ TEST (confirmation_height, all_block_types)
|
|||
nano::keypair key1;
|
||||
nano::keypair key2;
|
||||
auto & store = node->store;
|
||||
nano::send_block send (latest, key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
nano::send_block send1 (send.hash (), key2.pub, nano::dev::genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ()));
|
||||
nano::send_block send (latest, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
nano::send_block send1 (send.hash (), key2.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ()));
|
||||
|
||||
nano::open_block open (send.hash (), nano::dev::genesis_key.pub, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub));
|
||||
nano::state_block state_open (key2.pub, 0, 0, nano::Gxrb_ratio, send1.hash (), key2.prv, key2.pub, *system.work.generate (key2.pub));
|
||||
|
|
@ -569,7 +567,7 @@ TEST (confirmation_height, all_block_types)
|
|||
nano::state_block state_send3 (key2.pub, state_send2->hash (), 0, nano::Gxrb_ratio - 1, key1.pub, key2.prv, key2.pub, *system.work.generate (state_send2->hash ()));
|
||||
|
||||
nano::state_block state_send4 (key1.pub, state_send1.hash (), 0, nano::Gxrb_ratio - 2, nano::dev::genesis_key.pub, key1.prv, key1.pub, *system.work.generate (state_send1.hash ()));
|
||||
nano::state_block state_receive3 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::genesis_amount - nano::Gxrb_ratio * 2 + 1, state_send4.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ()));
|
||||
nano::state_block state_receive3 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2 + 1, state_send4.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ()));
|
||||
|
||||
{
|
||||
auto transaction (store.tx_begin_write ());
|
||||
|
|
@ -655,11 +653,10 @@ TEST (confirmation_height, conflict_rollback_cemented)
|
|||
auto node2 = system.add_node (node_flags);
|
||||
ASSERT_EQ (1, node1->network.size ());
|
||||
nano::keypair key1;
|
||||
nano::genesis genesis;
|
||||
auto send1 (std::make_shared<nano::send_block> (genesis.hash (), key1.pub, nano::dev::genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis.hash ())));
|
||||
auto send1 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
|
||||
nano::publish publish1 (send1);
|
||||
nano::keypair key2;
|
||||
auto send2 (std::make_shared<nano::send_block> (genesis.hash (), key2.pub, nano::dev::genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis.hash ())));
|
||||
auto send2 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key2.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
|
||||
nano::publish publish2 (send2);
|
||||
auto channel1 (node1->network.udp_channels.create (node1->network.endpoint ()));
|
||||
node1->network.inbound (publish1, channel1);
|
||||
|
|
@ -676,7 +673,7 @@ TEST (confirmation_height, conflict_rollback_cemented)
|
|||
node1->block_processor.flush ();
|
||||
node2->network.inbound (publish1, channel2);
|
||||
node2->block_processor.flush ();
|
||||
auto election (node2->active.election (nano::qualified_root (genesis.hash (), genesis.hash ())));
|
||||
auto election (node2->active.election (nano::qualified_root (nano::dev::genesis->hash (), nano::dev::genesis->hash ())));
|
||||
ASSERT_NE (nullptr, election);
|
||||
ASSERT_EQ (1, election->votes ().size ());
|
||||
// Force blocks to be cemented on both nodes
|
||||
|
|
@ -695,7 +692,7 @@ TEST (confirmation_height, conflict_rollback_cemented)
|
|||
ASSERT_TIMELY (20s, sb.component ()->str ().find (rollback_log_entry) != std::string::npos);
|
||||
auto winner (*election->tally ().begin ());
|
||||
ASSERT_EQ (*publish1.block, *winner.second);
|
||||
ASSERT_EQ (nano::dev::genesis_amount - 100, winner.first);
|
||||
ASSERT_EQ (nano::dev::constants.genesis_amount - 100, winner.first);
|
||||
ASSERT_TRUE (node1->ledger.block_or_pruned_exists (publish1.block->hash ()));
|
||||
ASSERT_TRUE (node2->ledger.block_or_pruned_exists (publish2.block->hash ()));
|
||||
ASSERT_FALSE (node2->ledger.block_or_pruned_exists (publish1.block->hash ()));
|
||||
|
|
@ -723,13 +720,12 @@ TEST (confirmation_heightDeathTest, rollback_added_block)
|
|||
auto path (nano::unique_path ());
|
||||
auto store = nano::make_store (logger, path);
|
||||
ASSERT_TRUE (!store->init_error ());
|
||||
nano::genesis genesis;
|
||||
nano::stat stats;
|
||||
nano::ledger ledger (*store, stats);
|
||||
nano::write_database_queue write_database_queue (false);
|
||||
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
|
||||
nano::keypair key1;
|
||||
auto send = std::make_shared<nano::send_block> (genesis.hash (), key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (genesis.hash ()));
|
||||
auto send = std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
|
||||
{
|
||||
auto transaction (store->tx_begin_write ());
|
||||
store->initialize (transaction, ledger.cache);
|
||||
|
|
@ -800,13 +796,12 @@ TEST (confirmation_heightDeathTest, modified_chain)
|
|||
auto path (nano::unique_path ());
|
||||
auto store = nano::make_store (logger, path);
|
||||
ASSERT_TRUE (!store->init_error ());
|
||||
nano::genesis genesis;
|
||||
nano::stat stats;
|
||||
nano::ledger ledger (*store, stats);
|
||||
nano::write_database_queue write_database_queue (false);
|
||||
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
|
||||
nano::keypair key1;
|
||||
auto send = std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
|
||||
auto send = std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
|
||||
{
|
||||
auto transaction (store->tx_begin_write ());
|
||||
store->initialize (transaction, ledger.cache);
|
||||
|
|
@ -871,13 +866,12 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed)
|
|||
auto path (nano::unique_path ());
|
||||
auto store = nano::make_store (logger, path);
|
||||
ASSERT_TRUE (!store->init_error ());
|
||||
nano::genesis genesis;
|
||||
nano::stat stats;
|
||||
nano::ledger ledger (*store, stats);
|
||||
nano::write_database_queue write_database_queue (false);
|
||||
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
|
||||
nano::keypair key1;
|
||||
auto send = std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
|
||||
auto send = std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
|
||||
auto open = std::make_shared<nano::state_block> (key1.pub, 0, 0, nano::Gxrb_ratio, send->hash (), key1.prv, key1.pub, *pool.generate (key1.pub));
|
||||
{
|
||||
auto transaction (store->tx_begin_write ());
|
||||
|
|
@ -940,8 +934,8 @@ TEST (confirmation_height, pending_observer_callbacks)
|
|||
nano::block_hash latest (node->latest (nano::dev::genesis_key.pub));
|
||||
|
||||
nano::keypair key1;
|
||||
nano::send_block send (latest, key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
auto send1 = std::make_shared<nano::send_block> (send.hash (), key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ()));
|
||||
nano::send_block send (latest, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
auto send1 = std::make_shared<nano::send_block> (send.hash (), key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ()));
|
||||
|
||||
{
|
||||
auto transaction = node->store.tx_begin_write ();
|
||||
|
|
@ -982,13 +976,13 @@ TEST (confirmation_height, callback_confirmed_history)
|
|||
nano::block_hash latest (node->latest (nano::dev::genesis_key.pub));
|
||||
|
||||
nano::keypair key1;
|
||||
auto send = std::make_shared<nano::send_block> (latest, key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
auto send = std::make_shared<nano::send_block> (latest, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
{
|
||||
auto transaction = node->store.tx_begin_write ();
|
||||
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
|
||||
}
|
||||
|
||||
auto send1 = std::make_shared<nano::send_block> (send->hash (), key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send->hash ()));
|
||||
auto send1 = std::make_shared<nano::send_block> (send->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send->hash ()));
|
||||
|
||||
add_callback_stats (*node);
|
||||
|
||||
|
|
@ -1063,9 +1057,9 @@ TEST (confirmation_height, dependent_election)
|
|||
nano::block_hash latest (node->latest (nano::dev::genesis_key.pub));
|
||||
|
||||
nano::keypair key1;
|
||||
auto send = std::make_shared<nano::send_block> (latest, key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
auto send1 = std::make_shared<nano::send_block> (send->hash (), key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send->hash ()));
|
||||
auto send2 = std::make_shared<nano::send_block> (send1->hash (), key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ()));
|
||||
auto send = std::make_shared<nano::send_block> (latest, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
auto send1 = std::make_shared<nano::send_block> (send->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send->hash ()));
|
||||
auto send2 = std::make_shared<nano::send_block> (send1->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ()));
|
||||
{
|
||||
auto transaction = node->store.tx_begin_write ();
|
||||
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
|
||||
|
|
@ -1115,22 +1109,22 @@ TEST (confirmation_height, cemented_gap_below_receive)
|
|||
nano::keypair key1;
|
||||
system.wallet (0)->insert_adhoc (key1.prv);
|
||||
|
||||
nano::send_block send (latest, key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
nano::send_block send1 (send.hash (), key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ()));
|
||||
nano::send_block send (latest, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
nano::send_block send1 (send.hash (), key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ()));
|
||||
nano::keypair dummy_key;
|
||||
nano::send_block dummy_send (send1.hash (), dummy_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ()));
|
||||
nano::send_block dummy_send (send1.hash (), dummy_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ()));
|
||||
|
||||
nano::open_block open (send.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub));
|
||||
nano::receive_block receive1 (open.hash (), send1.hash (), key1.prv, key1.pub, *system.work.generate (open.hash ()));
|
||||
nano::send_block send2 (receive1.hash (), nano::dev::genesis_key.pub, nano::Gxrb_ratio, key1.prv, key1.pub, *system.work.generate (receive1.hash ()));
|
||||
|
||||
nano::receive_block receive2 (dummy_send.hash (), send2.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (dummy_send.hash ()));
|
||||
nano::send_block dummy_send1 (receive2.hash (), dummy_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive2.hash ()));
|
||||
nano::send_block dummy_send1 (receive2.hash (), dummy_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive2.hash ()));
|
||||
|
||||
nano::keypair key2;
|
||||
system.wallet (0)->insert_adhoc (key2.prv);
|
||||
nano::send_block send3 (dummy_send1.hash (), key2.pub, nano::dev::genesis_amount - nano::Gxrb_ratio * 4, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (dummy_send1.hash ()));
|
||||
nano::send_block dummy_send2 (send3.hash (), dummy_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio * 5, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send3.hash ()));
|
||||
nano::send_block send3 (dummy_send1.hash (), key2.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 4, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (dummy_send1.hash ()));
|
||||
nano::send_block dummy_send2 (send3.hash (), dummy_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 5, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send3.hash ()));
|
||||
|
||||
auto open1 = std::make_shared<nano::open_block> (send3.hash (), nano::dev::genesis->account (), key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub));
|
||||
|
||||
|
|
@ -1200,22 +1194,22 @@ TEST (confirmation_height, cemented_gap_below_no_cache)
|
|||
nano::keypair key1;
|
||||
system.wallet (0)->insert_adhoc (key1.prv);
|
||||
|
||||
nano::send_block send (latest, key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
nano::send_block send1 (send.hash (), key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ()));
|
||||
nano::send_block send (latest, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
nano::send_block send1 (send.hash (), key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ()));
|
||||
nano::keypair dummy_key;
|
||||
nano::send_block dummy_send (send1.hash (), dummy_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ()));
|
||||
nano::send_block dummy_send (send1.hash (), dummy_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ()));
|
||||
|
||||
nano::open_block open (send.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub));
|
||||
nano::receive_block receive1 (open.hash (), send1.hash (), key1.prv, key1.pub, *system.work.generate (open.hash ()));
|
||||
nano::send_block send2 (receive1.hash (), nano::dev::genesis_key.pub, nano::Gxrb_ratio, key1.prv, key1.pub, *system.work.generate (receive1.hash ()));
|
||||
|
||||
nano::receive_block receive2 (dummy_send.hash (), send2.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (dummy_send.hash ()));
|
||||
nano::send_block dummy_send1 (receive2.hash (), dummy_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive2.hash ()));
|
||||
nano::send_block dummy_send1 (receive2.hash (), dummy_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive2.hash ()));
|
||||
|
||||
nano::keypair key2;
|
||||
system.wallet (0)->insert_adhoc (key2.prv);
|
||||
nano::send_block send3 (dummy_send1.hash (), key2.pub, nano::dev::genesis_amount - nano::Gxrb_ratio * 4, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (dummy_send1.hash ()));
|
||||
nano::send_block dummy_send2 (send3.hash (), dummy_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio * 5, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send3.hash ()));
|
||||
nano::send_block send3 (dummy_send1.hash (), key2.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 4, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (dummy_send1.hash ()));
|
||||
nano::send_block dummy_send2 (send3.hash (), dummy_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 5, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send3.hash ()));
|
||||
|
||||
auto open1 = std::make_shared<nano::open_block> (send3.hash (), nano::dev::genesis->account (), key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub));
|
||||
|
||||
|
|
@ -1281,9 +1275,9 @@ TEST (confirmation_height, election_winner_details_clearing)
|
|||
nano::block_hash latest (node->latest (nano::dev::genesis_key.pub));
|
||||
|
||||
nano::keypair key1;
|
||||
auto send = std::make_shared<nano::send_block> (latest, key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
auto send1 = std::make_shared<nano::send_block> (send->hash (), key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send->hash ()));
|
||||
auto send2 = std::make_shared<nano::send_block> (send1->hash (), key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ()));
|
||||
auto send = std::make_shared<nano::send_block> (latest, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
auto send1 = std::make_shared<nano::send_block> (send->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send->hash ()));
|
||||
auto send2 = std::make_shared<nano::send_block> (send1->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ()));
|
||||
|
||||
{
|
||||
auto transaction = node->store.tx_begin_write ();
|
||||
|
|
@ -1344,7 +1338,7 @@ TEST (confirmation_height, election_winner_details_clearing_node_process_confirm
|
|||
nano::system system (1);
|
||||
auto node = system.nodes.front ();
|
||||
|
||||
auto send = std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()));
|
||||
auto send = std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()));
|
||||
// Add to election_winner_details. Use an unrealistic iteration so that it should fall into the else case and do a cleanup
|
||||
node->active.add_election_winner_details (send->hash (), nullptr);
|
||||
nano::election_status election;
|
||||
|
|
@ -1364,7 +1358,6 @@ TEST (confirmation_height, unbounded_block_cache_iteration)
|
|||
auto path (nano::unique_path ());
|
||||
auto store = nano::make_store (logger, path);
|
||||
ASSERT_TRUE (!store->init_error ());
|
||||
nano::genesis genesis;
|
||||
nano::stat stats;
|
||||
nano::ledger ledger (*store, stats);
|
||||
nano::write_database_queue write_database_queue (false);
|
||||
|
|
@ -1372,8 +1365,8 @@ TEST (confirmation_height, unbounded_block_cache_iteration)
|
|||
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
|
||||
nano::logging logging;
|
||||
nano::keypair key1;
|
||||
auto send = std::make_shared<nano::send_block> (genesis.hash (), key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (genesis.hash ()));
|
||||
auto send1 = std::make_shared<nano::send_block> (send->hash (), key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send->hash ()));
|
||||
auto send = std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
|
||||
auto send1 = std::make_shared<nano::send_block> (send->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send->hash ()));
|
||||
{
|
||||
auto transaction (store->tx_begin_write ());
|
||||
store->initialize (transaction, ledger.cache);
|
||||
|
|
@ -1415,14 +1408,13 @@ TEST (confirmation_height, pruned_source)
|
|||
auto path (nano::unique_path ());
|
||||
auto store = nano::make_store (logger, path);
|
||||
ASSERT_TRUE (!store->init_error ());
|
||||
nano::genesis genesis;
|
||||
nano::stat stats;
|
||||
nano::ledger ledger (*store, stats);
|
||||
ledger.pruning = true;
|
||||
nano::write_database_queue write_database_queue (false);
|
||||
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
|
||||
nano::keypair key1, key2;
|
||||
auto send1 = std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, genesis.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - 100, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
|
||||
auto send1 = std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 100, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
|
||||
auto open1 = std::make_shared<nano::state_block> (key1.pub, 0, key1.pub, 100, send1->hash (), key1.prv, key1.pub, *pool.generate (key1.pub));
|
||||
auto send2 = std::make_shared<nano::state_block> (key1.pub, open1->hash (), key1.pub, 50, key2.pub, key1.prv, key1.pub, *pool.generate (open1->hash ()));
|
||||
auto send3 = std::make_shared<nano::state_block> (key1.pub, send2->hash (), key1.pub, 25, key2.pub, key1.prv, key1.pub, *pool.generate (send2->hash ()));
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ TEST (confirmation_solicitor, batches)
|
|||
auto & node2 = *system.add_node (node_flags);
|
||||
auto channel1 (node2.network.udp_channels.create (node1.network.endpoint ()));
|
||||
// Solicitor will only solicit from this representative
|
||||
nano::representative representative (nano::dev::genesis_key.pub, nano::dev::genesis_amount, channel1);
|
||||
nano::representative representative (nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, channel1);
|
||||
std::vector<nano::representative> representatives{ representative };
|
||||
nano::confirmation_solicitor solicitor (node2.network, node2.config);
|
||||
solicitor.prepare (representatives);
|
||||
|
|
@ -28,7 +28,7 @@ TEST (confirmation_solicitor, batches)
|
|||
ASSERT_EQ (channel1, representatives.front ().channel);
|
||||
ASSERT_EQ (nano::dev::genesis_key.pub, representatives.front ().account);
|
||||
ASSERT_TIMELY (3s, node2.network.size () == 1);
|
||||
auto send (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::keypair ().pub, nano::dev::genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
|
||||
auto send (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::keypair ().pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
|
||||
send->sideband_set ({});
|
||||
{
|
||||
nano::lock_guard<nano::mutex> guard (node2.active.mutex);
|
||||
|
|
@ -63,7 +63,7 @@ TEST (confirmation_solicitor, different_hash)
|
|||
auto & node2 = *system.add_node (node_flags);
|
||||
auto channel1 (node2.network.udp_channels.create (node1.network.endpoint ()));
|
||||
// Solicitor will only solicit from this representative
|
||||
nano::representative representative (nano::dev::genesis_key.pub, nano::dev::genesis_amount, channel1);
|
||||
nano::representative representative (nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, channel1);
|
||||
std::vector<nano::representative> representatives{ representative };
|
||||
nano::confirmation_solicitor solicitor (node2.network, node2.config);
|
||||
solicitor.prepare (representatives);
|
||||
|
|
@ -72,7 +72,7 @@ TEST (confirmation_solicitor, different_hash)
|
|||
ASSERT_EQ (channel1, representatives.front ().channel);
|
||||
ASSERT_EQ (nano::dev::genesis_key.pub, representatives.front ().account);
|
||||
ASSERT_TIMELY (3s, node2.network.size () == 1);
|
||||
auto send (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::keypair ().pub, nano::dev::genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
|
||||
auto send (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::keypair ().pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
|
||||
send->sideband_set ({});
|
||||
auto election (std::make_shared<nano::election> (node2, send, nullptr, nullptr, nano::election_behavior::normal));
|
||||
// Add a vote for something else, not the winner
|
||||
|
|
@ -108,7 +108,7 @@ TEST (confirmation_solicitor, bypass_max_requests_cap)
|
|||
ASSERT_EQ (max_representatives + 1, representatives.size ());
|
||||
solicitor.prepare (representatives);
|
||||
ASSERT_TIMELY (3s, node2.network.size () == 1);
|
||||
auto send (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::keypair ().pub, nano::dev::genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
|
||||
auto send (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::keypair ().pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
|
||||
send->sideband_set ({});
|
||||
auto election (std::make_shared<nano::election> (node2, send, nullptr, nullptr, nano::election_behavior::normal));
|
||||
// Add a vote for something else, not the winner
|
||||
|
|
|
|||
|
|
@ -12,9 +12,8 @@ TEST (conflicts, start_stop)
|
|||
{
|
||||
nano::system system (1);
|
||||
auto & node1 (*system.nodes[0]);
|
||||
nano::genesis genesis;
|
||||
nano::keypair key1;
|
||||
auto send1 (std::make_shared<nano::send_block> (genesis.hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
auto send1 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
node1.work_generate_blocking (*send1);
|
||||
ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code);
|
||||
ASSERT_EQ (0, node1.active.size ());
|
||||
|
|
@ -30,14 +29,13 @@ TEST (conflicts, add_existing)
|
|||
{
|
||||
nano::system system (1);
|
||||
auto & node1 (*system.nodes[0]);
|
||||
nano::genesis genesis;
|
||||
nano::keypair key1;
|
||||
auto send1 (std::make_shared<nano::send_block> (genesis.hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
auto send1 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
node1.work_generate_blocking (*send1);
|
||||
ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code);
|
||||
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
|
||||
nano::keypair key2;
|
||||
auto send2 (std::make_shared<nano::send_block> (genesis.hash (), key2.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
auto send2 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key2.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
send2->sideband_set ({});
|
||||
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
|
||||
node1.scheduler.flush ();
|
||||
|
|
@ -55,9 +53,8 @@ TEST (conflicts, add_two)
|
|||
{
|
||||
nano::system system (1);
|
||||
auto & node1 (*system.nodes[0]);
|
||||
nano::genesis genesis;
|
||||
nano::keypair key1;
|
||||
auto send1 (std::make_shared<nano::send_block> (genesis.hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
auto send1 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
node1.work_generate_blocking (*send1);
|
||||
ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code);
|
||||
node1.block_confirm (send1);
|
||||
|
|
|
|||
|
|
@ -9,12 +9,10 @@ using namespace std::chrono_literals;
|
|||
TEST (election, construction)
|
||||
{
|
||||
nano::system system (1);
|
||||
nano::genesis genesis;
|
||||
auto & node = *system.nodes[0];
|
||||
genesis.open->sideband_set (nano::block_sideband (nano::dev::genesis->account (), 0, nano::dev::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0));
|
||||
node.block_confirm (genesis.open);
|
||||
node.block_confirm (nano::dev::genesis);
|
||||
node.scheduler.flush ();
|
||||
auto election = node.active.election (genesis.open->qualified_root ());
|
||||
auto election = node.active.election (nano::dev::genesis->qualified_root ());
|
||||
election->transition_active ();
|
||||
}
|
||||
|
||||
|
|
@ -22,7 +20,7 @@ TEST (election, quorum_minimum_flip_success)
|
|||
{
|
||||
nano::system system;
|
||||
nano::node_config node_config (nano::get_available_port (), system.logging);
|
||||
node_config.online_weight_minimum = nano::dev::genesis_amount;
|
||||
node_config.online_weight_minimum = nano::dev::constants.genesis_amount;
|
||||
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
|
||||
auto & node1 = *system.add_node (node_config);
|
||||
nano::keypair key1;
|
||||
|
|
@ -68,7 +66,7 @@ TEST (election, quorum_minimum_flip_fail)
|
|||
{
|
||||
nano::system system;
|
||||
nano::node_config node_config (nano::get_available_port (), system.logging);
|
||||
node_config.online_weight_minimum = nano::dev::genesis_amount;
|
||||
node_config.online_weight_minimum = nano::dev::constants.genesis_amount;
|
||||
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
|
||||
auto & node1 = *system.add_node (node_config);
|
||||
nano::keypair key1;
|
||||
|
|
@ -114,7 +112,7 @@ TEST (election, quorum_minimum_confirm_success)
|
|||
{
|
||||
nano::system system;
|
||||
nano::node_config node_config (nano::get_available_port (), system.logging);
|
||||
node_config.online_weight_minimum = nano::dev::genesis_amount;
|
||||
node_config.online_weight_minimum = nano::dev::constants.genesis_amount;
|
||||
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
|
||||
auto & node1 = *system.add_node (node_config);
|
||||
nano::keypair key1;
|
||||
|
|
@ -147,7 +145,7 @@ TEST (election, quorum_minimum_confirm_fail)
|
|||
{
|
||||
nano::system system;
|
||||
nano::node_config node_config (nano::get_available_port (), system.logging);
|
||||
node_config.online_weight_minimum = nano::dev::genesis_amount;
|
||||
node_config.online_weight_minimum = nano::dev::constants.genesis_amount;
|
||||
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
|
||||
auto & node1 = *system.add_node (node_config);
|
||||
nano::keypair key1;
|
||||
|
|
@ -202,7 +200,7 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks)
|
|||
.account (key1.pub)
|
||||
.previous (0)
|
||||
.representative (key1.pub)
|
||||
.balance (nano::dev::genesis_amount - amount)
|
||||
.balance (nano::dev::constants.genesis_amount - amount)
|
||||
.link (send1->hash ())
|
||||
.work (0)
|
||||
.sign (key1.prv, key1.pub)
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ TEST (election_scheduler, activate_one_timely)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (nano::dev::genesis_key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
|
|
@ -39,7 +39,7 @@ TEST (election_scheduler, activate_one_flush)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (nano::dev::genesis_key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
|
|
@ -65,7 +65,7 @@ TEST (election_scheduler, no_vacancy)
|
|||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.link (key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
|
|
@ -91,7 +91,7 @@ TEST (election_scheduler, no_vacancy)
|
|||
.previous (send->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.link (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 2 * nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (send->hash ()))
|
||||
.build_shared ();
|
||||
|
|
@ -138,7 +138,7 @@ TEST (election_scheduler, flush_vacancy)
|
|||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.link (key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
|
|
|
|||
|
|
@ -210,7 +210,6 @@ TEST (frontiers_confirmation, expired_optimistic_elections_removal)
|
|||
|
||||
TEST (frontiers_confirmation, mode)
|
||||
{
|
||||
nano::genesis genesis;
|
||||
nano::keypair key;
|
||||
nano::node_flags node_flags;
|
||||
// Always mode
|
||||
|
|
@ -219,7 +218,7 @@ TEST (frontiers_confirmation, mode)
|
|||
nano::node_config node_config (nano::get_available_port (), system.logging);
|
||||
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::always;
|
||||
auto node = system.add_node (node_config, node_flags);
|
||||
nano::state_block send (nano::dev::genesis_key.pub, genesis.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (genesis.hash ()));
|
||||
nano::state_block send (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (nano::dev::genesis->hash ()));
|
||||
{
|
||||
auto transaction = node->store.tx_begin_write ();
|
||||
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
|
||||
|
|
@ -232,7 +231,7 @@ TEST (frontiers_confirmation, mode)
|
|||
nano::node_config node_config (nano::get_available_port (), system.logging);
|
||||
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::automatic;
|
||||
auto node = system.add_node (node_config, node_flags);
|
||||
nano::state_block send (nano::dev::genesis_key.pub, genesis.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (genesis.hash ()));
|
||||
nano::state_block send (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (nano::dev::genesis->hash ()));
|
||||
{
|
||||
auto transaction = node->store.tx_begin_write ();
|
||||
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
|
||||
|
|
@ -245,7 +244,7 @@ TEST (frontiers_confirmation, mode)
|
|||
nano::node_config node_config (nano::get_available_port (), system.logging);
|
||||
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
|
||||
auto node = system.add_node (node_config, node_flags);
|
||||
nano::state_block send (nano::dev::genesis_key.pub, genesis.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (genesis.hash ()));
|
||||
nano::state_block send (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (nano::dev::genesis->hash ()));
|
||||
{
|
||||
auto transaction = node->store.tx_begin_write ();
|
||||
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
|
||||
|
|
|
|||
|
|
@ -67,10 +67,10 @@ TEST (gap_cache, gap_bootstrap)
|
|||
auto & node2 (*system.nodes[1]);
|
||||
nano::block_hash latest (node1.latest (nano::dev::genesis_key.pub));
|
||||
nano::keypair key;
|
||||
auto send (std::make_shared<nano::send_block> (latest, key.pub, nano::dev::genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)));
|
||||
auto send (std::make_shared<nano::send_block> (latest, key.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)));
|
||||
node1.process (*send);
|
||||
ASSERT_EQ (nano::dev::genesis_amount - 100, node1.balance (nano::dev::genesis->account ()));
|
||||
ASSERT_EQ (nano::dev::genesis_amount, node2.balance (nano::dev::genesis->account ()));
|
||||
ASSERT_EQ (nano::dev::constants.genesis_amount - 100, node1.balance (nano::dev::genesis->account ()));
|
||||
ASSERT_EQ (nano::dev::constants.genesis_amount, node2.balance (nano::dev::genesis->account ()));
|
||||
// Confirm send block, allowing voting on the upcoming block
|
||||
node1.block_confirm (send);
|
||||
auto election = node1.active.election (send->qualified_root ());
|
||||
|
|
@ -81,9 +81,9 @@ TEST (gap_cache, gap_bootstrap)
|
|||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
auto latest_block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, 100));
|
||||
ASSERT_NE (nullptr, latest_block);
|
||||
ASSERT_EQ (nano::dev::genesis_amount - 200, node1.balance (nano::dev::genesis->account ()));
|
||||
ASSERT_EQ (nano::dev::genesis_amount, node2.balance (nano::dev::genesis->account ()));
|
||||
ASSERT_TIMELY (10s, node2.balance (nano::dev::genesis->account ()) == nano::dev::genesis_amount - 200);
|
||||
ASSERT_EQ (nano::dev::constants.genesis_amount - 200, node1.balance (nano::dev::genesis->account ()));
|
||||
ASSERT_EQ (nano::dev::constants.genesis_amount, node2.balance (nano::dev::genesis->account ()));
|
||||
ASSERT_TIMELY (10s, node2.balance (nano::dev::genesis->account ()) == nano::dev::constants.genesis_amount - 200);
|
||||
}
|
||||
|
||||
TEST (gap_cache, two_dependencies)
|
||||
|
|
@ -91,8 +91,7 @@ TEST (gap_cache, two_dependencies)
|
|||
nano::system system (1);
|
||||
auto & node1 (*system.nodes[0]);
|
||||
nano::keypair key;
|
||||
nano::genesis genesis;
|
||||
auto send1 (std::make_shared<nano::send_block> (genesis.hash (), key.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis.hash ())));
|
||||
auto send1 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
|
||||
auto send2 (std::make_shared<nano::send_block> (send1->hash (), key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ())));
|
||||
auto open (std::make_shared<nano::open_block> (send1->hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)));
|
||||
ASSERT_EQ (0, node1.gap_cache.size ());
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -205,17 +205,16 @@ TEST (network, send_discarded_publish)
|
|||
auto & node1 (*system.nodes[0]);
|
||||
auto & node2 (*system.nodes[1]);
|
||||
auto block (std::make_shared<nano::send_block> (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1))));
|
||||
nano::genesis genesis;
|
||||
{
|
||||
auto transaction (node1.store.tx_begin_read ());
|
||||
node1.network.flood_block (block);
|
||||
ASSERT_EQ (genesis.hash (), node1.ledger.latest (transaction, nano::dev::genesis_key.pub));
|
||||
ASSERT_EQ (genesis.hash (), node2.latest (nano::dev::genesis_key.pub));
|
||||
ASSERT_EQ (nano::dev::genesis->hash (), node1.ledger.latest (transaction, nano::dev::genesis_key.pub));
|
||||
ASSERT_EQ (nano::dev::genesis->hash (), node2.latest (nano::dev::genesis_key.pub));
|
||||
}
|
||||
ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0);
|
||||
auto transaction (node1.store.tx_begin_read ());
|
||||
ASSERT_EQ (genesis.hash (), node1.ledger.latest (transaction, nano::dev::genesis_key.pub));
|
||||
ASSERT_EQ (genesis.hash (), node2.latest (nano::dev::genesis_key.pub));
|
||||
ASSERT_EQ (nano::dev::genesis->hash (), node1.ledger.latest (transaction, nano::dev::genesis_key.pub));
|
||||
ASSERT_EQ (nano::dev::genesis->hash (), node2.latest (nano::dev::genesis_key.pub));
|
||||
}
|
||||
|
||||
TEST (network, send_invalid_publish)
|
||||
|
|
@ -223,18 +222,17 @@ TEST (network, send_invalid_publish)
|
|||
nano::system system (2);
|
||||
auto & node1 (*system.nodes[0]);
|
||||
auto & node2 (*system.nodes[1]);
|
||||
nano::genesis genesis;
|
||||
auto block (std::make_shared<nano::send_block> (1, 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::root (1))));
|
||||
{
|
||||
auto transaction (node1.store.tx_begin_read ());
|
||||
node1.network.flood_block (block);
|
||||
ASSERT_EQ (genesis.hash (), node1.ledger.latest (transaction, nano::dev::genesis_key.pub));
|
||||
ASSERT_EQ (genesis.hash (), node2.latest (nano::dev::genesis_key.pub));
|
||||
ASSERT_EQ (nano::dev::genesis->hash (), node1.ledger.latest (transaction, nano::dev::genesis_key.pub));
|
||||
ASSERT_EQ (nano::dev::genesis->hash (), node2.latest (nano::dev::genesis_key.pub));
|
||||
}
|
||||
ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0);
|
||||
auto transaction (node1.store.tx_begin_read ());
|
||||
ASSERT_EQ (genesis.hash (), node1.ledger.latest (transaction, nano::dev::genesis_key.pub));
|
||||
ASSERT_EQ (genesis.hash (), node2.latest (nano::dev::genesis_key.pub));
|
||||
ASSERT_EQ (nano::dev::genesis->hash (), node1.ledger.latest (transaction, nano::dev::genesis_key.pub));
|
||||
ASSERT_EQ (nano::dev::genesis->hash (), node2.latest (nano::dev::genesis_key.pub));
|
||||
}
|
||||
|
||||
TEST (network, send_valid_confirm_ack)
|
||||
|
|
@ -353,8 +351,7 @@ TEST (receivable_processor, confirm_insufficient_pos)
|
|||
{
|
||||
nano::system system (1);
|
||||
auto & node1 (*system.nodes[0]);
|
||||
nano::genesis genesis;
|
||||
auto block1 (std::make_shared<nano::send_block> (genesis.hash (), 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
auto block1 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
node1.work_generate_blocking (*block1);
|
||||
ASSERT_EQ (nano::process_result::progress, node1.process (*block1).code);
|
||||
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
|
||||
|
|
@ -368,8 +365,7 @@ TEST (receivable_processor, confirm_sufficient_pos)
|
|||
{
|
||||
nano::system system (1);
|
||||
auto & node1 (*system.nodes[0]);
|
||||
nano::genesis genesis;
|
||||
auto block1 (std::make_shared<nano::send_block> (genesis.hash (), 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
auto block1 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
node1.work_generate_blocking (*block1);
|
||||
ASSERT_EQ (nano::process_result::progress, node1.process (*block1).code);
|
||||
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
|
||||
|
|
@ -947,8 +943,7 @@ TEST (network, duplicate_detection)
|
|||
auto & node0 (*system.add_node (node_flags));
|
||||
auto & node1 (*system.add_node (node_flags));
|
||||
auto udp_channel (std::make_shared<nano::transport::channel_udp> (node0.network.udp_channels, node1.network.endpoint (), node1.network_params.protocol.protocol_version));
|
||||
nano::genesis genesis;
|
||||
nano::publish publish (genesis.open);
|
||||
nano::publish publish (nano::dev::genesis);
|
||||
|
||||
// Publish duplicate detection through UDP
|
||||
ASSERT_EQ (0, node1.stats.count (nano::stat::type::filter, nano::stat::detail::duplicate_publish));
|
||||
|
|
@ -970,8 +965,7 @@ TEST (network, duplicate_revert_publish)
|
|||
node_flags.block_processor_full_size = 0;
|
||||
auto & node (*system.add_node (node_flags));
|
||||
ASSERT_TRUE (node.block_processor.full ());
|
||||
nano::genesis genesis;
|
||||
nano::publish publish (genesis.open);
|
||||
nano::publish publish (nano::dev::genesis);
|
||||
std::vector<uint8_t> bytes;
|
||||
{
|
||||
nano::vectorstream stream (bytes);
|
||||
|
|
@ -1000,8 +994,7 @@ TEST (network, duplicate_revert_publish)
|
|||
TEST (network, bandwidth_limiter)
|
||||
{
|
||||
nano::system system;
|
||||
nano::genesis genesis;
|
||||
nano::publish message (genesis.open);
|
||||
nano::publish message (nano::dev::genesis);
|
||||
auto message_size = message.to_bytes ()->size ();
|
||||
auto message_limit = 4; // must be multiple of the number of channels
|
||||
nano::node_config node_config (nano::get_available_port (), system.logging);
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@
|
|||
|
||||
TEST (network_filter, unit)
|
||||
{
|
||||
nano::genesis genesis;
|
||||
nano::ledger_constants constants{ nano::networks::nano_dev_network };
|
||||
nano::network_filter filter (1);
|
||||
auto one_block = [&filter] (std::shared_ptr<nano::block> const & block_a, bool expect_duplicate_a) {
|
||||
nano::publish message (block_a);
|
||||
|
|
@ -32,17 +32,17 @@ TEST (network_filter, unit)
|
|||
ASSERT_NE (nullptr, block);
|
||||
ASSERT_EQ (*block, *block_a);
|
||||
};
|
||||
one_block (genesis.open, false);
|
||||
one_block (constants.genesis, false);
|
||||
for (int i = 0; i < 10; ++i)
|
||||
{
|
||||
one_block (genesis.open, true);
|
||||
one_block (constants.genesis, true);
|
||||
}
|
||||
nano::state_block_builder builder;
|
||||
auto new_block = builder
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.open->hash ())
|
||||
.previous (constants.genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 10 * nano::xrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - 10 * nano::xrb_ratio)
|
||||
.link (nano::public_key ())
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (0)
|
||||
|
|
@ -55,14 +55,14 @@ TEST (network_filter, unit)
|
|||
}
|
||||
for (int i = 0; i < 100; ++i)
|
||||
{
|
||||
one_block (genesis.open, false);
|
||||
one_block (constants.genesis, false);
|
||||
one_block (new_block, false);
|
||||
}
|
||||
}
|
||||
|
||||
TEST (network_filter, many)
|
||||
{
|
||||
nano::genesis genesis;
|
||||
nano::ledger_constants constants{ nano::networks::nano_dev_network };
|
||||
nano::network_filter filter (4);
|
||||
nano::keypair key1;
|
||||
for (int i = 0; i < 100; ++i)
|
||||
|
|
@ -70,9 +70,9 @@ TEST (network_filter, many)
|
|||
nano::state_block_builder builder;
|
||||
auto block = builder
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.open->hash ())
|
||||
.previous (constants.genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - i * 10 * nano::xrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - i * 10 * nano::xrb_ratio)
|
||||
.link (key1.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (0)
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -14,7 +14,6 @@ TEST (processor_service, bad_send_signature)
|
|||
ASSERT_FALSE (store->init_error ());
|
||||
nano::stat stats;
|
||||
nano::ledger ledger (*store, stats);
|
||||
nano::genesis genesis;
|
||||
auto transaction (store->tx_begin_write ());
|
||||
store->initialize (transaction, ledger.cache);
|
||||
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
|
||||
|
|
@ -33,7 +32,6 @@ TEST (processor_service, bad_receive_signature)
|
|||
ASSERT_FALSE (store->init_error ());
|
||||
nano::stat stats;
|
||||
nano::ledger ledger (*store, stats);
|
||||
nano::genesis genesis;
|
||||
auto transaction (store->tx_begin_write ());
|
||||
store->initialize (transaction, ledger.cache);
|
||||
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
|
||||
|
|
|
|||
|
|
@ -13,9 +13,8 @@ TEST (request_aggregator, one)
|
|||
nano::node_config node_config (nano::get_available_port (), system.logging);
|
||||
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
|
||||
auto & node (*system.add_node (node_config));
|
||||
nano::genesis genesis;
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, genesis.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (genesis.hash ())));
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (nano::dev::genesis->hash ())));
|
||||
std::vector<std::pair<nano::block_hash, nano::root>> request;
|
||||
request.emplace_back (send1->hash (), send1->root ());
|
||||
auto channel (node.network.udp_channels.create (node.network.endpoint ()));
|
||||
|
|
@ -49,18 +48,17 @@ TEST (request_aggregator, one_update)
|
|||
nano::node_config node_config (nano::get_available_port (), system.logging);
|
||||
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
|
||||
auto & node (*system.add_node (node_config));
|
||||
nano::genesis genesis;
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
nano::keypair key1;
|
||||
auto send1 = nano::state_block_builder ()
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (nano::dev::genesis_key.pub)
|
||||
.link (key1.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*node.work_generate_blocking (genesis.hash ()))
|
||||
.work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
|
||||
node.confirmation_height_processor.add (send1);
|
||||
|
|
@ -69,7 +67,7 @@ TEST (request_aggregator, one_update)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (send1->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 2 * nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio)
|
||||
.link (nano::dev::genesis_key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*node.work_generate_blocking (send1->hash ()))
|
||||
|
|
@ -115,18 +113,17 @@ TEST (request_aggregator, two)
|
|||
nano::node_config node_config (nano::get_available_port (), system.logging);
|
||||
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
|
||||
auto & node (*system.add_node (node_config));
|
||||
nano::genesis genesis;
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
nano::keypair key1;
|
||||
nano::state_block_builder builder;
|
||||
auto send1 = builder.make_block ()
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 1)
|
||||
.balance (nano::dev::constants.genesis_amount - 1)
|
||||
.link (key1.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*node.work_generate_blocking (genesis.hash ()))
|
||||
.work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
|
||||
node.confirmation_height_processor.add (send1);
|
||||
|
|
@ -135,7 +132,7 @@ TEST (request_aggregator, two)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (send1->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 2)
|
||||
.balance (nano::dev::constants.genesis_amount - 2)
|
||||
.link (nano::dev::genesis_key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*node.work_generate_blocking (send1->hash ()))
|
||||
|
|
@ -192,9 +189,8 @@ TEST (request_aggregator, two_endpoints)
|
|||
auto & node1 (*system.add_node (node_config, node_flags));
|
||||
node_config.peering_port = nano::get_available_port ();
|
||||
auto & node2 (*system.add_node (node_config, node_flags));
|
||||
nano::genesis genesis;
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, genesis.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - 1, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1.work_generate_blocking (genesis.hash ())));
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 1, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1.work_generate_blocking (nano::dev::genesis->hash ())));
|
||||
std::vector<std::pair<nano::block_hash, nano::root>> request;
|
||||
request.emplace_back (send1->hash (), send1->root ());
|
||||
ASSERT_EQ (nano::process_result::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1).code);
|
||||
|
|
@ -224,11 +220,10 @@ TEST (request_aggregator, split)
|
|||
nano::node_config node_config (nano::get_available_port (), system.logging);
|
||||
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
|
||||
auto & node (*system.add_node (node_config));
|
||||
nano::genesis genesis;
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
std::vector<std::pair<nano::block_hash, nano::root>> request;
|
||||
std::vector<std::shared_ptr<nano::block>> blocks;
|
||||
auto previous = genesis.hash ();
|
||||
auto previous = nano::dev::genesis->hash ();
|
||||
// Add max_vbh + 1 blocks and request votes for them
|
||||
for (size_t i (0); i <= max_vbh; ++i)
|
||||
{
|
||||
|
|
@ -238,7 +233,7 @@ TEST (request_aggregator, split)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (previous)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - (i + 1))
|
||||
.balance (nano::dev::constants.genesis_amount - (i + 1))
|
||||
.link (nano::dev::genesis_key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (previous))
|
||||
|
|
@ -278,9 +273,8 @@ TEST (request_aggregator, channel_lifetime)
|
|||
nano::node_config node_config (nano::get_available_port (), system.logging);
|
||||
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
|
||||
auto & node (*system.add_node (node_config));
|
||||
nano::genesis genesis;
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, genesis.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (genesis.hash ())));
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (nano::dev::genesis->hash ())));
|
||||
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
|
||||
std::vector<std::pair<nano::block_hash, nano::root>> request;
|
||||
request.emplace_back (send1->hash (), send1->root ());
|
||||
|
|
@ -299,9 +293,8 @@ TEST (request_aggregator, channel_update)
|
|||
nano::node_config node_config (nano::get_available_port (), system.logging);
|
||||
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
|
||||
auto & node (*system.add_node (node_config));
|
||||
nano::genesis genesis;
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, genesis.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (genesis.hash ())));
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (nano::dev::genesis->hash ())));
|
||||
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
|
||||
std::vector<std::pair<nano::block_hash, nano::root>> request;
|
||||
request.emplace_back (send1->hash (), send1->root ());
|
||||
|
|
@ -328,9 +321,8 @@ TEST (request_aggregator, channel_max_queue)
|
|||
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
|
||||
node_config.max_queued_requests = 1;
|
||||
auto & node (*system.add_node (node_config));
|
||||
nano::genesis genesis;
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, genesis.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (genesis.hash ())));
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (nano::dev::genesis->hash ())));
|
||||
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
|
||||
std::vector<std::pair<nano::block_hash, nano::root>> request;
|
||||
request.emplace_back (send1->hash (), send1->root ());
|
||||
|
|
@ -346,9 +338,8 @@ TEST (request_aggregator, unique)
|
|||
nano::node_config node_config (nano::get_available_port (), system.logging);
|
||||
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
|
||||
auto & node (*system.add_node (node_config));
|
||||
nano::genesis genesis;
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, genesis.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (genesis.hash ())));
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (nano::dev::genesis->hash ())));
|
||||
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
|
||||
std::vector<std::pair<nano::block_hash, nano::root>> request;
|
||||
request.emplace_back (send1->hash (), send1->root ());
|
||||
|
|
@ -371,13 +362,12 @@ TEST (request_aggregator, cannot_vote)
|
|||
auto & node (*system.add_node (flags));
|
||||
// This prevents activation of blocks which are cemented
|
||||
node.confirmation_height_processor.cemented_observers.clear ();
|
||||
nano::genesis genesis;
|
||||
nano::state_block_builder builder;
|
||||
auto send1 = builder.make_block ()
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 1)
|
||||
.balance (nano::dev::constants.genesis_amount - 1)
|
||||
.link (nano::dev::genesis_key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ TEST (system, system_genesis)
|
|||
for (auto & i : system.nodes)
|
||||
{
|
||||
auto transaction (i->store.tx_begin_read ());
|
||||
ASSERT_EQ (nano::dev::genesis_amount, i->ledger.account_balance (transaction, nano::dev::genesis->account ()));
|
||||
ASSERT_EQ (nano::dev::constants.genesis_amount, i->ledger.account_balance (transaction, nano::dev::genesis->account ()));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -40,7 +40,7 @@ TEST (system, DISABLED_generate_send_existing)
|
|||
nano::thread_runner runner (system.io_ctx, node1.config.io_threads);
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
nano::keypair stake_preserver;
|
||||
auto send_block (system.wallet (0)->send_action (nano::dev::genesis->account (), stake_preserver.pub, nano::dev::genesis_amount / 3 * 2, true));
|
||||
auto send_block (system.wallet (0)->send_action (nano::dev::genesis->account (), stake_preserver.pub, nano::dev::constants.genesis_amount / 3 * 2, true));
|
||||
nano::account_info info1;
|
||||
{
|
||||
auto transaction (node1.store.tx_begin_read ());
|
||||
|
|
@ -71,7 +71,7 @@ TEST (system, DISABLED_generate_send_existing)
|
|||
ASSERT_FALSE (node1.store.account.get (transaction, nano::dev::genesis_key.pub, info2));
|
||||
}
|
||||
ASSERT_EQ (info1.block_count + 2, info2.block_count);
|
||||
ASSERT_EQ (info2.balance, nano::dev::genesis_amount / 3);
|
||||
ASSERT_EQ (info2.balance, nano::dev::constants.genesis_amount / 3);
|
||||
{
|
||||
auto transaction (node1.store.tx_begin_read ());
|
||||
ASSERT_NE (node1.ledger.amount (transaction, info2.head), 0);
|
||||
|
|
@ -94,7 +94,7 @@ TEST (system, DISABLED_generate_send_new)
|
|||
ASSERT_EQ (node1.store.account.end (), iterator1);
|
||||
}
|
||||
nano::keypair stake_preserver;
|
||||
auto send_block (system.wallet (0)->send_action (nano::dev::genesis->account (), stake_preserver.pub, nano::dev::genesis_amount / 3 * 2, true));
|
||||
auto send_block (system.wallet (0)->send_action (nano::dev::genesis->account (), stake_preserver.pub, nano::dev::constants.genesis_amount / 3 * 2, true));
|
||||
{
|
||||
auto transaction (node1.store.tx_begin_write ());
|
||||
auto open_block (std::make_shared<nano::open_block> (send_block->hash (), nano::dev::genesis->account (), stake_preserver.pub, stake_preserver.prv, stake_preserver.pub, 0));
|
||||
|
|
@ -136,7 +136,7 @@ TEST (system, rep_initialize_one)
|
|||
nano::keypair key;
|
||||
system.ledger_initialization_set ({ key });
|
||||
auto node = system.add_node ();
|
||||
ASSERT_EQ (nano::dev::genesis_amount, node->balance (key.pub));
|
||||
ASSERT_EQ (nano::dev::constants.genesis_amount, node->balance (key.pub));
|
||||
}
|
||||
|
||||
TEST (system, rep_initialize_two)
|
||||
|
|
@ -146,8 +146,8 @@ TEST (system, rep_initialize_two)
|
|||
nano::keypair key1;
|
||||
system.ledger_initialization_set ({ key0, key1 });
|
||||
auto node = system.add_node ();
|
||||
ASSERT_EQ (nano::dev::genesis_amount / 2, node->balance (key0.pub));
|
||||
ASSERT_EQ (nano::dev::genesis_amount / 2, node->balance (key1.pub));
|
||||
ASSERT_EQ (nano::dev::constants.genesis_amount / 2, node->balance (key0.pub));
|
||||
ASSERT_EQ (nano::dev::constants.genesis_amount / 2, node->balance (key1.pub));
|
||||
}
|
||||
|
||||
TEST (system, rep_initialize_one_reserve)
|
||||
|
|
@ -156,7 +156,7 @@ TEST (system, rep_initialize_one_reserve)
|
|||
nano::keypair key;
|
||||
system.ledger_initialization_set ({ key }, nano::Gxrb_ratio);
|
||||
auto node = system.add_node ();
|
||||
ASSERT_EQ (nano::dev::genesis_amount - nano::Gxrb_ratio, node->balance (key.pub));
|
||||
ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, node->balance (key.pub));
|
||||
ASSERT_EQ (nano::Gxrb_ratio, node->balance (nano::dev::genesis_key.pub));
|
||||
}
|
||||
|
||||
|
|
@ -167,8 +167,8 @@ TEST (system, rep_initialize_two_reserve)
|
|||
nano::keypair key1;
|
||||
system.ledger_initialization_set ({ key0, key1 }, nano::Gxrb_ratio);
|
||||
auto node = system.add_node ();
|
||||
ASSERT_EQ ((nano::dev::genesis_amount - nano::Gxrb_ratio) / 2, node->balance (key0.pub));
|
||||
ASSERT_EQ ((nano::dev::genesis_amount - nano::Gxrb_ratio) / 2, node->balance (key1.pub));
|
||||
ASSERT_EQ ((nano::dev::constants.genesis_amount - nano::Gxrb_ratio) / 2, node->balance (key0.pub));
|
||||
ASSERT_EQ ((nano::dev::constants.genesis_amount - nano::Gxrb_ratio) / 2, node->balance (key1.pub));
|
||||
}
|
||||
|
||||
TEST (system, rep_initialize_many)
|
||||
|
|
@ -178,9 +178,9 @@ TEST (system, rep_initialize_many)
|
|||
nano::keypair key1;
|
||||
system.ledger_initialization_set ({ key0, key1 }, nano::Gxrb_ratio);
|
||||
auto node0 = system.add_node ();
|
||||
ASSERT_EQ ((nano::dev::genesis_amount - nano::Gxrb_ratio) / 2, node0->balance (key0.pub));
|
||||
ASSERT_EQ ((nano::dev::genesis_amount - nano::Gxrb_ratio) / 2, node0->balance (key1.pub));
|
||||
ASSERT_EQ ((nano::dev::constants.genesis_amount - nano::Gxrb_ratio) / 2, node0->balance (key0.pub));
|
||||
ASSERT_EQ ((nano::dev::constants.genesis_amount - nano::Gxrb_ratio) / 2, node0->balance (key1.pub));
|
||||
auto node1 = system.add_node ();
|
||||
ASSERT_EQ ((nano::dev::genesis_amount - nano::Gxrb_ratio) / 2, node1->balance (key0.pub));
|
||||
ASSERT_EQ ((nano::dev::genesis_amount - nano::Gxrb_ratio) / 2, node1->balance (key1.pub));
|
||||
ASSERT_EQ ((nano::dev::constants.genesis_amount - nano::Gxrb_ratio) / 2, node1->balance (key0.pub));
|
||||
ASSERT_EQ ((nano::dev::constants.genesis_amount - nano::Gxrb_ratio) / 2, node1->balance (key1.pub));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,9 +11,8 @@ TEST (vote_processor, codes)
|
|||
{
|
||||
nano::system system (1);
|
||||
auto & node (*system.nodes[0]);
|
||||
nano::genesis genesis;
|
||||
nano::keypair key;
|
||||
auto vote (std::make_shared<nano::vote> (key.pub, key.prv, 1, std::vector<nano::block_hash>{ genesis.open->hash () }));
|
||||
auto vote (std::make_shared<nano::vote> (key.pub, key.prv, 1, std::vector<nano::block_hash>{ nano::dev::genesis->hash () }));
|
||||
auto vote_invalid = std::make_shared<nano::vote> (*vote);
|
||||
vote_invalid->signature.bytes[0] ^= 1;
|
||||
auto channel (std::make_shared<nano::transport::channel_loopback> (node));
|
||||
|
|
@ -28,9 +27,8 @@ TEST (vote_processor, codes)
|
|||
ASSERT_EQ (nano::vote_code::indeterminate, node.vote_processor.vote_blocking (vote, channel));
|
||||
|
||||
// First vote from an account for an ongoing election
|
||||
genesis.open->sideband_set (nano::block_sideband (nano::dev::genesis->account (), 0, nano::dev::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0));
|
||||
node.block_confirm (genesis.open);
|
||||
ASSERT_NE (nullptr, node.active.election (genesis.open->qualified_root ()));
|
||||
node.block_confirm (nano::dev::genesis);
|
||||
ASSERT_NE (nullptr, node.active.election (nano::dev::genesis->qualified_root ()));
|
||||
ASSERT_EQ (nano::vote_code::vote, node.vote_processor.vote_blocking (vote, channel));
|
||||
|
||||
// Processing the same vote is a replay
|
||||
|
|
@ -46,7 +44,7 @@ TEST (vote_processor, codes)
|
|||
ASSERT_EQ (nano::vote_code::vote, node.vote_processor.vote_blocking (vote, channel));
|
||||
|
||||
// Once the election is removed (confirmed / dropped) the vote is again indeterminate
|
||||
node.active.erase (*genesis.open);
|
||||
node.active.erase (*nano::dev::genesis);
|
||||
ASSERT_EQ (nano::vote_code::indeterminate, node.vote_processor.vote_blocking (vote, channel));
|
||||
}
|
||||
|
||||
|
|
@ -54,8 +52,7 @@ TEST (vote_processor, flush)
|
|||
{
|
||||
nano::system system (1);
|
||||
auto & node (*system.nodes[0]);
|
||||
nano::genesis genesis;
|
||||
auto vote (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 1, std::vector<nano::block_hash>{ genesis.open->hash () }));
|
||||
auto vote (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 1, std::vector<nano::block_hash>{ nano::dev::genesis->hash () }));
|
||||
auto channel (std::make_shared<nano::transport::channel_loopback> (node));
|
||||
for (unsigned i = 0; i < 2000; ++i)
|
||||
{
|
||||
|
|
@ -71,16 +68,14 @@ TEST (vote_processor, invalid_signature)
|
|||
{
|
||||
nano::system system{ 1 };
|
||||
auto & node = *system.nodes[0];
|
||||
nano::genesis genesis;
|
||||
nano::keypair key;
|
||||
auto vote = std::make_shared<nano::vote> (key.pub, key.prv, 1, std::vector<nano::block_hash>{ genesis.open->hash () });
|
||||
auto vote = std::make_shared<nano::vote> (key.pub, key.prv, 1, std::vector<nano::block_hash>{ nano::dev::genesis->hash () });
|
||||
auto vote_invalid = std::make_shared<nano::vote> (*vote);
|
||||
vote_invalid->signature.bytes[0] ^= 1;
|
||||
auto channel = std::make_shared<nano::transport::channel_loopback> (node);
|
||||
|
||||
genesis.open->sideband_set (nano::block_sideband (nano::dev::genesis->account (), 0, nano::dev::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0));
|
||||
node.block_confirm (genesis.open);
|
||||
auto election = node.active.election (genesis.open->qualified_root ());
|
||||
node.block_confirm (nano::dev::genesis);
|
||||
auto election = node.active.election (nano::dev::genesis->qualified_root ());
|
||||
ASSERT_TRUE (election);
|
||||
ASSERT_EQ (1, election->votes ().size ());
|
||||
node.vote_processor.vote (vote_invalid, channel);
|
||||
|
|
@ -97,9 +92,8 @@ TEST (vote_processor, no_capacity)
|
|||
nano::node_flags node_flags;
|
||||
node_flags.vote_processor_capacity = 0;
|
||||
auto & node (*system.add_node (node_flags));
|
||||
nano::genesis genesis;
|
||||
nano::keypair key;
|
||||
auto vote (std::make_shared<nano::vote> (key.pub, key.prv, 1, std::vector<nano::block_hash>{ genesis.open->hash () }));
|
||||
auto vote (std::make_shared<nano::vote> (key.pub, key.prv, 1, std::vector<nano::block_hash>{ nano::dev::genesis->hash () }));
|
||||
auto channel (std::make_shared<nano::transport::channel_loopback> (node));
|
||||
ASSERT_TRUE (node.vote_processor.vote (vote, channel));
|
||||
}
|
||||
|
|
@ -110,9 +104,8 @@ TEST (vote_processor, overflow)
|
|||
nano::node_flags node_flags;
|
||||
node_flags.vote_processor_capacity = 1;
|
||||
auto & node (*system.add_node (node_flags));
|
||||
nano::genesis genesis;
|
||||
nano::keypair key;
|
||||
auto vote (std::make_shared<nano::vote> (key.pub, key.prv, 1, std::vector<nano::block_hash>{ genesis.open->hash () }));
|
||||
auto vote (std::make_shared<nano::vote> (key.pub, key.prv, 1, std::vector<nano::block_hash>{ nano::dev::genesis->hash () }));
|
||||
auto channel (std::make_shared<nano::transport::channel_loopback> (node));
|
||||
|
||||
// No way to lock the processor, but queueing votes in quick succession must result in overflow
|
||||
|
|
@ -262,14 +255,14 @@ TEST (vote_processor, no_broadcast_local)
|
|||
.account (key.pub)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.previous (0)
|
||||
.balance (nano::dev::genesis_amount - 2 * node.config.vote_minimum.number ())
|
||||
.balance (nano::dev::constants.genesis_amount - 2 * node.config.vote_minimum.number ())
|
||||
.link (send->hash ())
|
||||
.sign (key.prv, key.pub)
|
||||
.work (*system.work.generate (key.pub))
|
||||
.build (ec);
|
||||
ASSERT_FALSE (ec);
|
||||
ASSERT_EQ (nano::process_result::progress, node.process_local (open).code);
|
||||
ASSERT_EQ (nano::dev::genesis_amount - node.config.vote_minimum.number (), node.weight (nano::dev::genesis_key.pub));
|
||||
ASSERT_EQ (nano::dev::constants.genesis_amount - node.config.vote_minimum.number (), node.weight (nano::dev::genesis_key.pub));
|
||||
node.block_confirm (open);
|
||||
// Insert account in wallet
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
|
|
|
|||
|
|
@ -168,7 +168,7 @@ TEST (vote_spacing, vote_generator)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (nano::dev::genesis_key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
|
|
@ -177,7 +177,7 @@ TEST (vote_spacing, vote_generator)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio - 1)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio - 1)
|
||||
.link (nano::dev::genesis_key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
|
|
@ -211,7 +211,7 @@ TEST (vote_spacing, rapid)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (nano::dev::genesis_key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
|
|
@ -220,7 +220,7 @@ TEST (vote_spacing, rapid)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio - 1)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio - 1)
|
||||
.link (nano::dev::genesis_key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
|
|
|
|||
|
|
@ -169,7 +169,7 @@ TEST (wallet, insufficient_spend_one)
|
|||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
auto block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, 500));
|
||||
ASSERT_NE (nullptr, block);
|
||||
ASSERT_EQ (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, nano::dev::genesis_amount));
|
||||
ASSERT_EQ (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, nano::dev::constants.genesis_amount));
|
||||
}
|
||||
|
||||
TEST (wallet, spend_all_one)
|
||||
|
|
@ -636,7 +636,7 @@ TEST (wallet, work)
|
|||
nano::system system (1);
|
||||
auto wallet (system.wallet (0));
|
||||
wallet->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
nano::genesis genesis;
|
||||
wallet->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
auto done (false);
|
||||
system.deadline_set (20s);
|
||||
while (!done)
|
||||
|
|
@ -645,7 +645,7 @@ TEST (wallet, work)
|
|||
uint64_t work (0);
|
||||
if (!wallet->store.work_get (transaction, nano::dev::genesis_key.pub, work))
|
||||
{
|
||||
done = nano::work_difficulty (genesis.open->work_version (), genesis.hash (), work) >= system.nodes[0]->default_difficulty (genesis.open->work_version ());
|
||||
done = nano::work_difficulty (nano::dev::genesis->work_version (), nano::dev::genesis->hash (), work) >= system.nodes[0]->default_difficulty (nano::dev::genesis->work_version ());
|
||||
}
|
||||
ASSERT_NO_ERROR (system.poll ());
|
||||
}
|
||||
|
|
@ -837,7 +837,7 @@ TEST (wallet, send_race)
|
|||
for (auto i (1); i < 60; ++i)
|
||||
{
|
||||
ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, nano::Gxrb_ratio));
|
||||
ASSERT_EQ (nano::dev::genesis_amount - nano::Gxrb_ratio * i, system.nodes[0]->balance (nano::dev::genesis_key.pub));
|
||||
ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * i, system.nodes[0]->balance (nano::dev::genesis_key.pub));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1166,7 +1166,7 @@ TEST (wallet, search_pending)
|
|||
.account (nano::dev::genesis->account ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis->account ())
|
||||
.balance (nano::dev::genesis_amount - node.config.receive_minimum.number ())
|
||||
.balance (nano::dev::constants.genesis_amount - node.config.receive_minimum.number ())
|
||||
.link (nano::dev::genesis->account ())
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
|
|
@ -1193,7 +1193,7 @@ TEST (wallet, search_pending)
|
|||
// Pending search should create the receive block
|
||||
ASSERT_EQ (2, node.ledger.cache.block_count);
|
||||
ASSERT_FALSE (wallet.search_pending (wallet.wallets.tx_begin_read ()));
|
||||
ASSERT_TIMELY (3s, node.balance (nano::dev::genesis->account ()) == nano::dev::genesis_amount);
|
||||
ASSERT_TIMELY (3s, node.balance (nano::dev::genesis->account ()) == nano::dev::constants.genesis_amount);
|
||||
auto receive_hash = node.ledger.latest (node.store.tx_begin_read (), nano::dev::genesis->account ());
|
||||
auto receive = node.block (receive_hash);
|
||||
ASSERT_NE (nullptr, receive);
|
||||
|
|
|
|||
|
|
@ -97,8 +97,7 @@ TEST (wallets, vote_minimum)
|
|||
auto & node1 (*system.nodes[0]);
|
||||
nano::keypair key1;
|
||||
nano::keypair key2;
|
||||
nano::genesis genesis;
|
||||
nano::state_block send1 (nano::dev::genesis_key.pub, genesis.hash (), nano::dev::genesis_key.pub, std::numeric_limits<nano::uint128_t>::max () - node1.config.vote_minimum.number (), key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis.hash ()));
|
||||
nano::state_block send1 (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, std::numeric_limits<nano::uint128_t>::max () - node1.config.vote_minimum.number (), key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()));
|
||||
ASSERT_EQ (nano::process_result::progress, node1.process (send1).code);
|
||||
nano::state_block open1 (key1.pub, 0, key1.pub, node1.config.vote_minimum.number (), send1.hash (), key1.prv, key1.pub, *system.work.generate (key1.pub));
|
||||
ASSERT_EQ (nano::process_result::progress, node1.process (open1).code);
|
||||
|
|
@ -169,7 +168,7 @@ TEST (wallets, search_pending)
|
|||
.account (nano::dev::genesis->account ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis->account ())
|
||||
.balance (nano::dev::genesis_amount - node.config.receive_minimum.number ())
|
||||
.balance (nano::dev::constants.genesis_amount - node.config.receive_minimum.number ())
|
||||
.link (nano::dev::genesis->account ())
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
|
|
@ -210,7 +209,7 @@ TEST (wallets, search_pending)
|
|||
{
|
||||
node.wallets.search_pending (wallet_id);
|
||||
}
|
||||
ASSERT_TIMELY (3s, node.balance (nano::dev::genesis->account ()) == nano::dev::genesis_amount);
|
||||
ASSERT_TIMELY (3s, node.balance (nano::dev::genesis->account ()) == nano::dev::constants.genesis_amount);
|
||||
auto receive_hash = node.ledger.latest (node.store.tx_begin_read (), nano::dev::genesis->account ());
|
||||
auto receive = node.block (receive_hash);
|
||||
ASSERT_NE (nullptr, receive);
|
||||
|
|
|
|||
|
|
@ -83,7 +83,7 @@ TEST (websocket, confirmation)
|
|||
|
||||
nano::keypair key;
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
auto balance = nano::dev::genesis_amount;
|
||||
auto balance = nano::dev::constants.genesis_amount;
|
||||
auto send_amount = node1->online_reps.delta () + 1;
|
||||
// Quick-confirm a block, legacy blocks should work without filtering
|
||||
{
|
||||
|
|
@ -140,8 +140,7 @@ TEST (websocket, stopped_election)
|
|||
|
||||
// Create election, then erase it, causing a websocket message to be emitted
|
||||
nano::keypair key1;
|
||||
nano::genesis genesis;
|
||||
auto send1 (std::make_shared<nano::send_block> (genesis.hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis.hash ())));
|
||||
auto send1 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
|
||||
nano::publish publish1 (send1);
|
||||
auto channel1 (node1->network.udp_channels.create (node1->network.endpoint ()));
|
||||
node1->network.inbound (publish1, channel1);
|
||||
|
|
@ -186,7 +185,7 @@ TEST (websocket, confirmation_options)
|
|||
// Confirm a state block for an in-wallet account
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
nano::keypair key;
|
||||
auto balance = nano::dev::genesis_amount;
|
||||
auto balance = nano::dev::constants.genesis_amount;
|
||||
auto send_amount = node1->online_reps.delta () + 1;
|
||||
nano::block_hash previous (node1->latest (nano::dev::genesis_key.pub));
|
||||
{
|
||||
|
|
@ -320,7 +319,7 @@ TEST (websocket, confirmation_options_votes)
|
|||
// Confirm a state block for an in-wallet account
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
nano::keypair key;
|
||||
auto balance = nano::dev::genesis_amount;
|
||||
auto balance = nano::dev::constants.genesis_amount;
|
||||
auto send_amount = node1->config.online_weight_minimum.number () + 1;
|
||||
nano::block_hash previous (node1->latest (nano::dev::genesis_key.pub));
|
||||
{
|
||||
|
|
@ -422,7 +421,6 @@ TEST (websocket, confirmation_options_update)
|
|||
|
||||
// Confirm a block
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
nano::genesis genesis;
|
||||
nano::keypair key;
|
||||
nano::state_block_builder builder;
|
||||
auto previous (node1->latest (nano::dev::genesis_key.pub));
|
||||
|
|
@ -430,7 +428,7 @@ TEST (websocket, confirmation_options_update)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (previous)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
|
||||
.link (key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (previous))
|
||||
|
|
@ -448,7 +446,7 @@ TEST (websocket, confirmation_options_update)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (previous)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 2 * nano::Gxrb_ratio)
|
||||
.balance (nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio)
|
||||
.link (key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (previous))
|
||||
|
|
@ -490,7 +488,7 @@ TEST (websocket, vote)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (previous)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - (node1->online_reps.delta () + 1))
|
||||
.balance (nano::dev::constants.genesis_amount - (node1->online_reps.delta () + 1))
|
||||
.link (key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (previous))
|
||||
|
|
@ -532,8 +530,7 @@ TEST (websocket, vote_options_type)
|
|||
ASSERT_TIMELY (5s, ack_ready);
|
||||
|
||||
// Custom made votes for simplicity
|
||||
nano::genesis genesis;
|
||||
auto vote (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, genesis.open));
|
||||
auto vote (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, nano::dev::genesis));
|
||||
nano::websocket::message_builder builder;
|
||||
auto msg (builder.vote_received (vote, nano::vote_code::replay));
|
||||
node1->websocket_server->broadcast (msg);
|
||||
|
|
@ -582,7 +579,7 @@ TEST (websocket, vote_options_representatives)
|
|||
|
||||
// Quick-confirm a block
|
||||
nano::keypair key;
|
||||
auto balance = nano::dev::genesis_amount;
|
||||
auto balance = nano::dev::constants.genesis_amount;
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
auto send_amount = node1->online_reps.delta () + 1;
|
||||
auto confirm_block = [&] () {
|
||||
|
|
@ -913,15 +910,14 @@ TEST (websocket, new_unconfirmed_block)
|
|||
|
||||
nano::state_block_builder builder;
|
||||
// Process a new block
|
||||
nano::genesis genesis;
|
||||
auto send1 = builder
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (genesis.hash ())
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 1)
|
||||
.balance (nano::dev::constants.genesis_amount - 1)
|
||||
.link (nano::dev::genesis_key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (genesis.hash ()))
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
.build_shared ();
|
||||
|
||||
ASSERT_EQ (nano::process_result::progress, node1->process_local (send1).code);
|
||||
|
|
|
|||
|
|
@ -247,7 +247,7 @@ bool nano::bootstrap_attempt_lazy::process_block_lazy (std::shared_ptr<nano::blo
|
|||
if (!lazy_blocks_processed (hash))
|
||||
{
|
||||
// Search for new dependencies
|
||||
if (!block_a->source ().is_zero () && !node->ledger.block_or_pruned_exists (block_a->source ()) && block_a->source () != node->network_params.ledger.genesis_account ())
|
||||
if (!block_a->source ().is_zero () && !node->ledger.block_or_pruned_exists (block_a->source ()) && block_a->source () != node->network_params.ledger.genesis->account ())
|
||||
{
|
||||
lazy_add (block_a->source (), retry_limit);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -574,10 +574,10 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map
|
|||
{
|
||||
auto transaction (node.node->store.tx_begin_write ());
|
||||
auto conf_height_reset_num = 0;
|
||||
if (account == node.node->network_params.ledger.genesis_account ())
|
||||
if (account == node.node->network_params.ledger.genesis->account ())
|
||||
{
|
||||
conf_height_reset_num = 1;
|
||||
node.node->store.confirmation_height.put (transaction, account, { confirmation_height_info.height, node.node->network_params.ledger.genesis_hash () });
|
||||
node.node->store.confirmation_height.put (transaction, account, { confirmation_height_info.height, node.node->network_params.ledger.genesis->hash () });
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -1307,7 +1307,7 @@ void reset_confirmation_heights (nano::write_transaction const & transaction, na
|
|||
|
||||
// Then make sure the confirmation height of the genesis account open block is 1
|
||||
nano::network_params network_params;
|
||||
store.confirmation_height.put (transaction, network_params.ledger.genesis_account (), { 1, network_params.ledger.genesis_hash () });
|
||||
store.confirmation_height.put (transaction, network_params.ledger.genesis->account (), { 1, network_params.ledger.genesis->hash () });
|
||||
}
|
||||
|
||||
bool is_using_rocksdb (boost::filesystem::path const & data_path, boost::program_options::variables_map const & vm, std::error_code & ec)
|
||||
|
|
|
|||
|
|
@ -1041,11 +1041,11 @@ void nano::json_handler::active_difficulty ()
|
|||
|
||||
void nano::json_handler::available_supply ()
|
||||
{
|
||||
auto genesis_balance (node.balance (node.network_params.ledger.genesis_account ())); // Cold storage genesis
|
||||
auto genesis_balance (node.balance (node.network_params.ledger.genesis->account ())); // Cold storage genesis
|
||||
auto landing_balance (node.balance (nano::account ("059F68AAB29DE0D3A27443625C7EA9CDDB6517A8B76FE37727EF6A4D76832AD5"))); // Active unavailable account
|
||||
auto faucet_balance (node.balance (nano::account ("8E319CE6F3025E5B2DF66DA7AB1467FE48F1679C13DD43BFDB29FA2E9FC40D3B"))); // Faucet account
|
||||
auto burned_balance ((node.balance_pending (nano::account (0), false)).second); // Burning 0 account
|
||||
auto available (nano::dev::genesis_amount - genesis_balance - landing_balance - faucet_balance - burned_balance);
|
||||
auto available (nano::dev::constants.genesis_amount - genesis_balance - landing_balance - faucet_balance - burned_balance);
|
||||
response_l.put ("available", available.convert_to<std::string> ());
|
||||
response_errors ();
|
||||
}
|
||||
|
|
@ -2318,7 +2318,7 @@ public:
|
|||
// Report opens as a receive
|
||||
tree.put ("type", "receive");
|
||||
}
|
||||
if (block_a.hashables.source != network_params.ledger.genesis_account ())
|
||||
if (block_a.hashables.source != network_params.ledger.genesis->account ())
|
||||
{
|
||||
bool error_or_pruned (false);
|
||||
auto amount (handler.node.ledger.amount_safe (transaction, hash, error_or_pruned).convert_to<std::string> ());
|
||||
|
|
@ -2334,8 +2334,8 @@ public:
|
|||
}
|
||||
else
|
||||
{
|
||||
tree.put ("account", network_params.ledger.genesis_account ().to_account ());
|
||||
tree.put ("amount", nano::dev::genesis_amount.convert_to<std::string> ());
|
||||
tree.put ("account", network_params.ledger.genesis->account ().to_account ());
|
||||
tree.put ("amount", nano::dev::constants.genesis_amount.convert_to<std::string> ());
|
||||
}
|
||||
}
|
||||
void change_block (nano::change_block const & block_a)
|
||||
|
|
@ -3263,7 +3263,7 @@ void nano::json_handler::receive ()
|
|||
bool generate_work (work == 0); // Disable work generation if "work" option is provided
|
||||
auto response_a (response);
|
||||
wallet->receive_async (
|
||||
hash, representative, nano::dev::genesis_amount, account, [response_a] (std::shared_ptr<nano::block> const & block_a) {
|
||||
hash, representative, nano::dev::constants.genesis_amount, account, [response_a] (std::shared_ptr<nano::block> const & block_a) {
|
||||
if (block_a != nullptr)
|
||||
{
|
||||
boost::property_tree::ptree response_l;
|
||||
|
|
@ -4146,7 +4146,7 @@ void nano::json_handler::version ()
|
|||
response_l.put ("node_vendor", boost::str (boost::format ("Nano %1%") % NANO_VERSION_STRING));
|
||||
response_l.put ("store_vendor", node.store.vendor_get ());
|
||||
response_l.put ("network", node.network_params.network.get_current_network_as_string ());
|
||||
response_l.put ("network_identifier", node.network_params.ledger.genesis_hash ().to_string ());
|
||||
response_l.put ("network_identifier", node.network_params.ledger.genesis->hash ().to_string ());
|
||||
response_l.put ("build_info", BUILD_INFO);
|
||||
response_errors ();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1318,7 +1318,7 @@ void nano::node::process_confirmed_data (nano::transaction const & transaction_a
|
|||
bool error (false);
|
||||
auto previous_balance (ledger.balance_safe (transaction_a, previous, error));
|
||||
auto block_balance (store.block.balance_calculated (block_a));
|
||||
if (hash_a != ledger.network_params.ledger.genesis_account ())
|
||||
if (hash_a != ledger.network_params.ledger.genesis->account ())
|
||||
{
|
||||
if (!error)
|
||||
{
|
||||
|
|
@ -1331,7 +1331,7 @@ void nano::node::process_confirmed_data (nano::transaction const & transaction_a
|
|||
}
|
||||
else
|
||||
{
|
||||
amount_a = nano::dev::genesis_amount;
|
||||
amount_a = nano::dev::constants.genesis_amount;
|
||||
}
|
||||
if (auto state = dynamic_cast<nano::state_block *> (block_a.get ()))
|
||||
{
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ nano::node_config::node_config (uint16_t peering_port_a, nano::logging const & l
|
|||
{
|
||||
case nano::networks::nano_dev_network:
|
||||
enable_voting = true;
|
||||
preconfigured_representatives.push_back (network_params.ledger.genesis_account ());
|
||||
preconfigured_representatives.push_back (network_params.ledger.genesis->account ());
|
||||
break;
|
||||
case nano::networks::nano_beta_network:
|
||||
{
|
||||
|
|
@ -63,7 +63,7 @@ nano::node_config::node_config (uint16_t peering_port_a, nano::logging const & l
|
|||
break;
|
||||
case nano::networks::nano_test_network:
|
||||
preconfigured_peers.push_back (default_test_peer_network);
|
||||
preconfigured_representatives.push_back (network_params.ledger.genesis_account ());
|
||||
preconfigured_representatives.push_back (network_params.ledger.genesis->account ());
|
||||
break;
|
||||
default:
|
||||
debug_assert (false);
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ bool nano::telemetry::verify_message (nano::telemetry_ack const & message_a, nan
|
|||
if (!remove_channel)
|
||||
{
|
||||
// Check for different genesis blocks
|
||||
remove_channel = (message_a.data.genesis_block != network_params.ledger.genesis_hash ());
|
||||
remove_channel = (message_a.data.genesis_block != network_params.ledger.genesis->hash ());
|
||||
if (remove_channel)
|
||||
{
|
||||
stats.inc (nano::stat::type::telemetry, nano::stat::detail::different_genesis_hash);
|
||||
|
|
@ -634,7 +634,7 @@ nano::telemetry_data nano::local_telemetry_data (nano::ledger const & ledger_a,
|
|||
telemetry_data.protocol_version = network_params_a.protocol.protocol_version;
|
||||
telemetry_data.uptime = std::chrono::duration_cast<std::chrono::seconds> (std::chrono::steady_clock::now () - statup_time_a).count ();
|
||||
telemetry_data.unchecked_count = ledger_a.store.unchecked.count (ledger_a.store.tx_begin_read ());
|
||||
telemetry_data.genesis_block = network_params_a.ledger.genesis_hash ();
|
||||
telemetry_data.genesis_block = network_params_a.ledger.genesis->hash ();
|
||||
telemetry_data.peer_count = nano::narrow_cast<decltype (telemetry_data.peer_count)> (network_a.size ());
|
||||
telemetry_data.account_count = ledger_a.cache.account_count;
|
||||
telemetry_data.major_version = nano::get_major_node_version ();
|
||||
|
|
|
|||
|
|
@ -544,7 +544,7 @@ public:
|
|||
{
|
||||
static nano::network_params params;
|
||||
type = "Receive";
|
||||
if (block_a.hashables.source != params.ledger.genesis_account ())
|
||||
if (block_a.hashables.source != params.ledger.genesis->account ())
|
||||
{
|
||||
bool error_or_pruned (false);
|
||||
account = ledger.account_safe (transaction, block_a.hashables.source, error_or_pruned);
|
||||
|
|
@ -556,8 +556,8 @@ public:
|
|||
}
|
||||
else
|
||||
{
|
||||
account = params.ledger.genesis_account ();
|
||||
amount = nano::dev::genesis_amount;
|
||||
account = params.ledger.genesis->account ();
|
||||
amount = nano::dev::constants.genesis_amount;
|
||||
}
|
||||
}
|
||||
void change_block (nano::change_block const & block_a)
|
||||
|
|
|
|||
|
|
@ -562,9 +562,9 @@ TEST (history, pruned_source)
|
|||
auto transaction (store->tx_begin_write ());
|
||||
store->initialize (transaction, ledger.cache);
|
||||
auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub));
|
||||
nano::send_block send1 (latest, nano::dev::genesis_key.pub, nano::dev::genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
nano::send_block send1 (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code);
|
||||
nano::send_block send2 (send1.hash (), key.pub, nano::dev::genesis_amount - 200, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ()));
|
||||
nano::send_block send2 (send1.hash (), key.pub, nano::dev::constants.genesis_amount - 200, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ()));
|
||||
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code);
|
||||
nano::receive_block receive (send2.hash (), send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2.hash ()));
|
||||
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive).code);
|
||||
|
|
@ -592,7 +592,7 @@ TEST (history, pruned_source)
|
|||
{
|
||||
auto transaction (store->tx_begin_write ());
|
||||
auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub));
|
||||
nano::state_block send (nano::dev::genesis_key.pub, latest, nano::dev::genesis_key.pub, nano::dev::genesis_amount - 200, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
nano::state_block send (nano::dev::genesis_key.pub, latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 200, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code);
|
||||
auto latest_key (ledger.latest (transaction, key.pub));
|
||||
nano::state_block receive (key.pub, latest_key, key.pub, 200, send.hash (), key.prv, key.pub, *system.work.generate (latest_key));
|
||||
|
|
|
|||
|
|
@ -244,7 +244,7 @@ TEST (rpc, account_balance)
|
|||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::dev::genesis_amount - 1)
|
||||
.balance (nano::dev::constants.genesis_amount - 1)
|
||||
.link (nano::dev::genesis_key.pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (nano::dev::genesis->hash ()))
|
||||
|
|
@ -408,14 +408,14 @@ TEST (rpc, send)
|
|||
request.put ("source", nano::dev::genesis_key.pub.to_account ());
|
||||
request.put ("destination", nano::dev::genesis_key.pub.to_account ());
|
||||
request.put ("amount", "100");
|
||||
ASSERT_EQ (node->balance (nano::dev::genesis_key.pub), nano::dev::genesis_amount);
|
||||
ASSERT_EQ (node->balance (nano::dev::genesis_key.pub), nano::dev::constants.genesis_amount);
|
||||
auto response (wait_response (system, rpc, request, 10s));
|
||||
std::string block_text (response.get<std::string> ("block"));
|
||||
nano::block_hash block;
|
||||
ASSERT_FALSE (block.decode_hex (block_text));
|
||||
ASSERT_TRUE (node->ledger.block_or_pruned_exists (block));
|
||||
ASSERT_EQ (node->latest (nano::dev::genesis_key.pub), block);
|
||||
ASSERT_NE (node->balance (nano::dev::genesis_key.pub), nano::dev::genesis_amount);
|
||||
ASSERT_NE (node->balance (nano::dev::genesis_key.pub), nano::dev::constants.genesis_amount);
|
||||
}
|
||||
|
||||
TEST (rpc, send_fail)
|
||||
|
|
@ -495,18 +495,18 @@ TEST (rpc, send_idempotent)
|
|||
request.put ("action", "send");
|
||||
request.put ("source", nano::dev::genesis_key.pub.to_account ());
|
||||
request.put ("destination", nano::account (0).to_account ());
|
||||
request.put ("amount", (nano::dev::genesis_amount - (nano::dev::genesis_amount / 4)).convert_to<std::string> ());
|
||||
request.put ("amount", (nano::dev::constants.genesis_amount - (nano::dev::constants.genesis_amount / 4)).convert_to<std::string> ());
|
||||
request.put ("id", "123abc");
|
||||
auto response (wait_response (system, rpc, request));
|
||||
std::string block_text (response.get<std::string> ("block"));
|
||||
nano::block_hash block;
|
||||
ASSERT_FALSE (block.decode_hex (block_text));
|
||||
ASSERT_TRUE (node->ledger.block_or_pruned_exists (block));
|
||||
ASSERT_EQ (node->balance (nano::dev::genesis_key.pub), nano::dev::genesis_amount / 4);
|
||||
ASSERT_EQ (node->balance (nano::dev::genesis_key.pub), nano::dev::constants.genesis_amount / 4);
|
||||
auto response2 (wait_response (system, rpc, request));
|
||||
ASSERT_EQ ("", response2.get<std::string> ("error", ""));
|
||||
ASSERT_EQ (block_text, response2.get<std::string> ("block"));
|
||||
ASSERT_EQ (node->balance (nano::dev::genesis_key.pub), nano::dev::genesis_amount / 4);
|
||||
ASSERT_EQ (node->balance (nano::dev::genesis_key.pub), nano::dev::constants.genesis_amount / 4);
|
||||
request.erase ("id");
|
||||
request.put ("id", "456def");
|
||||
auto response3 (wait_response (system, rpc, request));
|
||||
|
|
@ -1094,9 +1094,9 @@ TEST (rpc, history)
|
|||
auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node0->config.receive_minimum.number (), send->link ().as_account ()));
|
||||
ASSERT_NE (nullptr, receive);
|
||||
nano::genesis genesis;
|
||||
nano::state_block usend (nano::dev::genesis->account (), node0->latest (nano::dev::genesis->account ()), nano::dev::genesis->account (), nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (node0->latest (nano::dev::genesis->account ())));
|
||||
nano::state_block ureceive (nano::dev::genesis->account (), usend.hash (), nano::dev::genesis->account (), nano::dev::genesis_amount, usend.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (usend.hash ()));
|
||||
nano::state_block uchange (nano::dev::genesis->account (), ureceive.hash (), nano::keypair ().pub, nano::dev::genesis_amount, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (ureceive.hash ()));
|
||||
nano::state_block usend (nano::dev::genesis->account (), node0->latest (nano::dev::genesis->account ()), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (node0->latest (nano::dev::genesis->account ())));
|
||||
nano::state_block ureceive (nano::dev::genesis->account (), usend.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, usend.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (usend.hash ()));
|
||||
nano::state_block uchange (nano::dev::genesis->account (), ureceive.hash (), nano::keypair ().pub, nano::dev::constants.genesis_amount, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (ureceive.hash ()));
|
||||
{
|
||||
auto transaction (node0->store.tx_begin_write ());
|
||||
ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, usend).code);
|
||||
|
|
@ -1135,7 +1135,7 @@ TEST (rpc, history)
|
|||
ASSERT_EQ (send->hash ().to_string (), std::get<3> (history_l[3]));
|
||||
ASSERT_EQ ("receive", std::get<0> (history_l[4]));
|
||||
ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<1> (history_l[4]));
|
||||
ASSERT_EQ (nano::dev::genesis_amount.convert_to<std::string> (), std::get<2> (history_l[4]));
|
||||
ASSERT_EQ (nano::dev::constants.genesis_amount.convert_to<std::string> (), std::get<2> (history_l[4]));
|
||||
ASSERT_EQ (genesis.hash ().to_string (), std::get<3> (history_l[4]));
|
||||
}
|
||||
|
||||
|
|
@ -1151,9 +1151,9 @@ TEST (rpc, account_history)
|
|||
auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node0->config.receive_minimum.number (), send->link ().as_account ()));
|
||||
ASSERT_NE (nullptr, receive);
|
||||
nano::genesis genesis;
|
||||
nano::state_block usend (nano::dev::genesis->account (), node0->latest (nano::dev::genesis->account ()), nano::dev::genesis->account (), nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (node0->latest (nano::dev::genesis->account ())));
|
||||
nano::state_block ureceive (nano::dev::genesis->account (), usend.hash (), nano::dev::genesis->account (), nano::dev::genesis_amount, usend.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (usend.hash ()));
|
||||
nano::state_block uchange (nano::dev::genesis->account (), ureceive.hash (), nano::keypair ().pub, nano::dev::genesis_amount, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (ureceive.hash ()));
|
||||
nano::state_block usend (nano::dev::genesis->account (), node0->latest (nano::dev::genesis->account ()), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (node0->latest (nano::dev::genesis->account ())));
|
||||
nano::state_block ureceive (nano::dev::genesis->account (), usend.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, usend.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (usend.hash ()));
|
||||
nano::state_block uchange (nano::dev::genesis->account (), ureceive.hash (), nano::keypair ().pub, nano::dev::constants.genesis_amount, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (ureceive.hash ()));
|
||||
{
|
||||
auto transaction (node0->store.tx_begin_write ());
|
||||
ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, usend).code);
|
||||
|
|
@ -1197,7 +1197,7 @@ TEST (rpc, account_history)
|
|||
ASSERT_EQ ("3", std::get<4> (history_l[3]));
|
||||
ASSERT_EQ ("receive", std::get<0> (history_l[4]));
|
||||
ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<1> (history_l[4]));
|
||||
ASSERT_EQ (nano::dev::genesis_amount.convert_to<std::string> (), std::get<2> (history_l[4]));
|
||||
ASSERT_EQ (nano::dev::constants.genesis_amount.convert_to<std::string> (), std::get<2> (history_l[4]));
|
||||
ASSERT_EQ (genesis.hash ().to_string (), std::get<3> (history_l[4]));
|
||||
ASSERT_EQ ("1", std::get<4> (history_l[4])); // change block (height 2) is skipped
|
||||
}
|
||||
|
|
@ -1287,13 +1287,13 @@ TEST (rpc, history_pruning)
|
|||
nano::genesis genesis;
|
||||
auto change (std::make_shared<nano::change_block> (genesis.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work.generate (genesis.hash ())));
|
||||
node0->process_active (change);
|
||||
auto send (std::make_shared<nano::send_block> (change->hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - node0->config.receive_minimum.number (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work.generate (change->hash ())));
|
||||
auto send (std::make_shared<nano::send_block> (change->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - node0->config.receive_minimum.number (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work.generate (change->hash ())));
|
||||
node0->process_active (send);
|
||||
auto receive (std::make_shared<nano::receive_block> (send->hash (), send->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work.generate (send->hash ())));
|
||||
node0->process_active (receive);
|
||||
auto usend (std::make_shared<nano::state_block> (nano::dev::genesis->account (), receive->hash (), nano::dev::genesis->account (), nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (receive->hash ())));
|
||||
auto ureceive (std::make_shared<nano::state_block> (nano::dev::genesis->account (), usend->hash (), nano::dev::genesis->account (), nano::dev::genesis_amount, usend->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (usend->hash ())));
|
||||
auto uchange (std::make_shared<nano::state_block> (nano::dev::genesis->account (), ureceive->hash (), nano::keypair ().pub, nano::dev::genesis_amount, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (ureceive->hash ())));
|
||||
auto usend (std::make_shared<nano::state_block> (nano::dev::genesis->account (), receive->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (receive->hash ())));
|
||||
auto ureceive (std::make_shared<nano::state_block> (nano::dev::genesis->account (), usend->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, usend->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (usend->hash ())));
|
||||
auto uchange (std::make_shared<nano::state_block> (nano::dev::genesis->account (), ureceive->hash (), nano::keypair ().pub, nano::dev::constants.genesis_amount, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (ureceive->hash ())));
|
||||
node0->process_active (usend);
|
||||
node0->process_active (ureceive);
|
||||
node0->process_active (uchange);
|
||||
|
|
@ -1498,7 +1498,7 @@ TEST (rpc, process_block_async)
|
|||
ASSERT_EQ (ec.message (), response.get<std::string> ("error"));
|
||||
}
|
||||
|
||||
auto state_send (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, latest, nano::dev::genesis_key.pub, nano::dev::genesis_amount - 100, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)));
|
||||
auto state_send (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)));
|
||||
std::string json1;
|
||||
state_send->serialize_json (json1);
|
||||
request.put ("block", json1);
|
||||
|
|
@ -1554,7 +1554,7 @@ TEST (rpc, process_subtype_send)
|
|||
auto [rpc, rpc_ctx] = add_rpc (system, node1);
|
||||
nano::keypair key;
|
||||
auto latest (node1->latest (nano::dev::genesis_key.pub));
|
||||
nano::state_block send (nano::dev::genesis->account (), latest, nano::dev::genesis->account (), nano::dev::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest));
|
||||
nano::state_block send (nano::dev::genesis->account (), latest, nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest));
|
||||
boost::property_tree::ptree request;
|
||||
request.put ("action", "process");
|
||||
std::string json;
|
||||
|
|
@ -1580,7 +1580,7 @@ TEST (rpc, process_subtype_open)
|
|||
auto & node2 = *system.add_node ();
|
||||
nano::keypair key;
|
||||
auto latest (node1->latest (nano::dev::genesis_key.pub));
|
||||
auto send = std::make_shared<nano::state_block> (nano::dev::genesis->account (), latest, nano::dev::genesis->account (), nano::dev::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest));
|
||||
auto send = std::make_shared<nano::state_block> (nano::dev::genesis->account (), latest, nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest));
|
||||
ASSERT_EQ (nano::process_result::progress, node1->process (*send).code);
|
||||
ASSERT_EQ (nano::process_result::progress, node2.process (*send).code);
|
||||
auto [rpc, rpc_ctx] = add_rpc (system, node1);
|
||||
|
|
@ -1610,12 +1610,12 @@ TEST (rpc, process_subtype_receive)
|
|||
auto node1 = add_ipc_enabled_node (system);
|
||||
auto & node2 = *system.add_node ();
|
||||
auto latest (node1->latest (nano::dev::genesis_key.pub));
|
||||
auto send = std::make_shared<nano::state_block> (nano::dev::genesis->account (), latest, nano::dev::genesis->account (), nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest));
|
||||
auto send = std::make_shared<nano::state_block> (nano::dev::genesis->account (), latest, nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest));
|
||||
ASSERT_EQ (nano::process_result::progress, node1->process (*send).code);
|
||||
ASSERT_EQ (nano::process_result::progress, node2.process (*send).code);
|
||||
auto [rpc, rpc_ctx] = add_rpc (system, node1);
|
||||
node1->scheduler.manual (send);
|
||||
nano::state_block receive (nano::dev::genesis_key.pub, send->hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount, send->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (send->hash ()));
|
||||
nano::state_block receive (nano::dev::genesis_key.pub, send->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, send->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (send->hash ()));
|
||||
boost::property_tree::ptree request;
|
||||
request.put ("action", "process");
|
||||
std::string json;
|
||||
|
|
@ -1644,7 +1644,7 @@ TEST (rpc, process_ledger_insufficient_work)
|
|||
auto latest (node->latest (nano::dev::genesis_key.pub));
|
||||
auto min_difficulty = node->network_params.network.publish_thresholds.entry;
|
||||
auto max_difficulty = node->network_params.network.publish_thresholds.epoch_1;
|
||||
nano::state_block send (nano::dev::genesis->account (), latest, nano::dev::genesis->account (), nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, system.work_generate_limited (latest, min_difficulty, max_difficulty));
|
||||
nano::state_block send (nano::dev::genesis->account (), latest, nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, system.work_generate_limited (latest, min_difficulty, max_difficulty));
|
||||
ASSERT_LT (send.difficulty (), max_difficulty);
|
||||
ASSERT_GE (send.difficulty (), min_difficulty);
|
||||
boost::property_tree::ptree request;
|
||||
|
|
@ -1885,7 +1885,7 @@ TEST (rpc, search_pending)
|
|||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
auto wallet (node->wallets.items.begin ()->first.to_string ());
|
||||
auto latest (node->latest (nano::dev::genesis_key.pub));
|
||||
nano::send_block block (latest, nano::dev::genesis_key.pub, nano::dev::genesis_amount - node->config.receive_minimum.number (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (latest));
|
||||
nano::send_block block (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - node->config.receive_minimum.number (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (latest));
|
||||
{
|
||||
auto transaction (node->store.tx_begin_write ());
|
||||
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, block).code);
|
||||
|
|
@ -1895,7 +1895,7 @@ TEST (rpc, search_pending)
|
|||
request.put ("action", "search_pending");
|
||||
request.put ("wallet", wallet);
|
||||
auto response (wait_response (system, rpc, request));
|
||||
ASSERT_TIMELY (10s, node->balance (nano::dev::genesis_key.pub) == nano::dev::genesis_amount);
|
||||
ASSERT_TIMELY (10s, node->balance (nano::dev::genesis_key.pub) == nano::dev::constants.genesis_amount);
|
||||
}
|
||||
|
||||
TEST (rpc, version)
|
||||
|
|
@ -2338,7 +2338,7 @@ TEST (rpc, block_count_pruning)
|
|||
node_flags.enable_pruning = true;
|
||||
auto node1 = add_ipc_enabled_node (system, node_config, node_flags);
|
||||
auto latest (node1->latest (nano::dev::genesis_key.pub));
|
||||
auto send1 (std::make_shared<nano::send_block> (latest, nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)));
|
||||
auto send1 (std::make_shared<nano::send_block> (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)));
|
||||
node1->process_active (send1);
|
||||
auto receive1 (std::make_shared<nano::receive_block> (send1->hash (), send1->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (send1->hash ())));
|
||||
node1->process_active (receive1);
|
||||
|
|
@ -2886,7 +2886,7 @@ TEST (rpc, republish)
|
|||
request.put ("action", "republish");
|
||||
request.put ("hash", send.hash ().to_string ());
|
||||
auto response (wait_response (system, rpc, request));
|
||||
ASSERT_TIMELY (10s, system.nodes[1]->balance (nano::dev::genesis_key.pub) != nano::dev::genesis_amount);
|
||||
ASSERT_TIMELY (10s, system.nodes[1]->balance (nano::dev::genesis_key.pub) != nano::dev::constants.genesis_amount);
|
||||
auto & blocks_node (response.get_child ("blocks"));
|
||||
std::vector<nano::block_hash> blocks;
|
||||
for (auto i (blocks_node.begin ()), n (blocks_node.end ()); i != n; ++i)
|
||||
|
|
@ -3430,7 +3430,7 @@ TEST (rpc, search_pending_all)
|
|||
auto node = add_ipc_enabled_node (system);
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
auto latest (node->latest (nano::dev::genesis_key.pub));
|
||||
nano::send_block block (latest, nano::dev::genesis_key.pub, nano::dev::genesis_amount - node->config.receive_minimum.number (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (latest));
|
||||
nano::send_block block (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - node->config.receive_minimum.number (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (latest));
|
||||
{
|
||||
auto transaction (node->store.tx_begin_write ());
|
||||
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, block).code);
|
||||
|
|
@ -3439,7 +3439,7 @@ TEST (rpc, search_pending_all)
|
|||
boost::property_tree::ptree request;
|
||||
request.put ("action", "search_pending_all");
|
||||
auto response (wait_response (system, rpc, request));
|
||||
ASSERT_TIMELY (10s, node->balance (nano::dev::genesis_key.pub) == nano::dev::genesis_amount);
|
||||
ASSERT_TIMELY (10s, node->balance (nano::dev::genesis_key.pub) == nano::dev::constants.genesis_amount);
|
||||
}
|
||||
|
||||
TEST (rpc, wallet_republish)
|
||||
|
|
@ -3783,7 +3783,7 @@ TEST (rpc, json_block_input)
|
|||
auto node1 = add_ipc_enabled_node (system);
|
||||
nano::keypair key;
|
||||
system.wallet (0)->insert_adhoc (key.prv);
|
||||
nano::state_block send (nano::dev::genesis->account (), node1->latest (nano::dev::genesis_key.pub), nano::dev::genesis->account (), nano::dev::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0);
|
||||
nano::state_block send (nano::dev::genesis->account (), node1->latest (nano::dev::genesis_key.pub), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0);
|
||||
auto [rpc, rpc_ctx] = add_rpc (system, node1);
|
||||
boost::property_tree::ptree request;
|
||||
request.put ("action", "sign");
|
||||
|
|
@ -3841,7 +3841,7 @@ TEST (rpc, blocks_info)
|
|||
std::string account_text (blocks.second.get<std::string> ("block_account"));
|
||||
ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), account_text);
|
||||
std::string amount_text (blocks.second.get<std::string> ("amount"));
|
||||
ASSERT_EQ (nano::dev::genesis_amount.convert_to<std::string> (), amount_text);
|
||||
ASSERT_EQ (nano::dev::constants.genesis_amount.convert_to<std::string> (), amount_text);
|
||||
std::string blocks_text (blocks.second.get<std::string> ("contents"));
|
||||
ASSERT_FALSE (blocks_text.empty ());
|
||||
boost::optional<std::string> pending (blocks.second.get_optional<std::string> ("pending"));
|
||||
|
|
@ -3849,7 +3849,7 @@ TEST (rpc, blocks_info)
|
|||
boost::optional<std::string> source (blocks.second.get_optional<std::string> ("source_account"));
|
||||
ASSERT_FALSE (source.is_initialized ());
|
||||
std::string balance_text (blocks.second.get<std::string> ("balance"));
|
||||
ASSERT_EQ (nano::dev::genesis_amount.convert_to<std::string> (), balance_text);
|
||||
ASSERT_EQ (nano::dev::constants.genesis_amount.convert_to<std::string> (), balance_text);
|
||||
ASSERT_TRUE (blocks.second.get<bool> ("confirmed")); // Genesis block is confirmed by default
|
||||
std::string successor_text (blocks.second.get<std::string> ("successor"));
|
||||
ASSERT_EQ (nano::block_hash (0).to_string (), successor_text); // Genesis block doesn't have successor yet
|
||||
|
|
@ -3960,14 +3960,14 @@ TEST (rpc, block_info_successor)
|
|||
std::string account_text (response.get<std::string> ("block_account"));
|
||||
ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), account_text);
|
||||
std::string amount_text (response.get<std::string> ("amount"));
|
||||
ASSERT_EQ (nano::dev::genesis_amount.convert_to<std::string> (), amount_text);
|
||||
ASSERT_EQ (nano::dev::constants.genesis_amount.convert_to<std::string> (), amount_text);
|
||||
}
|
||||
|
||||
TEST (rpc, block_info_pruning)
|
||||
{
|
||||
nano::system system;
|
||||
nano::node_config node_config0 (nano::get_available_port (), system.logging);
|
||||
node_config0.receive_minimum = nano::dev::genesis_amount; // Prevent auto-receive & receive1 block conflicts
|
||||
node_config0.receive_minimum = nano::dev::constants.genesis_amount; // Prevent auto-receive & receive1 block conflicts
|
||||
auto & node0 = *system.add_node (node_config0);
|
||||
nano::node_config node_config1 (nano::get_available_port (), system.logging);
|
||||
node_config1.enable_voting = false; // Remove after allowing pruned voting
|
||||
|
|
@ -3975,7 +3975,7 @@ TEST (rpc, block_info_pruning)
|
|||
node_flags.enable_pruning = true;
|
||||
auto node1 = add_ipc_enabled_node (system, node_config1, node_flags);
|
||||
auto latest (node1->latest (nano::dev::genesis_key.pub));
|
||||
auto send1 (std::make_shared<nano::send_block> (latest, nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)));
|
||||
auto send1 (std::make_shared<nano::send_block> (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)));
|
||||
node1->process_active (send1);
|
||||
auto receive1 (std::make_shared<nano::receive_block> (send1->hash (), send1->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (send1->hash ())));
|
||||
node1->process_active (receive1);
|
||||
|
|
@ -4010,7 +4010,7 @@ TEST (rpc, block_info_pruning)
|
|||
ASSERT_FALSE (json_error);
|
||||
ASSERT_EQ (receive1->full_hash (), receive_from_json.full_hash ());
|
||||
std::string balance_text (response2.get<std::string> ("balance"));
|
||||
ASSERT_EQ (nano::dev::genesis_amount.convert_to<std::string> (), balance_text);
|
||||
ASSERT_EQ (nano::dev::constants.genesis_amount.convert_to<std::string> (), balance_text);
|
||||
ASSERT_TRUE (response2.get<bool> ("confirmed"));
|
||||
std::string successor_text (response2.get<std::string> ("successor"));
|
||||
ASSERT_EQ (successor_text, nano::block_hash (0).to_string ()); // receive1 block doesn't have successor yet
|
||||
|
|
@ -4020,7 +4020,7 @@ TEST (rpc, pruned_exists)
|
|||
{
|
||||
nano::system system;
|
||||
nano::node_config node_config0 (nano::get_available_port (), system.logging);
|
||||
node_config0.receive_minimum = nano::dev::genesis_amount; // Prevent auto-receive & receive1 block conflicts
|
||||
node_config0.receive_minimum = nano::dev::constants.genesis_amount; // Prevent auto-receive & receive1 block conflicts
|
||||
auto & node0 = *system.add_node (node_config0);
|
||||
nano::node_config node_config1 (nano::get_available_port (), system.logging);
|
||||
node_config1.enable_voting = false; // Remove after allowing pruned voting
|
||||
|
|
@ -4028,7 +4028,7 @@ TEST (rpc, pruned_exists)
|
|||
node_flags.enable_pruning = true;
|
||||
auto node1 = add_ipc_enabled_node (system, node_config1, node_flags);
|
||||
auto latest (node1->latest (nano::dev::genesis_key.pub));
|
||||
auto send1 (std::make_shared<nano::send_block> (latest, nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)));
|
||||
auto send1 (std::make_shared<nano::send_block> (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)));
|
||||
node1->process_active (send1);
|
||||
auto receive1 (std::make_shared<nano::receive_block> (send1->hash (), send1->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (send1->hash ())));
|
||||
node1->process_active (receive1);
|
||||
|
|
@ -4095,7 +4095,7 @@ TEST (rpc, ledger)
|
|||
auto node = add_ipc_enabled_node (system);
|
||||
nano::keypair key;
|
||||
auto latest (node->latest (nano::dev::genesis_key.pub));
|
||||
auto genesis_balance (nano::dev::genesis_amount);
|
||||
auto genesis_balance (nano::dev::constants.genesis_amount);
|
||||
auto send_amount (genesis_balance - 100);
|
||||
genesis_balance -= send_amount;
|
||||
nano::send_block send (latest, key.pub, genesis_balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (latest));
|
||||
|
|
@ -4321,7 +4321,7 @@ TEST (rpc, block_create_state)
|
|||
request.put ("account", nano::dev::genesis_key.pub.to_account ());
|
||||
request.put ("previous", genesis.hash ().to_string ());
|
||||
request.put ("representative", nano::dev::genesis_key.pub.to_account ());
|
||||
request.put ("balance", (nano::dev::genesis_amount - nano::Gxrb_ratio).convert_to<std::string> ());
|
||||
request.put ("balance", (nano::dev::constants.genesis_amount - nano::Gxrb_ratio).convert_to<std::string> ());
|
||||
request.put ("link", key.pub.to_account ());
|
||||
request.put ("work", nano::to_string_hex (*node->work_generate_blocking (genesis.hash ())));
|
||||
auto response (wait_response (system, rpc, request));
|
||||
|
|
@ -4406,7 +4406,7 @@ TEST (rpc, block_create_state_request_work)
|
|||
request.put ("wallet", node->wallets.items.begin ()->first.to_string ());
|
||||
request.put ("account", nano::dev::genesis_key.pub.to_account ());
|
||||
request.put ("representative", nano::dev::genesis_key.pub.to_account ());
|
||||
request.put ("balance", (nano::dev::genesis_amount - nano::Gxrb_ratio).convert_to<std::string> ());
|
||||
request.put ("balance", (nano::dev::constants.genesis_amount - nano::Gxrb_ratio).convert_to<std::string> ());
|
||||
request.put ("link", key.pub.to_account ());
|
||||
request.put ("previous", previous);
|
||||
auto response (wait_response (system, rpc, request));
|
||||
|
|
@ -4718,7 +4718,7 @@ TEST (rpc, online_reps)
|
|||
auto send_block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, nano::Gxrb_ratio));
|
||||
ASSERT_NE (nullptr, send_block);
|
||||
ASSERT_TIMELY (10s, !node2->online_reps.list ().empty ());
|
||||
ASSERT_EQ (node2->online_reps.online (), nano::dev::genesis_amount - nano::Gxrb_ratio);
|
||||
ASSERT_EQ (node2->online_reps.online (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio);
|
||||
auto [rpc, rpc_ctx] = add_rpc (system, node2);
|
||||
boost::property_tree::ptree request;
|
||||
request.put ("action", "representatives_online");
|
||||
|
|
@ -4786,7 +4786,7 @@ TEST (rpc, confirmation_height_currently_processing)
|
|||
{
|
||||
auto transaction = node->store.tx_begin_write ();
|
||||
nano::keypair key1;
|
||||
nano::send_block send (previous_genesis_chain_hash, key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio - 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous_genesis_chain_hash));
|
||||
nano::send_block send (previous_genesis_chain_hash, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio - 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous_genesis_chain_hash));
|
||||
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
|
||||
previous_genesis_chain_hash = send.hash ();
|
||||
}
|
||||
|
|
@ -4856,7 +4856,7 @@ TEST (rpc, confirmation_history)
|
|||
ASSERT_EQ (block->hash ().to_string (), hash);
|
||||
nano::amount tally_num;
|
||||
tally_num.decode_dec (tally);
|
||||
debug_assert (tally_num == nano::dev::genesis_amount || tally_num == (nano::dev::genesis_amount - nano::Gxrb_ratio));
|
||||
debug_assert (tally_num == nano::dev::constants.genesis_amount || tally_num == (nano::dev::constants.genesis_amount - nano::Gxrb_ratio));
|
||||
system.stop ();
|
||||
}
|
||||
|
||||
|
|
@ -4887,7 +4887,7 @@ TEST (rpc, confirmation_history_hash)
|
|||
ASSERT_EQ (send2->hash ().to_string (), hash);
|
||||
nano::amount tally_num;
|
||||
tally_num.decode_dec (tally);
|
||||
debug_assert (tally_num == nano::dev::genesis_amount || tally_num == (nano::dev::genesis_amount - nano::Gxrb_ratio) || tally_num == (nano::dev::genesis_amount - 2 * nano::Gxrb_ratio) || tally_num == (nano::dev::genesis_amount - 3 * nano::Gxrb_ratio));
|
||||
debug_assert (tally_num == nano::dev::constants.genesis_amount || tally_num == (nano::dev::constants.genesis_amount - nano::Gxrb_ratio) || tally_num == (nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio) || tally_num == (nano::dev::constants.genesis_amount - 3 * nano::Gxrb_ratio));
|
||||
system.stop ();
|
||||
}
|
||||
|
||||
|
|
@ -4897,7 +4897,7 @@ TEST (rpc, block_confirm)
|
|||
auto node = add_ipc_enabled_node (system);
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
nano::genesis genesis;
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, genesis.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (genesis.hash ())));
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, genesis.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (genesis.hash ())));
|
||||
{
|
||||
auto transaction (node->store.tx_begin_write ());
|
||||
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code);
|
||||
|
|
@ -5220,7 +5220,7 @@ TEST (rpc, wallet_history)
|
|||
// Genesis block
|
||||
ASSERT_EQ ("receive", std::get<0> (history_l[3]));
|
||||
ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<1> (history_l[3]));
|
||||
ASSERT_EQ (nano::dev::genesis_amount.convert_to<std::string> (), std::get<2> (history_l[3]));
|
||||
ASSERT_EQ (nano::dev::constants.genesis_amount.convert_to<std::string> (), std::get<2> (history_l[3]));
|
||||
ASSERT_EQ (nano::dev::genesis->hash ().to_string (), std::get<3> (history_l[3]));
|
||||
ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<4> (history_l[3]));
|
||||
}
|
||||
|
|
@ -5230,7 +5230,7 @@ TEST (rpc, sign_hash)
|
|||
nano::system system;
|
||||
auto node1 = add_ipc_enabled_node (system);
|
||||
nano::keypair key;
|
||||
nano::state_block send (nano::dev::genesis->account (), node1->latest (nano::dev::genesis_key.pub), nano::dev::genesis->account (), nano::dev::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0);
|
||||
nano::state_block send (nano::dev::genesis->account (), node1->latest (nano::dev::genesis_key.pub), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0);
|
||||
auto [rpc, rpc_ctx] = add_rpc (system, node1);
|
||||
boost::property_tree::ptree request;
|
||||
request.put ("action", "sign");
|
||||
|
|
@ -5253,7 +5253,7 @@ TEST (rpc, sign_block)
|
|||
auto node1 = add_ipc_enabled_node (system);
|
||||
nano::keypair key;
|
||||
system.wallet (0)->insert_adhoc (key.prv);
|
||||
nano::state_block send (nano::dev::genesis->account (), node1->latest (nano::dev::genesis_key.pub), nano::dev::genesis->account (), nano::dev::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0);
|
||||
nano::state_block send (nano::dev::genesis->account (), node1->latest (nano::dev::genesis_key.pub), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0);
|
||||
auto [rpc, rpc_ctx] = add_rpc (system, node1);
|
||||
boost::property_tree::ptree request;
|
||||
request.put ("action", "sign");
|
||||
|
|
@ -5642,14 +5642,14 @@ TEST (rpc, epoch_upgrade)
|
|||
auto node = add_ipc_enabled_node (system);
|
||||
nano::keypair key1, key2, key3;
|
||||
nano::keypair epoch_signer (nano::dev::genesis_key);
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - 1, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); // to opened account
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 1, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); // to opened account
|
||||
ASSERT_EQ (nano::process_result::progress, node->process (*send1).code);
|
||||
auto send2 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, send1->hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - 2, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ()))); // to unopened account (pending)
|
||||
auto send2 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, send1->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 2, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ()))); // to unopened account (pending)
|
||||
ASSERT_EQ (nano::process_result::progress, node->process (*send2).code);
|
||||
auto send3 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, send2->hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - 3, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2->hash ()))); // to burn (0)
|
||||
auto send3 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, send2->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 3, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2->hash ()))); // to burn (0)
|
||||
ASSERT_EQ (nano::process_result::progress, node->process (*send3).code);
|
||||
nano::account max_account (std::numeric_limits<nano::uint256_t>::max ());
|
||||
auto send4 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, send3->hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - 4, max_account, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send3->hash ()))); // to max account
|
||||
auto send4 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, send3->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 4, max_account, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send3->hash ()))); // to max account
|
||||
ASSERT_EQ (nano::process_result::progress, node->process (*send4).code);
|
||||
auto open (std::make_shared<nano::state_block> (key1.pub, 0, key1.pub, 1, send1->hash (), key1.prv, key1.pub, *system.work.generate (key1.pub)));
|
||||
ASSERT_EQ (nano::process_result::progress, node->process (*open).code);
|
||||
|
|
@ -5691,9 +5691,9 @@ TEST (rpc, epoch_upgrade)
|
|||
rpc_ctx->io_scope->reset ();
|
||||
// Epoch 2 upgrade
|
||||
auto genesis_latest (node->latest (nano::dev::genesis_key.pub));
|
||||
auto send5 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, genesis_latest, nano::dev::genesis_key.pub, nano::dev::genesis_amount - 5, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis_latest))); // to burn (0)
|
||||
auto send5 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, genesis_latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 5, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis_latest))); // to burn (0)
|
||||
ASSERT_EQ (nano::process_result::progress, node->process (*send5).code);
|
||||
auto send6 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, send5->hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - 6, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send5->hash ()))); // to key1 (again)
|
||||
auto send6 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, send5->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 6, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send5->hash ()))); // to key1 (again)
|
||||
ASSERT_EQ (nano::process_result::progress, node->process (*send6).code);
|
||||
auto key1_latest (node->latest (key1.pub));
|
||||
auto send7 (std::make_shared<nano::state_block> (key1.pub, key1_latest, key1.pub, 0, key3.pub, key1.prv, key1.pub, *system.work.generate (key1_latest))); // to key3
|
||||
|
|
@ -5736,14 +5736,14 @@ TEST (rpc, epoch_upgrade_multithreaded)
|
|||
auto node = add_ipc_enabled_node (system, node_config);
|
||||
nano::keypair key1, key2, key3;
|
||||
nano::keypair epoch_signer (nano::dev::genesis_key);
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - 1, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); // to opened account
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 1, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); // to opened account
|
||||
ASSERT_EQ (nano::process_result::progress, node->process (*send1).code);
|
||||
auto send2 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, send1->hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - 2, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ()))); // to unopened account (pending)
|
||||
auto send2 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, send1->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 2, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ()))); // to unopened account (pending)
|
||||
ASSERT_EQ (nano::process_result::progress, node->process (*send2).code);
|
||||
auto send3 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, send2->hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - 3, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2->hash ()))); // to burn (0)
|
||||
auto send3 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, send2->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 3, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2->hash ()))); // to burn (0)
|
||||
ASSERT_EQ (nano::process_result::progress, node->process (*send3).code);
|
||||
nano::account max_account (std::numeric_limits<nano::uint256_t>::max ());
|
||||
auto send4 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, send3->hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - 4, max_account, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send3->hash ()))); // to max account
|
||||
auto send4 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, send3->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 4, max_account, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send3->hash ()))); // to max account
|
||||
ASSERT_EQ (nano::process_result::progress, node->process (*send4).code);
|
||||
auto open (std::make_shared<nano::state_block> (key1.pub, 0, key1.pub, 1, send1->hash (), key1.prv, key1.pub, *system.work.generate (key1.pub)));
|
||||
ASSERT_EQ (nano::process_result::progress, node->process (*open).code);
|
||||
|
|
@ -5784,9 +5784,9 @@ TEST (rpc, epoch_upgrade_multithreaded)
|
|||
rpc_ctx->io_scope->reset ();
|
||||
// Epoch 2 upgrade
|
||||
auto genesis_latest (node->latest (nano::dev::genesis_key.pub));
|
||||
auto send5 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, genesis_latest, nano::dev::genesis_key.pub, nano::dev::genesis_amount - 5, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis_latest))); // to burn (0)
|
||||
auto send5 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, genesis_latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 5, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis_latest))); // to burn (0)
|
||||
ASSERT_EQ (nano::process_result::progress, node->process (*send5).code);
|
||||
auto send6 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, send5->hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - 6, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send5->hash ()))); // to key1 (again)
|
||||
auto send6 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, send5->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 6, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send5->hash ()))); // to key1 (again)
|
||||
ASSERT_EQ (nano::process_result::progress, node->process (*send6).code);
|
||||
auto key1_latest (node->latest (key1.pub));
|
||||
auto send7 (std::make_shared<nano::state_block> (key1.pub, key1_latest, key1.pub, 0, key3.pub, key1.prv, key1.pub, *system.work.generate (key1_latest))); // to key3
|
||||
|
|
@ -5829,7 +5829,7 @@ TEST (rpc, account_lazy_start)
|
|||
auto node1 = system.add_node (node_flags);
|
||||
nano::keypair key;
|
||||
// Generating test chain
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
|
||||
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
|
||||
ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code);
|
||||
auto open (std::make_shared<nano::open_block> (send1->hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)));
|
||||
ASSERT_EQ (nano::process_result::progress, node1->process (*open).code);
|
||||
|
|
@ -5866,7 +5866,7 @@ TEST (rpc, receive)
|
|||
nano::keypair key1;
|
||||
wallet->insert_adhoc (key1.prv);
|
||||
auto send1 (wallet->send_action (nano::dev::genesis_key.pub, key1.pub, node->config.receive_minimum.number (), *node->work_generate_blocking (nano::dev::genesis->hash ())));
|
||||
ASSERT_TIMELY (5s, node->balance (nano::dev::genesis_key.pub) != nano::dev::genesis_amount);
|
||||
ASSERT_TIMELY (5s, node->balance (nano::dev::genesis_key.pub) != nano::dev::constants.genesis_amount);
|
||||
ASSERT_TIMELY (10s, !node->store.account.exists (node->store.tx_begin_read (), key1.pub));
|
||||
// Send below minimum receive amount
|
||||
auto send2 (wallet->send_action (nano::dev::genesis_key.pub, key1.pub, node->config.receive_minimum.number () - 1, *node->work_generate_blocking (send1->hash ())));
|
||||
|
|
@ -5907,7 +5907,7 @@ TEST (rpc, receive_unopened)
|
|||
// Test receiving for unopened account
|
||||
nano::keypair key1;
|
||||
auto send1 (wallet->send_action (nano::dev::genesis_key.pub, key1.pub, node->config.receive_minimum.number () - 1, *node->work_generate_blocking (nano::dev::genesis->hash ())));
|
||||
ASSERT_TIMELY (5s, !node->balance (nano::dev::genesis_key.pub) != nano::dev::genesis_amount);
|
||||
ASSERT_TIMELY (5s, !node->balance (nano::dev::genesis_key.pub) != nano::dev::constants.genesis_amount);
|
||||
ASSERT_FALSE (node->store.account.exists (node->store.tx_begin_read (), key1.pub));
|
||||
ASSERT_TRUE (node->store.block.exists (node->store.tx_begin_read (), send1->hash ()));
|
||||
wallet->insert_adhoc (key1.prv); // should not auto receive, amount sent was lower than minimum
|
||||
|
|
@ -5969,7 +5969,7 @@ TEST (rpc, receive_work_disabled)
|
|||
ASSERT_TRUE (worker_node.work_generation_enabled ());
|
||||
auto send1 (wallet->send_action (nano::dev::genesis_key.pub, key1.pub, node->config.receive_minimum.number () - 1, *worker_node.work_generate_blocking (genesis.hash ()), false));
|
||||
ASSERT_TRUE (send1 != nullptr);
|
||||
ASSERT_TIMELY (5s, node->balance (nano::dev::genesis_key.pub) != nano::dev::genesis_amount);
|
||||
ASSERT_TIMELY (5s, node->balance (nano::dev::genesis_key.pub) != nano::dev::constants.genesis_amount);
|
||||
ASSERT_FALSE (node->store.account.exists (node->store.tx_begin_read (), key1.pub));
|
||||
ASSERT_TRUE (node->store.block.exists (node->store.tx_begin_read (), send1->hash ()));
|
||||
wallet->insert_adhoc (key1.prv);
|
||||
|
|
@ -6002,7 +6002,7 @@ TEST (rpc, receive_pruned)
|
|||
nano::keypair key1;
|
||||
wallet2->insert_adhoc (key1.prv);
|
||||
auto send1 (wallet1->send_action (nano::dev::genesis_key.pub, key1.pub, node2->config.receive_minimum.number (), *node2->work_generate_blocking (nano::dev::genesis->hash ())));
|
||||
ASSERT_TIMELY (5s, node2->balance (nano::dev::genesis_key.pub) != nano::dev::genesis_amount);
|
||||
ASSERT_TIMELY (5s, node2->balance (nano::dev::genesis_key.pub) != nano::dev::constants.genesis_amount);
|
||||
ASSERT_TIMELY (10s, !node2->store.account.exists (node2->store.tx_begin_read (), key1.pub));
|
||||
// Send below minimum receive amount
|
||||
auto send2 (wallet1->send_action (nano::dev::genesis_key.pub, key1.pub, node2->config.receive_minimum.number () - 1, *node2->work_generate_blocking (send1->hash ())));
|
||||
|
|
@ -6219,8 +6219,8 @@ TEST (rpc, confirmation_active)
|
|||
auto [rpc, rpc_ctx] = add_rpc (system, node1);
|
||||
|
||||
nano::genesis genesis;
|
||||
auto send1 (std::make_shared<nano::send_block> (genesis.hash (), nano::public_key (), nano::dev::genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis.hash ())));
|
||||
auto send2 (std::make_shared<nano::send_block> (send1->hash (), nano::public_key (), nano::dev::genesis_amount - 200, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ())));
|
||||
auto send1 (std::make_shared<nano::send_block> (genesis.hash (), nano::public_key (), nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis.hash ())));
|
||||
auto send2 (std::make_shared<nano::send_block> (send1->hash (), nano::public_key (), nano::dev::constants.genesis_amount - 200, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ())));
|
||||
node1->process_active (send1);
|
||||
node1->process_active (send2);
|
||||
nano::blocks_confirm (*node1, { send1, send2 });
|
||||
|
|
@ -6248,7 +6248,7 @@ TEST (rpc, confirmation_info)
|
|||
auto [rpc, rpc_ctx] = add_rpc (system, node1);
|
||||
|
||||
nano::genesis genesis;
|
||||
auto send (std::make_shared<nano::send_block> (genesis.hash (), nano::public_key (), nano::dev::genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis.hash ())));
|
||||
auto send (std::make_shared<nano::send_block> (genesis.hash (), nano::public_key (), nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis.hash ())));
|
||||
node1->process_active (send);
|
||||
node1->block_processor.flush ();
|
||||
node1->scheduler.flush ();
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
#include <nano/crypto_lib/random_pool.hpp>
|
||||
#include <nano/lib/config.hpp>
|
||||
#include <nano/lib/numbers.hpp>
|
||||
#include <nano/lib/timer.hpp>
|
||||
#include <nano/secure/common.hpp>
|
||||
#include <nano/secure/store.hpp>
|
||||
|
||||
|
|
@ -79,10 +80,9 @@ char const * live_canary_public_key_data = "7CBAF192A3763DAEC9F9BAC1B2CDF665D836
|
|||
std::string const test_canary_public_key_data = nano::get_env_or_default ("NANO_TEST_CANARY_PUB", "3BAD2C554ACE05F5E528FBBCE79D51E552C55FA765CCFD89B289C4835DE5F04A"); // nano_1gxf7jcnomi7yqkkjyxwwygo5sckrohtgsgezp6u74g6ifgydw4cajwbk8bf
|
||||
}
|
||||
|
||||
nano::keypair nano::dev::genesis_key{ dev_private_key_data };
|
||||
nano::ledger_constants nano::dev::constants{ nano::networks::nano_dev_network };
|
||||
std::shared_ptr<nano::block> & nano::dev::genesis = nano::dev::constants.genesis;
|
||||
nano::keypair nano::dev::genesis_key{ dev_private_key_data };
|
||||
nano::uint128_t nano::dev::genesis_amount{ std::numeric_limits<nano::uint128_t>::max () };
|
||||
|
||||
nano::network_params::network_params () :
|
||||
network_params (network_constants::active_network)
|
||||
|
|
@ -117,6 +117,7 @@ nano::ledger_constants::ledger_constants (nano::networks network_a) :
|
|||
nano_live_genesis (parse_block_from_genesis_data (live_genesis_data)),
|
||||
nano_test_genesis (parse_block_from_genesis_data (test_genesis_data)),
|
||||
genesis (network_a == nano::networks::nano_dev_network ? nano_dev_genesis : network_a == nano::networks::nano_beta_network ? nano_beta_genesis : network_a == nano::networks::nano_test_network ? nano_test_genesis : nano_live_genesis),
|
||||
genesis_amount{ std::numeric_limits<nano::uint128_t>::max () },
|
||||
burn_account (0),
|
||||
nano_dev_final_votes_canary_account (dev_public_key_data),
|
||||
nano_beta_final_votes_canary_account (beta_canary_public_key_data),
|
||||
|
|
@ -129,10 +130,15 @@ nano::ledger_constants::ledger_constants (nano::networks network_a) :
|
|||
nano_test_final_votes_canary_height (1),
|
||||
final_votes_canary_height (network_a == nano::networks::nano_dev_network ? nano_dev_final_votes_canary_height : network_a == nano::networks::nano_beta_network ? nano_beta_final_votes_canary_height : network_a == nano::networks::nano_test_network ? nano_test_final_votes_canary_height : nano_live_final_votes_canary_height)
|
||||
{
|
||||
nano_beta_genesis->sideband_set (nano::block_sideband (nano_beta_genesis->account (), 0, nano::dev::constants.genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0));
|
||||
nano_dev_genesis->sideband_set (nano::block_sideband (nano_dev_genesis->account (), 0, nano::dev::constants.genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0));
|
||||
nano_live_genesis->sideband_set (nano::block_sideband (nano_live_genesis->account (), 0, nano::dev::constants.genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0));
|
||||
nano_test_genesis->sideband_set (nano::block_sideband (nano_test_genesis->account (), 0, nano::dev::constants.genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0));
|
||||
|
||||
nano::link epoch_link_v1;
|
||||
const char * epoch_message_v1 ("epoch v1 block");
|
||||
strncpy ((char *)epoch_link_v1.bytes.data (), epoch_message_v1, epoch_link_v1.bytes.size ());
|
||||
epochs.add (nano::epoch::epoch_1, genesis_account (), epoch_link_v1);
|
||||
epochs.add (nano::epoch::epoch_1, genesis->account (), epoch_link_v1);
|
||||
|
||||
nano::link epoch_link_v2;
|
||||
nano::account nano_live_epoch_v2_signer;
|
||||
|
|
@ -144,20 +150,6 @@ nano::ledger_constants::ledger_constants (nano::networks network_a) :
|
|||
epochs.add (nano::epoch::epoch_2, epoch_v2_signer, epoch_link_v2);
|
||||
}
|
||||
|
||||
nano::account nano::ledger_constants::genesis_account () const
|
||||
{
|
||||
auto result = genesis->account ();
|
||||
debug_assert (!result.is_zero ());
|
||||
return result;
|
||||
}
|
||||
|
||||
nano::block_hash nano::ledger_constants::genesis_hash () const
|
||||
{
|
||||
auto result = genesis->hash ();
|
||||
debug_assert (!result.is_zero ());
|
||||
return result;
|
||||
}
|
||||
|
||||
nano::random_constants::random_constants ()
|
||||
{
|
||||
nano::random_pool::generate_block (not_an_account.bytes.data (), not_an_account.bytes.size ());
|
||||
|
|
|
|||
|
|
@ -368,8 +368,6 @@ class ledger_constants
|
|||
public:
|
||||
ledger_constants (nano::network_constants & network_constants);
|
||||
ledger_constants (nano::networks network_a);
|
||||
nano::account genesis_account () const;
|
||||
nano::block_hash genesis_hash () const;
|
||||
nano::keypair zero_key;
|
||||
nano::account nano_beta_account;
|
||||
nano::account nano_live_account;
|
||||
|
|
@ -379,6 +377,7 @@ public:
|
|||
std::shared_ptr<nano::block> nano_live_genesis;
|
||||
std::shared_ptr<nano::block> nano_test_genesis;
|
||||
std::shared_ptr<nano::block> genesis;
|
||||
nano::uint128_t genesis_amount;
|
||||
nano::account burn_account;
|
||||
nano::account nano_dev_final_votes_canary_account;
|
||||
nano::account nano_beta_final_votes_canary_account;
|
||||
|
|
@ -395,10 +394,9 @@ public:
|
|||
|
||||
namespace dev
|
||||
{
|
||||
extern nano::keypair genesis_key;
|
||||
extern nano::ledger_constants constants;
|
||||
extern std::shared_ptr<nano::block> & genesis;
|
||||
extern nano::keypair genesis_key;
|
||||
extern nano::uint128_t genesis_amount;
|
||||
}
|
||||
|
||||
/** Constants which depend on random values (this class should never be used globally due to CryptoPP globals potentially not being initialized) */
|
||||
|
|
|
|||
|
|
@ -1102,8 +1102,8 @@ nano::account nano::ledger::account_safe (nano::transaction const & transaction_
|
|||
// Return amount decrease or increase for block
|
||||
nano::uint128_t nano::ledger::amount (nano::transaction const & transaction_a, nano::account const & account_a)
|
||||
{
|
||||
release_assert (account_a == network_params.ledger.genesis_account ());
|
||||
return nano::dev::genesis_amount;
|
||||
release_assert (account_a == network_params.ledger.genesis->account ());
|
||||
return nano::dev::constants.genesis_amount;
|
||||
}
|
||||
|
||||
nano::uint128_t nano::ledger::amount (nano::transaction const & transaction_a, nano::block_hash const & hash_a)
|
||||
|
|
@ -1204,7 +1204,7 @@ public:
|
|||
}
|
||||
void open_block (nano::open_block const & block_a) override
|
||||
{
|
||||
if (block_a.source () != ledger.network_params.ledger.genesis_account ())
|
||||
if (block_a.source () != ledger.network_params.ledger.genesis->account ())
|
||||
{
|
||||
result[0] = block_a.source ();
|
||||
}
|
||||
|
|
@ -1342,7 +1342,7 @@ uint64_t nano::ledger::pruning_action (nano::write_transaction & transaction_a,
|
|||
{
|
||||
uint64_t pruned_count (0);
|
||||
nano::block_hash hash (hash_a);
|
||||
while (!hash.is_zero () && hash != network_params.ledger.genesis_hash ())
|
||||
while (!hash.is_zero () && hash != network_params.ledger.genesis->hash ())
|
||||
{
|
||||
auto block (store.block.get (transaction_a, hash));
|
||||
if (block != nullptr)
|
||||
|
|
|
|||
|
|
@ -105,19 +105,18 @@ public:
|
|||
*/
|
||||
void initialize (nano::write_transaction const & transaction_a, nano::ledger_cache & ledger_cache_a) override
|
||||
{
|
||||
auto & genesis = *network_params.ledger.genesis;
|
||||
auto hash_l (genesis.hash ());
|
||||
debug_assert (network_params.ledger.genesis->has_sideband ());
|
||||
debug_assert (account.begin (transaction_a) == account.end ());
|
||||
genesis.sideband_set (nano::block_sideband (network_params.ledger.genesis_account (), 0, nano::dev::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0));
|
||||
block.put (transaction_a, hash_l, genesis);
|
||||
auto hash_l (network_params.ledger.genesis->hash ());
|
||||
block.put (transaction_a, hash_l, *network_params.ledger.genesis);
|
||||
++ledger_cache_a.block_count;
|
||||
confirmation_height.put (transaction_a, network_params.ledger.genesis_account (), nano::confirmation_height_info{ 1, genesis.hash () });
|
||||
confirmation_height.put (transaction_a, network_params.ledger.genesis->account (), nano::confirmation_height_info{ 1, network_params.ledger.genesis->hash () });
|
||||
++ledger_cache_a.cemented_count;
|
||||
ledger_cache_a.final_votes_confirmation_canary = (network_params.ledger.final_votes_canary_account == network_params.ledger.genesis_account () && 1 >= network_params.ledger.final_votes_canary_height);
|
||||
account.put (transaction_a, network_params.ledger.genesis_account (), { hash_l, network_params.ledger.genesis_account (), genesis.hash (), std::numeric_limits<nano::uint128_t>::max (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0 });
|
||||
ledger_cache_a.final_votes_confirmation_canary = (network_params.ledger.final_votes_canary_account == network_params.ledger.genesis->account () && 1 >= network_params.ledger.final_votes_canary_height);
|
||||
account.put (transaction_a, network_params.ledger.genesis->account (), { hash_l, network_params.ledger.genesis->account (), network_params.ledger.genesis->hash (), std::numeric_limits<nano::uint128_t>::max (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0 });
|
||||
++ledger_cache_a.account_count;
|
||||
ledger_cache_a.rep_weights.representation_put (network_params.ledger.genesis_account (), std::numeric_limits<nano::uint128_t>::max ());
|
||||
frontier.put (transaction_a, hash_l, network_params.ledger.genesis_account ());
|
||||
ledger_cache_a.rep_weights.representation_put (network_params.ledger.genesis->account (), std::numeric_limits<nano::uint128_t>::max ());
|
||||
frontier.put (transaction_a, hash_l, network_params.ledger.genesis->account ());
|
||||
}
|
||||
|
||||
bool root_exists (nano::transaction const & transaction_a, nano::root const & root_a) override
|
||||
|
|
|
|||
|
|
@ -95,13 +95,12 @@ TEST (ledger, deep_account_compute)
|
|||
ASSERT_FALSE (store->init_error ());
|
||||
nano::stat stats;
|
||||
nano::ledger ledger (*store, stats);
|
||||
nano::genesis genesis;
|
||||
auto transaction (store->tx_begin_write ());
|
||||
store->initialize (transaction, ledger.cache);
|
||||
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
|
||||
nano::keypair key;
|
||||
auto balance (nano::dev::genesis_amount - 1);
|
||||
nano::send_block send (genesis.hash (), key.pub, balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (genesis.hash ()));
|
||||
auto balance (nano::dev::constants.genesis_amount - 1);
|
||||
nano::send_block send (nano::dev::genesis->hash (), key.pub, balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
|
||||
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code);
|
||||
nano::open_block open (send.hash (), nano::dev::genesis_key.pub, key.pub, key.prv, key.pub, *pool.generate (key.pub));
|
||||
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code);
|
||||
|
|
@ -146,7 +145,7 @@ TEST (wallet, multithreaded_send_async)
|
|||
}
|
||||
}));
|
||||
}
|
||||
ASSERT_TIMELY (1000s, system.nodes[0]->balance (nano::dev::genesis_key.pub) == (nano::dev::genesis_amount - 20 * 1000 * 1000));
|
||||
ASSERT_TIMELY (1000s, system.nodes[0]->balance (nano::dev::genesis_key.pub) == (nano::dev::constants.genesis_amount - 20 * 1000 * 1000));
|
||||
}
|
||||
for (auto i (threads.begin ()), n (threads.end ()); i != n; ++i)
|
||||
{
|
||||
|
|
@ -488,7 +487,7 @@ TEST (node, mass_vote_by_hash)
|
|||
std::vector<std::shared_ptr<nano::state_block>> blocks;
|
||||
for (auto i (0); i < 10000; ++i)
|
||||
{
|
||||
auto block (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, previous, nano::dev::genesis_key.pub, nano::dev::genesis_amount - (i + 1) * nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous)));
|
||||
auto block (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, previous, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - (i + 1) * nano::Gxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous)));
|
||||
previous = block->hash ();
|
||||
blocks.push_back (block);
|
||||
}
|
||||
|
|
@ -647,7 +646,7 @@ TEST (confirmation_height, long_chains)
|
|||
auto const num_blocks = nano::confirmation_height::unbounded_cutoff * 2 + 50;
|
||||
|
||||
// First open the other account
|
||||
nano::send_block send (latest, key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio + num_blocks + 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
nano::send_block send (latest, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio + num_blocks + 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
nano::open_block open (send.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub));
|
||||
{
|
||||
auto transaction = node->store.tx_begin_write ();
|
||||
|
|
@ -662,7 +661,7 @@ TEST (confirmation_height, long_chains)
|
|||
auto transaction = node->store.tx_begin_write ();
|
||||
for (auto i = num_blocks - 1; i > 0; --i)
|
||||
{
|
||||
nano::send_block send (previous_genesis_chain_hash, key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio + i + 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous_genesis_chain_hash));
|
||||
nano::send_block send (previous_genesis_chain_hash, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio + i + 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous_genesis_chain_hash));
|
||||
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
|
||||
nano::receive_block receive (previous_destination_chain_hash, send.hash (), key1.prv, key1.pub, *system.work.generate (previous_destination_chain_hash));
|
||||
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, receive).code);
|
||||
|
|
@ -674,11 +673,11 @@ TEST (confirmation_height, long_chains)
|
|||
|
||||
// Send one from destination to genesis and pocket it
|
||||
nano::send_block send1 (previous_destination_chain_hash, nano::dev::genesis_key.pub, nano::Gxrb_ratio - 2, key1.prv, key1.pub, *system.work.generate (previous_destination_chain_hash));
|
||||
auto receive1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, previous_genesis_chain_hash, nano::dev::genesis->account (), nano::dev::genesis_amount - nano::Gxrb_ratio + 1, send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous_genesis_chain_hash)));
|
||||
auto receive1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, previous_genesis_chain_hash, nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio + 1, send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous_genesis_chain_hash)));
|
||||
|
||||
// Unpocketed. Send to a non-existing account to prevent auto receives from the wallet adjusting expected confirmation height
|
||||
nano::keypair key2;
|
||||
nano::state_block send2 (nano::dev::genesis->account (), receive1->hash (), nano::dev::genesis->account (), nano::dev::genesis_amount - nano::Gxrb_ratio, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive1->hash ()));
|
||||
nano::state_block send2 (nano::dev::genesis->account (), receive1->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive1->hash ()));
|
||||
|
||||
{
|
||||
auto transaction = node->store.tx_begin_write ();
|
||||
|
|
@ -734,11 +733,11 @@ TEST (confirmation_height, dynamic_algorithm)
|
|||
nano::keypair key;
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
auto const num_blocks = nano::confirmation_height::unbounded_cutoff;
|
||||
auto latest_genesis = nano::genesis ().open;
|
||||
auto latest_genesis = nano::dev::genesis;
|
||||
std::vector<std::shared_ptr<nano::state_block>> state_blocks;
|
||||
for (auto i = 0; i < num_blocks; ++i)
|
||||
{
|
||||
auto send (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, latest_genesis->hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - i - 1, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis->hash ())));
|
||||
auto send (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, latest_genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - i - 1, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis->hash ())));
|
||||
latest_genesis = send;
|
||||
state_blocks.push_back (send);
|
||||
}
|
||||
|
|
@ -794,7 +793,7 @@ TEST (confirmation_height, dynamic_algorithm_no_transition_while_pending)
|
|||
|
||||
auto add_block_to_genesis_chain = [&] (nano::write_transaction & transaction) {
|
||||
static int num = 0;
|
||||
auto send (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, latest_genesis, nano::dev::genesis_key.pub, nano::dev::genesis_amount - num - 1, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis)));
|
||||
auto send (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, latest_genesis, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - num - 1, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis)));
|
||||
latest_genesis = send->hash ();
|
||||
state_blocks.push_back (send);
|
||||
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
|
||||
|
|
@ -873,7 +872,7 @@ TEST (confirmation_height, many_accounts_send_receive_self)
|
|||
nano::keypair key;
|
||||
keys.emplace_back (key);
|
||||
|
||||
nano::send_block send (latest_genesis, key.pub, nano::dev::genesis_amount - 1 - i, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis));
|
||||
nano::send_block send (latest_genesis, key.pub, nano::dev::constants.genesis_amount - 1 - i, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis));
|
||||
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
|
||||
auto open = std::make_shared<nano::open_block> (send.hash (), nano::dev::genesis_key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub));
|
||||
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code);
|
||||
|
|
@ -966,7 +965,6 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections)
|
|||
auto path (nano::unique_path ());
|
||||
auto store = nano::make_store (logger, path);
|
||||
ASSERT_TRUE (!store->init_error ());
|
||||
nano::genesis genesis;
|
||||
nano::stat stats;
|
||||
nano::ledger ledger (*store, stats);
|
||||
nano::write_database_queue write_database_queue (false);
|
||||
|
|
@ -994,7 +992,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections)
|
|||
{
|
||||
nano::keypair key;
|
||||
keys.emplace_back (key);
|
||||
nano::send_block send (latest_genesis, key.pub, nano::dev::genesis_amount - 1 - i, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (latest_genesis));
|
||||
nano::send_block send (latest_genesis, key.pub, nano::dev::constants.genesis_amount - 1 - i, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (latest_genesis));
|
||||
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code);
|
||||
auto open = std::make_shared<nano::open_block> (send.hash (), nano::dev::genesis_key.pub, key.pub, key.prv, key.pub, *pool.generate (key.pub));
|
||||
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code);
|
||||
|
|
@ -1305,14 +1303,13 @@ TEST (telemetry, under_load)
|
|||
auto node = system.add_node (node_config, node_flags);
|
||||
node_config.peering_port = nano::get_available_port ();
|
||||
auto node1 = system.add_node (node_config, node_flags);
|
||||
nano::genesis genesis;
|
||||
nano::keypair key;
|
||||
nano::keypair key1;
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
system.wallet (0)->insert_adhoc (key.prv);
|
||||
auto latest_genesis = node->latest (nano::dev::genesis_key.pub);
|
||||
auto num_blocks = 150000;
|
||||
auto send (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, latest_genesis, nano::dev::genesis_key.pub, nano::dev::genesis_amount - num_blocks, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis)));
|
||||
auto send (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, latest_genesis, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - num_blocks, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis)));
|
||||
node->process_active (send);
|
||||
latest_genesis = send->hash ();
|
||||
auto open (std::make_shared<nano::state_block> (key.pub, 0, key.pub, num_blocks, send->hash (), key.prv, key.pub, *system.work.generate (key.pub)));
|
||||
|
|
@ -1329,7 +1326,7 @@ TEST (telemetry, under_load)
|
|||
}
|
||||
};
|
||||
|
||||
std::thread thread1 (thread_func, nano::dev::genesis_key, latest_genesis, nano::dev::genesis_amount - num_blocks);
|
||||
std::thread thread1 (thread_func, nano::dev::genesis_key, latest_genesis, nano::dev::constants.genesis_amount - num_blocks);
|
||||
std::thread thread2 (thread_func, key, latest_key, num_blocks);
|
||||
|
||||
ASSERT_TIMELY (200s, node1->ledger.cache.block_count == num_blocks * 2 + 3);
|
||||
|
|
@ -1446,8 +1443,7 @@ TEST (telemetry, many_nodes)
|
|||
|
||||
// Give all nodes a non-default number of blocks
|
||||
nano::keypair key;
|
||||
nano::genesis genesis;
|
||||
nano::state_block send (nano::dev::genesis_key.pub, genesis.hash (), nano::dev::genesis_key.pub, nano::dev::genesis_amount - nano::Mxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis.hash ()));
|
||||
nano::state_block send (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::Mxrb_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()));
|
||||
for (auto node : system.nodes)
|
||||
{
|
||||
auto transaction (node->store.tx_begin_write ());
|
||||
|
|
@ -1497,7 +1493,7 @@ TEST (telemetry, many_nodes)
|
|||
ASSERT_EQ (data.pre_release_version, nano::get_pre_release_node_version ());
|
||||
ASSERT_EQ (data.maker, 0);
|
||||
ASSERT_LT (data.uptime, 100);
|
||||
ASSERT_EQ (data.genesis_block, genesis.hash ());
|
||||
ASSERT_EQ (data.genesis_block, nano::dev::genesis->hash ());
|
||||
ASSERT_LE (data.timestamp, std::chrono::system_clock::now ());
|
||||
ASSERT_EQ (data.active_difficulty, system.nodes.front ()->default_difficulty (nano::work_version::work_1));
|
||||
}
|
||||
|
|
@ -1724,7 +1720,6 @@ TEST (node, mass_block_new)
|
|||
}
|
||||
};
|
||||
|
||||
nano::genesis genesis;
|
||||
nano::keypair key;
|
||||
std::vector<nano::keypair> keys (num_blocks);
|
||||
nano::state_block_builder builder;
|
||||
|
|
@ -1736,7 +1731,7 @@ TEST (node, mass_block_new)
|
|||
auto send = builder.make_block ()
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (latest_genesis)
|
||||
.balance (nano::dev::genesis_amount - i - 1)
|
||||
.balance (nano::dev::constants.genesis_amount - i - 1)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.link (keys[i].pub)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
|
|
@ -1834,7 +1829,7 @@ TEST (node, wallet_create_block_confirm_conflicts)
|
|||
auto transaction = node->store.tx_begin_write ();
|
||||
for (auto i = num_blocks - 1; i > 0; --i)
|
||||
{
|
||||
nano::send_block send (latest, key1.pub, nano::dev::genesis_amount - nano::Gxrb_ratio + i + 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
nano::send_block send (latest, key1.pub, nano::dev::constants.genesis_amount - nano::Gxrb_ratio + i + 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
|
||||
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
|
||||
latest = send.hash ();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -152,8 +152,8 @@ nano::system::~system ()
|
|||
void nano::system::ledger_initialization_set (std::vector<nano::keypair> const & reps, nano::amount const & reserve)
|
||||
{
|
||||
nano::block_hash previous = nano::dev::genesis->hash ();
|
||||
auto amount = (nano::dev::genesis_amount - reserve.number ()) / reps.size ();
|
||||
auto balance = nano::dev::genesis_amount;
|
||||
auto amount = (nano::dev::constants.genesis_amount - reserve.number ()) / reps.size ();
|
||||
auto balance = nano::dev::constants.genesis_amount;
|
||||
for (auto const & i : reps)
|
||||
{
|
||||
balance -= amount;
|
||||
|
|
@ -365,8 +365,7 @@ void nano::system::generate_rollback (nano::node & node_a, std::vector<nano::acc
|
|||
if (!error)
|
||||
{
|
||||
auto hash (info.open_block);
|
||||
nano::genesis genesis;
|
||||
if (hash != genesis.hash ())
|
||||
if (hash != node_a.network_params.ledger.genesis->hash ())
|
||||
{
|
||||
accounts_a[index] = accounts_a[accounts_a.size () - 1];
|
||||
accounts_a.pop_back ();
|
||||
|
|
@ -398,7 +397,7 @@ void nano::system::generate_receive (nano::node & node_a)
|
|||
}
|
||||
if (send_block != nullptr)
|
||||
{
|
||||
auto receive_error (wallet (0)->receive_sync (send_block, nano::ledger_constants (nano::networks::nano_dev_network).genesis_account (), std::numeric_limits<nano::uint128_t>::max ()));
|
||||
auto receive_error (wallet (0)->receive_sync (send_block, nano::dev::genesis->account (), std::numeric_limits<nano::uint128_t>::max ()));
|
||||
(void)receive_error;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ void nano::compare_default_telemetry_response_data_excluding_signature (nano::te
|
|||
ASSERT_EQ (telemetry_data_a.unchecked_count, 0);
|
||||
ASSERT_EQ (telemetry_data_a.account_count, 1);
|
||||
ASSERT_LT (telemetry_data_a.uptime, 100);
|
||||
ASSERT_EQ (telemetry_data_a.genesis_block, network_params_a.ledger.genesis_hash ());
|
||||
ASSERT_EQ (telemetry_data_a.genesis_block, network_params_a.ledger.genesis->hash ());
|
||||
ASSERT_EQ (telemetry_data_a.major_version, nano::get_major_node_version ());
|
||||
ASSERT_EQ (telemetry_data_a.minor_version, nano::get_minor_node_version ());
|
||||
ASSERT_EQ (telemetry_data_a.patch_version, nano::get_patch_node_version ());
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue