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

Moving dev constants in to their own namespace and deleting extra memorization of genesis_hash.

Browse source
This commit is contained in:
clemahieu 2021-07-20 17:53:53 +01:00
commit 0091262d96
No known key found for this signature in database
GPG key ID: 43708520C8DFB938
21 changed files with 131 additions and 124 deletions
Download patch file Download diff file Expand all files Collapse all files

24
nano/core_test/active_transactions.cpp
View file

@ -1021,12 +1021,12 @@ TEST (active_transactions, activate_account_chain)
nano::state_block_builder builder;
auto send = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.link (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 1)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build ();
auto send2 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
@ -1121,12 +1121,12 @@ TEST (active_transactions, activate_inactive)
nano::state_block_builder builder;
auto send = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.link (key.pub)
.balance (nano::genesis_amount - 1)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
auto send2 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
@ -1182,12 +1182,12 @@ TEST (active_transactions, pessimistic_elections)
nano::state_block_builder builder;
auto send = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.link (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 1)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
@ -1321,12 +1321,12 @@ TEST (active_transactions, list_active)
nano::state_block_builder builder;
auto send = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.link (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 1)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
@ -1376,12 +1376,12 @@ TEST (active_transactions, vacancy)
nano::state_block_builder builder;
auto send = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.link (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
std::atomic<bool> updated = false;
node.active.vacancy_update = [&updated] () { updated = true; };
@ -1414,12 +1414,12 @@ TEST (active_transactions, fifo)
// Construct two pending entries that can be received simultaneously
auto send0 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.link (key0.pub)
.balance (nano::genesis_amount - 1)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*send0).code);
nano::blocks_confirm (node, { send0 }, true);

6
nano/core_test/block_store.cpp
View file

@ -692,7 +692,7 @@ TEST (mdb_block_store, supported_version_upgrades)
store.confirmation_height.del (transaction, nano::genesis_account);
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "accounts_v1", MDB_CREATE, &store.accounts_v1_handle));
ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks_handle));
modify_account_info_to_v14 (store, transaction, nano::genesis_account, 1, nano::genesis_hash);
modify_account_info_to_v14 (store, transaction, nano::genesis_account, 1, nano::dev::genesis->hash ());
write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::genesis ().open);
}
@ -1700,7 +1700,7 @@ TEST (mdb_block_store, upgrade_v18_v19)
nano::keypair key1;
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::network_params network_params;
nano::send_block send (nano::genesis_hash, nano::dev_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::genesis_hash));
nano::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 ()));
@ -1760,7 +1760,7 @@ TEST (mdb_block_store, upgrade_v18_v19)
ASSERT_TRUE (store.block.get (transaction, send.hash ()));
ASSERT_TRUE (store.block.get (transaction, receive.hash ()));
ASSERT_TRUE (store.block.get (transaction, change.hash ()));
ASSERT_TRUE (store.block.get (transaction, nano::genesis_hash));
ASSERT_TRUE (store.block.get (transaction, nano::dev::genesis->hash ()));
auto state_epoch_disk (store.block.get (transaction, state_epoch.hash ()));
ASSERT_NE (nullptr, state_epoch_disk);
ASSERT_EQ (nano::epoch::epoch_1, state_epoch_disk->sideband ().details.epoch);

18
nano/core_test/confirmation_height.cpp
View file

