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

Remove process_return class which only contained process_result. Rename process_result to ledger_code to better indicate its purpose. (#4442)

Browse source
This commit is contained in:
clemahieu 2024-02-20 18:09:04 +00:00 • committed by GitHub
commit 40306635ec
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
48 changed files with 919 additions and 924 deletions
Download patch file Download diff file Expand all files Collapse all files

46
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 ());
}
ASSERT_EQ (nano::process_result::progress, node2.process (*send).code);
ASSERT_EQ (nano::block_status::progress, node2.process (*send));
ASSERT_TIMELY (5s, !node2.active.empty ());
// Save election to check request count afterwards
@ -490,10 +490,10 @@ TEST (active_transactions, inactive_votes_cache_election_start)
.sign (key2.prv, key2.pub)
.work (*system.work.generate (key2.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*send1).code);
ASSERT_EQ (nano::process_result::progress, node.process (*send2).code);
ASSERT_EQ (nano::process_result::progress, node.process (*open1).code);
ASSERT_EQ (nano::process_result::progress, node.process (*open2).code);
ASSERT_EQ (nano::block_status::progress, node.process (*send1));
ASSERT_EQ (nano::block_status::progress, node.process (*send2));
ASSERT_EQ (nano::block_status::progress, node.process (*open1));
ASSERT_EQ (nano::block_status::progress, node.process (*open2));
ASSERT_TIMELY_EQ (5s, 5, node.ledger.cache.block_count);
ASSERT_TRUE (node.active.empty ());
ASSERT_EQ (1, node.ledger.cache.cemented_count);
@ -1093,14 +1093,14 @@ TEST (active_transactions, conflicting_block_vote_existing_election)
.build_shared ();
auto vote_fork = nano::test::make_final_vote (nano::dev::genesis_key, { fork });
ASSERT_EQ (nano::process_result::progress, node.process_local (send).value ().code);
ASSERT_EQ (nano::block_status::progress, node.process_local (send).value ());
ASSERT_TIMELY_EQ (5s, 1, node.active.size ());
// Vote for conflicting block, but the block does not yet exist in the ledger
node.active.vote (vote_fork);
// Block now gets processed
ASSERT_EQ (nano::process_result::fork, node.process_local (fork).value ().code);
ASSERT_EQ (nano::block_status::fork, node.process_local (fork).value ());
// Election must be confirmed
auto election (node.active.election (fork->qualified_root ()));
@ -1163,11 +1163,11 @@ TEST (active_transactions, activate_account_chain)
.sign (key.prv, key.pub)
.work (*system.work.generate (open->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
ASSERT_EQ (nano::process_result::progress, node.process (*send2).code);
ASSERT_EQ (nano::process_result::progress, node.process (*send3).code);
ASSERT_EQ (nano::process_result::progress, node.process (*open).code);
ASSERT_EQ (nano::process_result::progress, node.process (*receive).code);
ASSERT_EQ (nano::block_status::progress, node.process (*send));
ASSERT_EQ (nano::block_status::progress, node.process (*send2));
ASSERT_EQ (nano::block_status::progress, node.process (*send3));
ASSERT_EQ (nano::block_status::progress, node.process (*open));
ASSERT_EQ (nano::block_status::progress, node.process (*receive));
node.scheduler.priority.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
ASSERT_TIMELY (5s, node.active.election (send->qualified_root ()));
@ -1246,9 +1246,9 @@ TEST (active_transactions, activate_inactive)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
ASSERT_EQ (nano::process_result::progress, node.process (*send2).code);
ASSERT_EQ (nano::process_result::progress, node.process (*open).code);
ASSERT_EQ (nano::block_status::progress, node.process (*send));
ASSERT_EQ (nano::block_status::progress, node.process (*send2));
ASSERT_EQ (nano::block_status::progress, node.process (*open));
auto election = nano::test::start_election (system, node, send2->hash ());
ASSERT_NE (nullptr, election);
@ -1283,7 +1283,7 @@ TEST (active_transactions, list_active)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
ASSERT_EQ (nano::block_status::progress, node.process (*send));
auto send2 = builder.make_block ()
.account (nano::dev::genesis_key.pub)
@ -1295,7 +1295,7 @@ TEST (active_transactions, list_active)
.work (*system.work.generate (send->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*send2).code);
ASSERT_EQ (nano::block_status::progress, node.process (*send2));
auto open = builder.make_block ()
.account (key.pub)
@ -1307,7 +1307,7 @@ TEST (active_transactions, list_active)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*open).code);
ASSERT_EQ (nano::block_status::progress, node.process (*open));
ASSERT_TRUE (nano::test::start_elections (system, node, { send, send2, open }));
ASSERT_EQ (3, node.active.size ());
@ -1340,7 +1340,7 @@ TEST (active_transactions, vacancy)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
node.active.vacancy_update = [&updated] () { updated = true; };
ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
ASSERT_EQ (nano::block_status::progress, node.process (*send));
ASSERT_EQ (1, node.active.vacancy ());
ASSERT_EQ (0, node.active.size ());
node.scheduler.priority.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
@ -1381,7 +1381,7 @@ TEST (active_transactions, fifo)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_hash))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*send1).code);
ASSERT_EQ (nano::block_status::progress, node.process (*send1));
node.process_confirmed (nano::election_status{ send1 });
ASSERT_TIMELY (5s, node.block_confirmed (send1->hash ()));
@ -1396,7 +1396,7 @@ TEST (active_transactions, fifo)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_hash))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*send2).code);
ASSERT_EQ (nano::block_status::progress, node.process (*send2));
node.process_confirmed (nano::election_status{ send2 });
ASSERT_TIMELY (5s, node.block_confirmed (send2->hash ()));
@ -1409,7 +1409,7 @@ TEST (active_transactions, fifo)
.sign (key0.prv, key0.pub)
.work (*system.work.generate (key0.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*receive1).code);
ASSERT_EQ (nano::block_status::progress, node.process (*receive1));
auto receive2 = builder.make_block ()
.previous (0)
@ -1420,7 +1420,7 @@ TEST (active_transactions, fifo)
.sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*receive2).code);
ASSERT_EQ (nano::block_status::progress, node.process (*receive2));
// Ensure first transaction becomes active
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)
.work (*pool.generate (nano::dev::genesis->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send));
auto receive = builder
.receive ()
.previous (send->hash ())
@ -1029,7 +1029,7 @@ TEST (mdb_block_store, sideband_height)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (send->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive));
auto change = builder
.change ()
.previous (receive->hash ())
@ -1037,7 +1037,7 @@ TEST (mdb_block_store, sideband_height)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (receive->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *change).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change));
auto state_send1 = builder
.state ()
.account (nano::dev::genesis_key.pub)
@ -1048,7 +1048,7 @@ TEST (mdb_block_store, sideband_height)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (change->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_send1).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_send1));
auto state_send2 = builder
.state ()
.account (nano::dev::genesis_key.pub)
@ -1059,7 +1059,7 @@ TEST (mdb_block_store, sideband_height)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (state_send1->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_send2).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_send2));
auto state_send3 = builder
.state ()
.account (nano::dev::genesis_key.pub)
@ -1070,7 +1070,7 @@ TEST (mdb_block_store, sideband_height)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (state_send2->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_send3).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_send3));
auto state_open = builder
.state ()
.account (key1.pub)
@ -1081,7 +1081,7 @@ TEST (mdb_block_store, sideband_height)
.sign (key1.prv, key1.pub)
.work (*pool.generate (key1.pub))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_open).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_open));
auto epoch = builder
.state ()
.account (key1.pub)
@ -1092,7 +1092,7 @@ TEST (mdb_block_store, sideband_height)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (state_open->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch));
ASSERT_EQ (nano::epoch::epoch_1, ledger.version (*epoch));
auto epoch_open = builder
.state ()
@ -1104,7 +1104,7 @@ TEST (mdb_block_store, sideband_height)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (key2.pub))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *epoch_open).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch_open));
ASSERT_EQ (nano::epoch::epoch_1, ledger.version (*epoch_open));
auto state_receive = builder
.state ()
@ -1116,7 +1116,7 @@ TEST (mdb_block_store, sideband_height)
.sign (key2.prv, key2.pub)
.work (*pool.generate (epoch_open->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *state_receive).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_receive));
auto open = builder
.open ()
.source (state_send3->hash ())
@ -1125,7 +1125,7 @@ TEST (mdb_block_store, sideband_height)
.sign (key3.prv, key3.pub)
.work (*pool.generate (key3.pub))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open));
auto block1 (store.block.get (transaction, nano::dev::genesis->hash ()));
ASSERT_EQ (block1->sideband ().height, 1);
auto block2 (store.block.get (transaction, send->hash ()));

74
nano/core_test/bootstrap.cpp
View file

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

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

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 ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send3).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open2).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open3).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open3));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send4).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send5).code);
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::process_result::progress, node->ledger.process (transaction, *receive1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send6).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive2).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send6));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2));
// Check confirmation heights of all the accounts (except genesis) are uninitialized (0),
// as we have any just added them to the ledger and not processed any live transactions yet.
@ -669,20 +669,20 @@ TEST (confirmation_height, send_receive_between_2_accounts)
// Unpocketed send
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open1).code);
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::process_result::progress, node->ledger.process (transaction, *send2).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive1).code);
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::process_result::progress, node->ledger.process (transaction, *send3).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send4).code);
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::process_result::progress, node->ledger.process (transaction, *receive2).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive3).code);
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::process_result::progress, node->ledger.process (transaction, *send5).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send6).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send5));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send6));
}
add_callback_stats (*node);
@ -793,14 +793,14 @@ TEST (confirmation_height, send_receive_self)
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send3).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive2).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive3).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send4).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send4));
}
add_callback_stats (*node);
@ -1023,30 +1023,30 @@ TEST (confirmation_height, all_block_types)
{
auto transaction (store.tx_begin_write ());
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_open).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_open));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_receive).code);
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::process_result::progress, node->ledger.process (transaction, *state_send).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *change).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_change).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *change));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_change));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *epoch).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *epoch1).code);
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::process_result::progress, node->ledger.process (transaction, *state_send1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_receive2).code);
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::process_result::progress, node->ledger.process (transaction, *state_send2).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_send3).code);
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::process_result::progress, node->ledger.process (transaction, *state_send4).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *state_receive3).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send4));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_receive3));
}
add_callback_stats (*node);
@ -1117,7 +1117,7 @@ TEST (confirmation_height, conflict_rollback_cemented)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis_hash))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process (*fork1a).code);
ASSERT_EQ (nano::block_status::progress, node1->process (*fork1a));
ASSERT_TRUE (nano::test::start_elections (system, *node1, { fork1a }, true));
ASSERT_TIMELY (5s, nano::test::confirmed (*node1, { fork1a }));
@ -1269,7 +1269,7 @@ TEST (confirmation_heightDeathTest, modified_chain)
{
auto transaction (store->tx_begin_write ());
store->initialize (transaction, ledger.cache, ledger.constants);
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send));
}
uint64_t batch_write_size = 2048;
@ -1290,7 +1290,7 @@ TEST (confirmation_heightDeathTest, modified_chain)
ASSERT_DEATH_IF_SUPPORTED (bounded_processor.cement_blocks (scoped_write_guard), "");
}
ASSERT_EQ (nano::process_result::progress, ledger.process (store->tx_begin_write (), *send).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (store->tx_begin_write (), *send));
store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () });
nano::confirmation_height_unbounded unbounded_processor (
@ -1356,8 +1356,8 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed)
{
auto transaction (store->tx_begin_write ());
store->initialize (transaction, ledger.cache, ledger.constants);
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code);
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open));
}
uint64_t batch_write_size = 2048;
@ -1379,7 +1379,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed)
}
// Reset conditions and test with the bounded processor
ASSERT_EQ (nano::process_result::progress, ledger.process (store->tx_begin_write (), *open).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (store->tx_begin_write (), *open));
store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () });
nano::confirmation_height_bounded bounded_processor (
@ -1434,8 +1434,8 @@ TEST (confirmation_height, pending_observer_callbacks)
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1));
}
add_callback_stats (*node);
@ -1482,7 +1482,7 @@ TEST (confirmation_height, callback_confirmed_history)
.build_shared ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
}
auto send1 = builder
@ -1586,9 +1586,9 @@ TEST (confirmation_height, dependent_election)
.build_shared ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2));
}
add_callback_stats (*node);
@ -1729,21 +1729,21 @@ TEST (confirmation_height, cemented_gap_below_receive)
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *dummy_send).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive2).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *dummy_send1).code);
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::process_result::progress, node->ledger.process (transaction, *send3).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *dummy_send2).code);
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::process_result::progress, node->ledger.process (transaction, *open1).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1));
}
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 ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *dummy_send).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2));
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive2).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *dummy_send1).code);
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::process_result::progress, node->ledger.process (transaction, *send3).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *dummy_send2).code);
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::process_result::progress, node->ledger.process (transaction, *open1).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1));
}
// Force some blocks to be cemented so that the cached confirmed info variable is empty
@ -1959,7 +1959,7 @@ TEST (confirmation_height, election_winner_details_clearing)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node->process (*send1).code);
ASSERT_EQ (nano::block_status::progress, node->process (*send1));
auto const send2 = builder.make_block ()
.previous (send1->hash ())
@ -1968,7 +1968,7 @@ TEST (confirmation_height, election_winner_details_clearing)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node->process (*send2).code);
ASSERT_EQ (nano::block_status::progress, node->process (*send2));
auto const send3 = builder.make_block ()
.previous (send2->hash ())
@ -1977,7 +1977,7 @@ TEST (confirmation_height, election_winner_details_clearing)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send2->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node->process (*send3).code);
ASSERT_EQ (nano::block_status::progress, node->process (*send3));
node->process_confirmed (nano::election_status{ send2 });
ASSERT_TIMELY (5s, node->block_confirmed (send2->hash ()));
@ -2062,8 +2062,8 @@ TEST (confirmation_height, unbounded_block_cache_iteration)
{
auto transaction (store->tx_begin_write ());
store->initialize (transaction, ledger.cache, nano::dev::constants);
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code);
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1));
}
nano::confirmation_height_processor confirmation_height_processor (ledger, write_database_queue, 10ms, logger, initialized_latch, nano::confirmation_height_mode::unbounded);
@ -2159,11 +2159,11 @@ TEST (confirmation_height, pruned_source)
{
auto transaction (store->tx_begin_write ());
store->initialize (transaction, ledger.cache, nano::dev::constants);
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code);
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code);
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code);
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send3).code);
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open2).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send3));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open2));
}
uint64_t batch_write_size = 2;
std::atomic<bool> stopped{ false };

