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

Convert ledger::process to accept a shared_ptr so it can store a reference.

Browse source
This commit is contained in:
Colin LeMahieu 2024-02-19 20:03:04 +00:00
commit 9f89fb8490
No known key found for this signature in database
GPG key ID: 43708520C8DFB938
31 changed files with 840 additions and 838 deletions
Download patch file Download diff file Expand all files Collapse all files

50
nano/core_test/active_transactions.cpp
View file

@ -149,7 +149,7 @@ TEST (active_transactions, confirm_frontier)
node2.rep_crawler.probable_reps.emplace (nano::dev::genesis_key.pub, *peers.begin ()); 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 ()); ASSERT_TIMELY (5s, !node2.active.empty ());
// Save election to check request count afterwards // Save election to check request count afterwards
@ -490,10 +490,10 @@ TEST (active_transactions, inactive_votes_cache_election_start)
.sign (key2.prv, key2.pub) .sign (key2.prv, key2.pub)
.work (*system.work.generate (key2.pub)) .work (*system.work.generate (key2.pub))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node.process (*send1)); 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 (send2));
ASSERT_EQ (nano::block_status::progress, node.process (*open1)); 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 (open2));
ASSERT_TIMELY_EQ (5s, 5, node.ledger.cache.block_count); ASSERT_TIMELY_EQ (5s, 5, node.ledger.cache.block_count);
ASSERT_TRUE (node.active.empty ()); ASSERT_TRUE (node.active.empty ());
ASSERT_EQ (1, node.ledger.cache.cemented_count); 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); nano::test::system system (1);
auto & node1 = *system.nodes[0]; auto & node1 = *system.nodes[0];
@ -1060,8 +1063,7 @@ TEST (active_transactions, confirm_new)
// Let node2 know about the block // Let node2 know about the block
ASSERT_TIMELY (5s, node2.block (send->hash ())); ASSERT_TIMELY (5s, node2.block (send->hash ()));
// Wait confirmation // Wait confirmation
ASSERT_TIMELY (5s, node1.ledger.cache.cemented_count == 2); ASSERT_TIMELY (5s, node1.ledger.cache.cemented_count == 2 && node2.ledger.cache.cemented_count == 2);
ASSERT_TIMELY (5s, node2.ledger.cache.cemented_count == 2);
} }
// Ensures votes are tallied on election::publish even if no vote is inserted through inactive_votes_cache // 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) .sign (key.prv, key.pub)
.work (*system.work.generate (open->hash ())) .work (*system.work.generate (open->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node.process (*send)); 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 (send2));
ASSERT_EQ (nano::block_status::progress, node.process (*send3)); 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 (open));
ASSERT_EQ (nano::block_status::progress, node.process (*receive)); ASSERT_EQ (nano::block_status::progress, node.process (receive));
node.scheduler.priority.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); node.scheduler.priority.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
ASSERT_TIMELY (5s, node.active.election (send->qualified_root ())); ASSERT_TIMELY (5s, node.active.election (send->qualified_root ()));
@ -1246,9 +1248,9 @@ TEST (active_transactions, activate_inactive)
.work (*system.work.generate (key.pub)) .work (*system.work.generate (key.pub))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node.process (*send)); 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 (send2));
ASSERT_EQ (nano::block_status::progress, node.process (*open)); ASSERT_EQ (nano::block_status::progress, node.process (open));
auto election = nano::test::start_election (system, node, send2->hash ()); auto election = nano::test::start_election (system, node, send2->hash ());
ASSERT_NE (nullptr, election); ASSERT_NE (nullptr, election);
@ -1283,7 +1285,7 @@ TEST (active_transactions, list_active)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node.process (*send)); ASSERT_EQ (nano::block_status::progress, node.process (send));
auto send2 = builder.make_block () auto send2 = builder.make_block ()
.account (nano::dev::genesis_key.pub) .account (nano::dev::genesis_key.pub)
@ -1295,7 +1297,7 @@ TEST (active_transactions, list_active)
.work (*system.work.generate (send->hash ())) .work (*system.work.generate (send->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node.process (*send2)); ASSERT_EQ (nano::block_status::progress, node.process (send2));
auto open = builder.make_block () auto open = builder.make_block ()
.account (key.pub) .account (key.pub)
@ -1307,7 +1309,7 @@ TEST (active_transactions, list_active)
.work (*system.work.generate (key.pub)) .work (*system.work.generate (key.pub))
.build (); .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_TRUE (nano::test::start_elections (system, node, { send, send2, open }));
ASSERT_EQ (3, node.active.size ()); ASSERT_EQ (3, node.active.size ());
@ -1340,7 +1342,7 @@ TEST (active_transactions, vacancy)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .build ();
node.active.vacancy_update = [&updated] () { updated = true; }; 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 (1, node.active.vacancy ());
ASSERT_EQ (0, node.active.size ()); ASSERT_EQ (0, node.active.size ());
node.scheduler.priority.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_hash)) .work (*system.work.generate (latest_hash))
.build (); .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 }); node.process_confirmed (nano::election_status{ send1 });
ASSERT_TIMELY (5s, node.block_confirmed (send1->hash ())); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_hash)) .work (*system.work.generate (latest_hash))
.build (); .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 }); node.process_confirmed (nano::election_status{ send2 });
ASSERT_TIMELY (5s, node.block_confirmed (send2->hash ())); ASSERT_TIMELY (5s, node.block_confirmed (send2->hash ()));
@ -1409,7 +1411,7 @@ TEST (active_transactions, fifo)
.sign (key0.prv, key0.pub) .sign (key0.prv, key0.pub)
.work (*system.work.generate (key0.pub)) .work (*system.work.generate (key0.pub))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node.process (*receive1)); ASSERT_EQ (nano::block_status::progress, node.process (receive1));
auto receive2 = builder.make_block () auto receive2 = builder.make_block ()
.previous (0) .previous (0)
@ -1420,7 +1422,7 @@ TEST (active_transactions, fifo)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub)) .work (*system.work.generate (key1.pub))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node.process (*receive2)); ASSERT_EQ (nano::block_status::progress, node.process (receive2));
// Ensure first transaction becomes active // Ensure first transaction becomes active
node.scheduler.manual.push (receive1); node.scheduler.manual.push (receive1);

22
nano/core_test/block_store.cpp
View file

@ -1021,7 +1021,7 @@ TEST (mdb_block_store, sideband_height)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (nano::dev::genesis->hash ())) .work (*pool.generate (nano::dev::genesis->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send));
auto receive = builder auto receive = builder
.receive () .receive ()
.previous (send->hash ()) .previous (send->hash ())
@ -1029,7 +1029,7 @@ TEST (mdb_block_store, sideband_height)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (send->hash ())) .work (*pool.generate (send->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive));
auto change = builder auto change = builder
.change () .change ()
.previous (receive->hash ()) .previous (receive->hash ())
@ -1037,7 +1037,7 @@ TEST (mdb_block_store, sideband_height)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (receive->hash ())) .work (*pool.generate (receive->hash ()))
.build (); .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 auto state_send1 = builder
.state () .state ()
.account (nano::dev::genesis_key.pub) .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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (change->hash ())) .work (*pool.generate (change->hash ()))
.build (); .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 auto state_send2 = builder
.state () .state ()
.account (nano::dev::genesis_key.pub) .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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (state_send1->hash ())) .work (*pool.generate (state_send1->hash ()))
.build (); .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 auto state_send3 = builder
.state () .state ()
.account (nano::dev::genesis_key.pub) .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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (state_send2->hash ())) .work (*pool.generate (state_send2->hash ()))
.build (); .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 auto state_open = builder
.state () .state ()
.account (key1.pub) .account (key1.pub)
@ -1081,7 +1081,7 @@ TEST (mdb_block_store, sideband_height)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*pool.generate (key1.pub)) .work (*pool.generate (key1.pub))
.build (); .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 auto epoch = builder
.state () .state ()
.account (key1.pub) .account (key1.pub)
@ -1092,7 +1092,7 @@ TEST (mdb_block_store, sideband_height)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (state_open->hash ())) .work (*pool.generate (state_open->hash ()))
.build (); .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)); ASSERT_EQ (nano::epoch::epoch_1, ledger.version (*epoch));
auto epoch_open = builder auto epoch_open = builder
.state () .state ()
@ -1104,7 +1104,7 @@ TEST (mdb_block_store, sideband_height)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (key2.pub)) .work (*pool.generate (key2.pub))
.build (); .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)); ASSERT_EQ (nano::epoch::epoch_1, ledger.version (*epoch_open));
auto state_receive = builder auto state_receive = builder
.state () .state ()
@ -1116,7 +1116,7 @@ TEST (mdb_block_store, sideband_height)
.sign (key2.prv, key2.pub) .sign (key2.prv, key2.pub)
.work (*pool.generate (epoch_open->hash ())) .work (*pool.generate (epoch_open->hash ()))
.build (); .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 auto open = builder
.open () .open ()
.source (state_send3->hash ()) .source (state_send3->hash ())
@ -1125,7 +1125,7 @@ TEST (mdb_block_store, sideband_height)
.sign (key3.prv, key3.pub) .sign (key3.prv, key3.pub)
.work (*pool.generate (key3.pub)) .work (*pool.generate (key3.pub))
.build (); .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 ())); auto block1 (store.block.get (transaction, nano::dev::genesis->hash ()));
ASSERT_EQ (block1->sideband ().height, 1); ASSERT_EQ (block1->sideband ().height, 1);
auto block2 (store.block.get (transaction, send->hash ())); auto block2 (store.block.get (transaction, send->hash ()));

74
nano/core_test/bootstrap.cpp
View file

