Moving nano::dev_genesis_key to nano::dev::genesis_key to consolidate unit test related variables in a single place.
This commit is contained in:
clemahieu
parent
8ff11c6c9a
commit
12ce2bedc1
35 changed files with 2048 additions and 2050 deletions
|
|
@ -22,7 +22,7 @@ TEST (active_transactions, confirm_active)
|
|||
.previous (genesis.hash ())
|
||||
.destination (nano::public_key ())
|
||||
.balance (nano::genesis_amount - 100)
|
||||
.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 (*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::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::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.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)
|
||||
.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);
|
||||
|
|
@ -235,24 +235,24 @@ 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)
|
||||
.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)
|
||||
.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)
|
||||
.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)
|
||||
.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,7 +387,7 @@ 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;
|
||||
|
|
@ -395,14 +395,14 @@ TEST (active_transactions, inactive_votes_cache_election_start)
|
|||
.previous (latest)
|
||||
.destination (key1.pub)
|
||||
.balance (nano::genesis_amount - 5000 * 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 (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)
|
||||
.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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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 ());
|
||||
|
|
@ -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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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);
|
||||
|
|
@ -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] {
|
||||
|
|
@ -947,7 +947,7 @@ TEST (active_transactions, confirm_new)
|
|||
.previous (genesis.hash ())
|
||||
.destination (nano::public_key ())
|
||||
.balance (nano::genesis_amount - 100)
|
||||
.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 (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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.link (nano::dev_genesis_key.pub)
|
||||
.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)
|
||||
.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)
|
||||
.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)
|
||||
.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)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.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)
|
||||
.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)
|
||||
.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)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.link (nano::dev_genesis_key.pub)
|
||||
.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)
|
||||
.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)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (send->hash ()))
|
||||
.build ();
|
||||
|
||||
|
|
@ -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)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.link (nano::dev_genesis_key.pub)
|
||||
.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)
|
||||
.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)
|
||||
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
|
||||
.work (*system.work.generate (send->hash ()))
|
||||
.build_shared ();
|
||||
|
||||
|
|
@ -1375,12 +1375,12 @@ 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)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.link (nano::dev_genesis_key.pub)
|
||||
.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)
|
||||
.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;
|
||||
|
|
@ -1388,7 +1388,7 @@ TEST (active_transactions, vacancy)
|
|||
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,12 +1413,12 @@ 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)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.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)
|
||||
.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);
|
||||
|
|
@ -1426,12 +1426,12 @@ TEST (active_transactions, fifo)
|
|||
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)
|
||||
.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)
|
||||
|
|
|
|||
|
|
@ -343,10 +343,10 @@ TEST (block_store, genesis)
|
|||
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::dev::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)
|
||||
|
|
@ -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::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::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::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::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::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::logger_mt logger;
|
||||
nano::mdb_store store (logger, path);
|
||||
|
|
@ -1317,8 +1317,8 @@ 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::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));
|
||||
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;
|
||||
|
|
@ -1352,7 +1352,7 @@ TEST (mdb_block_store, upgrade_v14_v15)
|
|||
// accounts_v1, state_blocks_v1 & pending_v1 tables should be deleted
|
||||
auto error_get_accounts_v1 (mdb_get (store.env.tx (transaction), store.accounts_v1_handle, nano::mdb_val (nano::dev::genesis->account ()), value));
|
||||
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
|
||||
|
|
@ -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::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 ()));
|
||||
|
||||
auto code = [&block1, &block2, &block3] (auto confirmation_height, nano::block_hash const & expected_cemented_frontier) {
|
||||
auto path (nano::unique_path ());
|
||||
|
|
@ -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::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::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::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::dev::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::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::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::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::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::state_block state_open (key1.pub, 0, 0, nano::Gxrb_ratio, state_send.hash (), key1.prv, key1.pub, *pool.generate (key1.pub));
|
||||
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
.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)
|
||||
.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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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,8 +424,8 @@ 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);
|
||||
|
|
@ -433,9 +433,9 @@ TEST (bootstrap_processor, push_diamond_pruning)
|
|||
node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false);
|
||||
ASSERT_TIMELY (10s, node0->balance (key.pub) == nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.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)
|
||||
.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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.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)
|
||||
.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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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,7 +1865,7 @@ 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::dev::genesis->account (), key1.pub, 25));
|
||||
auto send2 (system.wallet (0)->send_action (nano::dev::genesis->account (), key1.pub, 10));
|
||||
|
|
|
|||
|
|
@ -38,15 +38,15 @@ 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::dev::genesis->hash (), confirmation_height_info.frontier);
|
||||
|
||||
|
|
@ -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,12 +90,12 @@ 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::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub));
|
||||
|
|
@ -132,7 +132,7 @@ 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::dev::genesis->hash (), confirmation_height_info.frontier);
|
||||
ASSERT_TRUE (node->store.confirmation_height.get (transaction, key1.pub, confirmation_height_info));
|
||||
|
|
@ -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::dev::genesis->account (), genesis.hash (), nano::dev::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::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
node1.work_generate_blocking (*send1);
|
||||
auto send2 (std::make_shared<nano::state_block> (nano::dev::genesis->account (), send1->hash (), nano::dev::genesis->account (), nano::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::genesis_amount - 2 * nano::Gxrb_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
node1.work_generate_blocking (*send2);
|
||||
auto send3 (std::make_shared<nano::state_block> (nano::dev::genesis->account (), send2->hash (), nano::dev::genesis->account (), nano::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::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));
|
||||
|
|
@ -307,15 +307,15 @@ TEST (confirmation_height, gap_live)
|
|||
node_config.receive_minimum = nano::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::dev::genesis->account (), genesis.hash (), nano::dev::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::genesis_amount - 1, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
node->work_generate_blocking (*send1);
|
||||
auto send2 (std::make_shared<nano::state_block> (nano::dev::genesis->account (), send1->hash (), nano::dev::genesis->account (), nano::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::genesis_amount - 2, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
|
||||
node->work_generate_blocking (*send2);
|
||||
auto send3 (std::make_shared<nano::state_block> (nano::dev::genesis->account (), send2->hash (), nano::dev::genesis->account (), nano::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::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,7 +341,7 @@ 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::dev::genesis->hash (), confirmation_height_info.frontier);
|
||||
}
|
||||
|
|
@ -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::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::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::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::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::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::dev::genesis->account (), send1.hash (), nano::dev::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::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::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::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);
|
||||
|
|
@ -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::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::dev::genesis->hash (), key1.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
|
||||
auto send = std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, nano::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);
|
||||
|
|
@ -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::dev::genesis->hash (), key1.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
|
||||
auto send = std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, nano::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 ());
|
||||
|
|
@ -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::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 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::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::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::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 transaction = node->store.tx_begin_write ();
|
||||
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
|
||||
|
|
@ -1110,27 +1110,27 @@ 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::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::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::genesis_amount - nano::Gxrb_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ()));
|
||||
|
||||
nano::open_block open (send.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub));
|
||||
nano::receive_block receive1 (open.hash (), send1.hash (), key1.prv, key1.pub, *system.work.generate (open.hash ()));
|
||||
nano::send_block send2 (receive1.hash (), nano::dev_genesis_key.pub, nano::Gxrb_ratio, key1.prv, key1.pub, *system.work.generate (receive1.hash ()));
|
||||
nano::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::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::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 ()));
|
||||
|
||||
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));
|
||||
|
||||
|
|
@ -1195,27 +1195,27 @@ 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::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::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::genesis_amount - nano::Gxrb_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ()));
|
||||
|
||||
nano::open_block open (send.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub));
|
||||
nano::receive_block receive1 (open.hash (), send1.hash (), key1.prv, key1.pub, *system.work.generate (open.hash ()));
|
||||
nano::send_block send2 (receive1.hash (), nano::dev_genesis_key.pub, nano::Gxrb_ratio, key1.prv, key1.pub, *system.work.generate (receive1.hash ()));
|
||||
nano::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::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::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 ()));
|
||||
|
||||
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));
|
||||
|
||||
|
|
@ -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::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 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::dev::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::dev::genesis->hash ()));
|
||||
auto send = std::make_shared<nano::send_block> (nano::dev::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::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::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 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::dev::genesis->hash ()));
|
||||
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::dev::genesis->hash ()));
|
||||
auto open1 = std::make_shared<nano::state_block> (key1.pub, 0, key1.pub, 100, send1->hash (), key1.prv, key1.pub, *pool.generate (key1.pub));
|
||||
auto send2 = std::make_shared<nano::state_block> (key1.pub, open1->hash (), key1.pub, 50, key2.pub, key1.prv, key1.pub, *pool.generate (open1->hash ()));
|
||||
auto send3 = std::make_shared<nano::state_block> (key1.pub, send2->hash (), key1.pub, 25, key2.pub, key1.prv, key1.pub, *pool.generate (send2->hash ()));
|
||||
|
|
|
|||
|
|
@ -19,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::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::dev::genesis->hash (), nano::keypair ().pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
|
||||
auto send (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::keypair ().pub, nano::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::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::dev::genesis->hash (), nano::keypair ().pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
|
||||
auto send (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::keypair ().pub, nano::genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
|
||||
send->sideband_set ({});
|
||||
auto election (std::make_shared<nano::election> (node2, send, nullptr, nullptr, nano::election_behavior::normal));
|
||||
// Add a vote for something else, not the winner
|
||||
|
|
@ -108,7 +108,7 @@ TEST (confirmation_solicitor, bypass_max_requests_cap)
|
|||
ASSERT_EQ (max_representatives + 1, representatives.size ());
|
||||
solicitor.prepare (representatives);
|
||||
ASSERT_TIMELY (3s, node2.network.size () == 1);
|
||||
auto send (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::keypair ().pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
|
||||
auto send (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::keypair ().pub, nano::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
|
||||
|
|
|
|||
|
|
@ -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 ());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -28,24 +28,24 @@ TEST (election, quorum_minimum_flip_success)
|
|||
nano::keypair key1;
|
||||
nano::block_builder builder;
|
||||
auto send1 = builder.state ()
|
||||
.account (nano::dev_genesis_key.pub)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.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)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.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 ()));
|
||||
|
|
@ -74,24 +74,24 @@ TEST (election, quorum_minimum_flip_fail)
|
|||
nano::keypair key1;
|
||||
nano::block_builder builder;
|
||||
auto send1 = builder.state ()
|
||||
.account (nano::dev_genesis_key.pub)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.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)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.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 ()));
|
||||
|
|
@ -120,23 +120,23 @@ TEST (election, quorum_minimum_confirm_success)
|
|||
nano::keypair key1;
|
||||
nano::block_builder builder;
|
||||
auto send1 = builder.state ()
|
||||
.account (nano::dev_genesis_key.pub)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.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 ()));
|
||||
|
|
@ -153,23 +153,23 @@ TEST (election, quorum_minimum_confirm_fail)
|
|||
nano::keypair key1;
|
||||
nano::block_builder builder;
|
||||
auto send1 = builder.state ()
|
||||
.account (nano::dev_genesis_key.pub)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.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,18 +184,18 @@ 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)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.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 ()
|
||||
|
|
@ -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 ());
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.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)
|
||||
.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)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.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)
|
||||
.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,12 +61,12 @@ 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)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.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)
|
||||
.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 ()
|
||||
|
|
@ -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)
|
||||
.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)
|
||||
.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)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.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)
|
||||
.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 ());
|
||||
|
|
|
|||
|
|
@ -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::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::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::dev::genesis->account (), key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub));
|
||||
|
||||
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::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::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 ()));
|
||||
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 ();
|
||||
|
|
@ -85,7 +85,7 @@ TEST (frontiers_confirmation, prioritize_frontiers)
|
|||
|
||||
{
|
||||
// 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));
|
||||
|
|
@ -111,12 +111,12 @@ TEST (frontiers_confirmation, prioritize_frontiers)
|
|||
}
|
||||
|
||||
// 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);
|
||||
|
|
@ -161,7 +161,7 @@ TEST (frontiers_confirmation, prioritize_frontiers_max_optimistic_elections)
|
|||
auto transaction = node->store.tx_begin_write ();
|
||||
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::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::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::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::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 ());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -65,9 +65,9 @@ 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::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::dev::genesis->account ()));
|
||||
ASSERT_EQ (nano::genesis_amount, node2.balance (nano::dev::genesis->account ()));
|
||||
|
|
@ -78,8 +78,8 @@ 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::dev::genesis->account ()));
|
||||
ASSERT_EQ (nano::genesis_amount, node2.balance (nano::dev::genesis->account ()));
|
||||
|
|
@ -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 ());
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -69,10 +69,10 @@ TEST (ledger_walker, genesis_account_longer)
|
|||
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);
|
||||
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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 (); }));
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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 ();
|
||||
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::genesis_amount - nano::Gxrb_ratio)
|
||||
.link (nano::dev_genesis_key.pub)
|
||||
.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)
|
||||
.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)
|
||||
.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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.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)
|
||||
.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::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)
|
||||
.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)
|
||||
.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::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::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::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::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)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.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)
|
||||
.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;
|
||||
|
|
|
|||
|
|
@ -38,16 +38,16 @@ 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::dev::genesis->account (), stake_preserver.pub, nano::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
|
||||
{
|
||||
|
|
@ -60,7 +60,7 @@ TEST (system, DISABLED_generate_send_existing)
|
|||
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,7 +68,7 @@ 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);
|
||||
|
|
@ -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));
|
||||
|
|
@ -103,7 +103,7 @@ TEST (system, DISABLED_generate_send_new)
|
|||
}
|
||||
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;
|
||||
}
|
||||
|
|
@ -157,7 +157,7 @@ TEST (system, rep_initialize_one_reserve)
|
|||
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::Gxrb_ratio, node->balance (nano::dev::genesis_key.pub));
|
||||
}
|
||||
|
||||
TEST (system, rep_initialize_two_reserve)
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
{
|
||||
|
|
@ -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)
|
||||
.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)
|
||||
.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,7 +260,7 @@ 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 ())
|
||||
.link (send->hash ())
|
||||
|
|
@ -269,21 +269,21 @@ TEST (vote_processor, no_broadcast_local)
|
|||
.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::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
|
||||
|
|
|
|||
|
|
@ -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,7 +108,7 @@ 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);
|
||||
|
|
@ -162,24 +162,24 @@ 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)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.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)
|
||||
.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)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.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)
|
||||
.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);
|
||||
|
|
@ -205,24 +205,24 @@ 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)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.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)
|
||||
.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)
|
||||
.account (nano::dev::genesis_key.pub)
|
||||
.previous (nano::dev::genesis->hash ())
|
||||
.representative (nano::dev_genesis_key.pub)
|
||||
.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)
|
||||
.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);
|
||||
|
|
|
|||
|
|
@ -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::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)
|
||||
|
|
@ -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);
|
||||
|
|
@ -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::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,7 +1160,7 @@ 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::dev::genesis->account ())
|
||||
|
|
@ -1168,7 +1168,7 @@ TEST (wallet, search_pending)
|
|||
.representative (nano::dev::genesis->account ())
|
||||
.balance (nano::genesis_amount - node.config.receive_minimum.number ())
|
||||
.link (nano::dev::genesis->account ())
|
||||
.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::dev::genesis->hash ()))
|
||||
.build ();
|
||||
ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
|
||||
|
|
@ -1188,7 +1188,7 @@ 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);
|
||||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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,7 +163,7 @@ 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::dev::genesis->account ())
|
||||
|
|
@ -171,7 +171,7 @@ TEST (wallets, search_pending)
|
|||
.representative (nano::dev::genesis->account ())
|
||||
.balance (nano::genesis_amount - node.config.receive_minimum.number ())
|
||||
.link (nano::dev::genesis->account ())
|
||||
.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::dev::genesis->hash ()))
|
||||
.build ();
|
||||
ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
|
||||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
|
||||
auto balance = nano::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 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 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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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)
|
||||
.representative (nano::dev::genesis_key.pub)
|
||||
.balance (nano::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;
|
||||
|
|
@ -583,19 +583,19 @@ 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);
|
||||
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)
|
||||
.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)
|
||||
.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 ();
|
||||
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
@ -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::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::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::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);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -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 ());
|
||||
|
|
@ -907,7 +907,7 @@ TEST (wallet, DISABLED_synchronizing)
|
|||
{
|
||||
auto transaction (system1.nodes[0]->store.tx_begin_write ());
|
||||
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));
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -81,6 +81,7 @@ std::string const test_canary_public_key_data = nano::get_env_or_default ("NANO_
|
|||
|
||||
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::network_params::network_params () :
|
||||
network_params (network_constants::active_network)
|
||||
|
|
@ -107,7 +108,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),
|
||||
|
|
|
|||
|
|
@ -371,7 +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;
|
||||
|
|
@ -400,6 +399,7 @@ namespace dev
|
|||
{
|
||||
extern nano::ledger_constants constants;
|
||||
extern std::shared_ptr<nano::block> & genesis;
|
||||
extern nano::keypair genesis_key;
|
||||
}
|
||||
|
||||
/** Constants which depend on random values (this class should never be used globally due to CryptoPP globals potentially not being initialized) */
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
@ -101,16 +101,16 @@ TEST (ledger, deep_account_compute)
|
|||
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 ()));
|
||||
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::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);
|
||||
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::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,15 +639,15 @@ 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::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::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub));
|
||||
{
|
||||
auto transaction = node->store.tx_begin_write ();
|
||||
|
|
@ -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::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::dev::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::genesis_amount - nano::Gxrb_ratio + 1, send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous_genesis_chain_hash)));
|
||||
|
||||
// Unpocketed. Send to a non-existing account to prevent auto receives from the wallet adjusting expected confirmation height
|
||||
nano::keypair key2;
|
||||
nano::state_block send2 (nano::dev::genesis->account (), receive1->hash (), nano::dev::genesis->account (), nano::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::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::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::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::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 ();
|
||||
|
|
@ -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::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::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::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::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)
|
||||
.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 ();
|
||||
|
|
@ -1834,7 +1834,7 @@ TEST (node, wallet_create_block_confirm_conflicts)
|
|||
auto transaction = node->store.tx_begin_write ();
|
||||
for (auto i = num_blocks - 1; i > 0; --i)
|
||||
{
|
||||
nano::send_block send (latest, key1.pub, nano::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::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 ();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -158,12 +158,12 @@ void nano::system::ledger_initialization_set (std::vector<nano::keypair> const &
|
|||
{
|
||||
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 ());
|
||||
|
|
|
|||
|
|
@ -15,7 +15,6 @@ namespace
|
|||
nano::ledger_constants dev_constants (nano::networks::nano_dev_network);
|
||||
}
|
||||
|
||||
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::uint128_t const & nano::genesis_amount (dev_constants.genesis_amount);
|
||||
|
||||
|
|
|
|||
|
|
@ -53,7 +53,6 @@ class telemetry_data;
|
|||
class network_params;
|
||||
class system;
|
||||
|
||||
extern nano::keypair const & dev_genesis_key;
|
||||
extern nano::public_key const & nano_dev_account;
|
||||
extern nano::uint128_t const & genesis_amount;
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue