Minecon724/dncurrency
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions

Merge pull request #3383 from nanocurrency/genesis_dev_cleanup

Browse source 
Cleaning up genesis_dev constants
This commit is contained in:
clemahieu 2021-07-21 16:15:11 +01:00 • committed by GitHub
commit 386ec4ade7
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
40 changed files with 2734 additions and 2747 deletions
Download patch file Download diff file Expand all files Collapse all files

368
nano/core_test/active_transactions.cpp
View file

@ -21,8 +21,8 @@ TEST (active_transactions, confirm_active)
auto send = nano::send_block_builder ()
.previous (genesis.hash ())
.destination (nano::public_key ())
.balance (nano::genesis_amount - 100)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.balance (nano::dev::genesis_amount - 100)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis.hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1.process (*send).code);
@ -43,13 +43,13 @@ TEST (active_transactions, confirm_active)
auto election = node2.active.election (send->qualified_root ());
ASSERT_NE (nullptr, election);
// Add key to node1
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
// Add representative to disabled rep crawler
auto peers (node2.network.random_set (1));
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::genesis_amount, *peers.begin ());
node2.rep_crawler.probable_reps.emplace (nano::dev::genesis_key.pub, nano::dev::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 ());
@ -83,24 +83,24 @@ TEST (active_transactions, confirm_frontier)
auto & node2 = *system.add_node (node_flags2);
// Add key to node1
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
// Add representative to disabled rep crawler
auto peers (node2.network.random_set (1));
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::genesis_amount, *peers.begin ());
node2.rep_crawler.probable_reps.emplace (nano::dev::genesis_key.pub, nano::dev::genesis_amount, *peers.begin ());
}
nano::genesis genesis;
nano::state_block_builder builder;
auto send = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 100)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - 100)
.link (nano::public_key ())
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis.hash ()))
.build_shared ();
auto send_copy = builder.make_block ().from (*send).build_shared ();
@ -130,13 +130,13 @@ TEST (active_transactions, keep_local)
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);
auto send1 (wallet.send_action (nano::dev_genesis_key.pub, key1.pub, node.config.receive_minimum.number ()));
auto send2 (wallet.send_action (nano::dev_genesis_key.pub, key2.pub, node.config.receive_minimum.number ()));
auto send3 (wallet.send_action (nano::dev_genesis_key.pub, key3.pub, node.config.receive_minimum.number ()));
auto send4 (wallet.send_action (nano::dev_genesis_key.pub, key4.pub, node.config.receive_minimum.number ()));
auto send5 (wallet.send_action (nano::dev_genesis_key.pub, key5.pub, node.config.receive_minimum.number ()));
auto send6 (wallet.send_action (nano::dev_genesis_key.pub, key6.pub, node.config.receive_minimum.number ()));
wallet.insert_adhoc (nano::dev::genesis_key.prv);
auto send1 (wallet.send_action (nano::dev::genesis_key.pub, key1.pub, node.config.receive_minimum.number ()));
auto send2 (wallet.send_action (nano::dev::genesis_key.pub, key2.pub, node.config.receive_minimum.number ()));
auto send3 (wallet.send_action (nano::dev::genesis_key.pub, key3.pub, node.config.receive_minimum.number ()));
auto send4 (wallet.send_action (nano::dev::genesis_key.pub, key4.pub, node.config.receive_minimum.number ()));
auto send5 (wallet.send_action (nano::dev::genesis_key.pub, key5.pub, node.config.receive_minimum.number ()));
auto send6 (wallet.send_action (nano::dev::genesis_key.pub, key6.pub, node.config.receive_minimum.number ()));
// should not drop wallet created transactions
ASSERT_TIMELY (5s, node.active.size () == 1);
for (auto const & block : { send1, send2, send3, send4, send5, send6 })
@ -188,16 +188,16 @@ TEST (active_transactions, inactive_votes_cache)
{
nano::system system (1);
auto & node = *system.nodes[0];
nano::block_hash latest (node.latest (nano::dev_genesis_key.pub));
nano::block_hash latest (node.latest (nano::dev::genesis_key.pub));
nano::keypair key;
auto send = nano::send_block_builder ()
.previous (latest)
.destination (key.pub)
.balance (nano::genesis_amount - 100)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.balance (nano::dev::genesis_amount - 100)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
auto vote (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits<uint64_t>::max (), std::vector<nano::block_hash> (1, send->hash ())));
auto vote (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits<uint64_t>::max (), std::vector<nano::block_hash> (1, send->hash ())));
node.vote_processor.vote (vote, std::make_shared<nano::transport::channel_loopback> (node));
ASSERT_TIMELY (5s, node.active.inactive_votes_cache_size () == 1);
node.process_active (send);
@ -210,16 +210,16 @@ TEST (active_transactions, inactive_votes_cache_non_final)
{
nano::system system (1);
auto & node = *system.nodes[0];
nano::block_hash latest (node.latest (nano::dev_genesis_key.pub));
nano::block_hash latest (node.latest (nano::dev::genesis_key.pub));
nano::keypair key;
auto send = nano::send_block_builder ()
.previous (latest)
.destination (key.pub)
.balance (nano::genesis_amount - 100)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.balance (nano::dev::genesis_amount - 100)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
auto vote (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, std::vector<nano::block_hash> (1, send->hash ()))); // Non-final vote
auto vote (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, std::vector<nano::block_hash> (1, send->hash ()))); // Non-final vote
node.vote_processor.vote (vote, std::make_shared<nano::transport::channel_loopback> (node));
ASSERT_TIMELY (5s, node.active.inactive_votes_cache_size () == 1);
node.process_active (send);
@ -228,31 +228,31 @@ 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::genesis_amount - 100, election->tally ().begin ()->first);
ASSERT_EQ (nano::dev::genesis_amount - 100, election->tally ().begin ()->first);
}
TEST (active_transactions, inactive_votes_cache_fork)
{
nano::system system (1);
auto & node = *system.nodes[0];
nano::block_hash latest (node.latest (nano::dev_genesis_key.pub));
nano::block_hash latest (node.latest (nano::dev::genesis_key.pub));
nano::keypair key;
nano::send_block_builder builder;
auto send1 = builder.make_block ()
.previous (latest)
.destination (key.pub)
.balance (nano::genesis_amount - 100)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.balance (nano::dev::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::genesis_amount - 200)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.balance (nano::dev::genesis_amount - 200)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
auto vote (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits<uint64_t>::max (), std::vector<nano::block_hash> (1, send1->hash ())));
auto vote (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits<uint64_t>::max (), std::vector<nano::block_hash> (1, send1->hash ())));
node.vote_processor.vote (vote, std::make_shared<nano::transport::channel_loopback> (node));
auto channel1 (node.network.udp_channels.create (node.network.endpoint ()));
ASSERT_TIMELY (5s, node.active.inactive_votes_cache_size () == 1);
@ -279,14 +279,14 @@ TEST (active_transactions, inactive_votes_cache_existing_vote)
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::block_hash latest (node.latest (nano::dev_genesis_key.pub));
nano::block_hash latest (node.latest (nano::dev::genesis_key.pub));
nano::keypair key;
nano::block_builder builder;
auto send = builder.send ()
.previous (latest)
.destination (key.pub)
.balance (nano::genesis_amount - 100 * nano::Gxrb_ratio)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.balance (nano::dev::genesis_amount - 100 * nano::Gxrb_ratio)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
auto open = builder.state ()
@ -336,21 +336,21 @@ TEST (active_transactions, inactive_votes_cache_multiple_votes)
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::block_hash latest (node.latest (nano::dev_genesis_key.pub));
nano::block_hash latest (node.latest (nano::dev::genesis_key.pub));
nano::keypair key1;
nano::block_builder builder;
auto send1 = builder.send ()
.previous (latest)
.destination (key1.pub)
.balance (nano::genesis_amount - 100 * nano::Gxrb_ratio)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.balance (nano::dev::genesis_amount - 100 * nano::Gxrb_ratio)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
auto send2 = builder.send ()
.previous (send1->hash ())
.destination (key1.pub)
.balance (100 * nano::Gxrb_ratio)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
auto open = builder.state ()
@ -369,11 +369,11 @@ TEST (active_transactions, inactive_votes_cache_multiple_votes)
// Process votes
auto vote1 (std::make_shared<nano::vote> (key1.pub, key1.prv, 0, std::vector<nano::block_hash> (1, send1->hash ())));
node.vote_processor.vote (vote1, std::make_shared<nano::transport::channel_loopback> (node));
auto vote2 (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, std::vector<nano::block_hash> (1, send1->hash ())));
auto vote2 (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, std::vector<nano::block_hash> (1, send1->hash ())));
node.vote_processor.vote (vote2, std::make_shared<nano::transport::channel_loopback> (node));
ASSERT_TIMELY (5s, node.active.find_inactive_votes_cache (send1->hash ()).voters.size () == 2);
ASSERT_EQ (1, node.active.inactive_votes_cache_size ());
node.scheduler.activate (nano::dev_genesis_key.pub, node.store.tx_begin_read ());
node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
node.scheduler.flush ();
auto election = node.active.election (send1->qualified_root ());
ASSERT_NE (nullptr, election);
@ -387,22 +387,22 @@ TEST (active_transactions, inactive_votes_cache_election_start)
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::block_hash latest (node.latest (nano::dev_genesis_key.pub));
nano::block_hash latest (node.latest (nano::dev::genesis_key.pub));
nano::keypair key1, key2;
nano::send_block_builder send_block_builder;
nano::state_block_builder state_block_builder;
auto send1 = send_block_builder.make_block ()
.previous (latest)
.destination (key1.pub)
.balance (nano::genesis_amount - 5000 * nano::Gxrb_ratio)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.balance (nano::dev::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::genesis_amount - 10000 * nano::Gxrb_ratio)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.balance (nano::dev::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 ();
auto open1 = state_block_builder.make_block ()
@ -436,14 +436,14 @@ TEST (active_transactions, inactive_votes_cache_election_start)
.previous (send2->hash ())
.destination (nano::keypair ().pub)
.balance (send2->balance ().number () - 1)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send2->hash ()))
.build_shared ();
auto send4 = send_block_builder.make_block ()
.previous (send3->hash ())
.destination (nano::keypair ().pub)
.balance (send3->balance ().number () - 1)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send3->hash ()))
.build_shared ();
// Inactive votes
@ -459,7 +459,7 @@ TEST (active_transactions, inactive_votes_cache_election_start)
// Only open1 & open2 blocks elections should start (send4 is missing previous block in ledger)
ASSERT_TIMELY (5s, 2 == node.active.size ());
// Confirm elections with weight quorum
auto vote0 (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits<uint64_t>::max (), hashes)); // Final vote for confirmation
auto vote0 (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits<uint64_t>::max (), hashes)); // Final vote for confirmation
node.vote_processor.vote (vote0, std::make_shared<nano::transport::channel_loopback> (node));
ASSERT_TIMELY (5s, node.active.empty ());
ASSERT_TIMELY (5s, 5 == node.ledger.cache.cemented_count);
@ -496,12 +496,12 @@ TEST (active_transactions, vote_replays)
nano::keypair key;
nano::state_block_builder builder;
auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis.hash ()))
.build_shared ();
ASSERT_NE (nullptr, send1);
@ -520,7 +520,7 @@ TEST (active_transactions, vote_replays)
nano::blocks_confirm (node, { send1, open1 });
ASSERT_EQ (2, node.active.size ());
// First vote is not a replay and confirms the election, second vote should be a replay since the election has confirmed but not yet removed
auto vote_send1 (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits<uint64_t>::max (), send1));
auto vote_send1 (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits<uint64_t>::max (), send1));
ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote_send1));
ASSERT_EQ (2, node.active.size ());
ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_send1));
@ -528,7 +528,7 @@ TEST (active_transactions, vote_replays)
ASSERT_TIMELY (3s, node.active.size () == 1);
ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_send1));
// Open new account
auto vote_open1 (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits<uint64_t>::max (), open1));
auto vote_open1 (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits<uint64_t>::max (), open1));
ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote_open1));
ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_open1));
ASSERT_TIMELY (3s, node.active.empty ());
@ -548,7 +548,7 @@ TEST (active_transactions, vote_replays)
node.process_active (send2);
nano::blocks_confirm (node, { send2 });
ASSERT_EQ (1, node.active.size ());
auto vote1_send2 (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits<uint64_t>::max (), send2));
auto vote1_send2 (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits<uint64_t>::max (), send2));
auto vote2_send2 (std::make_shared<nano::vote> (key.pub, key.prv, 0, send2));
ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote2_send2));
ASSERT_EQ (1, node.active.size ());
@ -584,7 +584,7 @@ TEST (active_transactions, dropped_cleanup)
nano::genesis genesis;
auto block = genesis.open;
block->sideband_set (nano::block_sideband (nano::genesis_account, 0, nano::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0));
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;
@ -650,12 +650,12 @@ TEST (active_transactions, republish_winner)
nano::keypair key;
nano::state_block_builder builder;
auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis.hash ()))
.build_shared ();
@ -667,12 +667,12 @@ TEST (active_transactions, republish_winner)
for (auto i (0); i < 5; i++)
{
auto fork = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 1 - i)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - 1 - i)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis.hash ()))
.build_shared ();
node1.process_active (fork);
@ -683,12 +683,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)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - 2 * nano::Gxrb_ratio)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis.hash ()))
.build_shared ();
@ -696,7 +696,7 @@ TEST (active_transactions, republish_winner)
node1.block_processor.flush ();
auto election = node1.active.election (fork->qualified_root ());
ASSERT_NE (nullptr, election);
auto vote = std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits<uint64_t>::max (), std::vector<nano::block_hash>{ fork->hash () });
auto vote = std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits<uint64_t>::max (), std::vector<nano::block_hash>{ fork->hash () });
node1.vote_processor.vote (vote, std::make_shared<nano::transport::channel_loopback> (node1));
node1.vote_processor.flush ();
node1.block_processor.flush ();
@ -716,12 +716,12 @@ TEST (active_transactions, fork_filter_cleanup)
nano::keypair key;
nano::state_block_builder builder;
auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis.hash ()))
.build_shared ();
std::vector<uint8_t> block_bytes;
@ -734,12 +734,12 @@ TEST (active_transactions, fork_filter_cleanup)
for (auto i (0); i < 10; i++)
{
auto fork = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 1 - i)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - 1 - i)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis.hash ()))
.build_shared ();
node1.process_active (fork);
@ -776,7 +776,7 @@ TEST (active_transactions, fork_replacement_tally)
size_t const max_blocks = 10;
std::vector<nano::keypair> keys (reps_count);
auto latest (genesis.hash ());
auto balance (nano::genesis_amount);
auto balance (nano::dev::genesis_amount);
auto amount (node1.minimum_principal_weight ());
nano::state_block_builder builder;
@ -785,12 +785,12 @@ TEST (active_transactions, fork_replacement_tally)
{
balance -= amount + i;
auto send = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (latest)
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (balance)
.link (keys[i].pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
node1.process_active (send);
@ -806,7 +806,7 @@ TEST (active_transactions, fork_replacement_tally)
.build_shared ();
node1.process_active (open);
// Confirmation
auto vote (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits<uint64_t>::max (), std::vector<nano::block_hash>{ send->hash (), open->hash () }));
auto vote (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits<uint64_t>::max (), std::vector<nano::block_hash>{ send->hash (), open->hash () }));
node1.vote_processor.vote (vote, std::make_shared<nano::transport::channel_loopback> (node1));
}
node1.block_processor.flush ();
@ -814,12 +814,12 @@ TEST (active_transactions, fork_replacement_tally)
nano::keypair key;
auto send_last = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (latest)
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (balance - 2 * nano::Gxrb_ratio)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
@ -827,12 +827,12 @@ TEST (active_transactions, fork_replacement_tally)
for (auto i (0); i < reps_count; i++)
{
auto fork = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (latest)
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (balance - nano::Gxrb_ratio - i)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
node1.process_active (fork);
@ -848,12 +848,12 @@ TEST (active_transactions, fork_replacement_tally)
for (auto i (0); i < reps_count; i++)
{
auto fork = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (latest)
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (balance - 1 - i)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
auto vote (std::make_shared<nano::vote> (keys[i].pub, keys[i].prv, 0, std::vector<nano::block_hash>{ fork->hash () }));
@ -886,7 +886,7 @@ TEST (active_transactions, fork_replacement_tally)
ASSERT_FALSE (blocks1.find (send_last->hash ()) != blocks1.end ());
// Process vote for correct block & replace existing lowest tally block
auto vote (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, std::vector<nano::block_hash>{ send_last->hash () }));
auto vote (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, std::vector<nano::block_hash>{ send_last->hash () }));
node1.vote_processor.vote (vote, std::make_shared<nano::transport::channel_loopback> (node1));
node1.vote_processor.flush ();
node2.network.flood_block (send_last);
@ -905,7 +905,7 @@ TEST (active_transactions, fork_replacement_tally)
}
ASSERT_FALSE (votes2.find (keys[max_blocks].pub) != votes2.end ());
ASSERT_FALSE (votes2.find (keys[max_blocks + 1].pub) != votes2.end ());
ASSERT_TRUE (votes2.find (nano::dev_genesis_key.pub) != votes2.end ());
ASSERT_TRUE (votes2.find (nano::dev::genesis_key.pub) != votes2.end ());
}
namespace nano
@ -917,15 +917,15 @@ TEST (active_transactions, confirmation_consistency)
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);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
for (unsigned i = 0; i < 10; ++i)
{
auto block (system.wallet (0)->send_action (nano::dev_genesis_key.pub, nano::public_key (), node.config.receive_minimum.number ()));
auto block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::public_key (), node.config.receive_minimum.number ()));
ASSERT_NE (nullptr, block);
system.deadline_set (5s);
while (!node.ledger.block_confirmed (node.store.tx_begin_read (), block->hash ()))
{
node.scheduler.activate (nano::dev_genesis_key.pub, node.store.tx_begin_read ());
node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
ASSERT_NO_ERROR (system.poll (5ms));
}
ASSERT_NO_ERROR (system.poll_until_true (1s, [&node, &block, i] {
@ -946,8 +946,8 @@ TEST (active_transactions, confirm_new)
auto send = nano::send_block_builder ()
.previous (genesis.hash ())
.destination (nano::public_key ())
.balance (nano::genesis_amount - 100)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.balance (nano::dev::genesis_amount - 100)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis.hash ()))
.build_shared ();
node1.process_active (send);
@ -956,7 +956,7 @@ TEST (active_transactions, confirm_new)
ASSERT_EQ (1, node1.active.size ());
auto & node2 = *system.add_node ();
// Add key to node2
system.wallet (1)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (1)->insert_adhoc (nano::dev::genesis_key.prv);
// Let node2 know about the block
ASSERT_TIMELY (5s, node2.block (send->hash ()));
// Wait confirmation
@ -974,24 +974,24 @@ TEST (active_transactions, conflicting_block_vote_existing_election)
nano::keypair key;
nano::state_block_builder builder;
auto send = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 100)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - 100)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis.hash ()))
.build_shared ();
auto fork = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 200)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - 200)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (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));
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));
ASSERT_EQ (nano::process_result::progress, node.process_local (send).code);
node.scheduler.flush ();
@ -1020,30 +1020,30 @@ TEST (active_transactions, activate_account_chain)
nano::keypair key;
nano::state_block_builder builder;
auto send = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.link (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 1)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.link (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build ();
auto send2 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (send->hash ())
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.link (key.pub)
.balance (nano::genesis_amount - 2)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.balance (nano::dev::genesis_amount - 2)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send->hash ()))
.build ();
auto send3 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (send2->hash ())
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.link (key.pub)
.balance (nano::genesis_amount - 3)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.balance (nano::dev::genesis_amount - 3)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send2->hash ()))
.build ();
auto open = builder.make_block ()
@ -1070,19 +1070,19 @@ TEST (active_transactions, activate_account_chain)
ASSERT_EQ (nano::process_result::progress, node.process (*open).code);
ASSERT_EQ (nano::process_result::progress, node.process (*receive).code);
node.scheduler.activate (nano::dev_genesis_key.pub, node.store.tx_begin_read ());
node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
node.scheduler.flush ();
auto election1 = node.active.election (send->qualified_root ());
ASSERT_EQ (1, node.active.size ());
ASSERT_EQ (1, election1->blocks ().count (send->hash ()));
node.scheduler.activate (nano::dev_genesis_key.pub, node.store.tx_begin_read ());
node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
auto election2 = node.active.election (send->qualified_root ());
ASSERT_EQ (election2, election1);
election1->force_confirm ();
ASSERT_TIMELY (3s, node.block_confirmed (send->hash ()));
// On cementing, the next election is started
ASSERT_TIMELY (3s, node.active.active (send2->qualified_root ()));
node.scheduler.activate (nano::dev_genesis_key.pub, node.store.tx_begin_read ());
node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
auto election3 = node.active.election (send2->qualified_root ());
ASSERT_NE (nullptr, election3);
ASSERT_EQ (1, election3->blocks ().count (send2->hash ()));
@ -1091,7 +1091,7 @@ TEST (active_transactions, activate_account_chain)
// On cementing, the next election is started
ASSERT_TIMELY (3s, node.active.active (open->qualified_root ()));
ASSERT_TIMELY (3s, node.active.active (send3->qualified_root ()));
node.scheduler.activate (nano::dev_genesis_key.pub, node.store.tx_begin_read ());
node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
auto election4 = node.active.election (send3->qualified_root ());
ASSERT_NE (nullptr, election4);
ASSERT_EQ (1, election4->blocks ().count (send3->hash ()));
@ -1120,21 +1120,21 @@ TEST (active_transactions, activate_inactive)
nano::keypair key;
nano::state_block_builder builder;
auto send = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.link (key.pub)
.balance (nano::genesis_amount - 1)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.balance (nano::dev::genesis_amount - 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
auto send2 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (send->hash ())
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.link (nano::keypair ().pub)
.balance (nano::genesis_amount - 2)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.balance (nano::dev::genesis_amount - 2)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send->hash ()))
.build_shared ();
auto open = builder.make_block ()
@ -1181,24 +1181,24 @@ TEST (active_transactions, pessimistic_elections)
nano::keypair key;
nano::state_block_builder builder;
auto send = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.link (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 1)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.link (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
auto send2 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (send->hash ())
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.link (key.pub)
.balance (nano::genesis_amount - 2)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.balance (nano::dev::genesis_amount - 2)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send->hash ()))
.build ();
@ -1232,7 +1232,7 @@ TEST (active_transactions, pessimistic_elections)
ASSERT_EQ (2, node.active.expired_optimistic_election_infos.size ());
ASSERT_EQ (2, node.active.expired_optimistic_election_infos.size ());
auto election_started_it = node.active.expired_optimistic_election_infos.get<nano::active_transactions::tag_election_started> ().begin ();
ASSERT_EQ (election_started_it->account, nano::genesis_account);
ASSERT_EQ (election_started_it->account, nano::dev::genesis->account ());
ASSERT_EQ (election_started_it->election_started, true);
ASSERT_EQ ((++election_started_it)->election_started, false);
@ -1253,7 +1253,7 @@ TEST (active_transactions, pessimistic_elections)
nano::confirmation_height_info key1_confirmation_height_info;
{
auto transaction = node.store.tx_begin_read ();
node.store.confirmation_height.get (transaction, nano::genesis_account, genesis_confirmation_height_info);
node.store.confirmation_height.get (transaction, nano::dev::genesis->account (), genesis_confirmation_height_info);
ASSERT_EQ (2, genesis_confirmation_height_info.height);
node.store.confirmation_height.get (transaction, key.pub, key1_confirmation_height_info);
ASSERT_EQ (0, key1_confirmation_height_info.height);
@ -1275,7 +1275,7 @@ TEST (active_transactions, pessimistic_elections)
{
auto transaction = node.store.tx_begin_read ();
node.store.confirmation_height.get (transaction, nano::genesis_account, genesis_confirmation_height_info);
node.store.confirmation_height.get (transaction, nano::dev::genesis->account (), genesis_confirmation_height_info);
ASSERT_EQ (3, genesis_confirmation_height_info.height);
node.store.confirmation_height.get (transaction, key.pub, key1_confirmation_height_info);
ASSERT_EQ (0, key1_confirmation_height_info.height);
@ -1299,7 +1299,7 @@ TEST (active_transactions, pessimistic_elections)
{
auto transaction = node.store.tx_begin_read ();
node.store.confirmation_height.get (transaction, nano::genesis_account, genesis_confirmation_height_info);
node.store.confirmation_height.get (transaction, nano::dev::genesis->account (), genesis_confirmation_height_info);
ASSERT_EQ (3, genesis_confirmation_height_info.height);
node.store.confirmation_height.get (transaction, key.pub, key1_confirmation_height_info);
ASSERT_EQ (1, key1_confirmation_height_info.height);
@ -1320,24 +1320,24 @@ TEST (active_transactions, list_active)
nano::keypair key;
nano::state_block_builder builder;
auto send = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.link (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 1)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.link (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
auto send2 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (send->hash ())
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.link (key.pub)
.balance (nano::genesis_amount - 2)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.balance (nano::dev::genesis_amount - 2)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send->hash ()))
.build_shared ();
@ -1375,20 +1375,20 @@ TEST (active_transactions, vacancy)
auto & node = *system.add_node (config);
nano::state_block_builder builder;
auto send = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.link (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.account (nano::dev::genesis_key.pub)
.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)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
std::atomic<bool> updated = false;
node.active.vacancy_update = [&updated] () { updated = true; };
ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
ASSERT_EQ (1, node.active.vacancy ());
ASSERT_EQ (0, node.active.size ());
node.scheduler.activate (nano::dev_genesis_key.pub, node.store.tx_begin_read ());
node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
ASSERT_TIMELY (1s, updated);
updated = false;
ASSERT_EQ (0, node.active.vacancy ());
@ -1413,25 +1413,25 @@ TEST (active_transactions, fifo)
nano::state_block_builder builder;
// Construct two pending entries that can be received simultaneously
auto send0 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.link (key0.pub)
.balance (nano::genesis_amount - 1)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.balance (nano::dev::genesis_amount - 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*send0).code);
nano::blocks_confirm (node, { send0 }, true);
ASSERT_TIMELY (1s, node.block_confirmed (send0->hash ()));
ASSERT_TIMELY (1s, node.active.empty ());
auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (send0->hash ())
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.link (key1.pub)
.balance (nano::genesis_amount - 2)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.balance (nano::dev::genesis_amount - 2)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send0->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*send1).code);
@ -1442,7 +1442,7 @@ TEST (active_transactions, fifo)
auto receive0 = builder.make_block ()
.account (key0.pub)
.previous (0)
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.link (send0->hash ())
.balance (1)
.sign (key0.prv, key0.pub)
@ -1452,7 +1452,7 @@ TEST (active_transactions, fifo)
auto receive1 = builder.make_block ()
.account (key1.pub)
.previous (0)
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.link (send1->hash ())
.balance (1)
.sign (key1.prv, key1.pub)

126
nano/core_test/block_store.cpp
View file