@ -69,7 +69,7 @@ TEST (bulk_pull, end_not_owned)
open->refresh (); open->refresh ();
open->signature = nano::sign_message (key2.prv, key2.pub, open->hash ()); open->signature = nano::sign_message (key2.prv, key2.pub, open->hash ());
system.nodes[0]->work_generate_blocking (*open); 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<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0])); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = key2.pub; req->start = key2.pub;
@ -122,7 +122,7 @@ TEST (bulk_pull, ascending_one_hash)
.work (0) .work (0)
.build (); .build ();
node.work_generate_blocking (*block1); 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<nano::transport::socket> (node, nano::transport::socket::endpoint_type_t::server); auto socket = std::make_shared<nano::transport::socket> (node, nano::transport::socket::endpoint_type_t::server);
auto connection = std::make_shared<nano::transport::tcp_server> (socket, system.nodes[0]); auto connection = std::make_shared<nano::transport::tcp_server> (socket, system.nodes[0]);
auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
@ -154,7 +154,7 @@ TEST (bulk_pull, ascending_two_account)
.work (0) .work (0)
.build (); .build ();
node.work_generate_blocking (*block1); 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<nano::transport::socket> (node, nano::transport::socket::endpoint_type_t::server); auto socket = std::make_shared<nano::transport::socket> (node, nano::transport::socket::endpoint_type_t::server);
auto connection = std::make_shared<nano::transport::tcp_server> (socket, system.nodes[0]); auto connection = std::make_shared<nano::transport::tcp_server> (socket, system.nodes[0]);
auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
@ -189,7 +189,7 @@ TEST (bulk_pull, ascending_end)
.work (0) .work (0)
.build (); .build ();
node.work_generate_blocking (*block1); 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<nano::transport::socket> (node, nano::transport::socket::endpoint_type_t::server); auto socket = std::make_shared<nano::transport::socket> (node, nano::transport::socket::endpoint_type_t::server);
auto connection = std::make_shared<nano::transport::tcp_server> (socket, system.nodes[0]); auto connection = std::make_shared<nano::transport::tcp_server> (socket, system.nodes[0]);
auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network); auto req = std::make_unique<nano::bulk_pull> (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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (node0->latest (nano::dev::genesis_key.pub))) .work (*system.work.generate (node0->latest (nano::dev::genesis_key.pub)))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node0->process (*send1)); ASSERT_EQ (nano::block_status::progress, node0->process (send1));
auto receive1 = builder auto receive1 = builder
.receive () .receive ()
.previous (send1->hash ()) .previous (send1->hash ())
@ -257,7 +257,7 @@ TEST (bulk_pull, count_limit)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ())) .work (*system.work.generate (send1->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node0->process (*receive1)); ASSERT_EQ (nano::block_status::progress, node0->process (receive1));
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node0, nano::transport::socket::endpoint_type_t::server), node0)); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node0, nano::transport::socket::endpoint_type_t::server), node0));
auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
@ -375,8 +375,8 @@ TEST (bootstrap_processor, process_state)
node0->work_generate_blocking (*block1); node0->work_generate_blocking (*block1);
node0->work_generate_blocking (*block2); node0->work_generate_blocking (*block2);
ASSERT_EQ (nano::block_status::progress, node0->process (*block1)); 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 (block2));
ASSERT_TIMELY_EQ (5s, nano::test::account_info (*node0, nano::dev::genesis_key.pub).block_count, 3); 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); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (node0->latest (nano::dev::genesis_key.pub))) .work (*system.work.generate (node0->latest (nano::dev::genesis_key.pub)))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node0->process (*send1)); ASSERT_EQ (nano::block_status::progress, node0->process (send1));
auto open = builder auto open = builder
.open () .open ()
.source (send1->hash ()) .source (send1->hash ())
@ -453,7 +453,7 @@ TEST (bootstrap_processor, pull_diamond)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*system.work.generate (key.pub)) .work (*system.work.generate (key.pub))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node0->process (*open)); ASSERT_EQ (nano::block_status::progress, node0->process (open));
auto send2 = builder auto send2 = builder
.send () .send ()
.previous (open->hash ()) .previous (open->hash ())
@ -462,7 +462,7 @@ TEST (bootstrap_processor, pull_diamond)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*system.work.generate (open->hash ())) .work (*system.work.generate (open->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node0->process (*send2)); ASSERT_EQ (nano::block_status::progress, node0->process (send2));
auto receive = builder auto receive = builder
.receive () .receive ()
.previous (send1->hash ()) .previous (send1->hash ())
@ -470,7 +470,7 @@ TEST (bootstrap_processor, pull_diamond)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ())) .work (*system.work.generate (send1->hash ()))
.build (); .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 (); auto node1 = system.make_disconnected_node ();
node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .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 // open key account receiving all balance of genesis
auto open = builder auto open = builder
@ -552,7 +552,7 @@ TEST (bootstrap_processor, push_diamond)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*system.work.generate (key.pub)) .work (*system.work.generate (key.pub))
.build (); .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 // send from key to genesis 100 raw
auto send2 = builder auto send2 = builder
@ -563,7 +563,7 @@ TEST (bootstrap_processor, push_diamond)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*system.work.generate (open->hash ())) .work (*system.work.generate (open->hash ()))
.build (); .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 // receive the 100 raw on genesis
auto receive = builder auto receive = builder
@ -573,7 +573,7 @@ TEST (bootstrap_processor, push_diamond)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ())) .work (*system.work.generate (send1->hash ()))
.build (); .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 (); nano::node_config config = system.default_config ();
config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); ASSERT_EQ (nano::block_status::progress, node1->process (send1));
// receive all balance on key // receive all balance on key
auto open = builder auto open = builder
@ -625,7 +625,7 @@ TEST (bootstrap_processor, push_diamond_pruning)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*system.work.generate (key.pub)) .work (*system.work.generate (key.pub))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*open)); ASSERT_EQ (nano::block_status::progress, node1->process (open));
// 1st bootstrap // 1st bootstrap
node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false);
@ -643,7 +643,7 @@ TEST (bootstrap_processor, push_diamond_pruning)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*system.work.generate (open->hash ())) .work (*system.work.generate (open->hash ()))
.build (); .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 // receive the 100 raw from key on genesis
auto receive = builder auto receive = builder
@ -653,7 +653,7 @@ TEST (bootstrap_processor, push_diamond_pruning)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ())) .work (*system.work.generate (send1->hash ()))
.build (); .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 ()); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); ASSERT_EQ (nano::block_status::progress, node1->process (send1));
auto send2 = builder auto send2 = builder
.state () .state ()
.account (nano::dev::genesis_key.pub) .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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ())) .work (*system.work.generate (send1->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); ASSERT_EQ (nano::block_status::progress, node1->process (send2));
auto open = builder auto open = builder
.open () .open ()
.source (send1->hash ()) .source (send1->hash ())
@ -1150,7 +1150,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*system.work.generate (key.pub)) .work (*system.work.generate (key.pub))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*open)); ASSERT_EQ (nano::block_status::progress, node1->process (open));
auto receive = builder auto receive = builder
.state () .state ()
.account (key.pub) .account (key.pub)
@ -1161,7 +1161,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*system.work.generate (open->hash ())) .work (*system.work.generate (open->hash ()))
.build (); .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 })); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); ASSERT_EQ (nano::block_status::progress, node1->process (send1));
auto open = builder auto open = builder
.open () .open ()
.source (send1->hash ()) .source (send1->hash ())
@ -1209,7 +1209,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*system.work.generate (key.pub)) .work (*system.work.generate (key.pub))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*open)); ASSERT_EQ (nano::block_status::progress, node1->process (open));
auto send2 = builder auto send2 = builder
.state () .state ()
.account (key.pub) .account (key.pub)
@ -1220,7 +1220,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*system.work.generate (open->hash ())) .work (*system.work.generate (open->hash ()))
.build (); .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 // Start lazy bootstrap with last block in chain known
auto node2 = system.make_disconnected_node (std::nullopt, node_flags); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .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 // send Gxrb_ratio raw from genesis to key2
auto send2 = builder auto send2 = builder
@ -1272,7 +1272,7 @@ TEST (bootstrap_processor, lazy_destinations)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ())) .work (*system.work.generate (send1->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); ASSERT_EQ (nano::block_status::progress, node1->process (send2));
// receive send1 on key1 // receive send1 on key1
auto open = builder auto open = builder
@ -1283,7 +1283,7 @@ TEST (bootstrap_processor, lazy_destinations)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub)) .work (*system.work.generate (key1.pub))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*open)); ASSERT_EQ (nano::block_status::progress, node1->process (open));
// receive send2 on key2 // receive send2 on key2
auto state_open = builder auto state_open = builder
@ -1296,7 +1296,7 @@ TEST (bootstrap_processor, lazy_destinations)
.sign (key2.prv, key2.pub) .sign (key2.prv, key2.pub)
.work (*system.work.generate (key2.pub)) .work (*system.work.generate (key2.pub))
.build (); .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 // Start lazy bootstrap with last block in sender chain
auto node2 = system.make_disconnected_node (std::nullopt, node_flags); auto node2 = system.make_disconnected_node (std::nullopt, node_flags);
@ -1744,7 +1744,7 @@ TEST (frontier_req, count)
.work (0) .work (0)
.build (); .build ();
node1->work_generate_blocking (*send1); 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 auto receive1 = builder
.make_block () .make_block ()
.account (key1.pub) .account (key1.pub)
@ -1756,7 +1756,7 @@ TEST (frontier_req, count)
.work (0) .work (0)
.build (); .build ();
node1->work_generate_blocking (*receive1); 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<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket::endpoint_type_t::server), node1)); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket::endpoint_type_t::server), node1));
auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network); auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
@ -1839,7 +1839,7 @@ TEST (frontier_req, confirmed_frontier)
.work (0) .work (0)
.build (); .build ();
node1->work_generate_blocking (*send1); 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 auto send2 = builder
.make_block () .make_block ()
.account (nano::dev::genesis_key.pub) .account (nano::dev::genesis_key.pub)
@ -1851,7 +1851,7 @@ TEST (frontier_req, confirmed_frontier)
.work (0) .work (0)
.build (); .build ();
node1->work_generate_blocking (*send2); 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 auto receive1 = builder
.make_block () .make_block ()
.account (key_before_genesis.pub) .account (key_before_genesis.pub)
@ -1863,7 +1863,7 @@ TEST (frontier_req, confirmed_frontier)
.work (0) .work (0)
.build (); .build ();
node1->work_generate_blocking (*receive1); 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 auto receive2 = builder
.make_block () .make_block ()
.account (key_after_genesis.pub) .account (key_after_genesis.pub)
@ -1875,7 +1875,7 @@ TEST (frontier_req, confirmed_frontier)
.work (0) .work (0)
.build (); .build ();
node1->work_generate_blocking (*receive2); 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) // Request for all accounts (confirmed only)
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket::endpoint_type_t::server), node1)); auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket::endpoint_type_t::server), node1));

10
nano/core_test/bootstrap_ascending.cpp
View file

@ -171,7 +171,7 @@ TEST (bootstrap_ascending, account_base)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .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); auto & node1 = *system.add_node (flags);
ASSERT_TIMELY (5s, node1.block (send1->hash ()) != nullptr); 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 << "Genesis: " << nano::dev::genesis->hash ().to_string () << std::endl;
// std::cerr << "Send1: " << send1->hash ().to_string () << std::endl; // std::cerr << "Send1: " << send1->hash ().to_string () << std::endl;
// std::cerr << "Send2: " << send2->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 (send1));
ASSERT_EQ (nano::block_status::progress, node0.process (*send2)); ASSERT_EQ (nano::block_status::progress, node0.process (send2));
auto & node1 = *system.add_node (flags); auto & node1 = *system.add_node (flags);
ASSERT_TIMELY (50s, node1.block (send2->hash ()) != nullptr); 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; // std::cerr << "receive1: " << receive1->hash ().to_string () << std::endl;
auto & node1 = *system.add_node (); auto & node1 = *system.add_node ();
// std::cerr << "--------------- Start ---------------\n"; // std::cerr << "--------------- Start ---------------\n";
ASSERT_EQ (nano::block_status::progress, node0.process (*send1)); 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 (receive1));
ASSERT_EQ (node1.store.pending.begin (node1.store.tx_begin_read (), nano::pending_key{ key.pub, 0 }), node1.store.pending.end ()); 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 << "node0: " << node0.network.endpoint () << std::endl;
// std::cerr << "node1: " << node1.network.endpoint () << std::endl; // std::cerr << "node1: " << node1.network.endpoint () << std::endl;

180
nano/core_test/confirmation_height.cpp
View file

