diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index 3154b0d8..d7cdd33a 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -584,7 +584,7 @@ TEST (active_transactions, dropped_cleanup) nano::genesis genesis; auto block = genesis.open; - block->sideband_set (nano::block_sideband (nano::genesis_account, 0, nano::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); + block->sideband_set (nano::block_sideband (nano::dev::genesis->account (), 0, nano::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); // Add to network filter to ensure proper cleanup after the election is dropped std::vector block_bytes; @@ -1232,7 +1232,7 @@ TEST (active_transactions, pessimistic_elections) ASSERT_EQ (2, node.active.expired_optimistic_election_infos.size ()); ASSERT_EQ (2, node.active.expired_optimistic_election_infos.size ()); auto election_started_it = node.active.expired_optimistic_election_infos.get ().begin (); - ASSERT_EQ (election_started_it->account, nano::genesis_account); + ASSERT_EQ (election_started_it->account, nano::dev::genesis->account ()); ASSERT_EQ (election_started_it->election_started, true); ASSERT_EQ ((++election_started_it)->election_started, false); @@ -1253,7 +1253,7 @@ TEST (active_transactions, pessimistic_elections) nano::confirmation_height_info key1_confirmation_height_info; { auto transaction = node.store.tx_begin_read (); - node.store.confirmation_height.get (transaction, nano::genesis_account, genesis_confirmation_height_info); + node.store.confirmation_height.get (transaction, nano::dev::genesis->account (), genesis_confirmation_height_info); ASSERT_EQ (2, genesis_confirmation_height_info.height); node.store.confirmation_height.get (transaction, key.pub, key1_confirmation_height_info); ASSERT_EQ (0, key1_confirmation_height_info.height); @@ -1275,7 +1275,7 @@ TEST (active_transactions, pessimistic_elections) { auto transaction = node.store.tx_begin_read (); - node.store.confirmation_height.get (transaction, nano::genesis_account, genesis_confirmation_height_info); + node.store.confirmation_height.get (transaction, nano::dev::genesis->account (), genesis_confirmation_height_info); ASSERT_EQ (3, genesis_confirmation_height_info.height); node.store.confirmation_height.get (transaction, key.pub, key1_confirmation_height_info); ASSERT_EQ (0, key1_confirmation_height_info.height); @@ -1299,7 +1299,7 @@ TEST (active_transactions, pessimistic_elections) { auto transaction = node.store.tx_begin_read (); - node.store.confirmation_height.get (transaction, nano::genesis_account, genesis_confirmation_height_info); + node.store.confirmation_height.get (transaction, nano::dev::genesis->account (), genesis_confirmation_height_info); ASSERT_EQ (3, genesis_confirmation_height_info.height); node.store.confirmation_height.get (transaction, key.pub, key1_confirmation_height_info); ASSERT_EQ (1, key1_confirmation_height_info.height); diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index 995b8dad..0897a255 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -330,7 +330,7 @@ TEST (block_store, genesis) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger_cache); nano::account_info info; - ASSERT_FALSE (store->account.get (transaction, nano::genesis_account, info)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis->account (), info)); ASSERT_EQ (hash, info.head); auto block1 (store->block.get (transaction, info.head)); ASSERT_NE (nullptr, block1); @@ -340,13 +340,13 @@ TEST (block_store, genesis) ASSERT_EQ (info.block_count, 1); // Genesis block should be confirmed by default nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (store->confirmation_height.get (transaction, nano::genesis_account, confirmation_height_info)); + ASSERT_FALSE (store->confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (confirmation_height_info.height, 1); ASSERT_EQ (confirmation_height_info.frontier, hash); auto dev_pub_text (nano::dev_genesis_key.pub.to_string ()); auto dev_pub_account (nano::dev_genesis_key.pub.to_account ()); auto dev_prv_text (nano::dev_genesis_key.prv.to_string ()); - ASSERT_EQ (nano::genesis_account, nano::dev_genesis_key.pub); + ASSERT_EQ (nano::dev::genesis->account (), nano::dev_genesis_key.pub); } TEST (bootstrap, simple) @@ -689,10 +689,10 @@ TEST (mdb_block_store, supported_version_upgrades) store.initialize (transaction, ledger.cache); // Lower the database version to the minimum version supported for upgrade. store.version.put (transaction, store.minimum_version); - store.confirmation_height.del (transaction, nano::genesis_account); + store.confirmation_height.del (transaction, nano::dev::genesis->account ()); ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "accounts_v1", MDB_CREATE, &store.accounts_v1_handle)); ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks_handle)); - modify_account_info_to_v14 (store, transaction, nano::genesis_account, 1, nano::dev::genesis->hash ()); + modify_account_info_to_v14 (store, transaction, nano::dev::genesis->account (), 1, nano::dev::genesis->hash ()); write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::genesis ().open); } @@ -1285,9 +1285,9 @@ TEST (mdb_block_store, upgrade_v14_v15) auto transaction (store.tx_begin_write ()); store.initialize (transaction, ledger.cache); nano::account_info account_info; - ASSERT_FALSE (store.account.get (transaction, nano::genesis_account, account_info)); + ASSERT_FALSE (store.account.get (transaction, nano::dev::genesis->account (), account_info)); nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (store.confirmation_height.get (transaction, nano::genesis_account, confirmation_height_info)); + ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (confirmation_height_info.height, 1); ASSERT_EQ (confirmation_height_info.frontier, genesis.hash ()); // These databases get removed after an upgrade, so readd them @@ -1302,10 +1302,10 @@ TEST (mdb_block_store, upgrade_v14_v15) ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_send).code); // Lower the database to the previous version store.version.put (transaction, 14); - store.confirmation_height.del (transaction, nano::genesis_account); - modify_account_info_to_v14 (store, transaction, nano::genesis_account, confirmation_height_info.height, state_send.hash ()); + store.confirmation_height.del (transaction, nano::dev::genesis->account ()); + modify_account_info_to_v14 (store, transaction, nano::dev::genesis->account (), confirmation_height_info.height, state_send.hash ()); - store.pending.del (transaction, nano::pending_key (nano::genesis_account, state_send.hash ())); + store.pending.del (transaction, nano::pending_key (nano::dev::genesis->account (), state_send.hash ())); write_sideband_v14 (store, transaction, state_send, store.state_blocks_v1_handle); write_sideband_v14 (store, transaction, epoch, store.state_blocks_v1_handle); @@ -1317,18 +1317,18 @@ TEST (mdb_block_store, upgrade_v14_v15) store.block.del (transaction, epoch.hash ()); // Turn pending into v14 - ASSERT_FALSE (mdb_put (store.env.tx (transaction), store.pending_v0_handle, nano::mdb_val (nano::pending_key (nano::dev_genesis_key.pub, send.hash ())), nano::mdb_val (nano::pending_info_v14 (nano::genesis_account, nano::Gxrb_ratio, nano::epoch::epoch_0)), 0)); - ASSERT_FALSE (mdb_put (store.env.tx (transaction), store.pending_v1_handle, nano::mdb_val (nano::pending_key (nano::dev_genesis_key.pub, state_send.hash ())), nano::mdb_val (nano::pending_info_v14 (nano::genesis_account, nano::Gxrb_ratio, nano::epoch::epoch_1)), 0)); + ASSERT_FALSE (mdb_put (store.env.tx (transaction), store.pending_v0_handle, nano::mdb_val (nano::pending_key (nano::dev_genesis_key.pub, send.hash ())), nano::mdb_val (nano::pending_info_v14 (nano::dev::genesis->account (), nano::Gxrb_ratio, nano::epoch::epoch_0)), 0)); + ASSERT_FALSE (mdb_put (store.env.tx (transaction), store.pending_v1_handle, nano::mdb_val (nano::pending_key (nano::dev_genesis_key.pub, state_send.hash ())), nano::mdb_val (nano::pending_info_v14 (nano::dev::genesis->account (), nano::Gxrb_ratio, nano::epoch::epoch_1)), 0)); // This should fail as sizes are no longer correct for account_info nano::mdb_val value; - ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.accounts_v1_handle, nano::mdb_val (nano::genesis_account), value)); + ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.accounts_v1_handle, nano::mdb_val (nano::dev::genesis->account ()), value)); nano::account_info info; ASSERT_NE (value.size (), info.db_size ()); - store.account.del (transaction, nano::genesis_account); + store.account.del (transaction, nano::dev::genesis->account ()); // Confirmation height for the account should be deleted - ASSERT_TRUE (mdb_get (store.env.tx (transaction), store.confirmation_height_handle, nano::mdb_val (nano::genesis_account), value)); + ASSERT_TRUE (mdb_get (store.env.tx (transaction), store.confirmation_height_handle, nano::mdb_val (nano::dev::genesis->account ()), value)); } // Now do the upgrade @@ -1339,18 +1339,18 @@ TEST (mdb_block_store, upgrade_v14_v15) // Size of account_info should now equal that set in db nano::mdb_val value; - ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.accounts_handle, nano::mdb_val (nano::genesis_account), value)); + ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.accounts_handle, nano::mdb_val (nano::dev::genesis->account ()), value)); nano::account_info info (value); ASSERT_EQ (value.size (), info.db_size ()); // Confirmation height should exist nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (store.confirmation_height.get (transaction, nano::genesis_account, confirmation_height_info)); + ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (confirmation_height_info.height, 1); ASSERT_EQ (confirmation_height_info.frontier, genesis.hash ()); // accounts_v1, state_blocks_v1 & pending_v1 tables should be deleted - auto error_get_accounts_v1 (mdb_get (store.env.tx (transaction), store.accounts_v1_handle, nano::mdb_val (nano::genesis_account), value)); + auto error_get_accounts_v1 (mdb_get (store.env.tx (transaction), store.accounts_v1_handle, nano::mdb_val (nano::dev::genesis->account ()), value)); ASSERT_NE (error_get_accounts_v1, MDB_SUCCESS); auto error_get_pending_v1 (mdb_get (store.env.tx (transaction), store.pending_v1_handle, nano::mdb_val (nano::pending_key (nano::dev_genesis_key.pub, state_send.hash ())), value)); ASSERT_NE (error_get_pending_v1, MDB_SUCCESS); @@ -1395,15 +1395,15 @@ TEST (mdb_block_store, upgrade_v15_v16) // The representation table should get removed after, so readd it so that we can later confirm this actually happens auto txn = store.env.tx (transaction); ASSERT_FALSE (mdb_dbi_open (txn, "representation", MDB_CREATE, &store.representation_handle)); - auto weight = ledger.cache.rep_weights.representation_get (nano::genesis_account); - ASSERT_EQ (MDB_SUCCESS, mdb_put (txn, store.representation_handle, nano::mdb_val (nano::genesis_account), nano::mdb_val (nano::uint128_union (weight)), 0)); + auto weight = ledger.cache.rep_weights.representation_get (nano::dev::genesis->account ()); + ASSERT_EQ (MDB_SUCCESS, mdb_put (txn, store.representation_handle, nano::mdb_val (nano::dev::genesis->account ()), nano::mdb_val (nano::uint128_union (weight)), 0)); ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks_handle)); write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *genesis.open); // Lower the database to the previous version store.version.put (transaction, 15); // Confirm the rep weight exists in the database - ASSERT_EQ (MDB_SUCCESS, mdb_get (store.env.tx (transaction), store.representation_handle, nano::mdb_val (nano::genesis_account), value)); - store.confirmation_height.del (transaction, nano::genesis_account); + ASSERT_EQ (MDB_SUCCESS, mdb_get (store.env.tx (transaction), store.representation_handle, nano::mdb_val (nano::dev::genesis->account ()), value)); + store.confirmation_height.del (transaction, nano::dev::genesis->account ()); } // Now do the upgrade @@ -1413,7 +1413,7 @@ TEST (mdb_block_store, upgrade_v15_v16) auto transaction (store.tx_begin_read ()); // The representation table should now be deleted - auto error_get_representation (mdb_get (store.env.tx (transaction), store.representation_handle, nano::mdb_val (nano::genesis_account), value)); + auto error_get_representation (mdb_get (store.env.tx (transaction), store.representation_handle, nano::mdb_val (nano::dev::genesis->account ()), value)); ASSERT_NE (MDB_SUCCESS, error_get_representation); ASSERT_EQ (store.representation_handle, 0); @@ -1448,7 +1448,7 @@ TEST (mdb_block_store, upgrade_v16_v17) ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block3).code); - modify_confirmation_height_to_v15 (store, transaction, nano::genesis_account, confirmation_height); + modify_confirmation_height_to_v15 (store, transaction, nano::dev::genesis->account (), confirmation_height); ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks_handle)); write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *genesis.open); @@ -1468,7 +1468,7 @@ TEST (mdb_block_store, upgrade_v16_v17) auto transaction (store.tx_begin_read ()); nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (store.confirmation_height.get (transaction, nano::genesis_account, confirmation_height_info)); + ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (confirmation_height_info.height, confirmation_height); // Check confirmation height frontier is correct diff --git a/nano/core_test/bootstrap.cpp b/nano/core_test/bootstrap.cpp index a3a14b45..ef13cba3 100644 --- a/nano/core_test/bootstrap.cpp +++ b/nano/core_test/bootstrap.cpp @@ -1867,9 +1867,9 @@ TEST (bulk_pull_account, basics) nano::keypair key1; system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); system.wallet (0)->insert_adhoc (key1.prv); - auto send1 (system.wallet (0)->send_action (nano::genesis_account, key1.pub, 25)); - auto send2 (system.wallet (0)->send_action (nano::genesis_account, key1.pub, 10)); - auto send3 (system.wallet (0)->send_action (nano::genesis_account, key1.pub, 2)); + auto send1 (system.wallet (0)->send_action (nano::dev::genesis->account (), key1.pub, 25)); + auto send2 (system.wallet (0)->send_action (nano::dev::genesis->account (), key1.pub, 10)); + auto send3 (system.wallet (0)->send_action (nano::dev::genesis->account (), key1.pub, 2)); ASSERT_TIMELY (5s, system.nodes[0]->balance (key1.pub) == 25); auto connection (std::make_shared (std::make_shared (*system.nodes[0]), system.nodes[0])); @@ -1888,7 +1888,7 @@ TEST (bulk_pull_account, basics) auto block_data (request->get_next ()); ASSERT_EQ (send2->hash (), block_data.first.get ()->hash); ASSERT_EQ (nano::uint128_union (10), block_data.second.get ()->amount); - ASSERT_EQ (nano::genesis_account, block_data.second.get ()->source); + ASSERT_EQ (nano::dev::genesis->account (), block_data.second.get ()->source); ASSERT_EQ (nullptr, request->get_next ().first.get ()); } @@ -1902,7 +1902,7 @@ TEST (bulk_pull_account, basics) auto block_data (request->get_next ()); ASSERT_NE (nullptr, block_data.first.get ()); ASSERT_NE (nullptr, block_data.second.get ()); - ASSERT_EQ (nano::genesis_account, block_data.second.get ()->source); + ASSERT_EQ (nano::dev::genesis->account (), block_data.second.get ()->source); block_data = request->get_next (); ASSERT_EQ (nullptr, block_data.first.get ()); ASSERT_EQ (nullptr, block_data.second.get ()); diff --git a/nano/core_test/confirmation_height.cpp b/nano/core_test/confirmation_height.cpp index f42df2da..6dba764a 100644 --- a/nano/core_test/confirmation_height.cpp +++ b/nano/core_test/confirmation_height.cpp @@ -98,9 +98,9 @@ TEST (confirmation_height, multiple_accounts) nano::send_block send3 (send2.hash (), key3.pub, node->online_reps.delta () + 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send2.hash ())); // Open all accounts - nano::open_block open1 (send1.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); - nano::open_block open2 (send2.hash (), nano::genesis_account, key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub)); - nano::open_block open3 (send3.hash (), nano::genesis_account, key3.pub, key3.prv, key3.pub, *system.work.generate (key3.pub)); + nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); + nano::open_block open2 (send2.hash (), nano::dev::genesis->account (), key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub)); + nano::open_block open3 (send3.hash (), nano::dev::genesis->account (), key3.pub, key3.prv, key3.pub, *system.work.generate (key3.pub)); // Send and receive various blocks to these accounts nano::send_block send4 (open1.hash (), key2.pub, 50, key1.prv, key1.pub, *system.work.generate (open1.hash ())); @@ -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::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send1 (std::make_shared (nano::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::genesis_account, send1->hash (), nano::genesis_account, nano::genesis_amount - 2 * nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send2 (std::make_shared (nano::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::genesis_account, send2->hash (), nano::genesis_account, nano::genesis_amount - 3 * nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send3 (std::make_shared (nano::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 (send1->hash (), destination.pub, destination.pub, destination.prv, destination.pub, 0)); node1.work_generate_blocking (*open1); @@ -311,11 +311,11 @@ TEST (confirmation_height, gap_live) system.wallet (1)->insert_adhoc (destination.prv); nano::genesis genesis; - auto send1 (std::make_shared (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - 1, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send1 (std::make_shared (nano::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::genesis_account, send1->hash (), nano::genesis_account, nano::genesis_amount - 2, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send2 (std::make_shared (nano::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::genesis_account, send2->hash (), nano::genesis_account, nano::genesis_amount - 3, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send3 (std::make_shared (nano::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 (send1->hash (), destination.pub, destination.pub, destination.prv, destination.pub, 0)); @@ -396,10 +396,10 @@ TEST (confirmation_height, send_receive_between_2_accounts) nano::send_block send1 (latest, key1.pub, node->online_reps.delta () + 2, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); - nano::open_block open1 (send1.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); - nano::send_block send2 (open1.hash (), nano::genesis_account, 1000, key1.prv, key1.pub, *system.work.generate (open1.hash ())); - nano::send_block send3 (send2.hash (), nano::genesis_account, 900, key1.prv, key1.pub, *system.work.generate (send2.hash ())); - nano::send_block send4 (send3.hash (), nano::genesis_account, 500, key1.prv, key1.pub, *system.work.generate (send3.hash ())); + nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); + nano::send_block send2 (open1.hash (), nano::dev::genesis->account (), 1000, key1.prv, key1.pub, *system.work.generate (open1.hash ())); + nano::send_block send3 (send2.hash (), nano::dev::genesis->account (), 900, key1.prv, key1.pub, *system.work.generate (send2.hash ())); + nano::send_block send4 (send3.hash (), nano::dev::genesis->account (), 500, key1.prv, key1.pub, *system.work.generate (send3.hash ())); nano::receive_block receive1 (send1.hash (), send2.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1.hash ())); nano::receive_block receive2 (receive1.hash (), send3.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (receive1.hash ())); @@ -569,7 +569,7 @@ TEST (confirmation_height, all_block_types) nano::state_block state_send3 (key2.pub, state_send2->hash (), 0, nano::Gxrb_ratio - 1, key1.pub, key2.prv, key2.pub, *system.work.generate (state_send2->hash ())); nano::state_block state_send4 (key1.pub, state_send1.hash (), 0, nano::Gxrb_ratio - 2, nano::dev_genesis_key.pub, key1.prv, key1.pub, *system.work.generate (state_send1.hash ())); - nano::state_block state_receive3 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio * 2 + 1, state_send4.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1.hash ())); + nano::state_block state_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 ()); @@ -683,12 +683,12 @@ TEST (confirmation_height, conflict_rollback_cemented) { auto transaction (node1->store.tx_begin_write ()); ASSERT_TRUE (node1->store.block.exists (transaction, publish1.block->hash ())); - node1->store.confirmation_height.put (transaction, nano::genesis_account, nano::confirmation_height_info{ 2, send2->hash () }); + node1->store.confirmation_height.put (transaction, nano::dev::genesis->account (), nano::confirmation_height_info{ 2, send2->hash () }); } { auto transaction (node2->store.tx_begin_write ()); ASSERT_TRUE (node2->store.block.exists (transaction, publish2.block->hash ())); - node2->store.confirmation_height.put (transaction, nano::genesis_account, nano::confirmation_height_info{ 2, send2->hash () }); + node2->store.confirmation_height.put (transaction, nano::dev::genesis->account (), nano::confirmation_height_info{ 2, send2->hash () }); } auto rollback_log_entry = boost::str (boost::format ("Failed to roll back %1%") % send2->hash ().to_string ()); @@ -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::dev::genesis->hash () }); + store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () }); nano::confirmation_height_unbounded unbounded_processor ( ledger, write_database_queue, 10ms, logging, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); @@ -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::dev::genesis->hash () }); + store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () }); nano::confirmation_height_bounded bounded_processor ( ledger, write_database_queue, 10ms, logging, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); @@ -1120,7 +1120,7 @@ TEST (confirmation_height, cemented_gap_below_receive) 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::open_block open (send.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); + nano::open_block open (send.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); nano::receive_block receive1 (open.hash (), send1.hash (), key1.prv, key1.pub, *system.work.generate (open.hash ())); nano::send_block send2 (receive1.hash (), nano::dev_genesis_key.pub, nano::Gxrb_ratio, key1.prv, key1.pub, *system.work.generate (receive1.hash ())); @@ -1132,7 +1132,7 @@ TEST (confirmation_height, cemented_gap_below_receive) 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 (send3.hash (), nano::genesis_account, key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub)); + auto open1 = std::make_shared (send3.hash (), nano::dev::genesis->account (), key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub)); { auto transaction = node->store.tx_begin_write (); @@ -1205,7 +1205,7 @@ TEST (confirmation_height, cemented_gap_below_no_cache) 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::open_block open (send.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); + nano::open_block open (send.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); nano::receive_block receive1 (open.hash (), send1.hash (), key1.prv, key1.pub, *system.work.generate (open.hash ())); nano::send_block send2 (receive1.hash (), nano::dev_genesis_key.pub, nano::Gxrb_ratio, key1.prv, key1.pub, *system.work.generate (receive1.hash ())); @@ -1217,7 +1217,7 @@ TEST (confirmation_height, cemented_gap_below_no_cache) 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 (send3.hash (), nano::genesis_account, key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub)); + auto open1 = std::make_shared (send3.hash (), nano::dev::genesis->account (), key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub)); { auto transaction = node->store.tx_begin_write (); @@ -1241,7 +1241,7 @@ TEST (confirmation_height, cemented_gap_below_no_cache) // Force some blocks to be cemented so that the cached confirmed info variable is empty { auto transaction (node->store.tx_begin_write ()); - node->store.confirmation_height.put (transaction, nano::genesis_account, nano::confirmation_height_info{ 3, send1.hash () }); + node->store.confirmation_height.put (transaction, nano::dev::genesis->account (), nano::confirmation_height_info{ 3, send1.hash () }); node->store.confirmation_height.put (transaction, key1.pub, nano::confirmation_height_info{ 2, receive1.hash () }); } diff --git a/nano/core_test/election.cpp b/nano/core_test/election.cpp index 4afcfb0e..3c0d77e3 100644 --- a/nano/core_test/election.cpp +++ b/nano/core_test/election.cpp @@ -11,7 +11,7 @@ TEST (election, construction) nano::system system (1); nano::genesis genesis; auto & node = *system.nodes[0]; - genesis.open->sideband_set (nano::block_sideband (nano::genesis_account, 0, nano::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); + genesis.open->sideband_set (nano::block_sideband (nano::dev::genesis->account (), 0, nano::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); node.block_confirm (genesis.open); node.scheduler.flush (); auto election = node.active.election (genesis.open->qualified_root ()); diff --git a/nano/core_test/frontiers_confirmation.cpp b/nano/core_test/frontiers_confirmation.cpp index faa6edea..ea4674df 100644 --- a/nano/core_test/frontiers_confirmation.cpp +++ b/nano/core_test/frontiers_confirmation.cpp @@ -31,16 +31,16 @@ TEST (frontiers_confirmation, prioritize_frontiers) nano::send_block send6 (send5.hash (), key4.pub, node->config.online_weight_minimum.number () + 6000, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send5.hash ())); // Open all accounts and add other sends to get different uncemented counts (as well as some which are the same) - nano::open_block open1 (send1.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); + nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); nano::send_block send7 (open1.hash (), nano::dev_genesis_key.pub, 500, key1.prv, key1.pub, *system.work.generate (open1.hash ())); - nano::open_block open2 (send4.hash (), nano::genesis_account, key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub)); + nano::open_block open2 (send4.hash (), nano::dev::genesis->account (), key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub)); - nano::open_block open3 (send5.hash (), nano::genesis_account, key3.pub, key3.prv, key3.pub, *system.work.generate (key3.pub)); + nano::open_block open3 (send5.hash (), nano::dev::genesis->account (), key3.pub, key3.prv, key3.pub, *system.work.generate (key3.pub)); nano::send_block send8 (open3.hash (), nano::dev_genesis_key.pub, 500, key3.prv, key3.pub, *system.work.generate (open3.hash ())); nano::send_block send9 (send8.hash (), nano::dev_genesis_key.pub, 200, key3.prv, key3.pub, *system.work.generate (send8.hash ())); - nano::open_block open4 (send6.hash (), nano::genesis_account, key4.pub, key4.prv, key4.pub, *system.work.generate (key4.pub)); + nano::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 ())); @@ -78,8 +78,8 @@ TEST (frontiers_confirmation, prioritize_frontiers) node->active.prioritize_frontiers_for_confirmation (transaction, std::chrono::seconds (1), std::chrono::seconds (1)); ASSERT_EQ (node->active.priority_cementable_frontiers_size (), num_accounts); // Check the order of accounts is as expected (greatest number of uncemented blocks at the front). key3 and key4 have the same value, the order is unspecified so check both - std::array desired_order_1{ nano::genesis_account, key3.pub, key4.pub, key1.pub, key2.pub }; - std::array desired_order_2{ nano::genesis_account, key4.pub, key3.pub, key1.pub, key2.pub }; + std::array desired_order_1{ nano::dev::genesis->account (), key3.pub, key4.pub, key1.pub, key2.pub }; + std::array desired_order_2{ nano::dev::genesis->account (), key4.pub, key3.pub, key1.pub, key2.pub }; ASSERT_TRUE (priority_orders_match (node->active.priority_cementable_frontiers, desired_order_1) || priority_orders_match (node->active.priority_cementable_frontiers, desired_order_2)); } @@ -91,7 +91,7 @@ TEST (frontiers_confirmation, prioritize_frontiers) node->active.prioritize_frontiers_for_confirmation (transaction, std::chrono::seconds (1), std::chrono::seconds (1)); ASSERT_EQ (node->active.priority_cementable_frontiers_size (), num_accounts - 3); ASSERT_EQ (node->active.priority_wallet_cementable_frontiers_size (), num_accounts - 2); - std::array local_desired_order{ nano::genesis_account, key1.pub, key2.pub }; + std::array local_desired_order{ nano::dev::genesis->account (), key1.pub, key2.pub }; ASSERT_TRUE (priority_orders_match (node->active.priority_wallet_cementable_frontiers, local_desired_order)); std::array desired_order_1{ key3.pub, key4.pub }; std::array desired_order_2{ key4.pub, key3.pub }; @@ -105,8 +105,8 @@ TEST (frontiers_confirmation, prioritize_frontiers) node->active.prioritize_frontiers_for_confirmation (transaction, std::chrono::seconds (1), std::chrono::seconds (1)); ASSERT_EQ (node->active.priority_cementable_frontiers_size (), 0); ASSERT_EQ (node->active.priority_wallet_cementable_frontiers_size (), num_accounts); - std::array desired_order_1{ nano::genesis_account, key3.pub, key4.pub, key1.pub, key2.pub }; - std::array desired_order_2{ nano::genesis_account, key4.pub, key3.pub, key1.pub, key2.pub }; + std::array desired_order_1{ nano::dev::genesis->account (), key3.pub, key4.pub, key1.pub, key2.pub }; + std::array desired_order_2{ nano::dev::genesis->account (), key4.pub, key3.pub, key1.pub, key2.pub }; ASSERT_TRUE (priority_orders_match (node->active.priority_wallet_cementable_frontiers, desired_order_1) || priority_orders_match (node->active.priority_wallet_cementable_frontiers, desired_order_2)); } @@ -128,7 +128,7 @@ TEST (frontiers_confirmation, prioritize_frontiers) } transaction.refresh (); node->active.prioritize_frontiers_for_confirmation (transaction, std::chrono::seconds (1), std::chrono::seconds (1)); - ASSERT_TRUE (priority_orders_match (node->active.priority_wallet_cementable_frontiers, std::array{ key3.pub, nano::genesis_account, key4.pub, key1.pub, key2.pub })); + ASSERT_TRUE (priority_orders_match (node->active.priority_wallet_cementable_frontiers, std::array{ key3.pub, nano::dev::genesis->account (), key4.pub, key1.pub, key2.pub })); uint64_t election_count = 0; node->active.confirm_prioritized_frontiers (transaction, 100, election_count); @@ -159,11 +159,11 @@ TEST (frontiers_confirmation, prioritize_frontiers_max_optimistic_elections) for (auto i = 0; i < max_optimistic_election_count * 2; ++i) { auto transaction = node->store.tx_begin_write (); - auto latest = node->latest (nano::genesis_account); + auto latest = node->latest (nano::dev::genesis->account ()); nano::keypair key; nano::send_block send (latest, key.pub, node->config.online_weight_minimum.number () + 10000, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); - nano::open_block open (send.hash (), nano::genesis_account, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); + nano::open_block open (send.hash (), nano::dev::genesis->account (), key.pub, key.prv, key.pub, *system.work.generate (key.pub)); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open).code); } diff --git a/nano/core_test/gap_cache.cpp b/nano/core_test/gap_cache.cpp index e4679c8a..c12624c1 100644 --- a/nano/core_test/gap_cache.cpp +++ b/nano/core_test/gap_cache.cpp @@ -69,8 +69,8 @@ TEST (gap_cache, gap_bootstrap) nano::keypair key; auto send (std::make_shared (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::genesis_account)); - ASSERT_EQ (nano::genesis_amount, node2.balance (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - 100, node1.balance (nano::dev::genesis->account ())); + ASSERT_EQ (nano::genesis_amount, node2.balance (nano::dev::genesis->account ())); // Confirm send block, allowing voting on the upcoming block node1.block_confirm (send); auto election = node1.active.election (send->qualified_root ()); @@ -81,9 +81,9 @@ TEST (gap_cache, gap_bootstrap) system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); auto latest_block (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, 100)); ASSERT_NE (nullptr, latest_block); - ASSERT_EQ (nano::genesis_amount - 200, node1.balance (nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, node2.balance (nano::genesis_account)); - ASSERT_TIMELY (10s, node2.balance (nano::genesis_account) == nano::genesis_amount - 200); + ASSERT_EQ (nano::genesis_amount - 200, node1.balance (nano::dev::genesis->account ())); + ASSERT_EQ (nano::genesis_amount, node2.balance (nano::dev::genesis->account ())); + ASSERT_TIMELY (10s, node2.balance (nano::dev::genesis->account ()) == nano::genesis_amount - 200); } TEST (gap_cache, two_dependencies) diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index bec09a76..01f322b0 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -49,19 +49,19 @@ TEST (ledger, genesis_balance) nano::genesis genesis; auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); - auto balance (ledger.account_balance (transaction, nano::genesis_account)); + auto balance (ledger.account_balance (transaction, nano::dev::genesis->account ())); ASSERT_EQ (nano::genesis_amount, balance); - auto amount (ledger.amount (transaction, nano::genesis_account)); + auto amount (ledger.amount (transaction, nano::dev::genesis->account ())); ASSERT_EQ (nano::genesis_amount, amount); nano::account_info info; - ASSERT_FALSE (store->account.get (transaction, nano::genesis_account, info)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis->account (), info)); ASSERT_EQ (1, ledger.cache.account_count); // Frontier time should have been updated when genesis balance was added ASSERT_GE (nano::seconds_since_epoch (), info.modified); ASSERT_LT (nano::seconds_since_epoch () - info.modified, 10); // Genesis block should be confirmed by default nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (store->confirmation_height.get (transaction, nano::genesis_account, confirmation_height_info)); + ASSERT_FALSE (store->confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (confirmation_height_info.height, 1); ASSERT_EQ (confirmation_height_info.frontier, genesis.hash ()); } @@ -76,7 +76,7 @@ TEST (ledger, process_modifies_sideband) nano::genesis genesis; store->initialize (store->tx_begin_write (), ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (store->tx_begin_write (), send1).code); ASSERT_EQ (send1.sideband ().timestamp, store->block.get (store->tx_begin_read (), send1.hash ())->sideband ().timestamp); } @@ -406,7 +406,7 @@ TEST (ledger, weight) nano::genesis genesis; auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::dev::genesis->account ())); } TEST (ledger, representative_change) @@ -1557,15 +1557,15 @@ TEST (ledger, block_destination_source) balance -= nano::Gxrb_ratio; nano::send_block block1 (genesis.hash (), dest.pub, balance, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); balance -= nano::Gxrb_ratio; - nano::send_block block2 (block1.hash (), nano::genesis_account, balance, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block1.hash ())); + nano::send_block block2 (block1.hash (), nano::dev::genesis->account (), balance, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block1.hash ())); balance += nano::Gxrb_ratio; nano::receive_block block3 (block2.hash (), block2.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block2.hash ())); balance -= nano::Gxrb_ratio; - nano::state_block block4 (nano::genesis_account, block3.hash (), nano::genesis_account, balance, dest.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block3.hash ())); + nano::state_block block4 (nano::dev::genesis->account (), block3.hash (), nano::dev::genesis->account (), balance, dest.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block3.hash ())); balance -= nano::Gxrb_ratio; - nano::state_block block5 (nano::genesis_account, block4.hash (), nano::genesis_account, balance, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block4.hash ())); + nano::state_block block5 (nano::dev::genesis->account (), block4.hash (), nano::dev::genesis->account (), balance, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block4.hash ())); balance += nano::Gxrb_ratio; - nano::state_block block6 (nano::genesis_account, block5.hash (), nano::genesis_account, balance, block5.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block5.hash ())); + nano::state_block block6 (nano::dev::genesis->account (), block5.hash (), nano::dev::genesis->account (), balance, block5.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block5.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block3).code); @@ -1575,13 +1575,13 @@ TEST (ledger, block_destination_source) ASSERT_EQ (balance, ledger.balance (transaction, block6.hash ())); ASSERT_EQ (dest.pub, ledger.block_destination (transaction, block1)); ASSERT_TRUE (ledger.block_source (transaction, block1).is_zero ()); - ASSERT_EQ (nano::genesis_account, ledger.block_destination (transaction, block2)); + ASSERT_EQ (nano::dev::genesis->account (), ledger.block_destination (transaction, block2)); ASSERT_TRUE (ledger.block_source (transaction, block2).is_zero ()); ASSERT_TRUE (ledger.block_destination (transaction, block3).is_zero ()); ASSERT_EQ (block2.hash (), ledger.block_source (transaction, block3)); ASSERT_EQ (dest.pub, ledger.block_destination (transaction, block4)); ASSERT_TRUE (ledger.block_source (transaction, block4).is_zero ()); - ASSERT_EQ (nano::genesis_account, ledger.block_destination (transaction, block5)); + ASSERT_EQ (nano::dev::genesis->account (), ledger.block_destination (transaction, block5)); ASSERT_TRUE (ledger.block_source (transaction, block5).is_zero ()); ASSERT_TRUE (ledger.block_destination (transaction, block6).is_zero ()); ASSERT_EQ (block5.hash (), ledger.block_source (transaction, block6)); @@ -1598,9 +1598,9 @@ TEST (ledger, state_account) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_EQ (nano::genesis_account, ledger.account (transaction, send1.hash ())); + ASSERT_EQ (nano::dev::genesis->account (), ledger.account (transaction, send1.hash ())); } TEST (ledger, state_send_receive) @@ -1614,7 +1614,7 @@ TEST (ledger, state_send_receive) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); auto send2 (store->block.get (transaction, send1.hash ())); @@ -1622,13 +1622,13 @@ TEST (ledger, state_send_receive) ASSERT_EQ (send1, *send2); ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); - ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); ASSERT_EQ (2, send2->sideband ().height); ASSERT_TRUE (send2->sideband ().details.is_send); ASSERT_FALSE (send2->sideband ().details.is_receive); ASSERT_FALSE (send2->sideband ().details.is_epoch); - nano::state_block receive1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block receive1 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::genesis_amount, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); ASSERT_TRUE (store->block.exists (transaction, receive1.hash ())); auto receive2 (store->block.get (transaction, receive1.hash ())); @@ -1636,8 +1636,8 @@ TEST (ledger, state_send_receive) ASSERT_EQ (receive1, *receive2); ASSERT_EQ (nano::genesis_amount, ledger.balance (transaction, receive1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); - ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::dev::genesis->account ())); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); ASSERT_EQ (3, receive2->sideband ().height); ASSERT_FALSE (receive2->sideband ().details.is_send); @@ -1656,7 +1656,7 @@ TEST (ledger, state_receive) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::send_block send1 (genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block send1 (genesis.hash (), nano::dev::genesis->account (), 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, send1).code); ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); auto send2 (store->block.get (transaction, send1.hash ())); @@ -1664,8 +1664,8 @@ TEST (ledger, state_receive) ASSERT_EQ (send1, *send2); ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); - nano::state_block receive1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); + nano::state_block receive1 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::genesis_amount, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); ASSERT_TRUE (store->block.exists (transaction, receive1.hash ())); auto receive2 (store->block.get (transaction, receive1.hash ())); @@ -1673,7 +1673,7 @@ TEST (ledger, state_receive) ASSERT_EQ (receive1, *receive2); ASSERT_EQ (nano::genesis_amount, ledger.balance (transaction, receive1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (3, receive2->sideband ().height); ASSERT_FALSE (receive2->sideband ().details.is_send); ASSERT_TRUE (receive2->sideband ().details.is_receive); @@ -1692,7 +1692,7 @@ TEST (ledger, state_rep_change) store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair rep; - nano::state_block change1 (nano::genesis_account, genesis.hash (), rep.pub, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block change1 (nano::dev::genesis->account (), genesis.hash (), rep.pub, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change1).code); ASSERT_TRUE (store->block.exists (transaction, change1.hash ())); auto change2 (store->block.get (transaction, change1.hash ())); @@ -1700,7 +1700,7 @@ TEST (ledger, state_rep_change) ASSERT_EQ (change1, *change2); ASSERT_EQ (nano::genesis_amount, ledger.balance (transaction, change1.hash ())); ASSERT_EQ (0, ledger.amount (transaction, change1.hash ())); - ASSERT_EQ (0, ledger.weight (nano::genesis_account)); + ASSERT_EQ (0, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (nano::genesis_amount, ledger.weight (rep.pub)); ASSERT_EQ (2, change2->sideband ().height); ASSERT_FALSE (change2->sideband ().details.is_send); @@ -1720,7 +1720,7 @@ TEST (ledger, state_open) store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (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, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); auto send2 (store->block.get (transaction, send1.hash ())); @@ -1728,9 +1728,9 @@ TEST (ledger, state_open) ASSERT_EQ (send1, *send2); ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (destination.pub, send1.hash ()))); - nano::state_block open1 (destination.pub, 0, nano::genesis_account, nano::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::state_block open1 (destination.pub, 0, nano::dev::genesis->account (), nano::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (destination.pub, send1.hash ()))); ASSERT_TRUE (store->block.exists (transaction, open1.hash ())); @@ -1739,7 +1739,7 @@ TEST (ledger, state_open) ASSERT_EQ (open1, *open2); ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, open1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, open1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (ledger.cache.account_count, store->account.count (transaction)); ASSERT_EQ (1, open2->sideband ().height); ASSERT_FALSE (open2->sideband ().details.is_send); @@ -1759,9 +1759,9 @@ TEST (ledger, send_after_state_fail) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::send_block send2 (send1.hash (), nano::genesis_account, nano::genesis_amount - (2 * nano::Gxrb_ratio), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::send_block send2 (send1.hash (), nano::dev::genesis->account (), nano::genesis_amount - (2 * nano::Gxrb_ratio), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, send2).code); } @@ -1777,7 +1777,7 @@ TEST (ledger, receive_after_state_fail) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); nano::receive_block receive1 (send1.hash (), send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, receive1).code); @@ -1795,7 +1795,7 @@ TEST (ledger, change_after_state_fail) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); nano::keypair rep; nano::change_block change1 (send1.hash (), rep.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); @@ -1813,7 +1813,7 @@ TEST (ledger, state_unreceivable_fail) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::send_block send1 (genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block send1 (genesis.hash (), nano::dev::genesis->account (), 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, send1).code); ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); auto send2 (store->block.get (transaction, send1.hash ())); @@ -1821,8 +1821,8 @@ TEST (ledger, state_unreceivable_fail) ASSERT_EQ (send1, *send2); ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); - nano::state_block receive1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); + nano::state_block receive1 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::genesis_amount, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::gap_source, ledger.process (transaction, receive1).code); } @@ -1837,7 +1837,7 @@ TEST (ledger, state_receive_bad_amount_fail) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::send_block send1 (genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block send1 (genesis.hash (), nano::dev::genesis->account (), 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, send1).code); ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); auto send2 (store->block.get (transaction, send1.hash ())); @@ -1845,8 +1845,8 @@ TEST (ledger, state_receive_bad_amount_fail) ASSERT_EQ (send1, *send2); ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); - nano::state_block receive1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); + nano::state_block receive1 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::balance_mismatch, ledger.process (transaction, receive1).code); } @@ -1861,10 +1861,10 @@ TEST (ledger, state_no_link_amount_fail) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); nano::keypair rep; - nano::state_block change1 (nano::genesis_account, send1.hash (), rep.pub, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block change1 (nano::dev::genesis->account (), send1.hash (), rep.pub, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::balance_mismatch, ledger.process (transaction, change1).code); } @@ -1879,7 +1879,7 @@ TEST (ledger, state_receive_wrong_account_fail) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); auto send2 (store->block.get (transaction, send1.hash ())); @@ -1887,9 +1887,9 @@ TEST (ledger, state_receive_wrong_account_fail) ASSERT_EQ (send1, *send2); ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); nano::keypair key; - nano::state_block receive1 (key.pub, 0, nano::genesis_account, nano::Gxrb_ratio, send1.hash (), key.prv, key.pub, *pool.generate (key.pub)); + nano::state_block receive1 (key.pub, 0, nano::dev::genesis->account (), nano::Gxrb_ratio, send1.hash (), key.prv, key.pub, *pool.generate (key.pub)); ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, receive1).code); } @@ -1905,11 +1905,11 @@ TEST (ledger, state_open_state_fork) store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (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, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::state_block open1 (destination.pub, 0, nano::genesis_account, nano::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::state_block open1 (destination.pub, 0, nano::dev::genesis->account (), nano::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); - nano::open_block open2 (send1.hash (), nano::genesis_account, destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::open_block open2 (send1.hash (), nano::dev::genesis->account (), destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, open2).code); ASSERT_EQ (open1.root (), open2.root ()); } @@ -1926,11 +1926,11 @@ TEST (ledger, state_state_open_fork) store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (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, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::open_block open1 (send1.hash (), nano::genesis_account, destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); - nano::state_block open2 (destination.pub, 0, nano::genesis_account, nano::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::state_block open2 (destination.pub, 0, nano::dev::genesis->account (), nano::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, open2).code); ASSERT_EQ (open1.root (), open2.root ()); ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); @@ -1948,9 +1948,9 @@ TEST (ledger, state_open_previous_fail) store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (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, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::state_block open1 (destination.pub, 1, nano::genesis_account, nano::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (1)); + nano::state_block open1 (destination.pub, 1, nano::dev::genesis->account (), nano::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (1)); ASSERT_EQ (nano::process_result::gap_previous, ledger.process (transaction, open1).code); } @@ -1966,9 +1966,9 @@ TEST (ledger, state_open_source_fail) store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (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, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::state_block open1 (destination.pub, 0, nano::genesis_account, 0, 0, destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::state_block open1 (destination.pub, 0, nano::dev::genesis->account (), 0, 0, destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::gap_source, ledger.process (transaction, open1).code); } @@ -1984,7 +1984,7 @@ TEST (ledger, state_send_change) store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair rep; - nano::state_block send1 (nano::genesis_account, genesis.hash (), rep.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), genesis.hash (), rep.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); auto send2 (store->block.get (transaction, send1.hash ())); @@ -1992,7 +1992,7 @@ TEST (ledger, state_send_change) ASSERT_EQ (send1, *send2); ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (0, ledger.weight (nano::genesis_account)); + ASSERT_EQ (0, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (rep.pub)); ASSERT_EQ (2, send2->sideband ().height); ASSERT_TRUE (send2->sideband ().details.is_send); @@ -2011,7 +2011,7 @@ TEST (ledger, state_receive_change) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); auto send2 (store->block.get (transaction, send1.hash ())); @@ -2019,9 +2019,9 @@ TEST (ledger, state_receive_change) ASSERT_EQ (send1, *send2); ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); nano::keypair rep; - nano::state_block receive1 (nano::genesis_account, send1.hash (), rep.pub, nano::genesis_amount, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block receive1 (nano::dev::genesis->account (), send1.hash (), rep.pub, nano::genesis_amount, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); ASSERT_TRUE (store->block.exists (transaction, receive1.hash ())); auto receive2 (store->block.get (transaction, receive1.hash ())); @@ -2029,7 +2029,7 @@ TEST (ledger, state_receive_change) ASSERT_EQ (receive1, *receive2); ASSERT_EQ (nano::genesis_amount, ledger.balance (transaction, receive1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1.hash ())); - ASSERT_EQ (0, ledger.weight (nano::genesis_account)); + ASSERT_EQ (0, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (nano::genesis_amount, ledger.weight (rep.pub)); ASSERT_EQ (3, receive2->sideband ().height); ASSERT_FALSE (receive2->sideband ().details.is_send); @@ -2049,13 +2049,13 @@ TEST (ledger, state_open_old) store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (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, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::open_block open1 (send1.hash (), nano::genesis_account, destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, open1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, open1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::dev::genesis->account ())); } TEST (ledger, state_receive_old) @@ -2070,17 +2070,17 @@ TEST (ledger, state_receive_old) store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (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, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::state_block send2 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - (2 * nano::Gxrb_ratio), destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block send2 (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, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); - nano::open_block open1 (send1.hash (), nano::genesis_account, destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); nano::receive_block receive1 (open1.hash (), send2.hash (), destination.prv, destination.pub, *pool.generate (open1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); ASSERT_EQ (2 * nano::Gxrb_ratio, ledger.balance (transaction, receive1.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::dev::genesis->account ())); } TEST (ledger, state_rollback_send) @@ -2094,23 +2094,23 @@ TEST (ledger, state_rollback_send) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); auto send2 (store->block.get (transaction, send1.hash ())); ASSERT_NE (nullptr, send2); ASSERT_EQ (send1, *send2); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); nano::pending_info info; - ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::genesis_account, send1.hash ()), info)); - ASSERT_EQ (nano::genesis_account, info.source); + ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()), info)); + ASSERT_EQ (nano::dev::genesis->account (), info.source); ASSERT_EQ (nano::Gxrb_ratio, info.amount.number ()); ASSERT_FALSE (ledger.rollback (transaction, send1.hash ())); ASSERT_FALSE (store->block.exists (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); - ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::dev::genesis->account ())); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); ASSERT_TRUE (store->block.successor (transaction, genesis.hash ()).is_zero ()); ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); } @@ -2126,19 +2126,19 @@ TEST (ledger, state_rollback_receive) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::state_block receive1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block receive1 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::genesis_amount, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::genesis_account, receive1.hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), receive1.hash ()))); ASSERT_FALSE (ledger.rollback (transaction, receive1.hash ())); nano::pending_info info; - ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::genesis_account, send1.hash ()), info)); - ASSERT_EQ (nano::genesis_account, info.source); + ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()), info)); + ASSERT_EQ (nano::dev::genesis->account (), info.source); ASSERT_EQ (nano::Gxrb_ratio, info.amount.number ()); ASSERT_FALSE (store->block.exists (transaction, receive1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); } @@ -2154,17 +2154,17 @@ TEST (ledger, state_rollback_received_send) store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key; - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); nano::state_block receive1 (key.pub, 0, key.pub, nano::Gxrb_ratio, send1.hash (), key.prv, key.pub, *pool.generate (key.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::genesis_account, receive1.hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), receive1.hash ()))); ASSERT_FALSE (ledger.rollback (transaction, send1.hash ())); - ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); ASSERT_FALSE (store->block.exists (transaction, send1.hash ())); ASSERT_FALSE (store->block.exists (transaction, receive1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (0, ledger.account_balance (transaction, key.pub)); ASSERT_EQ (0, ledger.weight (key.pub)); ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); @@ -2182,12 +2182,12 @@ TEST (ledger, state_rep_change_rollback) store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair rep; - nano::state_block change1 (nano::genesis_account, genesis.hash (), rep.pub, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block change1 (nano::dev::genesis->account (), genesis.hash (), rep.pub, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change1).code); ASSERT_FALSE (ledger.rollback (transaction, change1.hash ())); ASSERT_FALSE (store->block.exists (transaction, change1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (0, ledger.weight (rep.pub)); } @@ -2203,17 +2203,17 @@ TEST (ledger, state_open_rollback) store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (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, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::state_block open1 (destination.pub, 0, nano::genesis_account, nano::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::state_block open1 (destination.pub, 0, nano::dev::genesis->account (), nano::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); ASSERT_FALSE (ledger.rollback (transaction, open1.hash ())); ASSERT_FALSE (store->block.exists (transaction, open1.hash ())); ASSERT_EQ (0, ledger.account_balance (transaction, destination.pub)); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); nano::pending_info info; ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (destination.pub, send1.hash ()), info)); - ASSERT_EQ (nano::genesis_account, info.source); + ASSERT_EQ (nano::dev::genesis->account (), info.source); ASSERT_EQ (nano::Gxrb_ratio, info.amount.number ()); ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); } @@ -2230,12 +2230,12 @@ TEST (ledger, state_send_change_rollback) store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair rep; - nano::state_block send1 (nano::genesis_account, genesis.hash (), rep.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), genesis.hash (), rep.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); ASSERT_FALSE (ledger.rollback (transaction, send1.hash ())); ASSERT_FALSE (store->block.exists (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); + ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (0, ledger.weight (rep.pub)); ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); } @@ -2251,15 +2251,15 @@ TEST (ledger, state_receive_change_rollback) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); nano::keypair rep; - nano::state_block receive1 (nano::genesis_account, send1.hash (), rep.pub, nano::genesis_amount, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block receive1 (nano::dev::genesis->account (), send1.hash (), rep.pub, nano::genesis_amount, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); ASSERT_FALSE (ledger.rollback (transaction, receive1.hash ())); ASSERT_FALSE (store->block.exists (transaction, receive1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (0, ledger.weight (rep.pub)); ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); } @@ -2276,41 +2276,41 @@ TEST (ledger, epoch_blocks_v1_general) store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; - nano::state_block epoch1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block epoch1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch1).code); ASSERT_FALSE (epoch1.sideband ().details.is_send); ASSERT_FALSE (epoch1.sideband ().details.is_receive); ASSERT_TRUE (epoch1.sideband ().details.is_epoch); ASSERT_EQ (nano::epoch::epoch_1, epoch1.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch1.sideband ().source_epoch); // Not used for epoch blocks - nano::state_block epoch2 (nano::genesis_account, epoch1.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); + nano::state_block epoch2 (nano::dev::genesis->account (), epoch1.hash (), nano::dev::genesis->account (), nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, epoch2).code); nano::account_info genesis_info; - ASSERT_FALSE (ledger.store.account.get (transaction, nano::genesis_account, genesis_info)); + ASSERT_FALSE (ledger.store.account.get (transaction, nano::dev::genesis->account (), genesis_info)); ASSERT_EQ (genesis_info.epoch (), nano::epoch::epoch_1); ASSERT_FALSE (ledger.rollback (transaction, epoch1.hash ())); - ASSERT_FALSE (ledger.store.account.get (transaction, nano::genesis_account, genesis_info)); + ASSERT_FALSE (ledger.store.account.get (transaction, nano::dev::genesis->account (), genesis_info)); ASSERT_EQ (genesis_info.epoch (), nano::epoch::epoch_0); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch1).code); - ASSERT_FALSE (ledger.store.account.get (transaction, nano::genesis_account, genesis_info)); + ASSERT_FALSE (ledger.store.account.get (transaction, nano::dev::genesis->account (), genesis_info)); ASSERT_EQ (genesis_info.epoch (), nano::epoch::epoch_1); ASSERT_FALSE (epoch1.sideband ().details.is_send); ASSERT_FALSE (epoch1.sideband ().details.is_receive); ASSERT_TRUE (epoch1.sideband ().details.is_epoch); ASSERT_EQ (nano::epoch::epoch_1, epoch1.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch1.sideband ().source_epoch); // Not used for epoch blocks - nano::change_block change1 (epoch1.hash (), nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); + nano::change_block change1 (epoch1.hash (), nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, change1).code); - nano::state_block send1 (nano::genesis_account, epoch1.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), epoch1.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); ASSERT_TRUE (send1.sideband ().details.is_send); ASSERT_FALSE (send1.sideband ().details.is_receive); ASSERT_FALSE (send1.sideband ().details.is_epoch); ASSERT_EQ (nano::epoch::epoch_1, send1.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, send1.sideband ().source_epoch); // Not used for send blocks - nano::open_block open1 (send1.hash (), nano::genesis_account, destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, open1).code); - nano::state_block epoch3 (destination.pub, 0, nano::genesis_account, 0, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (destination.pub)); + nano::state_block epoch3 (destination.pub, 0, nano::dev::genesis->account (), 0, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::representative_mismatch, ledger.process (transaction, epoch3).code); nano::state_block epoch4 (destination.pub, 0, 0, 0, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch4).code); @@ -2328,7 +2328,7 @@ TEST (ledger, epoch_blocks_v1_general) ASSERT_EQ (0, ledger.balance (transaction, epoch4.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, receive2.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive2.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.weight (destination.pub)); ASSERT_FALSE (receive2.sideband ().details.is_send); ASSERT_TRUE (receive2.sideband ().details.is_receive); @@ -2347,42 +2347,42 @@ TEST (ledger, epoch_blocks_v2_general) store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; - nano::state_block epoch1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block epoch1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); // Trying to upgrade from epoch 0 to epoch 2. It is a requirement epoch upgrades are sequential unless the account is unopened ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, epoch1).code); // Set it to the first epoch and it should now succeed - epoch1 = nano::state_block (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, epoch1.work); + epoch1 = nano::state_block (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, epoch1.work); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch1).code); ASSERT_EQ (nano::epoch::epoch_1, epoch1.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch1.sideband ().source_epoch); // Not used for epoch blocks - nano::state_block epoch2 (nano::genesis_account, epoch1.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); + nano::state_block epoch2 (nano::dev::genesis->account (), epoch1.hash (), nano::dev::genesis->account (), nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch2).code); ASSERT_EQ (nano::epoch::epoch_2, epoch2.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch2.sideband ().source_epoch); // Not used for epoch blocks - nano::state_block epoch3 (nano::genesis_account, epoch2.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch2.hash ())); + nano::state_block epoch3 (nano::dev::genesis->account (), epoch2.hash (), nano::dev::genesis->account (), nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch2.hash ())); ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, epoch3).code); nano::account_info genesis_info; - ASSERT_FALSE (ledger.store.account.get (transaction, nano::genesis_account, genesis_info)); + ASSERT_FALSE (ledger.store.account.get (transaction, nano::dev::genesis->account (), genesis_info)); ASSERT_EQ (genesis_info.epoch (), nano::epoch::epoch_2); ASSERT_FALSE (ledger.rollback (transaction, epoch1.hash ())); - ASSERT_FALSE (ledger.store.account.get (transaction, nano::genesis_account, genesis_info)); + ASSERT_FALSE (ledger.store.account.get (transaction, nano::dev::genesis->account (), genesis_info)); ASSERT_EQ (genesis_info.epoch (), nano::epoch::epoch_0); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch1).code); - ASSERT_FALSE (ledger.store.account.get (transaction, nano::genesis_account, genesis_info)); + ASSERT_FALSE (ledger.store.account.get (transaction, nano::dev::genesis->account (), genesis_info)); ASSERT_EQ (genesis_info.epoch (), nano::epoch::epoch_1); - nano::change_block change1 (epoch1.hash (), nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); + nano::change_block change1 (epoch1.hash (), nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, change1).code); - nano::state_block send1 (nano::genesis_account, epoch1.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), epoch1.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); ASSERT_EQ (nano::epoch::epoch_1, send1.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, send1.sideband ().source_epoch); // Not used for send blocks - nano::open_block open1 (send1.hash (), nano::genesis_account, destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, open1).code); nano::state_block epoch4 (destination.pub, 0, 0, 0, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch4).code); ASSERT_EQ (nano::epoch::epoch_1, epoch4.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch4.sideband ().source_epoch); // Not used for epoch blocks - nano::state_block epoch5 (destination.pub, epoch4.hash (), nano::genesis_account, 0, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch4.hash ())); + nano::state_block epoch5 (destination.pub, epoch4.hash (), nano::dev::genesis->account (), 0, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch4.hash ())); ASSERT_EQ (nano::process_result::representative_mismatch, ledger.process (transaction, epoch5).code); nano::state_block epoch6 (destination.pub, epoch4.hash (), 0, 0, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch4.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch6).code); @@ -2397,7 +2397,7 @@ TEST (ledger, epoch_blocks_v2_general) ASSERT_EQ (0, ledger.balance (transaction, epoch6.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, receive2.hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive2.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.weight (destination.pub)); } @@ -2413,11 +2413,11 @@ TEST (ledger, epoch_blocks_receive_upgrade) store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (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, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::state_block epoch1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block epoch1 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch1).code); - nano::state_block send2 (nano::genesis_account, epoch1.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio * 2, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); + nano::state_block send2 (nano::dev::genesis->account (), epoch1.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio * 2, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); ASSERT_EQ (nano::epoch::epoch_1, send2.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, send2.sideband ().source_epoch); // Not used for send blocks @@ -2454,14 +2454,14 @@ TEST (ledger, epoch_blocks_receive_upgrade) ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, open2).code); // Upgrade to epoch 2 and send to destination. Try to create an open block from an epoch 2 source block. nano::keypair destination3; - nano::state_block epoch2 (nano::genesis_account, send2.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio * 2, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send2.hash ())); + nano::state_block epoch2 (nano::dev::genesis->account (), send2.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio * 2, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send2.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch2).code); - nano::state_block send4 (nano::genesis_account, epoch2.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio * 3, destination3.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch2.hash ())); + nano::state_block send4 (nano::dev::genesis->account (), epoch2.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio * 3, destination3.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch2.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send4).code); nano::open_block open3 (send4.hash (), destination3.pub, destination3.pub, destination3.prv, destination3.pub, *pool.generate (destination3.pub)); ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, open3).code); // Send it to an epoch 1 account - nano::state_block send5 (nano::genesis_account, send4.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio * 4, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send4.hash ())); + nano::state_block send5 (nano::dev::genesis->account (), send4.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio * 4, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send4.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send5).code); ASSERT_FALSE (ledger.store.account.get (transaction, destination.pub, destination_info)); ASSERT_EQ (destination_info.epoch (), nano::epoch::epoch_1); @@ -2473,7 +2473,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) ASSERT_EQ (destination_info.epoch (), nano::epoch::epoch_2); // Upgrade an unopened account straight to epoch 2 nano::keypair destination4; - nano::state_block send6 (nano::genesis_account, send5.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio * 5, destination4.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send5.hash ())); + nano::state_block send6 (nano::dev::genesis->account (), send5.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio * 5, destination4.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send5.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send6).code); nano::state_block epoch4 (destination4.pub, 0, 0, 0, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (destination4.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch4).code); @@ -2496,15 +2496,15 @@ TEST (ledger, epoch_blocks_fork) nano::keypair destination; nano::send_block send1 (genesis.hash (), nano::account (0), nano::genesis_amount, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::state_block epoch1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block epoch1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, epoch1).code); - nano::state_block epoch2 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block epoch2 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, epoch2).code); - nano::state_block epoch3 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block epoch3 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch3).code); ASSERT_EQ (nano::epoch::epoch_1, epoch3.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch3.sideband ().source_epoch); // Not used for epoch state blocks - nano::state_block epoch4 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block epoch4 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, epoch2).code); } @@ -2562,9 +2562,9 @@ TEST (ledger, epoch_open_pending) ASSERT_EQ (blocks[0].verified, nano::signature_verification::valid_epoch); // New block to process epoch open auto send1 = builder.state () - .account (nano::genesis_account) + .account (nano::dev::genesis->account ()) .previous (nano::dev::genesis->hash ()) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (nano::genesis_amount - 100) .link (key1.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) @@ -2590,9 +2590,9 @@ TEST (ledger, block_hash_account_conflict) * in the ledger and not an account */ auto send1 = builder.state () - .account (nano::genesis_account) + .account (nano::dev::genesis->account ()) .previous (genesis.hash ()) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (nano::genesis_amount - 100) .link (key1.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) @@ -2602,7 +2602,7 @@ TEST (ledger, block_hash_account_conflict) auto receive1 = builder.state () .account (key1.pub) .previous (0) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (100) .link (send1->hash ()) .sign (key1.prv, key1.pub) @@ -2618,7 +2618,7 @@ TEST (ledger, block_hash_account_conflict) auto send2 = builder.state () .account (key1.pub) .previous (receive1->hash ()) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (90) .link (receive1->hash ()) .sign (key1.prv, key1.pub) @@ -2679,14 +2679,14 @@ TEST (ledger, could_fit) nano::work_pool pool (std::numeric_limits::max ()); nano::keypair destination; // Test legacy and state change blocks could_fit - nano::change_block change1 (genesis.hash (), nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); - nano::state_block change2 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::change_block change1 (genesis.hash (), nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block change2 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_TRUE (ledger.could_fit (transaction, change1)); ASSERT_TRUE (ledger.could_fit (transaction, change2)); // Test legacy and state send nano::keypair key1; nano::send_block send1 (change1.hash (), key1.pub, nano::genesis_amount - 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (change1.hash ())); - nano::state_block send2 (nano::genesis_account, change1.hash (), nano::genesis_account, nano::genesis_amount - 1, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (change1.hash ())); + nano::state_block send2 (nano::dev::genesis->account (), change1.hash (), nano::dev::genesis->account (), nano::genesis_amount - 1, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (change1.hash ())); ASSERT_FALSE (ledger.could_fit (transaction, send1)); ASSERT_FALSE (ledger.could_fit (transaction, send2)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change1).code); @@ -2695,8 +2695,8 @@ TEST (ledger, could_fit) ASSERT_TRUE (ledger.could_fit (transaction, send1)); ASSERT_TRUE (ledger.could_fit (transaction, send2)); // Test legacy and state open - nano::open_block open1 (send2.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); - nano::state_block open2 (key1.pub, 0, nano::genesis_account, 1, send2.hash (), key1.prv, key1.pub, *pool.generate (key1.pub)); + nano::open_block open1 (send2.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); + nano::state_block open2 (key1.pub, 0, nano::dev::genesis->account (), 1, send2.hash (), key1.prv, key1.pub, *pool.generate (key1.pub)); ASSERT_FALSE (ledger.could_fit (transaction, open1)); ASSERT_FALSE (ledger.could_fit (transaction, open2)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); @@ -2708,17 +2708,17 @@ TEST (ledger, could_fit) ASSERT_TRUE (ledger.could_fit (transaction, open1)); ASSERT_TRUE (ledger.could_fit (transaction, open2)); // Create another send to receive - nano::state_block send3 (nano::genesis_account, send2.hash (), nano::genesis_account, nano::genesis_amount - 2, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send2.hash ())); + nano::state_block send3 (nano::dev::genesis->account (), send2.hash (), nano::dev::genesis->account (), nano::genesis_amount - 2, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send2.hash ())); // Test legacy and state receive nano::receive_block receive1 (open1.hash (), send3.hash (), key1.prv, key1.pub, *pool.generate (open1.hash ())); - nano::state_block receive2 (key1.pub, open1.hash (), nano::genesis_account, 2, send3.hash (), key1.prv, key1.pub, *pool.generate (open1.hash ())); + nano::state_block receive2 (key1.pub, open1.hash (), nano::dev::genesis->account (), 2, send3.hash (), key1.prv, key1.pub, *pool.generate (open1.hash ())); ASSERT_FALSE (ledger.could_fit (transaction, receive1)); ASSERT_FALSE (ledger.could_fit (transaction, receive2)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send3).code); ASSERT_TRUE (ledger.could_fit (transaction, receive1)); ASSERT_TRUE (ledger.could_fit (transaction, receive2)); // Test epoch (state) - nano::state_block epoch1 (key1.pub, receive1.hash (), nano::genesis_account, 2, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (receive1.hash ())); + nano::state_block epoch1 (key1.pub, receive1.hash (), nano::dev::genesis->account (), 2, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (receive1.hash ())); ASSERT_FALSE (ledger.could_fit (transaction, epoch1)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); ASSERT_TRUE (ledger.could_fit (transaction, receive1)); @@ -2734,7 +2734,7 @@ TEST (ledger, unchecked_epoch) auto & node1 (*system.nodes[0]); nano::genesis genesis; nano::keypair destination; - auto send1 (std::make_shared (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send1 (std::make_shared (nano::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 open1 (std::make_shared (destination.pub, 0, destination.pub, nano::Gxrb_ratio, send1->hash (), destination.prv, destination.pub, 0)); node1.work_generate_blocking (*open1); @@ -2774,7 +2774,7 @@ TEST (ledger, unchecked_epoch_invalid) auto & node1 (*system.add_node (node_config)); nano::genesis genesis; nano::keypair destination; - auto send1 (std::make_shared (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send1 (std::make_shared (nano::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 open1 (std::make_shared (destination.pub, 0, destination.pub, nano::Gxrb_ratio, send1->hash (), destination.prv, destination.pub, 0)); node1.work_generate_blocking (*open1); @@ -2826,7 +2826,7 @@ TEST (ledger, unchecked_open) auto & node1 (*system.nodes[0]); nano::genesis genesis; nano::keypair destination; - auto send1 (std::make_shared (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send1 (std::make_shared (nano::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 open1 (std::make_shared (send1->hash (), destination.pub, destination.pub, destination.prv, destination.pub, 0)); node1.work_generate_blocking (*open1); @@ -2863,9 +2863,9 @@ TEST (ledger, unchecked_receive) auto & node1 (*system.nodes[0]); nano::genesis genesis; nano::keypair destination; - auto send1 (std::make_shared (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send1 (std::make_shared (nano::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::genesis_account, send1->hash (), nano::genesis_account, nano::genesis_amount - 2 * nano::Gxrb_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send2 (std::make_shared (nano::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 open1 (std::make_shared (send1->hash (), destination.pub, destination.pub, destination.prv, destination.pub, 0)); node1.work_generate_blocking (*open1); @@ -2923,14 +2923,14 @@ TEST (ledger, confirmation_height_not_updated) nano::keypair key; nano::send_block send1 (account_info.head, key.pub, 50, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (account_info.head)); nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (store->confirmation_height.get (transaction, nano::genesis_account, confirmation_height_info)); + ASSERT_FALSE (store->confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (1, confirmation_height_info.height); ASSERT_EQ (genesis.hash (), confirmation_height_info.frontier); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_FALSE (store->confirmation_height.get (transaction, nano::genesis_account, confirmation_height_info)); + ASSERT_FALSE (store->confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (1, confirmation_height_info.height); ASSERT_EQ (genesis.hash (), confirmation_height_info.frontier); - nano::open_block open1 (send1.hash (), nano::genesis_account, key.pub, key.prv, key.pub, *pool.generate (key.pub)); + nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), key.pub, key.prv, key.pub, *pool.generate (key.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); ASSERT_TRUE (store->confirmation_height.get (transaction, key.pub, confirmation_height_info)); ASSERT_EQ (0, confirmation_height_info.height); @@ -3078,9 +3078,9 @@ TEST (ledger, dependents_confirmed) nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; auto send1 = builder.state () - .account (nano::genesis_account) + .account (nano::dev::genesis->account ()) .previous (genesis.hash ()) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (nano::genesis_amount - 100) .link (key1.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) @@ -3089,9 +3089,9 @@ TEST (ledger, dependents_confirmed) ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); ASSERT_TRUE (ledger.dependents_confirmed (transaction, *send1)); auto send2 = builder.state () - .account (nano::genesis_account) + .account (nano::dev::genesis->account ()) .previous (send1->hash ()) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (nano::genesis_amount - 200) .link (key1.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) @@ -3102,7 +3102,7 @@ TEST (ledger, dependents_confirmed) auto receive1 = builder.state () .account (key1.pub) .previous (0) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (100) .link (send1->hash ()) .sign (key1.prv, key1.pub) @@ -3111,14 +3111,14 @@ TEST (ledger, dependents_confirmed) ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive1)); nano::confirmation_height_info height; - ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::genesis_account, height)); + ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); height.height += 1; - ledger.store.confirmation_height.put (transaction, nano::genesis_account, height); + ledger.store.confirmation_height.put (transaction, nano::dev::genesis->account (), height); ASSERT_TRUE (ledger.dependents_confirmed (transaction, *receive1)); auto receive2 = builder.state () .account (key1.pub) .previous (receive1->hash ()) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (200) .link (send2->hash ()) .sign (key1.prv, key1.pub) @@ -3130,9 +3130,9 @@ TEST (ledger, dependents_confirmed) height.height += 1; ledger.store.confirmation_height.put (transaction, key1.pub, height); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive2)); - ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::genesis_account, height)); + ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); height.height += 1; - ledger.store.confirmation_height.put (transaction, nano::genesis_account, height); + ledger.store.confirmation_height.put (transaction, nano::dev::genesis->account (), height); ASSERT_TRUE (ledger.dependents_confirmed (transaction, *receive2)); } @@ -3151,9 +3151,9 @@ TEST (ledger, dependents_confirmed_pruning) nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; auto send1 = builder.state () - .account (nano::genesis_account) + .account (nano::dev::genesis->account ()) .previous (genesis.hash ()) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (nano::genesis_amount - 100) .link (key1.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) @@ -3161,9 +3161,9 @@ TEST (ledger, dependents_confirmed_pruning) .build_shared (); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); auto send2 = builder.state () - .account (nano::genesis_account) + .account (nano::dev::genesis->account ()) .previous (send1->hash ()) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (nano::genesis_amount - 200) .link (key1.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) @@ -3171,15 +3171,15 @@ TEST (ledger, dependents_confirmed_pruning) .build_shared (); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); nano::confirmation_height_info height; - ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::genesis_account, height)); + ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); height.height = 3; - ledger.store.confirmation_height.put (transaction, nano::genesis_account, height); + ledger.store.confirmation_height.put (transaction, nano::dev::genesis->account (), height); ASSERT_TRUE (ledger.block_confirmed (transaction, send1->hash ())); ASSERT_EQ (2, ledger.pruning_action (transaction, send2->hash (), 1)); auto receive1 = builder.state () .account (key1.pub) .previous (0) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (100) .link (send1->hash ()) .sign (key1.prv, key1.pub) @@ -3203,9 +3203,9 @@ TEST (ledger, block_confirmed) nano::work_pool pool (std::numeric_limits::max ()); nano::keypair key1; auto send1 = builder.state () - .account (nano::genesis_account) + .account (nano::dev::genesis->account ()) .previous (genesis.hash ()) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (nano::genesis_amount - 100) .link (key1.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) @@ -3216,9 +3216,9 @@ TEST (ledger, block_confirmed) ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); ASSERT_FALSE (ledger.block_confirmed (transaction, send1->hash ())); nano::confirmation_height_info height; - ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::genesis_account, height)); + ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); ++height.height; - ledger.store.confirmation_height.put (transaction, nano::genesis_account, height); + ledger.store.confirmation_height.put (transaction, nano::dev::genesis->account (), height); ASSERT_TRUE (ledger.block_confirmed (transaction, send1->hash ())); } @@ -3249,16 +3249,16 @@ TEST (ledger, cache) ASSERT_EQ (account_count, cache_a.account_count); ASSERT_EQ (block_count, cache_a.block_count); ASSERT_EQ (cemented_count, cache_a.cemented_count); - ASSERT_EQ (genesis_weight, cache_a.rep_weights.representation_get (nano::genesis_account)); + ASSERT_EQ (genesis_weight, cache_a.rep_weights.representation_get (nano::dev::genesis->account ())); ASSERT_EQ (pruned_count, cache_a.pruned_count); }; nano::keypair key; - auto const latest = ledger.latest (store->tx_begin_read (), nano::genesis_account); + auto const latest = ledger.latest (store->tx_begin_read (), nano::dev::genesis->account ()); auto send = builder.state () - .account (nano::genesis_account) + .account (nano::dev::genesis->account ()) .previous (latest) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (nano::genesis_amount - (i + 1)) .link (key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) @@ -3296,10 +3296,10 @@ TEST (ledger, cache) { auto transaction (store->tx_begin_write ()); nano::confirmation_height_info height; - ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::genesis_account, height)); + ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); ++height.height; height.frontier = send->hash (); - ledger.store.confirmation_height.put (transaction, nano::genesis_account, height); + ledger.store.confirmation_height.put (transaction, nano::dev::genesis->account (), height); ASSERT_TRUE (ledger.block_confirmed (transaction, send->hash ())); ++ledger.cache.cemented_count; } @@ -3346,20 +3346,20 @@ TEST (ledger, pruning_action) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); auto send1_stored (store->block.get (transaction, send1.hash ())); ASSERT_NE (nullptr, send1_stored); ASSERT_EQ (send1, *send1_stored); - ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); - nano::state_block send2 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio * 2, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); + nano::state_block send2 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); ASSERT_TRUE (store->block.exists (transaction, send2.hash ())); // Pruning action ASSERT_EQ (1, ledger.pruning_action (transaction, send1.hash (), 1)); ASSERT_EQ (0, ledger.pruning_action (transaction, genesis.hash (), 1)); - ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); ASSERT_FALSE (store->block.exists (transaction, send1.hash ())); ASSERT_TRUE (ledger.block_or_pruned_exists (transaction, send1.hash ())); // Pruned ledger start without proper flags emulation @@ -3370,13 +3370,13 @@ TEST (ledger, pruning_action) ASSERT_TRUE (store->block.exists (transaction, genesis.hash ())); ASSERT_TRUE (store->block.exists (transaction, send2.hash ())); // Receiving pruned block - nano::state_block receive1 (nano::genesis_account, send2.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send2.hash ())); + nano::state_block receive1 (nano::dev::genesis->account (), send2.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send2.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); ASSERT_TRUE (store->block.exists (transaction, receive1.hash ())); auto receive1_stored (store->block.get (transaction, receive1.hash ())); ASSERT_NE (nullptr, receive1_stored); ASSERT_EQ (receive1, *receive1_stored); - ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); ASSERT_EQ (4, receive1_stored->sideband ().height); ASSERT_FALSE (receive1_stored->sideband ().details.is_send); ASSERT_TRUE (receive1_stored->sideband ().details.is_receive); @@ -3407,10 +3407,10 @@ TEST (ledger, pruning_large_chain) auto last_hash (genesis.hash ()); for (auto i (0); i < send_receive_pairs; i++) { - nano::state_block send (nano::genesis_account, last_hash, nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (last_hash)); + nano::state_block send (nano::dev::genesis->account (), last_hash, nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (last_hash)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); ASSERT_TRUE (store->block.exists (transaction, send.hash ())); - nano::state_block receive (nano::genesis_account, send.hash (), nano::genesis_account, nano::genesis_amount, send.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send.hash ())); + nano::state_block receive (nano::dev::genesis->account (), send.hash (), nano::dev::genesis->account (), nano::genesis_amount, 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); ASSERT_TRUE (store->block.exists (transaction, receive.hash ())); last_hash = receive.hash (); @@ -3440,12 +3440,12 @@ TEST (ledger, pruning_source_rollback) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block epoch1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block epoch1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch1).code); - nano::state_block send1 (nano::genesis_account, epoch1.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), epoch1.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); - nano::state_block send2 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio * 2, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); + nano::state_block send2 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); ASSERT_TRUE (store->block.exists (transaction, send2.hash ())); // Pruning action @@ -3456,26 +3456,26 @@ TEST (ledger, pruning_source_rollback) ASSERT_TRUE (store->pruned.exists (transaction, epoch1.hash ())); ASSERT_TRUE (store->block.exists (transaction, genesis.hash ())); nano::pending_info info; - ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::genesis_account, send1.hash ()), info)); - ASSERT_EQ (nano::genesis_account, info.source); + ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()), info)); + ASSERT_EQ (nano::dev::genesis->account (), info.source); ASSERT_EQ (nano::Gxrb_ratio, info.amount.number ()); ASSERT_EQ (nano::epoch::epoch_1, info.epoch); // Receiving pruned block - nano::state_block receive1 (nano::genesis_account, send2.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send2.hash ())); + nano::state_block receive1 (nano::dev::genesis->account (), send2.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send2.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (5, ledger.cache.block_count); // Rollback receive block ASSERT_FALSE (ledger.rollback (transaction, receive1.hash ())); nano::pending_info info2; - ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::genesis_account, send1.hash ()), info2)); - ASSERT_NE (nano::genesis_account, info2.source); // Tradeoff to not store pruned blocks accounts + ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()), info2)); + ASSERT_NE (nano::dev::genesis->account (), info2.source); // Tradeoff to not store pruned blocks accounts ASSERT_EQ (nano::Gxrb_ratio, info2.amount.number ()); ASSERT_EQ (nano::epoch::epoch_1, info2.epoch); // Process receive block again ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (5, ledger.cache.block_count); } @@ -3492,18 +3492,18 @@ TEST (ledger, pruning_source_rollback_legacy) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::send_block send1 (genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block send1 (genesis.hash (), nano::dev::genesis->account (), 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, send1).code); - ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); nano::keypair key1; nano::send_block send2 (send1.hash (), key1.pub, nano::genesis_amount - 2 * nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); ASSERT_TRUE (store->block.exists (transaction, send2.hash ())); ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (key1.pub, send2.hash ()))); - nano::send_block send3 (send2.hash (), nano::genesis_account, nano::genesis_amount - 3 * nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send2.hash ())); + nano::send_block send3 (send2.hash (), nano::dev::genesis->account (), nano::genesis_amount - 3 * nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send2.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send3).code); ASSERT_TRUE (store->block.exists (transaction, send3.hash ())); - ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::genesis_account, send3.hash ()))); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send3.hash ()))); // Pruning action ASSERT_EQ (2, ledger.pruning_action (transaction, send2.hash (), 1)); ASSERT_FALSE (store->block.exists (transaction, send2.hash ())); @@ -3512,35 +3512,35 @@ TEST (ledger, pruning_source_rollback_legacy) ASSERT_TRUE (store->pruned.exists (transaction, send1.hash ())); ASSERT_TRUE (store->block.exists (transaction, genesis.hash ())); nano::pending_info info1; - ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::genesis_account, send1.hash ()), info1)); - ASSERT_EQ (nano::genesis_account, info1.source); + ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()), info1)); + ASSERT_EQ (nano::dev::genesis->account (), info1.source); ASSERT_EQ (nano::Gxrb_ratio, info1.amount.number ()); ASSERT_EQ (nano::epoch::epoch_0, info1.epoch); nano::pending_info info2; ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (key1.pub, send2.hash ()), info2)); - ASSERT_EQ (nano::genesis_account, info2.source); + ASSERT_EQ (nano::dev::genesis->account (), info2.source); ASSERT_EQ (nano::Gxrb_ratio, info2.amount.number ()); ASSERT_EQ (nano::epoch::epoch_0, info2.epoch); // Receiving pruned block nano::receive_block receive1 (send3.hash (), send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send3.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (5, ledger.cache.block_count); // Rollback receive block ASSERT_FALSE (ledger.rollback (transaction, receive1.hash ())); nano::pending_info info3; - ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::genesis_account, send1.hash ()), info3)); - ASSERT_NE (nano::genesis_account, info3.source); // Tradeoff to not store pruned blocks accounts + ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()), info3)); + ASSERT_NE (nano::dev::genesis->account (), info3.source); // Tradeoff to not store pruned blocks accounts ASSERT_EQ (nano::Gxrb_ratio, info3.amount.number ()); ASSERT_EQ (nano::epoch::epoch_0, info3.epoch); // Process receive block again ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (5, ledger.cache.block_count); // Receiving pruned block (open) - nano::open_block open1 (send2.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); + nano::open_block open1 (send2.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (key1.pub, send2.hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); @@ -3549,7 +3549,7 @@ TEST (ledger, pruning_source_rollback_legacy) ASSERT_FALSE (ledger.rollback (transaction, open1.hash ())); nano::pending_info info4; ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (key1.pub, send2.hash ()), info4)); - ASSERT_NE (nano::genesis_account, info4.source); // Tradeoff to not store pruned blocks accounts + ASSERT_NE (nano::dev::genesis->account (), info4.source); // Tradeoff to not store pruned blocks accounts ASSERT_EQ (nano::Gxrb_ratio, info4.amount.number ()); ASSERT_EQ (nano::epoch::epoch_0, info4.epoch); // Process open block again @@ -3571,7 +3571,7 @@ TEST (ledger, pruning_process_error) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); ASSERT_EQ (0, ledger.cache.pruned_count); ASSERT_EQ (2, ledger.cache.block_count); @@ -3582,7 +3582,7 @@ TEST (ledger, pruning_process_error) // Attempt to process pruned block again ASSERT_EQ (nano::process_result::old, ledger.process (transaction, send1).code); // Attept to process new block after pruned - nano::state_block send2 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio * 2, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block send2 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::gap_previous, ledger.process (transaction, send2).code); ASSERT_EQ (1, ledger.cache.pruned_count); ASSERT_EQ (2, ledger.cache.block_count); @@ -3601,18 +3601,18 @@ TEST (ledger, pruning_legacy_blocks) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::send_block send1 (genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block send1 (genesis.hash (), nano::dev::genesis->account (), 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, send1).code); - ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); nano::receive_block receive1 (send1.hash (), send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); nano::change_block change1 (receive1.hash (), key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (receive1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change1).code); nano::send_block send2 (change1.hash (), key1.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (change1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); - nano::open_block open1 (send2.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); + nano::open_block open1 (send2.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); - nano::send_block send3 (open1.hash (), nano::genesis_account, 0, key1.prv, key1.pub, *pool.generate (open1.hash ())); + nano::send_block send3 (open1.hash (), nano::dev::genesis->account (), 0, key1.prv, key1.pub, *pool.generate (open1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send3).code); // Pruning action ASSERT_EQ (3, ledger.pruning_action (transaction, change1.hash (), 2)); @@ -3646,10 +3646,10 @@ TEST (ledger, pruning_safe_functions) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); - nano::state_block send2 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio * 2, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block send2 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); ASSERT_TRUE (store->block.exists (transaction, send2.hash ())); // Pruning action @@ -3673,7 +3673,7 @@ TEST (ledger, pruning_safe_functions) ASSERT_TRUE (ledger.account_safe (transaction, send1.hash (), error).is_zero ()); ASSERT_TRUE (error); error = false; - ASSERT_EQ (nano::genesis_account, ledger.account_safe (transaction, send2.hash (), error)); + ASSERT_EQ (nano::dev::genesis->account (), ledger.account_safe (transaction, send2.hash (), error)); ASSERT_FALSE (error); } @@ -3689,10 +3689,10 @@ TEST (ledger, hash_root_random) auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache); nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), genesis.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); - nano::state_block send2 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio * 2, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block send2 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio * 2, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); ASSERT_TRUE (store->block.exists (transaction, send2.hash ())); // Pruning action @@ -3752,13 +3752,13 @@ TEST (ledger, migrate_lmdb_to_rocksdb) ASSERT_FALSE (store.init_error ()); // Lower the database to the max version unsupported for upgrades - store.confirmation_height.put (transaction, nano::genesis_account, { 2, send->hash () }); + store.confirmation_height.put (transaction, nano::dev::genesis->account (), { 2, send->hash () }); store.online_weight.put (transaction, 100, nano::amount (2)); store.frontier.put (transaction, nano::block_hash (2), nano::account (5)); store.peer.put (transaction, endpoint_key); - store.pending.put (transaction, nano::pending_key (nano::genesis_account, send->hash ()), nano::pending_info (nano::genesis_account, 100, nano::epoch::epoch_0)); + store.pending.put (transaction, nano::pending_key (nano::dev::genesis->account (), send->hash ()), nano::pending_info (nano::dev::genesis->account (), 100, nano::epoch::epoch_0)); store.pruned.put (transaction, send->hash ()); store.unchecked.put (transaction, nano::dev::genesis->hash (), send); store.version.put (transaction, version); @@ -3774,7 +3774,7 @@ TEST (ledger, migrate_lmdb_to_rocksdb) auto rocksdb_transaction (rocksdb_store.tx_begin_read ()); nano::pending_info pending_info; - ASSERT_FALSE (rocksdb_store.pending.get (rocksdb_transaction, nano::pending_key (nano::genesis_account, send->hash ()), pending_info)); + ASSERT_FALSE (rocksdb_store.pending.get (rocksdb_transaction, nano::pending_key (nano::dev::genesis->account (), send->hash ()), pending_info)); for (auto i = rocksdb_store.online_weight.begin (rocksdb_transaction); i != rocksdb_store.online_weight.end (); ++i) { @@ -3791,7 +3791,7 @@ TEST (ledger, migrate_lmdb_to_rocksdb) ASSERT_EQ (rocksdb_store.version.get (rocksdb_transaction), version); ASSERT_EQ (rocksdb_store.frontier.get (rocksdb_transaction, 2), 5); nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (rocksdb_store.confirmation_height.get (rocksdb_transaction, nano::genesis_account, confirmation_height_info)); + ASSERT_FALSE (rocksdb_store.confirmation_height.get (rocksdb_transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (confirmation_height_info.height, 2); ASSERT_EQ (confirmation_height_info.frontier, send->hash ()); ASSERT_TRUE (rocksdb_store.final_vote.get (rocksdb_transaction, nano::root (send->previous ())).size () == 1); @@ -3799,7 +3799,7 @@ TEST (ledger, migrate_lmdb_to_rocksdb) 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 ().account, nano::dev::genesis->account ()); ASSERT_EQ (*unchecked_infos.front ().block, *send); } @@ -3819,11 +3819,11 @@ TEST (ledger, unconfirmed_frontiers) nano::state_block_builder builder; nano::keypair key; - auto const latest = ledger.latest (store->tx_begin_read (), nano::genesis_account); + auto const latest = ledger.latest (store->tx_begin_read (), nano::dev::genesis->account ()); auto send = builder.make_block () - .account (nano::genesis_account) + .account (nano::dev::genesis->account ()) .previous (latest) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (nano::genesis_amount - 100) .link (key.pub) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) @@ -3835,7 +3835,7 @@ TEST (ledger, unconfirmed_frontiers) unconfirmed_frontiers = ledger.unconfirmed_frontiers (); ASSERT_EQ (unconfirmed_frontiers.size (), 1); ASSERT_EQ (unconfirmed_frontiers.begin ()->first, 1); - nano::uncemented_info uncemented_info1{ latest, send->hash (), nano::genesis_account }; + nano::uncemented_info uncemented_info1{ latest, send->hash (), nano::dev::genesis->account () }; auto uncemented_info2 = unconfirmed_frontiers.begin ()->second; ASSERT_EQ (uncemented_info1.account, uncemented_info2.account); ASSERT_EQ (uncemented_info1.cemented_frontier, uncemented_info2.cemented_frontier); diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 615634a5..88be824a 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -2073,16 +2073,16 @@ TEST (node, DISABLED_unconfirmed_send) nano::keypair key0; wallet1->insert_adhoc (key0.prv); wallet0->insert_adhoc (nano::dev_genesis_key.prv); - auto send1 (wallet0->send_action (nano::genesis_account, key0.pub, 2 * nano::Mxrb_ratio)); + auto send1 (wallet0->send_action (nano::dev::genesis->account (), key0.pub, 2 * nano::Mxrb_ratio)); ASSERT_TIMELY (10s, node1.balance (key0.pub) == 2 * nano::Mxrb_ratio && !node1.bootstrap_initiator.in_progress ()); auto latest (node1.latest (key0.pub)); - nano::state_block send2 (key0.pub, latest, nano::genesis_account, nano::Mxrb_ratio, nano::genesis_account, key0.prv, key0.pub, *node0.work_generate_blocking (latest)); + nano::state_block send2 (key0.pub, latest, nano::dev::genesis->account (), nano::Mxrb_ratio, nano::dev::genesis->account (), key0.prv, key0.pub, *node0.work_generate_blocking (latest)); { auto transaction (node1.store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, send2).code); } - auto send3 (wallet1->send_action (key0.pub, nano::genesis_account, nano::Mxrb_ratio)); - ASSERT_TIMELY (10s, node0.balance (nano::genesis_account) == nano::genesis_amount); + auto send3 (wallet1->send_action (key0.pub, nano::dev::genesis->account (), nano::Mxrb_ratio)); + ASSERT_TIMELY (10s, node0.balance (nano::dev::genesis->account ()) == nano::genesis_amount); } // Test that nodes can track nodes that have rep weight for priority broadcasting @@ -3059,9 +3059,9 @@ TEST (node, vote_by_hash_epoch_block_republish) .work (*system.work.generate (genesis.hash ())) .build_shared (); auto epoch1 = nano::state_block_builder () - .account (nano::genesis_account) + .account (nano::dev::genesis->account ()) .previous (genesis.hash ()) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (nano::genesis_amount) .link (node1.ledger.epoch_link (nano::epoch::epoch_1)) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) diff --git a/nano/core_test/system.cpp b/nano/core_test/system.cpp index caf83c68..370efa83 100644 --- a/nano/core_test/system.cpp +++ b/nano/core_test/system.cpp @@ -29,7 +29,7 @@ TEST (system, system_genesis) for (auto & i : system.nodes) { auto transaction (i->store.tx_begin_read ()); - ASSERT_EQ (nano::genesis_amount, i->ledger.account_balance (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, i->ledger.account_balance (transaction, nano::dev::genesis->account ())); } } @@ -40,7 +40,7 @@ TEST (system, DISABLED_generate_send_existing) nano::thread_runner runner (system.io_ctx, node1.config.io_threads); system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); nano::keypair stake_preserver; - auto send_block (system.wallet (0)->send_action (nano::genesis_account, stake_preserver.pub, nano::genesis_amount / 3 * 2, true)); + auto send_block (system.wallet (0)->send_action (nano::dev::genesis->account (), stake_preserver.pub, nano::genesis_amount / 3 * 2, true)); nano::account_info info1; { auto transaction (node1.store.tx_begin_read ()); @@ -52,11 +52,11 @@ TEST (system, DISABLED_generate_send_existing) // Have stake_preserver receive funds after generate_send_existing so it isn't chosen as the destination { auto transaction (node1.store.tx_begin_write ()); - auto open_block (std::make_shared (send_block->hash (), nano::genesis_account, stake_preserver.pub, stake_preserver.prv, stake_preserver.pub, 0)); + auto open_block (std::make_shared (send_block->hash (), nano::dev::genesis->account (), stake_preserver.pub, stake_preserver.prv, stake_preserver.pub, 0)); node1.work_generate_blocking (*open_block); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *open_block).code); } - ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::genesis_account)); + ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::dev::genesis->account ())); nano::account_info info2; { auto transaction (node1.store.tx_begin_read ()); @@ -94,14 +94,14 @@ TEST (system, DISABLED_generate_send_new) ASSERT_EQ (node1.store.account.end (), iterator1); } nano::keypair stake_preserver; - auto send_block (system.wallet (0)->send_action (nano::genesis_account, stake_preserver.pub, nano::genesis_amount / 3 * 2, true)); + auto send_block (system.wallet (0)->send_action (nano::dev::genesis->account (), stake_preserver.pub, nano::genesis_amount / 3 * 2, true)); { auto transaction (node1.store.tx_begin_write ()); - auto open_block (std::make_shared (send_block->hash (), nano::genesis_account, stake_preserver.pub, stake_preserver.prv, stake_preserver.pub, 0)); + auto open_block (std::make_shared (send_block->hash (), nano::dev::genesis->account (), stake_preserver.pub, stake_preserver.prv, stake_preserver.pub, 0)); node1.work_generate_blocking (*open_block); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *open_block).code); } - ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::genesis_account)); + ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::dev::genesis->account ())); std::vector accounts; accounts.push_back (nano::dev_genesis_key.pub); // This indirectly waits for online weight to stabilize, required to prevent intermittent failures diff --git a/nano/core_test/vote_processor.cpp b/nano/core_test/vote_processor.cpp index 4f573769..c8ca56b6 100644 --- a/nano/core_test/vote_processor.cpp +++ b/nano/core_test/vote_processor.cpp @@ -28,7 +28,7 @@ TEST (vote_processor, codes) ASSERT_EQ (nano::vote_code::indeterminate, node.vote_processor.vote_blocking (vote, channel)); // First vote from an account for an ongoing election - genesis.open->sideband_set (nano::block_sideband (nano::genesis_account, 0, nano::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); + genesis.open->sideband_set (nano::block_sideband (nano::dev::genesis->account (), 0, nano::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); node.block_confirm (genesis.open); ASSERT_NE (nullptr, node.active.election (genesis.open->qualified_root ())); ASSERT_EQ (nano::vote_code::vote, node.vote_processor.vote_blocking (vote, channel)); @@ -78,7 +78,7 @@ TEST (vote_processor, invalid_signature) vote_invalid->signature.bytes[0] ^= 1; auto channel = std::make_shared (node); - genesis.open->sideband_set (nano::block_sideband (nano::genesis_account, 0, nano::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); + genesis.open->sideband_set (nano::block_sideband (nano::dev::genesis->account (), 0, nano::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); node.block_confirm (genesis.open); auto election = node.active.election (genesis.open->qualified_root ()); ASSERT_TRUE (election); diff --git a/nano/core_test/voting.cpp b/nano/core_test/voting.cpp index c7e7eb03..08bd5267 100644 --- a/nano/core_test/voting.cpp +++ b/nano/core_test/voting.cpp @@ -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::dev::genesis->hash ()); + generator_session.add (nano::dev::genesis->account (), nano::dev::genesis->hash ()); ASSERT_EQ (0, node->stats.count (nano::stat::type::vote, nano::stat::detail::vote_indeterminate)); generator_session.flush (); }); diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp index fc295738..e6d86cad 100644 --- a/nano/core_test/wallet.cpp +++ b/nano/core_test/wallet.cpp @@ -18,7 +18,7 @@ TEST (wallet, no_special_keys_accounts) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); nano::keypair key1; ASSERT_FALSE (wallet.exists (transaction, key1.pub)); @@ -39,7 +39,7 @@ TEST (wallet, no_key) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); nano::keypair key1; nano::raw_key prv1; @@ -54,7 +54,7 @@ TEST (wallet, fetch_locked) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_TRUE (wallet.valid_password (transaction)); nano::keypair key1; ASSERT_EQ (key1.pub, wallet.insert_adhoc (transaction, key1.prv)); @@ -76,7 +76,7 @@ TEST (wallet, retrieval) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); nano::keypair key1; ASSERT_TRUE (wallet.valid_password (transaction)); @@ -98,7 +98,7 @@ TEST (wallet, empty_iteration) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); auto i (wallet.begin (transaction)); auto j (wallet.end ()); @@ -112,7 +112,7 @@ TEST (wallet, one_item_iteration) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); nano::keypair key1; wallet.insert_adhoc (transaction, key1.prv); @@ -140,7 +140,7 @@ TEST (wallet, two_item_iteration) nano::kdf kdf; { auto transaction (env.tx_begin_write ()); - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); wallet.insert_adhoc (transaction, key1.prv); wallet.insert_adhoc (transaction, key2.prv); @@ -278,7 +278,7 @@ TEST (wallet, find_none) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); nano::account account (1000); ASSERT_EQ (wallet.end (), wallet.find (transaction, account)); @@ -291,7 +291,7 @@ TEST (wallet, find_existing) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); nano::keypair key1; ASSERT_FALSE (wallet.exists (transaction, key1.pub)); @@ -310,7 +310,7 @@ TEST (wallet, rekey) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); nano::raw_key password; wallet.password.value (password); @@ -382,7 +382,7 @@ TEST (wallet, hash_password) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); nano::raw_key hash1; wallet.derive_key (hash1, transaction, ""); @@ -432,25 +432,25 @@ TEST (wallet, reopen_default_password) ASSERT_FALSE (init); nano::kdf kdf; { - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); ASSERT_TRUE (wallet.valid_password (transaction)); } { bool init; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); ASSERT_TRUE (wallet.valid_password (transaction)); } { - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); wallet.rekey (transaction, ""); ASSERT_TRUE (wallet.valid_password (transaction)); } { bool init; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); ASSERT_FALSE (wallet.valid_password (transaction)); wallet.attempt_password (transaction, " "); @@ -467,10 +467,10 @@ TEST (wallet, representative) ASSERT_FALSE (error); auto transaction (env.tx_begin_write ()); nano::kdf kdf; - nano::wallet_store wallet (error, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (error, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (error); ASSERT_FALSE (wallet.is_representative (transaction)); - ASSERT_EQ (nano::genesis_account, wallet.representative (transaction)); + ASSERT_EQ (nano::dev::genesis->account (), wallet.representative (transaction)); ASSERT_FALSE (wallet.is_representative (transaction)); nano::keypair key; wallet.representative_set (transaction, key.pub); @@ -488,11 +488,11 @@ TEST (wallet, serialize_json_empty) ASSERT_FALSE (error); auto transaction (env.tx_begin_write ()); nano::kdf kdf; - nano::wallet_store wallet1 (error, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet1 (error, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (error); std::string serialized; wallet1.serialize_json (transaction, serialized); - nano::wallet_store wallet2 (error, kdf, transaction, nano::genesis_account, 1, "1", serialized); + nano::wallet_store wallet2 (error, kdf, transaction, nano::dev::genesis->account (), 1, "1", serialized); ASSERT_FALSE (error); nano::raw_key password1; nano::raw_key password2; @@ -513,13 +513,13 @@ TEST (wallet, serialize_json_one) ASSERT_FALSE (error); auto transaction (env.tx_begin_write ()); nano::kdf kdf; - nano::wallet_store wallet1 (error, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet1 (error, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (error); nano::keypair key; wallet1.insert_adhoc (transaction, key.prv); std::string serialized; wallet1.serialize_json (transaction, serialized); - nano::wallet_store wallet2 (error, kdf, transaction, nano::genesis_account, 1, "1", serialized); + nano::wallet_store wallet2 (error, kdf, transaction, nano::dev::genesis->account (), 1, "1", serialized); ASSERT_FALSE (error); nano::raw_key password1; nano::raw_key password2; @@ -542,14 +542,14 @@ TEST (wallet, serialize_json_password) ASSERT_FALSE (error); auto transaction (env.tx_begin_write ()); nano::kdf kdf; - nano::wallet_store wallet1 (error, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet1 (error, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (error); nano::keypair key; wallet1.rekey (transaction, "password"); wallet1.insert_adhoc (transaction, key.prv); std::string serialized; wallet1.serialize_json (transaction, serialized); - nano::wallet_store wallet2 (error, kdf, transaction, nano::genesis_account, 1, "1", serialized); + nano::wallet_store wallet2 (error, kdf, transaction, nano::dev::genesis->account (), 1, "1", serialized); ASSERT_FALSE (error); ASSERT_FALSE (wallet2.valid_password (transaction)); ASSERT_FALSE (wallet2.attempt_password (transaction, "password")); @@ -575,11 +575,11 @@ TEST (wallet_store, move) ASSERT_FALSE (error); auto transaction (env.tx_begin_write ()); nano::kdf kdf; - nano::wallet_store wallet1 (error, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet1 (error, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (error); nano::keypair key1; wallet1.insert_adhoc (transaction, key1.prv); - nano::wallet_store wallet2 (error, kdf, transaction, nano::genesis_account, 1, "1"); + nano::wallet_store wallet2 (error, kdf, transaction, nano::dev::genesis->account (), 1, "1"); ASSERT_FALSE (error); nano::keypair key2; wallet2.insert_adhoc (transaction, key2.prv); @@ -733,7 +733,7 @@ TEST (wallet, deterministic_keys) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); auto key1 = wallet.deterministic_key (transaction, 0); auto key2 = wallet.deterministic_key (transaction, 0); ASSERT_EQ (key1, key2); @@ -776,7 +776,7 @@ TEST (wallet, reseed) ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); nano::raw_key seed1; seed1 = 1; nano::raw_key seed2; @@ -1163,11 +1163,11 @@ TEST (wallet, search_pending) wallet.insert_adhoc (nano::dev_genesis_key.prv); nano::block_builder builder; auto send = builder.state () - .account (nano::genesis_account) + .account (nano::dev::genesis->account ()) .previous (nano::dev::genesis->hash ()) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (nano::genesis_amount - node.config.receive_minimum.number ()) - .link (nano::genesis_account) + .link (nano::dev::genesis->account ()) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); @@ -1180,7 +1180,7 @@ TEST (wallet, search_pending) ASSERT_NE (nullptr, election); // Erase the key so the confirmation does not trigger an automatic receive - wallet.store.erase (node.wallets.tx_begin_write (), nano::genesis_account); + wallet.store.erase (node.wallets.tx_begin_write (), nano::dev::genesis->account ()); // Now confirm the election election->force_confirm (); @@ -1193,8 +1193,8 @@ TEST (wallet, search_pending) // Pending search should create the receive block ASSERT_EQ (2, node.ledger.cache.block_count); ASSERT_FALSE (wallet.search_pending (wallet.wallets.tx_begin_read ())); - ASSERT_TIMELY (3s, node.balance (nano::genesis_account) == nano::genesis_amount); - auto receive_hash = node.ledger.latest (node.store.tx_begin_read (), nano::genesis_account); + ASSERT_TIMELY (3s, node.balance (nano::dev::genesis->account ()) == nano::genesis_amount); + auto receive_hash = node.ledger.latest (node.store.tx_begin_read (), nano::dev::genesis->account ()); auto receive = node.block (receive_hash); ASSERT_NE (nullptr, receive); ASSERT_EQ (receive->sideband ().height, 3); diff --git a/nano/core_test/wallets.cpp b/nano/core_test/wallets.cpp index 862d35fa..e0a9e477 100644 --- a/nano/core_test/wallets.cpp +++ b/nano/core_test/wallets.cpp @@ -166,11 +166,11 @@ TEST (wallets, search_pending) wallet->insert_adhoc (nano::dev_genesis_key.prv); nano::block_builder builder; auto send = builder.state () - .account (nano::genesis_account) + .account (nano::dev::genesis->account ()) .previous (nano::dev::genesis->hash ()) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (nano::genesis_amount - node.config.receive_minimum.number ()) - .link (nano::genesis_account) + .link (nano::dev::genesis->account ()) .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); @@ -190,7 +190,7 @@ TEST (wallets, search_pending) ASSERT_NE (nullptr, election); // Erase the key so the confirmation does not trigger an automatic receive - wallet->store.erase (node.wallets.tx_begin_write (), nano::genesis_account); + wallet->store.erase (node.wallets.tx_begin_write (), nano::dev::genesis->account ()); // Now confirm the election election->force_confirm (); @@ -210,8 +210,8 @@ TEST (wallets, search_pending) { node.wallets.search_pending (wallet_id); } - ASSERT_TIMELY (3s, node.balance (nano::genesis_account) == nano::genesis_amount); - auto receive_hash = node.ledger.latest (node.store.tx_begin_read (), nano::genesis_account); + ASSERT_TIMELY (3s, node.balance (nano::dev::genesis->account ()) == nano::genesis_amount); + auto receive_hash = node.ledger.latest (node.store.tx_begin_read (), nano::dev::genesis->account ()); auto receive = node.block (receive_hash); ASSERT_NE (nullptr, receive); ASSERT_EQ (receive->sideband ().height, 3); diff --git a/nano/load_test/entry.cpp b/nano/load_test/entry.cpp index e64b096c..454b2379 100644 --- a/nano/load_test/entry.cpp +++ b/nano/load_test/entry.cpp @@ -437,7 +437,7 @@ int main (int argc, char * const * argv) // Send from genesis account to different accounts and receive the funds boost::asio::spawn (ioc, [&ioc, &primary_node_results, &wallet, destination_account, &send_calls_remaining] (boost::asio::yield_context yield) { - send_receive (ioc, wallet, nano::genesis_account.to_account (), destination_account->as_string, send_calls_remaining, primary_node_results, yield); + send_receive (ioc, wallet, nano::dev::genesis->account ().to_account (), destination_account->as_string, send_calls_remaining, primary_node_results, yield); }); } diff --git a/nano/qt_test/qt.cpp b/nano/qt_test/qt.cpp index 33d12da7..74dd5d9f 100644 --- a/nano/qt_test/qt.cpp +++ b/nano/qt_test/qt.cpp @@ -350,7 +350,7 @@ TEST (wallet, process_block) nano_qt::eventloop_processor processor; nano::system system (1); nano::account account; - nano::block_hash latest (system.nodes[0]->latest (nano::genesis_account)); + nano::block_hash latest (system.nodes[0]->latest (nano::dev::genesis->account ())); system.wallet (0)->insert_adhoc (nano::keypair ().prv); { auto transaction (system.nodes[0]->wallets.tx_begin_read ()); @@ -655,7 +655,7 @@ TEST (wallet, block_viewer) ASSERT_NE (-1, wallet->advanced.layout->indexOf (wallet->advanced.block_viewer)); QTest::mouseClick (wallet->advanced.block_viewer, Qt::LeftButton); ASSERT_EQ (wallet->block_viewer.window, wallet->main_stack->currentWidget ()); - nano::block_hash latest (system.nodes[0]->latest (nano::genesis_account)); + nano::block_hash latest (system.nodes[0]->latest (nano::dev::genesis->account ())); QTest::keyClicks (wallet->block_viewer.hash, latest.to_string ().c_str ()); QTest::mouseClick (wallet->block_viewer.retrieve, Qt::LeftButton); ASSERT_FALSE (wallet->block_viewer.block->toPlainText ().toStdString ().empty ()); @@ -906,7 +906,7 @@ TEST (wallet, DISABLED_synchronizing) wallet->start (); { auto transaction (system1.nodes[0]->store.tx_begin_write ()); - auto latest (system1.nodes[0]->ledger.latest (transaction, nano::genesis_account)); + auto latest (system1.nodes[0]->ledger.latest (transaction, nano::dev::genesis->account ())); nano::send_block send (latest, key1, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system1.work.generate (latest)); system1.nodes[0]->ledger.process (transaction, send); } diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 9cabbd06..2a81df54 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -663,7 +663,7 @@ TEST (rpc, wallet_representative) request.put ("action", "wallet_representative"); auto response (wait_response (system, rpc, request)); std::string account_text1 (response.get ("representative")); - ASSERT_EQ (account_text1, nano::genesis_account.to_account ()); + ASSERT_EQ (account_text1, nano::dev::genesis->account ().to_account ()); } TEST (rpc, wallet_representative_set) @@ -822,7 +822,7 @@ TEST (rpc, wallet_export) rpc_ctx->io_scope->reset (); auto transaction (node->wallets.tx_begin_write ()); nano::kdf kdf; - nano::wallet_store store (error, kdf, transaction, nano::genesis_account, 1, "0", wallet_json); + nano::wallet_store store (error, kdf, transaction, nano::dev::genesis->account (), 1, "0", wallet_json); ASSERT_FALSE (error); ASSERT_TRUE (store.exists (transaction, nano::dev_genesis_key.pub)); } @@ -877,7 +877,7 @@ TEST (rpc, block) auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "block"); - request.put ("hash", node->latest (nano::genesis_account).to_string ()); + request.put ("hash", node->latest (nano::dev::genesis->account ()).to_string ()); auto response (wait_response (system, rpc, request)); auto contents (response.get ("contents")); ASSERT_FALSE (contents.empty ()); @@ -1086,9 +1086,9 @@ TEST (rpc, history) auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev_genesis_key.pub, node0->config.receive_minimum.number (), send->link ().as_account ())); ASSERT_NE (nullptr, receive); nano::genesis genesis; - nano::state_block usend (nano::genesis_account, node0->latest (nano::genesis_account), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (node0->latest (nano::genesis_account))); - nano::state_block ureceive (nano::genesis_account, usend.hash (), nano::genesis_account, nano::genesis_amount, usend.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (usend.hash ())); - nano::state_block uchange (nano::genesis_account, ureceive.hash (), nano::keypair ().pub, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (ureceive.hash ())); + nano::state_block usend (nano::dev::genesis->account (), node0->latest (nano::dev::genesis->account ()), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (node0->latest (nano::dev::genesis->account ()))); + nano::state_block ureceive (nano::dev::genesis->account (), usend.hash (), nano::dev::genesis->account (), nano::genesis_amount, usend.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (usend.hash ())); + nano::state_block uchange (nano::dev::genesis->account (), ureceive.hash (), nano::keypair ().pub, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (ureceive.hash ())); { auto transaction (node0->store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, usend).code); @@ -1143,9 +1143,9 @@ TEST (rpc, account_history) auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev_genesis_key.pub, node0->config.receive_minimum.number (), send->link ().as_account ())); ASSERT_NE (nullptr, receive); nano::genesis genesis; - nano::state_block usend (nano::genesis_account, node0->latest (nano::genesis_account), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (node0->latest (nano::genesis_account))); - nano::state_block ureceive (nano::genesis_account, usend.hash (), nano::genesis_account, nano::genesis_amount, usend.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (usend.hash ())); - nano::state_block uchange (nano::genesis_account, ureceive.hash (), nano::keypair ().pub, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (ureceive.hash ())); + nano::state_block usend (nano::dev::genesis->account (), node0->latest (nano::dev::genesis->account ()), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (node0->latest (nano::dev::genesis->account ()))); + nano::state_block ureceive (nano::dev::genesis->account (), usend.hash (), nano::dev::genesis->account (), nano::genesis_amount, usend.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (usend.hash ())); + nano::state_block uchange (nano::dev::genesis->account (), ureceive.hash (), nano::keypair ().pub, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (ureceive.hash ())); { auto transaction (node0->store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, usend).code); @@ -1156,7 +1156,7 @@ TEST (rpc, account_history) { boost::property_tree::ptree request; request.put ("action", "account_history"); - request.put ("account", nano::genesis_account.to_account ()); + request.put ("account", nano::dev::genesis->account ().to_account ()); request.put ("count", 100); auto response (wait_response (system, rpc, request, 10s)); std::vector> history_l; @@ -1197,7 +1197,7 @@ TEST (rpc, account_history) { boost::property_tree::ptree request; request.put ("action", "account_history"); - request.put ("account", nano::genesis_account.to_account ()); + request.put ("account", nano::dev::genesis->account ().to_account ()); request.put ("reverse", true); request.put ("count", 1); auto response (wait_response (system, rpc, request, 10s)); @@ -1283,9 +1283,9 @@ TEST (rpc, history_pruning) node0->process_active (send); auto receive (std::make_shared (send->hash (), send->hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work.generate (send->hash ()))); node0->process_active (receive); - auto usend (std::make_shared (nano::genesis_account, receive->hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (receive->hash ()))); - auto ureceive (std::make_shared (nano::genesis_account, usend->hash (), nano::genesis_account, nano::genesis_amount, usend->hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (usend->hash ()))); - auto uchange (std::make_shared (nano::genesis_account, ureceive->hash (), nano::keypair ().pub, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (ureceive->hash ()))); + auto usend (std::make_shared (nano::dev::genesis->account (), receive->hash (), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev::genesis->account (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (receive->hash ()))); + auto ureceive (std::make_shared (nano::dev::genesis->account (), usend->hash (), nano::dev::genesis->account (), nano::genesis_amount, usend->hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (usend->hash ()))); + auto uchange (std::make_shared (nano::dev::genesis->account (), ureceive->hash (), nano::keypair ().pub, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (ureceive->hash ()))); node0->process_active (usend); node0->process_active (ureceive); node0->process_active (uchange); @@ -1546,7 +1546,7 @@ TEST (rpc, process_subtype_send) auto [rpc, rpc_ctx] = add_rpc (system, node1); nano::keypair key; auto latest (node1->latest (nano::dev_genesis_key.pub)); - nano::state_block send (nano::genesis_account, latest, nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1->work_generate_blocking (latest)); + nano::state_block send (nano::dev::genesis->account (), latest, nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1->work_generate_blocking (latest)); boost::property_tree::ptree request; request.put ("action", "process"); std::string json; @@ -1572,7 +1572,7 @@ TEST (rpc, process_subtype_open) auto & node2 = *system.add_node (); nano::keypair key; auto latest (node1->latest (nano::dev_genesis_key.pub)); - auto send = std::make_shared (nano::genesis_account, latest, nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1->work_generate_blocking (latest)); + auto send = std::make_shared (nano::dev::genesis->account (), latest, nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1->work_generate_blocking (latest)); ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); ASSERT_EQ (nano::process_result::progress, node2.process (*send).code); auto [rpc, rpc_ctx] = add_rpc (system, node1); @@ -1602,7 +1602,7 @@ TEST (rpc, process_subtype_receive) auto node1 = add_ipc_enabled_node (system); auto & node2 = *system.add_node (); auto latest (node1->latest (nano::dev_genesis_key.pub)); - auto send = std::make_shared (nano::genesis_account, latest, nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1->work_generate_blocking (latest)); + auto send = std::make_shared (nano::dev::genesis->account (), latest, nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1->work_generate_blocking (latest)); ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); ASSERT_EQ (nano::process_result::progress, node2.process (*send).code); auto [rpc, rpc_ctx] = add_rpc (system, node1); @@ -1636,7 +1636,7 @@ TEST (rpc, process_ledger_insufficient_work) auto latest (node->latest (nano::dev_genesis_key.pub)); auto min_difficulty = node->network_params.network.publish_thresholds.entry; auto max_difficulty = node->network_params.network.publish_thresholds.epoch_1; - nano::state_block send (nano::genesis_account, latest, nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, system.work_generate_limited (latest, min_difficulty, max_difficulty)); + nano::state_block send (nano::dev::genesis->account (), latest, nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, system.work_generate_limited (latest, min_difficulty, max_difficulty)); ASSERT_LT (send.difficulty (), max_difficulty); ASSERT_GE (send.difficulty (), min_difficulty); boost::property_tree::ptree request; @@ -2478,11 +2478,11 @@ TEST (rpc, account_representative) auto node = add_ipc_enabled_node (system); auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; - request.put ("account", nano::genesis_account.to_account ()); + request.put ("account", nano::dev::genesis->account ().to_account ()); request.put ("action", "account_representative"); auto response (wait_response (system, rpc, request)); std::string account_text1 (response.get ("representative")); - ASSERT_EQ (account_text1, nano::genesis_account.to_account ()); + ASSERT_EQ (account_text1, nano::dev::genesis->account ().to_account ()); } TEST (rpc, account_representative_set) @@ -2493,7 +2493,7 @@ TEST (rpc, account_representative_set) auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; nano::keypair rep; - request.put ("account", nano::genesis_account.to_account ()); + request.put ("account", nano::dev::genesis->account ().to_account ()); request.put ("representative", rep.pub.to_account ()); request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); request.put ("action", "account_representative_set"); @@ -2517,7 +2517,7 @@ TEST (rpc, account_representative_set_work_disabled) auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; nano::keypair rep; - request.put ("account", nano::genesis_account.to_account ()); + request.put ("account", nano::dev::genesis->account ().to_account ()); request.put ("representative", rep.pub.to_account ()); request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); request.put ("action", "account_representative_set"); @@ -2569,7 +2569,7 @@ TEST (rpc, bootstrap) nano::system system1 (1); auto node1 = system1.nodes[0]; auto latest (node1->latest (nano::dev_genesis_key.pub)); - nano::send_block send (latest, nano::genesis_account, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1->work_generate_blocking (latest)); + nano::send_block send (latest, nano::dev::genesis->account (), 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1->work_generate_blocking (latest)); { auto transaction (node1->store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction, send).code); @@ -2585,7 +2585,7 @@ TEST (rpc, bootstrap) system0.poll (); } system1.deadline_set (10s); - while (node->latest (nano::genesis_account) != node1->latest (nano::genesis_account)) + while (node->latest (nano::dev::genesis->account ()) != node1->latest (nano::dev::genesis->account ())) { ASSERT_NO_ERROR (system0.poll ()); ASSERT_NO_ERROR (system1.poll ()); @@ -2624,7 +2624,7 @@ TEST (rpc, representatives) representatives.push_back (account); } ASSERT_EQ (1, representatives.size ()); - ASSERT_EQ (nano::genesis_account, representatives[0]); + ASSERT_EQ (nano::dev::genesis->account (), representatives[0]); } // wallet_seed is only available over IPC's unsafe encoding, and when running on test network @@ -2700,7 +2700,7 @@ TEST (rpc, wallet_frontiers) frontiers.push_back (nano::account (i->second.get (""))); } ASSERT_EQ (1, frontiers.size ()); - ASSERT_EQ (node->latest (nano::genesis_account), frontiers[0]); + ASSERT_EQ (node->latest (nano::dev::genesis->account ()), frontiers[0]); } TEST (rpc, work_validate) @@ -2848,7 +2848,7 @@ TEST (rpc, bootstrap_any) auto node = add_ipc_enabled_node (system0); nano::system system1 (1); auto latest (system1.nodes[0]->latest (nano::dev_genesis_key.pub)); - nano::send_block send (latest, nano::genesis_account, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system1.nodes[0]->work_generate_blocking (latest)); + nano::send_block send (latest, nano::dev::genesis->account (), 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system1.nodes[0]->work_generate_blocking (latest)); { auto transaction (system1.nodes[0]->store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, system1.nodes[0]->ledger.process (transaction, send).code); @@ -2985,7 +2985,7 @@ TEST (rpc, accounts_frontiers) std::string account_text (frontiers.first); ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), account_text); std::string frontier_text (frontiers.second.get ("")); - ASSERT_EQ (node->latest (nano::genesis_account), nano::block_hash{ frontier_text }); + ASSERT_EQ (node->latest (nano::dev::genesis->account ()), nano::block_hash{ frontier_text }); } } @@ -3093,14 +3093,14 @@ TEST (rpc, blocks) request.put ("action", "blocks"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", node->latest (nano::genesis_account).to_string ()); + entry.put ("", node->latest (nano::dev::genesis->account ()).to_string ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("hashes", peers_l); auto response (wait_response (system, rpc, request)); for (auto & blocks : response.get_child ("blocks")) { std::string hash_text (blocks.first); - ASSERT_EQ (node->latest (nano::genesis_account).to_string (), hash_text); + ASSERT_EQ (node->latest (nano::dev::genesis->account ()).to_string (), hash_text); std::string blocks_text (blocks.second.get ("")); ASSERT_FALSE (blocks_text.empty ()); } @@ -3203,7 +3203,7 @@ TEST (rpc, pending_exists) auto node = add_ipc_enabled_node (system); nano::keypair key1; system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto hash0 (node->latest (nano::genesis_account)); + auto hash0 (node->latest (nano::dev::genesis->account ())); auto block1 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key1.pub, 100)); node->scheduler.flush (); ASSERT_TIMELY (5s, !node->active.active (*block1)); @@ -3368,7 +3368,7 @@ TEST (rpc, work_get) std::string work_text (response.get ("work")); uint64_t work (1); auto transaction (node->wallets.tx_begin_read ()); - node->wallets.items.begin ()->second->store.work_get (transaction, nano::genesis_account, work); + node->wallets.items.begin ()->second->store.work_get (transaction, nano::dev::genesis->account (), work); ASSERT_EQ (nano::to_string_hex (work), work_text); } @@ -3390,7 +3390,7 @@ TEST (rpc, wallet_work_get) ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), account_text); std::string work_text (works.second.get ("")); uint64_t work (1); - node->wallets.items.begin ()->second->store.work_get (transaction, nano::genesis_account, work); + node->wallets.items.begin ()->second->store.work_get (transaction, nano::dev::genesis->account (), work); ASSERT_EQ (nano::to_string_hex (work), work_text); } } @@ -3412,7 +3412,7 @@ TEST (rpc, work_set) ASSERT_TRUE (success.empty ()); uint64_t work1 (1); auto transaction (node->wallets.tx_begin_read ()); - node->wallets.items.begin ()->second->store.work_get (transaction, nano::genesis_account, work1); + node->wallets.items.begin ()->second->store.work_get (transaction, nano::dev::genesis->account (), work1); ASSERT_EQ (work1, work0); } @@ -3775,7 +3775,7 @@ TEST (rpc, json_block_input) auto node1 = add_ipc_enabled_node (system); nano::keypair key; system.wallet (0)->insert_adhoc (key.prv); - nano::state_block send (nano::genesis_account, node1->latest (nano::dev_genesis_key.pub), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0); + nano::state_block send (nano::dev::genesis->account (), node1->latest (nano::dev_genesis_key.pub), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0); auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "sign"); @@ -3829,7 +3829,7 @@ TEST (rpc, blocks_info) for (auto & blocks : response.get_child ("blocks")) { std::string hash_text (blocks.first); - ASSERT_EQ (node->latest (nano::genesis_account).to_string (), hash_text); + ASSERT_EQ (node->latest (nano::dev::genesis->account ()).to_string (), hash_text); std::string account_text (blocks.second.get ("block_account")); ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), account_text); std::string amount_text (blocks.second.get ("amount")); @@ -3851,7 +3851,7 @@ TEST (rpc, blocks_info) request.put ("action", "blocks_info"); boost::property_tree::ptree entry; boost::property_tree::ptree hashes; - entry.put ("", node->latest (nano::genesis_account).to_string ()); + entry.put ("", node->latest (nano::dev::genesis->account ()).to_string ()); hashes.push_back (std::make_pair ("", entry)); request.add_child ("hashes", hashes); { @@ -5222,7 +5222,7 @@ TEST (rpc, sign_hash) nano::system system; auto node1 = add_ipc_enabled_node (system); nano::keypair key; - nano::state_block send (nano::genesis_account, node1->latest (nano::dev_genesis_key.pub), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0); + nano::state_block send (nano::dev::genesis->account (), node1->latest (nano::dev_genesis_key.pub), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0); auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "sign"); @@ -5245,7 +5245,7 @@ TEST (rpc, sign_block) auto node1 = add_ipc_enabled_node (system); nano::keypair key; system.wallet (0)->insert_adhoc (key.prv); - nano::state_block send (nano::genesis_account, node1->latest (nano::dev_genesis_key.pub), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0); + nano::state_block send (nano::dev::genesis->account (), node1->latest (nano::dev_genesis_key.pub), nano::dev::genesis->account (), nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0); auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "sign"); @@ -5321,7 +5321,7 @@ TEST (rpc, block_confirmed) nano::send_block send1 (latest, key.pub, 300, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send1).code); - nano::open_block open1 (send1.hash (), nano::genesis_account, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); + nano::open_block open1 (send1.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, open1).code); } rpc_ctx->io_scope->renew (); diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp index 4780ab28..e9492dfb 100644 --- a/nano/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -648,7 +648,7 @@ TEST (confirmation_height, long_chains) // First open the other account nano::send_block send (latest, key1.pub, nano::genesis_amount - nano::Gxrb_ratio + num_blocks + 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); - nano::open_block open (send.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); + nano::open_block open (send.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); { auto transaction = node->store.tx_begin_write (); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); @@ -674,11 +674,11 @@ TEST (confirmation_height, long_chains) // Send one from destination to genesis and pocket it nano::send_block send1 (previous_destination_chain_hash, nano::dev_genesis_key.pub, nano::Gxrb_ratio - 2, key1.prv, key1.pub, *system.work.generate (previous_destination_chain_hash)); - auto receive1 (std::make_shared (nano::dev_genesis_key.pub, previous_genesis_chain_hash, nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio + 1, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (previous_genesis_chain_hash))); + auto receive1 (std::make_shared (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::genesis_account, receive1->hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, key2.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (receive1->hash ())); + nano::state_block send2 (nano::dev::genesis->account (), receive1->hash (), nano::dev::genesis->account (), nano::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 (); diff --git a/nano/test_common/testutil.cpp b/nano/test_common/testutil.cpp index 1f593991..acc71493 100644 --- a/nano/test_common/testutil.cpp +++ b/nano/test_common/testutil.cpp @@ -18,7 +18,6 @@ nano::ledger_constants dev_constants (nano::networks::nano_dev_network); nano::keypair const & nano::zero_key (dev_constants.zero_key); nano::keypair const & nano::dev_genesis_key (dev_constants.dev_genesis_key); nano::account const & nano::nano_dev_account (dev_constants.nano_dev_account); -nano::account const & nano::genesis_account (dev_constants.genesis_account ()); nano::uint128_t const & nano::genesis_amount (dev_constants.genesis_amount); nano::account const & nano::burn_account (dev_constants.burn_account); diff --git a/nano/test_common/testutil.hpp b/nano/test_common/testutil.hpp index bf890b28..b7876ef3 100644 --- a/nano/test_common/testutil.hpp +++ b/nano/test_common/testutil.hpp @@ -56,7 +56,6 @@ class system; extern nano::keypair const & zero_key; extern nano::keypair const & dev_genesis_key; extern nano::public_key const & nano_dev_account; -extern nano::public_key const & genesis_account; extern nano::public_key const & burn_account; extern nano::uint128_t const & genesis_amount;