@ -330,7 +330,7 @@ TEST (block_store, genesis)
auto transaction (store->tx_begin_write ());
store->initialize (transaction, ledger_cache);
nano::account_info info;
ASSERT_FALSE (store->account.get (transaction, nano::genesis_account, info));
ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis->account (), info));
ASSERT_EQ (hash, info.head);
auto block1 (store->block.get (transaction, info.head));
ASSERT_NE (nullptr, block1);
@ -340,13 +340,13 @@ TEST (block_store, genesis)
ASSERT_EQ (info.block_count, 1);
// Genesis block should be confirmed by default
nano::confirmation_height_info confirmation_height_info;
ASSERT_FALSE (store->confirmation_height.get (transaction, nano::genesis_account, 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);
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 ());
ASSERT_EQ (nano::genesis_account, nano::dev_genesis_key.pub);
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 ());
ASSERT_EQ (nano::dev::genesis->account (), nano::dev::genesis_key.pub);
}
TEST (bootstrap, simple)
@ -689,10 +689,10 @@ TEST (mdb_block_store, supported_version_upgrades)
store.initialize (transaction, ledger.cache);
// Lower the database version to the minimum version supported for upgrade.
store.version.put (transaction, store.minimum_version);
store.confirmation_height.del (transaction, nano::genesis_account);
store.confirmation_height.del (transaction, nano::dev::genesis->account ());
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::genesis_account, 1, nano::genesis_hash);
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);
}
@ -932,8 +932,8 @@ TEST (block_store, DISABLED_change_dupsort) // Unchecked is no longer dupsort ta
auto transaction (store.tx_begin_write ());
ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.unchecked_handle, 1));
ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "unchecked", MDB_CREATE, &store.unchecked_handle));
auto send1 (std::make_shared<nano::send_block> (0, 0, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0));
auto send2 (std::make_shared<nano::send_block> (1, 0, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0));
auto send1 (std::make_shared<nano::send_block> (0, 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
auto send2 (std::make_shared<nano::send_block> (1, 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
ASSERT_NE (send1->hash (), send2->hash ());
store.unchecked.put (transaction, send1->hash (), send1);
store.unchecked.put (transaction, send1->hash (), send2);
@ -1016,29 +1016,29 @@ 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::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ()));
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 ()));
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 ()));
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 ()));
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::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::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::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::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::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::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);
nano::state_block epoch (key1.pub, state_open.hash (), 0, nano::Gxrb_ratio, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (state_open.hash ()));
nano::state_block epoch (key1.pub, state_open.hash (), 0, nano::Gxrb_ratio, ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_open.hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch).code);
ASSERT_EQ (nano::epoch::epoch_1, store.block.version (transaction, epoch.hash ()));
nano::state_block epoch_open (key2.pub, 0, 0, 0, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (key2.pub));
nano::state_block epoch_open (key2.pub, 0, 0, 0, ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (key2.pub));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch_open).code);
ASSERT_EQ (nano::epoch::epoch_1, store.block.version (transaction, epoch_open.hash ()));
nano::state_block state_receive (key2.pub, epoch_open.hash (), 0, nano::Gxrb_ratio, state_send2.hash (), key2.prv, key2.pub, *pool.generate (epoch_open.hash ()));
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));
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 ()));
ASSERT_EQ (block1->sideband ().height, 1);
@ -1274,9 +1274,9 @@ TEST (mdb_block_store, upgrade_v14_v15)
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::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::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::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 (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::logger_mt logger;
nano::mdb_store store (logger, path);
@ -1285,9 +1285,9 @@ TEST (mdb_block_store, upgrade_v14_v15)
auto transaction (store.tx_begin_write ());
store.initialize (transaction, ledger.cache);
nano::account_info account_info;
ASSERT_FALSE (store.account.get (transaction, nano::genesis_account, account_info));
ASSERT_FALSE (store.account.get (transaction, nano::dev::genesis->account (), account_info));
nano::confirmation_height_info confirmation_height_info;
ASSERT_FALSE (store.confirmation_height.get (transaction, nano::genesis_account, 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 ());
// These databases get removed after an upgrade, so readd them
@ -1302,10 +1302,10 @@ TEST (mdb_block_store, upgrade_v14_v15)
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_send).code);
// Lower the database to the previous version
store.version.put (transaction, 14);
store.confirmation_height.del (transaction, nano::genesis_account);
modify_account_info_to_v14 (store, transaction, nano::genesis_account, confirmation_height_info.height, state_send.hash ());
store.confirmation_height.del (transaction, nano::dev::genesis->account ());
modify_account_info_to_v14 (store, transaction, nano::dev::genesis->account (), confirmation_height_info.height, state_send.hash ());
store.pending.del (transaction, nano::pending_key (nano::genesis_account, state_send.hash ()));
store.pending.del (transaction, nano::pending_key (nano::dev::genesis->account (), state_send.hash ()));
write_sideband_v14 (store, transaction, state_send, store.state_blocks_v1_handle);
write_sideband_v14 (store, transaction, epoch, store.state_blocks_v1_handle);
@ -1317,18 +1317,18 @@ TEST (mdb_block_store, upgrade_v14_v15)
store.block.del (transaction, epoch.hash ());
// Turn pending into v14
ASSERT_FALSE (mdb_put (store.env.tx (transaction), store.pending_v0_handle, nano::mdb_val (nano::pending_key (nano::dev_genesis_key.pub, send.hash ())), nano::mdb_val (nano::pending_info_v14 (nano::genesis_account, nano::Gxrb_ratio, nano::epoch::epoch_0)), 0));
ASSERT_FALSE (mdb_put (store.env.tx (transaction), store.pending_v1_handle, nano::mdb_val (nano::pending_key (nano::dev_genesis_key.pub, state_send.hash ())), nano::mdb_val (nano::pending_info_v14 (nano::genesis_account, nano::Gxrb_ratio, nano::epoch::epoch_1)), 0));
ASSERT_FALSE (mdb_put (store.env.tx (transaction), store.pending_v0_handle, nano::mdb_val (nano::pending_key (nano::dev::genesis_key.pub, send.hash ())), nano::mdb_val (nano::pending_info_v14 (nano::dev::genesis->account (), nano::Gxrb_ratio, nano::epoch::epoch_0)), 0));
ASSERT_FALSE (mdb_put (store.env.tx (transaction), store.pending_v1_handle, nano::mdb_val (nano::pending_key (nano::dev::genesis_key.pub, state_send.hash ())), nano::mdb_val (nano::pending_info_v14 (nano::dev::genesis->account (), nano::Gxrb_ratio, nano::epoch::epoch_1)), 0));
// This should fail as sizes are no longer correct for account_info
nano::mdb_val value;
ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.accounts_v1_handle, nano::mdb_val (nano::genesis_account), value));
ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.accounts_v1_handle, nano::mdb_val (nano::dev::genesis->account ()), value));
nano::account_info info;
ASSERT_NE (value.size (), info.db_size ());
store.account.del (transaction, nano::genesis_account);
store.account.del (transaction, nano::dev::genesis->account ());
// Confirmation height for the account should be deleted
ASSERT_TRUE (mdb_get (store.env.tx (transaction), store.confirmation_height_handle, nano::mdb_val (nano::genesis_account), value));
ASSERT_TRUE (mdb_get (store.env.tx (transaction), store.confirmation_height_handle, nano::mdb_val (nano::dev::genesis->account ()), value));
}
// Now do the upgrade
@ -1339,20 +1339,20 @@ TEST (mdb_block_store, upgrade_v14_v15)
// Size of account_info should now equal that set in db
nano::mdb_val value;
ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.accounts_handle, nano::mdb_val (nano::genesis_account), value));
ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.accounts_handle, nano::mdb_val (nano::dev::genesis->account ()), value));
nano::account_info info (value);
ASSERT_EQ (value.size (), info.db_size ());
// Confirmation height should exist
nano::confirmation_height_info confirmation_height_info;
ASSERT_FALSE (store.confirmation_height.get (transaction, nano::genesis_account, 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 ());
// 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::genesis_account), value));
auto error_get_accounts_v1 (mdb_get (store.env.tx (transaction), store.accounts_v1_handle, nano::mdb_val (nano::dev::genesis->account ()), value));
ASSERT_NE (error_get_accounts_v1, MDB_SUCCESS);
auto error_get_pending_v1 (mdb_get (store.env.tx (transaction), store.pending_v1_handle, nano::mdb_val (nano::pending_key (nano::dev_genesis_key.pub, state_send.hash ())), value));
auto error_get_pending_v1 (mdb_get (store.env.tx (transaction), store.pending_v1_handle, nano::mdb_val (nano::pending_key (nano::dev::genesis_key.pub, state_send.hash ())), value));
ASSERT_NE (error_get_pending_v1, MDB_SUCCESS);
auto error_get_state_v1 (mdb_get (store.env.tx (transaction), store.state_blocks_v1_handle, nano::mdb_val (state_send.hash ()), value));
ASSERT_NE (error_get_state_v1, MDB_SUCCESS);
@ -1366,9 +1366,9 @@ TEST (mdb_block_store, upgrade_v14_v15)
ASSERT_EQ (block->sideband ().details.epoch, nano::epoch::epoch_0);
ASSERT_EQ (info.epoch (), nano::epoch::epoch_1);
nano::pending_info pending_info;
store.pending.get (transaction, nano::pending_key (nano::dev_genesis_key.pub, send.hash ()), pending_info);
store.pending.get (transaction, nano::pending_key (nano::dev::genesis_key.pub, send.hash ()), pending_info);
ASSERT_EQ (pending_info.epoch, nano::epoch::epoch_0);
store.pending.get (transaction, nano::pending_key (nano::dev_genesis_key.pub, state_send.hash ()), pending_info);
store.pending.get (transaction, nano::pending_key (nano::dev::genesis_key.pub, state_send.hash ()), pending_info);
ASSERT_EQ (pending_info.epoch, nano::epoch::epoch_1);
// Version should be correct
@ -1395,15 +1395,15 @@ TEST (mdb_block_store, upgrade_v15_v16)
// The representation table should get removed after, so readd it so that we can later confirm this actually happens
auto txn = store.env.tx (transaction);
ASSERT_FALSE (mdb_dbi_open (txn, "representation", MDB_CREATE, &store.representation_handle));
auto weight = ledger.cache.rep_weights.representation_get (nano::genesis_account);
ASSERT_EQ (MDB_SUCCESS, mdb_put (txn, store.representation_handle, nano::mdb_val (nano::genesis_account), nano::mdb_val (nano::uint128_union (weight)), 0));
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);
// Lower the database to the previous version
store.version.put (transaction, 15);
// Confirm the rep weight exists in the database
ASSERT_EQ (MDB_SUCCESS, mdb_get (store.env.tx (transaction), store.representation_handle, nano::mdb_val (nano::genesis_account), value));
store.confirmation_height.del (transaction, nano::genesis_account);
ASSERT_EQ (MDB_SUCCESS, mdb_get (store.env.tx (transaction), store.representation_handle, nano::mdb_val (nano::dev::genesis->account ()), value));
store.confirmation_height.del (transaction, nano::dev::genesis->account ());
}
// Now do the upgrade
@ -1413,7 +1413,7 @@ TEST (mdb_block_store, upgrade_v15_v16)
auto transaction (store.tx_begin_read ());
// The representation table should now be deleted
auto error_get_representation (mdb_get (store.env.tx (transaction), store.representation_handle, nano::mdb_val (nano::genesis_account), value));
auto error_get_representation (mdb_get (store.env.tx (transaction), store.representation_handle, nano::mdb_val (nano::dev::genesis->account ()), value));
ASSERT_NE (MDB_SUCCESS, error_get_representation);
ASSERT_EQ (store.representation_handle, 0);
@ -1430,9 +1430,9 @@ TEST (mdb_block_store, upgrade_v16_v17)
}
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::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::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::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, 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 ()));
auto code = [&block1, &block2, &block3] (auto confirmation_height, nano::block_hash const & expected_cemented_frontier) {
auto path (nano::unique_path ());
@ -1448,7 +1448,7 @@ TEST (mdb_block_store, upgrade_v16_v17)
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code);
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code);
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block3).code);
modify_confirmation_height_to_v15 (store, transaction, nano::genesis_account, confirmation_height);
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);
@ -1468,7 +1468,7 @@ TEST (mdb_block_store, upgrade_v16_v17)
auto transaction (store.tx_begin_read ());
nano::confirmation_height_info confirmation_height_info;
ASSERT_FALSE (store.confirmation_height.get (transaction, nano::genesis_account, confirmation_height_info));
ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info));
ASSERT_EQ (confirmation_height_info.height, confirmation_height);
// Check confirmation height frontier is correct
@ -1499,16 +1499,16 @@ TEST (mdb_block_store, upgrade_v17_v18)
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::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::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::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::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::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::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::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::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::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::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::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 ()));
{
@ -1700,11 +1700,11 @@ 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::genesis_hash, nano::dev_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::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::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::genesis_amount - nano::Gxrb_ratio, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (state_epoch.hash ()));
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::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_open (key1.pub, 0, 0, nano::Gxrb_ratio, state_send.hash (), key1.prv, key1.pub, *pool.generate (key1.pub));
{
@ -1760,7 +1760,7 @@ TEST (mdb_block_store, upgrade_v18_v19)
ASSERT_TRUE (store.block.get (transaction, send.hash ()));
ASSERT_TRUE (store.block.get (transaction, receive.hash ()));
ASSERT_TRUE (store.block.get (transaction, change.hash ()));
ASSERT_TRUE (store.block.get (transaction, nano::genesis_hash));
ASSERT_TRUE (store.block.get (transaction, nano::dev::genesis->hash ()));
auto state_epoch_disk (store.block.get (transaction, state_epoch.hash ()));
ASSERT_NE (nullptr, state_epoch_disk);
ASSERT_EQ (nano::epoch::epoch_1, state_epoch_disk->sideband ().details.epoch);

398
nano/core_test/bootstrap.cpp
View file

@ -26,11 +26,11 @@ TEST (bulk_pull, genesis_to_end)
nano::system system (1);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> ();
req->start = nano::dev_genesis_key.pub;
req->start = nano::dev::genesis_key.pub;
req->end.clear ();
connection->requests.push (std::unique_ptr<nano::message>{});
auto request (std::make_shared<nano::bulk_pull_server> (connection, std::move (req)));
ASSERT_EQ (system.nodes[0]->latest (nano::dev_genesis_key.pub), request->current);
ASSERT_EQ (system.nodes[0]->latest (nano::dev::genesis_key.pub), request->current);
ASSERT_EQ (request->request->end, request->request->end);
}
@ -40,11 +40,11 @@ TEST (bulk_pull, no_end)
nano::system system (1);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> ();
req->start = nano::dev_genesis_key.pub;
req->start = nano::dev::genesis_key.pub;
req->end = 1;
connection->requests.push (std::unique_ptr<nano::message>{});
auto request (std::make_shared<nano::bulk_pull_server> (connection, std::move (req)));
ASSERT_EQ (system.nodes[0]->latest (nano::dev_genesis_key.pub), request->current);
ASSERT_EQ (system.nodes[0]->latest (nano::dev::genesis_key.pub), request->current);
ASSERT_TRUE (request->request->end.is_zero ());
}
@ -52,9 +52,9 @@ TEST (bulk_pull, end_not_owned)
{
nano::system system (1);
nano::keypair key2;
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, 100));
nano::block_hash latest (system.nodes[0]->latest (nano::dev_genesis_key.pub));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, 100));
nano::block_hash latest (system.nodes[0]->latest (nano::dev::genesis_key.pub));
nano::open_block open (0, 1, 2, nano::keypair ().prv, 4, 5);
open.hashables.account = key2.pub;
open.hashables.representative = key2.pub;
@ -79,7 +79,7 @@ TEST (bulk_pull, none)
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->start = nano::dev::genesis_key.pub;
req->end = genesis.hash ();
connection->requests.push (std::unique_ptr<nano::message>{});
auto request (std::make_shared<nano::bulk_pull_server> (connection, std::move (req)));
@ -92,7 +92,7 @@ TEST (bulk_pull, get_next_on_open)
nano::system system (1);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> ();
req->start = nano::dev_genesis_key.pub;
req->start = nano::dev::genesis_key.pub;
req->end.clear ();
connection->requests.push (std::unique_ptr<nano::message>{});
auto request (std::make_shared<nano::bulk_pull_server> (connection, std::move (req)));
@ -145,9 +145,9 @@ TEST (bulk_pull, count_limit)
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))));
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);
auto receive1 (std::make_shared<nano::receive_block> (send1->hash (), send1->hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1->hash ())));
auto receive1 (std::make_shared<nano::receive_block> (send1->hash (), send1->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ())));
ASSERT_EQ (nano::process_result::progress, node0->process (*receive1).code);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node0), node0));
@ -196,19 +196,19 @@ TEST (bootstrap_processor, process_one)
nano::node_flags node_flags;
node_flags.disable_bootstrap_bulk_push_client = true;
auto node0 = system.add_node (node_config, node_flags);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
auto send (system.wallet (0)->send_action (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub, 100));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, 100));
ASSERT_NE (nullptr, send);
node_config.peering_port = nano::get_available_port ();
node_flags.disable_rep_crawler = true;
auto node1 (std::make_shared<nano::node> (system.io_ctx, nano::unique_path (), node_config, system.work, node_flags));
nano::block_hash hash1 (node0->latest (nano::dev_genesis_key.pub));
nano::block_hash hash2 (node1->latest (nano::dev_genesis_key.pub));
nano::block_hash hash1 (node0->latest (nano::dev::genesis_key.pub));
nano::block_hash hash2 (node1->latest (nano::dev::genesis_key.pub));
ASSERT_NE (hash1, hash2);
node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false);
ASSERT_NE (node1->latest (nano::dev_genesis_key.pub), node0->latest (nano::dev_genesis_key.pub));
ASSERT_TIMELY (10s, node1->latest (nano::dev_genesis_key.pub) == node0->latest (nano::dev_genesis_key.pub));
ASSERT_NE (node1->latest (nano::dev::genesis_key.pub), node0->latest (nano::dev::genesis_key.pub));
ASSERT_TIMELY (10s, node1->latest (nano::dev::genesis_key.pub) == node0->latest (nano::dev::genesis_key.pub));
ASSERT_EQ (0, node1->active.size ());
node1->stop ();
}
@ -221,12 +221,12 @@ TEST (bootstrap_processor, process_two)
nano::node_flags node_flags;
node_flags.disable_bootstrap_bulk_push_client = true;
auto node0 (system.add_node (config, node_flags));
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
nano::block_hash hash1 (node0->latest (nano::dev_genesis_key.pub));
ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub, 50));
nano::block_hash hash2 (node0->latest (nano::dev_genesis_key.pub));
ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub, 50));
nano::block_hash hash3 (node0->latest (nano::dev_genesis_key.pub));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::block_hash hash1 (node0->latest (nano::dev::genesis_key.pub));
ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, 50));
nano::block_hash hash2 (node0->latest (nano::dev::genesis_key.pub));
ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, 50));
nano::block_hash hash3 (node0->latest (nano::dev::genesis_key.pub));
ASSERT_NE (hash1, hash2);
ASSERT_NE (hash1, hash3);
ASSERT_NE (hash2, hash3);
@ -234,8 +234,8 @@ TEST (bootstrap_processor, process_two)
auto node1 (std::make_shared<nano::node> (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work));
ASSERT_FALSE (node1->init_error ());
node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false);
ASSERT_NE (node1->latest (nano::dev_genesis_key.pub), node0->latest (nano::dev_genesis_key.pub));
ASSERT_TIMELY (10s, node1->latest (nano::dev_genesis_key.pub) == node0->latest (nano::dev_genesis_key.pub));
ASSERT_NE (node1->latest (nano::dev::genesis_key.pub), node0->latest (nano::dev::genesis_key.pub));
ASSERT_TIMELY (10s, node1->latest (nano::dev::genesis_key.pub) == node0->latest (nano::dev::genesis_key.pub));
node1->stop ();
}
@ -251,24 +251,24 @@ TEST (bootstrap_processor, process_state)
nano::genesis genesis;
nano::state_block_builder builder;
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
auto block1 = builder
.account (nano::dev_genesis_key.pub)
.previous (node0->latest (nano::dev_genesis_key.pub))
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 100)
.link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.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)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
auto block2 = builder
.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (block1->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount)
.link (block1->hash ())
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
@ -278,11 +278,11 @@ TEST (bootstrap_processor, process_state)
node0->process (*block2);
auto node1 (std::make_shared<nano::node> (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work, node_flags));
ASSERT_EQ (node0->latest (nano::dev_genesis_key.pub), block2->hash ());
ASSERT_NE (node1->latest (nano::dev_genesis_key.pub), block2->hash ());
ASSERT_EQ (node0->latest (nano::dev::genesis_key.pub), block2->hash ());
ASSERT_NE (node1->latest (nano::dev::genesis_key.pub), block2->hash ());
node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false);
ASSERT_NE (node1->latest (nano::dev_genesis_key.pub), node0->latest (nano::dev_genesis_key.pub));
ASSERT_TIMELY (10s, node1->latest (nano::dev_genesis_key.pub) == node0->latest (nano::dev_genesis_key.pub));
ASSERT_NE (node1->latest (nano::dev::genesis_key.pub), node0->latest (nano::dev::genesis_key.pub));
ASSERT_TIMELY (10s, node1->latest (nano::dev::genesis_key.pub) == node0->latest (nano::dev::genesis_key.pub));
ASSERT_TIMELY (10s, node1->active.empty ());
node1->stop ();
}
@ -297,15 +297,15 @@ TEST (bootstrap_processor, process_new)
auto node1 (system.add_node (config, node_flags));
config.peering_port = nano::get_available_port ();
auto node2 (system.add_node (config, node_flags));
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::keypair key2;
system.wallet (1)->insert_adhoc (key2.prv);
auto send (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, node1->config.receive_minimum.number ()));
auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node1->config.receive_minimum.number ()));
ASSERT_NE (nullptr, send);
ASSERT_TIMELY (10s, !node1->balance (key2.pub).is_zero ());
auto receive (node2->block (node2->latest (key2.pub)));
ASSERT_NE (nullptr, receive);
nano::uint128_t balance1 (node1->balance (nano::dev_genesis_key.pub));
nano::uint128_t balance1 (node1->balance (nano::dev::genesis_key.pub));
nano::uint128_t balance2 (node1->balance (key2.pub));
ASSERT_TIMELY (10s, node1->block_confirmed (send->hash ()) && node1->block_confirmed (receive->hash ()) && node1->active.empty () && node2->active.empty ()); // All blocks should be propagated & confirmed
@ -313,7 +313,7 @@ TEST (bootstrap_processor, process_new)
ASSERT_FALSE (node3->init_error ());
node3->bootstrap_initiator.bootstrap (node1->network.endpoint (), false);
ASSERT_TIMELY (10s, node3->balance (key2.pub) == balance2);
ASSERT_EQ (balance1, node3->balance (nano::dev_genesis_key.pub));
ASSERT_EQ (balance1, node3->balance (nano::dev::genesis_key.pub));
node3->stop ();
}
@ -326,19 +326,19 @@ TEST (bootstrap_processor, pull_diamond)
node_flags.disable_bootstrap_bulk_push_client = true;
auto node0 (system.add_node (config, node_flags));
nano::keypair key;
auto send1 (std::make_shared<nano::send_block> (node0->latest (nano::dev_genesis_key.pub), key.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (node0->latest (nano::dev_genesis_key.pub))));
auto send1 (std::make_shared<nano::send_block> (node0->latest (nano::dev::genesis_key.pub), key.pub, 0, 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);
auto open (std::make_shared<nano::open_block> (send1->hash (), 1, key.pub, key.prv, key.pub, *system.work.generate (key.pub)));
ASSERT_EQ (nano::process_result::progress, node0->process (*open).code);
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 ())));
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, node0->process (*send2).code);
auto receive (std::make_shared<nano::receive_block> (send1->hash (), send2->hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1->hash ())));
auto receive (std::make_shared<nano::receive_block> (send1->hash (), send2->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ())));
ASSERT_EQ (nano::process_result::progress, node0->process (*receive).code);
auto node1 (std::make_shared<nano::node> (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work));
ASSERT_FALSE (node1->init_error ());
node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false);
ASSERT_TIMELY (10s, node1->balance (nano::dev_genesis_key.pub) == 100);
ASSERT_EQ (100, node1->balance (nano::dev_genesis_key.pub));
ASSERT_TIMELY (10s, node1->balance (nano::dev::genesis_key.pub) == 100);
ASSERT_EQ (100, node1->balance (nano::dev::genesis_key.pub));
node1->stop ();
}
@ -359,12 +359,12 @@ TEST (bootstrap_processor, DISABLED_pull_requeue_network_error)
nano::state_block_builder builder;
auto send1 = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
.link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis.hash ()))
.build_shared ();
@ -377,7 +377,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 (), genesis.hash (), attempt->incremental_id);
node1->bootstrap_initiator.connections->request_pull (lock);
node2->stop ();
}
@ -395,19 +395,19 @@ TEST (bootstrap_processor, push_diamond)
auto node1 (std::make_shared<nano::node> (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work));
ASSERT_FALSE (node1->init_error ());
auto wallet1 (node1->wallets.create (100));
wallet1->insert_adhoc (nano::dev_genesis_key.prv);
wallet1->insert_adhoc (nano::dev::genesis_key.prv);
wallet1->insert_adhoc (key.prv);
auto send1 (std::make_shared<nano::send_block> (node0->latest (nano::dev_genesis_key.pub), key.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (node0->latest (nano::dev_genesis_key.pub))));
auto send1 (std::make_shared<nano::send_block> (node0->latest (nano::dev::genesis_key.pub), key.pub, 0, 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, node1->process (*send1).code);
auto open (std::make_shared<nano::open_block> (send1->hash (), 1, key.pub, key.prv, key.pub, *system.work.generate (key.pub)));
ASSERT_EQ (nano::process_result::progress, node1->process (*open).code);
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 ())));
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);
auto receive (std::make_shared<nano::receive_block> (send1->hash (), send2->hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1->hash ())));
auto receive (std::make_shared<nano::receive_block> (send1->hash (), send2->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ())));
ASSERT_EQ (nano::process_result::progress, node1->process (*receive).code);
node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false);
ASSERT_TIMELY (10s, node0->balance (nano::dev_genesis_key.pub) == 100);
ASSERT_EQ (100, node0->balance (nano::dev_genesis_key.pub));
ASSERT_TIMELY (10s, node0->balance (nano::dev::genesis_key.pub) == 100);
ASSERT_EQ (100, node0->balance (nano::dev::genesis_key.pub));
node1->stop ();
}
@ -424,18 +424,18 @@ TEST (bootstrap_processor, push_diamond_pruning)
node_flags.enable_pruning = true;
auto node1 (std::make_shared<nano::node> (system.io_ctx, nano::unique_path (), config, system.work, node_flags, 1));
ASSERT_FALSE (node1->init_error ());
auto latest (node0->latest (nano::dev_genesis_key.pub));
auto send1 (std::make_shared<nano::send_block> (latest, key.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)));
auto latest (node0->latest (nano::dev::genesis_key.pub));
auto send1 (std::make_shared<nano::send_block> (latest, key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)));
ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code);
auto open (std::make_shared<nano::open_block> (send1->hash (), 1, key.pub, key.prv, key.pub, *system.work.generate (key.pub)));
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::genesis_amount);
ASSERT_TIMELY (10s, node0->balance (key.pub) == nano::dev::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 ())));
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);
auto receive (std::make_shared<nano::receive_block> (send1->hash (), send2->hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1->hash ())));
auto receive (std::make_shared<nano::receive_block> (send1->hash (), send2->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ())));
ASSERT_EQ (nano::process_result::progress, node1->process (*receive).code);
{
auto transaction (node1->store.tx_begin_write ());
@ -453,8 +453,8 @@ TEST (bootstrap_processor, push_diamond_pruning)
}
// 2nd bootstrap
node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false);
ASSERT_TIMELY (10s, node0->balance (nano::dev_genesis_key.pub) == 100);
ASSERT_EQ (100, node0->balance (nano::dev_genesis_key.pub));
ASSERT_TIMELY (10s, node0->balance (nano::dev::genesis_key.pub) == 100);
ASSERT_EQ (100, node0->balance (nano::dev::genesis_key.pub));
node1->stop ();
}
@ -468,13 +468,13 @@ TEST (bootstrap_processor, push_one)
auto node1 (std::make_shared<nano::node> (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work));
auto wallet (node1->wallets.create (nano::random_wallet_id ()));
ASSERT_NE (nullptr, wallet);
wallet->insert_adhoc (nano::dev_genesis_key.prv);
nano::uint128_t balance1 (node1->balance (nano::dev_genesis_key.pub));
auto send (wallet->send_action (nano::dev_genesis_key.pub, key1.pub, 100));
wallet->insert_adhoc (nano::dev::genesis_key.prv);
nano::uint128_t balance1 (node1->balance (nano::dev::genesis_key.pub));
auto send (wallet->send_action (nano::dev::genesis_key.pub, key1.pub, 100));
ASSERT_NE (nullptr, send);
ASSERT_NE (balance1, node1->balance (nano::dev_genesis_key.pub));
ASSERT_NE (balance1, node1->balance (nano::dev::genesis_key.pub));
node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false);
ASSERT_TIMELY (10s, node0->balance (nano::dev_genesis_key.pub) != balance1);
ASSERT_TIMELY (10s, node0->balance (nano::dev::genesis_key.pub) != balance1);
node1->stop ();
}
@ -494,12 +494,12 @@ TEST (bootstrap_processor, lazy_hash)
nano::state_block_builder builder;
auto send1 = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
.link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (genesis.hash ()))
.build_shared ();
auto receive1 = builder
@ -569,12 +569,12 @@ TEST (bootstrap_processor, lazy_hash_bootstrap_id)
nano::state_block_builder builder;
auto send1 = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
.link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (genesis.hash ()))
.build_shared ();
auto receive1 = builder
@ -646,52 +646,52 @@ TEST (bootstrap_processor, lazy_hash_pruning)
nano::state_block_builder builder;
auto send1 = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::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 ()))
.build_shared ();
auto receive1 = builder
.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (send1->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount)
.link (send1->hash ())
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (send1->hash ()))
.build_shared ();
auto change1 = builder
.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (receive1->hash ())
.representative (key1.pub)
.balance (nano::genesis_amount)
.balance (nano::dev::genesis_amount)
.link (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (receive1->hash ()))
.build_shared ();
auto change2 = builder
.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (change1->hash ())
.representative (key2.pub)
.balance (nano::genesis_amount)
.balance (nano::dev::genesis_amount)
.link (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (change1->hash ()))
.build_shared ();
auto send2 = builder
.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (change2->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
.link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (change2->hash ()))
.build_shared ();
auto receive2 = builder
@ -780,12 +780,12 @@ TEST (bootstrap_processor, lazy_max_pull_count)
nano::state_block_builder builder;
auto send1 = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
.link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (genesis.hash ()))
.build_shared ();
auto receive1 = builder
@ -832,7 +832,7 @@ TEST (bootstrap_processor, lazy_max_pull_count)
.make_block ()
.account (key2.pub)
.previous (change1->hash ())
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (nano::Gxrb_ratio)
.link (0)
.sign (key2.prv, key2.pub)
@ -883,23 +883,23 @@ TEST (bootstrap_processor, lazy_unclear_state_link)
nano::state_block_builder builder;
auto send1 = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis.hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code);
auto send2 = builder
.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (send1->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - 2 * nano::Gxrb_ratio)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code);
@ -946,12 +946,12 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing)
nano::state_block_builder builder;
auto send1 = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis.hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code);
@ -998,23 +998,23 @@ TEST (bootstrap_processor, DISABLED_lazy_destinations)
nano::state_block_builder builder;
auto send1 = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
.link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis.hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code);
auto send2 = builder
.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (send1->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - 2 * nano::Gxrb_ratio)
.link (key2.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code);
@ -1063,23 +1063,23 @@ TEST (bootstrap_processor, lazy_pruning_missing_block)
nano::state_block_builder builder;
auto send1 = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
.link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis.hash ()))
.build_shared ();
node1->process_active (send1);
auto send2 = builder
.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (send1->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - 2 * nano::Gxrb_ratio)
.link (key2.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
node1->process_active (send2);
@ -1158,12 +1158,12 @@ TEST (bootstrap_processor, lazy_cancel)
nano::state_block_builder builder;
auto send1 = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
.link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (genesis.hash ()))
.build_shared ();
@ -1198,12 +1198,12 @@ TEST (bootstrap_processor, wallet_lazy_frontier)
nano::state_block_builder builder;
auto send1 = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
.link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (genesis.hash ()))
.build_shared ();
auto receive1 = builder
@ -1277,12 +1277,12 @@ TEST (bootstrap_processor, wallet_lazy_pending)
nano::state_block_builder builder;
auto send1 = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
.link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (genesis.hash ()))
.build_shared ();
auto receive1 = builder
@ -1339,12 +1339,12 @@ TEST (bootstrap_processor, multiple_attempts)
nano::state_block_builder builder;
auto send1 = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
.link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (genesis.hash ()))
.build_shared ();
auto receive1 = builder
@ -1433,7 +1433,7 @@ TEST (frontier_req, begin)
req->count = std::numeric_limits<decltype (req->count)>::max ();
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 (nano::dev::genesis_key.pub, request->current);
nano::genesis genesis;
ASSERT_EQ (genesis.hash (), request->frontier);
}
@ -1443,7 +1443,7 @@ TEST (frontier_req, end)
nano::system system (1);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
auto req = std::make_unique<nano::frontier_req> ();
req->start = nano::dev_genesis_key.pub.number () + 1;
req->start = nano::dev::genesis_key.pub.number () + 1;
req->age = std::numeric_limits<decltype (req->age)>::max ();
req->count = std::numeric_limits<decltype (req->count)>::max ();
connection->requests.push (std::unique_ptr<nano::message>{});
@ -1461,12 +1461,12 @@ TEST (frontier_req, count)
nano::state_block_builder builder;
auto send1 = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
.link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
node1->work_generate_blocking (*send1);
@ -1475,7 +1475,7 @@ TEST (frontier_req, count)
.make_block ()
.account (key1.pub)
.previous (0)
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (nano::Gxrb_ratio)
.link (send1->hash ())
.sign (key1.prv, key1.pub)
@ -1491,7 +1491,7 @@ TEST (frontier_req, count)
req->count = 1;
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 (nano::dev::genesis_key.pub, request->current);
ASSERT_EQ (send1->hash (), request->frontier);
}
@ -1505,7 +1505,7 @@ TEST (frontier_req, time_bound)
req->count = std::numeric_limits<decltype (req->count)>::max ();
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 (nano::dev::genesis_key.pub, request->current);
// Wait 2 seconds until age of account will be > 1 seconds
std::this_thread::sleep_for (std::chrono::milliseconds (2100));
auto req2 (std::make_unique<nano::frontier_req> ());
@ -1528,7 +1528,7 @@ TEST (frontier_req, time_cutoff)
req->count = std::numeric_limits<decltype (req->count)>::max ();
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 (nano::dev::genesis_key.pub, request->current);
nano::genesis genesis;
ASSERT_EQ (genesis.hash (), request->frontier);
// Wait 4 seconds until age of account will be > 3 seconds
@ -1550,13 +1550,13 @@ TEST (frontier_req, confirmed_frontier)
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 ())
while (nano::pub_key (priv_key).number () >= nano::dev::genesis_key.pub.number ())
{
priv_key = nano::keypair ().prv;
}
nano::keypair key_before_genesis (priv_key.to_string ());
// Public key after genesis in accounts table
while (nano::pub_key (priv_key).number () <= nano::dev_genesis_key.pub.number ())
while (nano::pub_key (priv_key).number () <= nano::dev::genesis_key.pub.number ())
{
priv_key = nano::keypair ().prv;
}
@ -1564,24 +1564,24 @@ TEST (frontier_req, confirmed_frontier)
nano::state_block_builder builder;
auto send1 = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
.link (key_before_genesis.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
node1->work_generate_blocking (*send1);
ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code);
auto send2 = builder
.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (send1->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - 2 * nano::Gxrb_ratio)
.link (key_after_genesis.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
node1->work_generate_blocking (*send2);
@ -1590,7 +1590,7 @@ TEST (frontier_req, confirmed_frontier)
.make_block ()
.account (key_before_genesis.pub)
.previous (0)
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (nano::Gxrb_ratio)
.link (send1->hash ())
.sign (key_before_genesis.prv, key_before_genesis.pub)
@ -1602,7 +1602,7 @@ TEST (frontier_req, confirmed_frontier)
.make_block ()
.account (key_after_genesis.pub)
.previous (0)
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (nano::Gxrb_ratio)
.link (send2->hash ())
.sign (key_after_genesis.prv, key_after_genesis.pub)
@ -1622,7 +1622,7 @@ TEST (frontier_req, confirmed_frontier)
ASSERT_TRUE (req->header.frontier_req_is_only_confirmed_present ());
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 (nano::dev::genesis_key.pub, request->current);
ASSERT_EQ (genesis.hash (), request->frontier);
// Request starting with account before genesis (confirmed only)
@ -1636,7 +1636,7 @@ TEST (frontier_req, confirmed_frontier)
ASSERT_TRUE (req2->header.frontier_req_is_only_confirmed_present ());
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 (nano::dev::genesis_key.pub, request2->current);
ASSERT_EQ (genesis.hash (), request2->frontier);
// Request starting with account after genesis (confirmed only)
@ -1719,21 +1719,21 @@ TEST (bulk, genesis)
node_flags.disable_bootstrap_bulk_push_client = true;
node_flags.disable_lazy_bootstrap = true;
auto node1 = system.add_node (config, node_flags);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
auto node2 (std::make_shared<nano::node> (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work));
ASSERT_FALSE (node2->init_error ());
nano::block_hash latest1 (node1->latest (nano::dev_genesis_key.pub));
nano::block_hash latest2 (node2->latest (nano::dev_genesis_key.pub));
nano::block_hash latest1 (node1->latest (nano::dev::genesis_key.pub));
nano::block_hash latest2 (node2->latest (nano::dev::genesis_key.pub));
ASSERT_EQ (latest1, latest2);
nano::keypair key2;
auto send (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, 100));
auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, 100));
ASSERT_NE (nullptr, send);
nano::block_hash latest3 (node1->latest (nano::dev_genesis_key.pub));
nano::block_hash latest3 (node1->latest (nano::dev::genesis_key.pub));
ASSERT_NE (latest1, latest3);
node2->bootstrap_initiator.bootstrap (node1->network.endpoint (), false);
ASSERT_TIMELY (10s, node2->latest (nano::dev_genesis_key.pub) == node1->latest (nano::dev_genesis_key.pub));
ASSERT_EQ (node2->latest (nano::dev_genesis_key.pub), node1->latest (nano::dev_genesis_key.pub));
ASSERT_TIMELY (10s, node2->latest (nano::dev::genesis_key.pub) == node1->latest (nano::dev::genesis_key.pub));
ASSERT_EQ (node2->latest (nano::dev::genesis_key.pub), node1->latest (nano::dev::genesis_key.pub));
node2->stop ();
}
@ -1746,7 +1746,7 @@ TEST (bulk, offline_send)
node_flags.disable_bootstrap_bulk_push_client = true;
node_flags.disable_lazy_bootstrap = true;
auto node1 = system.add_node (config, node_flags);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
auto node2 (std::make_shared<nano::node> (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work));
ASSERT_FALSE (node2->init_error ());
node2->start ();
@ -1754,9 +1754,9 @@ TEST (bulk, offline_send)
nano::keypair key2;
auto wallet (node2->wallets.create (nano::random_wallet_id ()));
wallet->insert_adhoc (key2.prv);
auto send1 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, node1->config.receive_minimum.number ()));
auto send1 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node1->config.receive_minimum.number ()));
ASSERT_NE (nullptr, send1);
ASSERT_NE (std::numeric_limits<nano::uint256_t>::max (), node1->balance (nano::dev_genesis_key.pub));
ASSERT_NE (std::numeric_limits<nano::uint256_t>::max (), node1->balance (nano::dev::genesis_key.pub));
node1->block_processor.flush ();
node1->scheduler.flush ();
// Wait to finish election background tasks
@ -1771,7 +1771,7 @@ TEST (bulk, offline_send)
ASSERT_NO_ERROR (system.poll ());
} while (node1->network.empty () || node2->network.empty ());
// Send block arrival via bootstrap
ASSERT_TIMELY (10s, node2->balance (nano::dev_genesis_key.pub) != std::numeric_limits<nano::uint256_t>::max ());
ASSERT_TIMELY (10s, node2->balance (nano::dev::genesis_key.pub) != std::numeric_limits<nano::uint256_t>::max ());
// Receiving send block
ASSERT_TIMELY (20s, node2->balance (key2.pub) == node1->config.receive_minimum.number ());
node2->stop ();
@ -1789,25 +1789,25 @@ TEST (bulk, genesis_pruning)
node_flags.disable_ongoing_bootstrap = true;
node_flags.enable_pruning = true;
auto node1 = system.add_node (config, node_flags);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
node_flags.enable_pruning = false;
auto node2 (std::make_shared<nano::node> (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work, node_flags));
ASSERT_FALSE (node2->init_error ());
nano::block_hash latest1 (node1->latest (nano::dev_genesis_key.pub));
nano::block_hash latest2 (node2->latest (nano::dev_genesis_key.pub));
nano::block_hash latest1 (node1->latest (nano::dev::genesis_key.pub));
nano::block_hash latest2 (node2->latest (nano::dev::genesis_key.pub));
ASSERT_EQ (latest1, latest2);
nano::keypair key2;
auto send1 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, 100));
auto send1 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, 100));
ASSERT_NE (nullptr, send1);
auto send2 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, 100));
auto send2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, 100));
ASSERT_NE (nullptr, send2);
auto send3 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, 100));
auto send3 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, 100));
ASSERT_NE (nullptr, send3);
{
auto transaction (node1->wallets.tx_begin_write ());
system.wallet (0)->store.erase (transaction, nano::dev_genesis_key.pub);
system.wallet (0)->store.erase (transaction, nano::dev::genesis_key.pub);
}
nano::block_hash latest3 (node1->latest (nano::dev_genesis_key.pub));
nano::block_hash latest3 (node1->latest (nano::dev::genesis_key.pub));
ASSERT_NE (latest1, latest3);
ASSERT_EQ (send3->hash (), latest3);
// Confirm last block to prune previous
@ -1855,8 +1855,8 @@ TEST (bulk, genesis_pruning)
// New bootstrap
ASSERT_TIMELY (5s, node2->bootstrap_initiator.connections->connections_count == 0);
node2->bootstrap_initiator.bootstrap (node1->network.endpoint (), false);
ASSERT_TIMELY (10s, node2->latest (nano::dev_genesis_key.pub) == node1->latest (nano::dev_genesis_key.pub));
ASSERT_EQ (node2->latest (nano::dev_genesis_key.pub), node1->latest (nano::dev_genesis_key.pub));
ASSERT_TIMELY (10s, node2->latest (nano::dev::genesis_key.pub) == node1->latest (nano::dev::genesis_key.pub));
ASSERT_EQ (node2->latest (nano::dev::genesis_key.pub), node1->latest (nano::dev::genesis_key.pub));
node2->stop ();
}
@ -1865,11 +1865,11 @@ TEST (bulk_pull_account, basics)
nano::system system (1);
system.nodes[0]->config.receive_minimum = 20;
nano::keypair key1;
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
system.wallet (0)->insert_adhoc (key1.prv);
auto send1 (system.wallet (0)->send_action (nano::genesis_account, key1.pub, 25));
auto send2 (system.wallet (0)->send_action (nano::genesis_account, key1.pub, 10));
auto send3 (system.wallet (0)->send_action (nano::genesis_account, key1.pub, 2));
auto send1 (system.wallet (0)->send_action (nano::dev::genesis->account (), key1.pub, 25));
auto send2 (system.wallet (0)->send_action (nano::dev::genesis->account (), key1.pub, 10));
auto send3 (system.wallet (0)->send_action (nano::dev::genesis->account (), key1.pub, 2));
ASSERT_TIMELY (5s, system.nodes[0]->balance (key1.pub) == 25);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
@ -1888,7 +1888,7 @@ TEST (bulk_pull_account, basics)
auto block_data (request->get_next ());
ASSERT_EQ (send2->hash (), block_data.first.get ()->hash);
ASSERT_EQ (nano::uint128_union (10), block_data.second.get ()->amount);
ASSERT_EQ (nano::genesis_account, block_data.second.get ()->source);
ASSERT_EQ (nano::dev::genesis->account (), block_data.second.get ()->source);
ASSERT_EQ (nullptr, request->get_next ().first.get ());
}
@ -1902,7 +1902,7 @@ TEST (bulk_pull_account, basics)
auto block_data (request->get_next ());
ASSERT_NE (nullptr, block_data.first.get ());
ASSERT_NE (nullptr, block_data.second.get ());
ASSERT_EQ (nano::genesis_account, block_data.second.get ()->source);
ASSERT_EQ (nano::dev::genesis->account (), block_data.second.get ()->source);
block_data = request->get_next ();
ASSERT_EQ (nullptr, block_data.first.get ());
ASSERT_EQ (nullptr, block_data.second.get ());

242
nano/core_test/confirmation_height.cpp
View file

@ -38,17 +38,17 @@ TEST (confirmation_height, single)
node_flags.confirmation_height_processor_mode = mode_a;
auto node = system.add_node (node_flags);
nano::keypair key1;
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
nano::block_hash latest1 (node->latest (nano::dev_genesis_key.pub));
auto send1 (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, latest1, nano::dev_genesis_key.pub, amount - 100, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest1)));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::block_hash latest1 (node->latest (nano::dev::genesis_key.pub));
auto send1 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, latest1, nano::dev::genesis_key.pub, amount - 100, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest1)));
// Check confirmation heights before, should be uninitialized (1 for genesis).
nano::confirmation_height_info confirmation_height_info;
add_callback_stats (*node);
auto transaction = node->store.tx_begin_read ();
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev_genesis_key.pub, confirmation_height_info));
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info));
ASSERT_EQ (1, confirmation_height_info.height);
ASSERT_EQ (nano::genesis_hash, confirmation_height_info.frontier);
ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier);
node->process_active (send1);
node->block_processor.flush ();
@ -58,7 +58,7 @@ TEST (confirmation_height, single)
{
auto transaction = node->store.tx_begin_write ();
ASSERT_TRUE (node->ledger.block_confirmed (transaction, send1->hash ()));
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev_genesis_key.pub, confirmation_height_info));
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info));
ASSERT_EQ (2, confirmation_height_info.height);
ASSERT_EQ (send1->hash (), confirmation_height_info.frontier);
@ -90,17 +90,17 @@ TEST (confirmation_height, multiple_accounts)
nano::keypair key1;
nano::keypair key2;
nano::keypair key3;
nano::block_hash latest1 (system.nodes[0]->latest (nano::dev_genesis_key.pub));
nano::block_hash latest1 (system.nodes[0]->latest (nano::dev::genesis_key.pub));
// Send to all accounts
nano::send_block send1 (latest1, key1.pub, node->online_reps.delta () + 300, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest1));
nano::send_block send2 (send1.hash (), key2.pub, node->online_reps.delta () + 200, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1.hash ()));
nano::send_block send3 (send2.hash (), key3.pub, node->online_reps.delta () + 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send2.hash ()));
nano::send_block send1 (latest1, key1.pub, node->online_reps.delta () + 300, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest1));
nano::send_block send2 (send1.hash (), key2.pub, node->online_reps.delta () + 200, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ()));
nano::send_block send3 (send2.hash (), key3.pub, node->online_reps.delta () + 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2.hash ()));
// Open all accounts
nano::open_block open1 (send1.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub));
nano::open_block open2 (send2.hash (), nano::genesis_account, key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub));
nano::open_block open3 (send3.hash (), nano::genesis_account, key3.pub, key3.prv, key3.pub, *system.work.generate (key3.pub));
nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub));
nano::open_block open2 (send2.hash (), nano::dev::genesis->account (), key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub));
nano::open_block open3 (send3.hash (), nano::dev::genesis->account (), key3.pub, key3.prv, key3.pub, *system.work.generate (key3.pub));
// Send and receive various blocks to these accounts
nano::send_block send4 (open1.hash (), key2.pub, 50, key1.prv, key1.pub, *system.work.generate (open1.hash ()));
@ -132,9 +132,9 @@ TEST (confirmation_height, multiple_accounts)
// Check confirmation heights of all the accounts (except genesis) are uninitialized (0),
// as we have any just added them to the ledger and not processed any live transactions yet.
nano::confirmation_height_info confirmation_height_info;
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev_genesis_key.pub, confirmation_height_info));
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info));
ASSERT_EQ (1, confirmation_height_info.height);
ASSERT_EQ (nano::genesis_hash, confirmation_height_info.frontier);
ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier);
ASSERT_TRUE (node->store.confirmation_height.get (transaction, key1.pub, confirmation_height_info));
ASSERT_EQ (0, confirmation_height_info.height);
ASSERT_EQ (nano::block_hash (0), confirmation_height_info.frontier);
@ -162,8 +162,8 @@ TEST (confirmation_height, multiple_accounts)
auto & store = node->store;
auto transaction = node->store.tx_begin_read ();
ASSERT_TRUE (node->ledger.block_confirmed (transaction, receive3->hash ()));
ASSERT_FALSE (store.account.get (transaction, nano::dev_genesis_key.pub, account_info));
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev_genesis_key.pub, confirmation_height_info));
ASSERT_FALSE (store.account.get (transaction, nano::dev::genesis_key.pub, account_info));
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info));
ASSERT_EQ (4, confirmation_height_info.height);
ASSERT_EQ (send3.hash (), confirmation_height_info.frontier);
ASSERT_EQ (4, account_info.block_count);
@ -198,7 +198,7 @@ TEST (confirmation_height, multiple_accounts)
// Confirm the other latest can't be rolled back either
ASSERT_TRUE (node->ledger.rollback (transaction, node->latest (key3.pub)));
ASSERT_TRUE (node->ledger.rollback (transaction, node->latest (nano::dev_genesis_key.pub)));
ASSERT_TRUE (node->ledger.rollback (transaction, node->latest (nano::dev::genesis_key.pub)));
// Attempt some others which have been cemented
ASSERT_TRUE (node->ledger.rollback (transaction, open1.hash ()));
@ -225,11 +225,11 @@ TEST (confirmation_height, gap_bootstrap)
auto & node1 = *system.add_node (node_flags);
nano::genesis genesis;
nano::keypair destination;
auto send1 (std::make_shared<nano::state_block> (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::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 (), 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));
node1.work_generate_blocking (*send1);
auto send2 (std::make_shared<nano::state_block> (nano::genesis_account, send1->hash (), nano::genesis_account, nano::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::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::genesis_account, send2->hash (), nano::genesis_account, nano::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::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);
@ -259,7 +259,7 @@ TEST (confirmation_height, gap_bootstrap)
ASSERT_EQ (unchecked_count, 2);
nano::confirmation_height_info confirmation_height_info;
ASSERT_FALSE (node1.store.confirmation_height.get (transaction, nano::dev_genesis_key.pub, 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);
}
@ -275,7 +275,7 @@ TEST (confirmation_height, gap_bootstrap)
ASSERT_EQ (unchecked_count, 0);
nano::confirmation_height_info confirmation_height_info;
ASSERT_FALSE (node1.store.confirmation_height.get (transaction, nano::dev_genesis_key.pub, 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_TRUE (node1.store.confirmation_height.get (transaction, destination.pub, confirmation_height_info));
@ -304,18 +304,18 @@ 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::genesis_amount; // Prevent auto-receive & open1/receive1/receive2 blocks conflicts
node_config.receive_minimum = nano::dev::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 (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::genesis_account, genesis.hash (), nano::genesis_account, nano::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 (), genesis.hash (), nano::dev::genesis->account (), nano::dev::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::genesis_account, send1->hash (), nano::genesis_account, nano::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::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::genesis_account, send2->hash (), nano::genesis_account, nano::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::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));
@ -341,9 +341,9 @@ TEST (confirmation_height, gap_live)
{
auto transaction = node->store.tx_begin_read ();
nano::confirmation_height_info confirmation_height_info;
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev_genesis_key.pub, confirmation_height_info));
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info));
ASSERT_EQ (1, confirmation_height_info.height);
ASSERT_EQ (nano::genesis_hash, confirmation_height_info.frontier);
ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier);
}
// Vote and confirm all existing blocks
@ -363,7 +363,7 @@ TEST (confirmation_height, gap_live)
nano::confirmation_height_info confirmation_height_info;
ASSERT_TRUE (node->ledger.block_confirmed (transaction, receive2->hash ()));
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev_genesis_key.pub, confirmation_height_info));
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info));
ASSERT_EQ (4, confirmation_height_info.height);
ASSERT_EQ (send3->hash (), confirmation_height_info.frontier);
ASSERT_FALSE (node->store.confirmation_height.get (transaction, destination.pub, confirmation_height_info));
@ -392,24 +392,24 @@ TEST (confirmation_height, send_receive_between_2_accounts)
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto node = system.add_node (node_config, node_flags);
nano::keypair key1;
nano::block_hash latest (node->latest (nano::dev_genesis_key.pub));
nano::block_hash latest (node->latest (nano::dev::genesis_key.pub));
nano::send_block send1 (latest, key1.pub, node->online_reps.delta () + 2, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest));
nano::send_block send1 (latest, key1.pub, node->online_reps.delta () + 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
nano::open_block open1 (send1.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub));
nano::send_block send2 (open1.hash (), nano::genesis_account, 1000, key1.prv, key1.pub, *system.work.generate (open1.hash ()));
nano::send_block send3 (send2.hash (), nano::genesis_account, 900, key1.prv, key1.pub, *system.work.generate (send2.hash ()));
nano::send_block send4 (send3.hash (), nano::genesis_account, 500, key1.prv, key1.pub, *system.work.generate (send3.hash ()));
nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub));
nano::send_block send2 (open1.hash (), nano::dev::genesis->account (), 1000, key1.prv, key1.pub, *system.work.generate (open1.hash ()));
nano::send_block send3 (send2.hash (), nano::dev::genesis->account (), 900, key1.prv, key1.pub, *system.work.generate (send2.hash ()));
nano::send_block send4 (send3.hash (), nano::dev::genesis->account (), 500, key1.prv, key1.pub, *system.work.generate (send3.hash ()));
nano::receive_block receive1 (send1.hash (), send2.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1.hash ()));
nano::receive_block receive2 (receive1.hash (), send3.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (receive1.hash ()));
nano::receive_block receive3 (receive2.hash (), send4.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (receive2.hash ()));
nano::receive_block receive1 (send1.hash (), send2.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ()));
nano::receive_block receive2 (receive1.hash (), send3.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive1.hash ()));
nano::receive_block receive3 (receive2.hash (), send4.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive2.hash ()));
nano::send_block send5 (receive3.hash (), key1.pub, node->online_reps.delta () + 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (receive3.hash ()));
nano::send_block send5 (receive3.hash (), key1.pub, node->online_reps.delta () + 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive3.hash ()));
auto receive4 = std::make_shared<nano::receive_block> (send4.hash (), send5.hash (), key1.prv, key1.pub, *system.work.generate (send4.hash ()));
// Unpocketed send
nano::keypair key2;
nano::send_block send6 (send5.hash (), key2.pub, node->online_reps.delta (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send5.hash ()));
nano::send_block send6 (send5.hash (), key2.pub, node->online_reps.delta (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send5.hash ()));
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send1).code);
@ -443,8 +443,8 @@ TEST (confirmation_height, send_receive_between_2_accounts)
ASSERT_TRUE (node->ledger.block_confirmed (transaction, receive4->hash ()));
nano::account_info account_info;
nano::confirmation_height_info confirmation_height_info;
ASSERT_FALSE (node->store.account.get (transaction, nano::dev_genesis_key.pub, account_info));
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev_genesis_key.pub, confirmation_height_info));
ASSERT_FALSE (node->store.account.get (transaction, nano::dev::genesis_key.pub, account_info));
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info));
ASSERT_EQ (6, confirmation_height_info.height);
ASSERT_EQ (send5.hash (), confirmation_height_info.frontier);
ASSERT_EQ (7, account_info.block_count);
@ -476,19 +476,19 @@ TEST (confirmation_height, send_receive_self)
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::block_hash latest (node->latest (nano::dev_genesis_key.pub));
nano::block_hash latest (node->latest (nano::dev::genesis_key.pub));
nano::send_block send1 (latest, nano::dev_genesis_key.pub, nano::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::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::genesis_amount - 3, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send2.hash ()));
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::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::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 ()));
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 ()));
// Send to another account to prevent automatic receiving on the genesis account
nano::keypair key1;
nano::send_block send4 (receive3->hash (), key1.pub, node->online_reps.delta (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (receive3->hash ()));
nano::send_block send4 (receive3->hash (), key1.pub, node->online_reps.delta (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive3->hash ()));
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send1).code);
@ -513,9 +513,9 @@ TEST (confirmation_height, send_receive_self)
auto transaction (node->store.tx_begin_read ());
ASSERT_TRUE (node->ledger.block_confirmed (transaction, receive3->hash ()));
nano::account_info account_info;
ASSERT_FALSE (node->store.account.get (transaction, nano::dev_genesis_key.pub, account_info));
ASSERT_FALSE (node->store.account.get (transaction, nano::dev::genesis_key.pub, account_info));
nano::confirmation_height_info confirmation_height_info;
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev_genesis_key.pub, confirmation_height_info));
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info));
ASSERT_EQ (7, confirmation_height_info.height);
ASSERT_EQ (receive3->hash (), confirmation_height_info.frontier);
ASSERT_EQ (8, account_info.block_count);
@ -539,14 +539,14 @@ TEST (confirmation_height, all_block_types)
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::block_hash latest (node->latest (nano::dev_genesis_key.pub));
nano::block_hash latest (node->latest (nano::dev::genesis_key.pub));
nano::keypair key1;
nano::keypair key2;
auto & store = node->store;
nano::send_block send (latest, key1.pub, nano::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::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::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::open_block open (send.hash (), nano::dev_genesis_key.pub, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub));
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));
nano::send_block send2 (open.hash (), key2.pub, 0, key1.prv, key1.pub, *system.work.generate (open.hash ()));
@ -557,19 +557,19 @@ TEST (confirmation_height, all_block_types)
nano::change_block change (receive.hash (), key2.pub, key1.prv, key1.pub, *system.work.generate (receive.hash ()));
nano::state_block state_change (key2.pub, state_send.hash (), nano::dev_genesis_key.pub, nano::Gxrb_ratio, 0, key2.prv, key2.pub, *system.work.generate (state_send.hash ()));
nano::state_block state_change (key2.pub, state_send.hash (), nano::dev::genesis_key.pub, nano::Gxrb_ratio, 0, key2.prv, key2.pub, *system.work.generate (state_send.hash ()));
nano::state_block epoch (key2.pub, state_change.hash (), nano::dev_genesis_key.pub, nano::Gxrb_ratio, node->ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (state_change.hash ()));
nano::state_block epoch (key2.pub, state_change.hash (), nano::dev::genesis_key.pub, nano::Gxrb_ratio, node->ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (state_change.hash ()));
nano::state_block epoch1 (key1.pub, change.hash (), key2.pub, nano::Gxrb_ratio, node->ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (change.hash ()));
nano::state_block epoch1 (key1.pub, change.hash (), key2.pub, nano::Gxrb_ratio, node->ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (change.hash ()));
nano::state_block state_send1 (key1.pub, epoch1.hash (), 0, nano::Gxrb_ratio - 1, key2.pub, key1.prv, key1.pub, *system.work.generate (epoch1.hash ()));
nano::state_block state_receive2 (key2.pub, epoch.hash (), 0, nano::Gxrb_ratio + 1, state_send1.hash (), key2.prv, key2.pub, *system.work.generate (epoch.hash ()));
auto state_send2 = std::make_shared<nano::state_block> (key2.pub, state_receive2.hash (), 0, nano::Gxrb_ratio, key1.pub, key2.prv, key2.pub, *system.work.generate (state_receive2.hash ()));
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::genesis_account, send1.hash (), nano::genesis_account, nano::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_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 ()));
{
auto transaction (store.tx_begin_write ());
@ -611,8 +611,8 @@ TEST (confirmation_height, all_block_types)
ASSERT_TRUE (node->ledger.block_confirmed (transaction, state_send2->hash ()));
nano::account_info account_info;
nano::confirmation_height_info confirmation_height_info;
ASSERT_FALSE (node->store.account.get (transaction, nano::dev_genesis_key.pub, account_info));
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev_genesis_key.pub, confirmation_height_info));
ASSERT_FALSE (node->store.account.get (transaction, nano::dev::genesis_key.pub, account_info));
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info));
ASSERT_EQ (3, confirmation_height_info.height);
ASSERT_EQ (send1.hash (), confirmation_height_info.frontier);
ASSERT_LE (4, account_info.block_count);
@ -656,10 +656,10 @@ TEST (confirmation_height, conflict_rollback_cemented)
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::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> (genesis.hash (), key1.pub, nano::dev::genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis.hash ())));
nano::publish publish1 (send1);
nano::keypair key2;
auto send2 (std::make_shared<nano::send_block> (genesis.hash (), key2.pub, nano::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> (genesis.hash (), key2.pub, nano::dev::genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis.hash ())));
nano::publish publish2 (send2);
auto channel1 (node1->network.udp_channels.create (node1->network.endpoint ()));
node1->network.inbound (publish1, channel1);
@ -671,7 +671,7 @@ TEST (confirmation_height, conflict_rollback_cemented)
node2->scheduler.flush ();
ASSERT_EQ (1, node1->active.size ());
ASSERT_EQ (1, node2->active.size ());
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
node1->network.inbound (publish2, channel1);
node1->block_processor.flush ();
node2->network.inbound (publish1, channel2);
@ -683,19 +683,19 @@ TEST (confirmation_height, conflict_rollback_cemented)
{
auto transaction (node1->store.tx_begin_write ());
ASSERT_TRUE (node1->store.block.exists (transaction, publish1.block->hash ()));
node1->store.confirmation_height.put (transaction, nano::genesis_account, nano::confirmation_height_info{ 2, send2->hash () });
node1->store.confirmation_height.put (transaction, nano::dev::genesis->account (), nano::confirmation_height_info{ 2, send2->hash () });
}
{
auto transaction (node2->store.tx_begin_write ());
ASSERT_TRUE (node2->store.block.exists (transaction, publish2.block->hash ()));
node2->store.confirmation_height.put (transaction, nano::genesis_account, nano::confirmation_height_info{ 2, send2->hash () });
node2->store.confirmation_height.put (transaction, nano::dev::genesis->account (), nano::confirmation_height_info{ 2, send2->hash () });
}
auto rollback_log_entry = boost::str (boost::format ("Failed to roll back %1%") % send2->hash ().to_string ());
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::genesis_amount - 100, winner.first);
ASSERT_EQ (nano::dev::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 ()));
@ -729,7 +729,7 @@ TEST (confirmation_heightDeathTest, rollback_added_block)
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::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> (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 transaction (store->tx_begin_write ());
store->initialize (transaction, ledger.cache);
@ -759,9 +759,9 @@ TEST (confirmation_height, observers)
node_flags.confirmation_height_processor_mode = mode_a;
auto node1 = system.add_node (node_flags);
nano::keypair key1;
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
nano::block_hash latest1 (node1->latest (nano::dev_genesis_key.pub));
auto send1 (std::make_shared<nano::send_block> (latest1, key1.pub, amount - node1->config.receive_minimum.number (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest1)));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::block_hash latest1 (node1->latest (nano::dev::genesis_key.pub));
auto send1 (std::make_shared<nano::send_block> (latest1, key1.pub, amount - node1->config.receive_minimum.number (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest1)));
add_callback_stats (*node1);
@ -806,7 +806,7 @@ TEST (confirmation_heightDeathTest, modified_chain)
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::genesis_hash, key1.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::genesis_hash));
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 transaction (store->tx_begin_write ());
store->initialize (transaction, ledger.cache);
@ -832,7 +832,7 @@ TEST (confirmation_heightDeathTest, modified_chain)
}
ASSERT_EQ (nano::process_result::progress, ledger.process (store->tx_begin_write (), *send).code);
store->confirmation_height.put (store->tx_begin_write (), nano::genesis_account, { 1, nano::genesis_hash });
store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () });
nano::confirmation_height_unbounded unbounded_processor (
ledger, write_database_queue, 10ms, logging, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; });
@ -877,7 +877,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed)
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::genesis_hash, key1.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::genesis_hash));
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 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 ());
@ -906,7 +906,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed)
// Reset conditions and test with the bounded processor
ASSERT_EQ (nano::process_result::progress, ledger.process (store->tx_begin_write (), *open).code);
store->confirmation_height.put (store->tx_begin_write (), nano::genesis_account, { 1, nano::genesis_hash });
store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () });
nano::confirmation_height_bounded bounded_processor (
ledger, write_database_queue, 10ms, logging, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; });
@ -936,12 +936,12 @@ TEST (confirmation_height, pending_observer_callbacks)
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto node = system.add_node (node_config, node_flags);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
nano::block_hash latest (node->latest (nano::dev_genesis_key.pub));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::block_hash latest (node->latest (nano::dev::genesis_key.pub));
nano::keypair key1;
nano::send_block send (latest, key1.pub, nano::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::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::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 transaction = node->store.tx_begin_write ();
@ -979,16 +979,16 @@ TEST (confirmation_height, callback_confirmed_history)
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto node = system.add_node (node_config, node_flags);
nano::block_hash latest (node->latest (nano::dev_genesis_key.pub));
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::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::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::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::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);
@ -1060,12 +1060,12 @@ TEST (confirmation_height, dependent_election)
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto node = system.add_node (node_config, node_flags);
nano::block_hash latest (node->latest (nano::dev_genesis_key.pub));
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::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::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::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::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 transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
@ -1110,29 +1110,29 @@ TEST (confirmation_height, cemented_gap_below_receive)
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto node = system.add_node (node_config, node_flags);
nano::block_hash latest (node->latest (nano::dev_genesis_key.pub));
nano::block_hash latest (node->latest (nano::dev::genesis_key.pub));
nano::keypair key1;
system.wallet (0)->insert_adhoc (key1.prv);
nano::send_block send (latest, key1.pub, nano::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::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::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::keypair dummy_key;
nano::send_block dummy_send (send1.hash (), dummy_key.pub, nano::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::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::genesis_account, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub));
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::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::genesis_amount - nano::Gxrb_ratio * 3, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (receive2.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::keypair key2;
system.wallet (0)->insert_adhoc (key2.prv);
nano::send_block send3 (dummy_send1.hash (), key2.pub, nano::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::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::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 ()));
auto open1 = std::make_shared<nano::open_block> (send3.hash (), nano::genesis_account, key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub));
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));
{
auto transaction = node->store.tx_begin_write ();
@ -1195,29 +1195,29 @@ TEST (confirmation_height, cemented_gap_below_no_cache)
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto node = system.add_node (node_config, node_flags);
nano::block_hash latest (node->latest (nano::dev_genesis_key.pub));
nano::block_hash latest (node->latest (nano::dev::genesis_key.pub));
nano::keypair key1;
system.wallet (0)->insert_adhoc (key1.prv);
nano::send_block send (latest, key1.pub, nano::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::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::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::keypair dummy_key;
nano::send_block dummy_send (send1.hash (), dummy_key.pub, nano::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::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::genesis_account, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub));
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::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::genesis_amount - nano::Gxrb_ratio * 3, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (receive2.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::keypair key2;
system.wallet (0)->insert_adhoc (key2.prv);
nano::send_block send3 (dummy_send1.hash (), key2.pub, nano::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::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::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 ()));
auto open1 = std::make_shared<nano::open_block> (send3.hash (), nano::genesis_account, key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub));
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));
{
auto transaction = node->store.tx_begin_write ();
@ -1241,7 +1241,7 @@ TEST (confirmation_height, cemented_gap_below_no_cache)
// Force some blocks to be cemented so that the cached confirmed info variable is empty
{
auto transaction (node->store.tx_begin_write ());
node->store.confirmation_height.put (transaction, nano::genesis_account, nano::confirmation_height_info{ 3, send1.hash () });
node->store.confirmation_height.put (transaction, nano::dev::genesis->account (), nano::confirmation_height_info{ 3, send1.hash () });
node->store.confirmation_height.put (transaction, key1.pub, nano::confirmation_height_info{ 2, receive1.hash () });
}
@ -1278,12 +1278,12 @@ TEST (confirmation_height, election_winner_details_clearing)
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto node = system.add_node (node_config, node_flags);
nano::block_hash latest (node->latest (nano::dev_genesis_key.pub));
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::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::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::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::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 transaction = node->store.tx_begin_write ();
@ -1344,7 +1344,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::genesis_hash, nano::dev_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash));
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 ()));
// 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;
@ -1372,8 +1372,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::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::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> (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 transaction (store->tx_begin_write ());
store->initialize (transaction, ledger.cache);
@ -1422,7 +1422,7 @@ TEST (confirmation_height, pruned_source)
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::genesis_amount - 100, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::genesis_hash));
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 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 ()));