4
nano/core_test/conflicts.cpp
View file

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

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);
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_shared ();
ASSERT_EQ (nano::process_result::progress, node1.process (*open1).code);
ASSERT_EQ (nano::block_status::progress, node1.process (*open1));
nano::keypair key2;
auto const send2 = builder.make_block ()
@ -234,7 +234,7 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks)
.sign (key1.prv, key1.pub)
.work (*system.work.generate (open1->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1.process (*send2).code);
ASSERT_EQ (nano::block_status::progress, node1.process (*send2));
ASSERT_TIMELY_EQ (5s, node1.ledger.cache.block_count, 4);
node_config.peering_port = system.get_available_port ();

8
nano/core_test/election_scheduler.cpp
View file

@ -87,7 +87,7 @@ TEST (election_scheduler, no_vacancy)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*send).code);
ASSERT_EQ (nano::block_status::progress, node.process (*send));
node.process_confirmed (nano::election_status{ send });
auto receive = builder.make_block ()
@ -99,7 +99,7 @@ TEST (election_scheduler, no_vacancy)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*receive).code);
ASSERT_EQ (nano::block_status::progress, node.process (*receive));
node.process_confirmed (nano::election_status{ receive });
// Second, process two eligible transactions
@ -112,7 +112,7 @@ TEST (election_scheduler, no_vacancy)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*block1).code);
ASSERT_EQ (nano::block_status::progress, node.process (*block1));
// There is vacancy so it should be inserted
node.scheduler.priority.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
@ -128,7 +128,7 @@ TEST (election_scheduler, no_vacancy)
.sign (key.prv, key.pub)
.work (*system.work.generate (receive->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*block2).code);
ASSERT_EQ (nano::block_status::progress, node.process (*block2));
// There is no vacancy so it should stay queued
node.scheduler.priority.activate (key.pub, node.store.tx_begin_read ());

6
nano/core_test/frontiers_confirmation.cpp
View file

@ -29,7 +29,7 @@ TEST (frontiers_confirmation, mode)
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
}
ASSERT_TIMELY_EQ (5s, node->active.size (), 1);
}
@ -51,7 +51,7 @@ TEST (frontiers_confirmation, mode)
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
}
ASSERT_TIMELY_EQ (5s, node->active.size (), 1);
}
@ -73,7 +73,7 @@ TEST (frontiers_confirmation, mode)
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
}
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
std::this_thread::sleep_for (std::chrono::seconds (1));

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

180
nano/core_test/node.cpp
View file