@ -48,7 +48,7 @@ TEST (confirmation_height, single)
auto transaction = node->store.tx_begin_read ();
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev_genesis_key.pub, confirmation_height_info));
ASSERT_EQ (1, confirmation_height_info.height);
ASSERT_EQ (nano::genesis_hash, confirmation_height_info.frontier);
ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier);
node->process_active (send1);
node->block_processor.flush ();
@ -134,7 +134,7 @@ TEST (confirmation_height, multiple_accounts)
nano::confirmation_height_info confirmation_height_info;
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev_genesis_key.pub, confirmation_height_info));
ASSERT_EQ (1, confirmation_height_info.height);
ASSERT_EQ (nano::genesis_hash, confirmation_height_info.frontier);
ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier);
ASSERT_TRUE (node->store.confirmation_height.get (transaction, key1.pub, confirmation_height_info));
ASSERT_EQ (0, confirmation_height_info.height);
ASSERT_EQ (nano::block_hash (0), confirmation_height_info.frontier);
@ -343,7 +343,7 @@ TEST (confirmation_height, gap_live)
nano::confirmation_height_info confirmation_height_info;
ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev_genesis_key.pub, confirmation_height_info));
ASSERT_EQ (1, confirmation_height_info.height);
ASSERT_EQ (nano::genesis_hash, confirmation_height_info.frontier);
ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier);
}
// Vote and confirm all existing blocks
@ -806,7 +806,7 @@ TEST (confirmation_heightDeathTest, modified_chain)
nano::write_database_queue write_database_queue (false);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
auto send = std::make_shared<nano::send_block> (nano::genesis_hash, key1.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::genesis_hash));
auto send = std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
{
auto transaction (store->tx_begin_write ());
store->initialize (transaction, ledger.cache);
@ -832,7 +832,7 @@ TEST (confirmation_heightDeathTest, modified_chain)
}
ASSERT_EQ (nano::process_result::progress, ledger.process (store->tx_begin_write (), *send).code);
store->confirmation_height.put (store->tx_begin_write (), nano::genesis_account, { 1, nano::genesis_hash });
store->confirmation_height.put (store->tx_begin_write (), nano::genesis_account, { 1, nano::dev::genesis->hash () });
nano::confirmation_height_unbounded unbounded_processor (
ledger, write_database_queue, 10ms, logging, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; });
@ -877,7 +877,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed)
nano::write_database_queue write_database_queue (false);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1;
auto send = std::make_shared<nano::send_block> (nano::genesis_hash, key1.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::genesis_hash));
auto send = std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::dev::genesis->hash ()));
auto open = std::make_shared<nano::state_block> (key1.pub, 0, 0, nano::Gxrb_ratio, send->hash (), key1.prv, key1.pub, *pool.generate (key1.pub));
{
auto transaction (store->tx_begin_write ());
@ -906,7 +906,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed)
// Reset conditions and test with the bounded processor
ASSERT_EQ (nano::process_result::progress, ledger.process (store->tx_begin_write (), *open).code);
store->confirmation_height.put (store->tx_begin_write (), nano::genesis_account, { 1, nano::genesis_hash });
store->confirmation_height.put (store->tx_begin_write (), nano::genesis_account, { 1, nano::dev::genesis->hash () });
nano::confirmation_height_bounded bounded_processor (
ledger, write_database_queue, 10ms, logging, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; });
@ -1344,7 +1344,7 @@ TEST (confirmation_height, election_winner_details_clearing_node_process_confirm
nano::system system (1);
auto node = system.nodes.front ();
auto send = std::make_shared<nano::send_block> (nano::genesis_hash, nano::dev_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash));
auto send = std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::dev_genesis_key.pub, nano::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;
@ -1422,7 +1422,7 @@ TEST (confirmation_height, pruned_source)
nano::write_database_queue write_database_queue (false);
nano::work_pool pool (std::numeric_limits<unsigned>::max ());
nano::keypair key1, key2;
auto send1 = std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, genesis.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 100, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::genesis_hash));
auto send1 = std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, genesis.hash (), nano::dev_genesis_key.pub, nano::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 ()));

6
nano/core_test/confirmation_solicitor.cpp
View file

@ -28,7 +28,7 @@ TEST (confirmation_solicitor, batches)
ASSERT_EQ (channel1, representatives.front ().channel);
ASSERT_EQ (nano::dev_genesis_key.pub, representatives.front ().account);
ASSERT_TIMELY (3s, node2.network.size () == 1);
auto send (std::make_shared<nano::send_block> (nano::genesis_hash, nano::keypair ().pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash)));
auto send (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::keypair ().pub, nano::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);
@ -72,7 +72,7 @@ TEST (confirmation_solicitor, different_hash)
ASSERT_EQ (channel1, representatives.front ().channel);
ASSERT_EQ (nano::dev_genesis_key.pub, representatives.front ().account);
ASSERT_TIMELY (3s, node2.network.size () == 1);
auto send (std::make_shared<nano::send_block> (nano::genesis_hash, nano::keypair ().pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash)));
auto send (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::keypair ().pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
send->sideband_set ({});
auto election (std::make_shared<nano::election> (node2, send, nullptr, nullptr, nano::election_behavior::normal));
// Add a vote for something else, not the winner
@ -108,7 +108,7 @@ TEST (confirmation_solicitor, bypass_max_requests_cap)
ASSERT_EQ (max_representatives + 1, representatives.size ());
solicitor.prepare (representatives);
ASSERT_TIMELY (3s, node2.network.size () == 1);
auto send (std::make_shared<nano::send_block> (nano::genesis_hash, nano::keypair ().pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash)));
auto send (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), nano::keypair ().pub, nano::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
nano/core_test/election.cpp
View file