@ -199,20 +199,20 @@ TEST (confirmation_height, multiple_accounts)
{ {
auto transaction = node->store.tx_begin_write (); 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));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); 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, send3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1)); 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, open2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open3)); 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, send4));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send5)); 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, receive1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send6)); 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, receive2));
// Check confirmation heights of all the accounts (except genesis) are uninitialized (0), // 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. // 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 // Unpocketed send
{ {
auto transaction = node->store.tx_begin_write (); 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));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1)); 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, send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); 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, send3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send4)); 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, receive2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive3)); 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, send5));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send6)); ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send6));
} }
add_callback_stats (*node); add_callback_stats (*node);
@ -793,14 +793,14 @@ TEST (confirmation_height, send_receive_self)
.build (); .build ();
{ {
auto transaction = node->store.tx_begin_write (); 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));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); 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, send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3)); 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, receive2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive3)); 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, send4));
} }
add_callback_stats (*node); add_callback_stats (*node);
@ -1023,30 +1023,30 @@ TEST (confirmation_height, all_block_types)
{ {
auto transaction (store.tx_begin_write ()); 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, send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); 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, open));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_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, send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_receive)); 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, state_send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive)); 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, change));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_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, epoch));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *epoch1)); 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_send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_receive2)); 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_send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send3)); 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_send4));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_receive3)); ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_receive3));
} }
add_callback_stats (*node); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis_hash)) .work (*system.work.generate (genesis_hash))
.build (); .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_TRUE (nano::test::start_elections (system, *node1, { fork1a }, true));
ASSERT_TIMELY (5s, nano::test::confirmed (*node1, { fork1a })); ASSERT_TIMELY (5s, nano::test::confirmed (*node1, { fork1a }));
@ -1269,7 +1269,7 @@ TEST (confirmation_heightDeathTest, modified_chain)
{ {
auto transaction (store->tx_begin_write ()); auto transaction (store->tx_begin_write ());
store->initialize (transaction, ledger.cache, ledger.constants); 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; 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_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 () }); store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () });
nano::confirmation_height_unbounded unbounded_processor ( nano::confirmation_height_unbounded unbounded_processor (
@ -1356,8 +1356,8 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed)
{ {
auto transaction (store->tx_begin_write ()); auto transaction (store->tx_begin_write ());
store->initialize (transaction, ledger.cache, ledger.constants); 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));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open)); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open));
} }
uint64_t batch_write_size = 2048; 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 // 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 () }); store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () });
nano::confirmation_height_bounded bounded_processor ( nano::confirmation_height_bounded bounded_processor (
@ -1434,8 +1434,8 @@ TEST (confirmation_height, pending_observer_callbacks)
{ {
auto transaction = node->store.tx_begin_write (); 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_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1));
} }
add_callback_stats (*node); add_callback_stats (*node);
@ -1482,7 +1482,7 @@ TEST (confirmation_height, callback_confirmed_history)
.build (); .build ();
{ {
auto transaction = node->store.tx_begin_write (); 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 auto send1 = builder
@ -1586,9 +1586,9 @@ TEST (confirmation_height, dependent_election)
.build (); .build ();
{ {
auto transaction = node->store.tx_begin_write (); 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_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); 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, send2));
} }
add_callback_stats (*node); add_callback_stats (*node);
@ -1729,21 +1729,21 @@ TEST (confirmation_height, cemented_gap_below_receive)
{ {
auto transaction = node->store.tx_begin_write (); 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_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); 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, dummy_send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); 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, receive1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); 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, receive2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send1)); 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, send3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send2)); 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<nano::block_hash> observer_order; std::vector<nano::block_hash> observer_order;
@ -1889,21 +1889,21 @@ TEST (confirmation_height, cemented_gap_below_no_cache)
{ {
auto transaction = node->store.tx_begin_write (); 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_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1)); 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, dummy_send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); 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, receive1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2)); 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, receive2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send1)); 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, send3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send2)); 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 // 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest)) .work (*system.work.generate (latest))
.build (); .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 () auto const send2 = builder.make_block ()
.previous (send1->hash ()) .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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ())) .work (*system.work.generate (send1->hash ()))
.build (); .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 () auto const send3 = builder.make_block ()
.previous (send2->hash ()) .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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send2->hash ())) .work (*system.work.generate (send2->hash ()))
.build (); .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 }); node->process_confirmed (nano::election_status{ send2 });
ASSERT_TIMELY (5s, node->block_confirmed (send2->hash ())); 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 ()); auto transaction (store->tx_begin_write ());
store->initialize (transaction, ledger.cache, nano::dev::constants); 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, send));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1)); 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); 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 ()); auto transaction (store->tx_begin_write ());
store->initialize (transaction, ledger.cache, nano::dev::constants); 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, send1));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1)); 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, send2));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send3)); 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, open2));
} }
uint64_t batch_write_size = 2; uint64_t batch_write_size = 2;
std::atomic<bool> stopped{ false }; std::atomic<bool> stopped{ false };

4
nano/core_test/conflicts.cpp
View file

@ -27,7 +27,7 @@ TEST (conflicts, start_stop)
.work (0) .work (0)
.build (); .build ();
node1.work_generate_blocking (*send1); 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 ()); ASSERT_EQ (0, node1.active.size ());
node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ())); ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ()));
@ -56,7 +56,7 @@ TEST (conflicts, add_existing)
node1.work_generate_blocking (*send1); node1.work_generate_blocking (*send1);
// add the block to ledger as an unconfirmed block // 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 // wait for send1 to be inserted in the ledger
ASSERT_TIMELY (5s, node1.block (send1->hash ())); ASSERT_TIMELY (5s, node1.block (send1->hash ()));

4
nano/core_test/election.cpp
View file

@ -224,7 +224,7 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks)
ASSERT_TIMELY (5s, node1.block (send1->hash ()) != nullptr); 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 (); 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; nano::keypair key2;
auto const send2 = builder.make_block () auto const send2 = builder.make_block ()
@ -234,7 +234,7 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*system.work.generate (open1->hash ())) .work (*system.work.generate (open1->hash ()))
.build (); .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); ASSERT_TIMELY_EQ (5s, node1.ledger.cache.block_count, 4);
node_config.peering_port = system.get_available_port (); node_config.peering_port = system.get_available_port ();

12
nano/core_test/election_scheduler.cpp
View file

@ -27,7 +27,7 @@ TEST (election_scheduler, activate_one_timely)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .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 ()); 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 ())); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .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 ()); 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 ())); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .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 }); node.process_confirmed (nano::election_status{ send });
auto receive = builder.make_block () auto receive = builder.make_block ()
@ -99,7 +99,7 @@ TEST (election_scheduler, no_vacancy)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*system.work.generate (key.pub)) .work (*system.work.generate (key.pub))
.build (); .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 }); node.process_confirmed (nano::election_status{ receive });
// Second, process two eligible transactions // 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send->hash ())) .work (*system.work.generate (send->hash ()))
.build (); .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 // There is vacancy so it should be inserted
node.scheduler.priority.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); 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) .sign (key.prv, key.pub)
.work (*system.work.generate (receive->hash ())) .work (*system.work.generate (receive->hash ()))
.build (); .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 // There is no vacancy so it should stay queued
node.scheduler.priority.activate (key.pub, node.store.tx_begin_read ()); node.scheduler.priority.activate (key.pub, node.store.tx_begin_read ());

6
nano/core_test/frontiers_confirmation.cpp
View file

@ -29,7 +29,7 @@ TEST (frontiers_confirmation, mode)
.build (); .build ();
{ {
auto transaction = node->store.tx_begin_write (); 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); ASSERT_TIMELY_EQ (5s, node->active.size (), 1);
} }
@ -51,7 +51,7 @@ TEST (frontiers_confirmation, mode)
.build (); .build ();
{ {
auto transaction = node->store.tx_begin_write (); 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); ASSERT_TIMELY_EQ (5s, node->active.size (), 1);
} }
@ -73,7 +73,7 @@ TEST (frontiers_confirmation, mode)
.build (); .build ();
{ {
auto transaction = node->store.tx_begin_write (); 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); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
std::this_thread::sleep_for (std::chrono::seconds (1)); std::this_thread::sleep_for (std::chrono::seconds (1));

618
nano/core_test/ledger.cpp
View file

File diff suppressed because it is too large Load diff

4
nano/core_test/network.cpp
View file

@ -366,7 +366,7 @@ TEST (receivable_processor, confirm_insufficient_pos)
.work (0) .work (0)
.build (); .build ();
node1.work_generate_blocking (*block1); 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 ()); node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
nano::keypair key1; nano::keypair key1;
auto vote = nano::test::make_vote (key1, { block1 }, 0, 0); auto vote = nano::test::make_vote (key1, { block1 }, 0, 0);
@ -389,7 +389,7 @@ TEST (receivable_processor, confirm_sufficient_pos)
.work (0) .work (0)
.build (); .build ();
node1.work_generate_blocking (*block1); 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 ()); 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); auto vote = nano::test::make_vote (nano::dev::genesis_key, { block1 }, 0, 0);
nano::confirm_ack con1{ nano::dev::network_params.network, vote }; nano::confirm_ack con1{ nano::dev::network_params.network, vote };

190
nano/core_test/node.cpp
View file

