From 9f89fb8490737a9af7ea93506ca45b6cfa9ddc12 Mon Sep 17 00:00:00 2001 From: Colin LeMahieu Date: Mon, 19 Feb 2024 20:03:04 +0000 Subject: [PATCH] Convert ledger::process to accept a shared_ptr so it can store a reference. --- nano/core_test/active_transactions.cpp | 50 +- nano/core_test/block_store.cpp | 22 +- nano/core_test/bootstrap.cpp | 74 +-- nano/core_test/bootstrap_ascending.cpp | 10 +- nano/core_test/confirmation_height.cpp | 180 +++--- nano/core_test/conflicts.cpp | 4 +- nano/core_test/election.cpp | 4 +- nano/core_test/election_scheduler.cpp | 12 +- nano/core_test/frontiers_confirmation.cpp | 6 +- nano/core_test/ledger.cpp | 670 +++++++++++----------- nano/core_test/network.cpp | 4 +- nano/core_test/node.cpp | 302 +++++----- nano/core_test/processor_service.cpp | 6 +- nano/core_test/request_aggregator.cpp | 30 +- nano/core_test/system.cpp | 4 +- nano/core_test/voting.cpp | 8 +- nano/core_test/wallet.cpp | 4 +- nano/core_test/wallets.cpp | 10 +- nano/nano_node/entry.cpp | 4 +- nano/node/blockprocessor.cpp | 4 +- nano/node/node.cpp | 4 +- nano/node/node.hpp | 4 +- nano/qt_test/qt.cpp | 40 +- nano/rpc_test/receivable.cpp | 2 +- nano/rpc_test/rpc.cpp | 144 ++--- nano/secure/ledger.cpp | 6 +- nano/secure/ledger.hpp | 2 +- nano/slow_test/node.cpp | 60 +- nano/test_common/ledger.cpp | 2 +- nano/test_common/system.cpp | 4 +- nano/test_common/testutil.cpp | 2 +- 31 files changed, 840 insertions(+), 838 deletions(-) diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index b984e38b..c848ffe2 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -149,7 +149,7 @@ TEST (active_transactions, confirm_frontier) node2.rep_crawler.probable_reps.emplace (nano::dev::genesis_key.pub, *peers.begin ()); } - ASSERT_EQ (nano::block_status::progress, node2.process (*send)); + ASSERT_EQ (nano::block_status::progress, node2.process (send)); ASSERT_TIMELY (5s, !node2.active.empty ()); // Save election to check request count afterwards @@ -490,10 +490,10 @@ TEST (active_transactions, inactive_votes_cache_election_start) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send1)); - ASSERT_EQ (nano::block_status::progress, node.process (*send2)); - ASSERT_EQ (nano::block_status::progress, node.process (*open1)); - ASSERT_EQ (nano::block_status::progress, node.process (*open2)); + ASSERT_EQ (nano::block_status::progress, node.process (send1)); + ASSERT_EQ (nano::block_status::progress, node.process (send2)); + ASSERT_EQ (nano::block_status::progress, node.process (open1)); + ASSERT_EQ (nano::block_status::progress, node.process (open2)); ASSERT_TIMELY_EQ (5s, 5, node.ledger.cache.block_count); ASSERT_TRUE (node.active.empty ()); ASSERT_EQ (1, node.ledger.cache.cemented_count); @@ -1041,7 +1041,10 @@ TEST (active_transactions, confirmation_consistency) } } -TEST (active_transactions, confirm_new) +// Test disabled because it's failing intermittently. +// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3629 +// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3634 +TEST (active_transactions, DISABLED_confirm_new) { nano::test::system system (1); auto & node1 = *system.nodes[0]; @@ -1060,8 +1063,7 @@ TEST (active_transactions, confirm_new) // Let node2 know about the block ASSERT_TIMELY (5s, node2.block (send->hash ())); // Wait confirmation - ASSERT_TIMELY (5s, node1.ledger.cache.cemented_count == 2); - ASSERT_TIMELY (5s, node2.ledger.cache.cemented_count == 2); + ASSERT_TIMELY (5s, node1.ledger.cache.cemented_count == 2 && node2.ledger.cache.cemented_count == 2); } // Ensures votes are tallied on election::publish even if no vote is inserted through inactive_votes_cache @@ -1163,11 +1165,11 @@ TEST (active_transactions, activate_account_chain) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send)); - ASSERT_EQ (nano::block_status::progress, node.process (*send2)); - ASSERT_EQ (nano::block_status::progress, node.process (*send3)); - ASSERT_EQ (nano::block_status::progress, node.process (*open)); - ASSERT_EQ (nano::block_status::progress, node.process (*receive)); + ASSERT_EQ (nano::block_status::progress, node.process (send)); + ASSERT_EQ (nano::block_status::progress, node.process (send2)); + ASSERT_EQ (nano::block_status::progress, node.process (send3)); + ASSERT_EQ (nano::block_status::progress, node.process (open)); + ASSERT_EQ (nano::block_status::progress, node.process (receive)); node.scheduler.priority.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); ASSERT_TIMELY (5s, node.active.election (send->qualified_root ())); @@ -1246,9 +1248,9 @@ TEST (active_transactions, activate_inactive) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send)); - ASSERT_EQ (nano::block_status::progress, node.process (*send2)); - ASSERT_EQ (nano::block_status::progress, node.process (*open)); + ASSERT_EQ (nano::block_status::progress, node.process (send)); + ASSERT_EQ (nano::block_status::progress, node.process (send2)); + ASSERT_EQ (nano::block_status::progress, node.process (open)); auto election = nano::test::start_election (system, node, send2->hash ()); ASSERT_NE (nullptr, election); @@ -1283,7 +1285,7 @@ TEST (active_transactions, list_active) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send)); + ASSERT_EQ (nano::block_status::progress, node.process (send)); auto send2 = builder.make_block () .account (nano::dev::genesis_key.pub) @@ -1295,7 +1297,7 @@ TEST (active_transactions, list_active) .work (*system.work.generate (send->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node.process (send2)); auto open = builder.make_block () .account (key.pub) @@ -1307,7 +1309,7 @@ TEST (active_transactions, list_active) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*open)); + ASSERT_EQ (nano::block_status::progress, node.process (open)); ASSERT_TRUE (nano::test::start_elections (system, node, { send, send2, open })); ASSERT_EQ (3, node.active.size ()); @@ -1340,7 +1342,7 @@ TEST (active_transactions, vacancy) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); node.active.vacancy_update = [&updated] () { updated = true; }; - ASSERT_EQ (nano::block_status::progress, node.process (*send)); + ASSERT_EQ (nano::block_status::progress, node.process (send)); ASSERT_EQ (1, node.active.vacancy ()); ASSERT_EQ (0, node.active.size ()); node.scheduler.priority.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); @@ -1381,7 +1383,7 @@ TEST (active_transactions, fifo) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_hash)) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node.process (send1)); node.process_confirmed (nano::election_status{ send1 }); ASSERT_TIMELY (5s, node.block_confirmed (send1->hash ())); @@ -1396,7 +1398,7 @@ TEST (active_transactions, fifo) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_hash)) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node.process (send2)); node.process_confirmed (nano::election_status{ send2 }); ASSERT_TIMELY (5s, node.block_confirmed (send2->hash ())); @@ -1409,7 +1411,7 @@ TEST (active_transactions, fifo) .sign (key0.prv, key0.pub) .work (*system.work.generate (key0.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*receive1)); + ASSERT_EQ (nano::block_status::progress, node.process (receive1)); auto receive2 = builder.make_block () .previous (0) @@ -1420,7 +1422,7 @@ TEST (active_transactions, fifo) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*receive2)); + ASSERT_EQ (nano::block_status::progress, node.process (receive2)); // Ensure first transaction becomes active node.scheduler.manual.push (receive1); diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index c5694626..6f010ee2 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -1021,7 +1021,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); auto receive = builder .receive () .previous (send->hash ()) @@ -1029,7 +1029,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive)); auto change = builder .change () .previous (receive->hash ()) @@ -1037,7 +1037,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (receive->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change)); auto state_send1 = builder .state () .account (nano::dev::genesis_key.pub) @@ -1048,7 +1048,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (change->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, state_send1)); auto state_send2 = builder .state () .account (nano::dev::genesis_key.pub) @@ -1059,7 +1059,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (state_send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, state_send2)); auto state_send3 = builder .state () .account (nano::dev::genesis_key.pub) @@ -1070,7 +1070,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (state_send2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_send3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, state_send3)); auto state_open = builder .state () .account (key1.pub) @@ -1081,7 +1081,7 @@ TEST (mdb_block_store, sideband_height) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, state_open)); auto epoch = builder .state () .account (key1.pub) @@ -1092,7 +1092,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (state_open->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch)); ASSERT_EQ (nano::epoch::epoch_1, ledger.version (*epoch)); auto epoch_open = builder .state () @@ -1104,7 +1104,7 @@ TEST (mdb_block_store, sideband_height) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch_open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch_open)); ASSERT_EQ (nano::epoch::epoch_1, ledger.version (*epoch_open)); auto state_receive = builder .state () @@ -1116,7 +1116,7 @@ TEST (mdb_block_store, sideband_height) .sign (key2.prv, key2.pub) .work (*pool.generate (epoch_open->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_receive)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, state_receive)); auto open = builder .open () .source (state_send3->hash ()) @@ -1125,7 +1125,7 @@ TEST (mdb_block_store, sideband_height) .sign (key3.prv, key3.pub) .work (*pool.generate (key3.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); auto block1 (store.block.get (transaction, nano::dev::genesis->hash ())); ASSERT_EQ (block1->sideband ().height, 1); auto block2 (store.block.get (transaction, send->hash ())); diff --git a/nano/core_test/bootstrap.cpp b/nano/core_test/bootstrap.cpp index 485e49a0..bf1045d1 100644 --- a/nano/core_test/bootstrap.cpp +++ b/nano/core_test/bootstrap.cpp @@ -69,7 +69,7 @@ TEST (bulk_pull, end_not_owned) open->refresh (); open->signature = nano::sign_message (key2.prv, key2.pub, open->hash ()); system.nodes[0]->work_generate_blocking (*open); - ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (*open)); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (open)); auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0])); auto req = std::make_unique (nano::dev::network_params.network); req->start = key2.pub; @@ -122,7 +122,7 @@ TEST (bulk_pull, ascending_one_hash) .work (0) .build (); node.work_generate_blocking (*block1); - ASSERT_EQ (nano::block_status::progress, node.process (*block1)); + ASSERT_EQ (nano::block_status::progress, node.process (block1)); auto socket = std::make_shared (node, nano::transport::socket::endpoint_type_t::server); auto connection = std::make_shared (socket, system.nodes[0]); auto req = std::make_unique (nano::dev::network_params.network); @@ -154,7 +154,7 @@ TEST (bulk_pull, ascending_two_account) .work (0) .build (); node.work_generate_blocking (*block1); - ASSERT_EQ (nano::block_status::progress, node.process (*block1)); + ASSERT_EQ (nano::block_status::progress, node.process (block1)); auto socket = std::make_shared (node, nano::transport::socket::endpoint_type_t::server); auto connection = std::make_shared (socket, system.nodes[0]); auto req = std::make_unique (nano::dev::network_params.network); @@ -189,7 +189,7 @@ TEST (bulk_pull, ascending_end) .work (0) .build (); node.work_generate_blocking (*block1); - ASSERT_EQ (nano::block_status::progress, node.process (*block1)); + ASSERT_EQ (nano::block_status::progress, node.process (block1)); auto socket = std::make_shared (node, nano::transport::socket::endpoint_type_t::server); auto connection = std::make_shared (socket, system.nodes[0]); auto req = std::make_unique (nano::dev::network_params.network); @@ -249,7 +249,7 @@ TEST (bulk_pull, count_limit) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (node0->latest (nano::dev::genesis_key.pub))) .build (); - ASSERT_EQ (nano::block_status::progress, node0->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node0->process (send1)); auto receive1 = builder .receive () .previous (send1->hash ()) @@ -257,7 +257,7 @@ TEST (bulk_pull, count_limit) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node0->process (*receive1)); + ASSERT_EQ (nano::block_status::progress, node0->process (receive1)); auto connection (std::make_shared (std::make_shared (*node0, nano::transport::socket::endpoint_type_t::server), node0)); auto req = std::make_unique (nano::dev::network_params.network); @@ -375,8 +375,8 @@ TEST (bootstrap_processor, process_state) node0->work_generate_blocking (*block1); node0->work_generate_blocking (*block2); - ASSERT_EQ (nano::block_status::progress, node0->process (*block1)); - ASSERT_EQ (nano::block_status::progress, node0->process (*block2)); + ASSERT_EQ (nano::block_status::progress, node0->process (block1)); + ASSERT_EQ (nano::block_status::progress, node0->process (block2)); ASSERT_TIMELY_EQ (5s, nano::test::account_info (*node0, nano::dev::genesis_key.pub).block_count, 3); auto node1 = system.make_disconnected_node (std::nullopt, node_flags); @@ -444,7 +444,7 @@ TEST (bootstrap_processor, pull_diamond) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (node0->latest (nano::dev::genesis_key.pub))) .build (); - ASSERT_EQ (nano::block_status::progress, node0->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node0->process (send1)); auto open = builder .open () .source (send1->hash ()) @@ -453,7 +453,7 @@ TEST (bootstrap_processor, pull_diamond) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node0->process (*open)); + ASSERT_EQ (nano::block_status::progress, node0->process (open)); auto send2 = builder .send () .previous (open->hash ()) @@ -462,7 +462,7 @@ TEST (bootstrap_processor, pull_diamond) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node0->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node0->process (send2)); auto receive = builder .receive () .previous (send1->hash ()) @@ -470,7 +470,7 @@ TEST (bootstrap_processor, pull_diamond) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node0->process (*receive)); + ASSERT_EQ (nano::block_status::progress, node0->process (receive)); auto node1 = system.make_disconnected_node (); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); @@ -541,7 +541,7 @@ TEST (bootstrap_processor, push_diamond) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1->process (send1)); // open key account receiving all balance of genesis auto open = builder @@ -552,7 +552,7 @@ TEST (bootstrap_processor, push_diamond) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); // send from key to genesis 100 raw auto send2 = builder @@ -563,7 +563,7 @@ TEST (bootstrap_processor, push_diamond) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1->process (send2)); // receive the 100 raw on genesis auto receive = builder @@ -573,7 +573,7 @@ TEST (bootstrap_processor, push_diamond) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*receive)); + ASSERT_EQ (nano::block_status::progress, node1->process (receive)); nano::node_config config = system.default_config (); config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; @@ -614,7 +614,7 @@ TEST (bootstrap_processor, push_diamond_pruning) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1->process (send1)); // receive all balance on key auto open = builder @@ -625,7 +625,7 @@ TEST (bootstrap_processor, push_diamond_pruning) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); // 1st bootstrap node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); @@ -643,7 +643,7 @@ TEST (bootstrap_processor, push_diamond_pruning) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1->process (send2)); // receive the 100 raw from key on genesis auto receive = builder @@ -653,7 +653,7 @@ TEST (bootstrap_processor, push_diamond_pruning) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*receive)); + ASSERT_EQ (nano::block_status::progress, node1->process (receive)); { auto transaction (node1->store.tx_begin_write ()); @@ -1130,7 +1130,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1->process (send1)); auto send2 = builder .state () .account (nano::dev::genesis_key.pub) @@ -1141,7 +1141,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1->process (send2)); auto open = builder .open () .source (send1->hash ()) @@ -1150,7 +1150,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); auto receive = builder .state () .account (key.pub) @@ -1161,7 +1161,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*receive)); + ASSERT_EQ (nano::block_status::progress, node1->process (receive)); ASSERT_TIMELY (5s, nano::test::exists (*node1, { send1, send2, open, receive })); @@ -1200,7 +1200,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1->process (send1)); auto open = builder .open () .source (send1->hash ()) @@ -1209,7 +1209,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); auto send2 = builder .state () .account (key.pub) @@ -1220,7 +1220,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1->process (send2)); // Start lazy bootstrap with last block in chain known auto node2 = system.make_disconnected_node (std::nullopt, node_flags); @@ -1259,7 +1259,7 @@ TEST (bootstrap_processor, lazy_destinations) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1->process (send1)); // send Gxrb_ratio raw from genesis to key2 auto send2 = builder @@ -1272,7 +1272,7 @@ TEST (bootstrap_processor, lazy_destinations) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1->process (send2)); // receive send1 on key1 auto open = builder @@ -1283,7 +1283,7 @@ TEST (bootstrap_processor, lazy_destinations) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); // receive send2 on key2 auto state_open = builder @@ -1296,7 +1296,7 @@ TEST (bootstrap_processor, lazy_destinations) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*state_open)); + ASSERT_EQ (nano::block_status::progress, node1->process (state_open)); // Start lazy bootstrap with last block in sender chain auto node2 = system.make_disconnected_node (std::nullopt, node_flags); @@ -1744,7 +1744,7 @@ TEST (frontier_req, count) .work (0) .build (); node1->work_generate_blocking (*send1); - ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1->process (send1)); auto receive1 = builder .make_block () .account (key1.pub) @@ -1756,7 +1756,7 @@ TEST (frontier_req, count) .work (0) .build (); node1->work_generate_blocking (*receive1); - ASSERT_EQ (nano::block_status::progress, node1->process (*receive1)); + ASSERT_EQ (nano::block_status::progress, node1->process (receive1)); auto connection (std::make_shared (std::make_shared (*node1, nano::transport::socket::endpoint_type_t::server), node1)); auto req = std::make_unique (nano::dev::network_params.network); @@ -1839,7 +1839,7 @@ TEST (frontier_req, confirmed_frontier) .work (0) .build (); node1->work_generate_blocking (*send1); - ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1->process (send1)); auto send2 = builder .make_block () .account (nano::dev::genesis_key.pub) @@ -1851,7 +1851,7 @@ TEST (frontier_req, confirmed_frontier) .work (0) .build (); node1->work_generate_blocking (*send2); - ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1->process (send2)); auto receive1 = builder .make_block () .account (key_before_genesis.pub) @@ -1863,7 +1863,7 @@ TEST (frontier_req, confirmed_frontier) .work (0) .build (); node1->work_generate_blocking (*receive1); - ASSERT_EQ (nano::block_status::progress, node1->process (*receive1)); + ASSERT_EQ (nano::block_status::progress, node1->process (receive1)); auto receive2 = builder .make_block () .account (key_after_genesis.pub) @@ -1875,7 +1875,7 @@ TEST (frontier_req, confirmed_frontier) .work (0) .build (); node1->work_generate_blocking (*receive2); - ASSERT_EQ (nano::block_status::progress, node1->process (*receive2)); + ASSERT_EQ (nano::block_status::progress, node1->process (receive2)); // Request for all accounts (confirmed only) auto connection (std::make_shared (std::make_shared (*node1, nano::transport::socket::endpoint_type_t::server), node1)); diff --git a/nano/core_test/bootstrap_ascending.cpp b/nano/core_test/bootstrap_ascending.cpp index 914c58c6..a9ca2584 100644 --- a/nano/core_test/bootstrap_ascending.cpp +++ b/nano/core_test/bootstrap_ascending.cpp @@ -171,7 +171,7 @@ TEST (bootstrap_ascending, account_base) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node0.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node0.process (send1)); auto & node1 = *system.add_node (flags); ASSERT_TIMELY (5s, node1.block (send1->hash ()) != nullptr); } @@ -206,8 +206,8 @@ TEST (bootstrap_ascending, account_inductive) // std::cerr << "Genesis: " << nano::dev::genesis->hash ().to_string () << std::endl; // std::cerr << "Send1: " << send1->hash ().to_string () << std::endl; // std::cerr << "Send2: " << send2->hash ().to_string () << std::endl; - ASSERT_EQ (nano::block_status::progress, node0.process (*send1)); - ASSERT_EQ (nano::block_status::progress, node0.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node0.process (send1)); + ASSERT_EQ (nano::block_status::progress, node0.process (send2)); auto & node1 = *system.add_node (flags); ASSERT_TIMELY (50s, node1.block (send2->hash ()) != nullptr); } @@ -248,8 +248,8 @@ TEST (bootstrap_ascending, trace_base) // std::cerr << "receive1: " << receive1->hash ().to_string () << std::endl; auto & node1 = *system.add_node (); // std::cerr << "--------------- Start ---------------\n"; - ASSERT_EQ (nano::block_status::progress, node0.process (*send1)); - ASSERT_EQ (nano::block_status::progress, node0.process (*receive1)); + ASSERT_EQ (nano::block_status::progress, node0.process (send1)); + ASSERT_EQ (nano::block_status::progress, node0.process (receive1)); ASSERT_EQ (node1.store.pending.begin (node1.store.tx_begin_read (), nano::pending_key{ key.pub, 0 }), node1.store.pending.end ()); // std::cerr << "node0: " << node0.network.endpoint () << std::endl; // std::cerr << "node1: " << node1.network.endpoint () << std::endl; diff --git a/nano/core_test/confirmation_height.cpp b/nano/core_test/confirmation_height.cpp index 8027db46..906c6bc2 100644 --- a/nano/core_test/confirmation_height.cpp +++ b/nano/core_test/confirmation_height.cpp @@ -199,20 +199,20 @@ TEST (confirmation_height, multiple_accounts) { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send3)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open3)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send4)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send5)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send4)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send5)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send6)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send6)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive2)); // Check confirmation heights of all the accounts (except genesis) are uninitialized (0), // as we have any just added them to the ledger and not processed any live transactions yet. @@ -669,20 +669,20 @@ TEST (confirmation_height, send_receive_between_2_accounts) // Unpocketed send { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send4)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send4)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive3)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send5)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send6)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send5)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send6)); } add_callback_stats (*node); @@ -793,14 +793,14 @@ TEST (confirmation_height, send_receive_self) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send3)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive3)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send4)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send4)); } add_callback_stats (*node); @@ -1023,30 +1023,30 @@ TEST (confirmation_height, all_block_types) { auto transaction (store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_open)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_receive)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_receive)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *change)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_change)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, change)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_change)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *epoch)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *epoch1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, epoch)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, epoch1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_receive2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_receive2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_send3)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send4)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_receive3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_send4)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_receive3)); } add_callback_stats (*node); @@ -1117,7 +1117,7 @@ TEST (confirmation_height, conflict_rollback_cemented) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (genesis_hash)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*fork1a)); + ASSERT_EQ (nano::block_status::progress, node1->process (fork1a)); ASSERT_TRUE (nano::test::start_elections (system, *node1, { fork1a }, true)); ASSERT_TIMELY (5s, nano::test::confirmed (*node1, { fork1a })); @@ -1269,7 +1269,7 @@ TEST (confirmation_heightDeathTest, modified_chain) { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); } uint64_t batch_write_size = 2048; @@ -1290,7 +1290,7 @@ TEST (confirmation_heightDeathTest, modified_chain) ASSERT_DEATH_IF_SUPPORTED (bounded_processor.cement_blocks (scoped_write_guard), ""); } - ASSERT_EQ (nano::block_status::progress, ledger.process (store->tx_begin_write (), *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (store->tx_begin_write (), send)); store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () }); nano::confirmation_height_unbounded unbounded_processor ( @@ -1356,8 +1356,8 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed) { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, ledger.constants); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); } uint64_t batch_write_size = 2048; @@ -1379,7 +1379,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed) } // Reset conditions and test with the bounded processor - ASSERT_EQ (nano::block_status::progress, ledger.process (store->tx_begin_write (), *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (store->tx_begin_write (), open)); store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () }); nano::confirmation_height_bounded bounded_processor ( @@ -1434,8 +1434,8 @@ TEST (confirmation_height, pending_observer_callbacks) { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); } add_callback_stats (*node); @@ -1482,7 +1482,7 @@ TEST (confirmation_height, callback_confirmed_history) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); } auto send1 = builder @@ -1586,9 +1586,9 @@ TEST (confirmation_height, dependent_election) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2)); } add_callback_stats (*node); @@ -1729,21 +1729,21 @@ TEST (confirmation_height, cemented_gap_below_receive) { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, dummy_send)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, dummy_send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, dummy_send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open1)); } std::vector observer_order; @@ -1889,21 +1889,21 @@ TEST (confirmation_height, cemented_gap_below_no_cache) { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, dummy_send)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, dummy_send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send3)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, dummy_send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open1)); } // Force some blocks to be cemented so that the cached confirmed info variable is empty @@ -1959,7 +1959,7 @@ TEST (confirmation_height, election_winner_details_clearing) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node->process (send1)); auto const send2 = builder.make_block () .previous (send1->hash ()) @@ -1968,7 +1968,7 @@ TEST (confirmation_height, election_winner_details_clearing) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node->process (send2)); auto const send3 = builder.make_block () .previous (send2->hash ()) @@ -1977,7 +1977,7 @@ TEST (confirmation_height, election_winner_details_clearing) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*send3)); + ASSERT_EQ (nano::block_status::progress, node->process (send3)); node->process_confirmed (nano::election_status{ send2 }); ASSERT_TIMELY (5s, node->block_confirmed (send2->hash ())); @@ -2062,8 +2062,8 @@ TEST (confirmation_height, unbounded_block_cache_iteration) { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, nano::dev::constants); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); } nano::confirmation_height_processor confirmation_height_processor (ledger, write_database_queue, 10ms, logger, initialized_latch, nano::confirmation_height_mode::unbounded); @@ -2159,11 +2159,11 @@ TEST (confirmation_height, pruned_source) { auto transaction (store->tx_begin_write ()); store->initialize (transaction, ledger.cache, nano::dev::constants); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send3)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open2)); } uint64_t batch_write_size = 2; std::atomic stopped{ false }; diff --git a/nano/core_test/conflicts.cpp b/nano/core_test/conflicts.cpp index a670b377..644388bd 100644 --- a/nano/core_test/conflicts.cpp +++ b/nano/core_test/conflicts.cpp @@ -27,7 +27,7 @@ TEST (conflicts, start_stop) .work (0) .build (); node1.work_generate_blocking (*send1); - ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1.process (send1)); ASSERT_EQ (0, node1.active.size ()); node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); @@ -56,7 +56,7 @@ TEST (conflicts, add_existing) node1.work_generate_blocking (*send1); // add the block to ledger as an unconfirmed block - ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1.process (send1)); // wait for send1 to be inserted in the ledger ASSERT_TIMELY (5s, node1.block (send1->hash ())); diff --git a/nano/core_test/election.cpp b/nano/core_test/election.cpp index cfd43443..fc193cc6 100644 --- a/nano/core_test/election.cpp +++ b/nano/core_test/election.cpp @@ -224,7 +224,7 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks) ASSERT_TIMELY (5s, node1.block (send1->hash ()) != nullptr); auto const open1 = nano::open_block_builder{}.make_block ().account (key1.pub).source (send1->hash ()).representative (key1.pub).sign (key1.prv, key1.pub).work (*system.work.generate (key1.pub)).build (); - ASSERT_EQ (nano::block_status::progress, node1.process (*open1)); + ASSERT_EQ (nano::block_status::progress, node1.process (open1)); nano::keypair key2; auto const send2 = builder.make_block () @@ -234,7 +234,7 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks) .sign (key1.prv, key1.pub) .work (*system.work.generate (open1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1.process (send2)); ASSERT_TIMELY_EQ (5s, node1.ledger.cache.block_count, 4); node_config.peering_port = system.get_available_port (); diff --git a/nano/core_test/election_scheduler.cpp b/nano/core_test/election_scheduler.cpp index db78e136..af028dd9 100644 --- a/nano/core_test/election_scheduler.cpp +++ b/nano/core_test/election_scheduler.cpp @@ -27,7 +27,7 @@ TEST (election_scheduler, activate_one_timely) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), *send1); + system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), send1); system.nodes[0]->scheduler.priority.activate (nano::dev::genesis_key.pub, system.nodes[0]->store.tx_begin_read ()); ASSERT_TIMELY (5s, system.nodes[0]->active.election (send1->qualified_root ())); } @@ -45,7 +45,7 @@ TEST (election_scheduler, activate_one_flush) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), *send1); + system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), send1); system.nodes[0]->scheduler.priority.activate (nano::dev::genesis_key.pub, system.nodes[0]->store.tx_begin_read ()); ASSERT_TIMELY (5s, system.nodes[0]->active.election (send1->qualified_root ())); } @@ -87,7 +87,7 @@ TEST (election_scheduler, no_vacancy) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send)); + ASSERT_EQ (nano::block_status::progress, node.process (send)); node.process_confirmed (nano::election_status{ send }); auto receive = builder.make_block () @@ -99,7 +99,7 @@ TEST (election_scheduler, no_vacancy) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*receive)); + ASSERT_EQ (nano::block_status::progress, node.process (receive)); node.process_confirmed (nano::election_status{ receive }); // Second, process two eligible transactions @@ -112,7 +112,7 @@ TEST (election_scheduler, no_vacancy) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*block1)); + ASSERT_EQ (nano::block_status::progress, node.process (block1)); // There is vacancy so it should be inserted node.scheduler.priority.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); @@ -128,7 +128,7 @@ TEST (election_scheduler, no_vacancy) .sign (key.prv, key.pub) .work (*system.work.generate (receive->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*block2)); + ASSERT_EQ (nano::block_status::progress, node.process (block2)); // There is no vacancy so it should stay queued node.scheduler.priority.activate (key.pub, node.store.tx_begin_read ()); diff --git a/nano/core_test/frontiers_confirmation.cpp b/nano/core_test/frontiers_confirmation.cpp index 3b5c29f3..76812a6b 100644 --- a/nano/core_test/frontiers_confirmation.cpp +++ b/nano/core_test/frontiers_confirmation.cpp @@ -29,7 +29,7 @@ TEST (frontiers_confirmation, mode) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); } ASSERT_TIMELY_EQ (5s, node->active.size (), 1); } @@ -51,7 +51,7 @@ TEST (frontiers_confirmation, mode) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); } ASSERT_TIMELY_EQ (5s, node->active.size (), 1); } @@ -73,7 +73,7 @@ TEST (frontiers_confirmation, mode) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); } system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); std::this_thread::sleep_for (std::chrono::seconds (1)); diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 983ed8c7..821d1d49 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -77,7 +77,7 @@ TEST (ledger, process_modifies_sideband) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (store.tx_begin_write (), send1)); ASSERT_EQ (send1->sideband ().timestamp, store.block.get (store.tx_begin_read (), send1->hash ())->sideband ().timestamp); } @@ -105,7 +105,7 @@ TEST (ledger, process_send) ASSERT_EQ (nano::dev::genesis_key.pub, store.frontier.get (transaction, info1->head)); ASSERT_EQ (1, info1->block_count); // This was a valid block, it should progress. - auto return1 = ledger.process (transaction, *send); + auto return1 = ledger.process (transaction, send); ASSERT_EQ (nano::dev::genesis_key.pub, send->sideband ().account); ASSERT_EQ (2, send->sideband ().height); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.amount (transaction, hash1)); @@ -134,7 +134,7 @@ TEST (ledger, process_send) .build (); nano::block_hash hash2 (open->hash ()); // This was a valid block, it should progress. - auto return2 = ledger.process (transaction, *open); + auto return2 = ledger.process (transaction, open); ASSERT_EQ (nano::block_status::progress, return2); ASSERT_EQ (key2.pub, open->sideband ().account); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, open->sideband ().balance.number ()); @@ -212,7 +212,7 @@ TEST (ledger, process_receive) .work (*pool.generate (info1->head)) .build (); nano::block_hash hash1 (send->hash ()); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); nano::keypair key3; auto open = builder .open () @@ -223,7 +223,7 @@ TEST (ledger, process_receive) .work (*pool.generate (key2.pub)) .build (); nano::block_hash hash2 (open->hash ()); - auto return1 = ledger.process (transaction, *open); + auto return1 = ledger.process (transaction, open); ASSERT_EQ (nano::block_status::progress, return1); ASSERT_EQ (key2.pub, ledger.account (*open)); ASSERT_EQ (key2.pub, open->sideband ().account); @@ -240,7 +240,7 @@ TEST (ledger, process_receive) .work (*pool.generate (hash1)) .build (); nano::block_hash hash3 = send2->hash (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); auto receive = builder .receive () .previous (hash2) @@ -250,7 +250,7 @@ TEST (ledger, process_receive) .build (); auto hash4 = receive->hash (); ASSERT_EQ (key2.pub, store.frontier.get (transaction, hash2)); - auto return2 = ledger.process (transaction, *receive); + auto return2 = ledger.process (transaction, receive); ASSERT_EQ (key2.pub, receive->sideband ().account); ASSERT_EQ (nano::dev::constants.genesis_amount - 25, receive->sideband ().balance.number ()); ASSERT_EQ (2, receive->sideband ().height); @@ -300,7 +300,7 @@ TEST (ledger, rollback_receiver) .work (*pool.generate (info1->head)) .build (); nano::block_hash hash1 (send->hash ()); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); nano::keypair key3; auto open = builder .open () @@ -311,7 +311,7 @@ TEST (ledger, rollback_receiver) .work (*pool.generate (key2.pub)) .build (); nano::block_hash hash2 (open->hash ()); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); ASSERT_EQ (hash2, ledger.latest (transaction, key2.pub)); ASSERT_EQ (50, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); @@ -345,7 +345,7 @@ TEST (ledger, rollback_representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change1)); nano::keypair key3; auto change2 = builder .change () @@ -354,7 +354,7 @@ TEST (ledger, rollback_representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (change1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change2)); nano::keypair key2; auto send1 = builder .send () @@ -364,7 +364,7 @@ TEST (ledger, rollback_representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (change2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); nano::keypair key4; auto open = builder .open () @@ -374,7 +374,7 @@ TEST (ledger, rollback_representation) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); auto send2 = builder .send () .previous (send1->hash ()) @@ -383,7 +383,7 @@ TEST (ledger, rollback_representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); auto receive1 = builder .receive () .previous (open->hash ()) @@ -391,7 +391,7 @@ TEST (ledger, rollback_representation) .sign (key2.prv, key2.pub) .work (*pool.generate (open->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_EQ (1, ledger.weight (key3.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount - 1, ledger.weight (key4.pub)); auto info1 = ledger.account_info (transaction, key2.pub); @@ -435,7 +435,7 @@ TEST (ledger, receive_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); auto receive = builder .receive () .previous (send->hash ()) @@ -443,7 +443,7 @@ TEST (ledger, receive_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive)); ASSERT_FALSE (ledger.rollback (transaction, receive->hash ())); } @@ -467,8 +467,8 @@ TEST (ledger, process_duplicate) .work (*pool.generate (info1->head)) .build (); nano::block_hash hash1 (send->hash ()); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); - ASSERT_EQ (nano::block_status::old, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); + ASSERT_EQ (nano::block_status::old, ledger.process (transaction, send)); auto open = builder .open () .source (hash1) @@ -477,8 +477,8 @@ TEST (ledger, process_duplicate) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); - ASSERT_EQ (nano::block_status::old, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); + ASSERT_EQ (nano::block_status::old, ledger.process (transaction, open)); } TEST (ledger, representative_genesis) @@ -520,7 +520,7 @@ TEST (ledger, representative_change) .work (*pool.generate (info1->head)) .build (); ASSERT_EQ (nano::dev::genesis_key.pub, store.frontier.get (transaction, info1->head)); - auto return1 (ledger.process (transaction, *block)); + auto return1 (ledger.process (transaction, block)); ASSERT_EQ (0, ledger.amount (transaction, block->hash ())); ASSERT_TRUE (store.frontier.get (transaction, info1->head).is_zero ()); ASSERT_EQ (nano::dev::genesis_key.pub, store.frontier.get (transaction, block->hash ())); @@ -561,7 +561,7 @@ TEST (ledger, send_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1->head)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block)); auto block2 = builder .send () .previous (info1->head) @@ -570,7 +570,7 @@ TEST (ledger, send_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1->head)) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, block2)); } TEST (ledger, receive_fork) @@ -593,7 +593,7 @@ TEST (ledger, receive_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1->head)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block)); auto block2 = builder .open () .source (block->hash ()) @@ -602,7 +602,7 @@ TEST (ledger, receive_fork) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block2)); auto block3 = builder .change () .previous (block2->hash ()) @@ -610,7 +610,7 @@ TEST (ledger, receive_fork) .sign (key2.prv, key2.pub) .work (*pool.generate (block2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block3)); auto block4 = builder .send () .previous (block->hash ()) @@ -619,7 +619,7 @@ TEST (ledger, receive_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block4)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block4)); auto block5 = builder .receive () .previous (block2->hash ()) @@ -627,7 +627,7 @@ TEST (ledger, receive_fork) .sign (key2.prv, key2.pub) .work (*pool.generate (block2->hash ())) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *block5)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, block5)); } TEST (ledger, open_fork) @@ -650,7 +650,7 @@ TEST (ledger, open_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1->head)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block)); auto block2 = builder .open () .source (block->hash ()) @@ -659,7 +659,7 @@ TEST (ledger, open_fork) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block2)); auto block3 = builder .open () .source (block->hash ()) @@ -668,7 +668,7 @@ TEST (ledger, open_fork) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *block3)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, block3)); } TEST (ledger, representation_changes) @@ -701,7 +701,7 @@ TEST (ledger, representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block1)); ASSERT_EQ (nano::dev::constants.genesis_amount - 100, rep_weights.representation_get (nano::dev::genesis_key.pub)); nano::keypair key3; auto block2 = builder @@ -712,7 +712,7 @@ TEST (ledger, representation) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block2)); ASSERT_EQ (nano::dev::constants.genesis_amount - 100, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (100, rep_weights.representation_get (key3.pub)); @@ -724,7 +724,7 @@ TEST (ledger, representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block3)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (100, rep_weights.representation_get (key3.pub)); @@ -735,7 +735,7 @@ TEST (ledger, representation) .sign (key2.prv, key2.pub) .work (*pool.generate (block2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block4)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block4)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (200, rep_weights.representation_get (key3.pub)); @@ -747,7 +747,7 @@ TEST (ledger, representation) .sign (key2.prv, key2.pub) .work (*pool.generate (block4->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block5)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block5)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); @@ -761,7 +761,7 @@ TEST (ledger, representation) .sign (key2.prv, key2.pub) .work (*pool.generate (block5->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block6)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block6)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); @@ -776,7 +776,7 @@ TEST (ledger, representation) .sign (key5.prv, key5.pub) .work (*pool.generate (key5.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block7)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block7)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); @@ -791,7 +791,7 @@ TEST (ledger, representation) .sign (key2.prv, key2.pub) .work (*pool.generate (block6->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block8)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block8)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); @@ -805,7 +805,7 @@ TEST (ledger, representation) .sign (key5.prv, key5.pub) .work (*pool.generate (block7->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block9)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block9)); ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); @@ -834,7 +834,7 @@ TEST (ledger, double_open) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto open1 = builder .open () .source (send1->hash ()) @@ -843,7 +843,7 @@ TEST (ledger, double_open) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); auto open2 = builder .open () .source (send1->hash ()) @@ -852,7 +852,7 @@ TEST (ledger, double_open) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *open2)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, open2)); } TEST (ledger, double_receive) @@ -872,7 +872,7 @@ TEST (ledger, double_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto open1 = builder .open () .source (send1->hash ()) @@ -881,7 +881,7 @@ TEST (ledger, double_receive) .sign (key2.prv, key2.pub) .work (*pool.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); auto receive1 = builder .receive () .previous (open1->hash ()) @@ -889,7 +889,7 @@ TEST (ledger, double_receive) .sign (key2.prv, key2.pub) .work (*pool.generate (open1->hash ())) .build (); - ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, receive1)); } TEST (votes, check_signature) @@ -911,7 +911,7 @@ TEST (votes, check_signature) node1.work_generate_blocking (*send1); { auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, send1)); } node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); @@ -941,7 +941,7 @@ TEST (votes, add_one) .build (); node1.work_generate_blocking (*send1); auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, send1)); node1.start_election (send1); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); auto election1 = node1.active.election (send1->qualified_root ()); @@ -983,7 +983,7 @@ TEST (votes, add_existing) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .build (); node1.work_generate_blocking (*send1); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), send1)); node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); auto election1 = node1.active.election (send1->qualified_root ()); @@ -1042,7 +1042,7 @@ TEST (votes, add_old) .build (); node1.work_generate_blocking (*send1); auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, send1)); node1.start_election (send1); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); auto election1 = node1.active.election (send1->qualified_root ()); @@ -1100,8 +1100,8 @@ TEST (votes, DISABLED_add_old_different_account) .work (0) .build (); node1.work_generate_blocking (*send2); - ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); - ASSERT_EQ (nano::block_status::progress, node1.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1.process (send1)); + ASSERT_EQ (nano::block_status::progress, node1.process (send2)); ASSERT_TRUE (nano::test::start_elections (system, node1, { send1, send2 })); auto election1 = node1.active.election (send1->qualified_root ()); ASSERT_NE (nullptr, election1); @@ -1147,7 +1147,7 @@ TEST (votes, add_cooldown) .build (); node1.work_generate_blocking (*send1); auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, send1)); node1.start_election (send1); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); auto election1 = node1.active.election (send1->qualified_root ()); @@ -1190,7 +1190,7 @@ TEST (ledger, successor) .build (); node1.work_generate_blocking (*send1); auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, send1)); ASSERT_EQ (*send1, *node1.ledger.successor (transaction, nano::qualified_root (nano::root (0), nano::dev::genesis->hash ()))); ASSERT_EQ (*nano::dev::genesis, *node1.ledger.successor (transaction, nano::dev::genesis->qualified_root ())); ASSERT_EQ (nullptr, node1.ledger.successor (transaction, nano::qualified_root (0))); @@ -1212,9 +1212,9 @@ TEST (ledger, fail_change_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block); + auto result1 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::progress, result1); - auto result2 = ledger.process (transaction, *block); + auto result2 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::old, result2); } @@ -1234,7 +1234,7 @@ TEST (ledger, fail_change_gap_previous) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::root (1))) .build (); - auto result1 = ledger.process (transaction, *block); + auto result1 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::gap_previous, result1); } @@ -1256,7 +1256,7 @@ TEST (ledger, fail_state_bad_signature) .sign (nano::keypair ().prv, 0) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block); + auto result1 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::bad_signature, result1); } @@ -1279,10 +1279,10 @@ TEST (ledger, fail_epoch_bad_signature) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); block->signature.bytes[0] ^= 1; - auto result1 = ledger.process (transaction, *block); + auto result1 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::bad_signature, result1); // Fails epoch signature block->signature.bytes[0] ^= 1; - auto result2 = ledger.process (transaction, *block); + auto result2 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::progress, result2); // Succeeds with epoch signature } @@ -1302,7 +1302,7 @@ TEST (ledger, fail_change_bad_signature) .sign (nano::keypair ().prv, 0) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block); + auto result1 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::bad_signature, result1); } @@ -1322,7 +1322,7 @@ TEST (ledger, fail_change_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block1); + auto result1 = ledger.process (transaction, block1); ASSERT_EQ (nano::block_status::progress, result1); nano::keypair key2; auto block2 = builder @@ -1332,7 +1332,7 @@ TEST (ledger, fail_change_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result2 = ledger.process (transaction, *block2); + auto result2 = ledger.process (transaction, block2); ASSERT_EQ (nano::block_status::fork, result2); } @@ -1353,9 +1353,9 @@ TEST (ledger, fail_send_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block); + auto result1 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::progress, result1); - auto result2 = ledger.process (transaction, *block); + auto result2 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::old, result2); } @@ -1376,7 +1376,7 @@ TEST (ledger, fail_send_gap_previous) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::root (1))) .build (); - auto result1 = ledger.process (transaction, *block); + auto result1 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::gap_previous, result1); } @@ -1397,7 +1397,7 @@ TEST (ledger, fail_send_bad_signature) .sign (nano::keypair ().prv, 0) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block); + auto result1 = ledger.process (transaction, block); ASSERT_EQ (nano::block_status::bad_signature, result1); } @@ -1418,7 +1418,7 @@ TEST (ledger, fail_send_negative_spend) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block1)); nano::keypair key2; auto block2 = builder .send () @@ -1428,7 +1428,7 @@ TEST (ledger, fail_send_negative_spend) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - ASSERT_EQ (nano::block_status::negative_spend, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::negative_spend, ledger.process (transaction, block2)); } TEST (ledger, fail_send_fork) @@ -1448,7 +1448,7 @@ TEST (ledger, fail_send_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block1)); nano::keypair key2; auto block2 = builder .send () @@ -1458,7 +1458,7 @@ TEST (ledger, fail_send_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, block2)); } TEST (ledger, fail_open_old) @@ -1478,7 +1478,7 @@ TEST (ledger, fail_open_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block1)); auto block2 = builder .open () .source (block1->hash ()) @@ -1487,8 +1487,8 @@ TEST (ledger, fail_open_old) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); - ASSERT_EQ (nano::block_status::old, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block2)); + ASSERT_EQ (nano::block_status::old, ledger.process (transaction, block2)); } TEST (ledger, fail_open_gap_source) @@ -1508,7 +1508,7 @@ TEST (ledger, fail_open_gap_source) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result2 = ledger.process (transaction, *block2); + auto result2 = ledger.process (transaction, block2); ASSERT_EQ (nano::block_status::gap_source, result2); } @@ -1529,7 +1529,7 @@ TEST (ledger, fail_open_bad_signature) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block1)); auto block2 = builder .open () .source (block1->hash ()) @@ -1539,7 +1539,7 @@ TEST (ledger, fail_open_bad_signature) .work (*pool.generate (key1.pub)) .build (); block2->signature.clear (); - ASSERT_EQ (nano::block_status::bad_signature, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::bad_signature, ledger.process (transaction, block2)); } TEST (ledger, fail_open_fork_previous) @@ -1559,7 +1559,7 @@ TEST (ledger, fail_open_fork_previous) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block1)); auto block2 = builder .send () .previous (block1->hash ()) @@ -1568,7 +1568,7 @@ TEST (ledger, fail_open_fork_previous) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block2)); auto block3 = builder .open () .source (block1->hash ()) @@ -1577,7 +1577,7 @@ TEST (ledger, fail_open_fork_previous) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block3)); auto block4 = builder .open () .source (block2->hash ()) @@ -1586,7 +1586,7 @@ TEST (ledger, fail_open_fork_previous) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *block4)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, block4)); ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); } @@ -1607,7 +1607,7 @@ TEST (ledger, fail_open_account_mismatch) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block1)); nano::keypair badkey; auto block2 = builder .open () @@ -1617,7 +1617,7 @@ TEST (ledger, fail_open_account_mismatch) .sign (badkey.prv, badkey.pub) .work (*pool.generate (badkey.pub)) .build (); - ASSERT_NE (nano::block_status::progress, ledger.process (transaction, *block2)); + ASSERT_NE (nano::block_status::progress, ledger.process (transaction, block2)); ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); } @@ -1638,7 +1638,7 @@ TEST (ledger, fail_receive_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block1)); auto block2 = builder .send () .previous (block1->hash ()) @@ -1647,7 +1647,7 @@ TEST (ledger, fail_receive_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block2)); auto block3 = builder .open () .source (block1->hash ()) @@ -1656,7 +1656,7 @@ TEST (ledger, fail_receive_old) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block3)); auto block4 = builder .receive () .previous (block3->hash ()) @@ -1664,8 +1664,8 @@ TEST (ledger, fail_receive_old) .sign (key1.prv, key1.pub) .work (*pool.generate (block3->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block4)); - ASSERT_EQ (nano::block_status::old, ledger.process (transaction, *block4)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block4)); + ASSERT_EQ (nano::block_status::old, ledger.process (transaction, block4)); } TEST (ledger, fail_receive_gap_source) @@ -1685,7 +1685,7 @@ TEST (ledger, fail_receive_gap_source) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block1); + auto result1 = ledger.process (transaction, block1); ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .send () @@ -1695,7 +1695,7 @@ TEST (ledger, fail_receive_gap_source) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - auto result2 = ledger.process (transaction, *block2); + auto result2 = ledger.process (transaction, block2); ASSERT_EQ (nano::block_status::progress, result2); auto block3 = builder .open () @@ -1705,7 +1705,7 @@ TEST (ledger, fail_receive_gap_source) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result3 = ledger.process (transaction, *block3); + auto result3 = ledger.process (transaction, block3); ASSERT_EQ (nano::block_status::progress, result3); auto block4 = builder .receive () @@ -1714,7 +1714,7 @@ TEST (ledger, fail_receive_gap_source) .sign (key1.prv, key1.pub) .work (*pool.generate (block3->hash ())) .build (); - auto result4 = ledger.process (transaction, *block4); + auto result4 = ledger.process (transaction, block4); ASSERT_EQ (nano::block_status::gap_source, result4); } @@ -1735,7 +1735,7 @@ TEST (ledger, fail_receive_overreceive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block1); + auto result1 = ledger.process (transaction, block1); ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .open () @@ -1745,7 +1745,7 @@ TEST (ledger, fail_receive_overreceive) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result3 = ledger.process (transaction, *block2); + auto result3 = ledger.process (transaction, block2); ASSERT_EQ (nano::block_status::progress, result3); auto block3 = builder .receive () @@ -1754,7 +1754,7 @@ TEST (ledger, fail_receive_overreceive) .sign (key1.prv, key1.pub) .work (*pool.generate (block2->hash ())) .build (); - auto result4 = ledger.process (transaction, *block3); + auto result4 = ledger.process (transaction, block3); ASSERT_EQ (nano::block_status::unreceivable, result4); } @@ -1775,7 +1775,7 @@ TEST (ledger, fail_receive_bad_signature) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block1); + auto result1 = ledger.process (transaction, block1); ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .send () @@ -1785,7 +1785,7 @@ TEST (ledger, fail_receive_bad_signature) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - auto result2 = ledger.process (transaction, *block2); + auto result2 = ledger.process (transaction, block2); ASSERT_EQ (nano::block_status::progress, result2); auto block3 = builder .open () @@ -1795,7 +1795,7 @@ TEST (ledger, fail_receive_bad_signature) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result3 = ledger.process (transaction, *block3); + auto result3 = ledger.process (transaction, block3); ASSERT_EQ (nano::block_status::progress, result3); auto block4 = builder .receive () @@ -1804,7 +1804,7 @@ TEST (ledger, fail_receive_bad_signature) .sign (nano::keypair ().prv, 0) .work (*pool.generate (block3->hash ())) .build (); - auto result4 = ledger.process (transaction, *block4); + auto result4 = ledger.process (transaction, block4); ASSERT_EQ (nano::block_status::bad_signature, result4); } @@ -1825,7 +1825,7 @@ TEST (ledger, fail_receive_gap_previous_opened) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block1); + auto result1 = ledger.process (transaction, block1); ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .send () @@ -1835,7 +1835,7 @@ TEST (ledger, fail_receive_gap_previous_opened) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - auto result2 = ledger.process (transaction, *block2); + auto result2 = ledger.process (transaction, block2); ASSERT_EQ (nano::block_status::progress, result2); auto block3 = builder .open () @@ -1845,7 +1845,7 @@ TEST (ledger, fail_receive_gap_previous_opened) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result3 = ledger.process (transaction, *block3); + auto result3 = ledger.process (transaction, block3); ASSERT_EQ (nano::block_status::progress, result3); auto block4 = builder .receive () @@ -1854,7 +1854,7 @@ TEST (ledger, fail_receive_gap_previous_opened) .sign (key1.prv, key1.pub) .work (*pool.generate (nano::root (1))) .build (); - auto result4 = ledger.process (transaction, *block4); + auto result4 = ledger.process (transaction, block4); ASSERT_EQ (nano::block_status::gap_previous, result4); } @@ -1875,7 +1875,7 @@ TEST (ledger, fail_receive_gap_previous_unopened) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block1); + auto result1 = ledger.process (transaction, block1); ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .send () @@ -1885,7 +1885,7 @@ TEST (ledger, fail_receive_gap_previous_unopened) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - auto result2 = ledger.process (transaction, *block2); + auto result2 = ledger.process (transaction, block2); ASSERT_EQ (nano::block_status::progress, result2); auto block3 = builder .receive () @@ -1894,7 +1894,7 @@ TEST (ledger, fail_receive_gap_previous_unopened) .sign (key1.prv, key1.pub) .work (*pool.generate (nano::root (1))) .build (); - auto result3 = ledger.process (transaction, *block3); + auto result3 = ledger.process (transaction, block3); ASSERT_EQ (nano::block_status::gap_previous, result3); } @@ -1915,7 +1915,7 @@ TEST (ledger, fail_receive_fork_previous) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block1); + auto result1 = ledger.process (transaction, block1); ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .send () @@ -1925,7 +1925,7 @@ TEST (ledger, fail_receive_fork_previous) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - auto result2 = ledger.process (transaction, *block2); + auto result2 = ledger.process (transaction, block2); ASSERT_EQ (nano::block_status::progress, result2); auto block3 = builder .open () @@ -1935,7 +1935,7 @@ TEST (ledger, fail_receive_fork_previous) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result3 = ledger.process (transaction, *block3); + auto result3 = ledger.process (transaction, block3); ASSERT_EQ (nano::block_status::progress, result3); nano::keypair key2; auto block4 = builder @@ -1946,7 +1946,7 @@ TEST (ledger, fail_receive_fork_previous) .sign (key1.prv, key1.pub) .work (*pool.generate (block3->hash ())) .build (); - auto result4 = ledger.process (transaction, *block4); + auto result4 = ledger.process (transaction, block4); ASSERT_EQ (nano::block_status::progress, result4); auto block5 = builder .receive () @@ -1955,7 +1955,7 @@ TEST (ledger, fail_receive_fork_previous) .sign (key1.prv, key1.pub) .work (*pool.generate (block3->hash ())) .build (); - auto result5 = ledger.process (transaction, *block5); + auto result5 = ledger.process (transaction, block5); ASSERT_EQ (nano::block_status::fork, result5); } @@ -1976,7 +1976,7 @@ TEST (ledger, fail_receive_received_source) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - auto result1 = ledger.process (transaction, *block1); + auto result1 = ledger.process (transaction, block1); ASSERT_EQ (nano::block_status::progress, result1); auto block2 = builder .send () @@ -1986,7 +1986,7 @@ TEST (ledger, fail_receive_received_source) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block1->hash ())) .build (); - auto result2 = ledger.process (transaction, *block2); + auto result2 = ledger.process (transaction, block2); ASSERT_EQ (nano::block_status::progress, result2); auto block6 = builder .send () @@ -1996,7 +1996,7 @@ TEST (ledger, fail_receive_received_source) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block2->hash ())) .build (); - auto result6 = ledger.process (transaction, *block6); + auto result6 = ledger.process (transaction, block6); ASSERT_EQ (nano::block_status::progress, result6); auto block3 = builder .open () @@ -2006,7 +2006,7 @@ TEST (ledger, fail_receive_received_source) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto result3 = ledger.process (transaction, *block3); + auto result3 = ledger.process (transaction, block3); ASSERT_EQ (nano::block_status::progress, result3); nano::keypair key2; auto block4 = builder @@ -2017,7 +2017,7 @@ TEST (ledger, fail_receive_received_source) .sign (key1.prv, key1.pub) .work (*pool.generate (block3->hash ())) .build (); - auto result4 = ledger.process (transaction, *block4); + auto result4 = ledger.process (transaction, block4); ASSERT_EQ (nano::block_status::progress, result4); auto block5 = builder .receive () @@ -2026,7 +2026,7 @@ TEST (ledger, fail_receive_received_source) .sign (key1.prv, key1.pub) .work (*pool.generate (block4->hash ())) .build (); - auto result5 = ledger.process (transaction, *block5); + auto result5 = ledger.process (transaction, block5); ASSERT_EQ (nano::block_status::progress, result5); auto block7 = builder .receive () @@ -2035,7 +2035,7 @@ TEST (ledger, fail_receive_received_source) .sign (key1.prv, key1.pub) .work (*pool.generate (block3->hash ())) .build (); - auto result7 = ledger.process (transaction, *block7); + auto result7 = ledger.process (transaction, block7); ASSERT_EQ (nano::block_status::fork, result7); } @@ -2069,7 +2069,7 @@ TEST (ledger, latest_root) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (hash1)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); ASSERT_EQ (send->hash (), ledger.latest_root (transaction, nano::dev::genesis_key.pub).as_block_hash ()); } @@ -2091,7 +2091,7 @@ TEST (ledger, change_representative_move_representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub)); nano::keypair key2; auto change = builder @@ -2101,7 +2101,7 @@ TEST (ledger, change_representative_move_representation) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change)); nano::keypair key3; auto open = builder .open () @@ -2111,7 +2111,7 @@ TEST (ledger, change_representative_move_representation) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (key3.pub)); } @@ -2134,7 +2134,7 @@ TEST (ledger, send_open_receive_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1->head)) .build (); - auto return1 = ledger.process (transaction, *send1); + auto return1 = ledger.process (transaction, send1); ASSERT_EQ (nano::block_status::progress, return1); auto send2 = builder .send () @@ -2144,7 +2144,7 @@ TEST (ledger, send_open_receive_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - auto return2 = ledger.process (transaction, *send2); + auto return2 = ledger.process (transaction, send2); ASSERT_EQ (nano::block_status::progress, return2); nano::keypair key2; auto open = builder @@ -2155,7 +2155,7 @@ TEST (ledger, send_open_receive_rollback) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - auto return4 = ledger.process (transaction, *open); + auto return4 = ledger.process (transaction, open); ASSERT_EQ (nano::block_status::progress, return4); auto receive = builder .receive () @@ -2164,7 +2164,7 @@ TEST (ledger, send_open_receive_rollback) .sign (key1.prv, key1.pub) .work (*pool.generate (open->hash ())) .build (); - auto return5 = ledger.process (transaction, *receive); + auto return5 = ledger.process (transaction, receive); ASSERT_EQ (nano::block_status::progress, return5); nano::keypair key3; ASSERT_EQ (100, ledger.weight (key2.pub)); @@ -2177,7 +2177,7 @@ TEST (ledger, send_open_receive_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send2->hash ())) .build (); - auto return6 = ledger.process (transaction, *change1); + auto return6 = ledger.process (transaction, change1); ASSERT_EQ (nano::block_status::progress, return6); ASSERT_EQ (100, ledger.weight (key2.pub)); ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub)); @@ -2224,7 +2224,7 @@ TEST (ledger, bootstrap_rep_weight) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1->head)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); } ASSERT_EQ (2, ledger.cache.block_count); { @@ -2245,7 +2245,7 @@ TEST (ledger, bootstrap_rep_weight) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (info1->head)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); } ASSERT_EQ (3, ledger.cache.block_count); ASSERT_EQ (0, ledger.weight (key2.pub)); @@ -2320,12 +2320,12 @@ TEST (ledger, block_destination_source) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (block5->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block1)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block2)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block3)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block4)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block5)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *block6)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block4)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block5)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, block6)); 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 ()); @@ -2359,7 +2359,7 @@ TEST (ledger, state_account) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_EQ (nano::dev::genesis->account (), ledger.account (transaction, send1->hash ())); } @@ -2381,7 +2381,7 @@ TEST (ledger, state_send_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -2404,7 +2404,7 @@ TEST (ledger, state_send_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_TRUE (store.block.exists (transaction, receive1->hash ())); auto receive2 = store.block.get (transaction, receive1->hash ()); ASSERT_NE (nullptr, receive2); @@ -2436,7 +2436,7 @@ TEST (ledger, state_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -2454,7 +2454,7 @@ TEST (ledger, state_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_TRUE (store.block.exists (transaction, receive1->hash ())); auto receive2 = store.block.get (transaction, receive1->hash ()); ASSERT_NE (nullptr, receive2); @@ -2487,7 +2487,7 @@ TEST (ledger, state_rep_change) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change1)); ASSERT_TRUE (store.block.exists (transaction, change1->hash ())); auto change2 = store.block.get (transaction, change1->hash ()); ASSERT_NE (nullptr, change2); @@ -2521,7 +2521,7 @@ TEST (ledger, state_open) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -2540,7 +2540,7 @@ TEST (ledger, state_open) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (destination.pub, send1->hash ()))); ASSERT_TRUE (store.block.exists (transaction, open1->hash ())); auto open2 = store.block.get (transaction, open1->hash ()); @@ -2575,7 +2575,7 @@ TEST (ledger, send_after_state_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto send2 = builder .send () .previous (send1->hash ()) @@ -2584,7 +2584,7 @@ TEST (ledger, send_after_state_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, send2)); } // Make sure old block types can't be inserted after a state block. @@ -2606,7 +2606,7 @@ TEST (ledger, receive_after_state_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto receive1 = builder .receive () .previous (send1->hash ()) @@ -2614,7 +2614,7 @@ TEST (ledger, receive_after_state_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, receive1)); } // Make sure old block types can't be inserted after a state block. @@ -2636,7 +2636,7 @@ TEST (ledger, change_after_state_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); nano::keypair rep; auto change1 = builder .change () @@ -2645,7 +2645,7 @@ TEST (ledger, change_after_state_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *change1)); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, change1)); } TEST (ledger, state_unreceivable_fail) @@ -2664,7 +2664,7 @@ TEST (ledger, state_unreceivable_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -2682,7 +2682,7 @@ TEST (ledger, state_unreceivable_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::gap_source, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::gap_source, ledger.process (transaction, receive1)); } TEST (ledger, state_receive_bad_amount_fail) @@ -2701,7 +2701,7 @@ TEST (ledger, state_receive_bad_amount_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -2719,7 +2719,7 @@ TEST (ledger, state_receive_bad_amount_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::balance_mismatch, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::balance_mismatch, ledger.process (transaction, receive1)); } TEST (ledger, state_no_link_amount_fail) @@ -2740,7 +2740,7 @@ TEST (ledger, state_no_link_amount_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); nano::keypair rep; auto change1 = builder .state () @@ -2752,7 +2752,7 @@ TEST (ledger, state_no_link_amount_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::balance_mismatch, ledger.process (transaction, *change1)); + ASSERT_EQ (nano::block_status::balance_mismatch, ledger.process (transaction, change1)); } TEST (ledger, state_receive_wrong_account_fail) @@ -2773,7 +2773,7 @@ TEST (ledger, state_receive_wrong_account_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -2792,7 +2792,7 @@ TEST (ledger, state_receive_wrong_account_fail) .sign (key.prv, key.pub) .work (*pool.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, receive1)); } TEST (ledger, state_open_state_fork) @@ -2814,7 +2814,7 @@ TEST (ledger, state_open_state_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto open1 = builder .state () .account (destination.pub) @@ -2825,7 +2825,7 @@ TEST (ledger, state_open_state_fork) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); auto open2 = builder .open () .source (send1->hash ()) @@ -2834,7 +2834,7 @@ TEST (ledger, state_open_state_fork) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *open2)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, open2)); ASSERT_EQ (open1->root (), open2->root ()); } @@ -2857,7 +2857,7 @@ TEST (ledger, state_state_open_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto open1 = builder .open () .source (send1->hash ()) @@ -2866,7 +2866,7 @@ TEST (ledger, state_state_open_fork) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); auto open2 = builder .state () .account (destination.pub) @@ -2877,7 +2877,7 @@ TEST (ledger, state_state_open_fork) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *open2)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, open2)); ASSERT_EQ (open1->root (), open2->root ()); ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); } @@ -2901,7 +2901,7 @@ TEST (ledger, state_open_previous_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto open1 = builder .state () .account (destination.pub) @@ -2912,7 +2912,7 @@ TEST (ledger, state_open_previous_fail) .sign (destination.prv, destination.pub) .work (*pool.generate (1)) .build (); - ASSERT_EQ (nano::block_status::gap_previous, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::gap_previous, ledger.process (transaction, open1)); } TEST (ledger, state_open_source_fail) @@ -2934,7 +2934,7 @@ TEST (ledger, state_open_source_fail) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto open1 = builder .state () .account (destination.pub) @@ -2945,7 +2945,7 @@ TEST (ledger, state_open_source_fail) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::gap_source, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::gap_source, ledger.process (transaction, open1)); } TEST (ledger, state_send_change) @@ -2967,7 +2967,7 @@ TEST (ledger, state_send_change) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -3000,7 +3000,7 @@ TEST (ledger, state_receive_change) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -3019,7 +3019,7 @@ TEST (ledger, state_receive_change) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_TRUE (store.block.exists (transaction, receive1->hash ())); auto receive2 = store.block.get (transaction, receive1->hash ()); ASSERT_NE (nullptr, receive2); @@ -3053,7 +3053,7 @@ TEST (ledger, state_open_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto open1 = builder .open () .source (send1->hash ()) @@ -3062,7 +3062,7 @@ TEST (ledger, state_open_old) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, open1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, open1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); @@ -3087,7 +3087,7 @@ TEST (ledger, state_receive_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto send2 = builder .state () .account (nano::dev::genesis->account ()) @@ -3098,7 +3098,7 @@ TEST (ledger, state_receive_old) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); auto open1 = builder .open () .source (send1->hash ()) @@ -3107,7 +3107,7 @@ TEST (ledger, state_receive_old) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); auto receive1 = builder .receive () .previous (open1->hash ()) @@ -3115,7 +3115,7 @@ TEST (ledger, state_receive_old) .sign (destination.prv, destination.pub) .work (*pool.generate (open1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_EQ (2 * nano::Gxrb_ratio, ledger.balance (transaction, receive1->hash ())); ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); @@ -3139,7 +3139,7 @@ TEST (ledger, state_rollback_send) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store.block.exists (transaction, send1->hash ())); auto send2 = store.block.get (transaction, send1->hash ()); ASSERT_NE (nullptr, send2); @@ -3177,7 +3177,7 @@ TEST (ledger, state_rollback_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto receive1 = builder .state () .account (nano::dev::genesis->account ()) @@ -3188,7 +3188,7 @@ TEST (ledger, state_rollback_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_FALSE (store.pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), receive1->hash ()))); ASSERT_FALSE (ledger.rollback (transaction, receive1->hash ())); auto info = ledger.pending_info (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ())); @@ -3220,7 +3220,7 @@ TEST (ledger, state_rollback_received_send) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto receive1 = builder .state () .account (key.pub) @@ -3231,7 +3231,7 @@ TEST (ledger, state_rollback_received_send) .sign (key.prv, key.pub) .work (*pool.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); 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::dev::genesis->account (), send1->hash ()))); @@ -3263,7 +3263,7 @@ TEST (ledger, state_rep_change_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change1)); ASSERT_FALSE (ledger.rollback (transaction, change1->hash ())); ASSERT_FALSE (store.block.exists (transaction, change1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); @@ -3290,7 +3290,7 @@ TEST (ledger, state_open_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto open1 = builder .state () .account (destination.pub) @@ -3301,7 +3301,7 @@ TEST (ledger, state_open_rollback) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); ASSERT_FALSE (ledger.rollback (transaction, open1->hash ())); ASSERT_FALSE (store.block.exists (transaction, open1->hash ())); ASSERT_EQ (0, ledger.account_balance (transaction, destination.pub)); @@ -3332,7 +3332,7 @@ TEST (ledger, state_send_change_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_FALSE (ledger.rollback (transaction, send1->hash ())); ASSERT_FALSE (store.block.exists (transaction, send1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); @@ -3359,7 +3359,7 @@ TEST (ledger, state_receive_change_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); nano::keypair rep; auto receive1 = builder .state () @@ -3371,7 +3371,7 @@ TEST (ledger, state_receive_change_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_FALSE (ledger.rollback (transaction, receive1->hash ())); ASSERT_FALSE (store.block.exists (transaction, receive1->hash ())); ASSERT_EQ (nano::dev::constants.genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); @@ -3399,7 +3399,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); ASSERT_FALSE (epoch1->sideband ().details.is_send); ASSERT_FALSE (epoch1->sideband ().details.is_receive); ASSERT_TRUE (epoch1->sideband ().details.is_epoch); @@ -3415,7 +3415,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *epoch2)); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, epoch2)); auto genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_1); @@ -3423,7 +3423,7 @@ TEST (ledger, epoch_blocks_v1_general) genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_0); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_1); @@ -3439,7 +3439,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *change1)); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, change1)); auto send1 = builder .state () .account (nano::dev::genesis->account ()) @@ -3450,7 +3450,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (send1->sideband ().details.is_send); ASSERT_FALSE (send1->sideband ().details.is_receive); ASSERT_FALSE (send1->sideband ().details.is_epoch); @@ -3464,7 +3464,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, open1)); auto epoch3 = builder .state () .account (destination.pub) @@ -3475,7 +3475,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::representative_mismatch, ledger.process (transaction, *epoch3)); + ASSERT_EQ (nano::block_status::representative_mismatch, ledger.process (transaction, epoch3)); auto epoch4 = builder .state () .account (destination.pub) @@ -3486,7 +3486,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch4)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch4)); ASSERT_FALSE (epoch4->sideband ().details.is_send); ASSERT_FALSE (epoch4->sideband ().details.is_receive); ASSERT_TRUE (epoch4->sideband ().details.is_epoch); @@ -3499,7 +3499,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (destination.prv, destination.pub) .work (*pool.generate (epoch4->hash ())) .build (); - ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, receive1)); auto receive2 = builder .state () .account (destination.pub) @@ -3510,7 +3510,7 @@ TEST (ledger, epoch_blocks_v1_general) .sign (destination.prv, destination.pub) .work (*pool.generate (epoch4->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive2)); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().source_epoch); ASSERT_EQ (0, ledger.balance (transaction, epoch4->hash ())); @@ -3543,7 +3543,7 @@ TEST (ledger, epoch_blocks_v2_general) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); // 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::block_status::block_position, ledger.process (transaction, *epoch1)); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, epoch1)); // Set it to the first epoch and it should now succeed epoch1 = builder .state () @@ -3555,7 +3555,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (epoch1->work) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); 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 auto epoch2 = builder @@ -3568,7 +3568,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch2)); 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 auto epoch3 = builder @@ -3581,7 +3581,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch2->hash ())) .build (); - ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *epoch3)); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, epoch3)); auto genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_2); @@ -3589,7 +3589,7 @@ TEST (ledger, epoch_blocks_v2_general) genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_0); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); genesis_info = ledger.account_info (transaction, nano::dev::genesis->account ()); ASSERT_TRUE (genesis_info); ASSERT_EQ (genesis_info->epoch (), nano::epoch::epoch_1); @@ -3600,7 +3600,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *change1)); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, change1)); auto send1 = builder .state () .account (nano::dev::genesis->account ()) @@ -3611,7 +3611,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); 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 auto open1 = builder @@ -3622,7 +3622,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, open1)); auto epoch4 = builder .state () .account (destination.pub) @@ -3633,7 +3633,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch4)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch4)); 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 auto epoch5 = builder @@ -3646,7 +3646,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch4->hash ())) .build (); - ASSERT_EQ (nano::block_status::representative_mismatch, ledger.process (transaction, *epoch5)); + ASSERT_EQ (nano::block_status::representative_mismatch, ledger.process (transaction, epoch5)); auto epoch6 = builder .state () .account (destination.pub) @@ -3657,7 +3657,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch4->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch6)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch6)); ASSERT_EQ (nano::epoch::epoch_2, epoch6->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch6->sideband ().source_epoch); // Not used for epoch blocks auto receive1 = builder @@ -3667,7 +3667,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (destination.prv, destination.pub) .work (*pool.generate (epoch6->hash ())) .build (); - ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::block_position, ledger.process (transaction, receive1)); auto receive2 = builder .state () .account (destination.pub) @@ -3678,7 +3678,7 @@ TEST (ledger, epoch_blocks_v2_general) .sign (destination.prv, destination.pub) .work (*pool.generate (epoch6->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive2)); ASSERT_EQ (nano::epoch::epoch_2, receive2->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().source_epoch); ASSERT_EQ (0, ledger.balance (transaction, epoch6->hash ())); @@ -3707,7 +3707,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto epoch1 = builder .state () .account (nano::dev::genesis->account ()) @@ -3718,7 +3718,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); auto send2 = builder .state () .account (nano::dev::genesis->account ()) @@ -3729,7 +3729,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); 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 auto open1 = builder @@ -3740,7 +3740,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination.prv, destination.pub) .work (*pool.generate (destination.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); ASSERT_EQ (nano::epoch::epoch_0, open1->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, open1->sideband ().source_epoch); auto receive1 = builder @@ -3750,7 +3750,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination.prv, destination.pub) .work (*pool.generate (open1->hash ())) .build (); - ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, receive1)); auto receive2 = builder .state () .account (destination.pub) @@ -3761,7 +3761,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination.prv, destination.pub) .work (*pool.generate (open1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive2)); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().source_epoch); auto destination_info = ledger.account_info (transaction, destination.pub); @@ -3776,7 +3776,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) ASSERT_EQ (nano::dev::genesis_key.pub, pending_send2->source); ASSERT_EQ (nano::Gxrb_ratio, pending_send2->amount.number ()); ASSERT_EQ (nano::epoch::epoch_1, pending_send2->epoch); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive2)); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_1, receive2->sideband ().source_epoch); destination_info = ledger.account_info (transaction, destination.pub); @@ -3793,7 +3793,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination.prv, destination.pub) .work (*pool.generate (receive2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send3)); auto open2 = builder .open () .source (send3->hash ()) @@ -3802,7 +3802,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination2.prv, destination2.pub) .work (*pool.generate (destination2.pub)) .build (); - ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *open2)); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, open2)); // Upgrade to epoch 2 and send to destination. Try to create an open block from an epoch 2 source block. nano::keypair destination3; auto epoch2 = builder @@ -3815,7 +3815,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch2)); auto send4 = builder .state () .account (nano::dev::genesis->account ()) @@ -3826,7 +3826,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send4)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send4)); auto open3 = builder .open () .source (send4->hash ()) @@ -3835,7 +3835,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination3.prv, destination3.pub) .work (*pool.generate (destination3.pub)) .build (); - ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, *open3)); + ASSERT_EQ (nano::block_status::unreceivable, ledger.process (transaction, open3)); // Send it to an epoch 1 account auto send5 = builder .state () @@ -3847,7 +3847,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send4->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send5)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send5)); destination_info = ledger.account_info (transaction, destination.pub); ASSERT_TRUE (destination_info); ASSERT_EQ (destination_info->epoch (), nano::epoch::epoch_1); @@ -3861,7 +3861,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (destination.prv, destination.pub) .work (*pool.generate (send3->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive3)); ASSERT_EQ (nano::epoch::epoch_2, receive3->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_2, receive3->sideband ().source_epoch); destination_info = ledger.account_info (transaction, destination.pub); @@ -3879,7 +3879,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send5->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send6)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send6)); auto epoch4 = builder .state () .account (destination4.pub) @@ -3890,7 +3890,7 @@ TEST (ledger, epoch_blocks_receive_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (destination4.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch4)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch4)); ASSERT_EQ (nano::epoch::epoch_2, epoch4->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch4->sideband ().source_epoch); // Not used for epoch blocks ASSERT_EQ (store.account.count (transaction), ledger.cache.account_count); @@ -3913,7 +3913,7 @@ TEST (ledger, epoch_blocks_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto epoch1 = builder .state () .account (nano::dev::genesis->account ()) @@ -3924,7 +3924,7 @@ TEST (ledger, epoch_blocks_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *epoch1)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, epoch1)); auto epoch2 = builder .state () .account (nano::dev::genesis->account ()) @@ -3935,7 +3935,7 @@ TEST (ledger, epoch_blocks_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *epoch2)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, epoch2)); auto epoch3 = builder .state () .account (nano::dev::genesis->account ()) @@ -3946,7 +3946,7 @@ TEST (ledger, epoch_blocks_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch3)); 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 auto epoch4 = builder @@ -3959,7 +3959,7 @@ TEST (ledger, epoch_blocks_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, *epoch2)); + ASSERT_EQ (nano::block_status::fork, ledger.process (transaction, epoch2)); } TEST (ledger, successor_epoch) @@ -4017,11 +4017,11 @@ TEST (ledger, successor_epoch) .work (*pool.generate (open->hash ())) .build (); auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *open)); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *change)); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *send2)); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *epoch_open)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, open)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, change)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, send2)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, epoch_open)); ASSERT_EQ (*change, *node1.ledger.successor (transaction, change->qualified_root ())); ASSERT_EQ (*epoch_open, *node1.ledger.successor (transaction, epoch_open->qualified_root ())); ASSERT_EQ (nano::epoch::epoch_1, epoch_open->sideband ().details.epoch); @@ -4044,7 +4044,7 @@ TEST (ledger, epoch_open_pending) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (key1.pub)) .build (); - auto process_result = node1.ledger.process (node1.store.tx_begin_write (), *epoch_open); + auto process_result = node1.ledger.process (node1.store.tx_begin_write (), epoch_open); ASSERT_EQ (nano::block_status::gap_epoch_open_pending, process_result); node1.block_processor.add (epoch_open); // Waits for the block to get saved in the database @@ -4135,10 +4135,10 @@ TEST (ledger, block_hash_account_conflict) node1.work_generate_blocking (*receive1); node1.work_generate_blocking (*send2); node1.work_generate_blocking (*open_epoch1); - ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); - ASSERT_EQ (nano::block_status::progress, node1.process (*receive1)); - ASSERT_EQ (nano::block_status::progress, node1.process (*send2)); - ASSERT_EQ (nano::block_status::progress, node1.process (*open_epoch1)); + ASSERT_EQ (nano::block_status::progress, node1.process (send1)); + ASSERT_EQ (nano::block_status::progress, node1.process (receive1)); + ASSERT_EQ (nano::block_status::progress, node1.process (send2)); + ASSERT_EQ (nano::block_status::progress, node1.process (open_epoch1)); ASSERT_TRUE (nano::test::start_elections (system, node1, { send1, receive1, send2, open_epoch1 })); auto election1 = node1.active.election (send1->qualified_root ()); ASSERT_NE (nullptr, election1); @@ -4212,7 +4212,7 @@ TEST (ledger, could_fit) .build (); ASSERT_FALSE (ledger.could_fit (transaction, *send1)); ASSERT_FALSE (ledger.could_fit (transaction, *send2)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change1)); ASSERT_TRUE (ledger.could_fit (transaction, *change1)); ASSERT_TRUE (ledger.could_fit (transaction, *change2)); ASSERT_TRUE (ledger.could_fit (transaction, *send1)); @@ -4238,12 +4238,12 @@ TEST (ledger, could_fit) .build (); ASSERT_FALSE (ledger.could_fit (transaction, *open1)); ASSERT_FALSE (ledger.could_fit (transaction, *open2)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); ASSERT_TRUE (ledger.could_fit (transaction, *send1)); ASSERT_TRUE (ledger.could_fit (transaction, *send2)); ASSERT_TRUE (ledger.could_fit (transaction, *open1)); ASSERT_TRUE (ledger.could_fit (transaction, *open2)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); ASSERT_TRUE (ledger.could_fit (transaction, *open1)); ASSERT_TRUE (ledger.could_fit (transaction, *open2)); // Create another send to receive @@ -4277,7 +4277,7 @@ TEST (ledger, could_fit) .build (); ASSERT_FALSE (ledger.could_fit (transaction, *receive1)); ASSERT_FALSE (ledger.could_fit (transaction, *receive2)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send3)); ASSERT_TRUE (ledger.could_fit (transaction, *receive1)); ASSERT_TRUE (ledger.could_fit (transaction, *receive2)); // Test epoch (state) @@ -4292,11 +4292,11 @@ TEST (ledger, could_fit) .work (*pool.generate (receive1->hash ())) .build (); ASSERT_FALSE (ledger.could_fit (transaction, *epoch1)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_TRUE (ledger.could_fit (transaction, *receive1)); ASSERT_TRUE (ledger.could_fit (transaction, *receive2)); ASSERT_TRUE (ledger.could_fit (transaction, *epoch1)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); ASSERT_TRUE (ledger.could_fit (transaction, *epoch1)); } @@ -4588,7 +4588,7 @@ TEST (ledger, confirmation_height_not_updated) ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (1, confirmation_height_info.height); ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (1, confirmation_height_info.height); ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier); @@ -4600,7 +4600,7 @@ TEST (ledger, confirmation_height_not_updated) .sign (key.prv, key.pub) .work (*pool.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); ASSERT_TRUE (store.confirmation_height.get (transaction, key.pub, confirmation_height_info)); ASSERT_EQ (0, confirmation_height_info.height); ASSERT_EQ (nano::block_hash (0), confirmation_height_info.frontier); @@ -4621,7 +4621,7 @@ TEST (ledger, zero_rep) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *block1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, block1)); ASSERT_EQ (0, node1.ledger.cache.rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (nano::dev::constants.genesis_amount, node1.ledger.cache.rep_weights.representation_get (0)); auto block2 = builder.state () @@ -4633,7 +4633,7 @@ TEST (ledger, zero_rep) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (block1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *block2)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, block2)); ASSERT_EQ (nano::dev::constants.genesis_amount, node1.ledger.cache.rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, node1.ledger.cache.rep_weights.representation_get (0)); } @@ -4649,74 +4649,74 @@ TEST (ledger, work_validation) nano::keypair key; // With random work the block doesn't pass, then modifies the block with sufficient work and ensures a correct result - auto process_block = [&store, &ledger, &pool] (nano::block & block_a, nano::block_details const details_a) { - auto threshold = nano::dev::network_params.work.threshold (block_a.work_version (), details_a); + auto process_block = [&store, &ledger, &pool] (std::shared_ptr block_a, nano::block_details const details_a) { + auto threshold = nano::dev::network_params.work.threshold (block_a->work_version (), details_a); // Rarely failed with random work, so modify until it doesn't have enough difficulty - while (nano::dev::network_params.work.difficulty (block_a) >= threshold) + while (nano::dev::network_params.work.difficulty (*block_a) >= threshold) { - block_a.block_work_set (block_a.block_work () + 1); + block_a->block_work_set (block_a->block_work () + 1); } EXPECT_EQ (nano::block_status::insufficient_work, ledger.process (store.tx_begin_write (), block_a)); - block_a.block_work_set (*pool.generate (block_a.root (), threshold)); + block_a->block_work_set (*pool.generate (block_a->root (), threshold)); EXPECT_EQ (nano::block_status::progress, ledger.process (store.tx_begin_write (), block_a)); }; std::error_code ec; - auto send = *builder.send () - .previous (nano::dev::genesis->hash ()) - .destination (gen.pub) - .balance (nano::dev::constants.genesis_amount - 1) - .sign (gen.prv, gen.pub) - .work (0) - .build (ec); + auto send = builder.send () + .previous (nano::dev::genesis->hash ()) + .destination (gen.pub) + .balance (nano::dev::constants.genesis_amount - 1) + .sign (gen.prv, gen.pub) + .work (0) + .build (ec); ASSERT_FALSE (ec); - auto receive = *builder.receive () - .previous (send.hash ()) - .source (send.hash ()) - .sign (gen.prv, gen.pub) - .work (0) - .build (ec); - ASSERT_FALSE (ec); - - auto change = *builder.change () - .previous (receive.hash ()) - .representative (key.pub) + auto receive = builder.receive () + .previous (send->hash ()) + .source (send->hash ()) .sign (gen.prv, gen.pub) .work (0) .build (ec); ASSERT_FALSE (ec); - auto state = *builder.state () - .account (gen.pub) - .previous (change.hash ()) - .representative (gen.pub) - .balance (nano::dev::constants.genesis_amount - 1) - .link (key.pub) + auto change = builder.change () + .previous (receive->hash ()) + .representative (key.pub) .sign (gen.prv, gen.pub) .work (0) .build (ec); ASSERT_FALSE (ec); - auto open = *builder.open () - .account (key.pub) - .source (state.hash ()) - .representative (key.pub) - .sign (key.prv, key.pub) + auto state = builder.state () + .account (gen.pub) + .previous (change->hash ()) + .representative (gen.pub) + .balance (nano::dev::constants.genesis_amount - 1) + .link (key.pub) + .sign (gen.prv, gen.pub) .work (0) .build (ec); ASSERT_FALSE (ec); - auto epoch = *builder.state () - .account (key.pub) - .previous (open.hash ()) - .balance (1) - .representative (key.pub) - .link (ledger.epoch_link (nano::epoch::epoch_1)) - .sign (gen.prv, gen.pub) - .work (0) - .build (ec); + auto open = builder.open () + .account (key.pub) + .source (state->hash ()) + .representative (key.pub) + .sign (key.prv, key.pub) + .work (0) + .build (ec); + ASSERT_FALSE (ec); + + auto epoch = builder.state () + .account (key.pub) + .previous (open->hash ()) + .balance (1) + .representative (key.pub) + .link (ledger.epoch_link (nano::epoch::epoch_1)) + .sign (gen.prv, gen.pub) + .work (0) + .build (ec); ASSERT_FALSE (ec); process_block (send, {}); @@ -4746,7 +4746,7 @@ TEST (ledger, dependents_confirmed) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (ledger.dependents_confirmed (transaction, *send1)); auto send2 = builder.state () .account (nano::dev::genesis->account ()) @@ -4757,7 +4757,7 @@ TEST (ledger, dependents_confirmed) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *send2)); auto receive1 = builder.state () .account (key1.pub) @@ -4768,7 +4768,7 @@ TEST (ledger, dependents_confirmed) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive1)); nano::confirmation_height_info height; ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); @@ -4784,7 +4784,7 @@ TEST (ledger, dependents_confirmed) .sign (key1.prv, key1.pub) .work (*pool.generate (receive1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive2)); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive2)); ASSERT_TRUE (ledger.store.confirmation_height.get (transaction, key1.pub, height)); height.height += 1; @@ -4818,7 +4818,7 @@ TEST (ledger, dependents_confirmed_pruning) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto send2 = builder.state () .account (nano::dev::genesis->account ()) .previous (send1->hash ()) @@ -4828,7 +4828,7 @@ TEST (ledger, dependents_confirmed_pruning) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); nano::confirmation_height_info height; ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); height.height = 3; @@ -4868,7 +4868,7 @@ TEST (ledger, block_confirmed) .build (); // Must be safe against non-existing blocks ASSERT_FALSE (ledger.block_confirmed (transaction, send1->hash ())); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_FALSE (ledger.block_confirmed (transaction, send1->hash ())); nano::confirmation_height_info height; ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); @@ -4927,7 +4927,7 @@ TEST (ledger, cache) .build (); { auto transaction (store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); } ++block_count; @@ -4937,7 +4937,7 @@ TEST (ledger, cache) { auto transaction (store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); } ++block_count; @@ -5008,7 +5008,7 @@ TEST (ledger, pruning_action) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); auto send1_stored (store->block.get (transaction, send1->hash ())); ASSERT_NE (nullptr, send1_stored); @@ -5024,7 +5024,7 @@ TEST (ledger, pruning_action) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); ASSERT_TRUE (store->block.exists (transaction, send2->hash ())); // Pruning action ASSERT_EQ (1, ledger.pruning_action (transaction, send1->hash (), 1)); @@ -5050,7 +5050,7 @@ TEST (ledger, pruning_action) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); ASSERT_TRUE (store->block.exists (transaction, receive1->hash ())); auto receive1_stored (store->block.get (transaction, receive1->hash ())); ASSERT_NE (nullptr, receive1_stored); @@ -5096,7 +5096,7 @@ TEST (ledger, pruning_large_chain) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (last_hash)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); ASSERT_TRUE (store->block.exists (transaction, send->hash ())); auto receive = builder .state () @@ -5108,7 +5108,7 @@ TEST (ledger, pruning_large_chain) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive)); ASSERT_TRUE (store->block.exists (transaction, receive->hash ())); last_hash = receive->hash (); } @@ -5147,7 +5147,7 @@ TEST (ledger, pruning_source_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch1)); auto send1 = builder .state () .account (nano::dev::genesis->account ()) @@ -5158,7 +5158,7 @@ TEST (ledger, pruning_source_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (epoch1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); auto send2 = builder .state () @@ -5170,7 +5170,7 @@ TEST (ledger, pruning_source_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); ASSERT_TRUE (store->block.exists (transaction, send2->hash ())); // Pruning action ASSERT_EQ (2, ledger.pruning_action (transaction, send1->hash (), 1)); @@ -5195,7 +5195,7 @@ TEST (ledger, pruning_source_rollback) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); 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); @@ -5207,7 +5207,7 @@ TEST (ledger, pruning_source_rollback) ASSERT_EQ (nano::Gxrb_ratio, info2->amount.number ()); ASSERT_EQ (nano::epoch::epoch_1, info2->epoch); // Process receive block again - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); 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); @@ -5233,7 +5233,7 @@ TEST (ledger, pruning_source_rollback_legacy) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); nano::keypair key1; auto send2 = builder @@ -5244,7 +5244,7 @@ TEST (ledger, pruning_source_rollback_legacy) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); ASSERT_TRUE (store->block.exists (transaction, send2->hash ())); ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (key1.pub, send2->hash ()))); auto send3 = builder @@ -5255,7 +5255,7 @@ TEST (ledger, pruning_source_rollback_legacy) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send3)); ASSERT_TRUE (store->block.exists (transaction, send3->hash ())); ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send3->hash ()))); // Pruning action @@ -5283,7 +5283,7 @@ TEST (ledger, pruning_source_rollback_legacy) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send3->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); 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); @@ -5295,7 +5295,7 @@ TEST (ledger, pruning_source_rollback_legacy) ASSERT_EQ (nano::Gxrb_ratio, info3->amount.number ()); ASSERT_EQ (nano::epoch::epoch_0, info3->epoch); // Process receive block again - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); 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); @@ -5308,7 +5308,7 @@ TEST (ledger, pruning_source_rollback_legacy) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (key1.pub, send2->hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (6, ledger.cache.block_count); @@ -5320,7 +5320,7 @@ TEST (ledger, pruning_source_rollback_legacy) ASSERT_EQ (nano::Gxrb_ratio, info4->amount.number ()); ASSERT_EQ (nano::epoch::epoch_0, info4->epoch); // Process open block again - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (key1.pub, send2->hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (6, ledger.cache.block_count); @@ -5348,7 +5348,7 @@ TEST (ledger, pruning_process_error) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_EQ (0, ledger.cache.pruned_count); ASSERT_EQ (2, ledger.cache.block_count); // Pruning action for latest block (not valid action) @@ -5356,7 +5356,7 @@ TEST (ledger, pruning_process_error) ASSERT_FALSE (store->block.exists (transaction, send1->hash ())); ASSERT_TRUE (store->pruned.exists (transaction, send1->hash ())); // Attempt to process pruned block again - ASSERT_EQ (nano::block_status::old, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::old, ledger.process (transaction, send1)); // Attept to process new block after pruned auto send2 = builder .state () @@ -5368,7 +5368,7 @@ TEST (ledger, pruning_process_error) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::gap_previous, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::gap_previous, ledger.process (transaction, send2)); ASSERT_EQ (1, ledger.cache.pruned_count); ASSERT_EQ (2, ledger.cache.block_count); } @@ -5394,7 +5394,7 @@ TEST (ledger, pruning_legacy_blocks) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1->hash ()))); auto receive1 = builder .receive () @@ -5403,7 +5403,7 @@ TEST (ledger, pruning_legacy_blocks) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive1)); auto change1 = builder .change () .previous (receive1->hash ()) @@ -5411,7 +5411,7 @@ TEST (ledger, pruning_legacy_blocks) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (receive1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change1)); auto send2 = builder .send () .previous (change1->hash ()) @@ -5420,7 +5420,7 @@ TEST (ledger, pruning_legacy_blocks) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (change1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); auto open1 = builder .open () .source (send2->hash ()) @@ -5429,7 +5429,7 @@ TEST (ledger, pruning_legacy_blocks) .sign (key1.prv, key1.pub) .work (*pool.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1)); auto send3 = builder .send () .previous (open1->hash ()) @@ -5438,7 +5438,7 @@ TEST (ledger, pruning_legacy_blocks) .sign (key1.prv, key1.pub) .work (*pool.generate (open1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send3)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send3)); // Pruning action ASSERT_EQ (3, ledger.pruning_action (transaction, change1->hash (), 2)); ASSERT_EQ (1, ledger.pruning_action (transaction, open1->hash (), 1)); @@ -5481,7 +5481,7 @@ TEST (ledger, pruning_safe_functions) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); auto send2 = builder .state () @@ -5493,7 +5493,7 @@ TEST (ledger, pruning_safe_functions) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); ASSERT_TRUE (store->block.exists (transaction, send2->hash ())); // Pruning action ASSERT_EQ (1, ledger.pruning_action (transaction, send1->hash (), 1)); @@ -5542,7 +5542,7 @@ TEST (ledger, hash_root_random) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); ASSERT_TRUE (store->block.exists (transaction, send1->hash ())); auto send2 = builder .state () @@ -5554,7 +5554,7 @@ TEST (ledger, hash_root_random) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); ASSERT_TRUE (store->block.exists (transaction, send2->hash ())); // Pruning action ASSERT_EQ (1, ledger.pruning_action (transaction, send1->hash (), 1)); @@ -5680,7 +5680,7 @@ TEST (ledger, unconfirmed_frontiers) .work (*pool.generate (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (store.tx_begin_write (), *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (store.tx_begin_write (), send)); unconfirmed_frontiers = ledger.unconfirmed_frontiers (); ASSERT_EQ (unconfirmed_frontiers.size (), 1); diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index e3253fa3..e6a514b9 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -366,7 +366,7 @@ TEST (receivable_processor, confirm_insufficient_pos) .work (0) .build (); node1.work_generate_blocking (*block1); - ASSERT_EQ (nano::block_status::progress, node1.process (*block1)); + ASSERT_EQ (nano::block_status::progress, node1.process (block1)); node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); nano::keypair key1; auto vote = nano::test::make_vote (key1, { block1 }, 0, 0); @@ -389,7 +389,7 @@ TEST (receivable_processor, confirm_sufficient_pos) .work (0) .build (); node1.work_generate_blocking (*block1); - ASSERT_EQ (nano::block_status::progress, node1.process (*block1)); + ASSERT_EQ (nano::block_status::progress, node1.process (block1)); node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); auto vote = nano::test::make_vote (nano::dev::genesis_key, { block1 }, 0, 0); nano::confirm_ack con1{ nano::dev::network_params.network, vote }; diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 80999549..6da8ffee 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -771,10 +771,10 @@ TEST (node, fork_multi_flip) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), send1)); // Node2 has two blocks that will be rolled back by node1's vote - ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), *send2)); - ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), *send3)); + ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), send2)); + ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), send3)); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); // Insert voting key in to node1 auto election = nano::test::start_election (system, node2, send2->hash ()); @@ -821,8 +821,8 @@ TEST (node, fork_bootstrap_flip) .work (*system0.work.generate (latest)) .build (); // Insert but don't rebroadcast, simulating settled blocks - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1)); - ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), *send2)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), send1)); + ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), send2)); ASSERT_TRUE (node2.store.block.exists (node2.store.tx_begin_read (), send2->hash ())); node2.bootstrap_initiator.bootstrap (node1.network.endpoint ()); // Additionally add new peer to confirm & replace bootstrap block auto again (true); @@ -1033,9 +1033,9 @@ TEST (node, fork_no_vote_quorum) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (block->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); - ASSERT_EQ (nano::block_status::progress, node2.process (*send1)); - ASSERT_EQ (nano::block_status::progress, node3.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1.process (send1)); + ASSERT_EQ (nano::block_status::progress, node2.process (send1)); + ASSERT_EQ (nano::block_status::progress, node3.process (send1)); auto key2 (system.wallet (2)->deterministic_insert ()); auto send2 = nano::send_block_builder () .previous (block->hash ()) @@ -1181,9 +1181,9 @@ TEST (node, DISABLED_fork_stale) node1.work_generate_blocking (*send2); { auto transaction1 (node1.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction1, *send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction1, send1)); auto transaction2 (node2.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node2.ledger.process (transaction2, *send2)); + ASSERT_EQ (nano::block_status::progress, node2.ledger.process (transaction2, send2)); } node1.process_active (send1); node1.process_active (send2); @@ -1220,48 +1220,48 @@ TEST (node, DISABLED_broadcast_elected) auto transaction0 (node0->store.tx_begin_write ()); auto transaction1 (node1->store.tx_begin_write ()); auto transaction2 (node2->store.tx_begin_write ()); - auto fund_big = *builder.send () - .previous (nano::dev::genesis->hash ()) - .destination (rep_big.pub) - .balance (nano::Gxrb_ratio * 5) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (nano::dev::genesis->hash ())) - .build (); - auto open_big = *builder.open () - .source (fund_big.hash ()) - .representative (rep_big.pub) - .account (rep_big.pub) - .sign (rep_big.prv, rep_big.pub) - .work (*system.work.generate (rep_big.pub)) - .build (); - auto fund_small = *builder.send () - .previous (fund_big.hash ()) - .destination (rep_small.pub) - .balance (nano::Gxrb_ratio * 2) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (fund_big.hash ())) - .build (); - auto open_small = *builder.open () - .source (fund_small.hash ()) - .representative (rep_small.pub) - .account (rep_small.pub) - .sign (rep_small.prv, rep_small.pub) - .work (*system.work.generate (rep_small.pub)) - .build (); - auto fund_other = *builder.send () - .previous (fund_small.hash ()) - .destination (rep_other.pub) - .balance (nano::Gxrb_ratio) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (fund_small.hash ())) - .build (); - auto open_other = *builder.open () - .source (fund_other.hash ()) - .representative (rep_other.pub) - .account (rep_other.pub) - .sign (rep_other.prv, rep_other.pub) - .work (*system.work.generate (rep_other.pub)) - .build (); + auto fund_big = builder.send () + .previous (nano::dev::genesis->hash ()) + .destination (rep_big.pub) + .balance (nano::Gxrb_ratio * 5) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) + .build (); + auto open_big = builder.open () + .source (fund_big->hash ()) + .representative (rep_big.pub) + .account (rep_big.pub) + .sign (rep_big.prv, rep_big.pub) + .work (*system.work.generate (rep_big.pub)) + .build (); + auto fund_small = builder.send () + .previous (fund_big->hash ()) + .destination (rep_small.pub) + .balance (nano::Gxrb_ratio * 2) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (fund_big->hash ())) + .build (); + auto open_small = builder.open () + .source (fund_small->hash ()) + .representative (rep_small.pub) + .account (rep_small.pub) + .sign (rep_small.prv, rep_small.pub) + .work (*system.work.generate (rep_small.pub)) + .build (); + auto fund_other = builder.send () + .previous (fund_small->hash ()) + .destination (rep_other.pub) + .balance (nano::Gxrb_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (fund_small->hash ())) + .build (); + auto open_other = builder.open () + .source (fund_other->hash ()) + .representative (rep_other.pub) + .account (rep_other.pub) + .sign (rep_other.prv, rep_other.pub) + .work (*system.work.generate (rep_other.pub)) + .build (); ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction0, fund_big)); ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction1, fund_big)); ASSERT_EQ (nano::block_status::progress, node2->ledger.process (transaction2, fund_big)); @@ -1337,39 +1337,39 @@ TEST (node, rep_self_vote) auto node0 = system.add_node (node_config); nano::keypair rep_big; nano::block_builder builder; - auto fund_big = *builder.send () - .previous (nano::dev::genesis->hash ()) - .destination (rep_big.pub) - .balance (nano::uint128_t{ "0xb0000000000000000000000000000000" }) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (nano::dev::genesis->hash ())) - .build (); - auto open_big = *builder.open () - .source (fund_big.hash ()) - .representative (rep_big.pub) - .account (rep_big.pub) - .sign (rep_big.prv, rep_big.pub) - .work (*system.work.generate (rep_big.pub)) - .build (); + auto fund_big = builder.send () + .previous (nano::dev::genesis->hash ()) + .destination (rep_big.pub) + .balance (nano::uint128_t{ "0xb0000000000000000000000000000000" }) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) + .build (); + auto open_big = builder.open () + .source (fund_big->hash ()) + .representative (rep_big.pub) + .account (rep_big.pub) + .sign (rep_big.prv, rep_big.pub) + .work (*system.work.generate (rep_big.pub)) + .build (); ASSERT_EQ (nano::block_status::progress, node0->process (fund_big)); ASSERT_EQ (nano::block_status::progress, node0->process (open_big)); // Confirm both blocks, allowing voting on the upcoming block - node0->start_election (node0->block (open_big.hash ())); + node0->start_election (node0->block (open_big->hash ())); std::shared_ptr election; - ASSERT_TIMELY (5s, election = node0->active.election (open_big.qualified_root ())); + ASSERT_TIMELY (5s, election = node0->active.election (open_big->qualified_root ())); election->force_confirm (); system.wallet (0)->insert_adhoc (rep_big.prv); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_EQ (system.wallet (0)->wallets.reps ().voting, 2); auto block0 = builder.send () - .previous (fund_big.hash ()) + .previous (fund_big->hash ()) .destination (rep_big.pub) .balance (nano::uint128_t ("0x60000000000000000000000000000000")) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (fund_big.hash ())) + .work (*system.work.generate (fund_big->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node0->process (*block0)); + ASSERT_EQ (nano::block_status::progress, node0->process (block0)); auto & active = node0->active; auto & scheduler = node0->scheduler; scheduler.priority.activate (nano::dev::genesis_key.pub, node0->store.tx_begin_read ()); @@ -1403,7 +1403,7 @@ TEST (node, DISABLED_bootstrap_no_publish) .build (); { auto transaction (node0->store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *send0)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, send0)); } ASSERT_FALSE (node1->bootstrap_initiator.in_progress ()); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); @@ -1444,7 +1444,7 @@ TEST (node, DISABLED_bootstrap_bulk_push) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node0->process (*send0)); + ASSERT_EQ (nano::block_status::progress, node0->process (send0)); ASSERT_FALSE (node0->bootstrap_initiator.in_progress ()); ASSERT_FALSE (node1->bootstrap_initiator.in_progress ()); @@ -1475,27 +1475,27 @@ TEST (node, bootstrap_fork_open) auto node1 = system.add_node (node_config); nano::keypair key0; nano::block_builder builder; - auto send0 = *builder.send () - .previous (nano::dev::genesis->hash ()) - .destination (key0.pub) - .balance (nano::dev::constants.genesis_amount - 500) - .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*system.work.generate (nano::dev::genesis->hash ())) - .build (); - auto open0 = *builder.open () - .source (send0.hash ()) - .representative (1) - .account (key0.pub) - .sign (key0.prv, key0.pub) - .work (*system.work.generate (key0.pub)) - .build (); - auto open1 = *builder.open () - .source (send0.hash ()) - .representative (2) - .account (key0.pub) - .sign (key0.prv, key0.pub) - .work (*system.work.generate (key0.pub)) - .build (); + auto send0 = builder.send () + .previous (nano::dev::genesis->hash ()) + .destination (key0.pub) + .balance (nano::dev::constants.genesis_amount - 500) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) + .build (); + auto open0 = builder.open () + .source (send0->hash ()) + .representative (1) + .account (key0.pub) + .sign (key0.prv, key0.pub) + .work (*system.work.generate (key0.pub)) + .build (); + auto open1 = builder.open () + .source (send0->hash ()) + .representative (2) + .account (key0.pub) + .sign (key0.prv, key0.pub) + .work (*system.work.generate (key0.pub)) + .build (); // Both know about send0 ASSERT_EQ (nano::block_status::progress, node0->process (send0)); ASSERT_EQ (nano::block_status::progress, node1->process (send0)); @@ -1503,22 +1503,22 @@ TEST (node, bootstrap_fork_open) for (auto node : system.nodes) { node->start_election (node->block (node->latest (nano::dev::genesis_key.pub))); - ASSERT_TIMELY (1s, node->active.election (send0.qualified_root ())); - auto election = node->active.election (send0.qualified_root ()); + ASSERT_TIMELY (1s, node->active.election (send0->qualified_root ())); + auto election = node->active.election (send0->qualified_root ()); ASSERT_NE (nullptr, election); election->force_confirm (); ASSERT_TIMELY (2s, node->active.empty ()); } - ASSERT_TIMELY (3s, node0->block_confirmed (send0.hash ())); + ASSERT_TIMELY (3s, node0->block_confirmed (send0->hash ())); // They disagree about open0/open1 ASSERT_EQ (nano::block_status::progress, node0->process (open0)); ASSERT_EQ (nano::block_status::progress, node1->process (open1)); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); - ASSERT_FALSE (node1->ledger.block_or_pruned_exists (open0.hash ())); + ASSERT_FALSE (node1->ledger.block_or_pruned_exists (open0->hash ())); ASSERT_FALSE (node1->bootstrap_initiator.in_progress ()); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); ASSERT_TIMELY (1s, node1->active.empty ()); - ASSERT_TIMELY (10s, !node1->ledger.block_or_pruned_exists (open1.hash ()) && node1->ledger.block_or_pruned_exists (open0.hash ())); + ASSERT_TIMELY (10s, !node1->ledger.block_or_pruned_exists (open1->hash ()) && node1->ledger.block_or_pruned_exists (open0->hash ())); } // Unconfirmed blocks from bootstrap should be confirmed @@ -1540,7 +1540,7 @@ TEST (node, bootstrap_confirm_frontiers) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node0->process (*send0)); + ASSERT_EQ (nano::block_status::progress, node0->process (send0)); // each system only has one node, so there should be no bootstrapping going on ASSERT_FALSE (node0->bootstrap_initiator.in_progress ()); @@ -1598,7 +1598,7 @@ TEST (node, unconfirmed_send) .sign (key2.prv, key2.pub) .work (*system.work.generate (recv1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node2.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node2.process (send2)); auto send3 = wallet2->send_action (key2.pub, nano::dev::genesis->account (), nano::Mxrb_ratio); ASSERT_TIMELY (5s, node2.block_confirmed (send2->hash ())); @@ -1698,10 +1698,10 @@ TEST (node, rep_weight) .build (); { auto transaction = node.store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *block1)); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *block2)); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *block3)); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *block4)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block2)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block3)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block4)); } ASSERT_TRUE (node.rep_crawler.representatives (1).empty ()); std::shared_ptr channel1 = nano::test::establish_tcp (system, node, node1.network.endpoint ()); @@ -1788,10 +1788,10 @@ TEST (node, rep_remove) .build (); { auto transaction = searching_node.store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, *send_to_rep1)); - ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, *receive_rep1)); - ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, *send_to_rep2)); - ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, *receive_rep2)); + ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, send_to_rep1)); + ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, receive_rep1)); + ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, send_to_rep2)); + ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, receive_rep2)); } // Create channel for Rep1 @@ -2127,7 +2127,7 @@ TEST (node, confirm_quorum) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1.process (send1)); system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, new_balance.number ()); ASSERT_TIMELY (2s, node1.active.election (send1->qualified_root ())); auto election = node1.active.election (send1->qualified_root ()); @@ -2174,8 +2174,8 @@ TEST (node, local_votes_cache) .build (); { auto transaction (node.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, send2)); } // Confirm blocks to allow voting node.start_election (send2); @@ -2205,7 +2205,7 @@ TEST (node, local_votes_cache) // Max cache { auto transaction (node.store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *send3)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, send3)); } nano::confirm_req message3{ nano::dev::network_params.network, send3->hash (), send3->root () }; for (auto i (0); i < 100; ++i) @@ -2243,7 +2243,7 @@ TEST (node, DISABLED_local_votes_cache_batch) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1)); node.confirmation_height_processor.add (send1); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ())); auto send2 = nano::state_block_builder () @@ -2255,7 +2255,7 @@ TEST (node, DISABLED_local_votes_cache_batch) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send2)); auto receive1 = nano::state_block_builder () .account (key1.pub) .previous (0) @@ -2265,7 +2265,7 @@ TEST (node, DISABLED_local_votes_cache_batch) .sign (key1.prv, key1.pub) .work (*node.work_generate_blocking (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *receive1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), receive1)); std::vector> batch{ { send2->hash (), send2->root () }, { receive1->hash (), receive1->root () } }; nano::confirm_req message{ nano::dev::network_params.network, batch }; auto channel = std::make_shared (node); @@ -2328,7 +2328,7 @@ TEST (node, local_votes_cache_generate_new_vote) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node.process (send1)); // One of the hashes is cached std::vector> roots_hashes{ std::make_pair (nano::dev::genesis->hash (), nano::dev::genesis->root ()), std::make_pair (send1->hash (), send1->root ()) }; nano::confirm_req message2{ nano::dev::network_params.network, roots_hashes }; @@ -2376,7 +2376,7 @@ TEST (node, local_votes_cache_fork) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1.process (send1)); // Cache vote auto vote = nano::test::make_vote (nano::dev::genesis_key, { send1 }, 0, 0); node1.vote_processor.vote (vote, std::make_shared (node1)); @@ -2468,7 +2468,7 @@ TEST (node, vote_by_hash_bundle) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); blocks.push_back (block); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *blocks.back ())); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), blocks.back ())); for (auto i = 2; i < 200; ++i) { auto block = builder.make_block () @@ -2479,7 +2479,7 @@ TEST (node, vote_by_hash_bundle) .work (*system.work.generate (blocks.back ()->hash ())) .build (); blocks.push_back (block); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *blocks.back ())); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), blocks.back ())); } // Confirming last block will confirm whole chain and allow us to generate votes for those blocks later @@ -3443,8 +3443,8 @@ TEST (node, rollback_gap_source) .sign (key.prv, key.pub) .build (); // Set 'node' up with losing block 'fork1a' - ASSERT_EQ (nano::block_status::progress, node.process (*send1)); - ASSERT_EQ (nano::block_status::progress, node.process (*fork1a)); + ASSERT_EQ (nano::block_status::progress, node.process (send1)); + ASSERT_EQ (nano::block_status::progress, node.process (fork1a)); // Node has 'fork1a' & doesn't have source 'send2' for winning 'fork1b' block ASSERT_EQ (nullptr, node.block (send2->hash ())); node.block_processor.force (fork1b); @@ -3457,7 +3457,7 @@ TEST (node, rollback_gap_source) node.process_active (fork1a); ASSERT_TIMELY (5s, node.block (fork1a->hash ()) != nullptr); // With send2 block in ledger election can start again to remove fork block - ASSERT_EQ (nano::block_status::progress, node.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node.process (send2)); node.block_processor.force (fork1b); // Wait for new rollback ASSERT_TIMELY_EQ (5s, node.stats.count (nano::stat::type::rollback, nano::stat::detail::open), 2); @@ -3601,19 +3601,19 @@ TEST (node, dependency_graph) .work (*system.work.generate (key3_receive->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*gen_send1)); - ASSERT_EQ (nano::block_status::progress, node.process (*key1_open)); - ASSERT_EQ (nano::block_status::progress, node.process (*key1_send1)); - ASSERT_EQ (nano::block_status::progress, node.process (*gen_receive)); - ASSERT_EQ (nano::block_status::progress, node.process (*gen_send2)); - ASSERT_EQ (nano::block_status::progress, node.process (*key2_open)); - ASSERT_EQ (nano::block_status::progress, node.process (*key2_send1)); - ASSERT_EQ (nano::block_status::progress, node.process (*key3_open)); - ASSERT_EQ (nano::block_status::progress, node.process (*key2_send2)); - ASSERT_EQ (nano::block_status::progress, node.process (*key1_receive)); - ASSERT_EQ (nano::block_status::progress, node.process (*key1_send2)); - ASSERT_EQ (nano::block_status::progress, node.process (*key3_receive)); - ASSERT_EQ (nano::block_status::progress, node.process (*key3_epoch)); + ASSERT_EQ (nano::block_status::progress, node.process (gen_send1)); + ASSERT_EQ (nano::block_status::progress, node.process (key1_open)); + ASSERT_EQ (nano::block_status::progress, node.process (key1_send1)); + ASSERT_EQ (nano::block_status::progress, node.process (gen_receive)); + ASSERT_EQ (nano::block_status::progress, node.process (gen_send2)); + ASSERT_EQ (nano::block_status::progress, node.process (key2_open)); + ASSERT_EQ (nano::block_status::progress, node.process (key2_send1)); + ASSERT_EQ (nano::block_status::progress, node.process (key3_open)); + ASSERT_EQ (nano::block_status::progress, node.process (key2_send2)); + ASSERT_EQ (nano::block_status::progress, node.process (key1_receive)); + ASSERT_EQ (nano::block_status::progress, node.process (key1_send2)); + ASSERT_EQ (nano::block_status::progress, node.process (key3_receive)); + ASSERT_EQ (nano::block_status::progress, node.process (key3_epoch)); ASSERT_TRUE (node.active.empty ()); // Hash -> Ancestors @@ -3805,19 +3805,19 @@ TEST (node, dependency_graph_frontier) for (auto const & node : system.nodes) { auto transaction (node->store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *gen_send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key1_open)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key1_send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *gen_receive)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *gen_send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key2_open)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key2_send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key3_open)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key2_send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key1_receive)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key1_send2)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key3_receive)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key3_epoch)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, gen_send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key1_open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key1_send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, gen_receive)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, gen_send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key2_open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key2_send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key3_open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key2_send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key1_receive)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key1_send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key3_receive)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key3_epoch)); } // node1 can vote, but only on the first block @@ -3931,7 +3931,7 @@ TEST (node, deferred_dependent_elections) ASSERT_NE (nullptr, election_open); // Confirm one of the dependents of the receive but not the other, to ensure both have to be confirmed to start an election on processing - ASSERT_EQ (nano::block_status::progress, node.process (*receive)); + ASSERT_EQ (nano::block_status::progress, node.process (receive)); ASSERT_FALSE (node.active.active (receive->qualified_root ())); election_open->force_confirm (); ASSERT_TIMELY (5s, node.block_confirmed (open->hash ())); @@ -3944,7 +3944,7 @@ TEST (node, deferred_dependent_elections) ASSERT_NEVER (0.5s, node.active.active (receive->qualified_root ())); // Processing a fork will also not start an election - ASSERT_EQ (nano::block_status::fork, node.process (*fork)); + ASSERT_EQ (nano::block_status::fork, node.process (fork)); node.process_local (fork); ASSERT_NEVER (0.5s, node.active.active (receive->qualified_root ())); diff --git a/nano/core_test/processor_service.cpp b/nano/core_test/processor_service.cpp index d4fc7014..9a9f33b1 100644 --- a/nano/core_test/processor_service.cpp +++ b/nano/core_test/processor_service.cpp @@ -32,7 +32,7 @@ TEST (processor_service, bad_send_signature) .work (*pool.generate (info1->head)) .build (); send->signature.bytes[32] ^= 0x1; - ASSERT_EQ (nano::block_status::bad_signature, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::bad_signature, ledger.process (transaction, send)); } TEST (processor_service, bad_receive_signature) @@ -57,7 +57,7 @@ TEST (processor_service, bad_receive_signature) .work (*pool.generate (info1->head)) .build (); nano::block_hash hash1 (send->hash ()); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); auto info2 = ledger.account_info (transaction, nano::dev::genesis_key.pub); ASSERT_TRUE (info2); auto receive = builder @@ -68,5 +68,5 @@ TEST (processor_service, bad_receive_signature) .work (*pool.generate (hash1)) .build (); receive->signature.bytes[32] ^= 0x1; - ASSERT_EQ (nano::block_status::bad_signature, ledger.process (transaction, *receive)); + ASSERT_EQ (nano::block_status::bad_signature, ledger.process (transaction, receive)); } diff --git a/nano/core_test/request_aggregator.cpp b/nano/core_test/request_aggregator.cpp index 2d6f9ddf..dff32155 100644 --- a/nano/core_test/request_aggregator.cpp +++ b/nano/core_test/request_aggregator.cpp @@ -36,7 +36,7 @@ TEST (request_aggregator, one) ASSERT_TIMELY (3s, node.aggregator.empty ()); // Not yet in the ledger ASSERT_TIMELY_EQ (3s, 1, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_unknown)); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1)); node.aggregator.add (dummy_channel, request); ASSERT_EQ (1, node.aggregator.size ()); // In the ledger but no vote generated yet @@ -73,7 +73,7 @@ TEST (request_aggregator, one_update) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1)); node.confirmation_height_processor.add (send1); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ())); auto send2 = nano::state_block_builder () @@ -85,7 +85,7 @@ TEST (request_aggregator, one_update) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send2)); auto receive1 = nano::state_block_builder () .account (key1.pub) .previous (0) @@ -95,7 +95,7 @@ TEST (request_aggregator, one_update) .sign (key1.prv, key1.pub) .work (*node.work_generate_blocking (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *receive1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), receive1)); std::vector> request; request.emplace_back (send2->hash (), send2->root ()); auto client = std::make_shared (node); @@ -139,7 +139,7 @@ TEST (request_aggregator, two) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1)); node.confirmation_height_processor.add (send1); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ())); auto send2 = builder.make_block () @@ -160,8 +160,8 @@ TEST (request_aggregator, two) .sign (key1.prv, key1.pub) .work (*node.work_generate_blocking (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2)); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *receive1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send2)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), receive1)); std::vector> request; request.emplace_back (send2->hash (), send2->root ()); request.emplace_back (receive1->hash (), receive1->root ()); @@ -218,7 +218,7 @@ TEST (request_aggregator, two_endpoints) .build (); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), send1)); auto dummy_channel1 = std::make_shared (node1, node1); auto dummy_channel2 = std::make_shared (node2, node2); ASSERT_NE (nano::transport::map_endpoint_to_v6 (dummy_channel1->get_endpoint ()), nano::transport::map_endpoint_to_v6 (dummy_channel2->get_endpoint ())); @@ -279,7 +279,7 @@ TEST (request_aggregator, split) .build ()); auto const & block = blocks.back (); previous = block->hash (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *block)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), block)); request.emplace_back (block->hash (), block->root ()); } // Confirm all blocks @@ -325,7 +325,7 @@ TEST (request_aggregator, channel_lifetime) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1)); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); { @@ -356,7 +356,7 @@ TEST (request_aggregator, channel_update) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1)); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); std::weak_ptr channel1_w; @@ -396,7 +396,7 @@ TEST (request_aggregator, channel_max_queue) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1)); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); auto client = std::make_shared (node); @@ -424,7 +424,7 @@ TEST (request_aggregator, unique) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1)); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); auto client = std::make_shared (node); @@ -464,8 +464,8 @@ TEST (request_aggregator, cannot_vote) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send1)); - ASSERT_EQ (nano::block_status::progress, node.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node.process (send1)); + ASSERT_EQ (nano::block_status::progress, node.process (send2)); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_FALSE (node.ledger.dependents_confirmed (node.store.tx_begin_read (), *send2)); diff --git a/nano/core_test/system.cpp b/nano/core_test/system.cpp index 1ef8be8d..8ac65cc7 100644 --- a/nano/core_test/system.cpp +++ b/nano/core_test/system.cpp @@ -60,7 +60,7 @@ TEST (system, DISABLED_generate_send_existing) .work (0) .build (); node1.work_generate_blocking (*open_block); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *open_block)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, open_block)); } ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::dev::genesis->account ())); auto info2 = node1.ledger.account_info (node1.store.tx_begin_read (), nano::dev::genesis_key.pub); @@ -111,7 +111,7 @@ TEST (system, DISABLED_generate_send_new) .work (0) .build (); node1.work_generate_blocking (*open_block); - ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *open_block)); + ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, open_block)); } ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::dev::genesis->account ())); std::vector accounts; diff --git a/nano/core_test/voting.cpp b/nano/core_test/voting.cpp index 03d32293..cc95dd84 100644 --- a/nano/core_test/voting.cpp +++ b/nano/core_test/voting.cpp @@ -168,12 +168,12 @@ TEST (vote_spacing, vote_generator) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1)); ASSERT_EQ (0, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts)); node.generator.add (nano::dev::genesis->hash (), send1->hash ()); ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts), 1); ASSERT_FALSE (node.ledger.rollback (node.store.tx_begin_write (), send1->hash ())); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send2)); node.generator.add (nano::dev::genesis->hash (), send2->hash ()); ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_spacing), 1); ASSERT_EQ (1, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts)); @@ -212,11 +212,11 @@ TEST (vote_spacing, rapid) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1)); node.generator.add (nano::dev::genesis->hash (), send1->hash ()); ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts), 1); ASSERT_FALSE (node.ledger.rollback (node.store.tx_begin_write (), send1->hash ())); - ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2)); + ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send2)); node.generator.add (nano::dev::genesis->hash (), send2->hash ()); ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_spacing), 1); ASSERT_TIMELY_EQ (3s, 1, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts)); diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp index e7c8356e..f52eb666 100644 --- a/nano/core_test/wallet.cpp +++ b/nano/core_test/wallet.cpp @@ -1114,7 +1114,7 @@ TEST (wallet, epoch_2_receive_unopened) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (key.pub, node.network_params.work.epoch_2)) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*epoch2_unopened)); + ASSERT_EQ (nano::block_status::progress, node.process (epoch2_unopened)); wallet.insert_adhoc (key.prv, false); @@ -1175,7 +1175,7 @@ TEST (wallet, search_receivable) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send)); + ASSERT_EQ (nano::block_status::progress, node.process (send)); // Pending search should start an election ASSERT_TRUE (node.active.empty ()); diff --git a/nano/core_test/wallets.cpp b/nano/core_test/wallets.cpp index 5e3d45df..38009cdb 100644 --- a/nano/core_test/wallets.cpp +++ b/nano/core_test/wallets.cpp @@ -110,7 +110,7 @@ TEST (wallets, vote_minimum) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1.process (send1)); auto open1 = builder .state () .account (key1.pub) @@ -121,7 +121,7 @@ TEST (wallets, vote_minimum) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1.process (*open1)); + ASSERT_EQ (nano::block_status::progress, node1.process (open1)); // send2 with amount vote_minimum - 1 (not voting representative) auto send2 = builder .state () @@ -133,7 +133,7 @@ TEST (wallets, vote_minimum) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1.process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1.process (send2)); auto open2 = builder .state () .account (key2.pub) @@ -144,7 +144,7 @@ TEST (wallets, vote_minimum) .sign (key2.prv, key2.pub) .work (*system.work.generate (key2.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1.process (*open2)); + ASSERT_EQ (nano::block_status::progress, node1.process (open2)); auto wallet (node1.wallets.items.begin ()->second); nano::unique_lock representatives_lk (wallet->representatives_mutex); ASSERT_EQ (0, wallet->representatives.size ()); @@ -212,7 +212,7 @@ TEST (wallets, search_receivable) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node.process (*send)); + ASSERT_EQ (nano::block_status::progress, node.process (send)); // Pending search should start an election ASSERT_TRUE (node.active.empty ()); diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index 89cff937..64a899fa 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -1029,7 +1029,7 @@ int main (int argc, char * const * argv) .build (); genesis_latest = send->hash (); - node->ledger.process (transaction, *send); + node->ledger.process (transaction, send); auto open = builder.state () .account (keys[i].pub) @@ -1041,7 +1041,7 @@ int main (int argc, char * const * argv) .work (*node->work.generate (nano::work_version::work_1, keys[i].pub, node->network_params.work.epoch_1)) .build (); - node->ledger.process (transaction, *open); + node->ledger.process (transaction, open); } // Generating blocks std::deque> blocks; diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 471a3ccb..f9e2430e 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -314,9 +314,9 @@ auto nano::block_processor::process_batch (nano::unique_lock & lock nano::block_status nano::block_processor::process_one (store::write_transaction const & transaction_a, context const & context, bool const forced_a) { - auto const & block = context.block; + auto block = context.block; auto const hash = block->hash (); - nano::block_status result = node.ledger.process (transaction_a, *block); + nano::block_status result = node.ledger.process (transaction_a, block); node.stats.inc (nano::stat::type::blockprocessor_result, to_stat_detail (result)); node.stats.inc (nano::stat::type::blockprocessor_source, to_stat_detail (context.source)); diff --git a/nano/node/node.cpp b/nano/node/node.cpp index fe55224f..8ff62050 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -559,12 +559,12 @@ void nano::node::process_active (std::shared_ptr const & incoming) block_processor.add (incoming); } -[[nodiscard]] nano::block_status nano::node::process (store::write_transaction const & transaction, nano::block & block) +[[nodiscard]] nano::block_status nano::node::process (store::write_transaction const & transaction, std::shared_ptr block) { return ledger.process (transaction, block); } -nano::block_status nano::node::process (nano::block & block) +nano::block_status nano::node::process (std::shared_ptr block) { auto const transaction = store.tx_begin_write ({ tables::accounts, tables::blocks, tables::frontiers, tables::pending }); return process (transaction, block); diff --git a/nano/node/node.hpp b/nano/node/node.hpp index 247dd35c..7fdb5d06 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -210,8 +210,8 @@ public: // Testing convenience functions Creates a new write transaction and inserts `block' and returns result Transaction is comitted before function return */ - [[nodiscard]] nano::block_status process (nano::block & block); - [[nodiscard]] nano::block_status process (store::write_transaction const &, nano::block & block); + [[nodiscard]] nano::block_status process (std::shared_ptr block); + [[nodiscard]] nano::block_status process (store::write_transaction const &, std::shared_ptr block); nano::block_hash latest (nano::account const &); nano::uint128_t balance (nano::account const &); diff --git a/nano/qt_test/qt.cpp b/nano/qt_test/qt.cpp index df9cd9b7..3a6d9b4d 100644 --- a/nano/qt_test/qt.cpp +++ b/nano/qt_test/qt.cpp @@ -424,8 +424,8 @@ TEST (wallet, create_send) bool error (false); auto send = std::make_shared (error, tree1); ASSERT_FALSE (error); - ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (*send)); - ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (*send)); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (send)); + ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (send)); } TEST (wallet, create_open_receive) @@ -458,8 +458,8 @@ TEST (wallet, create_open_receive) bool error (false); auto open = std::make_shared (error, tree1); ASSERT_FALSE (error); - ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (*open)); - ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (*open)); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (open)); + ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (open)); wallet->block_creation.block->clear (); wallet->block_creation.source->clear (); wallet->block_creation.receive->click (); @@ -473,8 +473,8 @@ TEST (wallet, create_open_receive) bool error2 (false); auto receive = std::make_shared (error2, tree2); ASSERT_FALSE (error2); - ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (*receive)); - ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (*receive)); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (receive)); + ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (receive)); } TEST (wallet, create_change) @@ -501,8 +501,8 @@ TEST (wallet, create_change) bool error (false); auto change = std::make_shared (error, tree1); ASSERT_FALSE (error); - ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (*change)); - ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (*change)); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (change)); + ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (change)); } TEST (history, short_text) @@ -532,11 +532,11 @@ TEST (history, short_text) nano::keypair key; auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub)); auto send = std::make_shared (latest, nano::dev::genesis_key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); auto receive = std::make_shared (send->hash (), send->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send->hash ())); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive)); auto change = std::make_shared (receive->hash (), key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive->hash ())); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change)); } nano_qt::history history (ledger, nano::dev::genesis_key.pub, *wallet); history.refresh (); @@ -572,13 +572,13 @@ TEST (history, pruned_source) store->initialize (transaction, ledger.cache, nano::dev::constants); auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub)); auto send1 = std::make_shared (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1)); auto send2 = std::make_shared (send1->hash (), key.pub, nano::dev::constants.genesis_amount - 200, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ())); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2)); auto receive = std::make_shared (send2->hash (), send1->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2->hash ())); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive)); auto open = std::make_shared (send2->hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); ASSERT_EQ (1, ledger.pruning_action (transaction, send1->hash (), 2)); next_pruning = send2->hash (); } @@ -602,10 +602,10 @@ TEST (history, pruned_source) auto transaction (store->tx_begin_write ()); auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub)); auto send = std::make_shared (nano::dev::genesis_key.pub, latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 200, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); auto latest_key (ledger.latest (transaction, key.pub)); auto receive = std::make_shared (key.pub, latest_key, key.pub, 200, send->hash (), key.prv, key.pub, *system.work.generate (latest_key)); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive)); ASSERT_EQ (1, ledger.pruning_action (transaction, latest, 2)); ASSERT_EQ (1, ledger.pruning_action (transaction, latest_key, 2)); } @@ -718,7 +718,7 @@ TEST (wallet, republish) auto latest (system.nodes[0]->ledger.latest (transaction, nano::dev::genesis_key.pub)); auto block = std::make_shared (latest, key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); hash = block->hash (); - ASSERT_EQ (nano::block_status::progress, system.nodes[0]->ledger.process (transaction, *block)); + ASSERT_EQ (nano::block_status::progress, system.nodes[0]->ledger.process (transaction, block)); } auto account (nano::dev::genesis_key.pub); auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); @@ -917,7 +917,7 @@ TEST (wallet, DISABLED_synchronizing) auto transaction (system1.nodes[0]->store.tx_begin_write ()); auto latest (system1.nodes[0]->ledger.latest (transaction, nano::dev::genesis->account ())); auto send = std::make_shared (latest, key1, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system1.work.generate (latest)); - system1.nodes[0]->ledger.process (transaction, *send); + system1.nodes[0]->ledger.process (transaction, send); } ASSERT_EQ (0, wallet->active_status.active.count (nano_qt::status_types::synchronizing)); system0.nodes[0]->bootstrap_initiator.bootstrap (system1.nodes[0]->network.endpoint ()); @@ -967,7 +967,7 @@ TEST (wallet, epoch_2_validation) bool error (false); auto block = std::make_shared (error, tree1); EXPECT_FALSE (error); - EXPECT_EQ (nano::block_status::progress, node->process (*block)); + EXPECT_EQ (nano::block_status::progress, node->process (block)); return block->hash (); }; diff --git a/nano/rpc_test/receivable.cpp b/nano/rpc_test/receivable.cpp index 972dcbfa..81563180 100644 --- a/nano/rpc_test/receivable.cpp +++ b/nano/rpc_test/receivable.cpp @@ -370,7 +370,7 @@ TEST (rpc, search_receivable) .build (); { auto transaction (node->store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *block)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, block)); } auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index fd890c37..4f1c158f 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -72,7 +72,7 @@ TEST (rpc, account_balance) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node->process (send1)); ASSERT_TIMELY (5s, !node->active.active (*send1)); auto const rpc_ctx = add_rpc (system, node); @@ -152,7 +152,7 @@ TEST (rpc, account_weight) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*block)); + ASSERT_EQ (nano::block_status::progress, node1->process (block)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "account_weight"); @@ -957,9 +957,9 @@ TEST (rpc, history) .build (); { auto transaction (node0->store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *usend)); - ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *ureceive)); - ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *uchange)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, usend)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, ureceive)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, uchange)); } auto const rpc_ctx = add_rpc (system, node0); boost::property_tree::ptree request; @@ -1041,9 +1041,9 @@ TEST (rpc, account_history) .build (); { auto transaction (node0->store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *usend)); - ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *ureceive)); - ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *uchange)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, usend)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, ureceive)); + ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, uchange)); } auto const rpc_ctx = add_rpc (system, node0); { @@ -1557,8 +1557,8 @@ TEST (rpc, process_subtype_open) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); - ASSERT_EQ (nano::block_status::progress, node2.process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); + ASSERT_EQ (nano::block_status::progress, node2.process (send)); auto const rpc_ctx = add_rpc (system, node1); node1->scheduler.manual.push (send); auto open = builder @@ -1606,8 +1606,8 @@ TEST (rpc, process_subtype_receive) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); - ASSERT_EQ (nano::block_status::progress, node2.process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); + ASSERT_EQ (nano::block_status::progress, node2.process (send)); auto const rpc_ctx = add_rpc (system, node1); node1->scheduler.manual.push (send); auto receive = builder @@ -2497,7 +2497,7 @@ TEST (rpc, bootstrap) .build (); { auto transaction (node1->store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction, send)); } auto const rpc_ctx = add_rpc (system0, node); boost::property_tree::ptree request; @@ -2782,7 +2782,7 @@ TEST (rpc, bootstrap_any) .build (); { auto transaction (system1.nodes[0]->store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, system1.nodes[0]->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, system1.nodes[0]->ledger.process (transaction, send)); } auto const rpc_ctx = add_rpc (system0, node); boost::property_tree::ptree request; @@ -2808,7 +2808,7 @@ TEST (rpc, republish) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); auto open = builder .open () .source (send->hash ()) @@ -2817,7 +2817,7 @@ TEST (rpc, republish) .sign (key.prv, key.pub) .work (*node1->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "republish"); @@ -2998,7 +2998,7 @@ TEST (rpc, accounts_balances_unopened_account_with_receivables) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); } ASSERT_TIMELY (5s, node->block (send->hash ())); ASSERT_TIMELY (5s, !node->active.active (*send)); @@ -3531,7 +3531,7 @@ TEST (rpc, search_receivable_all) .build (); { auto transaction (node->store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *block)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, block)); } auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; @@ -3563,7 +3563,7 @@ TEST (rpc, wallet_republish) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); auto open = builder .open () .source (send->hash ()) @@ -3572,7 +3572,7 @@ TEST (rpc, wallet_republish) .sign (key.prv, key.pub) .work (*node1->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "wallet_republish"); @@ -3607,7 +3607,7 @@ TEST (rpc, delegators) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); auto open = builder .open () .source (send->hash ()) @@ -3616,7 +3616,7 @@ TEST (rpc, delegators) .sign (key.prv, key.pub) .work (*node1->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "delegators"); @@ -3648,7 +3648,7 @@ TEST (rpc, delegators_parameters) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); auto open = builder .open () .source (send->hash ()) @@ -3657,7 +3657,7 @@ TEST (rpc, delegators_parameters) .sign (key.prv, key.pub) .work (*node1->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); auto const rpc_ctx = add_rpc (system, node1); // Test with "count" = 2 @@ -3758,7 +3758,7 @@ TEST (rpc, delegators_count) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); auto open = builder .open () .source (send->hash ()) @@ -3767,7 +3767,7 @@ TEST (rpc, delegators_count) .sign (key.prv, key.pub) .work (*node1->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "delegators_count"); @@ -3810,7 +3810,7 @@ TEST (rpc, account_info) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); auto time = nano::seconds_since_epoch (); { auto transaction = node1->store.tx_begin_write (); @@ -3869,7 +3869,7 @@ TEST (rpc, account_info) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1->process (send1)); auto send2 = builder .send () .previous (send1->hash ()) @@ -3878,7 +3878,7 @@ TEST (rpc, account_info) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (send1->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1->process (send2)); auto state_change = builder .state () @@ -3890,7 +3890,7 @@ TEST (rpc, account_info) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (send2->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*state_change)); + ASSERT_EQ (nano::block_status::progress, node1->process (state_change)); auto open = builder .open () @@ -3900,7 +3900,7 @@ TEST (rpc, account_info) .sign (key1.prv, key1.pub) .work (*node1->work_generate_blocking (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); ASSERT_TIMELY (5s, !node1->active.active (*state_change)); ASSERT_TIMELY (5s, !node1->active.active (*open)); } @@ -4018,7 +4018,7 @@ TEST (rpc, json_block_output) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "block_info"); @@ -4240,7 +4240,7 @@ TEST (rpc, block_info_successor) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "block_info"); @@ -4430,7 +4430,7 @@ TEST (rpc, populate_backlog) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*send)); + ASSERT_EQ (nano::block_status::progress, node->process (send)); auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; @@ -4461,7 +4461,7 @@ TEST (rpc, ledger) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*send)); + ASSERT_EQ (nano::block_status::progress, node->process (send)); auto open = builder .open () .source (send->hash ()) @@ -4470,7 +4470,7 @@ TEST (rpc, ledger) .sign (key.prv, key.pub) .work (*node->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*open)); + ASSERT_EQ (nano::block_status::progress, node->process (open)); auto time = nano::seconds_since_epoch (); auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; @@ -4544,7 +4544,7 @@ TEST (rpc, ledger) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node->work_generate_blocking (send->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node->process (send2)); // When asking for pending, pending amount is taken into account for threshold so the account must show up request.put ("count", 2); request.put ("threshold", (send_amount + send2_amount).convert_to ()); @@ -4631,7 +4631,7 @@ TEST (rpc, block_create) boost::property_tree::read_json (block_stream, block_l); auto send_block (nano::deserialize_block_json (block_l)); ASSERT_EQ (send->hash (), send_block->hash ()); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); boost::property_tree::ptree request1; request1.put ("action", "block_create"); request1.put ("type", "open"); @@ -4649,7 +4649,7 @@ TEST (rpc, block_create) boost::property_tree::read_json (block_stream1, block_l); auto open_block (nano::deserialize_block_json (block_l)); ASSERT_EQ (open->hash (), open_block->hash ()); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); request1.put ("representative", key.pub.to_account ()); auto response2 (wait_response (system, rpc_ctx, request1)); std::string open2_hash (response2.get ("hash")); @@ -4672,7 +4672,7 @@ TEST (rpc, block_create) boost::property_tree::read_json (block_stream4, block_l); auto change_block (nano::deserialize_block_json (block_l)); ASSERT_EQ (change->hash (), change_block->hash ()); - ASSERT_EQ (nano::block_status::progress, node1->process (*change)); + ASSERT_EQ (nano::block_status::progress, node1->process (change)); auto send2 = builder .send () .previous (send->hash ()) @@ -4681,7 +4681,7 @@ TEST (rpc, block_create) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (send->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node1->process (send2)); boost::property_tree::ptree request2; request2.put ("action", "block_create"); request2.put ("type", "receive"); @@ -4729,7 +4729,7 @@ TEST (rpc, block_create_state) ASSERT_NE (nullptr, state_block); ASSERT_EQ (nano::block_type::state, state_block->type ()); ASSERT_EQ (state_hash, state_block->hash ().to_string ()); - auto process_result (node->process (*state_block)); + auto process_result (node->process (state_block)); ASSERT_EQ (nano::block_status::progress, process_result); } @@ -4765,7 +4765,7 @@ TEST (rpc, block_create_state_open) auto difficulty (nano::dev::network_params.work.difficulty (*state_block)); ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_0, false, true, false))); ASSERT_TRUE (node->latest (key.pub).is_zero ()); - auto process_result (node->process (*state_block)); + auto process_result (node->process (state_block)); ASSERT_EQ (nano::block_status::progress, process_result); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_0); ASSERT_TRUE (state_block->sideband ().details.is_receive); @@ -4844,7 +4844,7 @@ TEST (rpc, block_create_open_epoch_v2) auto difficulty (nano::dev::network_params.work.difficulty (*state_block)); ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false))); ASSERT_TRUE (node->latest (key.pub).is_zero ()); - auto process_result (node->process (*state_block)); + auto process_result (node->process (state_block)); ASSERT_EQ (nano::block_status::progress, process_result); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2); ASSERT_TRUE (state_block->sideband ().details.is_receive); @@ -4871,7 +4871,7 @@ TEST (rpc, block_create_receive_epoch_v2) .sign (key.prv, key.pub) .work (*node->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*open)); + ASSERT_EQ (nano::block_status::progress, node->process (open)); ASSERT_NE (nullptr, system.upgrade_genesis_epoch (*node, nano::epoch::epoch_2)); auto send_block_2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, nano::Gxrb_ratio)); auto const rpc_ctx = add_rpc (system, node); @@ -4896,7 +4896,7 @@ TEST (rpc, block_create_receive_epoch_v2) ASSERT_EQ (state_hash, state_block->hash ().to_string ()); auto difficulty (nano::dev::network_params.work.difficulty (*state_block)); ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false))); - auto process_result (node->process (*state_block)); + auto process_result (node->process (state_block)); ASSERT_EQ (nano::block_status::progress, process_result); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2); ASSERT_TRUE (state_block->sideband ().details.is_receive); @@ -4924,7 +4924,7 @@ TEST (rpc, block_create_send_epoch_v2) .sign (key.prv, key.pub) .work (*node->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*open)); + ASSERT_EQ (nano::block_status::progress, node->process (open)); auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "block_create"); @@ -4947,7 +4947,7 @@ TEST (rpc, block_create_send_epoch_v2) ASSERT_EQ (state_hash, state_block->hash ().to_string ()); auto difficulty (nano::dev::network_params.work.difficulty (*state_block)); ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, true, false, false))); - auto process_result (node->process (*state_block)); + auto process_result (node->process (state_block)); ASSERT_EQ (nano::block_status::progress, process_result); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2); ASSERT_TRUE (state_block->sideband ().details.is_send); @@ -5048,7 +5048,7 @@ TEST (rpc, wallet_ledger) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send)); + ASSERT_EQ (nano::block_status::progress, node1->process (send)); auto open = builder .open () .source (send->hash ()) @@ -5057,7 +5057,7 @@ TEST (rpc, wallet_ledger) .sign (key.prv, key.pub) .work (*node1->work_generate_blocking (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); auto time = nano::seconds_since_epoch (); auto const rpc_ctx = add_rpc (system, node1); boost::property_tree::ptree request; @@ -5221,7 +5221,7 @@ TEST (rpc, confirmation_height_currently_processing) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous_genesis_chain_hash)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); previous_genesis_chain_hash = send->hash (); } @@ -5343,7 +5343,7 @@ TEST (rpc, block_confirm) .build (); { auto transaction (node->store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); } auto const rpc_ctx = add_rpc (system, node); boost::property_tree::ptree request; @@ -5850,7 +5850,7 @@ TEST (rpc, block_confirmed) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); auto open1 = builder .open () @@ -5860,7 +5860,7 @@ TEST (rpc, block_confirmed) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open1)); } // This should not be confirmed @@ -6144,7 +6144,7 @@ TEST (rpc, epoch_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); // to opened account - ASSERT_EQ (nano::block_status::progress, node->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node->process (send1)); auto send2 = builder .state () .account (nano::dev::genesis_key.pub) @@ -6155,7 +6155,7 @@ TEST (rpc, epoch_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); // to unopened account (pending) - ASSERT_EQ (nano::block_status::progress, node->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node->process (send2)); auto send3 = builder .state () .account (nano::dev::genesis_key.pub) @@ -6166,7 +6166,7 @@ TEST (rpc, epoch_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) .build (); // to burn (0) - ASSERT_EQ (nano::block_status::progress, node->process (*send3)); + ASSERT_EQ (nano::block_status::progress, node->process (send3)); nano::account max_account (std::numeric_limits::max ()); auto send4 = builder .state () @@ -6178,7 +6178,7 @@ TEST (rpc, epoch_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send3->hash ())) .build (); // to max account - ASSERT_EQ (nano::block_status::progress, node->process (*send4)); + ASSERT_EQ (nano::block_status::progress, node->process (send4)); auto open = builder .state () .account (key1.pub) @@ -6189,7 +6189,7 @@ TEST (rpc, epoch_upgrade) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*open)); + ASSERT_EQ (nano::block_status::progress, node->process (open)); // Check accounts epochs { auto transaction (node->store.tx_begin_read ()); @@ -6235,7 +6235,7 @@ TEST (rpc, epoch_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (genesis_latest)) .build (); // to burn (0) - ASSERT_EQ (nano::block_status::progress, node->process (*send5)); + ASSERT_EQ (nano::block_status::progress, node->process (send5)); auto send6 = builder .state () .account (nano::dev::genesis_key.pub) @@ -6246,7 +6246,7 @@ TEST (rpc, epoch_upgrade) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send5->hash ())) .build (); // to key1 (again) - ASSERT_EQ (nano::block_status::progress, node->process (*send6)); + ASSERT_EQ (nano::block_status::progress, node->process (send6)); auto key1_latest (node->latest (key1.pub)); auto send7 = builder .state () @@ -6258,7 +6258,7 @@ TEST (rpc, epoch_upgrade) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1_latest)) .build (); // to key3 - ASSERT_EQ (nano::block_status::progress, node->process (*send7)); + ASSERT_EQ (nano::block_status::progress, node->process (send7)); { // Check pending entry auto transaction (node->store.tx_begin_read ()); @@ -6307,7 +6307,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); // to opened account - ASSERT_EQ (nano::block_status::progress, node->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node->process (send1)); auto send2 = builder .state () .account (nano::dev::genesis_key.pub) @@ -6318,7 +6318,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build (); // to unopened account (pending) - ASSERT_EQ (nano::block_status::progress, node->process (*send2)); + ASSERT_EQ (nano::block_status::progress, node->process (send2)); auto send3 = builder .state () .account (nano::dev::genesis_key.pub) @@ -6329,7 +6329,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) .build (); // to burn (0) - ASSERT_EQ (nano::block_status::progress, node->process (*send3)); + ASSERT_EQ (nano::block_status::progress, node->process (send3)); nano::account max_account (std::numeric_limits::max ()); auto send4 = builder .state () @@ -6341,7 +6341,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send3->hash ())) .build (); // to max account - ASSERT_EQ (nano::block_status::progress, node->process (*send4)); + ASSERT_EQ (nano::block_status::progress, node->process (send4)); auto open = builder .state () .account (key1.pub) @@ -6352,7 +6352,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node->process (*open)); + ASSERT_EQ (nano::block_status::progress, node->process (open)); // Check accounts epochs { auto transaction (node->store.tx_begin_read ()); @@ -6399,7 +6399,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (genesis_latest)) .build (); // to burn (0) - ASSERT_EQ (nano::block_status::progress, node->process (*send5)); + ASSERT_EQ (nano::block_status::progress, node->process (send5)); auto send6 = builder .state () .account (nano::dev::genesis_key.pub) @@ -6410,7 +6410,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send5->hash ())) .build (); // to key1 (again) - ASSERT_EQ (nano::block_status::progress, node->process (*send6)); + ASSERT_EQ (nano::block_status::progress, node->process (send6)); auto key1_latest (node->latest (key1.pub)); auto send7 = builder .state () @@ -6422,7 +6422,7 @@ TEST (rpc, epoch_upgrade_multithreaded) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1_latest)) .build (); // to key3 - ASSERT_EQ (nano::block_status::progress, node->process (*send7)); + ASSERT_EQ (nano::block_status::progress, node->process (send7)); { // Check pending entry auto transaction (node->store.tx_begin_read ()); @@ -6471,7 +6471,7 @@ TEST (rpc, account_lazy_start) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); + ASSERT_EQ (nano::block_status::progress, node1->process (send1)); auto open = builder .open () .source (send1->hash ()) @@ -6480,7 +6480,7 @@ TEST (rpc, account_lazy_start) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node1->process (*open)); + ASSERT_EQ (nano::block_status::progress, node1->process (open)); // Start lazy bootstrap with account nano::node_config node_config = system.default_config (); diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index 62503f5c..c23ffc73 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -915,11 +915,11 @@ std::optional nano::ledger::pending_info (store::transaction return std::nullopt; } -nano::block_status nano::ledger::process (store::write_transaction const & transaction_a, nano::block & block_a) +nano::block_status nano::ledger::process (store::write_transaction const & transaction_a, std::shared_ptr block_a) { - debug_assert (!constants.work.validate_entry (block_a) || constants.genesis == nano::dev::genesis); + debug_assert (!constants.work.validate_entry (*block_a) || constants.genesis == nano::dev::genesis); ledger_processor processor (*this, transaction_a); - block_a.visit (processor); + block_a->visit (processor); if (processor.result == nano::block_status::progress) { ++cache.block_count; diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index 9f3c69a5..935f57e2 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -72,7 +72,7 @@ public: nano::block_hash block_source (store::transaction const &, nano::block const &); std::pair hash_root_random (store::transaction const &) const; std::optional pending_info (store::transaction const & transaction, nano::pending_key const & key) const; - nano::block_status process (store::write_transaction const &, nano::block &); + nano::block_status process (store::write_transaction const & transaction, std::shared_ptr block); bool rollback (store::write_transaction const &, nano::block_hash const &, std::vector> &); bool rollback (store::write_transaction const &, nano::block_hash const &); void update_account (store::write_transaction const &, nano::account const &, nano::account_info const &, nano::account_info const &); diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp index 9bfa3bdd..1dd982e0 100644 --- a/nano/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -136,7 +136,7 @@ TEST (ledger, deep_account_compute) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (nano::dev::genesis->hash ())) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); auto open = builder .open () .source (send->hash ()) @@ -145,7 +145,7 @@ TEST (ledger, deep_account_compute) .sign (key.prv, key.pub) .work (*pool.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); auto sprevious (send->hash ()); auto rprevious (open->hash ()); for (auto i (0), n (100000); i != n; ++i) @@ -159,7 +159,7 @@ TEST (ledger, deep_account_compute) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (sprevious)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); sprevious = send->hash (); auto receive = builder .receive () @@ -168,7 +168,7 @@ TEST (ledger, deep_account_compute) .sign (key.prv, key.pub) .work (*pool.generate (rprevious)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive)); rprevious = receive->hash (); if (i % 100 == 0) { @@ -277,7 +277,7 @@ TEST (node, fork_storm) previous = send->hash (); for (auto node_i : system.nodes) { - auto send_result (node_i->process (*send)); + auto send_result (node_i->process (send)); ASSERT_EQ (nano::block_status::progress, send_result); nano::keypair rep; auto open = builder @@ -289,7 +289,7 @@ TEST (node, fork_storm) .work (0) .build (); node_i->work_generate_blocking (*open); - auto open_result (node_i->process (*open)); + auto open_result (node_i->process (open)); ASSERT_EQ (nano::block_status::progress, open_result); auto transaction (node_i->store.tx_begin_read ()); node_i->network.flood_block (open); @@ -660,7 +660,7 @@ TEST (confirmation_height, many_accounts_single_confirmation) .sign (last_keypair.prv, last_keypair.pub) .work (*system.work.generate (last_open_hash)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); auto open = builder .open () .source (send->hash ()) @@ -669,7 +669,7 @@ TEST (confirmation_height, many_accounts_single_confirmation) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open)); last_open_hash = open->hash (); last_keypair = key; } @@ -744,7 +744,7 @@ TEST (confirmation_height, many_accounts_many_confirmations) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_genesis)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); auto open = builder .open () .source (send->hash ()) @@ -753,7 +753,7 @@ TEST (confirmation_height, many_accounts_many_confirmations) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open)); open_blocks.push_back (std::move (open)); latest_genesis = send->hash (); } @@ -826,8 +826,8 @@ TEST (confirmation_height, long_chains) .build (); { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open)); } // Bulk send from genesis account to destination account @@ -845,7 +845,7 @@ TEST (confirmation_height, long_chains) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous_genesis_chain_hash)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); auto receive = builder .receive () .previous (previous_destination_chain_hash) @@ -853,7 +853,7 @@ TEST (confirmation_height, long_chains) .sign (key1.prv, key1.pub) .work (*system.work.generate (previous_destination_chain_hash)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive)); previous_genesis_chain_hash = send->hash (); previous_destination_chain_hash = receive->hash (); @@ -895,9 +895,9 @@ TEST (confirmation_height, long_chains) { auto transaction = node->store.tx_begin_write (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive1)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2)); } // Call block confirm on the existing receive block on the genesis account which will confirm everything underneath on both accounts @@ -970,7 +970,7 @@ TEST (confirmation_height, dynamic_algorithm) auto transaction = node->store.tx_begin_write (); for (auto const & block : state_blocks) { - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *block)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, block)); } } @@ -1031,7 +1031,7 @@ TEST (confirmation_height, dynamic_algorithm_no_transition_while_pending) .build (); latest_genesis = send->hash (); state_blocks.push_back (send); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); ++num; }; @@ -1116,7 +1116,7 @@ TEST (confirmation_height, many_accounts_send_receive_self) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest_genesis)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); auto open = builder .open () .source (send->hash ()) @@ -1125,7 +1125,7 @@ TEST (confirmation_height, many_accounts_send_receive_self) .sign (key.prv, key.pub) .work (*system.work.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open)); open_blocks.push_back (std::move (open)); latest_genesis = send->hash (); } @@ -1263,7 +1263,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (latest_genesis)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send)); auto open = builder .open () .source (send->hash ()) @@ -1272,7 +1272,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) .sign (key.prv, key.pub) .work (*pool.generate (key.pub)) .build (); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open)); open_blocks.push_back (std::move (open)); latest_genesis = send->hash (); } @@ -1316,8 +1316,8 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) .work (*system.work.generate (send_blocks.back ()->hash ())) .build ()); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send_blocks.back ())); - ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive_blocks.back ())); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send_blocks.back ())); + ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive_blocks.back ())); } } @@ -1688,7 +1688,7 @@ TEST (telemetry, many_nodes) for (auto node : system.nodes) { auto transaction (node->store.tx_begin_write ()); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); } // This is the node which will request metrics from all other nodes @@ -1788,7 +1788,7 @@ TEST (node, mass_epoch_upgrader) .build (ec); ASSERT_FALSE (ec); ASSERT_NE (nullptr, block); - ASSERT_EQ (nano::block_status::progress, node.process (*block)); + ASSERT_EQ (nano::block_status::progress, node.process (block)); latest = block->hash (); info.pending_hash = block->hash (); } @@ -1812,7 +1812,7 @@ TEST (node, mass_epoch_upgrader) .build (ec); ASSERT_FALSE (ec); ASSERT_NE (nullptr, block); - ASSERT_EQ (nano::block_status::progress, node.process (*block)); + ASSERT_EQ (nano::block_status::progress, node.process (block)); } ASSERT_EQ (1 + total_accounts + opened.size (), node.ledger.cache.block_count); ASSERT_EQ (1 + opened.size (), node.ledger.cache.account_count); @@ -2042,7 +2042,7 @@ TEST (node, aggressive_flooding) { for (auto const & block : genesis_blocks) { - auto process_result (node_wallet.first->process (*block)); + auto process_result (node_wallet.first->process (block)); ASSERT_TRUE (nano::block_status::progress == process_result || nano::block_status::old == process_result); } ASSERT_EQ (node1.latest (nano::dev::genesis_key.pub), node_wallet.first->latest (nano::dev::genesis_key.pub)); @@ -2146,7 +2146,7 @@ TEST (node, wallet_create_block_confirm_conflicts) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build (); - ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send)); + ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send)); latest = send->hash (); } } diff --git a/nano/test_common/ledger.cpp b/nano/test_common/ledger.cpp index 611206eb..063000f3 100644 --- a/nano/test_common/ledger.cpp +++ b/nano/test_common/ledger.cpp @@ -12,7 +12,7 @@ nano::test::context::ledger_context::ledger_context (std::dequeinitialize (tx, ledger_m.cache, ledger_m.constants); for (auto const & i : blocks_m) { - auto process_result = ledger_m.process (tx, *i); + auto process_result = ledger_m.process (tx, i); debug_assert (process_result == nano::block_status::progress); } } diff --git a/nano/test_common/system.cpp b/nano/test_common/system.cpp index 35d86b4e..37e13762 100644 --- a/nano/test_common/system.cpp +++ b/nano/test_common/system.cpp @@ -40,7 +40,7 @@ std::shared_ptr nano::test::system::add_node (nano::node_config cons auto node (std::make_shared (io_ctx, nano::unique_path (), node_config_a, work, node_flags_a, node_sequence++)); for (auto i : initialization_blocks) { - auto result = node->ledger.process (node->store.tx_begin_write (), *i); + auto result = node->ledger.process (node->store.tx_begin_write (), i); debug_assert (result == nano::block_status::progress); } debug_assert (!node->init_error ()); @@ -262,7 +262,7 @@ std::shared_ptr nano::test::upgrade_epoch (nano::work_pool & bool error{ true }; if (!ec && epoch) { - error = ledger_a.process (transaction, *epoch) != nano::block_status::progress; + error = ledger_a.process (transaction, epoch) != nano::block_status::progress; } return !error ? std::move (epoch) : nullptr; diff --git a/nano/test_common/testutil.cpp b/nano/test_common/testutil.cpp index d08ca37b..9d6d5bb7 100644 --- a/nano/test_common/testutil.cpp +++ b/nano/test_common/testutil.cpp @@ -64,7 +64,7 @@ bool nano::test::process (nano::node & node, std::vector