@ -29,7 +29,7 @@ TEST (election, quorum_minimum_flip_success)
nano::block_builder builder;
auto send1 = builder.state ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (node1.online_reps.delta ())
.link (key1.pub)
@ -40,7 +40,7 @@ TEST (election, quorum_minimum_flip_success)
nano::keypair key2;
auto send2 = builder.state ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (node1.online_reps.delta ())
.link (key2.pub)
@ -75,7 +75,7 @@ TEST (election, quorum_minimum_flip_fail)
nano::block_builder builder;
auto send1 = builder.state ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (node1.online_reps.delta () - 1)
.link (key1.pub)
@ -86,7 +86,7 @@ TEST (election, quorum_minimum_flip_fail)
nano::keypair key2;
auto send2 = builder.state ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (node1.online_reps.delta () - 1)
.link (key2.pub)
@ -121,7 +121,7 @@ TEST (election, quorum_minimum_confirm_success)
nano::block_builder builder;
auto send1 = builder.state ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (node1.online_reps.delta ())
.link (key1.pub)
@ -154,7 +154,7 @@ TEST (election, quorum_minimum_confirm_fail)
nano::block_builder builder;
auto send1 = builder.state ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (node1.online_reps.delta () - 1)
.link (key1.pub)
@ -190,7 +190,7 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks)
nano::block_builder builder;
auto send1 = builder.state ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (amount)
.link (key1.pub)

16
nano/core_test/election_scheduler.cpp
View file

@ -19,12 +19,12 @@ TEST (election_scheduler, activate_one_timely)
nano::state_block_builder builder;
auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.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 ());
@ -37,12 +37,12 @@ TEST (election_scheduler, activate_one_flush)
nano::state_block_builder builder;
auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.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 ());
@ -62,12 +62,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)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.link (key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
auto receive = builder.make_block ()
.account (key.pub)
@ -135,12 +135,12 @@ TEST (election_scheduler, flush_vacancy)
auto send = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.link (key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.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 ());

18
nano/core_test/ledger.cpp
View file

@ -742,7 +742,7 @@ TEST (votes, add_existing)
nano::block_builder builder;
std::shared_ptr<nano::block> send1 = builder.state ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub) // No representative, blocks can't confirm
.balance (nano::genesis_amount / 2 - nano::Gxrb_ratio)
.link (key1.pub)
@ -762,7 +762,7 @@ TEST (votes, add_existing)
nano::keypair key2;
std::shared_ptr<nano::block> send2 = builder.state ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub) // No representative, blocks can't confirm
.balance (nano::genesis_amount / 2 - nano::Gxrb_ratio)
.link (key2.pub)
@ -2563,12 +2563,12 @@ TEST (ledger, epoch_open_pending)
// New block to process epoch open
auto send1 = builder.state ()
.account (nano::genesis_account)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::genesis_account)
.balance (nano::genesis_amount - 100)
.link (key1.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*pool.generate (nano::genesis_hash))
.work (*pool.generate (nano::dev::genesis->hash ()))
.build_shared ();
node1.block_processor.add (send1);
node1.block_processor.flush ();
@ -3000,7 +3000,7 @@ TEST (ledger, work_validation)
std::error_code ec;
auto send = *builder.send ()
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.destination (gen.pub)
.balance (nano::genesis_amount - 1)
.sign (gen.prv, gen.pub)
@ -3735,12 +3735,12 @@ TEST (ledger, migrate_lmdb_to_rocksdb)
auto send = nano::state_block_builder ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (0)
.link (nano::account (10))
.balance (nano::genesis_amount - 100)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*pool.generate (nano::genesis_hash))
.work (*pool.generate (nano::dev::genesis->hash ()))
.build_shared ();
nano::endpoint_key endpoint_key (address.to_bytes (), port);
@ -3760,7 +3760,7 @@ TEST (ledger, migrate_lmdb_to_rocksdb)
store.pending.put (transaction, nano::pending_key (nano::genesis_account, send->hash ()), nano::pending_info (nano::genesis_account, 100, nano::epoch::epoch_0));
store.pruned.put (transaction, send->hash ());
store.unchecked.put (transaction, nano::genesis_hash, send);
store.unchecked.put (transaction, nano::dev::genesis->hash (), send);
store.version.put (transaction, version);
send->sideband_set ({});
store.block.put (transaction, send->hash (), *send);
@ -3797,7 +3797,7 @@ TEST (ledger, migrate_lmdb_to_rocksdb)
ASSERT_TRUE (rocksdb_store.final_vote.get (rocksdb_transaction, nano::root (send->previous ())).size () == 1);
ASSERT_EQ (rocksdb_store.final_vote.get (rocksdb_transaction, nano::root (send->previous ()))[0], nano::block_hash (2));
auto unchecked_infos = rocksdb_store.unchecked.get (rocksdb_transaction, nano::genesis_hash);
auto unchecked_infos = rocksdb_store.unchecked.get (rocksdb_transaction, nano::dev::genesis->hash ());
ASSERT_EQ (unchecked_infos.size (), 1);
ASSERT_EQ (unchecked_infos.front ().account, nano::genesis_account);
ASSERT_EQ (*unchecked_infos.front ().block, *send);