@ -618,7 +618,7 @@ TEST (node, fork_publish_inactive)
std::shared_ptr<nano::election> election;
ASSERT_TIMELY (5s, election = node.active.election (send1->qualified_root ()));
ASSERT_EQ (nano::process_result::fork, node.process_local (send2).value ().code);
ASSERT_EQ (nano::block_status::fork, node.process_local (send2).value ());
ASSERT_TIMELY_EQ (5s, election->blocks ().size (), 2);
@ -771,10 +771,10 @@ TEST (node, fork_multi_flip)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send2->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1).code);
ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1));
// Node2 has two blocks that will be rolled back by node1's vote
ASSERT_EQ (nano::process_result::progress, node2.ledger.process (node2.store.tx_begin_write (), *send2).code);
ASSERT_EQ (nano::process_result::progress, node2.ledger.process (node2.store.tx_begin_write (), *send3).code);
ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), *send2));
ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), *send3));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); // Insert voting key in to node1
auto election = nano::test::start_election (system, node2, send2->hash ());
@ -821,8 +821,8 @@ TEST (node, fork_bootstrap_flip)
.work (*system0.work.generate (latest))
.build_shared ();
// Insert but don't rebroadcast, simulating settled blocks
ASSERT_EQ (nano::process_result::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1).code);
ASSERT_EQ (nano::process_result::progress, node2.ledger.process (node2.store.tx_begin_write (), *send2).code);
ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1));
ASSERT_EQ (nano::block_status::progress, node2.ledger.process (node2.store.tx_begin_write (), *send2));
ASSERT_TRUE (node2.store.block.exists (node2.store.tx_begin_read (), send2->hash ()));
node2.bootstrap_initiator.bootstrap (node1.network.endpoint ()); // Additionally add new peer to confirm & replace bootstrap block
auto again (true);
@ -1033,9 +1033,9 @@ TEST (node, fork_no_vote_quorum)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (block->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code);
ASSERT_EQ (nano::process_result::progress, node2.process (*send1).code);
ASSERT_EQ (nano::process_result::progress, node3.process (*send1).code);
ASSERT_EQ (nano::block_status::progress, node1.process (*send1));
ASSERT_EQ (nano::block_status::progress, node2.process (*send1));
ASSERT_EQ (nano::block_status::progress, node3.process (*send1));
auto key2 (system.wallet (2)->deterministic_insert ());
auto send2 = nano::send_block_builder ()
.previous (block->hash ())
@ -1181,9 +1181,9 @@ TEST (node, DISABLED_fork_stale)
node1.work_generate_blocking (*send2);
{
auto transaction1 (node1.store.tx_begin_write ());
ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction1, *send1).code);
ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction1, *send1));
auto transaction2 (node2.store.tx_begin_write ());
ASSERT_EQ (nano::process_result::progress, node2.ledger.process (transaction2, *send2).code);
ASSERT_EQ (nano::block_status::progress, node2.ledger.process (transaction2, *send2));
}
node1.process_active (send1);
node1.process_active (send2);
@ -1262,24 +1262,24 @@ TEST (node, DISABLED_broadcast_elected)
.sign (rep_other.prv, rep_other.pub)
.work (*system.work.generate (rep_other.pub))
.build ();
ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, fund_big).code);
ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, fund_big).code);
ASSERT_EQ (nano::process_result::progress, node2->ledger.process (transaction2, fund_big).code);
ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, open_big).code);
ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, open_big).code);
ASSERT_EQ (nano::process_result::progress, node2->ledger.process (transaction2, open_big).code);
ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, fund_small).code);
ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, fund_small).code);
ASSERT_EQ (nano::process_result::progress, node2->ledger.process (transaction2, fund_small).code);
ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, open_small).code);
ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, open_small).code);
ASSERT_EQ (nano::process_result::progress, node2->ledger.process (transaction2, open_small).code);
ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, fund_other).code);
ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, fund_other).code);
ASSERT_EQ (nano::process_result::progress, node2->ledger.process (transaction2, fund_other).code);
ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, open_other).code);
ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, open_other).code);
ASSERT_EQ (nano::process_result::progress, node2->ledger.process (transaction2, open_other).code);
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction0, fund_big));
ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction1, fund_big));
ASSERT_EQ (nano::block_status::progress, node2->ledger.process (transaction2, fund_big));
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction0, open_big));
ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction1, open_big));
ASSERT_EQ (nano::block_status::progress, node2->ledger.process (transaction2, open_big));
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction0, fund_small));
ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction1, fund_small));
ASSERT_EQ (nano::block_status::progress, node2->ledger.process (transaction2, fund_small));
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction0, open_small));
ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction1, open_small));
ASSERT_EQ (nano::block_status::progress, node2->ledger.process (transaction2, open_small));
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction0, fund_other));
ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction1, fund_other));
ASSERT_EQ (nano::block_status::progress, node2->ledger.process (transaction2, fund_other));
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction0, open_other));
ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction1, open_other));
ASSERT_EQ (nano::block_status::progress, node2->ledger.process (transaction2, open_other));
}
// Confirm blocks to allow voting
for (auto & node : system.nodes)
@ -1351,8 +1351,8 @@ TEST (node, rep_self_vote)
.sign (rep_big.prv, rep_big.pub)
.work (*system.work.generate (rep_big.pub))
.build ();
ASSERT_EQ (nano::process_result::progress, node0->process (fund_big).code);
ASSERT_EQ (nano::process_result::progress, node0->process (open_big).code);
ASSERT_EQ (nano::block_status::progress, node0->process (fund_big));
ASSERT_EQ (nano::block_status::progress, node0->process (open_big));
// Confirm both blocks, allowing voting on the upcoming block
node0->start_election (node0->block (open_big.hash ()));
std::shared_ptr<nano::election> election;
@ -1369,7 +1369,7 @@ TEST (node, rep_self_vote)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (fund_big.hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node0->process (*block0).code);
ASSERT_EQ (nano::block_status::progress, node0->process (*block0));
auto & active = node0->active;
auto & scheduler = node0->scheduler;
scheduler.priority.activate (nano::dev::genesis_key.pub, node0->store.tx_begin_read ());
@ -1403,7 +1403,7 @@ TEST (node, DISABLED_bootstrap_no_publish)
.build ();
{
auto transaction (node0->store.tx_begin_write ());
ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, *send0).code);
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *send0));
}
ASSERT_FALSE (node1->bootstrap_initiator.in_progress ());
node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false);
@ -1444,7 +1444,7 @@ TEST (node, DISABLED_bootstrap_bulk_push)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node0->process (*send0).code);
ASSERT_EQ (nano::block_status::progress, node0->process (*send0));
ASSERT_FALSE (node0->bootstrap_initiator.in_progress ());
ASSERT_FALSE (node1->bootstrap_initiator.in_progress ());
@ -1497,8 +1497,8 @@ TEST (node, bootstrap_fork_open)
.work (*system.work.generate (key0.pub))
.build ();
// Both know about send0
ASSERT_EQ (nano::process_result::progress, node0->process (send0).code);
ASSERT_EQ (nano::process_result::progress, node1->process (send0).code);
ASSERT_EQ (nano::block_status::progress, node0->process (send0));
ASSERT_EQ (nano::block_status::progress, node1->process (send0));
// Confirm send0 to allow starting and voting on the following blocks
for (auto node : system.nodes)
{
@ -1511,8 +1511,8 @@ TEST (node, bootstrap_fork_open)
}
ASSERT_TIMELY (3s, node0->block_confirmed (send0.hash ()));
// They disagree about open0/open1
ASSERT_EQ (nano::process_result::progress, node0->process (open0).code);
ASSERT_EQ (nano::process_result::progress, node1->process (open1).code);
ASSERT_EQ (nano::block_status::progress, node0->process (open0));
ASSERT_EQ (nano::block_status::progress, node1->process (open1));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
ASSERT_FALSE (node1->ledger.block_or_pruned_exists (open0.hash ()));
ASSERT_FALSE (node1->bootstrap_initiator.in_progress ());
@ -1540,7 +1540,7 @@ TEST (node, bootstrap_confirm_frontiers)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node0->process (*send0).code);
ASSERT_EQ (nano::block_status::progress, node0->process (*send0));
// each system only has one node, so there should be no bootstrapping going on
ASSERT_FALSE (node0->bootstrap_initiator.in_progress ());
@ -1598,7 +1598,7 @@ TEST (node, unconfirmed_send)
.sign (key2.prv, key2.pub)
.work (*system.work.generate (recv1->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node2.process (*send2).code);
ASSERT_EQ (nano::block_status::progress, node2.process (*send2));
auto send3 = wallet2->send_action (key2.pub, nano::dev::genesis->account (), nano::Mxrb_ratio);
ASSERT_TIMELY (5s, node2.block_confirmed (send2->hash ()));
@ -1698,10 +1698,10 @@ TEST (node, rep_weight)
.build ();
{
auto transaction = node.store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (transaction, *block1).code);
ASSERT_EQ (nano::process_result::progress, node.ledger.process (transaction, *block2).code);
ASSERT_EQ (nano::process_result::progress, node.ledger.process (transaction, *block3).code);
ASSERT_EQ (nano::process_result::progress, node.ledger.process (transaction, *block4).code);
ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *block1));
ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *block2));
ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *block3));
ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *block4));
}
ASSERT_TRUE (node.rep_crawler.representatives (1).empty ());
std::shared_ptr<nano::transport::channel> channel1 = nano::test::establish_tcp (system, node, node1.network.endpoint ());
@ -1788,10 +1788,10 @@ TEST (node, rep_remove)
.build ();
{
auto transaction = searching_node.store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, searching_node.ledger.process (transaction, *send_to_rep1).code);
ASSERT_EQ (nano::process_result::progress, searching_node.ledger.process (transaction, *receive_rep1).code);
ASSERT_EQ (nano::process_result::progress, searching_node.ledger.process (transaction, *send_to_rep2).code);
ASSERT_EQ (nano::process_result::progress, searching_node.ledger.process (transaction, *receive_rep2).code);
ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, *send_to_rep1));
ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, *receive_rep1));
ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, *send_to_rep2));
ASSERT_EQ (nano::block_status::progress, searching_node.ledger.process (transaction, *receive_rep2));
}
// Create channel for Rep1
@ -2127,7 +2127,7 @@ TEST (node, confirm_quorum)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code);
ASSERT_EQ (nano::block_status::progress, node1.process (*send1));
system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, new_balance.number ());
ASSERT_TIMELY (2s, node1.active.election (send1->qualified_root ()));
auto election = node1.active.election (send1->qualified_root ());
@ -2174,8 +2174,8 @@ TEST (node, local_votes_cache)
.build_shared ();
{
auto transaction (node.store.tx_begin_write ());
ASSERT_EQ (nano::process_result::progress, node.ledger.process (transaction, *send1).code);
ASSERT_EQ (nano::process_result::progress, node.ledger.process (transaction, *send2).code);
ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *send2));
}
// Confirm blocks to allow voting
node.start_election (send2);
@ -2205,7 +2205,7 @@ TEST (node, local_votes_cache)
// Max cache
{
auto transaction (node.store.tx_begin_write ());
ASSERT_EQ (nano::process_result::progress, node.ledger.process (transaction, *send3).code);
ASSERT_EQ (nano::block_status::progress, node.ledger.process (transaction, *send3));
}
nano::confirm_req message3{ nano::dev::network_params.network, send3->hash (), send3->root () };
for (auto i (0); i < 100; ++i)
@ -2243,7 +2243,7 @@ TEST (node, DISABLED_local_votes_cache_batch)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1));
node.confirmation_height_processor.add (send1);
ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ()));
auto send2 = nano::state_block_builder ()
@ -2255,7 +2255,7 @@ TEST (node, DISABLED_local_votes_cache_batch)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code);
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2));
auto receive1 = nano::state_block_builder ()
.account (key1.pub)
.previous (0)
@ -2265,7 +2265,7 @@ TEST (node, DISABLED_local_votes_cache_batch)
.sign (key1.prv, key1.pub)
.work (*node.work_generate_blocking (key1.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code);
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 () } };
nano::confirm_req message{ nano::dev::network_params.network, batch };
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)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*send1).code);
ASSERT_EQ (nano::block_status::progress, node.process (*send1));
// 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 ()) };
nano::confirm_req message2{ nano::dev::network_params.network, roots_hashes };
@ -2376,7 +2376,7 @@ TEST (node, local_votes_cache_fork)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code);
ASSERT_EQ (nano::block_status::progress, node1.process (*send1));
// Cache vote
auto vote = nano::test::make_vote (nano::dev::genesis_key, { send1 }, 0, 0);
node1.vote_processor.vote (vote, std::make_shared<nano::transport::fake::channel> (node1));
@ -2468,7 +2468,7 @@ TEST (node, vote_by_hash_bundle)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
blocks.push_back (block);
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *blocks.back ()).code);
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *blocks.back ()));
for (auto i = 2; i < 200; ++i)
{
auto block = builder.make_block ()
@ -2479,7 +2479,7 @@ TEST (node, vote_by_hash_bundle)
.work (*system.work.generate (blocks.back ()->hash ()))
.build_shared ();
blocks.push_back (block);
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *blocks.back ()).code);
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *blocks.back ()));
}
// Confirming last block will confirm whole chain and allow us to generate votes for those blocks later
@ -3443,8 +3443,8 @@ TEST (node, rollback_gap_source)
.sign (key.prv, key.pub)
.build_shared ();
// Set 'node' up with losing block 'fork1a'
ASSERT_EQ (nano::process_result::progress, node.process (*send1).code);
ASSERT_EQ (nano::process_result::progress, node.process (*fork1a).code);
ASSERT_EQ (nano::block_status::progress, node.process (*send1));
ASSERT_EQ (nano::block_status::progress, node.process (*fork1a));
// Node has 'fork1a' & doesn't have source 'send2' for winning 'fork1b' block
ASSERT_EQ (nullptr, node.block (send2->hash ()));
node.block_processor.force (fork1b);
@ -3457,7 +3457,7 @@ TEST (node, rollback_gap_source)
node.process_active (fork1a);
ASSERT_TIMELY (5s, node.block (fork1a->hash ()) != nullptr);
// With send2 block in ledger election can start again to remove fork block
ASSERT_EQ (nano::process_result::progress, node.process (*send2).code);
ASSERT_EQ (nano::block_status::progress, node.process (*send2));
node.block_processor.force (fork1b);
// Wait for new rollback
ASSERT_TIMELY_EQ (5s, node.stats.count (nano::stat::type::rollback, nano::stat::detail::open), 2);
@ -3601,19 +3601,19 @@ TEST (node, dependency_graph)
.work (*system.work.generate (key3_receive->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, node.process (*gen_send1).code);
ASSERT_EQ (nano::process_result::progress, node.process (*key1_open).code);
ASSERT_EQ (nano::process_result::progress, node.process (*key1_send1).code);
ASSERT_EQ (nano::process_result::progress, node.process (*gen_receive).code);
ASSERT_EQ (nano::process_result::progress, node.process (*gen_send2).code);
ASSERT_EQ (nano::process_result::progress, node.process (*key2_open).code);
ASSERT_EQ (nano::process_result::progress, node.process (*key2_send1).code);
ASSERT_EQ (nano::process_result::progress, node.process (*key3_open).code);
ASSERT_EQ (nano::process_result::progress, node.process (*key2_send2).code);
ASSERT_EQ (nano::process_result::progress, node.process (*key1_receive).code);
ASSERT_EQ (nano::process_result::progress, node.process (*key1_send2).code);
ASSERT_EQ (nano::process_result::progress, node.process (*key3_receive).code);
ASSERT_EQ (nano::process_result::progress, node.process (*key3_epoch).code);
ASSERT_EQ (nano::block_status::progress, node.process (*gen_send1));
ASSERT_EQ (nano::block_status::progress, node.process (*key1_open));
ASSERT_EQ (nano::block_status::progress, node.process (*key1_send1));
ASSERT_EQ (nano::block_status::progress, node.process (*gen_receive));
ASSERT_EQ (nano::block_status::progress, node.process (*gen_send2));
ASSERT_EQ (nano::block_status::progress, node.process (*key2_open));
ASSERT_EQ (nano::block_status::progress, node.process (*key2_send1));
ASSERT_EQ (nano::block_status::progress, node.process (*key3_open));
ASSERT_EQ (nano::block_status::progress, node.process (*key2_send2));
ASSERT_EQ (nano::block_status::progress, node.process (*key1_receive));
ASSERT_EQ (nano::block_status::progress, node.process (*key1_send2));
ASSERT_EQ (nano::block_status::progress, node.process (*key3_receive));
ASSERT_EQ (nano::block_status::progress, node.process (*key3_epoch));
ASSERT_TRUE (node.active.empty ());
// Hash -> Ancestors
@ -3805,19 +3805,19 @@ TEST (node, dependency_graph_frontier)
for (auto const & node : system.nodes)
{
auto transaction (node->store.tx_begin_write ());
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *gen_send1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *key1_open).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *key1_send1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *gen_receive).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *gen_send2).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *key2_open).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *key2_send1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *key3_open).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *key2_send2).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *key1_receive).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *key1_send2).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *key3_receive).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *key3_epoch).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *gen_send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key1_open));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key1_send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *gen_receive));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *gen_send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key2_open));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key2_send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key3_open));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key2_send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key1_receive));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key1_send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key3_receive));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *key3_epoch));
}
// node1 can vote, but only on the first block
@ -3931,7 +3931,7 @@ TEST (node, deferred_dependent_elections)
ASSERT_NE (nullptr, election_open);
// Confirm one of the dependents of the receive but not the other, to ensure both have to be confirmed to start an election on processing
ASSERT_EQ (nano::process_result::progress, node.process (*receive).code);
ASSERT_EQ (nano::block_status::progress, node.process (*receive));
ASSERT_FALSE (node.active.active (receive->qualified_root ()));
election_open->force_confirm ();
ASSERT_TIMELY (5s, node.block_confirmed (open->hash ()));
@ -3944,7 +3944,7 @@ TEST (node, deferred_dependent_elections)
ASSERT_NEVER (0.5s, node.active.active (receive->qualified_root ()));
// Processing a fork will also not start an election
ASSERT_EQ (nano::process_result::fork, node.process (*fork).code);
ASSERT_EQ (nano::block_status::fork, node.process (*fork));
node.process_local (fork);
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))
.build ();
send->signature.bytes[32] ^= 0x1;
ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, *send).code);
ASSERT_EQ (nano::block_status::bad_signature, ledger.process (transaction, *send));
}
TEST (processor_service, bad_receive_signature)
@ -57,7 +57,7 @@ TEST (processor_service, bad_receive_signature)
.work (*pool.generate (info1->head))
.build ();
nano::block_hash hash1 (send->hash ());
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send));
auto info2 = ledger.account_info (transaction, nano::dev::genesis_key.pub);
ASSERT_TRUE (info2);
auto receive = builder
@ -68,5 +68,5 @@ TEST (processor_service, bad_receive_signature)
.work (*pool.generate (hash1))
.build ();
receive->signature.bytes[32] ^= 0x1;
ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, *receive).code);
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 ());
// Not yet in the ledger
ASSERT_TIMELY_EQ (3s, 1, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_unknown));
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1));
node.aggregator.add (dummy_channel, request);
ASSERT_EQ (1, node.aggregator.size ());
// In the ledger but no vote generated yet
@ -73,7 +73,7 @@ TEST (request_aggregator, one_update)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1));
node.confirmation_height_processor.add (send1);
ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ()));
auto send2 = nano::state_block_builder ()
@ -85,7 +85,7 @@ TEST (request_aggregator, one_update)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code);
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2));
auto receive1 = nano::state_block_builder ()
.account (key1.pub)
.previous (0)
@ -95,7 +95,7 @@ TEST (request_aggregator, one_update)
.sign (key1.prv, key1.pub)
.work (*node.work_generate_blocking (key1.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code);
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;
request.emplace_back (send2->hash (), send2->root ());
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)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1));
node.confirmation_height_processor.add (send1);
ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ()));
auto send2 = builder.make_block ()
@ -160,8 +160,8 @@ TEST (request_aggregator, two)
.sign (key1.prv, key1.pub)
.work (*node.work_generate_blocking (key1.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code);
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code);
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2));
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *receive1));
std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send2->hash (), send2->root ());
request.emplace_back (receive1->hash (), receive1->root ());
@ -218,7 +218,7 @@ TEST (request_aggregator, two_endpoints)
.build_shared ();
std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send1->hash (), send1->root ());
ASSERT_EQ (nano::process_result::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1).code);
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_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 ()));
@ -279,7 +279,7 @@ TEST (request_aggregator, split)
.build ());
auto const & block = blocks.back ();
previous = block->hash ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *block).code);
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *block));
request.emplace_back (block->hash (), block->root ());
}
// Confirm all blocks
@ -325,7 +325,7 @@ TEST (request_aggregator, channel_lifetime)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
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;
request.emplace_back (send1->hash (), send1->root ());
{
@ -356,7 +356,7 @@ TEST (request_aggregator, channel_update)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
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;
request.emplace_back (send1->hash (), send1->root ());
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)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
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;
request.emplace_back (send1->hash (), send1->root ());
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)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
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;
request.emplace_back (send1->hash (), send1->root ());
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)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.process (*send1).code);
ASSERT_EQ (nano::process_result::progress, node.process (*send2).code);
ASSERT_EQ (nano::block_status::progress, node.process (*send1));
ASSERT_EQ (nano::block_status::progress, node.process (*send2));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
ASSERT_FALSE (node.ledger.dependents_confirmed (node.store.tx_begin_read (), *send2));