@ -771,10 +771,10 @@ TEST (node, fork_multi_flip)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send2->hash ())) .work (*system.work.generate (send2->hash ()))
.build (); .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 // 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 (), 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 (), send3));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); // Insert voting key in to node1 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 ()); auto election = nano::test::start_election (system, node2, send2->hash ());
@ -821,8 +821,8 @@ TEST (node, fork_bootstrap_flip)
.work (*system0.work.generate (latest)) .work (*system0.work.generate (latest))
.build (); .build ();
// Insert but don't rebroadcast, simulating settled blocks // 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, 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, node2.ledger.process (node2.store.tx_begin_write (), send2));
ASSERT_TRUE (node2.store.block.exists (node2.store.tx_begin_read (), send2->hash ())); 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 node2.bootstrap_initiator.bootstrap (node1.network.endpoint ()); // Additionally add new peer to confirm & replace bootstrap block
auto again (true); auto again (true);
@ -1033,9 +1033,9 @@ TEST (node, fork_no_vote_quorum)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (block->hash ())) .work (*system.work.generate (block->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1.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, node2.process (send1));
ASSERT_EQ (nano::block_status::progress, node3.process (*send1)); ASSERT_EQ (nano::block_status::progress, node3.process (send1));
auto key2 (system.wallet (2)->deterministic_insert ()); auto key2 (system.wallet (2)->deterministic_insert ());
auto send2 = nano::send_block_builder () auto send2 = nano::send_block_builder ()
.previous (block->hash ()) .previous (block->hash ())
@ -1181,9 +1181,9 @@ TEST (node, DISABLED_fork_stale)
node1.work_generate_blocking (*send2); node1.work_generate_blocking (*send2);
{ {
auto transaction1 (node1.store.tx_begin_write ()); 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 ()); 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 (send1);
node1.process_active (send2); node1.process_active (send2);
@ -1220,43 +1220,43 @@ TEST (node, DISABLED_broadcast_elected)
auto transaction0 (node0->store.tx_begin_write ()); auto transaction0 (node0->store.tx_begin_write ());
auto transaction1 (node1->store.tx_begin_write ()); auto transaction1 (node1->store.tx_begin_write ());
auto transaction2 (node2->store.tx_begin_write ()); auto transaction2 (node2->store.tx_begin_write ());
auto fund_big = *builder.send () auto fund_big = builder.send ()
.previous (nano::dev::genesis->hash ()) .previous (nano::dev::genesis->hash ())
.destination (rep_big.pub) .destination (rep_big.pub)
.balance (nano::Gxrb_ratio * 5) .balance (nano::Gxrb_ratio * 5)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .build ();
auto open_big = *builder.open () auto open_big = builder.open ()
.source (fund_big.hash ()) .source (fund_big->hash ())
.representative (rep_big.pub) .representative (rep_big.pub)
.account (rep_big.pub) .account (rep_big.pub)
.sign (rep_big.prv, rep_big.pub) .sign (rep_big.prv, rep_big.pub)
.work (*system.work.generate (rep_big.pub)) .work (*system.work.generate (rep_big.pub))
.build (); .build ();
auto fund_small = *builder.send () auto fund_small = builder.send ()
.previous (fund_big.hash ()) .previous (fund_big->hash ())
.destination (rep_small.pub) .destination (rep_small.pub)
.balance (nano::Gxrb_ratio * 2) .balance (nano::Gxrb_ratio * 2)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (fund_big.hash ())) .work (*system.work.generate (fund_big->hash ()))
.build (); .build ();
auto open_small = *builder.open () auto open_small = builder.open ()
.source (fund_small.hash ()) .source (fund_small->hash ())
.representative (rep_small.pub) .representative (rep_small.pub)
.account (rep_small.pub) .account (rep_small.pub)
.sign (rep_small.prv, rep_small.pub) .sign (rep_small.prv, rep_small.pub)
.work (*system.work.generate (rep_small.pub)) .work (*system.work.generate (rep_small.pub))
.build (); .build ();
auto fund_other = *builder.send () auto fund_other = builder.send ()
.previous (fund_small.hash ()) .previous (fund_small->hash ())
.destination (rep_other.pub) .destination (rep_other.pub)
.balance (nano::Gxrb_ratio) .balance (nano::Gxrb_ratio)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (fund_small.hash ())) .work (*system.work.generate (fund_small->hash ()))
.build (); .build ();
auto open_other = *builder.open () auto open_other = builder.open ()
.source (fund_other.hash ()) .source (fund_other->hash ())
.representative (rep_other.pub) .representative (rep_other.pub)
.account (rep_other.pub) .account (rep_other.pub)
.sign (rep_other.prv, rep_other.pub) .sign (rep_other.prv, rep_other.pub)
@ -1337,15 +1337,15 @@ TEST (node, rep_self_vote)
auto node0 = system.add_node (node_config); auto node0 = system.add_node (node_config);
nano::keypair rep_big; nano::keypair rep_big;
nano::block_builder builder; nano::block_builder builder;
auto fund_big = *builder.send () auto fund_big = builder.send ()
.previous (nano::dev::genesis->hash ()) .previous (nano::dev::genesis->hash ())
.destination (rep_big.pub) .destination (rep_big.pub)
.balance (nano::uint128_t{ "0xb0000000000000000000000000000000" }) .balance (nano::uint128_t{ "0xb0000000000000000000000000000000" })
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .build ();
auto open_big = *builder.open () auto open_big = builder.open ()
.source (fund_big.hash ()) .source (fund_big->hash ())
.representative (rep_big.pub) .representative (rep_big.pub)
.account (rep_big.pub) .account (rep_big.pub)
.sign (rep_big.prv, rep_big.pub) .sign (rep_big.prv, rep_big.pub)
@ -1354,22 +1354,22 @@ TEST (node, rep_self_vote)
ASSERT_EQ (nano::block_status::progress, node0->process (fund_big)); ASSERT_EQ (nano::block_status::progress, node0->process (fund_big));
ASSERT_EQ (nano::block_status::progress, node0->process (open_big)); ASSERT_EQ (nano::block_status::progress, node0->process (open_big));
// Confirm both blocks, allowing voting on the upcoming block // 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<nano::election> election; std::shared_ptr<nano::election> 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 (); election->force_confirm ();
system.wallet (0)->insert_adhoc (rep_big.prv); system.wallet (0)->insert_adhoc (rep_big.prv);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
ASSERT_EQ (system.wallet (0)->wallets.reps ().voting, 2); ASSERT_EQ (system.wallet (0)->wallets.reps ().voting, 2);
auto block0 = builder.send () auto block0 = builder.send ()
.previous (fund_big.hash ()) .previous (fund_big->hash ())
.destination (rep_big.pub) .destination (rep_big.pub)
.balance (nano::uint128_t ("0x60000000000000000000000000000000")) .balance (nano::uint128_t ("0x60000000000000000000000000000000"))
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (fund_big.hash ())) .work (*system.work.generate (fund_big->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node0->process (*block0)); ASSERT_EQ (nano::block_status::progress, node0->process (block0));
auto & active = node0->active; auto & active = node0->active;
auto & scheduler = node0->scheduler; auto & scheduler = node0->scheduler;
scheduler.priority.activate (nano::dev::genesis_key.pub, node0->store.tx_begin_read ()); scheduler.priority.activate (nano::dev::genesis_key.pub, node0->store.tx_begin_read ());
@ -1403,7 +1403,7 @@ TEST (node, DISABLED_bootstrap_no_publish)
.build (); .build ();
{ {
auto transaction (node0->store.tx_begin_write ()); 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 ()); ASSERT_FALSE (node1->bootstrap_initiator.in_progress ());
node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) .work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
.build (); .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 (node0->bootstrap_initiator.in_progress ());
ASSERT_FALSE (node1->bootstrap_initiator.in_progress ()); ASSERT_FALSE (node1->bootstrap_initiator.in_progress ());
@ -1475,22 +1475,22 @@ TEST (node, bootstrap_fork_open)
auto node1 = system.add_node (node_config); auto node1 = system.add_node (node_config);
nano::keypair key0; nano::keypair key0;
nano::block_builder builder; nano::block_builder builder;
auto send0 = *builder.send () auto send0 = builder.send ()
.previous (nano::dev::genesis->hash ()) .previous (nano::dev::genesis->hash ())
.destination (key0.pub) .destination (key0.pub)
.balance (nano::dev::constants.genesis_amount - 500) .balance (nano::dev::constants.genesis_amount - 500)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .build ();
auto open0 = *builder.open () auto open0 = builder.open ()
.source (send0.hash ()) .source (send0->hash ())
.representative (1) .representative (1)
.account (key0.pub) .account (key0.pub)
.sign (key0.prv, key0.pub) .sign (key0.prv, key0.pub)
.work (*system.work.generate (key0.pub)) .work (*system.work.generate (key0.pub))
.build (); .build ();
auto open1 = *builder.open () auto open1 = builder.open ()
.source (send0.hash ()) .source (send0->hash ())
.representative (2) .representative (2)
.account (key0.pub) .account (key0.pub)
.sign (key0.prv, key0.pub) .sign (key0.prv, key0.pub)
@ -1503,22 +1503,22 @@ TEST (node, bootstrap_fork_open)
for (auto node : system.nodes) for (auto node : system.nodes)
{ {
node->start_election (node->block (node->latest (nano::dev::genesis_key.pub))); node->start_election (node->block (node->latest (nano::dev::genesis_key.pub)));
ASSERT_TIMELY (1s, node->active.election (send0.qualified_root ())); ASSERT_TIMELY (1s, node->active.election (send0->qualified_root ()));
auto election = node->active.election (send0.qualified_root ()); auto election = node->active.election (send0->qualified_root ());
ASSERT_NE (nullptr, election); ASSERT_NE (nullptr, election);
election->force_confirm (); election->force_confirm ();
ASSERT_TIMELY (2s, node->active.empty ()); 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 // They disagree about open0/open1
ASSERT_EQ (nano::block_status::progress, node0->process (open0)); ASSERT_EQ (nano::block_status::progress, node0->process (open0));
ASSERT_EQ (nano::block_status::progress, node1->process (open1)); ASSERT_EQ (nano::block_status::progress, node1->process (open1));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); 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 ()); ASSERT_FALSE (node1->bootstrap_initiator.in_progress ());
node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false);
ASSERT_TIMELY (1s, node1->active.empty ()); 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 // 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) .work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
.build (); .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 // each system only has one node, so there should be no bootstrapping going on
ASSERT_FALSE (node0->bootstrap_initiator.in_progress ()); ASSERT_FALSE (node0->bootstrap_initiator.in_progress ());
@ -1598,7 +1598,7 @@ TEST (node, unconfirmed_send)
.sign (key2.prv, key2.pub) .sign (key2.prv, key2.pub)
.work (*system.work.generate (recv1->hash ())) .work (*system.work.generate (recv1->hash ()))
.build (); .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); auto send3 = wallet2->send_action (key2.pub, nano::dev::genesis->account (), nano::Mxrb_ratio);
ASSERT_TIMELY (5s, node2.block_confirmed (send2->hash ())); ASSERT_TIMELY (5s, node2.block_confirmed (send2->hash ()));
@ -1698,10 +1698,10 @@ TEST (node, rep_weight)
.build (); .build ();
{ {
auto transaction = node.store.tx_begin_write (); 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, block1));
ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *block2)); 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, block3));
ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *block4)); ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, block4));
} }
ASSERT_TRUE (node.rep_crawler.representatives (1).empty ()); ASSERT_TRUE (node.rep_crawler.representatives (1).empty ());
std::shared_ptr<nano::transport::channel> channel1 = nano::test::establish_tcp (system, node, node1.network.endpoint ()); std::shared_ptr<nano::transport::channel> channel1 = nano::test::establish_tcp (system, node, node1.network.endpoint ());
@ -1788,10 +1788,10 @@ TEST (node, rep_remove)
.build (); .build ();
{ {
auto transaction = searching_node.store.tx_begin_write (); 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, 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, 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, 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, receive_rep2));
} }
// Create channel for Rep1 // Create channel for Rep1
@ -2127,7 +2127,7 @@ TEST (node, confirm_quorum)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1.work_generate_blocking (nano::dev::genesis->hash ())) .work (*node1.work_generate_blocking (nano::dev::genesis->hash ()))
.build (); .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 ()); 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 ())); ASSERT_TIMELY (2s, node1.active.election (send1->qualified_root ()));
auto election = node1.active.election (send1->qualified_root ()); auto election = node1.active.election (send1->qualified_root ());
@ -2174,8 +2174,8 @@ TEST (node, local_votes_cache)
.build (); .build ();
{ {
auto transaction (node.store.tx_begin_write ()); 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));
ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *send2)); ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, send2));
} }
// Confirm blocks to allow voting // Confirm blocks to allow voting
node.start_election (send2); node.start_election (send2);
@ -2205,7 +2205,7 @@ TEST (node, local_votes_cache)
// Max cache // Max cache
{ {
auto transaction (node.store.tx_begin_write ()); 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 () }; nano::confirm_req message3{ nano::dev::network_params.network, send3->hash (), send3->root () };
for (auto i (0); i < 100; ++i) 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build (); .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); node.confirmation_height_processor.add (send1);
ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ())); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ()));
auto send2 = nano::state_block_builder () 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (send1->hash ())) .work (*node.work_generate_blocking (send1->hash ()))
.build (); .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 () auto receive1 = nano::state_block_builder ()
.account (key1.pub) .account (key1.pub)
.previous (0) .previous (0)
@ -2265,7 +2265,7 @@ TEST (node, DISABLED_local_votes_cache_batch)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*node.work_generate_blocking (key1.pub)) .work (*node.work_generate_blocking (key1.pub))
.build (); .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<std::pair<nano::block_hash, nano::root>> batch{ { send2->hash (), send2->root () }, { receive1->hash (), receive1->root () } }; std::vector<std::pair<nano::block_hash, nano::root>> batch{ { send2->hash (), send2->root () }, { receive1->hash (), receive1->root () } };
nano::confirm_req message{ nano::dev::network_params.network, batch }; nano::confirm_req message{ nano::dev::network_params.network, batch };
auto channel = std::make_shared<nano::transport::fake::channel> (node); auto channel = std::make_shared<nano::transport::fake::channel> (node);
@ -2328,7 +2328,7 @@ TEST (node, local_votes_cache_generate_new_vote)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build (); .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 // One of the hashes is cached
std::vector<std::pair<nano::block_hash, nano::root>> roots_hashes{ std::make_pair (nano::dev::genesis->hash (), nano::dev::genesis->root ()), std::make_pair (send1->hash (), send1->root ()) }; std::vector<std::pair<nano::block_hash, nano::root>> 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 }; 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1.work_generate_blocking (nano::dev::genesis->hash ())) .work (*node1.work_generate_blocking (nano::dev::genesis->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); ASSERT_EQ (nano::block_status::progress, node1.process (send1));
// Cache vote // Cache vote
auto vote = nano::test::make_vote (nano::dev::genesis_key, { send1 }, 0, 0); auto vote = nano::test::make_vote (nano::dev::genesis_key, { send1 }, 0, 0);
node1.vote_processor.vote (vote, std::make_shared<nano::transport::fake::channel> (node1)); node1.vote_processor.vote (vote, std::make_shared<nano::transport::fake::channel> (node1));
@ -2468,7 +2468,7 @@ TEST (node, vote_by_hash_bundle)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .build ();
blocks.push_back (block); 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) for (auto i = 2; i < 200; ++i)
{ {
auto block = builder.make_block () auto block = builder.make_block ()
@ -2479,7 +2479,7 @@ TEST (node, vote_by_hash_bundle)
.work (*system.work.generate (blocks.back ()->hash ())) .work (*system.work.generate (blocks.back ()->hash ()))
.build (); .build ();
blocks.push_back (block); 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 // 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) .sign (key.prv, key.pub)
.build (); .build ();
// Set 'node' up with losing block 'fork1a' // Set 'node' up with losing block 'fork1a'
ASSERT_EQ (nano::block_status::progress, node.process (*send1)); 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 (fork1a));
// Node has 'fork1a' & doesn't have source 'send2' for winning 'fork1b' block // Node has 'fork1a' & doesn't have source 'send2' for winning 'fork1b' block
ASSERT_EQ (nullptr, node.block (send2->hash ())); ASSERT_EQ (nullptr, node.block (send2->hash ()));
node.block_processor.force (fork1b); node.block_processor.force (fork1b);
@ -3457,7 +3457,7 @@ TEST (node, rollback_gap_source)
node.process_active (fork1a); node.process_active (fork1a);
ASSERT_TIMELY (5s, node.block (fork1a->hash ()) != nullptr); ASSERT_TIMELY (5s, node.block (fork1a->hash ()) != nullptr);
// With send2 block in ledger election can start again to remove fork block // 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); node.block_processor.force (fork1b);
// Wait for new rollback // Wait for new rollback
ASSERT_TIMELY_EQ (5s, node.stats.count (nano::stat::type::rollback, nano::stat::detail::open), 2); 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 ())) .work (*system.work.generate (key3_receive->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node.process (*gen_send1)); 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_open));
ASSERT_EQ (nano::block_status::progress, node.process (*key1_send1)); 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_receive));
ASSERT_EQ (nano::block_status::progress, node.process (*gen_send2)); 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_open));
ASSERT_EQ (nano::block_status::progress, node.process (*key2_send1)); 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 (key3_open));
ASSERT_EQ (nano::block_status::progress, node.process (*key2_send2)); 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_receive));
ASSERT_EQ (nano::block_status::progress, node.process (*key1_send2)); 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_receive));
ASSERT_EQ (nano::block_status::progress, node.process (*key3_epoch)); ASSERT_EQ (nano::block_status::progress, node.process (key3_epoch));
ASSERT_TRUE (node.active.empty ()); ASSERT_TRUE (node.active.empty ());
// Hash -> Ancestors // Hash -> Ancestors
@ -3805,19 +3805,19 @@ TEST (node, dependency_graph_frontier)
for (auto const & node : system.nodes) for (auto const & node : system.nodes)
{ {
auto transaction (node->store.tx_begin_write ()); 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, 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_open));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key1_send1)); 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_receive));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *gen_send2)); 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_open));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key2_send1)); 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, key3_open));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key2_send2)); 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_receive));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key1_send2)); 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_receive));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key3_epoch)); ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, key3_epoch));
} }
// node1 can vote, but only on the first block // node1 can vote, but only on the first block
@ -3931,7 +3931,7 @@ TEST (node, deferred_dependent_elections)
ASSERT_NE (nullptr, election_open); 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 // 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 ())); ASSERT_FALSE (node.active.active (receive->qualified_root ()));
election_open->force_confirm (); election_open->force_confirm ();
ASSERT_TIMELY (5s, node.block_confirmed (open->hash ())); 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 ())); ASSERT_NEVER (0.5s, node.active.active (receive->qualified_root ()));
// Processing a fork will also not start an election // 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); node.process_local (fork);
ASSERT_NEVER (0.5s, node.active.active (receive->qualified_root ())); ASSERT_NEVER (0.5s, node.active.active (receive->qualified_root ()));