14
nano/core_test/confirmation_solicitor.cpp
View file

@ -19,16 +19,16 @@ 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::genesis_amount, channel1);
nano::representative representative (nano::dev::genesis_key.pub, nano::dev::genesis_amount, channel1);
std::vector<nano::representative> representatives{ representative };
nano::confirmation_solicitor solicitor (node2.network, node2.config);
solicitor.prepare (representatives);
// Ensure the representatives are correct
ASSERT_EQ (1, representatives.size ());
ASSERT_EQ (channel1, representatives.front ().channel);
ASSERT_EQ (nano::dev_genesis_key.pub, representatives.front ().account);
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::genesis_hash, nano::keypair ().pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash)));
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 ())));
send->sideband_set ({});
{
nano::lock_guard<nano::mutex> guard (node2.active.mutex);
@ -63,16 +63,16 @@ 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::genesis_amount, channel1);
nano::representative representative (nano::dev::genesis_key.pub, nano::dev::genesis_amount, channel1);
std::vector<nano::representative> representatives{ representative };
nano::confirmation_solicitor solicitor (node2.network, node2.config);
solicitor.prepare (representatives);
// Ensure the representatives are correct
ASSERT_EQ (1, representatives.size ());
ASSERT_EQ (channel1, representatives.front ().channel);
ASSERT_EQ (nano::dev_genesis_key.pub, representatives.front ().account);
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::genesis_hash, nano::keypair ().pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash)));
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 ())));
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::genesis_hash, nano::keypair ().pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash)));
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 ())));
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

18
nano/core_test/conflicts.cpp
View file

@ -14,11 +14,11 @@ TEST (conflicts, start_stop)
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> (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 ());
node1.scheduler.activate (nano::dev_genesis_key.pub, node1.store.tx_begin_read ());
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
node1.scheduler.flush ();
auto election1 = node1.active.election (send1->qualified_root ());
ASSERT_EQ (1, node1.active.size ());
@ -32,14 +32,14 @@ TEST (conflicts, add_existing)
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> (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 ());
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> (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.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
node1.scheduler.flush ();
auto election1 = node1.active.election (send2->qualified_root ());
ASSERT_NE (nullptr, election1);
@ -57,16 +57,16 @@ TEST (conflicts, add_two)
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> (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);
node1.active.election (send1->qualified_root ())->force_confirm ();
nano::keypair key2;
auto send2 (std::make_shared<nano::send_block> (send1->hash (), key2.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0));
auto send2 (std::make_shared<nano::send_block> (send1->hash (), key2.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
node1.work_generate_blocking (*send2);
ASSERT_EQ (nano::process_result::progress, node1.process (*send2).code);
node1.scheduler.activate (nano::dev_genesis_key.pub, node1.store.tx_begin_read ());
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
node1.scheduler.flush ();
ASSERT_EQ (2, node1.active.size ());
}

86
nano/core_test/election.cpp
View file

@ -11,7 +11,7 @@ TEST (election, construction)
nano::system system (1);
nano::genesis genesis;
auto & node = *system.nodes[0];
genesis.open->sideband_set (nano::block_sideband (nano::genesis_account, 0, nano::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_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.scheduler.flush ();
auto election = node.active.election (genesis.open->qualified_root ());
@ -22,30 +22,30 @@ 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::genesis_amount;
node_config.online_weight_minimum = nano::dev::genesis_amount;
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto & node1 = *system.add_node (node_config);
nano::keypair key1;
nano::block_builder builder;
auto send1 = builder.state ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (node1.online_reps.delta ())
.link (key1.pub)
.work (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.build_shared ();
node1.work_generate_blocking (*send1);
nano::keypair key2;
auto send2 = builder.state ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (node1.online_reps.delta ())
.link (key2.pub)
.work (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.build_shared ();
node1.work_generate_blocking (*send2);
node1.process_active (send1);
@ -57,7 +57,7 @@ TEST (election, quorum_minimum_flip_success)
auto election = node1.active.election (send1->qualified_root ());
ASSERT_NE (nullptr, election);
ASSERT_EQ (2, election->blocks ().size ());
auto vote1 (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits<uint64_t>::max (), send2));
auto vote1 (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits<uint64_t>::max (), send2));
ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1));
node1.block_processor.flush ();
ASSERT_NE (nullptr, node1.block (send2->hash ()));
@ -68,30 +68,30 @@ 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::genesis_amount;
node_config.online_weight_minimum = nano::dev::genesis_amount;
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto & node1 = *system.add_node (node_config);
nano::keypair key1;
nano::block_builder builder;
auto send1 = builder.state ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (node1.online_reps.delta () - 1)
.link (key1.pub)
.work (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.build_shared ();
node1.work_generate_blocking (*send1);
nano::keypair key2;
auto send2 = builder.state ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (node1.online_reps.delta () - 1)
.link (key2.pub)
.work (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.build_shared ();
node1.work_generate_blocking (*send2);
node1.process_active (send1);
@ -103,7 +103,7 @@ TEST (election, quorum_minimum_flip_fail)
auto election = node1.active.election (send1->qualified_root ());
ASSERT_NE (nullptr, election);
ASSERT_EQ (2, election->blocks ().size ());
auto vote1 (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits<uint64_t>::max (), send2));
auto vote1 (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits<uint64_t>::max (), send2));
ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1));
node1.block_processor.flush ();
ASSERT_NE (nullptr, node1.block (send1->hash ()));
@ -114,29 +114,29 @@ 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::genesis_amount;
node_config.online_weight_minimum = nano::dev::genesis_amount;
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto & node1 = *system.add_node (node_config);
nano::keypair key1;
nano::block_builder builder;
auto send1 = builder.state ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (node1.online_reps.delta ())
.link (key1.pub)
.work (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.build_shared ();
node1.work_generate_blocking (*send1);
node1.process_active (send1);
node1.block_processor.flush ();
node1.scheduler.activate (nano::dev_genesis_key.pub, node1.store.tx_begin_read ());
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
node1.scheduler.flush ();
auto election = node1.active.election (send1->qualified_root ());
ASSERT_NE (nullptr, election);
ASSERT_EQ (1, election->blocks ().size ());
auto vote1 (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits<uint64_t>::max (), send1));
auto vote1 (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits<uint64_t>::max (), send1));
ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1));
node1.block_processor.flush ();
ASSERT_NE (nullptr, node1.block (send1->hash ()));
@ -147,29 +147,29 @@ 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::genesis_amount;
node_config.online_weight_minimum = nano::dev::genesis_amount;
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto & node1 = *system.add_node (node_config);
nano::keypair key1;
nano::block_builder builder;
auto send1 = builder.state ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (node1.online_reps.delta () - 1)
.link (key1.pub)
.work (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.build_shared ();
node1.work_generate_blocking (*send1);
node1.process_active (send1);
node1.block_processor.flush ();
node1.scheduler.activate (nano::dev_genesis_key.pub, node1.store.tx_begin_read ());
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
node1.scheduler.flush ();
auto election = node1.active.election (send1->qualified_root ());
ASSERT_NE (nullptr, election);
ASSERT_EQ (1, election->blocks ().size ());
auto vote1 (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits<uint64_t>::max (), send1));
auto vote1 (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits<uint64_t>::max (), send1));
ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1));
node1.block_processor.flush ();
ASSERT_NE (nullptr, node1.block (send1->hash ()));
@ -184,25 +184,25 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks)
nano::node_config node_config (nano::get_available_port (), system.logging);
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto & node1 = *system.add_node (node_config);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
auto amount = ((nano::uint256_t (node_config.online_weight_minimum.number ()) * nano::online_reps::online_weight_quorum) / 100).convert_to<nano::uint128_t> () - 1;
nano::keypair key1;
nano::block_builder builder;
auto send1 = builder.state ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (amount)
.link (key1.pub)
.work (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.build_shared ();
node1.work_generate_blocking (*send1);
auto open1 = builder.state ()
.account (key1.pub)
.previous (0)
.representative (key1.pub)
.balance (nano::genesis_amount - amount)
.balance (nano::dev::genesis_amount - amount)
.link (send1->hash ())
.work (0)
.sign (key1.prv, key1.pub)
@ -235,12 +235,12 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks)
node2.block_processor.flush ();
ASSERT_EQ (node2.ledger.cache.block_count, 4);
node1.scheduler.activate (nano::dev_genesis_key.pub, node1.store.tx_begin_read ());
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
node1.scheduler.flush ();
auto election = node1.active.election (send1->qualified_root ());
ASSERT_NE (nullptr, election);
ASSERT_EQ (1, election->blocks ().size ());
auto vote1 (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits<uint64_t>::max (), send1));
auto vote1 (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, std::numeric_limits<uint64_t>::max (), send1));
ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1));
auto vote2 (std::make_shared<nano::vote> (key1.pub, key1.prv, std::numeric_limits<uint64_t>::max (), send1));
auto channel = node1.network.find_channel (node2.network.endpoint ());

70
nano/core_test/election_scheduler.cpp
View file

@ -18,16 +18,16 @@ TEST (election_scheduler, activate_one_timely)
nano::system system{ 1 };
nano::state_block_builder builder;
auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.balance (nano::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::genesis_hash))
.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)
.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 ()))
.build_shared ();
system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), *send1);
system.nodes[0]->scheduler.activate (nano::dev_genesis_key.pub, system.nodes[0]->store.tx_begin_read ());
system.nodes[0]->scheduler.activate (nano::dev::genesis_key.pub, system.nodes[0]->store.tx_begin_read ());
ASSERT_TIMELY (1s, system.nodes[0]->active.election (send1->qualified_root ()));
}
@ -36,16 +36,16 @@ TEST (election_scheduler, activate_one_flush)
nano::system system{ 1 };
nano::state_block_builder builder;
auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.balance (nano::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::genesis_hash))
.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)
.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 ()))
.build_shared ();
system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), *send1);
system.nodes[0]->scheduler.activate (nano::dev_genesis_key.pub, system.nodes[0]->store.tx_begin_read ());
system.nodes[0]->scheduler.activate (nano::dev::genesis_key.pub, system.nodes[0]->store.tx_begin_read ());
system.nodes[0]->scheduler.flush ();
ASSERT_NE (nullptr, system.nodes[0]->active.election (send1->qualified_root ()));
}
@ -61,13 +61,13 @@ TEST (election_scheduler, no_vacancy)
// Activating accounts depends on confirmed dependencies. First, prepare 2 accounts
auto send = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.link (key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.balance (nano::dev::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 ();
auto receive = builder.make_block ()
.account (key.pub)
@ -87,12 +87,12 @@ TEST (election_scheduler, no_vacancy)
// Second, process two eligble transactions
auto block0 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (send->hash ())
.representative (nano::dev_genesis_key.pub)
.link (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.link (nano::dev::genesis_key.pub)
.balance (nano::dev::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 ();
auto block1 = builder.make_block ()
@ -106,7 +106,7 @@ TEST (election_scheduler, no_vacancy)
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*block0).code);
ASSERT_EQ (nano::process_result::progress, node.process (*block1).code);
node.scheduler.activate (nano::dev_genesis_key.pub, node.store.tx_begin_read ());
node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
// There is vacancy so it should be inserted
ASSERT_TIMELY (1s, node.active.size () == 1);
node.scheduler.activate (key.pub, node.store.tx_begin_read ());
@ -134,16 +134,16 @@ TEST (election_scheduler, flush_vacancy)
nano::keypair key;
auto send = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.link (key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.balance (nano::dev::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 ();
ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
node.scheduler.activate (nano::dev_genesis_key.pub, node.store.tx_begin_read ());
node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
// Ensure this call does not block, even though no elections can be activated.
node.scheduler.flush ();
ASSERT_EQ (0, node.active.size ());

72
nano/core_test/frontiers_confirmation.cpp
View file

@ -20,29 +20,29 @@ TEST (frontiers_confirmation, prioritize_frontiers)
nano::keypair key2;
nano::keypair key3;
nano::keypair key4;
nano::block_hash latest1 (node->latest (nano::dev_genesis_key.pub));
nano::block_hash latest1 (node->latest (nano::dev::genesis_key.pub));
// Send different numbers of blocks all accounts
nano::send_block send1 (latest1, key1.pub, node->config.online_weight_minimum.number () + 10000, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest1));
nano::send_block send2 (send1.hash (), key1.pub, node->config.online_weight_minimum.number () + 8500, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1.hash ()));
nano::send_block send3 (send2.hash (), key1.pub, node->config.online_weight_minimum.number () + 8000, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send2.hash ()));
nano::send_block send4 (send3.hash (), key2.pub, node->config.online_weight_minimum.number () + 7500, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send3.hash ()));
nano::send_block send5 (send4.hash (), key3.pub, node->config.online_weight_minimum.number () + 6500, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send4.hash ()));
nano::send_block send6 (send5.hash (), key4.pub, node->config.online_weight_minimum.number () + 6000, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send5.hash ()));
nano::send_block send1 (latest1, key1.pub, node->config.online_weight_minimum.number () + 10000, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest1));
nano::send_block send2 (send1.hash (), key1.pub, node->config.online_weight_minimum.number () + 8500, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ()));
nano::send_block send3 (send2.hash (), key1.pub, node->config.online_weight_minimum.number () + 8000, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2.hash ()));
nano::send_block send4 (send3.hash (), key2.pub, node->config.online_weight_minimum.number () + 7500, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send3.hash ()));
nano::send_block send5 (send4.hash (), key3.pub, node->config.online_weight_minimum.number () + 6500, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send4.hash ()));
nano::send_block send6 (send5.hash (), key4.pub, node->config.online_weight_minimum.number () + 6000, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send5.hash ()));
// Open all accounts and add other sends to get different uncemented counts (as well as some which are the same)
nano::open_block open1 (send1.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub));
nano::send_block send7 (open1.hash (), nano::dev_genesis_key.pub, 500, key1.prv, key1.pub, *system.work.generate (open1.hash ()));
nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub));
nano::send_block send7 (open1.hash (), nano::dev::genesis_key.pub, 500, key1.prv, key1.pub, *system.work.generate (open1.hash ()));
nano::open_block open2 (send4.hash (), nano::genesis_account, key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub));
nano::open_block open2 (send4.hash (), nano::dev::genesis->account (), key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub));
nano::open_block open3 (send5.hash (), nano::genesis_account, key3.pub, key3.prv, key3.pub, *system.work.generate (key3.pub));
nano::send_block send8 (open3.hash (), nano::dev_genesis_key.pub, 500, key3.prv, key3.pub, *system.work.generate (open3.hash ()));
nano::send_block send9 (send8.hash (), nano::dev_genesis_key.pub, 200, key3.prv, key3.pub, *system.work.generate (send8.hash ()));
nano::open_block open3 (send5.hash (), nano::dev::genesis->account (), key3.pub, key3.prv, key3.pub, *system.work.generate (key3.pub));
nano::send_block send8 (open3.hash (), nano::dev::genesis_key.pub, 500, key3.prv, key3.pub, *system.work.generate (open3.hash ()));
nano::send_block send9 (send8.hash (), nano::dev::genesis_key.pub, 200, key3.prv, key3.pub, *system.work.generate (send8.hash ()));
nano::open_block open4 (send6.hash (), nano::genesis_account, key4.pub, key4.prv, key4.pub, *system.work.generate (key4.pub));
nano::send_block send10 (open4.hash (), nano::dev_genesis_key.pub, 500, key4.prv, key4.pub, *system.work.generate (open4.hash ()));
nano::send_block send11 (send10.hash (), nano::dev_genesis_key.pub, 200, key4.prv, key4.pub, *system.work.generate (send10.hash ()));
nano::open_block open4 (send6.hash (), nano::dev::genesis->account (), key4.pub, key4.prv, key4.pub, *system.work.generate (key4.pub));
nano::send_block send10 (open4.hash (), nano::dev::genesis_key.pub, 500, key4.prv, key4.pub, *system.work.generate (open4.hash ()));
nano::send_block send11 (send10.hash (), nano::dev::genesis_key.pub, 200, key4.prv, key4.pub, *system.work.generate (send10.hash ()));
{
auto transaction = node->store.tx_begin_write ();
@ -78,20 +78,20 @@ TEST (frontiers_confirmation, prioritize_frontiers)
node->active.prioritize_frontiers_for_confirmation (transaction, std::chrono::seconds (1), std::chrono::seconds (1));
ASSERT_EQ (node->active.priority_cementable_frontiers_size (), num_accounts);
// Check the order of accounts is as expected (greatest number of uncemented blocks at the front). key3 and key4 have the same value, the order is unspecified so check both
std::array<nano::account, num_accounts> desired_order_1{ nano::genesis_account, key3.pub, key4.pub, key1.pub, key2.pub };
std::array<nano::account, num_accounts> desired_order_2{ nano::genesis_account, key4.pub, key3.pub, key1.pub, key2.pub };
std::array<nano::account, num_accounts> desired_order_1{ nano::dev::genesis->account (), key3.pub, key4.pub, key1.pub, key2.pub };
std::array<nano::account, num_accounts> desired_order_2{ nano::dev::genesis->account (), key4.pub, key3.pub, key1.pub, key2.pub };
ASSERT_TRUE (priority_orders_match (node->active.priority_cementable_frontiers, desired_order_1) || priority_orders_match (node->active.priority_cementable_frontiers, desired_order_2));
}
{
// Add some to the local node wallets and check ordering of both containers
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
system.wallet (0)->insert_adhoc (key1.prv);
system.wallet (0)->insert_adhoc (key2.prv);
node->active.prioritize_frontiers_for_confirmation (transaction, std::chrono::seconds (1), std::chrono::seconds (1));
ASSERT_EQ (node->active.priority_cementable_frontiers_size (), num_accounts - 3);
ASSERT_EQ (node->active.priority_wallet_cementable_frontiers_size (), num_accounts - 2);
std::array<nano::account, 3> local_desired_order{ nano::genesis_account, key1.pub, key2.pub };
std::array<nano::account, 3> local_desired_order{ nano::dev::genesis->account (), key1.pub, key2.pub };
ASSERT_TRUE (priority_orders_match (node->active.priority_wallet_cementable_frontiers, local_desired_order));
std::array<nano::account, 2> desired_order_1{ key3.pub, key4.pub };
std::array<nano::account, 2> desired_order_2{ key4.pub, key3.pub };
@ -105,18 +105,18 @@ TEST (frontiers_confirmation, prioritize_frontiers)
node->active.prioritize_frontiers_for_confirmation (transaction, std::chrono::seconds (1), std::chrono::seconds (1));
ASSERT_EQ (node->active.priority_cementable_frontiers_size (), 0);
ASSERT_EQ (node->active.priority_wallet_cementable_frontiers_size (), num_accounts);
std::array<nano::account, num_accounts> desired_order_1{ nano::genesis_account, key3.pub, key4.pub, key1.pub, key2.pub };
std::array<nano::account, num_accounts> desired_order_2{ nano::genesis_account, key4.pub, key3.pub, key1.pub, key2.pub };
std::array<nano::account, num_accounts> desired_order_1{ nano::dev::genesis->account (), key3.pub, key4.pub, key1.pub, key2.pub };
std::array<nano::account, num_accounts> desired_order_2{ nano::dev::genesis->account (), key4.pub, key3.pub, key1.pub, key2.pub };
ASSERT_TRUE (priority_orders_match (node->active.priority_wallet_cementable_frontiers, desired_order_1) || priority_orders_match (node->active.priority_wallet_cementable_frontiers, desired_order_2));
}
// Check that accounts which already exist have their order modified when the uncemented count changes.
nano::send_block send12 (send9.hash (), nano::dev_genesis_key.pub, 100, key3.prv, key3.pub, *system.work.generate (send9.hash ()));
nano::send_block send13 (send12.hash (), nano::dev_genesis_key.pub, 90, key3.prv, key3.pub, *system.work.generate (send12.hash ()));
nano::send_block send14 (send13.hash (), nano::dev_genesis_key.pub, 80, key3.prv, key3.pub, *system.work.generate (send13.hash ()));
nano::send_block send15 (send14.hash (), nano::dev_genesis_key.pub, 70, key3.prv, key3.pub, *system.work.generate (send14.hash ()));
nano::send_block send16 (send15.hash (), nano::dev_genesis_key.pub, 60, key3.prv, key3.pub, *system.work.generate (send15.hash ()));
nano::send_block send17 (send16.hash (), nano::dev_genesis_key.pub, 50, key3.prv, key3.pub, *system.work.generate (send16.hash ()));
nano::send_block send12 (send9.hash (), nano::dev::genesis_key.pub, 100, key3.prv, key3.pub, *system.work.generate (send9.hash ()));
nano::send_block send13 (send12.hash (), nano::dev::genesis_key.pub, 90, key3.prv, key3.pub, *system.work.generate (send12.hash ()));
nano::send_block send14 (send13.hash (), nano::dev::genesis_key.pub, 80, key3.prv, key3.pub, *system.work.generate (send13.hash ()));
nano::send_block send15 (send14.hash (), nano::dev::genesis_key.pub, 70, key3.prv, key3.pub, *system.work.generate (send14.hash ()));
nano::send_block send16 (send15.hash (), nano::dev::genesis_key.pub, 60, key3.prv, key3.pub, *system.work.generate (send15.hash ()));
nano::send_block send17 (send16.hash (), nano::dev::genesis_key.pub, 50, key3.prv, key3.pub, *system.work.generate (send16.hash ()));
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send12).code);
@ -128,7 +128,7 @@ TEST (frontiers_confirmation, prioritize_frontiers)
}
transaction.refresh ();
node->active.prioritize_frontiers_for_confirmation (transaction, std::chrono::seconds (1), std::chrono::seconds (1));
ASSERT_TRUE (priority_orders_match (node->active.priority_wallet_cementable_frontiers, std::array<nano::account, num_accounts>{ key3.pub, nano::genesis_account, key4.pub, key1.pub, key2.pub }));
ASSERT_TRUE (priority_orders_match (node->active.priority_wallet_cementable_frontiers, std::array<nano::account, num_accounts>{ key3.pub, nano::dev::genesis->account (), key4.pub, key1.pub, key2.pub }));
uint64_t election_count = 0;
node->active.confirm_prioritized_frontiers (transaction, 100, election_count);
@ -159,11 +159,11 @@ TEST (frontiers_confirmation, prioritize_frontiers_max_optimistic_elections)
for (auto i = 0; i < max_optimistic_election_count * 2; ++i)
{
auto transaction = node->store.tx_begin_write ();
auto latest = node->latest (nano::genesis_account);
auto latest = node->latest (nano::dev::genesis->account ());
nano::keypair key;
nano::send_block send (latest, key.pub, node->config.online_weight_minimum.number () + 10000, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest));
nano::send_block send (latest, key.pub, node->config.online_weight_minimum.number () + 10000, 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);
nano::open_block open (send.hash (), nano::genesis_account, key.pub, key.prv, key.pub, *system.work.generate (key.pub));
nano::open_block open (send.hash (), nano::dev::genesis->account (), key.pub, key.prv, key.pub, *system.work.generate (key.pub));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open).code);
}
@ -219,7 +219,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::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, 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 ()));
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
@ -232,7 +232,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::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, 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 ()));
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
@ -245,12 +245,12 @@ 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::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, 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 ()));
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
}
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
std::this_thread::sleep_for (std::chrono::seconds (1));
ASSERT_EQ (0, node->active.size ());
}

22
nano/core_test/gap_cache.cpp
View file

@ -65,12 +65,12 @@ TEST (gap_cache, gap_bootstrap)
auto & node1 (*system.nodes[0]);
auto & node2 (*system.nodes[1]);
nano::block_hash latest (node1.latest (nano::dev_genesis_key.pub));
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::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::genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)));
node1.process (*send);
ASSERT_EQ (nano::genesis_amount - 100, node1.balance (nano::genesis_account));
ASSERT_EQ (nano::genesis_amount, node2.balance (nano::genesis_account));
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 ()));
// Confirm send block, allowing voting on the upcoming block
node1.block_confirm (send);
auto election = node1.active.election (send->qualified_root ());
@ -78,12 +78,12 @@ TEST (gap_cache, gap_bootstrap)
election->force_confirm ();
ASSERT_TIMELY (2s, node1.block_confirmed (send->hash ()));
node1.active.erase (*send);
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));
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::genesis_amount - 200, node1.balance (nano::genesis_account));
ASSERT_EQ (nano::genesis_amount, node2.balance (nano::genesis_account));
ASSERT_TIMELY (10s, node2.balance (nano::genesis_account) == nano::genesis_amount - 200);
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);
}
TEST (gap_cache, two_dependencies)
@ -92,8 +92,8 @@ TEST (gap_cache, two_dependencies)
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 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 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 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 ());
node1.block_processor.add (send2, nano::seconds_since_epoch ());

1068
nano/core_test/ledger.cpp
View file

File diff suppressed because it is too large Load diff

26
nano/core_test/ledger_walker.cpp
View file