8
nano/core_test/ledger_walker.cpp
View file

@ -19,19 +19,19 @@ TEST (ledger_walker, genesis_block)
nano::ledger_walker ledger_walker{ node->ledger };
std::size_t walked_blocks_count = 0;
ledger_walker.walk_backward (nano::genesis_hash,
ledger_walker.walk_backward (nano::dev::genesis->hash (),
[&] (const auto & block) {
++walked_blocks_count;
EXPECT_EQ (block->hash (), nano::genesis_hash);
EXPECT_EQ (block->hash (), nano::dev::genesis->hash ());
});
EXPECT_EQ (walked_blocks_count, 1);
walked_blocks_count = 0;
ledger_walker.walk (nano::genesis_hash,
ledger_walker.walk (nano::dev::genesis->hash (),
[&] (const auto & block) {
++walked_blocks_count;
EXPECT_EQ (block->hash (), nano::genesis_hash);
EXPECT_EQ (block->hash (), nano::dev::genesis->hash ());
});
EXPECT_EQ (walked_blocks_count, 1);

52
nano/core_test/node.cpp
View file

@ -1718,11 +1718,11 @@ TEST (node, broadcast_elected)
auto transaction1 (node1->store.tx_begin_write ());
auto transaction2 (node2->store.tx_begin_write ());
auto fund_big = *builder.send ()
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.destination (rep_big.pub)
.balance (nano::Gxrb_ratio * 5)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build ();
auto open_big = *builder.open ()
.source (fund_big.hash ())
@ -1836,11 +1836,11 @@ TEST (node, rep_self_vote)
nano::keypair rep_big;
nano::block_builder builder;
auto fund_big = *builder.send ()
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.destination (rep_big.pub)
.balance (nano::uint128_t{ "0xb0000000000000000000000000000000" })
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build ();
auto open_big = *builder.open ()
.source (fund_big.hash ())
@ -1924,11 +1924,11 @@ TEST (node, bootstrap_bulk_push)
nano::keypair key0;
// node0 knows about send0 but node1 doesn't.
auto send0 = nano::send_block_builder ()
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.destination (key0.pub)
.balance (500)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*node0->work_generate_blocking (nano::genesis_hash))
.work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node0->process (*send0).code);
@ -1962,11 +1962,11 @@ TEST (node, bootstrap_fork_open)
nano::keypair key0;
nano::block_builder builder;
auto send0 = *builder.send ()
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.destination (key0.pub)
.balance (nano::genesis_amount - 500)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build ();
auto open0 = *builder.open ()
.source (send0.hash ())
@ -2018,11 +2018,11 @@ TEST (node, bootstrap_confirm_frontiers)
nano::keypair key0;
// node0 knows about send0 but node1 doesn't.
auto send0 = nano::send_block_builder ()
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.destination (key0.pub)
.balance (nano::genesis_amount - 500)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*node0->work_generate_blocking (nano::genesis_hash))
.work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node0->process (*send0).code);
@ -2496,7 +2496,7 @@ TEST (node, online_reps_rep_crawler)
nano::node_flags flags;
flags.disable_rep_crawler = true;
auto & node1 = *system.add_node (flags);
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>{ nano::genesis_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>{ nano::dev::genesis->hash () });
ASSERT_EQ (0, node1.online_reps.online ());
// Without rep crawler
node1.vote_processor.vote_blocking (vote, std::make_shared<nano::transport::channel_loopback> (node1));
@ -2504,7 +2504,7 @@ TEST (node, online_reps_rep_crawler)
// After inserting to rep crawler
{
nano::lock_guard<nano::mutex> guard (node1.rep_crawler.probable_reps_mutex);
node1.rep_crawler.active.insert (nano::genesis_hash);
node1.rep_crawler.active.insert (nano::dev::genesis->hash ());
}
node1.vote_processor.vote_blocking (vote, std::make_shared<nano::transport::channel_loopback> (node1));
ASSERT_EQ (nano::genesis_amount, node1.online_reps.online ());
@ -2957,12 +2957,12 @@ TEST (node, vote_by_hash_bundle)
std::vector<std::shared_ptr<nano::state_block>> blocks;
auto block = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 1)
.link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
blocks.push_back (block);
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *blocks.back ()).code);
@ -3974,12 +3974,12 @@ TEST (node, rollback_vote_self)
auto weight = node.online_reps.delta ();
auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.link (key.pub)
.balance (nano::genesis_amount - weight)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
auto open = builder.make_block ()
.account (key.pub)
@ -4063,12 +4063,12 @@ TEST (node, rollback_gap_source)
nano::keypair key;
auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.link (key.pub)
.balance (nano::genesis_amount - 1)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
auto fork = builder.make_block ()
.account (key.pub)
@ -4160,12 +4160,12 @@ TEST (node, dependency_graph)
// Send to key1
auto gen_send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.link (key1.pub)
.balance (nano::genesis_amount - 1)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
// Receive from genesis
auto key1_open = builder.make_block ()
@ -4362,12 +4362,12 @@ TEST (node, dependency_graph_frontier)
// Send to key1
auto gen_send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.link (key1.pub)
.balance (nano::genesis_amount - 1)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
// Receive from genesis
auto key1_open = builder.make_block ()
@ -4525,12 +4525,12 @@ TEST (node, deferred_dependent_elections)
nano::keypair key;
auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.link (key.pub)
.balance (nano::genesis_amount - 1)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
auto open = builder.make_block ()
.account (key.pub)
@ -4678,10 +4678,10 @@ TEST (rep_crawler, local)
flags.disable_rep_crawler = true;
auto & node = *system.add_node (flags);
auto loopback = std::make_shared<nano::transport::channel_loopback> (node);
auto vote = std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, std::vector{ nano::genesis_hash });
auto vote = std::make_shared<nano::vote> (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, std::vector{ nano::dev::genesis->hash () });
{
nano::lock_guard<nano::mutex> guard (node.rep_crawler.probable_reps_mutex);
node.rep_crawler.active.insert (nano::genesis_hash);
node.rep_crawler.active.insert (nano::dev::genesis->hash ());
node.rep_crawler.responses.emplace_back (loopback, vote);
}
node.rep_crawler.validate ();