6
nano/core_test/processor_service.cpp
View file

@ -32,7 +32,7 @@ TEST (processor_service, bad_send_signature)
.work (*pool.generate (info1->head)) .work (*pool.generate (info1->head))
.build (); .build ();
send->signature.bytes[32] ^= 0x1; 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) TEST (processor_service, bad_receive_signature)
@ -57,7 +57,7 @@ TEST (processor_service, bad_receive_signature)
.work (*pool.generate (info1->head)) .work (*pool.generate (info1->head))
.build (); .build ();
nano::block_hash hash1 (send->hash ()); 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); auto info2 = ledger.account_info (transaction, nano::dev::genesis_key.pub);
ASSERT_TRUE (info2); ASSERT_TRUE (info2);
auto receive = builder auto receive = builder
@ -68,5 +68,5 @@ TEST (processor_service, bad_receive_signature)
.work (*pool.generate (hash1)) .work (*pool.generate (hash1))
.build (); .build ();
receive->signature.bytes[32] ^= 0x1; 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));
} }

30
nano/core_test/request_aggregator.cpp
View file

@ -36,7 +36,7 @@ TEST (request_aggregator, one)
ASSERT_TIMELY (3s, node.aggregator.empty ()); ASSERT_TIMELY (3s, node.aggregator.empty ());
// Not yet in the ledger // Not yet in the ledger
ASSERT_TIMELY_EQ (3s, 1, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_unknown)); 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); node.aggregator.add (dummy_channel, request);
ASSERT_EQ (1, node.aggregator.size ()); ASSERT_EQ (1, node.aggregator.size ());
// In the ledger but no vote generated yet // 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build (); .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); node.confirmation_height_processor.add (send1);
ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ())); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ()));
auto send2 = nano::state_block_builder () 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (send1->hash ())) .work (*node.work_generate_blocking (send1->hash ()))
.build (); .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 () auto receive1 = nano::state_block_builder ()
.account (key1.pub) .account (key1.pub)
.previous (0) .previous (0)
@ -95,7 +95,7 @@ TEST (request_aggregator, one_update)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*node.work_generate_blocking (key1.pub)) .work (*node.work_generate_blocking (key1.pub))
.build (); .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<std::pair<nano::block_hash, nano::root>> request; std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send2->hash (), send2->root ()); request.emplace_back (send2->hash (), send2->root ());
auto client = std::make_shared<nano::transport::socket> (node); auto client = std::make_shared<nano::transport::socket> (node);
@ -139,7 +139,7 @@ TEST (request_aggregator, two)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build (); .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); node.confirmation_height_processor.add (send1);
ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ())); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ()));
auto send2 = builder.make_block () auto send2 = builder.make_block ()
@ -160,8 +160,8 @@ TEST (request_aggregator, two)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*node.work_generate_blocking (key1.pub)) .work (*node.work_generate_blocking (key1.pub))
.build (); .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));
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<std::pair<nano::block_hash, nano::root>> request; std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send2->hash (), send2->root ()); request.emplace_back (send2->hash (), send2->root ());
request.emplace_back (receive1->hash (), receive1->root ()); request.emplace_back (receive1->hash (), receive1->root ());
@ -218,7 +218,7 @@ TEST (request_aggregator, two_endpoints)
.build (); .build ();
std::vector<std::pair<nano::block_hash, nano::root>> request; std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send1->hash (), send1->root ()); 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<nano::transport::inproc::channel> (node1, node1); auto dummy_channel1 = std::make_shared<nano::transport::inproc::channel> (node1, node1);
auto dummy_channel2 = std::make_shared<nano::transport::inproc::channel> (node2, node2); auto dummy_channel2 = std::make_shared<nano::transport::inproc::channel> (node2, node2);
ASSERT_NE (nano::transport::map_endpoint_to_v6 (dummy_channel1->get_endpoint ()), nano::transport::map_endpoint_to_v6 (dummy_channel2->get_endpoint ())); 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 ()); .build ());
auto const & block = blocks.back (); auto const & block = blocks.back ();
previous = block->hash (); 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 ()); request.emplace_back (block->hash (), block->root ());
} }
// Confirm all blocks // Confirm all blocks
@ -325,7 +325,7 @@ TEST (request_aggregator, channel_lifetime)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build (); .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<std::pair<nano::block_hash, nano::root>> request; std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send1->hash (), send1->root ()); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build (); .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<std::pair<nano::block_hash, nano::root>> request; std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send1->hash (), send1->root ()); request.emplace_back (send1->hash (), send1->root ());
std::weak_ptr<nano::transport::channel> channel1_w; std::weak_ptr<nano::transport::channel> channel1_w;
@ -396,7 +396,7 @@ TEST (request_aggregator, channel_max_queue)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build (); .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<std::pair<nano::block_hash, nano::root>> request; std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send1->hash (), send1->root ()); request.emplace_back (send1->hash (), send1->root ());
auto client = std::make_shared<nano::transport::socket> (node); auto client = std::make_shared<nano::transport::socket> (node);
@ -424,7 +424,7 @@ TEST (request_aggregator, unique)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build (); .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<std::pair<nano::block_hash, nano::root>> request; std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send1->hash (), send1->root ()); request.emplace_back (send1->hash (), send1->root ());
auto client = std::make_shared<nano::transport::socket> (node); auto client = std::make_shared<nano::transport::socket> (node);
@ -464,8 +464,8 @@ TEST (request_aggregator, cannot_vote)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ())) .work (*system.work.generate (send1->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node.process (*send1)); 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 (send2));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
ASSERT_FALSE (node.ledger.dependents_confirmed (node.store.tx_begin_read (), *send2)); ASSERT_FALSE (node.ledger.dependents_confirmed (node.store.tx_begin_read (), *send2));

4
nano/core_test/system.cpp
View file

@ -60,7 +60,7 @@ TEST (system, DISABLED_generate_send_existing)
.work (0) .work (0)
.build (); .build ();
node1.work_generate_blocking (*open_block); 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 ())); 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); 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) .work (0)
.build (); .build ();
node1.work_generate_blocking (*open_block); 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 ())); ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::dev::genesis->account ()));
std::vector<nano::account> accounts; std::vector<nano::account> accounts;

8
nano/core_test/voting.cpp
View file

@ -168,12 +168,12 @@ TEST (vote_spacing, vote_generator)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .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)); 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 ()); 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_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_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 ()); 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, 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)); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .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 ()); 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_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_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 ()); 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, 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)); ASSERT_TIMELY_EQ (3s, 1, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts));

4
nano/core_test/wallet.cpp
View file

@ -1114,7 +1114,7 @@ TEST (wallet, epoch_2_receive_unopened)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (key.pub, node.network_params.work.epoch_2)) .work (*system.work.generate (key.pub, node.network_params.work.epoch_2))
.build (); .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); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .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 // Pending search should start an election
ASSERT_TRUE (node.active.empty ()); ASSERT_TRUE (node.active.empty ());

10
nano/core_test/wallets.cpp
View file

@ -110,7 +110,7 @@ TEST (wallets, vote_minimum)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1.process (*send1)); ASSERT_EQ (nano::block_status::progress, node1.process (send1));
auto open1 = builder auto open1 = builder
.state () .state ()
.account (key1.pub) .account (key1.pub)
@ -121,7 +121,7 @@ TEST (wallets, vote_minimum)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub)) .work (*system.work.generate (key1.pub))
.build (); .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) // send2 with amount vote_minimum - 1 (not voting representative)
auto send2 = builder auto send2 = builder
.state () .state ()
@ -133,7 +133,7 @@ TEST (wallets, vote_minimum)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ())) .work (*system.work.generate (send1->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1.process (*send2)); ASSERT_EQ (nano::block_status::progress, node1.process (send2));
auto open2 = builder auto open2 = builder
.state () .state ()
.account (key2.pub) .account (key2.pub)
@ -144,7 +144,7 @@ TEST (wallets, vote_minimum)
.sign (key2.prv, key2.pub) .sign (key2.prv, key2.pub)
.work (*system.work.generate (key2.pub)) .work (*system.work.generate (key2.pub))
.build (); .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); auto wallet (node1.wallets.items.begin ()->second);
nano::unique_lock<nano::mutex> representatives_lk (wallet->representatives_mutex); nano::unique_lock<nano::mutex> representatives_lk (wallet->representatives_mutex);
ASSERT_EQ (0, wallet->representatives.size ()); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .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 // Pending search should start an election
ASSERT_TRUE (node.active.empty ()); ASSERT_TRUE (node.active.empty ());

4
nano/nano_node/entry.cpp
View file

@ -1029,7 +1029,7 @@ int main (int argc, char * const * argv)
.build (); .build ();
genesis_latest = send->hash (); genesis_latest = send->hash ();
node->ledger.process (transaction, *send); node->ledger.process (transaction, send);
auto open = builder.state () auto open = builder.state ()
.account (keys[i].pub) .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)) .work (*node->work.generate (nano::work_version::work_1, keys[i].pub, node->network_params.work.epoch_1))
.build (); .build ();
node->ledger.process (transaction, *open); node->ledger.process (transaction, open);
} }
// Generating blocks // Generating blocks
std::deque<std::shared_ptr<nano::block>> blocks; std::deque<std::shared_ptr<nano::block>> blocks;

4
nano/node/blockprocessor.cpp
View file

@ -314,9 +314,9 @@ auto nano::block_processor::process_batch (nano::unique_lock<nano::mutex> & lock
nano::block_status nano::block_processor::process_one (store::write_transaction const & transaction_a, context const & context, bool const forced_a) 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 (); 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_result, to_stat_detail (result));
node.stats.inc (nano::stat::type::blockprocessor_source, to_stat_detail (context.source)); node.stats.inc (nano::stat::type::blockprocessor_source, to_stat_detail (context.source));

4
nano/node/node.cpp
View file