4
nano/core_test/system.cpp
View file

@ -60,7 +60,7 @@ TEST (system, DISABLED_generate_send_existing)
.work (0)
.build_shared ();
node1.work_generate_blocking (*open_block);
ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *open_block).code);
ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *open_block));
}
ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::dev::genesis->account ()));
auto info2 = node1.ledger.account_info (node1.store.tx_begin_read (), nano::dev::genesis_key.pub);
@ -111,7 +111,7 @@ TEST (system, DISABLED_generate_send_new)
.work (0)
.build_shared ();
node1.work_generate_blocking (*open_block);
ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *open_block).code);
ASSERT_EQ (nano::block_status::progress, node1.ledger.process (transaction, *open_block));
}
ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::dev::genesis->account ()));
std::vector<nano::account> accounts;

6
nano/core_test/vote_processor.cpp
View file

@ -204,7 +204,7 @@ TEST (vote_processor, no_broadcast_local)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build (ec);
ASSERT_FALSE (ec);
ASSERT_EQ (nano::process_result::progress, node.process_local (send).value ().code);
ASSERT_EQ (nano::block_status::progress, node.process_local (send).value ());
ASSERT_TIMELY (10s, !node.active.empty ());
ASSERT_EQ (2 * node.config.vote_minimum.number (), node.weight (nano::dev::genesis_key.pub));
// Insert account in wallet. Votes on node are not enabled.
@ -257,7 +257,7 @@ TEST (vote_processor, local_broadcast_without_a_representative)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build (ec);
ASSERT_FALSE (ec);
ASSERT_EQ (nano::process_result::progress, node.process_local (send).value ().code);
ASSERT_EQ (nano::block_status::progress, node.process_local (send).value ());
ASSERT_TIMELY (10s, !node.active.empty ());
ASSERT_EQ (node.config.vote_minimum, node.weight (nano::dev::genesis_key.pub));
node.start_election (send);
@ -305,7 +305,7 @@ TEST (vote_processor, no_broadcast_local_with_a_principal_representative)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build (ec);
ASSERT_FALSE (ec);
ASSERT_EQ (nano::process_result::progress, node.process_local (send).value ().code);
ASSERT_EQ (nano::block_status::progress, node.process_local (send).value ());
ASSERT_TIMELY (10s, !node.active.empty ());
ASSERT_EQ (nano::dev::constants.genesis_amount - 2 * node.config.vote_minimum.number (), node.weight (nano::dev::genesis_key.pub));
// Insert account in wallet. Votes on node are not enabled.

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)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1));
ASSERT_EQ (0, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts));
node.generator.add (nano::dev::genesis->hash (), send1->hash ());
ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts), 1);
ASSERT_FALSE (node.ledger.rollback (node.store.tx_begin_write (), send1->hash ()));
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code);
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2));
node.generator.add (nano::dev::genesis->hash (), send2->hash ());
ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_spacing), 1);
ASSERT_EQ (1, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts));
@ -212,11 +212,11 @@ TEST (vote_spacing, rapid)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code);
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1));
node.generator.add (nano::dev::genesis->hash (), send1->hash ());
ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts), 1);
ASSERT_FALSE (node.ledger.rollback (node.store.tx_begin_write (), send1->hash ()));
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code);
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2));
node.generator.add (nano::dev::genesis->hash (), send2->hash ());
ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_spacing), 1);
ASSERT_TIMELY_EQ (3s, 1, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts));

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

2
nano/core_test/websocket.cpp
View file

@ -1061,7 +1061,7 @@ TEST (websocket, new_unconfirmed_block)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node1->process_local (send1).value ().code);
ASSERT_EQ (nano::block_status::progress, node1->process_local (send1).value ());
ASSERT_TIMELY_EQ (5s, future.wait_for (0s), std::future_status::ready);

4
nano/node/active_transactions.cpp
View file