4
nano/core_test/request_aggregator.cpp
View file

@ -375,12 +375,12 @@ TEST (request_aggregator, cannot_vote)
nano::state_block_builder builder;
auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 1)
.link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
auto send2 = builder.make_block ()
.from (*send1)

4
nano/core_test/vote_processor.cpp
View file

@ -195,11 +195,11 @@ TEST (vote_processor, no_broadcast_local)
std::shared_ptr<nano::block> send = builder.state ()
.account (nano::dev_genesis_key.pub)
.representative (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.balance (2 * node.config.vote_minimum.number ())
.link (key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build (ec);
ASSERT_FALSE (ec);
ASSERT_EQ (nano::process_result::progress, node.process_local (send).code);

30
nano/core_test/voting.cpp
View file

@ -112,7 +112,7 @@ TEST (vote_generator, session)
nano::vote_generator_session generator_session (node->active.generator);
boost::thread thread ([node, &generator_session] () {
nano::thread_role::set (nano::thread_role::name::request_loop);
generator_session.add (nano::genesis_account, nano::genesis_hash);
generator_session.add (nano::genesis_account, nano::dev::genesis->hash ());
ASSERT_EQ (0, node->stats.count (nano::stat::type::vote, nano::stat::detail::vote_indeterminate));
generator_session.flush ();
});
@ -166,33 +166,33 @@ TEST (vote_spacing, vote_generator)
nano::state_block_builder builder;
auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
auto send2 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio - 1)
.link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
ASSERT_EQ (0, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts));
node.active.generator.add (nano::genesis_hash, send1->hash ());
node.active.generator.add (nano::dev::genesis->hash (), send1->hash ());
ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts) == 1);
ASSERT_FALSE (node.ledger.rollback (node.store.tx_begin_write (), send1->hash ()));
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code);
node.active.generator.add (nano::genesis_hash, send2->hash ());
node.active.generator.add (nano::dev::genesis->hash (), send2->hash ());
ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_spacing) == 1);
ASSERT_EQ (1, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts));
std::this_thread::sleep_for (config.network_params.voting.delay);
node.active.generator.add (nano::genesis_hash, send2->hash ());
node.active.generator.add (nano::dev::genesis->hash (), send2->hash ());
ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts) == 2);
}
@ -209,31 +209,31 @@ TEST (vote_spacing, rapid)
nano::state_block_builder builder;
auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio)
.link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
auto send2 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - nano::Gxrb_ratio - 1)
.link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
node.active.generator.add (nano::genesis_hash, send1->hash ());
node.active.generator.add (nano::dev::genesis->hash (), send1->hash ());
ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts) == 1);
ASSERT_FALSE (node.ledger.rollback (node.store.tx_begin_write (), send1->hash ()));
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code);
node.active.generator.add (nano::genesis_hash, send2->hash ());
node.active.generator.add (nano::dev::genesis->hash (), send2->hash ());
ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_spacing) == 1);
ASSERT_TIMELY (3s, 1 == node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts));
std::this_thread::sleep_for (config.network_params.voting.delay);
node.active.generator.add (nano::genesis_hash, send2->hash ());
node.active.generator.add (nano::dev::genesis->hash (), send2->hash ());
ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts) == 2);
}