@ -559,12 +559,12 @@ void nano::node::process_active (std::shared_ptr<nano::block> const & incoming)
block_processor.add (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<nano::block> block)
{ {
return ledger.process (transaction, block); return ledger.process (transaction, block);
} }
nano::block_status nano::node::process (nano::block & block) nano::block_status nano::node::process (std::shared_ptr<nano::block> block)
{ {
auto const transaction = store.tx_begin_write ({ tables::accounts, tables::blocks, tables::frontiers, tables::pending }); auto const transaction = store.tx_begin_write ({ tables::accounts, tables::blocks, tables::frontiers, tables::pending });
return process (transaction, block); return process (transaction, block);

4
nano/node/node.hpp
View file

@ -210,8 +210,8 @@ public: // Testing convenience functions
Creates a new write transaction and inserts `block' and returns result Creates a new write transaction and inserts `block' and returns result
Transaction is comitted before function return Transaction is comitted before function return
*/ */
[[nodiscard]] nano::block_status process (nano::block & block); [[nodiscard]] nano::block_status process (std::shared_ptr<nano::block> block);
[[nodiscard]] nano::block_status process (store::write_transaction const &, nano::block & block); [[nodiscard]] nano::block_status process (store::write_transaction const &, std::shared_ptr<nano::block> block);
nano::block_hash latest (nano::account const &); nano::block_hash latest (nano::account const &);
nano::uint128_t balance (nano::account const &); nano::uint128_t balance (nano::account const &);

40
nano/qt_test/qt.cpp
View file

@ -424,8 +424,8 @@ TEST (wallet, create_send)
bool error (false); bool error (false);
auto send = std::make_shared<nano::state_block> (error, tree1); auto send = std::make_shared<nano::state_block> (error, tree1);
ASSERT_FALSE (error); ASSERT_FALSE (error);
ASSERT_EQ (nano::block_status::progress, 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)); ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (send));
} }
TEST (wallet, create_open_receive) TEST (wallet, create_open_receive)
@ -458,8 +458,8 @@ TEST (wallet, create_open_receive)
bool error (false); bool error (false);
auto open = std::make_shared<nano::state_block> (error, tree1); auto open = std::make_shared<nano::state_block> (error, tree1);
ASSERT_FALSE (error); ASSERT_FALSE (error);
ASSERT_EQ (nano::block_status::progress, 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)); ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (open));
wallet->block_creation.block->clear (); wallet->block_creation.block->clear ();
wallet->block_creation.source->clear (); wallet->block_creation.source->clear ();
wallet->block_creation.receive->click (); wallet->block_creation.receive->click ();
@ -473,8 +473,8 @@ TEST (wallet, create_open_receive)
bool error2 (false); bool error2 (false);
auto receive = std::make_shared<nano::state_block> (error2, tree2); auto receive = std::make_shared<nano::state_block> (error2, tree2);
ASSERT_FALSE (error2); ASSERT_FALSE (error2);
ASSERT_EQ (nano::block_status::progress, 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)); ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (receive));
} }
TEST (wallet, create_change) TEST (wallet, create_change)
@ -501,8 +501,8 @@ TEST (wallet, create_change)
bool error (false); bool error (false);
auto change = std::make_shared<nano::state_block> (error, tree1); auto change = std::make_shared<nano::state_block> (error, tree1);
ASSERT_FALSE (error); ASSERT_FALSE (error);
ASSERT_EQ (nano::block_status::progress, 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)); ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (change));
} }
TEST (history, short_text) TEST (history, short_text)
@ -532,11 +532,11 @@ TEST (history, short_text)
nano::keypair key; nano::keypair key;
auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub)); auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub));
auto send = std::make_shared<nano::send_block> (latest, nano::dev::genesis_key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); auto send = std::make_shared<nano::send_block> (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<nano::receive_block> (send->hash (), send->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send->hash ())); auto receive = std::make_shared<nano::receive_block> (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<nano::change_block> (receive->hash (), key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive->hash ())); auto change = std::make_shared<nano::change_block> (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); nano_qt::history history (ledger, nano::dev::genesis_key.pub, *wallet);
history.refresh (); history.refresh ();
@ -572,13 +572,13 @@ TEST (history, pruned_source)
store->initialize (transaction, ledger.cache, nano::dev::constants); store->initialize (transaction, ledger.cache, nano::dev::constants);
auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub)); auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub));
auto send1 = std::make_shared<nano::send_block> (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)); auto send1 = std::make_shared<nano::send_block> (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<nano::send_block> (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 ())); auto send2 = std::make_shared<nano::send_block> (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<nano::receive_block> (send2->hash (), send1->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2->hash ())); auto receive = std::make_shared<nano::receive_block> (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<nano::open_block> (send2->hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); auto open = std::make_shared<nano::open_block> (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)); ASSERT_EQ (1, ledger.pruning_action (transaction, send1->hash (), 2));
next_pruning = send2->hash (); next_pruning = send2->hash ();
} }
@ -602,10 +602,10 @@ TEST (history, pruned_source)
auto transaction (store->tx_begin_write ()); auto transaction (store->tx_begin_write ());
auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub)); auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub));
auto send = std::make_shared<nano::state_block> (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)); auto send = std::make_shared<nano::state_block> (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 latest_key (ledger.latest (transaction, key.pub));
auto receive = std::make_shared<nano::state_block> (key.pub, latest_key, key.pub, 200, send->hash (), key.prv, key.pub, *system.work.generate (latest_key)); auto receive = std::make_shared<nano::state_block> (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, 2));
ASSERT_EQ (1, ledger.pruning_action (transaction, latest_key, 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 latest (system.nodes[0]->ledger.latest (transaction, nano::dev::genesis_key.pub));
auto block = std::make_shared<nano::send_block> (latest, key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); auto block = std::make_shared<nano::send_block> (latest, key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
hash = block->hash (); 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 account (nano::dev::genesis_key.pub);
auto wallet (std::make_shared<nano_qt::wallet> (*test_application, processor, *system.nodes[0], system.wallet (0), account)); auto wallet (std::make_shared<nano_qt::wallet> (*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 transaction (system1.nodes[0]->store.tx_begin_write ());
auto latest (system1.nodes[0]->ledger.latest (transaction, nano::dev::genesis->account ())); auto latest (system1.nodes[0]->ledger.latest (transaction, nano::dev::genesis->account ()));
auto send = std::make_shared<nano::send_block> (latest, key1, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system1.work.generate (latest)); auto send = std::make_shared<nano::send_block> (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)); ASSERT_EQ (0, wallet->active_status.active.count (nano_qt::status_types::synchronizing));
system0.nodes[0]->bootstrap_initiator.bootstrap (system1.nodes[0]->network.endpoint ()); system0.nodes[0]->bootstrap_initiator.bootstrap (system1.nodes[0]->network.endpoint ());
@ -967,7 +967,7 @@ TEST (wallet, epoch_2_validation)
bool error (false); bool error (false);
auto block = std::make_shared<nano::state_block> (error, tree1); auto block = std::make_shared<nano::state_block> (error, tree1);
EXPECT_FALSE (error); EXPECT_FALSE (error);
EXPECT_EQ (nano::block_status::progress, node->process (*block)); EXPECT_EQ (nano::block_status::progress, node->process (block));
return block->hash (); return block->hash ();
}; };

2
nano/rpc_test/receivable.cpp
View file

@ -370,7 +370,7 @@ TEST (rpc, search_receivable)
.build (); .build ();
{ {
auto transaction (node->store.tx_begin_write ()); 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); auto const rpc_ctx = add_rpc (system, node);
boost::property_tree::ptree request; boost::property_tree::ptree request;

144
nano/rpc_test/rpc.cpp
View file

@ -72,7 +72,7 @@ TEST (rpc, account_balance)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .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)); ASSERT_TIMELY (5s, !node->active.active (*send1));
auto const rpc_ctx = add_rpc (system, node); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest)) .work (*node1->work_generate_blocking (latest))
.build (); .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); auto const rpc_ctx = add_rpc (system, node1);
boost::property_tree::ptree request; boost::property_tree::ptree request;
request.put ("action", "account_weight"); request.put ("action", "account_weight");
@ -957,9 +957,9 @@ TEST (rpc, history)
.build (); .build ();
{ {
auto transaction (node0->store.tx_begin_write ()); 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, usend));
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *ureceive)); 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, uchange));
} }
auto const rpc_ctx = add_rpc (system, node0); auto const rpc_ctx = add_rpc (system, node0);
boost::property_tree::ptree request; boost::property_tree::ptree request;
@ -1041,9 +1041,9 @@ TEST (rpc, account_history)
.build (); .build ();
{ {
auto transaction (node0->store.tx_begin_write ()); 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, usend));
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *ureceive)); 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, uchange));
} }
auto const rpc_ctx = add_rpc (system, node0); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest)) .work (*node1->work_generate_blocking (latest))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send)); ASSERT_EQ (nano::block_status::progress, node1->process (send));
ASSERT_EQ (nano::block_status::progress, node2.process (*send)); ASSERT_EQ (nano::block_status::progress, node2.process (send));
auto const rpc_ctx = add_rpc (system, node1); auto const rpc_ctx = add_rpc (system, node1);
node1->scheduler.manual.push (send); node1->scheduler.manual.push (send);
auto open = builder auto open = builder
@ -1606,8 +1606,8 @@ TEST (rpc, process_subtype_receive)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest)) .work (*node1->work_generate_blocking (latest))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send)); ASSERT_EQ (nano::block_status::progress, node1->process (send));
ASSERT_EQ (nano::block_status::progress, node2.process (*send)); ASSERT_EQ (nano::block_status::progress, node2.process (send));
auto const rpc_ctx = add_rpc (system, node1); auto const rpc_ctx = add_rpc (system, node1);
node1->scheduler.manual.push (send); node1->scheduler.manual.push (send);
auto receive = builder auto receive = builder
@ -2497,7 +2497,7 @@ TEST (rpc, bootstrap)
.build (); .build ();
{ {
auto transaction (node1->store.tx_begin_write ()); 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); auto const rpc_ctx = add_rpc (system0, node);
boost::property_tree::ptree request; boost::property_tree::ptree request;
@ -2782,7 +2782,7 @@ TEST (rpc, bootstrap_any)
.build (); .build ();
{ {
auto transaction (system1.nodes[0]->store.tx_begin_write ()); 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); auto const rpc_ctx = add_rpc (system0, node);
boost::property_tree::ptree request; boost::property_tree::ptree request;
@ -2808,7 +2808,7 @@ TEST (rpc, republish)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest)) .work (*node1->work_generate_blocking (latest))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send)); ASSERT_EQ (nano::block_status::progress, node1->process (send));
auto open = builder auto open = builder
.open () .open ()
.source (send->hash ()) .source (send->hash ())
@ -2817,7 +2817,7 @@ TEST (rpc, republish)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*node1->work_generate_blocking (key.pub)) .work (*node1->work_generate_blocking (key.pub))
.build (); .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); auto const rpc_ctx = add_rpc (system, node1);
boost::property_tree::ptree request; boost::property_tree::ptree request;
request.put ("action", "republish"); request.put ("action", "republish");
@ -2998,7 +2998,7 @@ TEST (rpc, accounts_balances_unopened_account_with_receivables)
.build (); .build ();
{ {
auto transaction = node->store.tx_begin_write (); 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->block (send->hash ()));
ASSERT_TIMELY (5s, !node->active.active (*send)); ASSERT_TIMELY (5s, !node->active.active (*send));
@ -3531,7 +3531,7 @@ TEST (rpc, search_receivable_all)
.build (); .build ();
{ {
auto transaction (node->store.tx_begin_write ()); 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); auto const rpc_ctx = add_rpc (system, node);
boost::property_tree::ptree request; boost::property_tree::ptree request;
@ -3563,7 +3563,7 @@ TEST (rpc, wallet_republish)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest)) .work (*node1->work_generate_blocking (latest))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send)); ASSERT_EQ (nano::block_status::progress, node1->process (send));
auto open = builder auto open = builder
.open () .open ()
.source (send->hash ()) .source (send->hash ())
@ -3572,7 +3572,7 @@ TEST (rpc, wallet_republish)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*node1->work_generate_blocking (key.pub)) .work (*node1->work_generate_blocking (key.pub))
.build (); .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); auto const rpc_ctx = add_rpc (system, node1);
boost::property_tree::ptree request; boost::property_tree::ptree request;
request.put ("action", "wallet_republish"); request.put ("action", "wallet_republish");
@ -3607,7 +3607,7 @@ TEST (rpc, delegators)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest)) .work (*node1->work_generate_blocking (latest))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send)); ASSERT_EQ (nano::block_status::progress, node1->process (send));
auto open = builder auto open = builder
.open () .open ()
.source (send->hash ()) .source (send->hash ())
@ -3616,7 +3616,7 @@ TEST (rpc, delegators)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*node1->work_generate_blocking (key.pub)) .work (*node1->work_generate_blocking (key.pub))
.build (); .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); auto const rpc_ctx = add_rpc (system, node1);
boost::property_tree::ptree request; boost::property_tree::ptree request;
request.put ("action", "delegators"); request.put ("action", "delegators");
@ -3648,7 +3648,7 @@ TEST (rpc, delegators_parameters)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest)) .work (*node1->work_generate_blocking (latest))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send)); ASSERT_EQ (nano::block_status::progress, node1->process (send));
auto open = builder auto open = builder
.open () .open ()
.source (send->hash ()) .source (send->hash ())
@ -3657,7 +3657,7 @@ TEST (rpc, delegators_parameters)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*node1->work_generate_blocking (key.pub)) .work (*node1->work_generate_blocking (key.pub))
.build (); .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); auto const rpc_ctx = add_rpc (system, node1);
// Test with "count" = 2 // Test with "count" = 2
@ -3758,7 +3758,7 @@ TEST (rpc, delegators_count)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest)) .work (*node1->work_generate_blocking (latest))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send)); ASSERT_EQ (nano::block_status::progress, node1->process (send));
auto open = builder auto open = builder
.open () .open ()
.source (send->hash ()) .source (send->hash ())
@ -3767,7 +3767,7 @@ TEST (rpc, delegators_count)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*node1->work_generate_blocking (key.pub)) .work (*node1->work_generate_blocking (key.pub))
.build (); .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); auto const rpc_ctx = add_rpc (system, node1);
boost::property_tree::ptree request; boost::property_tree::ptree request;
request.put ("action", "delegators_count"); request.put ("action", "delegators_count");
@ -3810,7 +3810,7 @@ TEST (rpc, account_info)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest)) .work (*node1->work_generate_blocking (latest))
.build (); .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 time = nano::seconds_since_epoch ();
{ {
auto transaction = node1->store.tx_begin_write (); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest)) .work (*node1->work_generate_blocking (latest))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); ASSERT_EQ (nano::block_status::progress, node1->process (send1));
auto send2 = builder auto send2 = builder
.send () .send ()
.previous (send1->hash ()) .previous (send1->hash ())
@ -3878,7 +3878,7 @@ TEST (rpc, account_info)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (send1->hash ())) .work (*node1->work_generate_blocking (send1->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); ASSERT_EQ (nano::block_status::progress, node1->process (send2));
auto state_change = builder auto state_change = builder
.state () .state ()
@ -3890,7 +3890,7 @@ TEST (rpc, account_info)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (send2->hash ())) .work (*node1->work_generate_blocking (send2->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*state_change)); ASSERT_EQ (nano::block_status::progress, node1->process (state_change));
auto open = builder auto open = builder
.open () .open ()
@ -3900,7 +3900,7 @@ TEST (rpc, account_info)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*node1->work_generate_blocking (key1.pub)) .work (*node1->work_generate_blocking (key1.pub))
.build (); .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 (*state_change));
ASSERT_TIMELY (5s, !node1->active.active (*open)); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest)) .work (*node1->work_generate_blocking (latest))
.build (); .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); auto const rpc_ctx = add_rpc (system, node1);
boost::property_tree::ptree request; boost::property_tree::ptree request;
request.put ("action", "block_info"); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest)) .work (*node1->work_generate_blocking (latest))
.build (); .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); auto const rpc_ctx = add_rpc (system, node1);
boost::property_tree::ptree request; boost::property_tree::ptree request;
request.put ("action", "block_info"); request.put ("action", "block_info");
@ -4430,7 +4430,7 @@ TEST (rpc, populate_backlog)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node->work_generate_blocking (latest)) .work (*node->work_generate_blocking (latest))
.build (); .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); auto const rpc_ctx = add_rpc (system, node);
boost::property_tree::ptree request; boost::property_tree::ptree request;
@ -4461,7 +4461,7 @@ TEST (rpc, ledger)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node->work_generate_blocking (latest)) .work (*node->work_generate_blocking (latest))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node->process (*send)); ASSERT_EQ (nano::block_status::progress, node->process (send));
auto open = builder auto open = builder
.open () .open ()
.source (send->hash ()) .source (send->hash ())
@ -4470,7 +4470,7 @@ TEST (rpc, ledger)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*node->work_generate_blocking (key.pub)) .work (*node->work_generate_blocking (key.pub))
.build (); .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 time = nano::seconds_since_epoch ();
auto const rpc_ctx = add_rpc (system, node); auto const rpc_ctx = add_rpc (system, node);
boost::property_tree::ptree request; boost::property_tree::ptree request;
@ -4544,7 +4544,7 @@ TEST (rpc, ledger)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node->work_generate_blocking (send->hash ())) .work (*node->work_generate_blocking (send->hash ()))
.build (); .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 // When asking for pending, pending amount is taken into account for threshold so the account must show up
request.put ("count", 2); request.put ("count", 2);
request.put ("threshold", (send_amount + send2_amount).convert_to<std::string> ()); request.put ("threshold", (send_amount + send2_amount).convert_to<std::string> ());
@ -4631,7 +4631,7 @@ TEST (rpc, block_create)
boost::property_tree::read_json (block_stream, block_l); boost::property_tree::read_json (block_stream, block_l);
auto send_block (nano::deserialize_block_json (block_l)); auto send_block (nano::deserialize_block_json (block_l));
ASSERT_EQ (send->hash (), send_block->hash ()); 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; boost::property_tree::ptree request1;
request1.put ("action", "block_create"); request1.put ("action", "block_create");
request1.put ("type", "open"); request1.put ("type", "open");
@ -4649,7 +4649,7 @@ TEST (rpc, block_create)
boost::property_tree::read_json (block_stream1, block_l); boost::property_tree::read_json (block_stream1, block_l);
auto open_block (nano::deserialize_block_json (block_l)); auto open_block (nano::deserialize_block_json (block_l));
ASSERT_EQ (open->hash (), open_block->hash ()); 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 ()); request1.put ("representative", key.pub.to_account ());
auto response2 (wait_response (system, rpc_ctx, request1)); auto response2 (wait_response (system, rpc_ctx, request1));
std::string open2_hash (response2.get<std::string> ("hash")); std::string open2_hash (response2.get<std::string> ("hash"));
@ -4672,7 +4672,7 @@ TEST (rpc, block_create)
boost::property_tree::read_json (block_stream4, block_l); boost::property_tree::read_json (block_stream4, block_l);
auto change_block (nano::deserialize_block_json (block_l)); auto change_block (nano::deserialize_block_json (block_l));
ASSERT_EQ (change->hash (), change_block->hash ()); 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 auto send2 = builder
.send () .send ()
.previous (send->hash ()) .previous (send->hash ())
@ -4681,7 +4681,7 @@ TEST (rpc, block_create)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (send->hash ())) .work (*node1->work_generate_blocking (send->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send2)); ASSERT_EQ (nano::block_status::progress, node1->process (send2));
boost::property_tree::ptree request2; boost::property_tree::ptree request2;
request2.put ("action", "block_create"); request2.put ("action", "block_create");
request2.put ("type", "receive"); request2.put ("type", "receive");
@ -4729,7 +4729,7 @@ TEST (rpc, block_create_state)
ASSERT_NE (nullptr, state_block); ASSERT_NE (nullptr, state_block);
ASSERT_EQ (nano::block_type::state, state_block->type ()); ASSERT_EQ (nano::block_type::state, state_block->type ());
ASSERT_EQ (state_hash, state_block->hash ().to_string ()); 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); 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)); 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_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 ()); 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 (nano::block_status::progress, process_result);
ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_0); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_0);
ASSERT_TRUE (state_block->sideband ().details.is_receive); 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)); 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_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 ()); 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 (nano::block_status::progress, process_result);
ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2);
ASSERT_TRUE (state_block->sideband ().details.is_receive); ASSERT_TRUE (state_block->sideband ().details.is_receive);
@ -4871,7 +4871,7 @@ TEST (rpc, block_create_receive_epoch_v2)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*node->work_generate_blocking (key.pub)) .work (*node->work_generate_blocking (key.pub))
.build (); .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)); 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 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); 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 ()); ASSERT_EQ (state_hash, state_block->hash ().to_string ());
auto difficulty (nano::dev::network_params.work.difficulty (*state_block)); 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_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 (nano::block_status::progress, process_result);
ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2);
ASSERT_TRUE (state_block->sideband ().details.is_receive); ASSERT_TRUE (state_block->sideband ().details.is_receive);
@ -4924,7 +4924,7 @@ TEST (rpc, block_create_send_epoch_v2)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*node->work_generate_blocking (key.pub)) .work (*node->work_generate_blocking (key.pub))
.build (); .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); auto const rpc_ctx = add_rpc (system, node);
boost::property_tree::ptree request; boost::property_tree::ptree request;
request.put ("action", "block_create"); 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 ()); ASSERT_EQ (state_hash, state_block->hash ().to_string ());
auto difficulty (nano::dev::network_params.work.difficulty (*state_block)); 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))); 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 (nano::block_status::progress, process_result);
ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2);
ASSERT_TRUE (state_block->sideband ().details.is_send); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest)) .work (*node1->work_generate_blocking (latest))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send)); ASSERT_EQ (nano::block_status::progress, node1->process (send));
auto open = builder auto open = builder
.open () .open ()
.source (send->hash ()) .source (send->hash ())
@ -5057,7 +5057,7 @@ TEST (rpc, wallet_ledger)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*node1->work_generate_blocking (key.pub)) .work (*node1->work_generate_blocking (key.pub))
.build (); .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 time = nano::seconds_since_epoch ();
auto const rpc_ctx = add_rpc (system, node1); auto const rpc_ctx = add_rpc (system, node1);
boost::property_tree::ptree request; 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous_genesis_chain_hash)) .work (*system.work.generate (previous_genesis_chain_hash))
.build (); .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 (); previous_genesis_chain_hash = send->hash ();
} }
@ -5343,7 +5343,7 @@ TEST (rpc, block_confirm)
.build (); .build ();
{ {
auto transaction (node->store.tx_begin_write ()); 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); auto const rpc_ctx = add_rpc (system, node);
boost::property_tree::ptree request; boost::property_tree::ptree request;
@ -5850,7 +5850,7 @@ TEST (rpc, block_confirmed)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest)) .work (*system.work.generate (latest))
.build (); .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 auto open1 = builder
.open () .open ()
@ -5860,7 +5860,7 @@ TEST (rpc, block_confirmed)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*system.work.generate (key.pub)) .work (*system.work.generate (key.pub))
.build (); .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 // This should not be confirmed
@ -6144,7 +6144,7 @@ TEST (rpc, epoch_upgrade)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); // to opened account .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 auto send2 = builder
.state () .state ()
.account (nano::dev::genesis_key.pub) .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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ())) .work (*system.work.generate (send1->hash ()))
.build (); // to unopened account (pending) .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 auto send3 = builder
.state () .state ()
.account (nano::dev::genesis_key.pub) .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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send2->hash ())) .work (*system.work.generate (send2->hash ()))
.build (); // to burn (0) .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<nano::uint256_t>::max ()); nano::account max_account (std::numeric_limits<nano::uint256_t>::max ());
auto send4 = builder auto send4 = builder
.state () .state ()
@ -6178,7 +6178,7 @@ TEST (rpc, epoch_upgrade)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send3->hash ())) .work (*system.work.generate (send3->hash ()))
.build (); // to max account .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 auto open = builder
.state () .state ()
.account (key1.pub) .account (key1.pub)
@ -6189,7 +6189,7 @@ TEST (rpc, epoch_upgrade)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub)) .work (*system.work.generate (key1.pub))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node->process (*open)); ASSERT_EQ (nano::block_status::progress, node->process (open));
// Check accounts epochs // Check accounts epochs
{ {
auto transaction (node->store.tx_begin_read ()); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis_latest)) .work (*system.work.generate (genesis_latest))
.build (); // to burn (0) .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 auto send6 = builder
.state () .state ()
.account (nano::dev::genesis_key.pub) .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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send5->hash ())) .work (*system.work.generate (send5->hash ()))
.build (); // to key1 (again) .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 key1_latest (node->latest (key1.pub));
auto send7 = builder auto send7 = builder
.state () .state ()
@ -6258,7 +6258,7 @@ TEST (rpc, epoch_upgrade)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*system.work.generate (key1_latest)) .work (*system.work.generate (key1_latest))
.build (); // to key3 .build (); // to key3
ASSERT_EQ (nano::block_status::progress, node->process (*send7)); ASSERT_EQ (nano::block_status::progress, node->process (send7));
{ {
// Check pending entry // Check pending entry
auto transaction (node->store.tx_begin_read ()); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); // to opened account .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 auto send2 = builder
.state () .state ()
.account (nano::dev::genesis_key.pub) .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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ())) .work (*system.work.generate (send1->hash ()))
.build (); // to unopened account (pending) .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 auto send3 = builder
.state () .state ()
.account (nano::dev::genesis_key.pub) .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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send2->hash ())) .work (*system.work.generate (send2->hash ()))
.build (); // to burn (0) .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<nano::uint256_t>::max ()); nano::account max_account (std::numeric_limits<nano::uint256_t>::max ());
auto send4 = builder auto send4 = builder
.state () .state ()
@ -6341,7 +6341,7 @@ TEST (rpc, epoch_upgrade_multithreaded)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send3->hash ())) .work (*system.work.generate (send3->hash ()))
.build (); // to max account .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 auto open = builder
.state () .state ()
.account (key1.pub) .account (key1.pub)
@ -6352,7 +6352,7 @@ TEST (rpc, epoch_upgrade_multithreaded)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub)) .work (*system.work.generate (key1.pub))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node->process (*open)); ASSERT_EQ (nano::block_status::progress, node->process (open));
// Check accounts epochs // Check accounts epochs
{ {
auto transaction (node->store.tx_begin_read ()); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis_latest)) .work (*system.work.generate (genesis_latest))
.build (); // to burn (0) .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 auto send6 = builder
.state () .state ()
.account (nano::dev::genesis_key.pub) .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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send5->hash ())) .work (*system.work.generate (send5->hash ()))
.build (); // to key1 (again) .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 key1_latest (node->latest (key1.pub));
auto send7 = builder auto send7 = builder
.state () .state ()
@ -6422,7 +6422,7 @@ TEST (rpc, epoch_upgrade_multithreaded)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*system.work.generate (key1_latest)) .work (*system.work.generate (key1_latest))
.build (); // to key3 .build (); // to key3
ASSERT_EQ (nano::block_status::progress, node->process (*send7)); ASSERT_EQ (nano::block_status::progress, node->process (send7));
{ {
// Check pending entry // Check pending entry
auto transaction (node->store.tx_begin_read ()); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send1)); ASSERT_EQ (nano::block_status::progress, node1->process (send1));
auto open = builder auto open = builder
.open () .open ()
.source (send1->hash ()) .source (send1->hash ())
@ -6480,7 +6480,7 @@ TEST (rpc, account_lazy_start)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*system.work.generate (key.pub)) .work (*system.work.generate (key.pub))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*open)); ASSERT_EQ (nano::block_status::progress, node1->process (open));
// Start lazy bootstrap with account // Start lazy bootstrap with account
nano::node_config node_config = system.default_config (); nano::node_config node_config = system.default_config ();