@ -19,19 +19,19 @@ TEST (ledger_walker, genesis_block)
nano::ledger_walker ledger_walker{ node->ledger };
std::size_t walked_blocks_count = 0;
ledger_walker.walk_backward (nano::genesis_hash,
ledger_walker.walk_backward (nano::dev::genesis->hash (),
[&] (const auto & block) {
++walked_blocks_count;
EXPECT_EQ (block->hash (), nano::genesis_hash);
EXPECT_EQ (block->hash (), nano::dev::genesis->hash ());
});
EXPECT_EQ (walked_blocks_count, 1);
walked_blocks_count = 0;
ledger_walker.walk (nano::genesis_hash,
ledger_walker.walk (nano::dev::genesis->hash (),
[&] (const auto & block) {
++walked_blocks_count;
EXPECT_EQ (block->hash (), nano::genesis_hash);
EXPECT_EQ (block->hash (), nano::dev::genesis->hash ());
});
EXPECT_EQ (walked_blocks_count, 1);
@ -65,18 +65,18 @@ TEST (ledger_walker, genesis_account_longer)
const auto transaction = node->ledger.store.tx_begin_read ();
nano::account_info genesis_account_info{};
ASSERT_FALSE (node->ledger.store.account.get (transaction, nano::nano_dev_account, genesis_account_info));
ASSERT_FALSE (node->ledger.store.account.get (transaction, nano::dev::genesis_key.pub, genesis_account_info));
EXPECT_EQ (get_number_of_walked_blocks (genesis_account_info.open_block), 1);
EXPECT_EQ (get_number_of_walked_blocks (genesis_account_info.head), 1);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
for (auto itr = 1; itr <= 5; ++itr)
{
const auto send = system.wallet (0)->send_action (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub, 1);
const auto send = system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, 1);
ASSERT_TRUE (send);
EXPECT_EQ (get_number_of_walked_blocks (send->hash ()), 1 + itr * 2 - 1);
ASSERT_TIMELY (3s, 1 + itr * 2 == node->ledger.cache.cemented_count);
ASSERT_FALSE (node->ledger.store.account.get (transaction, nano::nano_dev_account, genesis_account_info));
ASSERT_FALSE (node->ledger.store.account.get (transaction, nano::dev::genesis_key.pub, genesis_account_info));
// TODO: check issue with account head
// EXPECT_EQ(get_number_of_walked_blocks (genesis_account_info.head), 1 + itr * 2);
}
@ -97,13 +97,13 @@ TEST (ledger_walker, cross_account)
const auto node = system.add_node (node_config);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
ASSERT_TRUE (system.wallet (0)->send_action (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub, 1));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
ASSERT_TRUE (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, 1));
ASSERT_TIMELY (3s, 3 == node->ledger.cache.cemented_count);
nano::keypair key{};
system.wallet (0)->insert_adhoc (key.prv);
ASSERT_TRUE (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, 1));
ASSERT_TRUE (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, 1));
ASSERT_TIMELY (3s, 5 == node->ledger.cache.cemented_count);
const auto transaction = node->ledger.store.tx_begin_read ();
@ -146,11 +146,11 @@ TEST (ledger_walker, ladder_geometry)
const auto node = system.add_node (node_config);
std::array<nano::keypair, 3> keys{};
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
for (auto itr = 0; itr != keys.size (); ++itr)
{
system.wallet (0)->insert_adhoc (keys[itr].prv);
const auto block = system.wallet (0)->send_action (nano::dev_genesis_key.pub, keys[itr].pub, 1000);
const auto block = system.wallet (0)->send_action (nano::dev::genesis_key.pub, keys[itr].pub, 1000);
ASSERT_TIMELY (3s, 1 + (itr + 1) * 2 == node->ledger.cache.cemented_count);
}

84
nano/core_test/network.cpp
View file

@ -209,13 +209,13 @@ TEST (network, send_discarded_publish)
{
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 (genesis.hash (), node1.ledger.latest (transaction, nano::dev::genesis_key.pub));
ASSERT_EQ (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 (genesis.hash (), node1.ledger.latest (transaction, nano::dev::genesis_key.pub));
ASSERT_EQ (genesis.hash (), node2.latest (nano::dev::genesis_key.pub));
}
TEST (network, send_invalid_publish)
@ -224,17 +224,17 @@ TEST (network, send_invalid_publish)
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 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 (genesis.hash (), node1.ledger.latest (transaction, nano::dev::genesis_key.pub));
ASSERT_EQ (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 (genesis.hash (), node1.ledger.latest (transaction, nano::dev::genesis_key.pub));
ASSERT_EQ (genesis.hash (), node2.latest (nano::dev::genesis_key.pub));
}
TEST (network, send_valid_confirm_ack)
@ -253,16 +253,16 @@ TEST (network, send_valid_confirm_ack)
auto & node1 (*system.nodes[0]);
auto & node2 (*system.nodes[1]);
nano::keypair key2;
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
system.wallet (1)->insert_adhoc (key2.prv);
nano::block_hash latest1 (node1.latest (nano::dev_genesis_key.pub));
nano::send_block block2 (latest1, key2.pub, 50, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest1));
nano::block_hash latest2 (node2.latest (nano::dev_genesis_key.pub));
nano::block_hash latest1 (node1.latest (nano::dev::genesis_key.pub));
nano::send_block block2 (latest1, key2.pub, 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest1));
nano::block_hash latest2 (node2.latest (nano::dev::genesis_key.pub));
node1.process_active (std::make_shared<nano::send_block> (block2));
// Keep polling until latest block changes
ASSERT_TIMELY (10s, node2.latest (nano::dev_genesis_key.pub) != latest2);
ASSERT_TIMELY (10s, node2.latest (nano::dev::genesis_key.pub) != latest2);
// Make sure the balance has decreased after processing the block.
ASSERT_EQ (50, node2.balance (nano::dev_genesis_key.pub));
ASSERT_EQ (50, node2.balance (nano::dev::genesis_key.pub));
}
}
@ -283,18 +283,18 @@ TEST (network, send_valid_publish)
auto & node2 (*system.nodes[1]);
node1.bootstrap_initiator.stop ();
node2.bootstrap_initiator.stop ();
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::keypair key2;
system.wallet (1)->insert_adhoc (key2.prv);
nano::block_hash latest1 (node1.latest (nano::dev_genesis_key.pub));
nano::send_block block2 (latest1, key2.pub, 50, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest1));
nano::block_hash latest1 (node1.latest (nano::dev::genesis_key.pub));
nano::send_block block2 (latest1, key2.pub, 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest1));
auto hash2 (block2.hash ());
nano::block_hash latest2 (node2.latest (nano::dev_genesis_key.pub));
nano::block_hash latest2 (node2.latest (nano::dev::genesis_key.pub));
node2.process_active (std::make_shared<nano::send_block> (block2));
ASSERT_TIMELY (10s, node1.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0);
ASSERT_NE (hash2, latest2);
ASSERT_TIMELY (10s, node2.latest (nano::dev_genesis_key.pub) != latest2);
ASSERT_EQ (50, node2.balance (nano::dev_genesis_key.pub));
ASSERT_TIMELY (10s, node2.latest (nano::dev::genesis_key.pub) != latest2);
ASSERT_EQ (50, node2.balance (nano::dev::genesis_key.pub));
}
}
@ -305,7 +305,7 @@ TEST (network, send_insufficient_work_udp)
node_flags.disable_udp = false;
auto & node1 = *system.add_node (node_flags);
auto & node2 = *system.add_node (node_flags);
auto block (std::make_shared<nano::send_block> (0, 1, 20, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0));
auto block (std::make_shared<nano::send_block> (0, 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
nano::publish publish (block);
nano::transport::channel_udp channel (node1.network.udp_channels, node2.network.endpoint (), node1.network_params.protocol.protocol_version);
channel.send (publish, [] (boost::system::error_code const & ec, size_t size) {});
@ -320,7 +320,7 @@ TEST (network, send_insufficient_work)
auto & node1 = *system.nodes[0];
auto & node2 = *system.nodes[1];
// Block zero work
auto block1 (std::make_shared<nano::send_block> (0, 1, 20, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0));
auto block1 (std::make_shared<nano::send_block> (0, 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
nano::publish publish1 (block1);
auto tcp_channel (node1.network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node2.network.endpoint ())));
tcp_channel->send (publish1, [] (boost::system::error_code const & ec, size_t size) {});
@ -328,20 +328,20 @@ TEST (network, send_insufficient_work)
ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work) != 0);
ASSERT_EQ (1, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work));
// Legacy block work between epoch_2_recieve & epoch_1
auto block2 (std::make_shared<nano::send_block> (block1->hash (), 1, 20, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.network.publish_thresholds.epoch_2_receive, node1.network_params.network.publish_thresholds.epoch_1 - 1)));
auto block2 (std::make_shared<nano::send_block> (block1->hash (), 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.network.publish_thresholds.epoch_2_receive, node1.network_params.network.publish_thresholds.epoch_1 - 1)));
nano::publish publish2 (block2);
tcp_channel->send (publish2, [] (boost::system::error_code const & ec, size_t size) {});
ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work) != 1);
ASSERT_EQ (2, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work));
// Legacy block work epoch_1
auto block3 (std::make_shared<nano::send_block> (block2->hash (), 1, 20, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (block2->hash (), node1.network_params.network.publish_thresholds.epoch_2)));
auto block3 (std::make_shared<nano::send_block> (block2->hash (), 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (block2->hash (), node1.network_params.network.publish_thresholds.epoch_2)));
nano::publish publish3 (block3);
tcp_channel->send (publish3, [] (boost::system::error_code const & ec, size_t size) {});
ASSERT_EQ (0, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in));
ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0);
ASSERT_EQ (1, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in));
// State block work epoch_2_recieve
auto block4 (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, block1->hash (), nano::dev_genesis_key.pub, 20, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.network.publish_thresholds.epoch_2_receive, node1.network_params.network.publish_thresholds.epoch_1 - 1)));
auto block4 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, block1->hash (), nano::dev::genesis_key.pub, 20, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.network.publish_thresholds.epoch_2_receive, node1.network_params.network.publish_thresholds.epoch_1 - 1)));
nano::publish publish4 (block4);
tcp_channel->send (publish4, [] (boost::system::error_code const & ec, size_t size) {});
ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0);
@ -354,10 +354,10 @@ 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> (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 ());
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
nano::keypair key1;
auto vote (std::make_shared<nano::vote> (key1.pub, key1.prv, 0, block1));
nano::confirm_ack con1 (vote);
@ -369,11 +369,11 @@ 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> (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 ());
auto vote (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, block1));
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
auto vote (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, block1));
nano::confirm_ack con1 (vote);
node1.network.inbound (con1, node1.network.udp_channels.create (node1.network.endpoint ()));
}
@ -395,26 +395,26 @@ TEST (receivable_processor, send_with_receive)
auto & node2 (*system.nodes[1]);
auto amount (std::numeric_limits<nano::uint128_t>::max ());
nano::keypair key2;
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
nano::block_hash latest1 (node1.latest (nano::dev_genesis_key.pub));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::block_hash latest1 (node1.latest (nano::dev::genesis_key.pub));
system.wallet (1)->insert_adhoc (key2.prv);
auto block1 (std::make_shared<nano::send_block> (latest1, key2.pub, amount - node1.config.receive_minimum.number (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest1)));
ASSERT_EQ (amount, node1.balance (nano::dev_genesis_key.pub));
auto block1 (std::make_shared<nano::send_block> (latest1, key2.pub, amount - node1.config.receive_minimum.number (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest1)));
ASSERT_EQ (amount, node1.balance (nano::dev::genesis_key.pub));
ASSERT_EQ (0, node1.balance (key2.pub));
ASSERT_EQ (amount, node2.balance (nano::dev_genesis_key.pub));
ASSERT_EQ (amount, node2.balance (nano::dev::genesis_key.pub));
ASSERT_EQ (0, node2.balance (key2.pub));
node1.process_active (block1);
node1.block_processor.flush ();
node2.process_active (block1);
node2.block_processor.flush ();
ASSERT_EQ (amount - node1.config.receive_minimum.number (), node1.balance (nano::dev_genesis_key.pub));
ASSERT_EQ (amount - node1.config.receive_minimum.number (), node1.balance (nano::dev::genesis_key.pub));
ASSERT_EQ (0, node1.balance (key2.pub));
ASSERT_EQ (amount - node1.config.receive_minimum.number (), node2.balance (nano::dev_genesis_key.pub));
ASSERT_EQ (amount - node1.config.receive_minimum.number (), node2.balance (nano::dev::genesis_key.pub));
ASSERT_EQ (0, node2.balance (key2.pub));
ASSERT_TIMELY (10s, node1.balance (key2.pub) == node1.config.receive_minimum.number () && node2.balance (key2.pub) == node1.config.receive_minimum.number ());
ASSERT_EQ (amount - node1.config.receive_minimum.number (), node1.balance (nano::dev_genesis_key.pub));
ASSERT_EQ (amount - node1.config.receive_minimum.number (), node1.balance (nano::dev::genesis_key.pub));
ASSERT_EQ (node1.config.receive_minimum.number (), node1.balance (key2.pub));
ASSERT_EQ (amount - node1.config.receive_minimum.number (), node2.balance (nano::dev_genesis_key.pub));
ASSERT_EQ (amount - node1.config.receive_minimum.number (), node2.balance (nano::dev::genesis_key.pub));
ASSERT_EQ (node1.config.receive_minimum.number (), node2.balance (key2.pub));
}
}
@ -422,14 +422,14 @@ TEST (receivable_processor, send_with_receive)
TEST (network, receive_weight_change)
{
nano::system system (2);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::keypair key2;
system.wallet (1)->insert_adhoc (key2.prv);
{
auto transaction (system.nodes[1]->wallets.tx_begin_write ());
system.wallet (1)->store.representative_set (transaction, key2.pub);
}
ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ()));
ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ()));
ASSERT_TIMELY (10s, std::all_of (system.nodes.begin (), system.nodes.end (), [&] (std::shared_ptr<nano::node> const & node_a) { return node_a->weight (key2.pub) == system.nodes[0]->config.receive_minimum.number (); }));
}

16
nano/core_test/network_filter.cpp
View file

@ -39,12 +39,12 @@ TEST (network_filter, unit)
}
nano::state_block_builder builder;
auto new_block = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.open->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 10 * nano::xrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - 10 * nano::xrb_ratio)
.link (nano::public_key ())
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
@ -69,12 +69,12 @@ TEST (network_filter, many)
{
nano::state_block_builder builder;
auto block = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.open->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - i * 10 * nano::xrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - i * 10 * nano::xrb_ratio)
.link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();

972
nano/core_test/node.cpp
View file

File diff suppressed because it is too large Load diff

12
nano/core_test/processor_service.cpp
View file

@ -19,9 +19,9 @@ TEST (processor_service, bad_send_signature)
store->initialize (transaction, ledger.cache);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::account_info info1;
ASSERT_FALSE (store->account.get (transaction, nano::dev_genesis_key.pub, info1));
ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info1));
nano::keypair key2;
nano::send_block send (info1.head, nano::dev_genesis_key.pub, 50, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (info1.head));
nano::send_block send (info1.head, nano::dev::genesis_key.pub, 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (info1.head));
send.signature.bytes[32] ^= 0x1;
ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, send).code);
}
@ -38,13 +38,13 @@ TEST (processor_service, bad_receive_signature)
store->initialize (transaction, ledger.cache);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::account_info info1;
ASSERT_FALSE (store->account.get (transaction, nano::dev_genesis_key.pub, info1));
nano::send_block send (info1.head, nano::dev_genesis_key.pub, 50, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (info1.head));
ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info1));
nano::send_block send (info1.head, nano::dev::genesis_key.pub, 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (info1.head));
nano::block_hash hash1 (send.hash ());
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code);
nano::account_info info2;
ASSERT_FALSE (store->account.get (transaction, nano::dev_genesis_key.pub, info2));
nano::receive_block receive (hash1, hash1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (hash1));
ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info2));
nano::receive_block receive (hash1, hash1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (hash1));
receive.signature.bytes[32] ^= 0x1;
ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, receive).code);
}

100
nano/core_test/request_aggregator.cpp
View file

@ -14,8 +14,8 @@ TEST (request_aggregator, one)
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::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 ())));
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 ())));
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 ()));
@ -50,35 +50,35 @@ TEST (request_aggregator, one_update)
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);
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)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.link (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::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)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (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);
ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ()));
auto send2 = nano::state_block_builder ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (send1->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
.link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::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 ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code);
auto receive1 = nano::state_block_builder ()
.account (key1.pub)
.previous (0)
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (nano::Gxrb_ratio)
.link (send1->hash ())
.sign (key1.prv, key1.pub)
@ -116,34 +116,34 @@ TEST (request_aggregator, two)
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);
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)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 1)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - 1)
.link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (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);
ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ()));
auto send2 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (send1->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 2)
.link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::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 ()))
.build_shared ();
auto receive1 = builder.make_block ()
.account (key1.pub)
.previous (0)
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (1)
.link (send1->hash ())
.sign (key1.prv, key1.pub)
@ -193,8 +193,8 @@ TEST (request_aggregator, two_endpoints)
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::genesis_amount - 1, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (genesis.hash ())));
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 ())));
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);
@ -225,7 +225,7 @@ TEST (request_aggregator, split)
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);
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 ();
@ -235,12 +235,12 @@ TEST (request_aggregator, split)
nano::block_builder builder;
blocks.push_back (builder
.state ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (previous)
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - (i + 1))
.link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::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))
.build ());
auto const & block = blocks.back ();
@ -279,8 +279,8 @@ TEST (request_aggregator, channel_lifetime)
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::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 ())));
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 ())));
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 ());
@ -300,8 +300,8 @@ TEST (request_aggregator, channel_update)
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::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 ())));
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 ())));
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 ());
@ -329,8 +329,8 @@ TEST (request_aggregator, channel_max_queue)
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::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 ())));
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 ())));
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 ());
@ -347,8 +347,8 @@ TEST (request_aggregator, unique)
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::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 ())));
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 ())));
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 ());
@ -374,24 +374,24 @@ TEST (request_aggregator, cannot_vote)
nano::genesis genesis;
nano::state_block_builder builder;
auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.balance (nano::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::genesis_hash))
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::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 ()))
.build_shared ();
auto send2 = builder.make_block ()
.from (*send1)
.previous (send1->hash ())
.balance (send1->balance ().number () - 1)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*send1).code);
ASSERT_EQ (nano::process_result::progress, node.process (*send2).code);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
ASSERT_FALSE (node.ledger.dependents_confirmed (node.store.tx_begin_read (), *send2));
std::vector<std::pair<nano::block_hash, nano::root>> request;

56
nano/core_test/system.cpp
View file

@ -29,7 +29,7 @@ TEST (system, system_genesis)
for (auto & i : system.nodes)
{
auto transaction (i->store.tx_begin_read ());
ASSERT_EQ (nano::genesis_amount, i->ledger.account_balance (transaction, nano::genesis_account));
ASSERT_EQ (nano::dev::genesis_amount, i->ledger.account_balance (transaction, nano::dev::genesis->account ()));
}
}
@ -38,29 +38,29 @@ TEST (system, DISABLED_generate_send_existing)
nano::system system (1);
auto & node1 (*system.nodes[0]);
nano::thread_runner runner (system.io_ctx, node1.config.io_threads);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::keypair stake_preserver;
auto send_block (system.wallet (0)->send_action (nano::genesis_account, stake_preserver.pub, nano::genesis_amount / 3 * 2, true));
auto send_block (system.wallet (0)->send_action (nano::dev::genesis->account (), stake_preserver.pub, nano::dev::genesis_amount / 3 * 2, true));
nano::account_info info1;
{
auto transaction (node1.store.tx_begin_read ());
ASSERT_FALSE (node1.store.account.get (transaction, nano::dev_genesis_key.pub, info1));
ASSERT_FALSE (node1.store.account.get (transaction, nano::dev::genesis_key.pub, info1));
}
std::vector<nano::account> accounts;
accounts.push_back (nano::dev_genesis_key.pub);
accounts.push_back (nano::dev::genesis_key.pub);
system.generate_send_existing (node1, accounts);
// Have stake_preserver receive funds after generate_send_existing so it isn't chosen as the destination
{
auto transaction (node1.store.tx_begin_write ());
auto open_block (std::make_shared<nano::open_block> (send_block->hash (), nano::genesis_account, stake_preserver.pub, stake_preserver.prv, stake_preserver.pub, 0));
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));
node1.work_generate_blocking (*open_block);
ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *open_block).code);
}
ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::genesis_account));
ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::dev::genesis->account ()));
nano::account_info info2;
{
auto transaction (node1.store.tx_begin_read ());
ASSERT_FALSE (node1.store.account.get (transaction, nano::dev_genesis_key.pub, info2));
ASSERT_FALSE (node1.store.account.get (transaction, nano::dev::genesis_key.pub, info2));
}
ASSERT_NE (info1.head, info2.head);
system.deadline_set (15s);
@ -68,10 +68,10 @@ TEST (system, DISABLED_generate_send_existing)
{
ASSERT_NO_ERROR (system.poll ());
auto transaction (node1.store.tx_begin_read ());
ASSERT_FALSE (node1.store.account.get (transaction, nano::dev_genesis_key.pub, info2));
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::genesis_amount / 3);
ASSERT_EQ (info2.balance, nano::dev::genesis_amount / 3);
{
auto transaction (node1.store.tx_begin_read ());
ASSERT_NE (node1.ledger.amount (transaction, info2.head), 0);
@ -85,7 +85,7 @@ TEST (system, DISABLED_generate_send_new)
nano::system system (1);
auto & node1 (*system.nodes[0]);
nano::thread_runner runner (system.io_ctx, node1.config.io_threads);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
{
auto transaction (node1.store.tx_begin_read ());
auto iterator1 (node1.store.account.begin (transaction));
@ -94,16 +94,16 @@ 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::genesis_account, stake_preserver.pub, nano::genesis_amount / 3 * 2, true));
auto send_block (system.wallet (0)->send_action (nano::dev::genesis->account (), stake_preserver.pub, nano::dev::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::genesis_account, stake_preserver.pub, stake_preserver.prv, stake_preserver.pub, 0));
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));
node1.work_generate_blocking (*open_block);
ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *open_block).code);
}
ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::genesis_account));
ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::dev::genesis->account ()));
std::vector<nano::account> accounts;
accounts.push_back (nano::dev_genesis_key.pub);
accounts.push_back (nano::dev::genesis_key.pub);
// This indirectly waits for online weight to stabilize, required to prevent intermittent failures
ASSERT_TIMELY (5s, node1.wallets.reps ().voting > 0);
system.generate_send_new (node1, accounts);
@ -111,13 +111,13 @@ TEST (system, DISABLED_generate_send_new)
{
auto transaction (node1.wallets.tx_begin_read ());
auto iterator2 (system.wallet (0)->store.begin (transaction));
if (iterator2->first != nano::dev_genesis_key.pub)
if (iterator2->first != nano::dev::genesis_key.pub)
{
new_account = iterator2->first;
}
++iterator2;
ASSERT_NE (system.wallet (0)->store.end (), iterator2);
if (iterator2->first != nano::dev_genesis_key.pub)
if (iterator2->first != nano::dev::genesis_key.pub)
{
new_account = iterator2->first;
}
@ -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::genesis_amount, node->balance (key.pub));
ASSERT_EQ (nano::dev::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::genesis_amount / 2, node->balance (key0.pub));
ASSERT_EQ (nano::genesis_amount / 2, node->balance (key1.pub));
ASSERT_EQ (nano::dev::genesis_amount / 2, node->balance (key0.pub));
ASSERT_EQ (nano::dev::genesis_amount / 2, node->balance (key1.pub));
}
TEST (system, rep_initialize_one_reserve)
@ -156,8 +156,8 @@ 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::genesis_amount - nano::Gxrb_ratio, node->balance (key.pub));
ASSERT_EQ (nano::Gxrb_ratio, node->balance (nano::dev_genesis_key.pub));
ASSERT_EQ (nano::dev::genesis_amount - nano::Gxrb_ratio, node->balance (key.pub));
ASSERT_EQ (nano::Gxrb_ratio, node->balance (nano::dev::genesis_key.pub));
}
TEST (system, rep_initialize_two_reserve)
@ -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::genesis_amount - nano::Gxrb_ratio) / 2, node->balance (key0.pub));
ASSERT_EQ ((nano::genesis_amount - nano::Gxrb_ratio) / 2, node->balance (key1.pub));
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));
}
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::genesis_amount - nano::Gxrb_ratio) / 2, node0->balance (key0.pub));
ASSERT_EQ ((nano::genesis_amount - nano::Gxrb_ratio) / 2, node0->balance (key1.pub));
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));
auto node1 = system.add_node ();
ASSERT_EQ ((nano::genesis_amount - nano::Gxrb_ratio) / 2, node1->balance (key0.pub));
ASSERT_EQ ((nano::genesis_amount - nano::Gxrb_ratio) / 2, node1->balance (key1.pub));
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));
}

12
nano/core_test/telemetry.cpp
View file