@ -35,9 +35,9 @@ nano::active_transactions::active_transactions (nano::node & node_a, nano::confi
// Notify elections about alternative (forked) blocks
block_processor.block_processed.add ([this] (auto const & result, auto const & context) {
switch (result.code)
switch (result)
{
case nano::process_result::fork:
case nano::block_status::fork:
publish (context.block);
break;
default:

4
nano/node/block_broadcast.cpp
View file

@ -15,9 +15,9 @@ void nano::block_broadcast::connect (nano::block_processor & block_processor)
return;
}
block_processor.block_processed.add ([this] (auto const & result, auto const & context) {
switch (result.code)
switch (result)
{
case nano::process_result::progress:
case nano::block_status::progress:
observe (context);
break;
default:

40
nano/node/blockprocessor.cpp
View file

@ -96,7 +96,7 @@ void nano::block_processor::add (std::shared_ptr<nano::block> const & block, blo
add_impl (context{ block, source });
}
std::optional<nano::process_return> nano::block_processor::add_blocking (std::shared_ptr<nano::block> const & block, block_source const source)
std::optional<nano::block_status> nano::block_processor::add_blocking (std::shared_ptr<nano::block> const & block, block_source const source)
{
node.stats.inc (nano::stat::type::blockprocessor, nano::stat::detail::process_blocking);
node.logger.debug (nano::log::type::blockprocessor, "Processing block (blocking): {} (source: {})", block->hash ().to_string (), to_string (source));
@ -312,24 +312,24 @@ auto nano::block_processor::process_batch (nano::unique_lock<nano::mutex> & lock
return processed;
}
nano::process_return 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 const hash = block->hash ();
nano::process_return 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.code));
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.logger.trace (nano::log::type::blockprocessor, nano::log::detail::block_processed,
nano::log::arg{ "result", result.code },
nano::log::arg{ "result", result },
nano::log::arg{ "source", context.source },
nano::log::arg{ "arrival", nano::log::microseconds (context.arrival) },
nano::log::arg{ "forced", forced_a },
nano::log::arg{ "block", block });
switch (result.code)
switch (result)
{
case nano::process_result::progress:
case nano::block_status::progress:
{
queue_unchecked (transaction_a, hash);
/* For send blocks check epoch open unchecked (gap pending).
@ -343,63 +343,63 @@ nano::process_return nano::block_processor::process_one (store::write_transactio
}
break;
}
case nano::process_result::gap_previous:
case nano::block_status::gap_previous:
{
node.unchecked.put (block->previous (), block);
node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_previous);
break;
}
case nano::process_result::gap_source:
case nano::block_status::gap_source:
{
node.unchecked.put (node.ledger.block_source (transaction_a, *block), block);
node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source);
break;
}
case nano::process_result::gap_epoch_open_pending:
case nano::block_status::gap_epoch_open_pending:
{
node.unchecked.put (block->account (), block); // Specific unchecked key starting with epoch open block account public key
node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source);
break;
}
case nano::process_result::old:
case nano::block_status::old:
{
node.stats.inc (nano::stat::type::ledger, nano::stat::detail::old);
break;
}
case nano::process_result::bad_signature:
case nano::block_status::bad_signature:
{
break;
}
case nano::process_result::negative_spend:
case nano::block_status::negative_spend:
{
break;
}
case nano::process_result::unreceivable:
case nano::block_status::unreceivable:
{
break;
}
case nano::process_result::fork:
case nano::block_status::fork:
{
node.stats.inc (nano::stat::type::ledger, nano::stat::detail::fork);
break;
}
case nano::process_result::opened_burn_account:
case nano::block_status::opened_burn_account:
{
break;
}
case nano::process_result::balance_mismatch:
case nano::block_status::balance_mismatch:
{
break;
}
case nano::process_result::representative_mismatch:
case nano::block_status::representative_mismatch:
{
break;
}
case nano::process_result::block_position:
case nano::block_status::block_position:
{
break;
}
case nano::process_result::insufficient_work:
case nano::block_status::insufficient_work:
{
break;
}

10
nano/node/blockprocessor.hpp
View file

@ -51,7 +51,7 @@ public: // Context
std::chrono::steady_clock::time_point const arrival{ std::chrono::steady_clock::now () };
public:
using result_t = nano::process_return;
using result_t = nano::block_status;
std::future<result_t> get_future ();
private:
@ -69,7 +69,7 @@ public:
bool full ();
bool half_full ();
void add (std::shared_ptr<nano::block> const &, block_source = block_source::live);
std::optional<nano::process_return> add_blocking (std::shared_ptr<nano::block> const & block, block_source);
std::optional<nano::block_status> add_blocking (std::shared_ptr<nano::block> const & block, block_source);
void force (std::shared_ptr<nano::block> const &);
bool should_log ();
bool have_blocks_ready ();
@ -80,17 +80,17 @@ public:
std::atomic<bool> flushing{ false };
public: // Events
using processed_t = std::tuple<nano::process_return, context>;
using processed_t = std::tuple<nano::block_status, context>;
using processed_batch_t = std::deque<processed_t>;
// The batch observer feeds the processed observer
nano::observer_set<nano::process_return const &, context const &> block_processed;
nano::observer_set<nano::block_status const &, context const &> block_processed;
nano::observer_set<processed_batch_t const &> batch_processed;
private:
// Roll back block in the ledger that conflicts with 'block'
void rollback_competitor (store::write_transaction const &, nano::block const & block);
nano::process_return process_one (store::write_transaction const &, context const &, bool forced = false);
nano::block_status process_one (store::write_transaction const &, context const &, bool forced = false);
void queue_unchecked (store::write_transaction const &, nano::hash_or_account const &);
processed_batch_t process_batch (nano::unique_lock<nano::mutex> &);
context next ();

2
nano/node/bootstrap/bootstrap.cpp
View file

@ -165,7 +165,7 @@ bool nano::bootstrap_initiator::in_progress ()
return !attempts_list.empty ();
}
void nano::bootstrap_initiator::block_processed (store::transaction const & tx, nano::process_return const & result, nano::block const & block)
void nano::bootstrap_initiator::block_processed (store::transaction const & tx, nano::block_status const & result, nano::block const & block)
{
nano::lock_guard<nano::mutex> lock{ mutex };
for (auto & i : attempts_list)

2
nano/node/bootstrap/bootstrap.hpp
View file

@ -105,7 +105,7 @@ public:
void notify_listeners (bool);
void add_observer (std::function<void (bool)> const &);
bool in_progress ();
void block_processed (store::transaction const & tx, nano::process_return const & result, nano::block const & block);
void block_processed (store::transaction const & tx, nano::block_status const & result, nano::block const & block);
std::shared_ptr<nano::bootstrap_connections> connections;
std::shared_ptr<nano::bootstrap_attempt> new_attempt ();
bool has_new_attempts ();

2
nano/node/bootstrap/bootstrap_attempt.cpp
View file

@ -138,6 +138,6 @@ bool nano::bootstrap_attempt::process_block (std::shared_ptr<nano::block> const
return stop_pull;
}
void nano::bootstrap_attempt::block_processed (store::transaction const & tx, nano::process_return const & result, nano::block const & block)
void nano::bootstrap_attempt::block_processed (store::transaction const & tx, nano::block_status const & result, nano::block const & block)
{
}

2
nano/node/bootstrap/bootstrap_attempt.hpp
View file

@ -34,7 +34,7 @@ public:
char const * mode_text ();
virtual bool process_block (std::shared_ptr<nano::block> const &, nano::account const &, uint64_t, nano::bulk_pull::count_t, bool, unsigned);
virtual void get_information (boost::property_tree::ptree &) = 0;
virtual void block_processed (store::transaction const & tx, nano::process_return const & result, nano::block const & block);
virtual void block_processed (store::transaction const & tx, nano::block_status const & result, nano::block const & block);
nano::mutex next_log_mutex;
std::chrono::steady_clock::time_point next_log{ std::chrono::steady_clock::now () };
std::atomic<unsigned> pulling{ 0 };

12
nano/node/bootstrap_ascending/service.cpp
View file

@ -124,13 +124,13 @@ std::size_t nano::bootstrap_ascending::service::score_size () const
- Marks an account as blocked if the result code is gap source as there is no reason request additional blocks for this account until the dependency is resolved
- Marks an account as forwarded if it has been recently referenced by a block that has been inserted.
*/
void nano::bootstrap_ascending::service::inspect (store::transaction const & tx, nano::process_return const & result, nano::block const & block)
void nano::bootstrap_ascending::service::inspect (store::transaction const & tx, nano::block_status const & result, nano::block const & block)
{
auto const hash = block.hash ();
switch (result.code)
switch (result)
{
case nano::process_result::progress:
case nano::block_status::progress:
{
const auto account = ledger.account (tx, hash);
const auto is_send = ledger.is_send (tx, block);
@ -164,7 +164,7 @@ void nano::bootstrap_ascending::service::inspect (store::transaction const & tx,
}
}
break;
case nano::process_result::gap_source:
case nano::block_status::gap_source:
{
const auto account = block.previous ().is_zero () ? block.account () : ledger.account (tx, block.previous ());
const auto source = block.source ().is_zero () ? block.link ().as_block_hash () : block.source ();
@ -175,12 +175,12 @@ void nano::bootstrap_ascending::service::inspect (store::transaction const & tx,
// TODO: Track stats
}
break;
case nano::process_result::old:
case nano::block_status::old:
{
// TODO: Track stats
}
break;
case nano::process_result::gap_previous:
case nano::block_status::gap_previous:
{
// TODO: Track stats
}

2
nano/node/bootstrap_ascending/service.hpp
View file

@ -88,7 +88,7 @@ namespace bootstrap_ascending
private:
/* Inspects a block that has been processed by the block processor */
void inspect (store::transaction const &, nano::process_return const & result, nano::block const & block);
void inspect (store::transaction const &, nano::block_status const & result, nano::block const & block);
void throttle_if_needed (nano::unique_lock<nano::mutex> & lock);
void run ();

8
nano/node/epoch_upgrader.cpp
View file

@ -47,18 +47,18 @@ void nano::epoch_upgrader::upgrade_impl (nano::raw_key const & prv_a, nano::epoc
epoch->block_work_set (node.work_generate_blocking (nano::work_version::work_1, root_a, difficulty).value_or (0));
bool valid_signature (!nano::validate_message (signer_a, epoch->hash (), epoch->block_signature ()));
bool valid_work (node.network_params.work.difficulty (*epoch) >= difficulty);
nano::process_result result (nano::process_result::old);
nano::block_status result (nano::block_status::old);
if (valid_signature && valid_work)
{
result = node.process_local (epoch).value ().code;
result = node.process_local (epoch).value ();
}
if (result == nano::process_result::progress)
if (result == nano::block_status::progress)
{
++counter;
}
else
{
bool fork (result == nano::process_result::fork);
bool fork (result == nano::block_status::fork);
logger.error (nano::log::type::epoch_upgrader, "Failed to upgrade account {} (valid signature: {}, valid work: {}, fork: {})",
account_a.to_account (),

28
nano/node/json_handler.cpp
View file

@ -3271,60 +3271,60 @@ void nano::json_handler::process ()
else
{
auto const & result = result_maybe.value ();
switch (result.code)
switch (result)
{
case nano::process_result::progress:
case nano::block_status::progress:
{
rpc_l->response_l.put ("hash", block->hash ().to_string ());
break;
}
case nano::process_result::gap_previous:
case nano::block_status::gap_previous:
{
rpc_l->ec = nano::error_process::gap_previous;
break;
}
case nano::process_result::gap_source:
case nano::block_status::gap_source:
{
rpc_l->ec = nano::error_process::gap_source;
break;
}
case nano::process_result::old:
case nano::block_status::old:
{
rpc_l->ec = nano::error_process::old;
break;
}
case nano::process_result::bad_signature:
case nano::block_status::bad_signature:
{
rpc_l->ec = nano::error_process::bad_signature;
break;
}
case nano::process_result::negative_spend:
case nano::block_status::negative_spend:
{
// TODO once we get RPC versioning, this should be changed to "negative spend"
rpc_l->ec = nano::error_process::negative_spend;
break;
}
case nano::process_result::balance_mismatch:
case nano::block_status::balance_mismatch:
{
rpc_l->ec = nano::error_process::balance_mismatch;
break;
}
case nano::process_result::unreceivable:
case nano::block_status::unreceivable:
{
rpc_l->ec = nano::error_process::unreceivable;
break;
}
case nano::process_result::block_position:
case nano::block_status::block_position:
{
rpc_l->ec = nano::error_process::block_position;
break;
}
case nano::process_result::gap_epoch_open_pending:
case nano::block_status::gap_epoch_open_pending:
{
rpc_l->ec = nano::error_process::gap_epoch_open_pending;
break;
}
case nano::process_result::fork:
case nano::block_status::fork:
{
bool const force = rpc_l->request.get<bool> ("force", false);
if (force)
@ -3339,12 +3339,12 @@ void nano::json_handler::process ()
}
break;
}
case nano::process_result::insufficient_work:
case nano::block_status::insufficient_work:
{
rpc_l->ec = nano::error_process::insufficient_work;
break;
}
case nano::process_result::opened_burn_account:
case nano::block_status::opened_burn_account:
rpc_l->ec = nano::error_process::opened_burn_account;
break;
default:

6
nano/node/node.cpp
View file

@ -559,18 +559,18 @@ void nano::node::process_active (std::shared_ptr<nano::block> const & incoming)
block_processor.add (incoming);
}
[[nodiscard]] nano::process_return nano::node::process (store::write_transaction const & transaction, nano::block & block)
[[nodiscard]] nano::block_status nano::node::process (store::write_transaction const & transaction, nano::block & block)
{
return ledger.process (transaction, block);
}
nano::process_return nano::node::process (nano::block & block)
nano::block_status nano::node::process (nano::block & block)
{
auto const transaction = store.tx_begin_write ({ tables::accounts, tables::blocks, tables::frontiers, tables::pending });
return process (transaction, block);
}
std::optional<nano::process_return> nano::node::process_local (std::shared_ptr<nano::block> const & block_a)
std::optional<nano::block_status> nano::node::process_local (std::shared_ptr<nano::block> const & block_a)
{
return block_processor.add_blocking (block_a, nano::block_source::local);
}

6
nano/node/node.hpp
View file

@ -86,7 +86,7 @@ public:
void process_confirmed_data (store::transaction const &, std::shared_ptr<nano::block> const &, nano::block_hash const &, nano::account &, nano::uint128_t &, bool &, bool &, nano::account &);
void process_confirmed (nano::election_status const &, uint64_t = 0);
void process_active (std::shared_ptr<nano::block> const &);
std::optional<nano::process_return> process_local (std::shared_ptr<nano::block> const &);
std::optional<nano::block_status> process_local (std::shared_ptr<nano::block> const &);
void process_local_async (std::shared_ptr<nano::block> const &);
void keepalive_preconfigured (std::vector<std::string> const &);
std::shared_ptr<nano::block> block (nano::block_hash const &);
@ -210,8 +210,8 @@ public: // Testing convenience functions
Creates a new write transaction and inserts `block' and returns result
Transaction is comitted before function return
*/
[[nodiscard]] nano::process_return process (nano::block & block);
[[nodiscard]] nano::process_return process (store::write_transaction const &, nano::block & block);
[[nodiscard]] nano::block_status process (nano::block & block);
[[nodiscard]] nano::block_status process (store::write_transaction const &, nano::block & block);
nano::block_hash latest (nano::account const &);
nano::uint128_t balance (nano::account const &);

6
nano/node/process_live_dispatcher.cpp
View file

@ -28,11 +28,11 @@ void nano::process_live_dispatcher::connect (nano::block_processor & block_proce
});
}
void nano::process_live_dispatcher::inspect (nano::process_return const & result, nano::block const & block, store::transaction const & transaction)
void nano::process_live_dispatcher::inspect (nano::block_status const & result, nano::block const & block, store::transaction const & transaction)
{
switch (result.code)
switch (result)
{
case nano::process_result::progress:
case nano::block_status::progress:
process_live (block, transaction);
break;
default:

2
nano/node/process_live_dispatcher.hpp
View file

@ -28,7 +28,7 @@ public:
private:
// Block_processor observer
void inspect (nano::process_return const & result, nano::block const & block, store::transaction const & transaction);
void inspect (nano::block_status const & result, nano::block const & block, store::transaction const & transaction);
void process_live (nano::block const & block, store::transaction const & transaction);
nano::ledger & ledger;

2
nano/node/wallet.cpp
View file

@ -1054,7 +1054,7 @@ bool nano::wallet::action_complete (std::shared_ptr<nano::block> const & block_a
if (!error)
{
auto result = wallets.node.process_local (block_a);
error = !result || result.value ().code != nano::process_result::progress;
error = !result || result.value () != nano::block_status::progress;
debug_assert (error || block_a->sideband ().details == details_a);
}
if (!error && generate_work_a)

38
nano/qt_test/qt.cpp
View file

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

2
nano/rpc_test/receivable.cpp
View file

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

8
nano/secure/common.cpp
View file

@ -497,14 +497,14 @@ void nano::generate_cache::enable_all ()
account_count = true;
}
std::string_view nano::to_string (nano::process_result process_result)
std::string_view nano::to_string (nano::block_status code)
{
return magic_enum::enum_name (process_result);
return magic_enum::enum_name (code);
}
nano::stat::detail nano::to_stat_detail (nano::process_result process_result)
nano::stat::detail nano::to_stat_detail (nano::block_status code)
{
auto value = magic_enum::enum_cast<nano::stat::detail> (magic_enum::enum_name (process_result));
auto value = magic_enum::enum_cast<nano::stat::detail> (magic_enum::enum_name (code));
debug_assert (value);
return value.value_or (nano::stat::detail{});
}

11
nano/secure/common.hpp
View file

@ -253,7 +253,7 @@ enum class vote_code
indeterminate // Unknown if replay or vote
};
enum class process_result
enum class block_status
{
progress, // Hasn't been seen before, signed correctly
bad_signature, // Signature was bad, forged or transmission error
@ -271,14 +271,9 @@ enum class process_result
insufficient_work // Insufficient work for this block, even though it passed the minimal validation
};
std::string_view to_string (process_result);
nano::stat::detail to_stat_detail (process_result);
std::string_view to_string (block_status);
nano::stat::detail to_stat_detail (block_status);
class process_return final
{
public:
nano::process_result code;
};
enum class tally_result
{
vote,

232
nano/secure/ledger.cpp
View file

@ -203,7 +203,7 @@ public:
void epoch_block_impl (nano::state_block &);
nano::ledger & ledger;
nano::store::write_transaction const & transaction;
nano::process_return result;
nano::block_status result;
private:
bool validate_epoch_block (nano::state_block const & block_a);
@ -216,8 +216,8 @@ bool ledger_processor::validate_epoch_block (nano::state_block const & block_a)
nano::amount prev_balance (0);
if (!block_a.hashables.previous.is_zero ())
{
result.code = ledger.store.block.exists (transaction, block_a.hashables.previous) ? nano::process_result::progress : nano::process_result::gap_previous;
if (result.code == nano::process_result::progress)
result = ledger.store.block.exists (transaction, block_a.hashables.previous) ? nano::block_status::progress : nano::block_status::gap_previous;
if (result == nano::block_status::progress)
{
prev_balance = ledger.balance (transaction, block_a.hashables.previous);
}
@ -229,7 +229,7 @@ bool ledger_processor::validate_epoch_block (nano::state_block const & block_a)
// Is epoch block signed correctly
if (validate_message (ledger.epoch_signer (block_a.link ()), block_a.hash (), block_a.signature))
{
result.code = nano::process_result::bad_signature;
result = nano::block_status::bad_signature;
}
}
}
@ -239,7 +239,7 @@ bool ledger_processor::validate_epoch_block (nano::state_block const & block_a)
void ledger_processor::state_block (nano::state_block & block_a)
{
result.code = nano::process_result::progress;
result = nano::block_status::progress;
auto is_epoch_block = false;
if (ledger.is_epoch_link (block_a.hashables.link))
{
@ -247,7 +247,7 @@ void ledger_processor::state_block (nano::state_block & block_a)
is_epoch_block = validate_epoch_block (block_a);
}
if (result.code == nano::process_result::progress)
if (result == nano::block_status::progress)
{
if (is_epoch_block)
{
@ -264,15 +264,15 @@ void ledger_processor::state_block_impl (nano::state_block & block_a)
{
auto hash (block_a.hash ());
auto existing (ledger.block_or_pruned_exists (transaction, hash));
result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block before? (Unambiguous)
if (result.code == nano::process_result::progress)
result = existing ? nano::block_status::old : nano::block_status::progress; // Have we seen this block before? (Unambiguous)
if (result == nano::block_status::progress)
{
result.code = validate_message (block_a.hashables.account, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is this block signed correctly (Unambiguous)
if (result.code == nano::process_result::progress)
result = validate_message (block_a.hashables.account, hash, block_a.signature) ? nano::block_status::bad_signature : nano::block_status::progress; // Is this block signed correctly (Unambiguous)
if (result == nano::block_status::progress)
{
debug_assert (!validate_message (block_a.hashables.account, hash, block_a.signature));
result.code = block_a.hashables.account.is_zero () ? nano::process_result::opened_burn_account : nano::process_result::progress; // Is this for the burn account? (Unambiguous)
if (result.code == nano::process_result::progress)
result = block_a.hashables.account.is_zero () ? nano::block_status::opened_burn_account : nano::block_status::progress; // Is this for the burn account? (Unambiguous)
if (result == nano::block_status::progress)
{
nano::epoch epoch (nano::epoch::epoch_0);
nano::epoch source_epoch (nano::epoch::epoch_0);
@ -285,44 +285,44 @@ void ledger_processor::state_block_impl (nano::state_block & block_a)
{
// Account already exists
epoch = info.epoch ();
result.code = block_a.hashables.previous.is_zero () ? nano::process_result::fork : nano::process_result::progress; // Has this account already been opened? (Ambigious)
if (result.code == nano::process_result::progress)
result = block_a.hashables.previous.is_zero () ? nano::block_status::fork : nano::block_status::progress; // Has this account already been opened? (Ambigious)
if (result == nano::block_status::progress)
{
result.code = ledger.store.block.exists (transaction, block_a.hashables.previous) ? nano::process_result::progress : nano::process_result::gap_previous; // Does the previous block exist in the ledger? (Unambigious)
if (result.code == nano::process_result::progress)
result = ledger.store.block.exists (transaction, block_a.hashables.previous) ? nano::block_status::progress : nano::block_status::gap_previous; // Does the previous block exist in the ledger? (Unambigious)
if (result == nano::block_status::progress)
{
is_send = block_a.hashables.balance < info.balance;
is_receive = !is_send && !block_a.hashables.link.is_zero ();
amount = is_send ? (info.balance.number () - amount.number ()) : (amount.number () - info.balance.number ());
result.code = block_a.hashables.previous == info.head ? nano::process_result::progress : nano::process_result::fork; // Is the previous block the account's head block? (Ambigious)
result = block_a.hashables.previous == info.head ? nano::block_status::progress : nano::block_status::fork; // Is the previous block the account's head block? (Ambigious)
}
}
}
else
{
// Account does not yet exists
result.code = block_a.previous ().is_zero () ? nano::process_result::progress : nano::process_result::gap_previous; // Does the first block in an account yield 0 for previous() ? (Unambigious)
if (result.code == nano::process_result::progress)
result = block_a.previous ().is_zero () ? nano::block_status::progress : nano::block_status::gap_previous; // Does the first block in an account yield 0 for previous() ? (Unambigious)
if (result == nano::block_status::progress)
{
is_receive = true;
result.code = !block_a.hashables.link.is_zero () ? nano::process_result::progress : nano::process_result::gap_source; // Is the first block receiving from a send ? (Unambigious)
result = !block_a.hashables.link.is_zero () ? nano::block_status::progress : nano::block_status::gap_source; // Is the first block receiving from a send ? (Unambigious)
}
}
if (result.code == nano::process_result::progress)
if (result == nano::block_status::progress)
{
if (!is_send)
{
if (!block_a.hashables.link.is_zero ())
{
result.code = ledger.block_or_pruned_exists (transaction, block_a.hashables.link.as_block_hash ()) ? nano::process_result::progress : nano::process_result::gap_source; // Have we seen the source block already? (Harmless)
if (result.code == nano::process_result::progress)
result = ledger.block_or_pruned_exists (transaction, block_a.hashables.link.as_block_hash ()) ? nano::block_status::progress : nano::block_status::gap_source; // Have we seen the source block already? (Harmless)
if (result == nano::block_status::progress)
{
nano::pending_key key (block_a.hashables.account, block_a.hashables.link.as_block_hash ());
nano::pending_info pending;
result.code = ledger.store.pending.get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed)
if (result.code == nano::process_result::progress)
result = ledger.store.pending.get (transaction, key, pending) ? nano::block_status::unreceivable : nano::block_status::progress; // Has this source already been received (Malformed)
if (result == nano::block_status::progress)
{
result.code = amount == pending.amount ? nano::process_result::progress : nano::process_result::balance_mismatch;
result = amount == pending.amount ? nano::block_status::progress : nano::block_status::balance_mismatch;
source_epoch = pending.epoch;
epoch = std::max (epoch, source_epoch);
}
@ -331,15 +331,15 @@ void ledger_processor::state_block_impl (nano::state_block & block_a)
else
{
// If there's no link, the balance must remain the same, only the representative can change
result.code = amount.is_zero () ? nano::process_result::progress : nano::process_result::balance_mismatch;
result = amount.is_zero () ? nano::block_status::progress : nano::block_status::balance_mismatch;
}
}
}
if (result.code == nano::process_result::progress)
if (result == nano::block_status::progress)
{
nano::block_details block_details (epoch, is_send, is_receive, false);
result.code = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed)
if (result.code == nano::process_result::progress)
result = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::block_status::progress : nano::block_status::insufficient_work; // Does this block have sufficient work? (Malformed)
if (result == nano::block_status::progress)
{
ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::state_block);
block_a.sideband_set (nano::block_sideband (block_a.hashables.account /* unused */, 0, 0 /* unused */, info.block_count + 1, nano::seconds_since_epoch (), block_details, source_epoch));
@ -384,55 +384,55 @@ void ledger_processor::epoch_block_impl (nano::state_block & block_a)
{
auto hash (block_a.hash ());
auto existing (ledger.block_or_pruned_exists (transaction, hash));
result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block before? (Unambiguous)
if (result.code == nano::process_result::progress)
result = existing ? nano::block_status::old : nano::block_status::progress; // Have we seen this block before? (Unambiguous)
if (result == nano::block_status::progress)
{
result.code = validate_message (ledger.epoch_signer (block_a.hashables.link), hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is this block signed correctly (Unambiguous)
if (result.code == nano::process_result::progress)
result = validate_message (ledger.epoch_signer (block_a.hashables.link), hash, block_a.signature) ? nano::block_status::bad_signature : nano::block_status::progress; // Is this block signed correctly (Unambiguous)
if (result == nano::block_status::progress)
{
debug_assert (!validate_message (ledger.epoch_signer (block_a.hashables.link), hash, block_a.signature));
result.code = block_a.hashables.account.is_zero () ? nano::process_result::opened_burn_account : nano::process_result::progress; // Is this for the burn account? (Unambiguous)
if (result.code == nano::process_result::progress)
result = block_a.hashables.account.is_zero () ? nano::block_status::opened_burn_account : nano::block_status::progress; // Is this for the burn account? (Unambiguous)
if (result == nano::block_status::progress)
{
nano::account_info info;
auto account_error (ledger.store.account.get (transaction, block_a.hashables.account, info));
if (!account_error)
{
// Account already exists
result.code = block_a.hashables.previous.is_zero () ? nano::process_result::fork : nano::process_result::progress; // Has this account already been opened? (Ambigious)
if (result.code == nano::process_result::progress)
result = block_a.hashables.previous.is_zero () ? nano::block_status::fork : nano::block_status::progress; // Has this account already been opened? (Ambigious)
if (result == nano::block_status::progress)
{
result.code = block_a.hashables.previous == info.head ? nano::process_result::progress : nano::process_result::fork; // Is the previous block the account's head block? (Ambigious)
if (result.code == nano::process_result::progress)
result = block_a.hashables.previous == info.head ? nano::block_status::progress : nano::block_status::fork; // Is the previous block the account's head block? (Ambigious)
if (result == nano::block_status::progress)
{
result.code = block_a.hashables.representative == info.representative ? nano::process_result::progress : nano::process_result::representative_mismatch;
result = block_a.hashables.representative == info.representative ? nano::block_status::progress : nano::block_status::representative_mismatch;
}
}
}
else
{
result.code = block_a.hashables.representative.is_zero () ? nano::process_result::progress : nano::process_result::representative_mismatch;
result = block_a.hashables.representative.is_zero () ? nano::block_status::progress : nano::block_status::representative_mismatch;
// Non-exisitng account should have pending entries
if (result.code == nano::process_result::progress)
if (result == nano::block_status::progress)
{
bool pending_exists = ledger.store.pending.any (transaction, block_a.hashables.account);
result.code = pending_exists ? nano::process_result::progress : nano::process_result::gap_epoch_open_pending;
result = pending_exists ? nano::block_status::progress : nano::block_status::gap_epoch_open_pending;
}
}
if (result.code == nano::process_result::progress)
if (result == nano::block_status::progress)
{
auto epoch = ledger.constants.epochs.epoch (block_a.hashables.link);
// Must be an epoch for an unopened account or the epoch upgrade must be sequential
auto is_valid_epoch_upgrade = account_error ? static_cast<std::underlying_type_t<nano::epoch>> (epoch) > 0 : nano::epochs::is_sequential (info.epoch (), epoch);
result.code = is_valid_epoch_upgrade ? nano::process_result::progress : nano::process_result::block_position;
if (result.code == nano::process_result::progress)
result = is_valid_epoch_upgrade ? nano::block_status::progress : nano::block_status::block_position;
if (result == nano::block_status::progress)
{
result.code = block_a.hashables.balance == info.balance ? nano::process_result::progress : nano::process_result::balance_mismatch;
if (result.code == nano::process_result::progress)
result = block_a.hashables.balance == info.balance ? nano::block_status::progress : nano::block_status::balance_mismatch;
if (result == nano::block_status::progress)
{
nano::block_details block_details (epoch, false, false, true);
result.code = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed)
if (result.code == nano::process_result::progress)
result = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::block_status::progress : nano::block_status::insufficient_work; // Does this block have sufficient work? (Malformed)
if (result == nano::block_status::progress)
{
ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::epoch_block);
block_a.sideband_set (nano::block_sideband (block_a.hashables.account /* unused */, 0, 0 /* unused */, info.block_count + 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */));
@ -456,29 +456,29 @@ void ledger_processor::change_block (nano::change_block & block_a)
{
auto hash (block_a.hash ());
auto existing (ledger.block_or_pruned_exists (transaction, hash));
result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block before? (Harmless)
if (result.code == nano::process_result::progress)
result = existing ? nano::block_status::old : nano::block_status::progress; // Have we seen this block before? (Harmless)
if (result == nano::block_status::progress)
{
auto previous (ledger.store.block.get (transaction, block_a.hashables.previous));
result.code = previous != nullptr ? nano::process_result::progress : nano::process_result::gap_previous; // Have we seen the previous block already? (Harmless)
if (result.code == nano::process_result::progress)
result = previous != nullptr ? nano::block_status::progress : nano::block_status::gap_previous; // Have we seen the previous block already? (Harmless)
if (result == nano::block_status::progress)
{
result.code = block_a.valid_predecessor (*previous) ? nano::process_result::progress : nano::process_result::block_position;
if (result.code == nano::process_result::progress)
result = block_a.valid_predecessor (*previous) ? nano::block_status::progress : nano::block_status::block_position;
if (result == nano::block_status::progress)
{
auto account (ledger.store.frontier.get (transaction, block_a.hashables.previous));
result.code = account.is_zero () ? nano::process_result::fork : nano::process_result::progress;
if (result.code == nano::process_result::progress)
result = account.is_zero () ? nano::block_status::fork : nano::block_status::progress;
if (result == nano::block_status::progress)
{
auto info = ledger.account_info (transaction, account);
debug_assert (info);
debug_assert (info->head == block_a.hashables.previous);
result.code = validate_message (account, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is this block signed correctly (Malformed)
if (result.code == nano::process_result::progress)
result = validate_message (account, hash, block_a.signature) ? nano::block_status::bad_signature : nano::block_status::progress; // Is this block signed correctly (Malformed)
if (result == nano::block_status::progress)
{
nano::block_details block_details (nano::epoch::epoch_0, false /* unused */, false /* unused */, false /* unused */);
result.code = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed)
if (result.code == nano::process_result::progress)
result = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::block_status::progress : nano::block_status::insufficient_work; // Does this block have sufficient work? (Malformed)
if (result == nano::block_status::progress)
{
debug_assert (!validate_message (account, hash, block_a.signature));
block_a.sideband_set (nano::block_sideband (account, 0, info->balance, info->block_count + 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */));
@ -502,33 +502,33 @@ void ledger_processor::send_block (nano::send_block & block_a)
{
auto hash (block_a.hash ());
auto existing (ledger.block_or_pruned_exists (transaction, hash));
result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block before? (Harmless)
if (result.code == nano::process_result::progress)
result = existing ? nano::block_status::old : nano::block_status::progress; // Have we seen this block before? (Harmless)
if (result == nano::block_status::progress)
{
auto previous (ledger.store.block.get (transaction, block_a.hashables.previous));
result.code = previous != nullptr ? nano::process_result::progress : nano::process_result::gap_previous; // Have we seen the previous block already? (Harmless)
if (result.code == nano::process_result::progress)
result = previous != nullptr ? nano::block_status::progress : nano::block_status::gap_previous; // Have we seen the previous block already? (Harmless)
if (result == nano::block_status::progress)
{
result.code = block_a.valid_predecessor (*previous) ? nano::process_result::progress : nano::process_result::block_position;
if (result.code == nano::process_result::progress)
result = block_a.valid_predecessor (*previous) ? nano::block_status::progress : nano::block_status::block_position;
if (result == nano::block_status::progress)
{
auto account (ledger.store.frontier.get (transaction, block_a.hashables.previous));
result.code = account.is_zero () ? nano::process_result::fork : nano::process_result::progress;
if (result.code == nano::process_result::progress)
result = account.is_zero () ? nano::block_status::fork : nano::block_status::progress;
if (result == nano::block_status::progress)
{
result.code = validate_message (account, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is this block signed correctly (Malformed)
if (result.code == nano::process_result::progress)
result = validate_message (account, hash, block_a.signature) ? nano::block_status::bad_signature : nano::block_status::progress; // Is this block signed correctly (Malformed)
if (result == nano::block_status::progress)
{
nano::block_details block_details (nano::epoch::epoch_0, false /* unused */, false /* unused */, false /* unused */);
result.code = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed)
if (result.code == nano::process_result::progress)
result = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::block_status::progress : nano::block_status::insufficient_work; // Does this block have sufficient work? (Malformed)
if (result == nano::block_status::progress)
{
debug_assert (!validate_message (account, hash, block_a.signature));
auto info = ledger.account_info (transaction, account);
debug_assert (info);
debug_assert (info->head == block_a.hashables.previous);
result.code = info->balance.number () >= block_a.hashables.balance.number () ? nano::process_result::progress : nano::process_result::negative_spend; // Is this trying to spend a negative amount (Malicious)
if (result.code == nano::process_result::progress)
result = info->balance.number () >= block_a.hashables.balance.number () ? nano::block_status::progress : nano::block_status::negative_spend; // Is this trying to spend a negative amount (Malicious)
if (result == nano::block_status::progress)
{
auto amount (info->balance.number () - block_a.hashables.balance.number ());
ledger.cache.rep_weights.representation_add (info->representative, 0 - amount);
@ -553,43 +553,43 @@ void ledger_processor::receive_block (nano::receive_block & block_a)
{
auto hash (block_a.hash ());
auto existing (ledger.block_or_pruned_exists (transaction, hash));
result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block already? (Harmless)
if (result.code == nano::process_result::progress)
result = existing ? nano::block_status::old : nano::block_status::progress; // Have we seen this block already? (Harmless)
if (result == nano::block_status::progress)
{
auto previous (ledger.store.block.get (transaction, block_a.hashables.previous));
result.code = previous != nullptr ? nano::process_result::progress : nano::process_result::gap_previous;
if (result.code == nano::process_result::progress)
result = previous != nullptr ? nano::block_status::progress : nano::block_status::gap_previous;
if (result == nano::block_status::progress)
{
result.code = block_a.valid_predecessor (*previous) ? nano::process_result::progress : nano::process_result::block_position;
if (result.code == nano::process_result::progress)
result = block_a.valid_predecessor (*previous) ? nano::block_status::progress : nano::block_status::block_position;
if (result == nano::block_status::progress)
{
auto account (ledger.store.frontier.get (transaction, block_a.hashables.previous));
result.code = account.is_zero () ? nano::process_result::gap_previous : nano::process_result::progress; // Have we seen the previous block? No entries for account at all (Harmless)
if (result.code == nano::process_result::progress)
result = account.is_zero () ? nano::block_status::gap_previous : nano::block_status::progress; // Have we seen the previous block? No entries for account at all (Harmless)
if (result == nano::block_status::progress)
{
result.code = validate_message (account, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is the signature valid (Malformed)
if (result.code == nano::process_result::progress)
result = validate_message (account, hash, block_a.signature) ? nano::block_status::bad_signature : nano::block_status::progress; // Is the signature valid (Malformed)
if (result == nano::block_status::progress)
{
debug_assert (!validate_message (account, hash, block_a.signature));
result.code = ledger.block_or_pruned_exists (transaction, block_a.hashables.source) ? nano::process_result::progress : nano::process_result::gap_source; // Have we seen the source block already? (Harmless)
if (result.code == nano::process_result::progress)
result = ledger.block_or_pruned_exists (transaction, block_a.hashables.source) ? nano::block_status::progress : nano::block_status::gap_source; // Have we seen the source block already? (Harmless)
if (result == nano::block_status::progress)
{
auto info = ledger.account_info (transaction, account);
debug_assert (info);
result.code = info->head == block_a.hashables.previous ? nano::process_result::progress : nano::process_result::gap_previous; // Block doesn't immediately follow latest block (Harmless)
if (result.code == nano::process_result::progress)
result = info->head == block_a.hashables.previous ? nano::block_status::progress : nano::block_status::gap_previous; // Block doesn't immediately follow latest block (Harmless)
if (result == nano::block_status::progress)
{
nano::pending_key key (account, block_a.hashables.source);
nano::pending_info pending;
result.code = ledger.store.pending.get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed)
if (result.code == nano::process_result::progress)
result = ledger.store.pending.get (transaction, key, pending) ? nano::block_status::unreceivable : nano::block_status::progress; // Has this source already been received (Malformed)
if (result == nano::block_status::progress)
{
result.code = pending.epoch == nano::epoch::epoch_0 ? nano::process_result::progress : nano::process_result::unreceivable; // Are we receiving a state-only send? (Malformed)
if (result.code == nano::process_result::progress)
result = pending.epoch == nano::epoch::epoch_0 ? nano::block_status::progress : nano::block_status::unreceivable; // Are we receiving a state-only send? (Malformed)
if (result == nano::block_status::progress)
{
nano::block_details block_details (nano::epoch::epoch_0, false /* unused */, false /* unused */, false /* unused */);
result.code = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed)
if (result.code == nano::process_result::progress)
result = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::block_status::progress : nano::block_status::insufficient_work; // Does this block have sufficient work? (Malformed)
if (result == nano::block_status::progress)
{
auto new_balance (info->balance.number () + pending.amount.number ());
#ifdef NDEBUG
@ -617,7 +617,7 @@ void ledger_processor::receive_block (nano::receive_block & block_a)
}
else
{
result.code = ledger.store.block.exists (transaction, block_a.hashables.previous) ? nano::process_result::fork : nano::process_result::gap_previous; // If we have the block but it's not the latest we have a signed fork (Malicious)
result = ledger.store.block.exists (transaction, block_a.hashables.previous) ? nano::block_status::fork : nano::block_status::gap_previous; // If we have the block but it's not the latest we have a signed fork (Malicious)
}
}
}
@ -628,34 +628,34 @@ void ledger_processor::open_block (nano::open_block & block_a)
{
auto hash (block_a.hash ());
auto existing (ledger.block_or_pruned_exists (transaction, hash));
result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block already? (Harmless)
if (result.code == nano::process_result::progress)
result = existing ? nano::block_status::old : nano::block_status::progress; // Have we seen this block already? (Harmless)
if (result == nano::block_status::progress)
{
result.code = validate_message (block_a.hashables.account, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is the signature valid (Malformed)
if (result.code == nano::process_result::progress)
result = validate_message (block_a.hashables.account, hash, block_a.signature) ? nano::block_status::bad_signature : nano::block_status::progress; // Is the signature valid (Malformed)
if (result == nano::block_status::progress)
{
debug_assert (!validate_message (block_a.hashables.account, hash, block_a.signature));
result.code = ledger.block_or_pruned_exists (transaction, block_a.hashables.source) ? nano::process_result::progress : nano::process_result::gap_source; // Have we seen the source block? (Harmless)
if (result.code == nano::process_result::progress)
result = ledger.block_or_pruned_exists (transaction, block_a.hashables.source) ? nano::block_status::progress : nano::block_status::gap_source; // Have we seen the source block? (Harmless)
if (result == nano::block_status::progress)
{
nano::account_info info;
result.code = ledger.store.account.get (transaction, block_a.hashables.account, info) ? nano::process_result::progress : nano::process_result::fork; // Has this account already been opened? (Malicious)
if (result.code == nano::process_result::progress)
result = ledger.store.account.get (transaction, block_a.hashables.account, info) ? nano::block_status::progress : nano::block_status::fork; // Has this account already been opened? (Malicious)
if (result == nano::block_status::progress)
{
nano::pending_key key (block_a.hashables.account, block_a.hashables.source);
nano::pending_info pending;
result.code = ledger.store.pending.get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed)
if (result.code == nano::process_result::progress)
result = ledger.store.pending.get (transaction, key, pending) ? nano::block_status::unreceivable : nano::block_status::progress; // Has this source already been received (Malformed)
if (result == nano::block_status::progress)
{
result.code = block_a.hashables.account == ledger.constants.burn_account ? nano::process_result::opened_burn_account : nano::process_result::progress; // Is it burning 0 account? (Malicious)
if (result.code == nano::process_result::progress)
result = block_a.hashables.account == ledger.constants.burn_account ? nano::block_status::opened_burn_account : nano::block_status::progress; // Is it burning 0 account? (Malicious)
if (result == nano::block_status::progress)
{
result.code = pending.epoch == nano::epoch::epoch_0 ? nano::process_result::progress : nano::process_result::unreceivable; // Are we receiving a state-only send? (Malformed)
if (result.code == nano::process_result::progress)
result = pending.epoch == nano::epoch::epoch_0 ? nano::block_status::progress : nano::block_status::unreceivable; // Are we receiving a state-only send? (Malformed)
if (result == nano::block_status::progress)
{
nano::block_details block_details (nano::epoch::epoch_0, false /* unused */, false /* unused */, false /* unused */);
result.code = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed)
if (result.code == nano::process_result::progress)
result = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::block_status::progress : nano::block_status::insufficient_work; // Does this block have sufficient work? (Malformed)
if (result == nano::block_status::progress)
{
#ifdef NDEBUG
if (ledger.store.block.exists (transaction, block_a.hashables.source))
@ -915,12 +915,12 @@ std::optional<nano::pending_info> nano::ledger::pending_info (store::transaction
return std::nullopt;
}
nano::process_return 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, nano::block & block_a)
{
debug_assert (!constants.work.validate_entry (block_a) || constants.genesis == nano::dev::genesis);
ledger_processor processor (*this, transaction_a);
block_a.visit (processor);
if (processor.result.code == nano::process_result::progress)
if (processor.result == nano::block_status::progress)
{
++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 &);
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;
nano::process_return process (store::write_transaction const &, nano::block &);
nano::block_status process (store::write_transaction const &, 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 &);
void update_account (store::write_transaction const &, nano::account const &, nano::account_info const &, nano::account_info const &);

62
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)
.work (*pool.generate (nano::dev::genesis->hash ()))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send));
auto open = builder
.open ()
.source (send->hash ())
@ -145,7 +145,7 @@ TEST (ledger, deep_account_compute)
.sign (key.prv, key.pub)
.work (*pool.generate (key.pub))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open));
auto sprevious (send->hash ());
auto rprevious (open->hash ());
for (auto i (0), n (100000); i != n; ++i)
@ -159,7 +159,7 @@ TEST (ledger, deep_account_compute)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (sprevious))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send));
sprevious = send->hash ();
auto receive = builder
.receive ()
@ -168,7 +168,7 @@ TEST (ledger, deep_account_compute)
.sign (key.prv, key.pub)
.work (*pool.generate (rprevious))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive));
rprevious = receive->hash ();
if (i % 100 == 0)
{
@ -278,7 +278,7 @@ TEST (node, fork_storm)
for (auto node_i : system.nodes)
{
auto send_result (node_i->process (*send));
ASSERT_EQ (nano::process_result::progress, send_result.code);
ASSERT_EQ (nano::block_status::progress, send_result);
nano::keypair rep;
auto open = builder
.open ()
@ -290,7 +290,7 @@ TEST (node, fork_storm)
.build_shared ();
node_i->work_generate_blocking (*open);
auto open_result (node_i->process (*open));
ASSERT_EQ (nano::process_result::progress, open_result.code);
ASSERT_EQ (nano::block_status::progress, open_result);
auto transaction (node_i->store.tx_begin_read ());
node_i->network.flood_block (open);
}
@ -660,7 +660,7 @@ TEST (confirmation_height, many_accounts_single_confirmation)
.sign (last_keypair.prv, last_keypair.pub)
.work (*system.work.generate (last_open_hash))
.build ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
auto open = builder
.open ()
.source (send->hash ())
@ -669,7 +669,7 @@ TEST (confirmation_height, many_accounts_single_confirmation)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open));
last_open_hash = open->hash ();
last_keypair = key;
}
@ -744,7 +744,7 @@ TEST (confirmation_height, many_accounts_many_confirmations)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_genesis))
.build ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
auto open = builder
.open ()
.source (send->hash ())
@ -753,7 +753,7 @@ TEST (confirmation_height, many_accounts_many_confirmations)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open));
open_blocks.push_back (std::move (open));
latest_genesis = send->hash ();
}
@ -826,8 +826,8 @@ TEST (confirmation_height, long_chains)
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open));
}
// Bulk send from genesis account to destination account
@ -845,7 +845,7 @@ TEST (confirmation_height, long_chains)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous_genesis_chain_hash))
.build ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
auto receive = builder
.receive ()
.previous (previous_destination_chain_hash)
@ -853,7 +853,7 @@ TEST (confirmation_height, long_chains)
.sign (key1.prv, key1.pub)
.work (*system.work.generate (previous_destination_chain_hash))
.build ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive));
previous_genesis_chain_hash = send->hash ();
previous_destination_chain_hash = receive->hash ();
@ -895,9 +895,9 @@ TEST (confirmation_height, long_chains)
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *receive1).code);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send2).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2));
}
// Call block confirm on the existing receive block on the genesis account which will confirm everything underneath on both accounts
@ -970,7 +970,7 @@ TEST (confirmation_height, dynamic_algorithm)
auto transaction = node->store.tx_begin_write ();
for (auto const & block : state_blocks)
{
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *block).code);
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_shared ();
latest_genesis = send->hash ();
state_blocks.push_back (send);
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
++num;
};
@ -1116,7 +1116,7 @@ TEST (confirmation_height, many_accounts_send_receive_self)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_genesis))
.build ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
auto open = builder
.open ()
.source (send->hash ())
@ -1125,7 +1125,7 @@ TEST (confirmation_height, many_accounts_send_receive_self)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open));
open_blocks.push_back (std::move (open));
latest_genesis = send->hash ();
}
@ -1263,7 +1263,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (latest_genesis))
.build ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send));
auto open = builder
.open ()
.source (send->hash ())
@ -1272,7 +1272,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections)
.sign (key.prv, key.pub)
.work (*pool.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open));
open_blocks.push_back (std::move (open));
latest_genesis = send->hash ();
}
@ -1316,8 +1316,8 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections)
.work (*system.work.generate (send_blocks.back ()->hash ()))
.build_shared ());
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send_blocks.back ()).code);
ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive_blocks.back ()).code);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send_blocks.back ()));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive_blocks.back ()));
}
}
@ -1688,7 +1688,7 @@ TEST (telemetry, many_nodes)
for (auto node : system.nodes)
{
auto transaction (node->store.tx_begin_write ());
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
}
// This is the node which will request metrics from all other nodes
@ -1788,7 +1788,7 @@ TEST (node, mass_epoch_upgrader)
.build (ec);
ASSERT_FALSE (ec);
ASSERT_NE (nullptr, block);
ASSERT_EQ (nano::process_result::progress, node.process (*block).code);
ASSERT_EQ (nano::block_status::progress, node.process (*block));
latest = block->hash ();
info.pending_hash = block->hash ();
}
@ -1812,7 +1812,7 @@ TEST (node, mass_epoch_upgrader)
.build (ec);
ASSERT_FALSE (ec);
ASSERT_NE (nullptr, block);
ASSERT_EQ (nano::process_result::progress, node.process (*block).code);
ASSERT_EQ (nano::block_status::progress, node.process (*block));
}
ASSERT_EQ (1 + total_accounts + opened.size (), node.ledger.cache.block_count);
ASSERT_EQ (1 + opened.size (), node.ledger.cache.account_count);
@ -2043,7 +2043,7 @@ TEST (node, aggressive_flooding)
for (auto const & block : genesis_blocks)
{
auto process_result (node_wallet.first->process (*block));
ASSERT_TRUE (nano::process_result::progress == process_result.code || nano::process_result::old == process_result.code);
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 (genesis_blocks.back ()->hash (), node_wallet.first->latest (nano::dev::genesis_key.pub));
@ -2083,7 +2083,7 @@ TEST (node, aggressive_flooding)
.build ();
}
// Processing locally goes through the aggressive block flooding path
ASSERT_EQ (nano::process_result::progress, node1.process_local (block).value ().code);
ASSERT_EQ (nano::block_status::progress, node1.process_local (block).value ());
auto all_have_block = [&nodes_wallets] (nano::block_hash const & hash_a) {
return std::all_of (nodes_wallets.begin (), nodes_wallets.end (), [hash = hash_a] (auto const & node_wallet) {
@ -2146,7 +2146,7 @@ TEST (node, wallet_create_block_confirm_conflicts)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build ();
ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
latest = send->hash ();
}
}

2
nano/test_common/ledger.cpp
View file

@ -13,7 +13,7 @@ nano::test::context::ledger_context::ledger_context (std::deque<std::shared_ptr<
for (auto const & i : blocks_m)
{
auto process_result = ledger_m.process (tx, *i);
debug_assert (process_result.code == nano::process_result::progress);
debug_assert (process_result == nano::block_status::progress);
}
}

4
nano/test_common/system.cpp
View file

@ -41,7 +41,7 @@ std::shared_ptr<nano::node> nano::test::system::add_node (nano::node_config cons
for (auto i : initialization_blocks)
{
auto result = node->ledger.process (node->store.tx_begin_write (), *i);
debug_assert (result.code == nano::process_result::progress);
debug_assert (result == nano::block_status::progress);
}
debug_assert (!node->init_error ());
auto wallet = node->wallets.create (nano::random_wallet_id ());
@ -262,7 +262,7 @@ std::unique_ptr<nano::state_block> nano::test::upgrade_epoch (nano::work_pool &
bool error{ true };
if (!ec && epoch)
{
error = ledger_a.process (transaction, *epoch).code != nano::process_result::progress;
error = ledger_a.process (transaction, *epoch) != nano::block_status::progress;
}
return !error ? std::move (epoch) : nullptr;

2
nano/test_common/testutil.cpp
View file

@ -65,7 +65,7 @@ bool nano::test::process (nano::node & node, std::vector<std::shared_ptr<nano::b
for (auto & block : blocks)
{
auto result = node.process (transaction, *block);
if (result.code != nano::process_result::progress)
if (result != nano::block_status::progress)
{
return false;
}