6
nano/secure/ledger.cpp
View file

@ -915,11 +915,11 @@ std::optional<nano::pending_info> nano::ledger::pending_info (store::transaction
return std::nullopt; 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<nano::block> 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); ledger_processor processor (*this, transaction_a);
block_a.visit (processor); block_a->visit (processor);
if (processor.result == nano::block_status::progress) if (processor.result == nano::block_status::progress)
{ {
++cache.block_count; ++cache.block_count;

2
nano/secure/ledger.hpp
View file

@ -72,7 +72,7 @@ public:
nano::block_hash block_source (store::transaction const &, nano::block const &); nano::block_hash block_source (store::transaction const &, nano::block const &);
std::pair<nano::block_hash, nano::block_hash> hash_root_random (store::transaction const &) const; std::pair<nano::block_hash, nano::block_hash> hash_root_random (store::transaction const &) const;
std::optional<nano::pending_info> pending_info (store::transaction const & transaction, nano::pending_key const & key) const; std::optional<nano::pending_info> 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<nano::block> block);
bool rollback (store::write_transaction const &, nano::block_hash const &, std::vector<std::shared_ptr<nano::block>> &); bool rollback (store::write_transaction const &, nano::block_hash const &, std::vector<std::shared_ptr<nano::block>> &);
bool rollback (store::write_transaction const &, nano::block_hash const &); 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 &); void update_account (store::write_transaction const &, nano::account const &, nano::account_info const &, nano::account_info const &);