4
nano/core_test/wallet.cpp
View file

@ -1164,12 +1164,12 @@ TEST (wallet, search_pending)
nano::block_builder builder;
auto send = builder.state ()
.account (nano::genesis_account)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::genesis_account)
.balance (nano::genesis_amount - node.config.receive_minimum.number ())
.link (nano::genesis_account)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, node.process (*send).code);

4
nano/core_test/wallets.cpp
View file

@ -167,12 +167,12 @@ TEST (wallets, search_pending)
nano::block_builder builder;
auto send = builder.state ()
.account (nano::genesis_account)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::genesis_account)
.balance (nano::genesis_amount - node.config.receive_minimum.number ())
.link (nano::genesis_account)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, node.process (*send).code);

28
nano/rpc_test/rpc.cpp
View file

@ -234,12 +234,12 @@ TEST (rpc, account_balance)
auto send1 = builder.make_block ()
.account (nano::dev_genesis_key.pub)
.previous (nano::genesis_hash)
.previous (nano::dev::genesis->hash ())
.representative (nano::dev_genesis_key.pub)
.balance (nano::genesis_amount - 1)
.link (nano::dev_genesis_key.pub)
.sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub)
.work (*system.work.generate (nano::genesis_hash))
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, node->process (*send1).code);
@ -531,7 +531,7 @@ TEST (rpc, send_epoch_2)
request.put ("amount", "1");
// Test that the correct error is given if there is insufficient work
auto insufficient = system.work_generate_limited (nano::genesis_hash, min_difficulty, target_difficulty);
auto insufficient = system.work_generate_limited (nano::dev::genesis->hash (), min_difficulty, target_difficulty);
request.put ("work", nano::to_string_hex (insufficient));
{
auto response (wait_response (system, rpc, request));
@ -2552,7 +2552,7 @@ TEST (rpc, account_representative_set_epoch_2)
request.put ("representative", nano::keypair ().pub.to_account ());
// Test that the correct error is given if there is insufficient work
auto insufficient = system.work_generate_limited (nano::genesis_hash, min_difficulty, target_difficulty);
auto insufficient = system.work_generate_limited (nano::dev::genesis->hash (), min_difficulty, target_difficulty);
request.put ("work", nano::to_string_hex (insufficient));
{
auto response (wait_response (system, rpc, request));
@ -3729,7 +3729,7 @@ TEST (rpc, account_info)
ASSERT_EQ (confirmed_representative, nano::dev_genesis_key.pub.to_account ());
auto confirmed_frontier (response.get<std::string> ("confirmed_frontier"));
ASSERT_EQ (nano::genesis_hash.to_string (), confirmed_frontier);
ASSERT_EQ (nano::dev::genesis->hash ().to_string (), confirmed_frontier);
auto confirmed_height (response.get<uint64_t> ("confirmed_height"));
ASSERT_EQ (1, confirmed_height);
@ -4941,7 +4941,7 @@ TEST (rpc, block_confirm_confirmed)
// Check confirmation history
auto confirmed (node->active.list_recently_cemented ());
ASSERT_EQ (1, confirmed.size ());
ASSERT_EQ (nano::genesis_hash, confirmed.begin ()->winner->hash ());
ASSERT_EQ (nano::dev::genesis->hash (), confirmed.begin ()->winner->hash ());
// Check callback
ASSERT_TIMELY (10s, node->stats.count (nano::stat::type::error, nano::stat::detail::http_callback, nano::stat::dir::out) != 0);
// Callback result is error because callback target port isn't listening
@ -5213,7 +5213,7 @@ TEST (rpc, wallet_history)
ASSERT_EQ ("receive", std::get<0> (history_l[3]));
ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<1> (history_l[3]));
ASSERT_EQ (nano::genesis_amount.convert_to<std::string> (), std::get<2> (history_l[3]));
ASSERT_EQ (nano::genesis_hash.to_string (), std::get<3> (history_l[3]));
ASSERT_EQ (nano::dev::genesis->hash ().to_string (), std::get<3> (history_l[3]));
ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<4> (history_l[3]));
}
@ -5623,7 +5623,7 @@ TEST (rpc, deprecated_account_format)
request.put ("account", account_text);
auto response2 (wait_response (system, rpc, request));
std::string frontier (response2.get<std::string> ("frontier"));
ASSERT_EQ (nano::genesis_hash.to_string (), frontier);
ASSERT_EQ (nano::dev::genesis->hash ().to_string (), frontier);
boost::optional<std::string> deprecated_account_format2 (response2.get_optional<std::string> ("deprecated_account_format"));
ASSERT_TRUE (deprecated_account_format2.is_initialized ());
}
@ -5634,7 +5634,7 @@ TEST (rpc, epoch_upgrade)
auto node = add_ipc_enabled_node (system);
nano::keypair key1, key2, key3;
nano::keypair epoch_signer (nano::dev_genesis_key);
auto send1 (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, nano::genesis_hash, nano::dev_genesis_key.pub, nano::genesis_amount - 1, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash))); // to opened account
auto send1 (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, nano::dev::genesis->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 1, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); // to opened account
ASSERT_EQ (nano::process_result::progress, node->process (*send1).code);
auto send2 (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, send1->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 2, key2.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1->hash ()))); // to unopened account (pending)
ASSERT_EQ (nano::process_result::progress, node->process (*send2).code);
@ -5728,7 +5728,7 @@ TEST (rpc, epoch_upgrade_multithreaded)
auto node = add_ipc_enabled_node (system, node_config);
nano::keypair key1, key2, key3;
nano::keypair epoch_signer (nano::dev_genesis_key);
auto send1 (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, nano::genesis_hash, nano::dev_genesis_key.pub, nano::genesis_amount - 1, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash))); // to opened account
auto send1 (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, nano::dev::genesis->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 1, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); // to opened account
ASSERT_EQ (nano::process_result::progress, node->process (*send1).code);
auto send2 (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, send1->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 2, key2.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1->hash ()))); // to unopened account (pending)
ASSERT_EQ (nano::process_result::progress, node->process (*send2).code);
@ -5821,7 +5821,7 @@ TEST (rpc, account_lazy_start)
auto node1 = system.add_node (node_flags);
nano::keypair key;
// Generating test chain
auto send1 (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, nano::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, *system.work.generate (nano::genesis_hash)));
auto send1 (std::make_shared<nano::state_block> (nano::dev_genesis_key.pub, nano::dev::genesis->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code);
auto open (std::make_shared<nano::open_block> (send1->hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)));
ASSERT_EQ (nano::process_result::progress, node1->process (*open).code);
@ -5857,7 +5857,7 @@ TEST (rpc, receive)
wallet->insert_adhoc (nano::dev_genesis_key.prv);
nano::keypair key1;
wallet->insert_adhoc (key1.prv);
auto send1 (wallet->send_action (nano::dev_genesis_key.pub, key1.pub, node->config.receive_minimum.number (), *node->work_generate_blocking (nano::genesis_hash)));
auto send1 (wallet->send_action (nano::dev_genesis_key.pub, key1.pub, node->config.receive_minimum.number (), *node->work_generate_blocking (nano::dev::genesis->hash ())));
ASSERT_TIMELY (5s, node->balance (nano::dev_genesis_key.pub) != nano::genesis_amount);
ASSERT_TIMELY (10s, !node->store.account.exists (node->store.tx_begin_read (), key1.pub));
// Send below minimum receive amount
@ -5898,7 +5898,7 @@ TEST (rpc, receive_unopened)
wallet->insert_adhoc (nano::dev_genesis_key.prv);
// Test receiving for unopened account
nano::keypair key1;
auto send1 (wallet->send_action (nano::dev_genesis_key.pub, key1.pub, node->config.receive_minimum.number () - 1, *node->work_generate_blocking (nano::genesis_hash)));
auto send1 (wallet->send_action (nano::dev_genesis_key.pub, key1.pub, node->config.receive_minimum.number () - 1, *node->work_generate_blocking (nano::dev::genesis->hash ())));
ASSERT_TIMELY (5s, !node->balance (nano::dev_genesis_key.pub) != nano::genesis_amount);
ASSERT_FALSE (node->store.account.exists (node->store.tx_begin_read (), key1.pub));
ASSERT_TRUE (node->store.block.exists (node->store.tx_begin_read (), send1->hash ()));
@ -5993,7 +5993,7 @@ TEST (rpc, receive_pruned)
wallet1->insert_adhoc (nano::dev_genesis_key.prv);
nano::keypair key1;
wallet2->insert_adhoc (key1.prv);
auto send1 (wallet1->send_action (nano::dev_genesis_key.pub, key1.pub, node2->config.receive_minimum.number (), *node2->work_generate_blocking (nano::genesis_hash)));
auto send1 (wallet1->send_action (nano::dev_genesis_key.pub, key1.pub, node2->config.receive_minimum.number (), *node2->work_generate_blocking (nano::dev::genesis->hash ())));
ASSERT_TIMELY (5s, node2->balance (nano::dev_genesis_key.pub) != nano::genesis_amount);
ASSERT_TIMELY (10s, !node2->store.account.exists (node2->store.tx_begin_read (), key1.pub));
// Send below minimum receive amount