@ -555,12 +555,12 @@ TEST (telemetry, remove_peer_different_genesis)
// Possible TSAN issue in the future if something else uses this, but will only appear in tests.
nano::state_block_builder builder;
auto junk = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (0)
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (0)
.link (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
node1->network_params.ledger.genesis = junk;
@ -593,12 +593,12 @@ TEST (telemetry, remove_peer_different_genesis_udp)
auto node1 (std::make_shared<nano::node> (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work, node_flags));
nano::state_block_builder builder;
auto junk = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (0)
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (0)
.link (0)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
node1->network_params.ledger.genesis = junk;

4
nano/core_test/uint256_union.cpp
View file

@ -375,9 +375,9 @@ TEST (uint256_union, decode_nano_variant)
TEST (uint256_union, account_transcode)
{
nano::account value;
auto text (nano::dev_genesis_key.pub.to_account ());
auto text (nano::dev::genesis_key.pub.to_account ());
ASSERT_FALSE (value.decode_account (text));
ASSERT_EQ (nano::dev_genesis_key.pub, value);
ASSERT_EQ (nano::dev::genesis_key.pub, value);
/*
* Handle different offsets for the underscore separator

70
nano/core_test/vote_processor.cpp
View file

@ -28,7 +28,7 @@ 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::genesis_account, 0, nano::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_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);
ASSERT_NE (nullptr, node.active.election (genesis.open->qualified_root ()));
ASSERT_EQ (nano::vote_code::vote, node.vote_processor.vote_blocking (vote, channel));
@ -55,7 +55,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>{ genesis.open->hash () }));
auto channel (std::make_shared<nano::transport::channel_loopback> (node));
for (unsigned i = 0; i < 2000; ++i)
{
@ -78,7 +78,7 @@ TEST (vote_processor, invalid_signature)
vote_invalid->signature.bytes[0] ^= 1;
auto channel = std::make_shared<nano::transport::channel_loopback> (node);
genesis.open->sideband_set (nano::block_sideband (nano::genesis_account, 0, nano::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_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);
auto election = node.active.election (genesis.open->qualified_root ());
ASSERT_TRUE (election);
@ -148,16 +148,16 @@ TEST (vote_processor, weights)
nano::keypair key1;
nano::keypair key2;
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
system.wallet (1)->insert_adhoc (key0.prv);
system.wallet (2)->insert_adhoc (key1.prv);
system.wallet (3)->insert_adhoc (key2.prv);
system.wallet (1)->store.representative_set (system.nodes[1]->wallets.tx_begin_write (), key0.pub);
system.wallet (2)->store.representative_set (system.nodes[2]->wallets.tx_begin_write (), key1.pub);
system.wallet (3)->store.representative_set (system.nodes[3]->wallets.tx_begin_write (), key2.pub);
system.wallet (0)->send_sync (nano::dev_genesis_key.pub, key0.pub, level0);
system.wallet (0)->send_sync (nano::dev_genesis_key.pub, key1.pub, level1);
system.wallet (0)->send_sync (nano::dev_genesis_key.pub, key2.pub, level2);
system.wallet (0)->send_sync (nano::dev::genesis_key.pub, key0.pub, level0);
system.wallet (0)->send_sync (nano::dev::genesis_key.pub, key1.pub, level1);
system.wallet (0)->send_sync (nano::dev::genesis_key.pub, key2.pub, level2);
// Wait for representatives
ASSERT_TIMELY (10s, node.ledger.cache.rep_weights.get_rep_amounts ().size () == 4);
@ -175,9 +175,9 @@ TEST (vote_processor, weights)
ASSERT_NE (node.vote_processor.representatives_2.end (), node.vote_processor.representatives_2.find (key2.pub));
ASSERT_EQ (node.vote_processor.representatives_3.end (), node.vote_processor.representatives_3.find (key2.pub));
ASSERT_NE (node.vote_processor.representatives_1.end (), node.vote_processor.representatives_1.find (nano::dev_genesis_key.pub));
ASSERT_NE (node.vote_processor.representatives_2.end (), node.vote_processor.representatives_2.find (nano::dev_genesis_key.pub));
ASSERT_NE (node.vote_processor.representatives_3.end (), node.vote_processor.representatives_3.find (nano::dev_genesis_key.pub));
ASSERT_NE (node.vote_processor.representatives_1.end (), node.vote_processor.representatives_1.find (nano::dev::genesis_key.pub));
ASSERT_NE (node.vote_processor.representatives_2.end (), node.vote_processor.representatives_2.find (nano::dev::genesis_key.pub));
ASSERT_NE (node.vote_processor.representatives_3.end (), node.vote_processor.representatives_3.find (nano::dev::genesis_key.pub));
}
}
@ -193,30 +193,30 @@ TEST (vote_processor, no_broadcast_local)
// Reduce the weight of genesis to 2x default min voting weight
nano::keypair key;
std::shared_ptr<nano::block> send = builder.state ()
.account (nano::dev_genesis_key.pub)
.representative (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.account (nano::dev::genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
.balance (2 * node.config.vote_minimum.number ())
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build (ec);
ASSERT_FALSE (ec);
ASSERT_EQ (nano::process_result::progress, node.process_local (send).code);
ASSERT_EQ (2 * node.config.vote_minimum.number (), node.weight (nano::dev_genesis_key.pub));
ASSERT_EQ (2 * node.config.vote_minimum.number (), node.weight (nano::dev::genesis_key.pub));
// Insert account in wallet
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
node.wallets.compute_reps ();
ASSERT_TRUE (node.wallets.reps ().exists (nano::dev_genesis_key.pub));
ASSERT_TRUE (node.wallets.reps ().exists (nano::dev::genesis_key.pub));
ASSERT_FALSE (node.wallets.reps ().have_half_rep ());
// Process a vote
auto vote = std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::milliseconds_since_epoch (), std::vector<nano::block_hash>{ send->hash () });
auto vote = std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::milliseconds_since_epoch (), std::vector<nano::block_hash>{ send->hash () });
ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote));
// Make sure the vote was processed
auto election (node.active.election (send->qualified_root ()));
ASSERT_NE (nullptr, election);
auto votes (election->votes ());
auto existing (votes.find (nano::dev_genesis_key.pub));
auto existing (votes.find (nano::dev::genesis_key.pub));
ASSERT_NE (votes.end (), existing);
ASSERT_EQ (vote->timestamp, existing->second.timestamp);
// Ensure the vote, from a local representative, was not broadcast on processing - it should be flooded on generation instead
@ -225,31 +225,31 @@ TEST (vote_processor, no_broadcast_local)
// Repeat test with no representative
// Erase account from the wallet
system.wallet (0)->store.erase (node.wallets.tx_begin_write (), nano::dev_genesis_key.pub);
system.wallet (0)->store.erase (node.wallets.tx_begin_write (), nano::dev::genesis_key.pub);
node.wallets.compute_reps ();
ASSERT_FALSE (node.wallets.reps ().exists (nano::dev_genesis_key.pub));
ASSERT_FALSE (node.wallets.reps ().exists (nano::dev::genesis_key.pub));
std::shared_ptr<nano::block> send2 = builder.state ()
.account (nano::dev_genesis_key.pub)
.representative (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.previous (send->hash ())
.balance (node.config.vote_minimum)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send->hash ()))
.build (ec);
ASSERT_FALSE (ec);
ASSERT_EQ (nano::process_result::progress, node.process_local (send2).code);
ASSERT_EQ (node.config.vote_minimum, node.weight (nano::dev_genesis_key.pub));
ASSERT_EQ (node.config.vote_minimum, node.weight (nano::dev::genesis_key.pub));
node.block_confirm (send2);
// Process a vote
auto vote2 = std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::milliseconds_since_epoch (), std::vector<nano::block_hash>{ send2->hash () });
auto vote2 = std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::milliseconds_since_epoch (), std::vector<nano::block_hash>{ send2->hash () });
ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote2));
// Make sure the vote was processed
auto election2 (node.active.election (send2->qualified_root ()));
ASSERT_NE (nullptr, election2);
auto votes2 (election2->votes ());
auto existing2 (votes2.find (nano::dev_genesis_key.pub));
auto existing2 (votes2.find (nano::dev::genesis_key.pub));
ASSERT_NE (votes2.end (), existing2);
ASSERT_EQ (vote2->timestamp, existing2->second.timestamp);
// Ensure the vote was broadcast
@ -260,30 +260,30 @@ TEST (vote_processor, no_broadcast_local)
// Increase the genesis weight again
std::shared_ptr<nano::block> open = builder.state ()
.account (key.pub)
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.previous (0)
.balance (nano::genesis_amount - 2 * node.config.vote_minimum.number ())
.balance (nano::dev::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::genesis_amount - node.config.vote_minimum.number (), node.weight (nano::dev_genesis_key.pub));
ASSERT_EQ (nano::dev::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);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
node.wallets.compute_reps ();
ASSERT_TRUE (node.wallets.reps ().exists (nano::dev_genesis_key.pub));
ASSERT_TRUE (node.wallets.reps ().exists (nano::dev::genesis_key.pub));
ASSERT_TRUE (node.wallets.reps ().have_half_rep ());
// Process a vote
auto vote3 = std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::milliseconds_since_epoch (), std::vector<nano::block_hash>{ open->hash () });
auto vote3 = std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::milliseconds_since_epoch (), std::vector<nano::block_hash>{ open->hash () });
ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote3));
// Make sure the vote was processed
auto election3 (node.active.election (open->qualified_root ()));
ASSERT_NE (nullptr, election3);
auto votes3 (election3->votes ());
auto existing3 (votes3.find (nano::dev_genesis_key.pub));
auto existing3 (votes3.find (nano::dev::genesis_key.pub));
ASSERT_NE (votes3.end (), existing3);
ASSERT_EQ (vote3->timestamp, existing3->second.timestamp);
// Ensure the vote wass not broadcasst

90
nano/core_test/voting.cpp
View file

@ -61,7 +61,7 @@ TEST (vote_generator, cache)
nano::system system (1);
auto & node (*system.nodes[0]);
auto epoch1 = system.upgrade_genesis_epoch (node, nano::epoch::epoch_1);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
node.active.generator.add (epoch1->root (), epoch1->hash ());
ASSERT_TIMELY (1s, !node.history.votes (epoch1->root (), epoch1->hash ()).empty ());
auto votes (node.history.votes (epoch1->root (), epoch1->hash ()));
@ -75,14 +75,14 @@ TEST (vote_generator, multiple_representatives)
auto & node (*system.nodes[0]);
nano::keypair key1, key2, key3;
auto & wallet (*system.wallet (0));
wallet.insert_adhoc (nano::dev_genesis_key.prv);
wallet.insert_adhoc (nano::dev::genesis_key.prv);
wallet.insert_adhoc (key1.prv);
wallet.insert_adhoc (key2.prv);
wallet.insert_adhoc (key3.prv);
auto const amount = 100 * nano::Gxrb_ratio;
wallet.send_sync (nano::dev_genesis_key.pub, key1.pub, amount);
wallet.send_sync (nano::dev_genesis_key.pub, key2.pub, amount);
wallet.send_sync (nano::dev_genesis_key.pub, key3.pub, amount);
wallet.send_sync (nano::dev::genesis_key.pub, key1.pub, amount);
wallet.send_sync (nano::dev::genesis_key.pub, key2.pub, amount);
wallet.send_sync (nano::dev::genesis_key.pub, key3.pub, amount);
ASSERT_TIMELY (3s, node.balance (key1.pub) == amount && node.balance (key2.pub) == amount && node.balance (key3.pub) == amount);
wallet.change_sync (key1.pub, key1.pub);
wallet.change_sync (key2.pub, key2.pub);
@ -90,12 +90,12 @@ TEST (vote_generator, multiple_representatives)
ASSERT_TRUE (node.weight (key1.pub) == amount && node.weight (key2.pub) == amount && node.weight (key3.pub) == amount);
node.wallets.compute_reps ();
ASSERT_EQ (4, node.wallets.reps ().voting);
auto hash = wallet.send_sync (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub, 1);
auto hash = wallet.send_sync (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, 1);
auto send = node.block (hash);
ASSERT_NE (nullptr, send);
ASSERT_TIMELY (5s, node.history.votes (send->root (), send->hash ()).size () == 4);
auto votes (node.history.votes (send->root (), send->hash ()));
for (auto const & account : { key1.pub, key2.pub, key3.pub, nano::dev_genesis_key.pub })
for (auto const & account : { key1.pub, key2.pub, key3.pub, nano::dev::genesis_key.pub })
{
auto existing (std::find_if (votes.begin (), votes.end (), [&account] (std::shared_ptr<nano::vote> const & vote_a) -> bool {
return vote_a->account == account;
@ -108,11 +108,11 @@ TEST (vote_generator, session)
{
nano::system system (1);
auto node (system.nodes[0]);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::vote_generator_session generator_session (node->active.generator);
boost::thread thread ([node, &generator_session] () {
nano::thread_role::set (nano::thread_role::name::request_loop);
generator_session.add (nano::genesis_account, nano::genesis_hash);
generator_session.add (nano::dev::genesis->account (), nano::dev::genesis->hash ());
ASSERT_EQ (0, node->stats.count (nano::stat::type::vote, nano::stat::detail::vote_indeterminate));
generator_session.flush ();
});
@ -162,37 +162,37 @@ TEST (vote_spacing, vote_generator)
node_flags.disable_search_pending = true;
auto & node = *system.add_node (config, node_flags);
auto & wallet = *system.wallet (0);
wallet.insert_adhoc (nano::dev_genesis_key.prv);
wallet.insert_adhoc (nano::dev::genesis_key.prv);
nano::state_block_builder builder;
auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.balance (nano::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::genesis_hash))
.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)
.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 ()))
.build_shared ();
auto send2 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.balance (nano::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::genesis_hash))
.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)
.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 ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
ASSERT_EQ (0, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts));
node.active.generator.add (nano::genesis_hash, send1->hash ());
node.active.generator.add (nano::dev::genesis->hash (), send1->hash ());
ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts) == 1);
ASSERT_FALSE (node.ledger.rollback (node.store.tx_begin_write (), send1->hash ()));
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code);
node.active.generator.add (nano::genesis_hash, send2->hash ());
node.active.generator.add (nano::dev::genesis->hash (), send2->hash ());
ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_spacing) == 1);
ASSERT_EQ (1, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts));
std::this_thread::sleep_for (config.network_params.voting.delay);
node.active.generator.add (nano::genesis_hash, send2->hash ());
node.active.generator.add (nano::dev::genesis->hash (), send2->hash ());
ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts) == 2);
}
@ -205,35 +205,35 @@ TEST (vote_spacing, rapid)
node_flags.disable_search_pending = true;
auto & node = *system.add_node (config, node_flags);
auto & wallet = *system.wallet (0);
wallet.insert_adhoc (nano::dev_genesis_key.prv);
wallet.insert_adhoc (nano::dev::genesis_key.prv);
nano::state_block_builder builder;
auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.balance (nano::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::genesis_hash))
.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)
.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 ()))
.build_shared ();
auto send2 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.representative (nano::dev_genesis_key.pub)
.balance (nano::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::genesis_hash))
.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)
.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 ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
node.active.generator.add (nano::genesis_hash, send1->hash ());
node.active.generator.add (nano::dev::genesis->hash (), send1->hash ());
ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts) == 1);
ASSERT_FALSE (node.ledger.rollback (node.store.tx_begin_write (), send1->hash ()));
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code);
node.active.generator.add (nano::genesis_hash, send2->hash ());
node.active.generator.add (nano::dev::genesis->hash (), send2->hash ());
ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_spacing) == 1);
ASSERT_TIMELY (3s, 1 == node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts));
std::this_thread::sleep_for (config.network_params.voting.delay);
node.active.generator.add (nano::genesis_hash, send2->hash ());
node.active.generator.add (nano::dev::genesis->hash (), send2->hash ());
ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts) == 2);
}

206
nano/core_test/wallet.cpp
View file

@ -18,7 +18,7 @@ TEST (wallet, no_special_keys_accounts)
ASSERT_FALSE (init);
auto transaction (env.tx_begin_write ());
nano::kdf kdf;
nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0");
ASSERT_FALSE (init);
nano::keypair key1;
ASSERT_FALSE (wallet.exists (transaction, key1.pub));
@ -39,7 +39,7 @@ TEST (wallet, no_key)
ASSERT_FALSE (init);
auto transaction (env.tx_begin_write ());
nano::kdf kdf;
nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0");
ASSERT_FALSE (init);
nano::keypair key1;
nano::raw_key prv1;
@ -54,7 +54,7 @@ TEST (wallet, fetch_locked)
ASSERT_FALSE (init);
auto transaction (env.tx_begin_write ());
nano::kdf kdf;
nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0");
ASSERT_TRUE (wallet.valid_password (transaction));
nano::keypair key1;
ASSERT_EQ (key1.pub, wallet.insert_adhoc (transaction, key1.prv));
@ -76,7 +76,7 @@ TEST (wallet, retrieval)
ASSERT_FALSE (init);
auto transaction (env.tx_begin_write ());
nano::kdf kdf;
nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0");
ASSERT_FALSE (init);
nano::keypair key1;
ASSERT_TRUE (wallet.valid_password (transaction));
@ -98,7 +98,7 @@ TEST (wallet, empty_iteration)
ASSERT_FALSE (init);
auto transaction (env.tx_begin_write ());
nano::kdf kdf;
nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0");
ASSERT_FALSE (init);
auto i (wallet.begin (transaction));
auto j (wallet.end ());
@ -112,7 +112,7 @@ TEST (wallet, one_item_iteration)
ASSERT_FALSE (init);
auto transaction (env.tx_begin_write ());
nano::kdf kdf;
nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0");
ASSERT_FALSE (init);
nano::keypair key1;
wallet.insert_adhoc (transaction, key1.prv);
@ -140,7 +140,7 @@ TEST (wallet, two_item_iteration)
nano::kdf kdf;
{
auto transaction (env.tx_begin_write ());
nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0");
ASSERT_FALSE (init);
wallet.insert_adhoc (transaction, key1.prv);
wallet.insert_adhoc (transaction, key2.prv);
@ -166,43 +166,43 @@ TEST (wallet, insufficient_spend_one)
{
nano::system system (1);
nano::keypair key1;
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));
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::genesis_amount));
ASSERT_EQ (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, nano::dev::genesis_amount));
}
TEST (wallet, spend_all_one)
{
nano::system system (1);
auto & node1 (*system.nodes[0]);
nano::block_hash latest1 (node1.latest (nano::dev_genesis_key.pub));
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
nano::block_hash latest1 (node1.latest (nano::dev::genesis_key.pub));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::keypair key2;
ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, std::numeric_limits<nano::uint128_t>::max ()));
ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, std::numeric_limits<nano::uint128_t>::max ()));
nano::account_info info2;
{
auto transaction (node1.store.tx_begin_read ());
node1.store.account.get (transaction, nano::dev_genesis_key.pub, info2);
node1.store.account.get (transaction, nano::dev::genesis_key.pub, info2);
ASSERT_NE (latest1, info2.head);
auto block (node1.store.block.get (transaction, info2.head));
ASSERT_NE (nullptr, block);
ASSERT_EQ (latest1, block->previous ());
}
ASSERT_TRUE (info2.balance.is_zero ());
ASSERT_EQ (0, node1.balance (nano::dev_genesis_key.pub));
ASSERT_EQ (0, node1.balance (nano::dev::genesis_key.pub));
}
TEST (wallet, send_async)
{
nano::system system (1);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::keypair key2;
std::thread thread ([&system] () {
ASSERT_TIMELY (10s, system.nodes[0]->balance (nano::dev_genesis_key.pub).is_zero ());
ASSERT_TIMELY (10s, system.nodes[0]->balance (nano::dev::genesis_key.pub).is_zero ());
});
std::atomic<bool> success (false);
system.wallet (0)->send_async (nano::dev_genesis_key.pub, key2.pub, std::numeric_limits<nano::uint128_t>::max (), [&success] (std::shared_ptr<nano::block> const & block_a) { ASSERT_NE (nullptr, block_a); success = true; });
system.wallet (0)->send_async (nano::dev::genesis_key.pub, key2.pub, std::numeric_limits<nano::uint128_t>::max (), [&success] (std::shared_ptr<nano::block> const & block_a) { ASSERT_NE (nullptr, block_a); success = true; });
thread.join ();
ASSERT_TIMELY (2s, success);
}
@ -211,34 +211,34 @@ TEST (wallet, spend)
{
nano::system system (1);
auto & node1 (*system.nodes[0]);
nano::block_hash latest1 (node1.latest (nano::dev_genesis_key.pub));
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
nano::block_hash latest1 (node1.latest (nano::dev::genesis_key.pub));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::keypair key2;
// Sending from empty accounts should always be an error. Accounts need to be opened with an open block, not a send block.
ASSERT_EQ (nullptr, system.wallet (0)->send_action (0, key2.pub, 0));
ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, std::numeric_limits<nano::uint128_t>::max ()));
ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, std::numeric_limits<nano::uint128_t>::max ()));
nano::account_info info2;
{
auto transaction (node1.store.tx_begin_read ());
node1.store.account.get (transaction, nano::dev_genesis_key.pub, info2);
node1.store.account.get (transaction, nano::dev::genesis_key.pub, info2);
ASSERT_NE (latest1, info2.head);
auto block (node1.store.block.get (transaction, info2.head));
ASSERT_NE (nullptr, block);
ASSERT_EQ (latest1, block->previous ());
}
ASSERT_TRUE (info2.balance.is_zero ());
ASSERT_EQ (0, node1.balance (nano::dev_genesis_key.pub));
ASSERT_EQ (0, node1.balance (nano::dev::genesis_key.pub));
}
TEST (wallet, change)
{
nano::system system (1);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::keypair key2;
auto block1 (system.nodes[0]->rep_block (nano::dev_genesis_key.pub));
auto block1 (system.nodes[0]->rep_block (nano::dev::genesis_key.pub));
ASSERT_FALSE (block1.is_zero ());
ASSERT_NE (nullptr, system.wallet (0)->change_action (nano::dev_genesis_key.pub, key2.pub));
auto block2 (system.nodes[0]->rep_block (nano::dev_genesis_key.pub));
ASSERT_NE (nullptr, system.wallet (0)->change_action (nano::dev::genesis_key.pub, key2.pub));
auto block2 (system.nodes[0]->rep_block (nano::dev::genesis_key.pub));
ASSERT_FALSE (block2.is_zero ());
ASSERT_NE (block1, block2);
}
@ -246,20 +246,20 @@ TEST (wallet, change)
TEST (wallet, partial_spend)
{
nano::system system (1);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::keypair key2;
ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, 500));
ASSERT_EQ (std::numeric_limits<nano::uint128_t>::max () - 500, system.nodes[0]->balance (nano::dev_genesis_key.pub));
ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, 500));
ASSERT_EQ (std::numeric_limits<nano::uint128_t>::max () - 500, system.nodes[0]->balance (nano::dev::genesis_key.pub));
}
TEST (wallet, spend_no_previous)
{
nano::system system (1);
{
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
auto transaction (system.nodes[0]->store.tx_begin_read ());
nano::account_info info1;
ASSERT_FALSE (system.nodes[0]->store.account.get (transaction, nano::dev_genesis_key.pub, info1));
ASSERT_FALSE (system.nodes[0]->store.account.get (transaction, nano::dev::genesis_key.pub, info1));
for (auto i (0); i < 50; ++i)
{
nano::keypair key;
@ -267,8 +267,8 @@ TEST (wallet, spend_no_previous)
}
}
nano::keypair key2;
ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, 500));
ASSERT_EQ (std::numeric_limits<nano::uint128_t>::max () - 500, system.nodes[0]->balance (nano::dev_genesis_key.pub));
ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, 500));
ASSERT_EQ (std::numeric_limits<nano::uint128_t>::max () - 500, system.nodes[0]->balance (nano::dev::genesis_key.pub));
}
TEST (wallet, find_none)
@ -278,7 +278,7 @@ TEST (wallet, find_none)
ASSERT_FALSE (init);
auto transaction (env.tx_begin_write ());
nano::kdf kdf;
nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0");
ASSERT_FALSE (init);
nano::account account (1000);
ASSERT_EQ (wallet.end (), wallet.find (transaction, account));
@ -291,7 +291,7 @@ TEST (wallet, find_existing)
ASSERT_FALSE (init);
auto transaction (env.tx_begin_write ());
nano::kdf kdf;
nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0");
ASSERT_FALSE (init);
nano::keypair key1;
ASSERT_FALSE (wallet.exists (transaction, key1.pub));
@ -310,7 +310,7 @@ TEST (wallet, rekey)
ASSERT_FALSE (init);
auto transaction (env.tx_begin_write ());
nano::kdf kdf;
nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0");
ASSERT_FALSE (init);
nano::raw_key password;
wallet.password.value (password);
@ -382,7 +382,7 @@ TEST (wallet, hash_password)
ASSERT_FALSE (init);
auto transaction (env.tx_begin_write ());
nano::kdf kdf;
nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0");
ASSERT_FALSE (init);
nano::raw_key hash1;
wallet.derive_key (hash1, transaction, "");
@ -432,25 +432,25 @@ TEST (wallet, reopen_default_password)
ASSERT_FALSE (init);
nano::kdf kdf;
{
nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0");
ASSERT_FALSE (init);
ASSERT_TRUE (wallet.valid_password (transaction));
}
{
bool init;
nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0");
ASSERT_FALSE (init);
ASSERT_TRUE (wallet.valid_password (transaction));
}
{
nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0");
ASSERT_FALSE (init);
wallet.rekey (transaction, "");
ASSERT_TRUE (wallet.valid_password (transaction));
}
{
bool init;
nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0");
ASSERT_FALSE (init);
ASSERT_FALSE (wallet.valid_password (transaction));
wallet.attempt_password (transaction, " ");
@ -467,10 +467,10 @@ TEST (wallet, representative)
ASSERT_FALSE (error);
auto transaction (env.tx_begin_write ());
nano::kdf kdf;
nano::wallet_store wallet (error, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet (error, kdf, transaction, nano::dev::genesis->account (), 1, "0");
ASSERT_FALSE (error);
ASSERT_FALSE (wallet.is_representative (transaction));
ASSERT_EQ (nano::genesis_account, wallet.representative (transaction));
ASSERT_EQ (nano::dev::genesis->account (), wallet.representative (transaction));
ASSERT_FALSE (wallet.is_representative (transaction));
nano::keypair key;
wallet.representative_set (transaction, key.pub);
@ -488,11 +488,11 @@ TEST (wallet, serialize_json_empty)
ASSERT_FALSE (error);
auto transaction (env.tx_begin_write ());
nano::kdf kdf;
nano::wallet_store wallet1 (error, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet1 (error, kdf, transaction, nano::dev::genesis->account (), 1, "0");
ASSERT_FALSE (error);
std::string serialized;
wallet1.serialize_json (transaction, serialized);
nano::wallet_store wallet2 (error, kdf, transaction, nano::genesis_account, 1, "1", serialized);
nano::wallet_store wallet2 (error, kdf, transaction, nano::dev::genesis->account (), 1, "1", serialized);
ASSERT_FALSE (error);
nano::raw_key password1;
nano::raw_key password2;
@ -513,13 +513,13 @@ TEST (wallet, serialize_json_one)
ASSERT_FALSE (error);
auto transaction (env.tx_begin_write ());
nano::kdf kdf;
nano::wallet_store wallet1 (error, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet1 (error, kdf, transaction, nano::dev::genesis->account (), 1, "0");
ASSERT_FALSE (error);
nano::keypair key;
wallet1.insert_adhoc (transaction, key.prv);
std::string serialized;
wallet1.serialize_json (transaction, serialized);
nano::wallet_store wallet2 (error, kdf, transaction, nano::genesis_account, 1, "1", serialized);
nano::wallet_store wallet2 (error, kdf, transaction, nano::dev::genesis->account (), 1, "1", serialized);
ASSERT_FALSE (error);
nano::raw_key password1;
nano::raw_key password2;
@ -542,14 +542,14 @@ TEST (wallet, serialize_json_password)
ASSERT_FALSE (error);
auto transaction (env.tx_begin_write ());
nano::kdf kdf;
nano::wallet_store wallet1 (error, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet1 (error, kdf, transaction, nano::dev::genesis->account (), 1, "0");
ASSERT_FALSE (error);
nano::keypair key;
wallet1.rekey (transaction, "password");
wallet1.insert_adhoc (transaction, key.prv);
std::string serialized;
wallet1.serialize_json (transaction, serialized);
nano::wallet_store wallet2 (error, kdf, transaction, nano::genesis_account, 1, "1", serialized);
nano::wallet_store wallet2 (error, kdf, transaction, nano::dev::genesis->account (), 1, "1", serialized);
ASSERT_FALSE (error);
ASSERT_FALSE (wallet2.valid_password (transaction));
ASSERT_FALSE (wallet2.attempt_password (transaction, "password"));
@ -575,11 +575,11 @@ TEST (wallet_store, move)
ASSERT_FALSE (error);
auto transaction (env.tx_begin_write ());
nano::kdf kdf;
nano::wallet_store wallet1 (error, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet1 (error, kdf, transaction, nano::dev::genesis->account (), 1, "0");
ASSERT_FALSE (error);
nano::keypair key1;
wallet1.insert_adhoc (transaction, key1.prv);
nano::wallet_store wallet2 (error, kdf, transaction, nano::genesis_account, 1, "1");
nano::wallet_store wallet2 (error, kdf, transaction, nano::dev::genesis->account (), 1, "1");
ASSERT_FALSE (error);
nano::keypair key2;
wallet2.insert_adhoc (transaction, key2.prv);
@ -635,7 +635,7 @@ TEST (wallet, work)
{
nano::system system (1);
auto wallet (system.wallet (0));
wallet->insert_adhoc (nano::dev_genesis_key.prv);
wallet->insert_adhoc (nano::dev::genesis_key.prv);
nano::genesis genesis;
auto done (false);
system.deadline_set (20s);
@ -643,7 +643,7 @@ TEST (wallet, work)
{
auto transaction (system.wallet (0)->wallets.tx_begin_read ());
uint64_t work (0);
if (!wallet->store.work_get (transaction, nano::dev_genesis_key.pub, work))
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 ());
}
@ -656,18 +656,18 @@ TEST (wallet, work_generate)
nano::system system (1);
auto & node1 (*system.nodes[0]);
auto wallet (system.wallet (0));
nano::uint128_t amount1 (node1.balance (nano::dev_genesis_key.pub));
nano::uint128_t amount1 (node1.balance (nano::dev::genesis_key.pub));
uint64_t work1;
wallet->insert_adhoc (nano::dev_genesis_key.prv);
wallet->insert_adhoc (nano::dev::genesis_key.prv);
nano::account account1;
{
auto transaction (node1.wallets.tx_begin_read ());
account1 = system.account (transaction, 0);
}
nano::keypair key;
auto block (wallet->send_action (nano::dev_genesis_key.pub, key.pub, 100));
auto block (wallet->send_action (nano::dev::genesis_key.pub, key.pub, 100));
auto transaction (node1.store.tx_begin_read ());
ASSERT_TIMELY (10s, node1.ledger.account_balance (transaction, nano::dev_genesis_key.pub) != amount1);
ASSERT_TIMELY (10s, node1.ledger.account_balance (transaction, nano::dev::genesis_key.pub) != amount1);
system.deadline_set (10s);
auto again (true);
while (again)
@ -685,18 +685,18 @@ TEST (wallet, work_cache_delayed)
auto & node1 (*system.nodes[0]);
auto wallet (system.wallet (0));
uint64_t work1;
wallet->insert_adhoc (nano::dev_genesis_key.prv);
wallet->insert_adhoc (nano::dev::genesis_key.prv);
nano::account account1;
{
auto transaction (node1.wallets.tx_begin_read ());
account1 = system.account (transaction, 0);
}
nano::keypair key;
auto block1 (wallet->send_action (nano::dev_genesis_key.pub, key.pub, 100));
ASSERT_EQ (block1->hash (), node1.latest (nano::dev_genesis_key.pub));
auto block2 (wallet->send_action (nano::dev_genesis_key.pub, key.pub, 100));
ASSERT_EQ (block2->hash (), node1.latest (nano::dev_genesis_key.pub));
ASSERT_EQ (block2->hash (), node1.wallets.delayed_work->operator[] (nano::dev_genesis_key.pub));
auto block1 (wallet->send_action (nano::dev::genesis_key.pub, key.pub, 100));
ASSERT_EQ (block1->hash (), node1.latest (nano::dev::genesis_key.pub));
auto block2 (wallet->send_action (nano::dev::genesis_key.pub, key.pub, 100));
ASSERT_EQ (block2->hash (), node1.latest (nano::dev::genesis_key.pub));
ASSERT_EQ (block2->hash (), node1.wallets.delayed_work->operator[] (nano::dev::genesis_key.pub));
auto threshold (node1.default_difficulty (nano::work_version::work_1));
auto again (true);
system.deadline_set (10s);
@ -733,7 +733,7 @@ TEST (wallet, deterministic_keys)
ASSERT_FALSE (init);
auto transaction (env.tx_begin_write ());
nano::kdf kdf;
nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0");
auto key1 = wallet.deterministic_key (transaction, 0);
auto key2 = wallet.deterministic_key (transaction, 0);
ASSERT_EQ (key1, key2);
@ -776,7 +776,7 @@ TEST (wallet, reseed)
ASSERT_FALSE (init);
auto transaction (env.tx_begin_write ());
nano::kdf kdf;
nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0");
nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0");
nano::raw_key seed1;
seed1 = 1;
nano::raw_key seed2;
@ -817,27 +817,27 @@ TEST (wallet, insert_deterministic_locked)
TEST (wallet, no_work)
{
nano::system system (1);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv, false);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv, false);
nano::keypair key2;
auto block (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, std::numeric_limits<nano::uint128_t>::max (), false));
auto block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, std::numeric_limits<nano::uint128_t>::max (), false));
ASSERT_NE (nullptr, block);
ASSERT_NE (0, block->block_work ());
ASSERT_GE (block->difficulty (), nano::work_threshold (block->work_version (), block->sideband ().details));
auto transaction (system.wallet (0)->wallets.tx_begin_read ());
uint64_t cached_work (0);
system.wallet (0)->store.work_get (transaction, nano::dev_genesis_key.pub, cached_work);
system.wallet (0)->store.work_get (transaction, nano::dev::genesis_key.pub, cached_work);
ASSERT_EQ (0, cached_work);
}
TEST (wallet, send_race)
{
nano::system system (1);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::keypair key2;
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::genesis_amount - nano::Gxrb_ratio * i, system.nodes[0]->balance (nano::dev_genesis_key.pub));
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));
}
}
@ -950,8 +950,8 @@ TEST (wallet, change_seed)
uint32_t index (4);
auto prv = nano::deterministic_key (seed1, index);
pub = nano::pub_key (prv);
wallet->insert_adhoc (nano::dev_genesis_key.prv, false);
auto block (wallet->send_action (nano::dev_genesis_key.pub, pub, 100));
wallet->insert_adhoc (nano::dev::genesis_key.prv, false);
auto block (wallet->send_action (nano::dev::genesis_key.pub, pub, 100));
ASSERT_NE (nullptr, block);
system.nodes[0]->block_processor.flush ();
{
@ -984,8 +984,8 @@ TEST (wallet, deterministic_restore)
auto prv = nano::deterministic_key (seed1, index);
pub = nano::pub_key (prv);
}
wallet->insert_adhoc (nano::dev_genesis_key.prv, false);
auto block (wallet->send_action (nano::dev_genesis_key.pub, pub, 100));
wallet->insert_adhoc (nano::dev::genesis_key.prv, false);
auto block (wallet->send_action (nano::dev::genesis_key.pub, pub, 100));
ASSERT_NE (nullptr, block);
system.nodes[0]->block_processor.flush ();
{
@ -1006,7 +1006,7 @@ TEST (wallet, epoch_2_validation)
ASSERT_NE (nullptr, system.upgrade_genesis_epoch (node, nano::epoch::epoch_1));
ASSERT_NE (nullptr, system.upgrade_genesis_epoch (node, nano::epoch::epoch_2));
wallet.insert_adhoc (nano::dev_genesis_key.prv, false);
wallet.insert_adhoc (nano::dev::genesis_key.prv, false);
// Test send and receive blocks
// An epoch 2 receive block should be generated with lower difficulty with high probability
@ -1015,12 +1015,12 @@ TEST (wallet, epoch_2_validation)
auto amount = node.config.receive_minimum.number ();
while (++tries < max_tries)
{
auto send = wallet.send_action (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub, amount, 1);
auto send = wallet.send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, amount, 1);
ASSERT_NE (nullptr, send);
ASSERT_EQ (nano::epoch::epoch_2, send->sideband ().details.epoch);
ASSERT_EQ (nano::epoch::epoch_0, send->sideband ().source_epoch); // Not used for send state blocks
auto receive = wallet.receive_action (send->hash (), nano::dev_genesis_key.pub, amount, send->link ().as_account (), 1);
auto receive = wallet.receive_action (send->hash (), nano::dev::genesis_key.pub, amount, send->link ().as_account (), 1);
ASSERT_NE (nullptr, receive);
if (receive->difficulty () < node.network_params.network.publish_thresholds.base)
{
@ -1033,7 +1033,7 @@ TEST (wallet, epoch_2_validation)
ASSERT_LT (tries, max_tries);
// Test a change block
ASSERT_NE (nullptr, wallet.change_action (nano::dev_genesis_key.pub, nano::keypair ().pub, 1));
ASSERT_NE (nullptr, wallet.change_action (nano::dev::genesis_key.pub, nano::keypair ().pub, 1));
}
// Receiving from an upgraded account uses the lower threshold and upgrades the receiving account
@ -1057,19 +1057,19 @@ TEST (wallet, epoch_2_receive_propagation)
nano::state_block_builder builder;
// Send and open the account
wallet.insert_adhoc (nano::dev_genesis_key.prv, false);
wallet.insert_adhoc (nano::dev::genesis_key.prv, false);
wallet.insert_adhoc (key.prv, false);
auto amount = node.config.receive_minimum.number ();
auto send1 = wallet.send_action (nano::dev_genesis_key.pub, key.pub, amount, 1);
auto send1 = wallet.send_action (nano::dev::genesis_key.pub, key.pub, amount, 1);
ASSERT_NE (nullptr, send1);
ASSERT_NE (nullptr, wallet.receive_action (send1->hash (), nano::dev_genesis_key.pub, amount, send1->link ().as_account (), 1));
ASSERT_NE (nullptr, wallet.receive_action (send1->hash (), nano::dev::genesis_key.pub, amount, send1->link ().as_account (), 1));
// Upgrade the genesis account to epoch 2
auto epoch2 = system.upgrade_genesis_epoch (node, nano::epoch::epoch_2);
ASSERT_NE (nullptr, epoch2);
// Send a block
auto send2 = wallet.send_action (nano::dev_genesis_key.pub, key.pub, amount, 1);
auto send2 = wallet.send_action (nano::dev::genesis_key.pub, key.pub, amount, 1);
ASSERT_NE (nullptr, send2);
auto receive2 = wallet.receive_action (send2->hash (), key.pub, amount, send2->link ().as_account (), 1);
@ -1107,12 +1107,12 @@ TEST (wallet, epoch_2_receive_unopened)
nano::state_block_builder builder;
// Send
wallet.insert_adhoc (nano::dev_genesis_key.prv, false);
wallet.insert_adhoc (nano::dev::genesis_key.prv, false);
auto amount = node.config.receive_minimum.number ();
auto send1 = wallet.send_action (nano::dev_genesis_key.pub, key.pub, amount, 1);
auto send1 = wallet.send_action (nano::dev::genesis_key.pub, key.pub, amount, 1);
// Upgrade unopened account to epoch_2
auto epoch2_unopened = nano::state_block (key.pub, 0, 0, 0, node.network_params.ledger.epochs.link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (key.pub, node.network_params.network.publish_thresholds.epoch_2));
auto epoch2_unopened = nano::state_block (key.pub, 0, 0, 0, node.network_params.ledger.epochs.link (nano::epoch::epoch_2), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (key.pub, node.network_params.network.publish_thresholds.epoch_2));
ASSERT_EQ (nano::process_result::progress, node.process (epoch2_unopened).code);
wallet.insert_adhoc (key.prv, false);
@ -1134,7 +1134,7 @@ TEST (wallet, foreach_representative_deadlock)
{
nano::system system (1);
auto & node (*system.nodes[0]);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
node.wallets.compute_reps ();
ASSERT_EQ (1, node.wallets.reps ().voting);
node.wallets.foreach_representative ([&node] (nano::public_key const & pub, nano::raw_key const & prv) {
@ -1160,16 +1160,16 @@ TEST (wallet, search_pending)
auto & node (*system.add_node (config, flags));
auto & wallet (*system.wallet (0));
wallet.insert_adhoc (nano::dev_genesis_key.prv);
wallet.insert_adhoc (nano::dev::genesis_key.prv);
nano::block_builder builder;
auto send = builder.state ()
.account (nano::genesis_account)
.previous (nano::genesis_hash)
.representative (nano::genesis_account)
.balance (nano::genesis_amount - node.config.receive_minimum.number ())
.link (nano::genesis_account)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.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 ())
.link (nano::dev::genesis->account ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
@ -1180,7 +1180,7 @@ TEST (wallet, search_pending)
ASSERT_NE (nullptr, election);
// Erase the key so the confirmation does not trigger an automatic receive
wallet.store.erase (node.wallets.tx_begin_write (), nano::genesis_account);
wallet.store.erase (node.wallets.tx_begin_write (), nano::dev::genesis->account ());
// Now confirm the election
election->force_confirm ();
@ -1188,13 +1188,13 @@ TEST (wallet, search_pending)
ASSERT_TIMELY (5s, node.block_confirmed (send->hash ()) && node.active.empty ());
// Re-insert the key
wallet.insert_adhoc (nano::dev_genesis_key.prv);
wallet.insert_adhoc (nano::dev::genesis_key.prv);
// 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::genesis_account) == nano::genesis_amount);
auto receive_hash = node.ledger.latest (node.store.tx_begin_read (), nano::genesis_account);
ASSERT_TIMELY (3s, node.balance (nano::dev::genesis->account ()) == nano::dev::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);
ASSERT_EQ (receive->sideband ().height, 3);
@ -1219,10 +1219,10 @@ TEST (wallet, receive_pruned)
nano::state_block_builder builder;
// Send
wallet1.insert_adhoc (nano::dev_genesis_key.prv, false);
wallet1.insert_adhoc (nano::dev::genesis_key.prv, false);
auto amount = node2.config.receive_minimum.number ();
auto send1 = wallet1.send_action (nano::dev_genesis_key.pub, key.pub, amount, 1);
auto send2 = wallet1.send_action (nano::dev_genesis_key.pub, key.pub, 1, 1);
auto send1 = wallet1.send_action (nano::dev::genesis_key.pub, key.pub, amount, 1);
auto send2 = wallet1.send_action (nano::dev::genesis_key.pub, key.pub, 1, 1);
// Pruning
ASSERT_TIMELY (5s, node2.ledger.cache.cemented_count == 3);

30
nano/core_test/wallets.cpp
View file

@ -98,12 +98,12 @@ TEST (wallets, vote_minimum)
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, 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 ()));
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);
// send2 with amount vote_minimum - 1 (not voting representative)
nano::state_block send2 (nano::dev_genesis_key.pub, send1.hash (), nano::dev_genesis_key.pub, std::numeric_limits<nano::uint128_t>::max () - 2 * node1.config.vote_minimum.number () + 1, key2.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1.hash ()));
nano::state_block send2 (nano::dev::genesis_key.pub, send1.hash (), nano::dev::genesis_key.pub, std::numeric_limits<nano::uint128_t>::max () - 2 * node1.config.vote_minimum.number () + 1, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ()));
ASSERT_EQ (nano::process_result::progress, node1.process (send2).code);
nano::state_block open2 (key2.pub, 0, key2.pub, node1.config.vote_minimum.number () - 1, send2.hash (), key2.prv, key2.pub, *system.work.generate (key2.pub));
ASSERT_EQ (nano::process_result::progress, node1.process (open2).code);
@ -111,7 +111,7 @@ TEST (wallets, vote_minimum)
nano::unique_lock<nano::mutex> representatives_lk (wallet->representatives_mutex);
ASSERT_EQ (0, wallet->representatives.size ());
representatives_lk.unlock ();
wallet->insert_adhoc (nano::dev_genesis_key.prv);
wallet->insert_adhoc (nano::dev::genesis_key.prv);
wallet->insert_adhoc (key1.prv);
wallet->insert_adhoc (key2.prv);
node1.wallets.compute_reps ();
@ -163,16 +163,16 @@ TEST (wallets, search_pending)
auto wallet_id = wallets.begin ()->first;
auto wallet = wallets.begin ()->second;
wallet->insert_adhoc (nano::dev_genesis_key.prv);
wallet->insert_adhoc (nano::dev::genesis_key.prv);
nano::block_builder builder;
auto send = builder.state ()
.account (nano::genesis_account)
.previous (nano::genesis_hash)
.representative (nano::genesis_account)
.balance (nano::genesis_amount - node.config.receive_minimum.number ())
.link (nano::genesis_account)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.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 ())
.link (nano::dev::genesis->account ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
@ -190,7 +190,7 @@ TEST (wallets, search_pending)
ASSERT_NE (nullptr, election);
// Erase the key so the confirmation does not trigger an automatic receive
wallet->store.erase (node.wallets.tx_begin_write (), nano::genesis_account);
wallet->store.erase (node.wallets.tx_begin_write (), nano::dev::genesis->account ());
// Now confirm the election
election->force_confirm ();
@ -198,7 +198,7 @@ TEST (wallets, search_pending)
ASSERT_TIMELY (5s, node.block_confirmed (send->hash ()) && node.active.empty ());
// Re-insert the key
wallet->insert_adhoc (nano::dev_genesis_key.prv);
wallet->insert_adhoc (nano::dev::genesis_key.prv);
// Pending search should create the receive block
ASSERT_EQ (2, node.ledger.cache.block_count);
@ -210,8 +210,8 @@ TEST (wallets, search_pending)
{
node.wallets.search_pending (wallet_id);
}
ASSERT_TIMELY (3s, node.balance (nano::genesis_account) == nano::genesis_amount);
auto receive_hash = node.ledger.latest (node.store.tx_begin_read (), nano::genesis_account);
ASSERT_TIMELY (3s, node.balance (nano::dev::genesis->account ()) == nano::dev::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);
ASSERT_EQ (receive->sideband ().height, 3);

118
nano/core_test/websocket.cpp
View file

@ -82,14 +82,14 @@ TEST (websocket, confirmation)
ASSERT_TIMELY (5s, ack_ready);
nano::keypair key;
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
auto balance = nano::genesis_amount;
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
auto balance = nano::dev::genesis_amount;
auto send_amount = node1->online_reps.delta () + 1;
// Quick-confirm a block, legacy blocks should work without filtering
{
nano::block_hash previous (node1->latest (nano::dev_genesis_key.pub));
nano::block_hash previous (node1->latest (nano::dev::genesis_key.pub));
balance -= send_amount;
auto send (std::make_shared<nano::send_block> (previous, key.pub, balance, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (previous)));
auto send (std::make_shared<nano::send_block> (previous, key.pub, balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous)));
node1->process_active (send);
}
@ -98,15 +98,15 @@ TEST (websocket, confirmation)
// Quick confirm a state block
{
nano::state_block_builder builder;
nano::block_hash previous (node1->latest (nano::dev_genesis_key.pub));
nano::block_hash previous (node1->latest (nano::dev::genesis_key.pub));
balance -= send_amount;
auto send = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (previous)
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (balance)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
@ -141,7 +141,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> (genesis.hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis.hash ())));
nano::publish publish1 (send1);
auto channel1 (node1->network.udp_channels.create (node1->network.endpoint ()));
node1->network.inbound (publish1, channel1);
@ -184,21 +184,21 @@ TEST (websocket, confirmation_options)
ASSERT_TIMELY (5s, ack_ready);
// Confirm a state block for an in-wallet account
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::keypair key;
auto balance = nano::genesis_amount;
auto balance = nano::dev::genesis_amount;
auto send_amount = node1->online_reps.delta () + 1;
nano::block_hash previous (node1->latest (nano::dev_genesis_key.pub));
nano::block_hash previous (node1->latest (nano::dev::genesis_key.pub));
{
balance -= send_amount;
nano::state_block_builder builder;
auto send = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (previous)
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (balance)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
@ -226,12 +226,12 @@ TEST (websocket, confirmation_options)
balance -= send_amount;
nano::state_block_builder builder;
auto send = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (previous)
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (balance)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
@ -288,7 +288,7 @@ TEST (websocket, confirmation_options)
// When filtering options are enabled, legacy blocks are always filtered
{
balance -= send_amount;
auto send (std::make_shared<nano::send_block> (previous, key.pub, balance, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (previous)));
auto send (std::make_shared<nano::send_block> (previous, key.pub, balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous)));
node1->process_active (send);
previous = send->hash ();
}
@ -318,21 +318,21 @@ TEST (websocket, confirmation_options_votes)
ASSERT_TIMELY (10s, ack_ready);
// Confirm a state block for an in-wallet account
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::keypair key;
auto balance = nano::genesis_amount;
auto balance = nano::dev::genesis_amount;
auto send_amount = node1->config.online_weight_minimum.number () + 1;
nano::block_hash previous (node1->latest (nano::dev_genesis_key.pub));
nano::block_hash previous (node1->latest (nano::dev::genesis_key.pub));
{
nano::state_block_builder builder;
balance -= send_amount;
auto send = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (previous)
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (balance)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
@ -368,13 +368,13 @@ TEST (websocket, confirmation_options_votes)
for (auto & vote : votes_l.get ())
{
std::string representative (vote.second.get<std::string> ("representative"));
ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), representative);
ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), representative);
std::string timestamp (vote.second.get<std::string> ("timestamp"));
ASSERT_NE ("0", timestamp);
std::string hash (vote.second.get<std::string> ("hash"));
ASSERT_EQ (node1->latest (nano::dev_genesis_key.pub).to_string (), hash);
ASSERT_EQ (node1->latest (nano::dev::genesis_key.pub).to_string (), hash);
std::string weight (vote.second.get<std::string> ("weight"));
ASSERT_EQ (node1->balance (nano::dev_genesis_key.pub).convert_to<std::string> (), weight);
ASSERT_EQ (node1->balance (nano::dev::genesis_key.pub).convert_to<std::string> (), weight);
}
}
catch (std::runtime_error const & ex)
@ -401,14 +401,14 @@ TEST (websocket, confirmation_options_update)
client.await_ack ();
EXPECT_EQ (1, node1->websocket_server->subscriber_count (nano::websocket::topic::confirmation));
// Now update filter with an account and wait for a response
std::string add_message = boost::str (boost::format (R"json({"action": "update", "topic": "confirmation", "ack": "true", "options": {"accounts_add": ["%1%"]}})json") % nano::dev_genesis_key.pub.to_account ());
std::string add_message = boost::str (boost::format (R"json({"action": "update", "topic": "confirmation", "ack": "true", "options": {"accounts_add": ["%1%"]}})json") % nano::dev::genesis_key.pub.to_account ());
client.send_message (add_message);
client.await_ack ();
EXPECT_EQ (1, node1->websocket_server->subscriber_count (nano::websocket::topic::confirmation));
added = true;
EXPECT_TRUE (client.get_response ());
// Update the filter again, removing the account
std::string delete_message = boost::str (boost::format (R"json({"action": "update", "topic": "confirmation", "ack": "true", "options": {"accounts_del": ["%1%"]}})json") % nano::dev_genesis_key.pub.to_account ());
std::string delete_message = boost::str (boost::format (R"json({"action": "update", "topic": "confirmation", "ack": "true", "options": {"accounts_del": ["%1%"]}})json") % nano::dev::genesis_key.pub.to_account ());
client.send_message (delete_message);
client.await_ack ();
EXPECT_EQ (1, node1->websocket_server->subscriber_count (nano::websocket::topic::confirmation));
@ -421,18 +421,18 @@ TEST (websocket, confirmation_options_update)
ASSERT_TIMELY (5s, added);
// Confirm a block
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
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));
auto previous (node1->latest (nano::dev::genesis_key.pub));
auto send = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (previous)
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - nano::Gxrb_ratio)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
@ -445,12 +445,12 @@ TEST (websocket, confirmation_options_update)
previous = send->hash ();
auto send2 = builder
.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (previous)
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 2 * nano::Gxrb_ratio)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - 2 * nano::Gxrb_ratio)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
@ -484,15 +484,15 @@ TEST (websocket, vote)
// Quick-confirm a block
nano::keypair key;
nano::state_block_builder builder;
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
nano::block_hash previous (node1->latest (nano::dev_genesis_key.pub));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::block_hash previous (node1->latest (nano::dev::genesis_key.pub));
auto send = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (previous)
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - (node1->online_reps.delta () + 1))
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::genesis_amount - (node1->online_reps.delta () + 1))
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
@ -533,7 +533,7 @@ TEST (websocket, vote_options_type)
// 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, genesis.open));
nano::websocket::message_builder builder;
auto msg (builder.vote_received (vote, nano::vote_code::replay));
node1->websocket_server->broadcast (msg);
@ -563,7 +563,7 @@ TEST (websocket, vote_options_representatives)
std::atomic<bool> ack_ready{ false };
auto task1 = ([&ack_ready, config, &node1] () {
fake_websocket_client client (config.websocket_config.port);
std::string message = boost::str (boost::format (R"json({"action": "subscribe", "topic": "vote", "ack": "true", "options": {"representatives": ["%1%"]}})json") % nano::dev_genesis_key.pub.to_account ());
std::string message = boost::str (boost::format (R"json({"action": "subscribe", "topic": "vote", "ack": "true", "options": {"representatives": ["%1%"]}})json") % nano::dev::genesis_key.pub.to_account ());
client.send_message (message);
client.await_ack ();
ack_ready = true;
@ -582,20 +582,20 @@ TEST (websocket, vote_options_representatives)
// Quick-confirm a block
nano::keypair key;
auto balance = nano::genesis_amount;
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
auto balance = nano::dev::genesis_amount;
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
auto send_amount = node1->online_reps.delta () + 1;
auto confirm_block = [&] () {
nano::block_hash previous (node1->latest (nano::dev_genesis_key.pub));
nano::block_hash previous (node1->latest (nano::dev::genesis_key.pub));
balance -= send_amount;
nano::state_block_builder builder;
auto send = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (previous)
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (balance)
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
node1->process_active (send);
@ -915,12 +915,12 @@ TEST (websocket, new_unconfirmed_block)
// Process a new block
nano::genesis genesis;
auto send1 = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis.hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 1)
.link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (nano::dev::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 ()))
.build_shared ();

4
nano/load_test/entry.cpp
View file

@ -406,7 +406,7 @@ int main (int argc, char * const * argv)
std::string wallet = wallet_create_rpc (ioc, primary_node_results);
// Add genesis account to it
wallet_add_rpc (ioc, primary_node_results, wallet, nano::dev_genesis_key.prv.to_string ());
wallet_add_rpc (ioc, primary_node_results, wallet, nano::dev::genesis_key.prv.to_string ());
// Add destination accounts
for (auto & account : destination_accounts)
@ -437,7 +437,7 @@ int main (int argc, char * const * argv)
// Send from genesis account to different accounts and receive the funds
boost::asio::spawn (ioc, [&ioc, &primary_node_results, &wallet, destination_account, &send_calls_remaining] (boost::asio::yield_context yield) {
send_receive (ioc, wallet, nano::genesis_account.to_account (), destination_account->as_string, send_calls_remaining, primary_node_results, yield);
send_receive (ioc, wallet, nano::dev::genesis->account ().to_account (), destination_account->as_string, send_calls_remaining, primary_node_results, yield);
});
}

32
nano/nano_node/entry.cpp
View file

@ -899,7 +899,7 @@ int main (int argc, char * const * argv)
nano::inactive_node inactive_node (nano::unique_path (), data_path, node_flags);
auto node = inactive_node.node;
nano::block_hash genesis_latest (node->latest (dev_params.ledger.dev_genesis_key.pub));
nano::block_hash genesis_latest (node->latest (nano::dev::genesis_key.pub));
nano::uint128_t genesis_balance (std::numeric_limits<nano::uint128_t>::max ());
// Generating keys
std::vector<nano::keypair> keys (num_accounts);
@ -912,12 +912,12 @@ int main (int argc, char * const * argv)
genesis_balance = genesis_balance - 1000000000;
auto send = builder.state ()
.account (dev_params.ledger.dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis_latest)
.representative (dev_params.ledger.dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (genesis_balance)
.link (keys[i].pub)
.sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1))
.build ();
@ -1016,7 +1016,7 @@ int main (int argc, char * const * argv)
nano::node_wrapper node_wrapper (nano::unique_path (), data_path, node_flags);
auto node = node_wrapper.node;
nano::block_hash genesis_latest (node->latest (dev_params.ledger.dev_genesis_key.pub));
nano::block_hash genesis_latest (node->latest (nano::dev::genesis_key.pub));
nano::uint128_t genesis_balance (std::numeric_limits<nano::uint128_t>::max ());
// Generating keys
std::vector<nano::keypair> keys (num_representatives);
@ -1027,12 +1027,12 @@ int main (int argc, char * const * argv)
genesis_balance = genesis_balance - balance;
auto send = builder.state ()
.account (dev_params.ledger.dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis_latest)
.representative (dev_params.ledger.dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (genesis_balance)
.link (keys[i].pub)
.sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1))
.build ();
@ -1059,12 +1059,12 @@ int main (int argc, char * const * argv)
nano::keypair destination;
auto send = builder.state ()
.account (dev_params.ledger.dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis_latest)
.representative (dev_params.ledger.dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (genesis_balance)
.link (destination.pub)
.sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1))
.build ();
@ -1156,7 +1156,7 @@ int main (int argc, char * const * argv)
flags.disable_wallet_bootstrap = true;
flags.disable_bootstrap_listener = true;
auto node1 (std::make_shared<nano::node> (io_ctx1, path1, config1, work, flags, 0));
nano::block_hash genesis_latest (node1->latest (dev_params.ledger.dev_genesis_key.pub));
nano::block_hash genesis_latest (node1->latest (nano::dev::genesis_key.pub));
nano::uint128_t genesis_balance (std::numeric_limits<nano::uint128_t>::max ());
// Generating blocks
std::deque<std::shared_ptr<nano::block>> blocks;
@ -1166,12 +1166,12 @@ int main (int argc, char * const * argv)
genesis_balance = genesis_balance - 1;
auto send = builder.state ()
.account (dev_params.ledger.dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (genesis_latest)
.representative (dev_params.ledger.dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.balance (genesis_balance)
.link (key.pub)
.sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*work.generate (nano::work_version::work_1, genesis_latest, dev_params.network.publish_thresholds.epoch_1))
.build ();
@ -1264,7 +1264,7 @@ int main (int argc, char * const * argv)
// Insert representative
std::cout << "Initializing representative\n";
auto wallet (node1->wallets.create (nano::random_wallet_id ()));
wallet->insert_adhoc (dev_params.ledger.dev_genesis_key.prv);
wallet->insert_adhoc (nano::dev::genesis_key.prv);
node2->network.merge_peer (node1->network.endpoint ());
while (node2->rep_crawler.representative_count () == 0)
{

6
nano/node/json_handler.cpp
View file

@ -1042,7 +1042,7 @@ void nano::json_handler::available_supply ()
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 (node.network_params.ledger.genesis_amount - genesis_balance - landing_balance - faucet_balance - burned_balance);
auto available (nano::dev::genesis_amount - genesis_balance - landing_balance - faucet_balance - burned_balance);
response_l.put ("available", available.convert_to<std::string> ());
response_errors ();
}
@ -2332,7 +2332,7 @@ public:
else
{
tree.put ("account", network_params.ledger.genesis_account ().to_account ());
tree.put ("amount", network_params.ledger.genesis_amount.convert_to<std::string> ());
tree.put ("amount", nano::dev::genesis_amount.convert_to<std::string> ());
}
}
void change_block (nano::change_block const & block_a)
@ -3260,7 +3260,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, node.network_params.ledger.genesis_amount, account, [response_a] (std::shared_ptr<nano::block> const & block_a) {
hash, representative, nano::dev::genesis_amount, account, [response_a] (std::shared_ptr<nano::block> const & block_a) {
if (block_a != nullptr)
{
boost::property_tree::ptree response_l;

2
nano/node/node.cpp
View file

@ -1331,7 +1331,7 @@ void nano::node::process_confirmed_data (nano::transaction const & transaction_a
}
else
{
amount_a = ledger.network_params.ledger.genesis_amount;
amount_a = nano::dev::genesis_amount;
}
if (auto state = dynamic_cast<nano::state_block *> (block_a.get ()))
{

2
nano/qt/qt.cpp
View file

@ -557,7 +557,7 @@ public:
else
{
account = params.ledger.genesis_account ();
amount = params.ledger.genesis_amount;
amount = nano::dev::genesis_amount;
}
}
void change_block (nano::change_block const & block_a)

94
nano/qt_test/qt.cpp
View file

@ -291,9 +291,9 @@ TEST (wallet, send)
{
nano_qt::eventloop_processor processor;
nano::system system (2);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::public_key key1 (system.wallet (1)->insert_adhoc (nano::keypair ().prv));
auto account (nano::dev_genesis_key.pub);
auto account (nano::dev::genesis_key.pub);
auto wallet (std::make_shared<nano_qt::wallet> (*test_application, processor, *system.nodes[0], system.wallet (0), account));
wallet->start ();
ASSERT_NE (wallet->rendering_ratio, nano::raw_ratio);
@ -324,13 +324,13 @@ TEST (wallet, send_locked)
{
nano_qt::eventloop_processor processor;
nano::system system (1);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::keypair key1;
{
auto transaction (system.wallet (0)->wallets.tx_begin_write ());
system.wallet (0)->enter_password (transaction, "0");
}
auto account (nano::dev_genesis_key.pub);
auto account (nano::dev::genesis_key.pub);
auto wallet (std::make_shared<nano_qt::wallet> (*test_application, processor, *system.nodes[0], system.wallet (0), account));
wallet->start ();
QTest::mouseClick (wallet->send_blocks, Qt::LeftButton);
@ -350,7 +350,7 @@ TEST (wallet, process_block)
nano_qt::eventloop_processor processor;
nano::system system (1);
nano::account account;
nano::block_hash latest (system.nodes[0]->latest (nano::genesis_account));
nano::block_hash latest (system.nodes[0]->latest (nano::dev::genesis->account ()));
system.wallet (0)->insert_adhoc (nano::keypair ().prv);
{
auto transaction (system.nodes[0]->wallets.tx_begin_read ());
@ -365,7 +365,7 @@ TEST (wallet, process_block)
QTest::mouseClick (wallet->show_advanced, Qt::LeftButton);
QTest::mouseClick (wallet->advanced.enter_block, Qt::LeftButton);
ASSERT_EQ (wallet->block_entry.window, wallet->main_stack->currentWidget ());
nano::send_block send (latest, key1.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest));
nano::send_block send (latest, key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
std::string previous;
send.hashables.previous.encode_hex (previous);
std::string balance;
@ -394,16 +394,16 @@ TEST (wallet, create_send)
nano_qt::eventloop_processor processor;
nano::keypair key;
nano::system system (1);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
system.wallet (0)->insert_adhoc (key.prv);
auto account (nano::dev_genesis_key.pub);
auto account (nano::dev::genesis_key.pub);
auto wallet (std::make_shared<nano_qt::wallet> (*test_application, processor, *system.nodes[0], system.wallet (0), account));
wallet->start ();
wallet->client_window->show ();
QTest::mouseClick (wallet->show_advanced, Qt::LeftButton);
QTest::mouseClick (wallet->advanced.create_block, Qt::LeftButton);
QTest::mouseClick (wallet->block_creation.send, Qt::LeftButton);
QTest::keyClicks (wallet->block_creation.account, nano::dev_genesis_key.pub.to_account ().c_str ());
QTest::keyClicks (wallet->block_creation.account, nano::dev::genesis_key.pub.to_account ().c_str ());
QTest::keyClicks (wallet->block_creation.amount, "100000000000000000000");
QTest::keyClicks (wallet->block_creation.destination, key.pub.to_account ().c_str ());
QTest::mouseClick (wallet->block_creation.create, Qt::LeftButton);
@ -424,14 +424,14 @@ TEST (wallet, create_open_receive)
nano_qt::eventloop_processor processor;
nano::keypair key;
nano::system system (1);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, 100);
nano::block_hash latest1 (system.nodes[0]->latest (nano::dev_genesis_key.pub));
system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, 100);
nano::block_hash latest2 (system.nodes[0]->latest (nano::dev_genesis_key.pub));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, 100);
nano::block_hash latest1 (system.nodes[0]->latest (nano::dev::genesis_key.pub));
system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, 100);
nano::block_hash latest2 (system.nodes[0]->latest (nano::dev::genesis_key.pub));
ASSERT_NE (latest1, latest2);
system.wallet (0)->insert_adhoc (key.prv);
auto account (nano::dev_genesis_key.pub);
auto account (nano::dev::genesis_key.pub);
auto wallet (std::make_shared<nano_qt::wallet> (*test_application, processor, *system.nodes[0], system.wallet (0), account));
wallet->start ();
wallet->client_window->show ();
@ -439,7 +439,7 @@ TEST (wallet, create_open_receive)
QTest::mouseClick (wallet->advanced.create_block, Qt::LeftButton);
wallet->block_creation.open->click ();
QTest::keyClicks (wallet->block_creation.source, latest1.to_string ().c_str ());
QTest::keyClicks (wallet->block_creation.representative, nano::dev_genesis_key.pub.to_account ().c_str ());
QTest::keyClicks (wallet->block_creation.representative, nano::dev::genesis_key.pub.to_account ().c_str ());
QTest::mouseClick (wallet->block_creation.create, Qt::LeftButton);
std::string json1 (wallet->block_creation.block->toPlainText ().toStdString ());
ASSERT_FALSE (json1.empty ());
@ -473,15 +473,15 @@ TEST (wallet, create_change)
nano_qt::eventloop_processor processor;
nano::keypair key;
nano::system system (1);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
auto account (nano::dev_genesis_key.pub);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
auto account (nano::dev::genesis_key.pub);
auto wallet (std::make_shared<nano_qt::wallet> (*test_application, processor, *system.nodes[0], system.wallet (0), account));
wallet->start ();
wallet->client_window->show ();
QTest::mouseClick (wallet->show_advanced, Qt::LeftButton);
QTest::mouseClick (wallet->advanced.create_block, Qt::LeftButton);
wallet->block_creation.change->click ();
QTest::keyClicks (wallet->block_creation.account, nano::dev_genesis_key.pub.to_account ().c_str ());
QTest::keyClicks (wallet->block_creation.account, nano::dev::genesis_key.pub.to_account ().c_str ());
QTest::keyClicks (wallet->block_creation.representative, key.pub.to_account ().c_str ());
wallet->block_creation.create->click ();
std::string json (wallet->block_creation.block->toPlainText ().toStdString ());
@ -521,15 +521,15 @@ TEST (history, short_text)
auto transaction (store->tx_begin_write ());
store->initialize (transaction, ledger.cache);
nano::keypair key;
auto latest (ledger.latest (transaction, nano::dev_genesis_key.pub));
nano::send_block send (latest, nano::dev_genesis_key.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest));
auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub));
nano::send_block send (latest, nano::dev::genesis_key.pub, 0, 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);
nano::receive_block receive (send.hash (), send.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send.hash ()));
nano::receive_block receive (send.hash (), send.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive).code);
nano::change_block change (receive.hash (), key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (receive.hash ()));
nano::change_block change (receive.hash (), key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive.hash ()));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change).code);
}
nano_qt::history history (ledger, nano::dev_genesis_key.pub, *wallet);
nano_qt::history history (ledger, nano::dev::genesis_key.pub, *wallet);
history.refresh ();
ASSERT_EQ (4, history.model->rowCount ());
}
@ -561,19 +561,19 @@ 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::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest));
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));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code);
nano::send_block send2 (send1.hash (), key.pub, nano::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::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 ()));
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);
nano::open_block open (send2.hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code);
ASSERT_EQ (1, ledger.pruning_action (transaction, send1.hash (), 2));
next_pruning = send2.hash ();
}
nano_qt::history history1 (ledger, nano::dev_genesis_key.pub, *wallet);
nano_qt::history history1 (ledger, nano::dev::genesis_key.pub, *wallet);
history1.refresh ();
ASSERT_EQ (2, history1.model->rowCount ());
nano_qt::history history2 (ledger, key.pub, *wallet);
@ -591,8 +591,8 @@ TEST (history, pruned_source)
// Pruning for state blocks. Previous block is pruned, source is pruned
{
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::genesis_amount - 200, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest));
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));
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));
@ -623,7 +623,7 @@ TEST (wallet, startup_work)
uint64_t work1;
{
auto transaction (system.nodes[0]->wallets.tx_begin_read ());
ASSERT_TRUE (wallet->wallet_m->store.work_get (transaction, nano::dev_genesis_key.pub, work1));
ASSERT_TRUE (wallet->wallet_m->store.work_get (transaction, nano::dev::genesis_key.pub, work1));
}
QTest::mouseClick (wallet->accounts_button, Qt::LeftButton);
QTest::keyClicks (wallet->accounts.account_key_line, "34F0A37AAD20F4A260F0A5B3CB3D7FB50673212263E58A380BC10474BB039CE4");
@ -634,7 +634,7 @@ TEST (wallet, startup_work)
{
ASSERT_NO_ERROR (system.poll ());
auto transaction (system.nodes[0]->wallets.tx_begin_read ());
again = wallet->wallet_m->store.work_get (transaction, nano::dev_genesis_key.pub, work1);
again = wallet->wallet_m->store.work_get (transaction, nano::dev::genesis_key.pub, work1);
}
}
@ -655,7 +655,7 @@ TEST (wallet, block_viewer)
ASSERT_NE (-1, wallet->advanced.layout->indexOf (wallet->advanced.block_viewer));
QTest::mouseClick (wallet->advanced.block_viewer, Qt::LeftButton);
ASSERT_EQ (wallet->block_viewer.window, wallet->main_stack->currentWidget ());
nano::block_hash latest (system.nodes[0]->latest (nano::genesis_account));
nano::block_hash latest (system.nodes[0]->latest (nano::dev::genesis->account ()));
QTest::keyClicks (wallet->block_viewer.hash, latest.to_string ().c_str ());
QTest::mouseClick (wallet->block_viewer.retrieve, Qt::LeftButton);
ASSERT_FALSE (wallet->block_viewer.block->toPlainText ().toStdString ().empty ());
@ -701,17 +701,17 @@ TEST (wallet, republish)
{
nano_qt::eventloop_processor processor;
nano::system system (2);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::keypair key;
nano::block_hash hash;
{
auto transaction (system.nodes[0]->store.tx_begin_write ());
auto latest (system.nodes[0]->ledger.latest (transaction, nano::dev_genesis_key.pub));
nano::send_block block (latest, key.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest));
auto latest (system.nodes[0]->ledger.latest (transaction, nano::dev::genesis_key.pub));
nano::send_block block (latest, key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
hash = block.hash ();
ASSERT_EQ (nano::process_result::progress, system.nodes[0]->ledger.process (transaction, block).code);
}
auto account (nano::dev_genesis_key.pub);
auto account (nano::dev::genesis_key.pub);
auto wallet (std::make_shared<nano_qt::wallet> (*test_application, processor, *system.nodes[0], system.wallet (0), account));
wallet->start ();
QTest::mouseClick (wallet->show_advanced, Qt::LeftButton);
@ -720,9 +720,9 @@ TEST (wallet, republish)
ASSERT_EQ (wallet->block_viewer.window, wallet->main_stack->currentWidget ());
QTest::keyClicks (wallet->block_viewer.hash, hash.to_string ().c_str ());
QTest::mouseClick (wallet->block_viewer.rebroadcast, Qt::LeftButton);
ASSERT_FALSE (system.nodes[1]->balance (nano::dev_genesis_key.pub).is_zero ());
ASSERT_FALSE (system.nodes[1]->balance (nano::dev::genesis_key.pub).is_zero ());
system.deadline_set (10s);
while (system.nodes[1]->balance (nano::dev_genesis_key.pub).is_zero ())
while (system.nodes[1]->balance (nano::dev::genesis_key.pub).is_zero ())
{
ASSERT_NO_ERROR (system.poll ());
}
@ -740,7 +740,7 @@ TEST (wallet, ignore_empty_adhoc)
ASSERT_EQ (wallet->advanced.window, wallet->main_stack->currentWidget ());
QTest::mouseClick (wallet->accounts_button, Qt::LeftButton);
ASSERT_EQ (wallet->accounts.window, wallet->main_stack->currentWidget ());
QTest::keyClicks (wallet->accounts.account_key_line, nano::dev_genesis_key.prv.to_string ().c_str ());
QTest::keyClicks (wallet->accounts.account_key_line, nano::dev::genesis_key.prv.to_string ().c_str ());
QTest::mouseClick (wallet->accounts.account_key_button, Qt::LeftButton);
ASSERT_EQ (1, wallet->accounts.model->rowCount ());
ASSERT_EQ (0, wallet->accounts.account_key_line->text ().length ());
@ -906,8 +906,8 @@ TEST (wallet, DISABLED_synchronizing)
wallet->start ();
{
auto transaction (system1.nodes[0]->store.tx_begin_write ());
auto latest (system1.nodes[0]->ledger.latest (transaction, nano::genesis_account));
nano::send_block send (latest, key1, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system1.work.generate (latest));
auto latest (system1.nodes[0]->ledger.latest (transaction, nano::dev::genesis->account ()));
nano::send_block send (latest, key1, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system1.work.generate (latest));
system1.nodes[0]->ledger.process (transaction, send);
}
ASSERT_EQ (0, wallet->active_status.active.count (nano_qt::status_types::synchronizing));
@ -938,9 +938,9 @@ TEST (wallet, epoch_2_validation)
ASSERT_NE (nullptr, system.upgrade_genesis_epoch (*node, nano::epoch::epoch_1));
ASSERT_NE (nullptr, system.upgrade_genesis_epoch (*node, nano::epoch::epoch_2));
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
auto account (nano::dev_genesis_key.pub);
auto account (nano::dev::genesis_key.pub);
auto wallet (std::make_shared<nano_qt::wallet> (*test_application, processor, *node, system.wallet (0), account));
wallet->start ();
wallet->client_window->show ();
@ -964,7 +964,7 @@ TEST (wallet, epoch_2_validation)
auto do_send = [&] (nano::public_key const & destination) -> nano::block_hash {
wallet->block_creation.send->click ();
wallet->block_creation.account->setText (nano::dev_genesis_key.pub.to_account ().c_str ());
wallet->block_creation.account->setText (nano::dev::genesis_key.pub.to_account ().c_str ());
wallet->block_creation.amount->setText ("1");
wallet->block_creation.destination->setText (destination.to_account ().c_str ());
return create_and_process ();
@ -1002,6 +1002,6 @@ TEST (wallet, epoch_2_validation)
do_open (send1, key.pub);
auto send2 = do_send (key.pub);
do_receive (send2);
do_change (key.pub, nano::dev_genesis_key.pub);
do_change (key.pub, nano::dev::genesis_key.pub);
}
}

848
nano/rpc_test/rpc.cpp
View file

File diff suppressed because it is too large Load diff

10
nano/secure/common.cpp
View file

@ -79,6 +79,11 @@ 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::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)
{
@ -104,8 +109,6 @@ nano::ledger_constants::ledger_constants (nano::network_constants & network_cons
nano::ledger_constants::ledger_constants (nano::networks network_a) :
zero_key ("0"),
dev_genesis_key (dev_private_key_data),
nano_dev_account (dev_public_key_data),
nano_beta_account (beta_public_key_data),
nano_live_account (live_public_key_data),
nano_test_account (test_public_key_data),
@ -114,7 +117,6 @@ 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),
@ -136,7 +138,7 @@ nano::ledger_constants::ledger_constants (nano::networks network_a) :
nano::account nano_live_epoch_v2_signer;
auto error (nano_live_epoch_v2_signer.decode_account ("nano_3qb6o6i1tkzr6jwr5s7eehfxwg9x6eemitdinbpi7u8bjjwsgqfj4wzser3x"));
debug_assert (!error);
auto epoch_v2_signer (network_a == nano::networks::nano_dev_network ? nano_dev_account : network_a == nano::networks::nano_beta_network ? nano_beta_account : network_a == nano::networks::nano_test_network ? nano_test_account : nano_live_epoch_v2_signer);
auto epoch_v2_signer (network_a == nano::networks::nano_dev_network ? nano::dev::genesis_key.pub : network_a == nano::networks::nano_beta_network ? nano_beta_account : network_a == nano::networks::nano_test_network ? nano_test_account : nano_live_epoch_v2_signer);
const char * epoch_message_v2 ("epoch v2 block");
strncpy ((char *)epoch_link_v2.bytes.data (), epoch_message_v2, epoch_link_v2.bytes.size ());
epochs.add (nano::epoch::epoch_2, epoch_v2_signer, epoch_link_v2);

11
nano/secure/common.hpp
View file

@ -371,8 +371,6 @@ public:
nano::account genesis_account () const;
nano::block_hash genesis_hash () const;
nano::keypair zero_key;
nano::keypair dev_genesis_key;
nano::account nano_dev_account;
nano::account nano_beta_account;
nano::account nano_live_account;
nano::account nano_test_account;
@ -381,7 +379,6 @@ 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;
@ -396,6 +393,14 @@ public:
nano::epochs epochs;
};
namespace dev
{
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) */
class random_constants
{

2
nano/secure/ledger.cpp
View file

@ -1103,7 +1103,7 @@ nano::account nano::ledger::account_safe (nano::transaction const & transaction_
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 network_params.ledger.genesis_amount;
return nano::dev::genesis_amount;
}
nano::uint128_t nano::ledger::amount (nano::transaction const & transaction_a, nano::block_hash const & hash_a)

2
nano/secure/store_partial.hpp
View file

@ -108,7 +108,7 @@ public:
auto & genesis = *network_params.ledger.genesis;
auto hash_l (genesis.hash ());
debug_assert (account.begin (transaction_a) == account.end ());
genesis.sideband_set (nano::block_sideband (network_params.ledger.genesis_account (), 0, network_params.ledger.genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0));
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);
++ledger_cache_a.block_count;
confirmation_height.put (transaction_a, network_params.ledger.genesis_account (), nano::confirmation_height_info{ 1, genesis.hash () });

152
nano/slow_test/node.cpp
View file

@ -22,7 +22,7 @@ TEST (system, generate_mass_activity)
nano::node_config node_config (nano::get_available_port (), system.logging);
node_config.enable_voting = false; // Prevent blocks cementing
auto node = system.add_node (node_config);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
uint32_t count (20);
system.generate_mass_activity (count, *system.nodes[0]);
auto transaction (system.nodes[0]->store.tx_begin_read ());
@ -38,7 +38,7 @@ TEST (system, generate_mass_activity_long)
node_config.enable_voting = false; // Prevent blocks cementing
auto node = system.add_node (node_config);
nano::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
uint32_t count (1000000000);
system.generate_mass_activity (count, *system.nodes[0]);
auto transaction (system.nodes[0]->store.tx_begin_read ());
@ -58,20 +58,20 @@ TEST (system, receive_while_synchronizing)
node_config.enable_voting = false; // Prevent blocks cementing
auto node = system.add_node (node_config);
nano::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
uint32_t count (1000);
system.generate_mass_activity (count, *system.nodes[0]);
nano::keypair key;
auto node1 (std::make_shared<nano::node> (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work));
ASSERT_FALSE (node1->init_error ());
auto wallet (node1->wallets.create (1));
wallet->insert_adhoc (nano::dev_genesis_key.prv); // For voting
wallet->insert_adhoc (nano::dev::genesis_key.prv); // For voting
ASSERT_EQ (key.pub, wallet->insert_adhoc (key.prv));
node1->start ();
system.nodes.push_back (node1);
ASSERT_NE (nullptr, nano::establish_tcp (system, *node1, node->network.endpoint ()));
node1->workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (200), ([&system, &key] () {
auto hash (system.wallet (0)->send_sync (nano::dev_genesis_key.pub, key.pub, system.nodes[0]->config.receive_minimum.number ()));
auto hash (system.wallet (0)->send_sync (nano::dev::genesis_key.pub, key.pub, system.nodes[0]->config.receive_minimum.number ()));
auto transaction (system.nodes[0]->store.tx_begin_read ());
auto block (system.nodes[0]->store.block.get (transaction, hash));
std::string block_text;
@ -100,17 +100,17 @@ TEST (ledger, deep_account_compute)
store->initialize (transaction, ledger.cache);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key;
auto balance (nano::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::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 ()));
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));
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);
auto sprevious (send.hash ());
auto rprevious (open.hash ());
for (auto i (0), n (100000); i != n; ++i)
{
balance -= 1;
nano::send_block send (sprevious, key.pub, balance, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (sprevious));
nano::send_block send (sprevious, key.pub, balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (sprevious));
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code);
sprevious = send.hash ();
nano::receive_block receive (rprevious, send.hash (), key.prv, key.pub, *pool.generate (rprevious));
@ -132,21 +132,21 @@ TEST (wallet, multithreaded_send_async)
nano::system system (1);
nano::keypair key;
auto wallet_l (system.wallet (0));
wallet_l->insert_adhoc (nano::dev_genesis_key.prv);
wallet_l->insert_adhoc (nano::dev::genesis_key.prv);
wallet_l->insert_adhoc (key.prv);
for (auto i (0); i < 20; ++i)
{
threads.push_back (boost::thread ([wallet_l, &key] () {
for (auto i (0); i < 1000; ++i)
{
wallet_l->send_async (nano::dev_genesis_key.pub, key.pub, 1000, [] (std::shared_ptr<nano::block> const & block_a) {
wallet_l->send_async (nano::dev::genesis_key.pub, key.pub, 1000, [] (std::shared_ptr<nano::block> const & block_a) {
ASSERT_FALSE (block_a == nullptr);
ASSERT_FALSE (block_a->hash ().is_zero ());
});
}
}));
}
ASSERT_TIMELY (1000s, system.nodes[0]->balance (nano::dev_genesis_key.pub) == (nano::genesis_amount - 20 * 1000 * 1000));
ASSERT_TIMELY (1000s, system.nodes[0]->balance (nano::dev::genesis_key.pub) == (nano::dev::genesis_amount - 20 * 1000 * 1000));
}
for (auto i (threads.begin ()), n (threads.end ()); i != n; ++i)
{
@ -186,15 +186,15 @@ TEST (node, fork_storm)
nano::node_flags flags;
flags.disable_max_peers_per_ip = true;
nano::system system (64, nano::transport::transport_type::tcp, flags);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
auto previous (system.nodes[0]->latest (nano::dev_genesis_key.pub));
auto balance (system.nodes[0]->balance (nano::dev_genesis_key.pub));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
auto previous (system.nodes[0]->latest (nano::dev::genesis_key.pub));
auto balance (system.nodes[0]->balance (nano::dev::genesis_key.pub));
ASSERT_FALSE (previous.is_zero ());
for (auto j (0); j != system.nodes.size (); ++j)
{
balance -= 1;
nano::keypair key;
nano::send_block send (previous, key.pub, balance, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0);
nano::send_block send (previous, key.pub, balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0);
system.nodes[j]->work_generate_blocking (send);
previous = send.hash ();
for (auto i (0); i != system.nodes.size (); ++i)
@ -393,7 +393,7 @@ TEST (store, unchecked_load)
{
nano::system system (1);
auto & node (*system.nodes[0]);
auto block (std::make_shared<nano::send_block> (0, 0, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0));
auto block (std::make_shared<nano::send_block> (0, 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
constexpr auto num_unchecked = 1000000;
for (auto i (0); i < 1000000; ++i)
{
@ -408,10 +408,10 @@ TEST (store, vote_load)
{
nano::system system (1);
auto & node (*system.nodes[0]);
auto block (std::make_shared<nano::send_block> (0, 0, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0));
auto block (std::make_shared<nano::send_block> (0, 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
for (auto i (0); i < 1000000; ++i)
{
auto vote (std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, i, block));
auto vote (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, i, block));
node.vote_processor.vote (vote, std::make_shared<nano::transport::channel_loopback> (node));
}
}
@ -482,13 +482,13 @@ TEST (wallets, rep_scan)
TEST (node, mass_vote_by_hash)
{
nano::system system (1);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
nano::block_hash previous (nano::genesis_hash);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::block_hash previous (nano::dev::genesis->hash ());
nano::keypair key;
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::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::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);
}
@ -507,13 +507,13 @@ TEST (confirmation_height, many_accounts_single_confirmation)
node_config.online_weight_minimum = 100;
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto node = system.add_node (node_config);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
// The number of frontiers should be more than the nano::confirmation_height::unbounded_cutoff to test the amount of blocks confirmed is correct.
node->confirmation_height_processor.batch_write_size = 500;
auto const num_accounts = nano::confirmation_height::unbounded_cutoff * 2 + 50;
nano::keypair last_keypair = nano::dev_genesis_key;
auto last_open_hash = node->latest (nano::dev_genesis_key.pub);
nano::keypair last_keypair = nano::dev::genesis_key;
auto last_open_hash = node->latest (nano::dev::genesis_key.pub);
{
auto transaction = node->store.tx_begin_write ();
for (auto i = num_accounts - 1; i > 0; --i)
@ -577,11 +577,11 @@ TEST (confirmation_height, many_accounts_many_confirmations)
node_config.online_weight_minimum = 100;
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto node = system.add_node (node_config);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
node->confirmation_height_processor.batch_write_size = 500;
auto const num_accounts = nano::confirmation_height::unbounded_cutoff * 2 + 50;
auto latest_genesis = node->latest (nano::dev_genesis_key.pub);
auto latest_genesis = node->latest (nano::dev::genesis_key.pub);
std::vector<std::shared_ptr<nano::open_block>> open_blocks;
{
auto transaction = node->store.tx_begin_write ();
@ -590,9 +590,9 @@ TEST (confirmation_height, many_accounts_many_confirmations)
nano::keypair key;
system.wallet (0)->insert_adhoc (key.prv);
nano::send_block send (latest_genesis, key.pub, node->online_reps.delta (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest_genesis));
nano::send_block send (latest_genesis, key.pub, node->online_reps.delta (), 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));
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);
open_blocks.push_back (std::move (open));
latest_genesis = send.hash ();
@ -639,16 +639,16 @@ TEST (confirmation_height, long_chains)
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto node = system.add_node (node_config);
nano::keypair key1;
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
nano::block_hash latest (node->latest (nano::dev_genesis_key.pub));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::block_hash latest (node->latest (nano::dev::genesis_key.pub));
system.wallet (0)->insert_adhoc (key1.prv);
node->confirmation_height_processor.batch_write_size = 500;
auto const num_blocks = nano::confirmation_height::unbounded_cutoff * 2 + 50;
// First open the other account
nano::send_block send (latest, key1.pub, nano::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::genesis_account, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub));
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::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 ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
@ -662,7 +662,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::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::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);
@ -673,12 +673,12 @@ 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::genesis_account, nano::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)));
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)));
// 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::genesis_account, receive1->hash (), nano::genesis_account, nano::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::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 ();
@ -699,9 +699,9 @@ TEST (confirmation_height, long_chains)
auto transaction (node->store.tx_begin_read ());
nano::account_info account_info;
ASSERT_FALSE (node->store.account.get (transaction, nano::dev_genesis_key.pub, account_info));
ASSERT_FALSE (node->store.account.get (transaction, nano::dev::genesis_key.pub, account_info));
nano::confirmation_height_info confirmation_height_info;
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev_genesis_key.pub, confirmation_height_info));
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info));
ASSERT_EQ (num_blocks + 2, confirmation_height_info.height);
ASSERT_EQ (num_blocks + 3, account_info.block_count); // Includes the unpocketed send
@ -732,13 +732,13 @@ TEST (confirmation_height, dynamic_algorithm)
node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
auto node = system.add_node (node_config);
nano::keypair key;
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
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;
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::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::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);
}
@ -786,15 +786,15 @@ TEST (confirmation_height, dynamic_algorithm_no_transition_while_pending)
node_flags.force_use_write_database_queue = true;
auto node = system.add_node (node_config, node_flags);
nano::keypair key;
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
auto latest_genesis = node->latest (nano::dev_genesis_key.pub);
auto latest_genesis = node->latest (nano::dev::genesis_key.pub);
std::vector<std::shared_ptr<nano::state_block>> state_blocks;
auto const num_blocks = nano::confirmation_height::unbounded_cutoff - 2;
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::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::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);
@ -855,7 +855,7 @@ TEST (confirmation_height, many_accounts_send_receive_self)
nano::node_flags node_flags;
node_flags.confirmation_height_processor_mode = nano::confirmation_height_mode::unbounded;
auto node = system.add_node (node_config);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
#ifndef NDEBUG
auto const num_accounts = 10000;
@ -863,7 +863,7 @@ TEST (confirmation_height, many_accounts_send_receive_self)
auto const num_accounts = 100000;
#endif
auto latest_genesis = node->latest (nano::dev_genesis_key.pub);
auto latest_genesis = node->latest (nano::dev::genesis_key.pub);
std::vector<nano::keypair> keys;
std::vector<std::shared_ptr<nano::open_block>> open_blocks;
{
@ -873,9 +873,9 @@ TEST (confirmation_height, many_accounts_send_receive_self)
nano::keypair key;
keys.emplace_back (key);
nano::send_block send (latest_genesis, key.pub, nano::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::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));
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);
open_blocks.push_back (std::move (open));
latest_genesis = send.hash ();
@ -979,7 +979,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections)
auto const num_accounts = 100000;
auto latest_genesis = nano::genesis_hash;
auto latest_genesis = nano::dev::genesis->hash ();
std::vector<nano::keypair> keys;
std::vector<std::shared_ptr<nano::open_block>> open_blocks;
@ -994,9 +994,9 @@ 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::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::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));
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);
open_blocks.push_back (std::move (open));
latest_genesis = send.hash ();
@ -1077,11 +1077,11 @@ TEST (confirmation_height, prioritize_frontiers_overwrite)
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);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
auto num_accounts = node->active.max_priority_cementable_frontiers * 2;
nano::keypair last_keypair = nano::dev_genesis_key;
auto last_open_hash = node->latest (nano::dev_genesis_key.pub);
nano::keypair last_keypair = nano::dev::genesis_key;
auto last_open_hash = node->latest (nano::dev::genesis_key.pub);
// Clear confirmation height so that the genesis account has the same amount of uncemented blocks as the other frontiers
{
auto transaction = node->store.tx_begin_write ();
@ -1119,9 +1119,9 @@ TEST (confirmation_height, prioritize_frontiers_overwrite)
// Add a new frontier with 1 block, it should not be added to the frontier container because it is not higher than any already in the maxed out container
nano::keypair key;
auto latest_genesis = node->latest (nano::dev_genesis_key.pub);
nano::send_block send (latest_genesis, key.pub, nano::Gxrb_ratio - 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest_genesis));
nano::open_block open (send.hash (), nano::dev_genesis_key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub));
auto latest_genesis = node->latest (nano::dev::genesis_key.pub);
nano::send_block send (latest_genesis, key.pub, nano::Gxrb_ratio - 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis));
nano::open_block open (send.hash (), nano::dev::genesis_key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub));
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code);
@ -1133,7 +1133,7 @@ TEST (confirmation_height, prioritize_frontiers_overwrite)
ASSERT_EQ (node->active.priority_wallet_cementable_frontiers_size (), num_accounts / 2);
// The account now has an extra block (2 in total) so has 1 more uncemented block than the next smallest frontier in the collection.
nano::send_block send1 (send.hash (), key.pub, nano::Gxrb_ratio - 2, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send.hash ()));
nano::send_block send1 (send.hash (), key.pub, nano::Gxrb_ratio - 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ()));
nano::receive_block receive (open.hash (), send1.hash (), key.prv, key.pub, *system.work.generate (open.hash ()));
{
auto transaction = node->store.tx_begin_write ();
@ -1308,11 +1308,11 @@ TEST (telemetry, under_load)
nano::genesis genesis;
nano::keypair key;
nano::keypair key1;
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
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 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::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::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 +1329,7 @@ TEST (telemetry, under_load)
}
};
std::thread thread1 (thread_func, nano::dev_genesis_key, latest_genesis, nano::genesis_amount - num_blocks);
std::thread thread1 (thread_func, nano::dev::genesis_key, latest_genesis, nano::dev::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);
@ -1447,7 +1447,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::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, 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 ()));
for (auto node : system.nodes)
{
auto transaction (node->store.tx_begin_write ());
@ -1594,8 +1594,8 @@ TEST (node, mass_epoch_upgrader)
//node_config.work_peers = { { "192.168.1.101", 7000 } };
auto & node = *system.add_node (node_config);
auto balance = node.balance (nano::dev_genesis_key.pub);
auto latest = node.latest (nano::dev_genesis_key.pub);
auto balance = node.balance (nano::dev::genesis_key.pub);
auto latest = node.latest (nano::dev::genesis_key.pub);
nano::uint128_t amount = 1;
// Send to all accounts
@ -1608,12 +1608,12 @@ TEST (node, mass_epoch_upgrader)
nano::state_block_builder builder;
std::error_code ec;
auto block = builder
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (latest)
.balance (balance)
.link (info.key.pub)
.representative (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (latest, nano::work_threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_0, false, false, false))))
.build (ec);
ASSERT_FALSE (ec);
@ -1647,7 +1647,7 @@ TEST (node, mass_epoch_upgrader)
ASSERT_EQ (1 + total_accounts + opened.size (), node.ledger.cache.block_count);
ASSERT_EQ (1 + opened.size (), node.ledger.cache.account_count);
nano::keypair epoch_signer (nano::dev_genesis_key);
nano::keypair epoch_signer (nano::dev::genesis_key);
auto const block_count_before = node.ledger.cache.block_count.load ();
auto const total_to_upgrade = 1 + total_accounts;
@ -1730,16 +1730,16 @@ TEST (node, mass_block_new)
nano::state_block_builder builder;
std::vector<std::shared_ptr<nano::state_block>> send_blocks;
auto send_threshold (nano::work_threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_2, true, false, false)));
auto latest_genesis = node.latest (nano::dev_genesis_key.pub);
auto latest_genesis = node.latest (nano::dev::genesis_key.pub);
for (auto i = 0; i < num_blocks; ++i)
{
auto send = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.account (nano::dev::genesis_key.pub)
.previous (latest_genesis)
.balance (nano::genesis_amount - i - 1)
.representative (nano::dev_genesis_key.pub)
.balance (nano::dev::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)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::work_version::work_1, latest_genesis, send_threshold))
.build ();
latest_genesis = send->hash ();
@ -1828,13 +1828,13 @@ TEST (node, wallet_create_block_confirm_conflicts)
auto const num_blocks = 10000;
// First open the other account
auto latest = nano::genesis_hash;
auto latest = nano::dev::genesis->hash ();
nano::keypair key1;
{
auto transaction = node->store.tx_begin_write ();
for (auto i = num_blocks - 1; i > 0; --i)
{
nano::send_block send (latest, key1.pub, nano::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::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 ();
}

16
nano/test_common/system.cpp
View file

@ -151,19 +151,19 @@ nano::system::~system ()
void nano::system::ledger_initialization_set (std::vector<nano::keypair> const & reps, nano::amount const & reserve)
{
nano::block_hash previous = nano::genesis_hash;
auto amount = (nano::genesis_amount - reserve.number ()) / reps.size ();
auto balance = nano::genesis_amount;
nano::block_hash previous = nano::dev::genesis->hash ();
auto amount = (nano::dev::genesis_amount - reserve.number ()) / reps.size ();
auto balance = nano::dev::genesis_amount;
for (auto const & i : reps)
{
balance -= amount;
nano::state_block_builder builder;
builder.account (nano::dev_genesis_key.pub)
builder.account (nano::dev::genesis_key.pub)
.previous (previous)
.representative (nano::dev_genesis_key.pub)
.representative (nano::dev::genesis_key.pub)
.link (i.pub)
.balance (balance)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*work.generate (previous));
initialization_blocks.emplace_back (builder.build_shared ());
previous = initialization_blocks.back ()->hash ();
@ -212,7 +212,7 @@ uint64_t nano::system::work_generate_limited (nano::block_hash const & root_a, u
std::unique_ptr<nano::state_block> nano::upgrade_epoch (nano::work_pool & pool_a, nano::ledger & ledger_a, nano::epoch epoch_a)
{
auto transaction (ledger_a.store.tx_begin_write ());
auto dev_genesis_key = nano::ledger_constants (nano::networks::nano_dev_network).dev_genesis_key;
auto dev_genesis_key = nano::dev::genesis_key;
auto account = dev_genesis_key.pub;
auto latest = ledger_a.latest (transaction, account);
auto balance = ledger_a.account_balance (transaction, account);
@ -523,7 +523,7 @@ void nano::system::generate_send_new (nano::node & node_a, std::vector<nano::acc
void nano::system::generate_mass_activity (uint32_t count_a, nano::node & node_a)
{
std::vector<nano::account> accounts;
auto dev_genesis_key = nano::ledger_constants (nano::networks::nano_dev_network).dev_genesis_key;
auto dev_genesis_key = nano::dev::genesis_key;
wallet (0)->insert_adhoc (dev_genesis_key.prv);
accounts.push_back (dev_genesis_key.pub);
auto previous (std::chrono::steady_clock::now ());

14
nano/test_common/testutil.cpp
View file

@ -9,20 +9,6 @@
using namespace std::chrono_literals;
/* Convenience constants for tests which are always on the test network */
namespace
{
nano::ledger_constants dev_constants (nano::networks::nano_dev_network);
}
nano::keypair const & nano::zero_key (dev_constants.zero_key);
nano::keypair const & nano::dev_genesis_key (dev_constants.dev_genesis_key);
nano::account const & nano::nano_dev_account (dev_constants.nano_dev_account);
nano::account const & nano::genesis_account (dev_constants.genesis_account ());
nano::block_hash const & nano::genesis_hash (dev_constants.genesis_hash ());
nano::uint128_t const & nano::genesis_amount (dev_constants.genesis_amount);
nano::account const & nano::burn_account (dev_constants.burn_account);
void nano::wait_peer_connections (nano::system & system_a)
{
auto wait_peer_count = [&system_a] (bool in_memory) {

6
nano/test_common/testutil.hpp
View file

@ -53,12 +53,6 @@ class telemetry_data;
class network_params;
class system;
extern nano::keypair const & zero_key;
extern nano::keypair const & dev_genesis_key;
extern nano::block_hash const & genesis_hash;
extern nano::public_key const & nano_dev_account;
extern nano::public_key const & genesis_account;
extern nano::public_key const & burn_account;
extern nano::uint128_t const & genesis_amount;
class stringstream_mt_sink : public boost::iostreams::sink