60
nano/slow_test/node.cpp
View file

@ -136,7 +136,7 @@ TEST (ledger, deep_account_compute)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (nano::dev::genesis->hash ())) .work (*pool.generate (nano::dev::genesis->hash ()))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send));
auto open = builder auto open = builder
.open () .open ()
.source (send->hash ()) .source (send->hash ())
@ -145,7 +145,7 @@ TEST (ledger, deep_account_compute)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*pool.generate (key.pub)) .work (*pool.generate (key.pub))
.build (); .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 sprevious (send->hash ());
auto rprevious (open->hash ()); auto rprevious (open->hash ());
for (auto i (0), n (100000); i != n; ++i) 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (sprevious)) .work (*pool.generate (sprevious))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send));
sprevious = send->hash (); sprevious = send->hash ();
auto receive = builder auto receive = builder
.receive () .receive ()
@ -168,7 +168,7 @@ TEST (ledger, deep_account_compute)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*pool.generate (rprevious)) .work (*pool.generate (rprevious))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive)); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive));
rprevious = receive->hash (); rprevious = receive->hash ();
if (i % 100 == 0) if (i % 100 == 0)
{ {
@ -277,7 +277,7 @@ TEST (node, fork_storm)
previous = send->hash (); previous = send->hash ();
for (auto node_i : system.nodes) 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); ASSERT_EQ (nano::block_status::progress, send_result);
nano::keypair rep; nano::keypair rep;
auto open = builder auto open = builder
@ -289,7 +289,7 @@ TEST (node, fork_storm)
.work (0) .work (0)
.build (); .build ();
node_i->work_generate_blocking (*open); 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); ASSERT_EQ (nano::block_status::progress, open_result);
auto transaction (node_i->store.tx_begin_read ()); auto transaction (node_i->store.tx_begin_read ());
node_i->network.flood_block (open); node_i->network.flood_block (open);
@ -660,7 +660,7 @@ TEST (confirmation_height, many_accounts_single_confirmation)
.sign (last_keypair.prv, last_keypair.pub) .sign (last_keypair.prv, last_keypair.pub)
.work (*system.work.generate (last_open_hash)) .work (*system.work.generate (last_open_hash))
.build (); .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 auto open = builder
.open () .open ()
.source (send->hash ()) .source (send->hash ())
@ -669,7 +669,7 @@ TEST (confirmation_height, many_accounts_single_confirmation)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*system.work.generate (key.pub)) .work (*system.work.generate (key.pub))
.build (); .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_open_hash = open->hash ();
last_keypair = key; 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_genesis)) .work (*system.work.generate (latest_genesis))
.build (); .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 auto open = builder
.open () .open ()
.source (send->hash ()) .source (send->hash ())
@ -753,7 +753,7 @@ TEST (confirmation_height, many_accounts_many_confirmations)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*system.work.generate (key.pub)) .work (*system.work.generate (key.pub))
.build (); .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)); open_blocks.push_back (std::move (open));
latest_genesis = send->hash (); latest_genesis = send->hash ();
} }
@ -826,8 +826,8 @@ TEST (confirmation_height, long_chains)
.build (); .build ();
{ {
auto transaction = node->store.tx_begin_write (); 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_EQ (nano::block_status::progress, node->ledger.process (transaction, *open)); ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open));
} }
// Bulk send from genesis account to destination account // 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous_genesis_chain_hash)) .work (*system.work.generate (previous_genesis_chain_hash))
.build (); .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 auto receive = builder
.receive () .receive ()
.previous (previous_destination_chain_hash) .previous (previous_destination_chain_hash)
@ -853,7 +853,7 @@ TEST (confirmation_height, long_chains)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*system.work.generate (previous_destination_chain_hash)) .work (*system.work.generate (previous_destination_chain_hash))
.build (); .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_genesis_chain_hash = send->hash ();
previous_destination_chain_hash = receive->hash (); previous_destination_chain_hash = receive->hash ();
@ -895,9 +895,9 @@ TEST (confirmation_height, long_chains)
{ {
auto transaction = node->store.tx_begin_write (); 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));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1)); 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, send2));
} }
// Call block confirm on the existing receive block on the genesis account which will confirm everything underneath on both accounts // 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 (); auto transaction = node->store.tx_begin_write ();
for (auto const & block : state_blocks) 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 (); .build ();
latest_genesis = send->hash (); latest_genesis = send->hash ();
state_blocks.push_back (send); 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; ++num;
}; };
@ -1116,7 +1116,7 @@ TEST (confirmation_height, many_accounts_send_receive_self)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_genesis)) .work (*system.work.generate (latest_genesis))
.build (); .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 auto open = builder
.open () .open ()
.source (send->hash ()) .source (send->hash ())
@ -1125,7 +1125,7 @@ TEST (confirmation_height, many_accounts_send_receive_self)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*system.work.generate (key.pub)) .work (*system.work.generate (key.pub))
.build (); .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)); open_blocks.push_back (std::move (open));
latest_genesis = send->hash (); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (latest_genesis)) .work (*pool.generate (latest_genesis))
.build (); .build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send)); ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send));
auto open = builder auto open = builder
.open () .open ()
.source (send->hash ()) .source (send->hash ())
@ -1272,7 +1272,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections)
.sign (key.prv, key.pub) .sign (key.prv, key.pub)
.work (*pool.generate (key.pub)) .work (*pool.generate (key.pub))
.build (); .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)); open_blocks.push_back (std::move (open));
latest_genesis = send->hash (); 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 ())) .work (*system.work.generate (send_blocks.back ()->hash ()))
.build ()); .build ());
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send_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 ())); 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) for (auto node : system.nodes)
{ {
auto transaction (node->store.tx_begin_write ()); 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 // This is the node which will request metrics from all other nodes
@ -1788,7 +1788,7 @@ TEST (node, mass_epoch_upgrader)
.build (ec); .build (ec);
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
ASSERT_NE (nullptr, block); 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 (); latest = block->hash ();
info.pending_hash = block->hash (); info.pending_hash = block->hash ();
} }
@ -1812,7 +1812,7 @@ TEST (node, mass_epoch_upgrader)
.build (ec); .build (ec);
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
ASSERT_NE (nullptr, block); 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 + total_accounts + opened.size (), node.ledger.cache.block_count);
ASSERT_EQ (1 + opened.size (), node.ledger.cache.account_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) 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_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)); 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) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest)) .work (*system.work.generate (latest))
.build (); .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 (); latest = send->hash ();
} }
} }

2
nano/test_common/ledger.cpp
View file

@ -12,7 +12,7 @@ nano::test::context::ledger_context::ledger_context (std::deque<std::shared_ptr<
store_m->initialize (tx, ledger_m.cache, ledger_m.constants); store_m->initialize (tx, ledger_m.cache, ledger_m.constants);
for (auto const & i : blocks_m) 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); debug_assert (process_result == nano::block_status::progress);
} }
} }

4
nano/test_common/system.cpp
View file

@ -40,7 +40,7 @@ std::shared_ptr<nano::node> nano::test::system::add_node (nano::node_config cons
auto node (std::make_shared<nano::node> (io_ctx, nano::unique_path (), node_config_a, work, node_flags_a, node_sequence++)); auto node (std::make_shared<nano::node> (io_ctx, nano::unique_path (), node_config_a, work, node_flags_a, node_sequence++));
for (auto i : initialization_blocks) 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 (result == nano::block_status::progress);
} }
debug_assert (!node->init_error ()); debug_assert (!node->init_error ());
@ -262,7 +262,7 @@ std::shared_ptr<nano::state_block> nano::test::upgrade_epoch (nano::work_pool &
bool error{ true }; bool error{ true };
if (!ec && epoch) 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; return !error ? std::move (epoch) : nullptr;

2
nano/test_common/testutil.cpp
View file

@ -64,7 +64,7 @@ bool nano::test::process (nano::node & node, std::vector<std::shared_ptr<nano::b
auto const transaction = node.store.tx_begin_write ({ tables::accounts, tables::blocks, tables::frontiers, tables::pending }); auto const transaction = node.store.tx_begin_write ({ tables::accounts, tables::blocks, tables::frontiers, tables::pending });
for (auto & block : blocks) for (auto & block : blocks)
{ {
auto result = node.process (transaction, *block); auto result = node.process (transaction, block);
if (result != nano::block_status::progress) if (result != nano::block_status::progress)
{ {
return false; return false;