3
nano/secure/common.cpp
View file

@ -79,6 +79,9 @@ char const * live_canary_public_key_data = "7CBAF192A3763DAEC9F9BAC1B2CDF665D836
std::string const test_canary_public_key_data = nano::get_env_or_default ("NANO_TEST_CANARY_PUB", "3BAD2C554ACE05F5E528FBBCE79D51E552C55FA765CCFD89B289C4835DE5F04A"); // nano_1gxf7jcnomi7yqkkjyxwwygo5sckrohtgsgezp6u74g6ifgydw4cajwbk8bf
}
nano::ledger_constants nano::dev::constants{ nano::networks::nano_dev_network };
std::shared_ptr<nano::block> & nano::dev::genesis = nano::dev::constants.genesis;
nano::network_params::network_params () :
network_params (network_constants::active_network)
{

6
nano/secure/common.hpp
View file

@ -396,6 +396,12 @@ public:
nano::epochs epochs;
};
namespace dev
{
extern nano::ledger_constants constants;
extern std::shared_ptr<nano::block> & genesis;
}
/** Constants which depend on random values (this class should never be used globally due to CryptoPP globals potentially not being initialized) */
class random_constants
{

6
nano/slow_test/node.cpp
View file

@ -483,7 +483,7 @@ TEST (node, mass_vote_by_hash)
{
nano::system system (1);
system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv);
nano::block_hash previous (nano::genesis_hash);
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)
@ -979,7 +979,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections)
auto const num_accounts = 100000;
auto latest_genesis = nano::genesis_hash;
auto latest_genesis = nano::dev::genesis->hash ();
std::vector<nano::keypair> keys;
std::vector<std::shared_ptr<nano::open_block>> open_blocks;
@ -1828,7 +1828,7 @@ TEST (node, wallet_create_block_confirm_conflicts)
auto const num_blocks = 10000;
// First open the other account
auto latest = nano::genesis_hash;
auto latest = nano::dev::genesis->hash ();
nano::keypair key1;
{
auto transaction = node->store.tx_begin_write ();

2
nano/test_common/system.cpp
View file

@ -151,7 +151,7 @@ nano::system::~system ()
void nano::system::ledger_initialization_set (std::vector<nano::keypair> const & reps, nano::amount const & reserve)
{
nano::block_hash previous = nano::genesis_hash;
nano::block_hash previous = nano::dev::genesis->hash ();
auto amount = (nano::genesis_amount - reserve.number ()) / reps.size ();
auto balance = nano::genesis_amount;
for (auto const & i : reps)

1
nano/test_common/testutil.cpp
View file

@ -19,7 +19,6 @@ nano::keypair const & nano::zero_key (dev_constants.zero_key);
nano::keypair const & nano::dev_genesis_key (dev_constants.dev_genesis_key);
nano::account const & nano::nano_dev_account (dev_constants.nano_dev_account);
nano::account const & nano::genesis_account (dev_constants.genesis_account ());
nano::block_hash const & nano::genesis_hash (dev_constants.genesis_hash ());
nano::uint128_t const & nano::genesis_amount (dev_constants.genesis_amount);
nano::account const & nano::burn_account (dev_constants.burn_account);

1
nano/test_common/testutil.hpp
View file

@ -55,7 +55,6 @@ class system;
extern nano::keypair const & zero_key;
extern nano::keypair const & dev_genesis_key;
extern nano::block_hash const & genesis_hash;
extern nano::public_key const & nano_dev_account;
extern nano::public_key const & genesis_account;
extern nano::public_key const & burn_account;