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

Merge pull request #4443 from clemahieu/ledger_process_ptr

Browse source 
Convert ledger::process to take a shared_ptr argument instead of a block reference.
This commit is contained in:
clemahieu 2024-02-23 10:29:39 +00:00 • committed by GitHub
commit 2903a9977a
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
45 changed files with 1342 additions and 1358 deletions
Download patch file Download diff file Expand all files Collapse all files

138
nano/core_test/active_transactions.cpp
View file

@ -39,7 +39,7 @@ TEST (active_transactions, confirm_election_by_request)
.balance (nano::dev::constants.genesis_amount - 100)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
// Process send1 locally on node1
ASSERT_TRUE (nano::test::process (node1, { send1 }));
@ -115,7 +115,7 @@ TEST (active_transactions, confirm_frontier)
.link (nano::public_key ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
{
// Voting node
@ -127,7 +127,7 @@ TEST (active_transactions, confirm_frontier)
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
// we cannot use the same block instance on 2 different nodes, so make a copy
auto send_copy = builder.make_block ().from (*send).build_shared ();
auto send_copy = builder.make_block ().from (*send).build ();
ASSERT_TRUE (nano::test::process (node1, { send_copy }));
ASSERT_TRUE (nano::test::start_elections (system, node1, { send_copy }));
ASSERT_TIMELY (5s, nano::test::confirmed (node1, { send_copy }));
@ -149,7 +149,7 @@ TEST (active_transactions, confirm_frontier)
node2.rep_crawler.probable_reps.emplace (nano::dev::genesis_key.pub, *peers.begin ());
}
ASSERT_EQ (nano::block_status::progress, node2.process (*send));
ASSERT_EQ (nano::block_status::progress, node2.process (send));
ASSERT_TIMELY (5s, !node2.active.empty ());
// Save election to check request count afterwards
@ -216,7 +216,7 @@ TEST (active_transactions, keep_local)
.link (send1->hash ())
.sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub))
.build_shared ();
.build ();
const auto receive2 = builder.make_block ()
.account (key2.pub)
.previous (0)
@ -225,7 +225,7 @@ TEST (active_transactions, keep_local)
.link (send2->hash ())
.sign (key2.prv, key2.pub)
.work (*system.work.generate (key2.pub))
.build_shared ();
.build ();
const auto receive3 = builder.make_block ()
.account (key3.pub)
.previous (0)
@ -234,7 +234,7 @@ TEST (active_transactions, keep_local)
.link (send3->hash ())
.sign (key3.prv, key3.pub)
.work (*system.work.generate (key3.pub))
.build_shared ();
.build ();
node.process_active (receive1);
node.process_active (receive2);
node.process_active (receive3);
@ -256,7 +256,7 @@ TEST (active_transactions, inactive_votes_cache)
.balance (nano::dev::constants.genesis_amount - 100)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
.build ();
auto vote = nano::test::make_final_vote (nano::dev::genesis_key, { send });
node.vote_processor.vote (vote, std::make_shared<nano::transport::inproc::channel> (node, node));
ASSERT_TIMELY_EQ (5s, node.vote_cache.size (), 1);
@ -279,7 +279,7 @@ TEST (active_transactions, inactive_votes_cache_non_final)
.balance (nano::dev::constants.genesis_amount - 100)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
// Non-final vote
auto vote = std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector<nano::block_hash> (1, send->hash ()));
@ -309,7 +309,7 @@ TEST (active_transactions, inactive_votes_cache_fork)
.balance (nano::dev::constants.genesis_amount - 100)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
.build ();
auto send2 = builder.make_block ()
.previous (latest)
@ -317,7 +317,7 @@ TEST (active_transactions, inactive_votes_cache_fork)
.balance (nano::dev::constants.genesis_amount - 200)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
.build ();
auto const vote = nano::test::make_final_vote (nano::dev::genesis_key, { send1 });
node.vote_processor.vote (vote, std::make_shared<nano::transport::inproc::channel> (node, node));
@ -349,7 +349,7 @@ TEST (active_transactions, inactive_votes_cache_existing_vote)
.balance (nano::dev::constants.genesis_amount - 100 * nano::Gxrb_ratio)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
.build ();
auto open = builder.state ()
.account (key.pub)
.previous (0)
@ -358,7 +358,7 @@ TEST (active_transactions, inactive_votes_cache_existing_vote)
.link (send->hash ())
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
.build ();
node.process_active (send);
node.block_processor.add (open);
ASSERT_TIMELY_EQ (5s, node.active.size (), 1);
@ -404,7 +404,7 @@ TEST (active_transactions, inactive_votes_cache_multiple_votes)
.balance (nano::dev::constants.genesis_amount - 100 * nano::Gxrb_ratio)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
auto send2 = builder.send ()
.previous (send1->hash ())
@ -412,7 +412,7 @@ TEST (active_transactions, inactive_votes_cache_multiple_votes)
.balance (100 * nano::Gxrb_ratio)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
.build ();
auto open = builder.state ()
.account (key1.pub)
@ -422,7 +422,7 @@ TEST (active_transactions, inactive_votes_cache_multiple_votes)
.link (send1->hash ())
.sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub))
.build_shared ();
.build ();
// put the blocks in the ledger witout triggering an election
ASSERT_TRUE (nano::test::process (node, { send1, send2, open }));
@ -464,14 +464,14 @@ TEST (active_transactions, inactive_votes_cache_election_start)
.balance (nano::dev::constants.genesis_amount - amount)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
.build ();
auto send2 = send_block_builder.make_block ()
.previous (send1->hash ())
.destination (key2.pub)
.balance (nano::dev::constants.genesis_amount - 2 * amount)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
.build ();
auto open1 = state_block_builder.make_block ()
.account (key1.pub)
.previous (0)
@ -480,7 +480,7 @@ TEST (active_transactions, inactive_votes_cache_election_start)
.link (send1->hash ())
.sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub))
.build_shared ();
.build ();
auto open2 = state_block_builder.make_block ()
.account (key2.pub)
.previous (0)
@ -489,11 +489,11 @@ TEST (active_transactions, inactive_votes_cache_election_start)
.link (send2->hash ())
.sign (key2.prv, key2.pub)
.work (*system.work.generate (key2.pub))
.build_shared ();
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));
.build ();
ASSERT_EQ (nano::block_status::progress, node.process (send1));
ASSERT_EQ (nano::block_status::progress, node.process (send2));
ASSERT_EQ (nano::block_status::progress, node.process (open1));
ASSERT_EQ (nano::block_status::progress, node.process (open2));
ASSERT_TIMELY_EQ (5s, 5, node.ledger.cache.block_count);
ASSERT_TRUE (node.active.empty ());
ASSERT_EQ (1, node.ledger.cache.cemented_count);
@ -504,14 +504,14 @@ TEST (active_transactions, inactive_votes_cache_election_start)
.balance (send2->balance ().number () - 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send2->hash ()))
.build_shared ();
.build ();
auto send4 = send_block_builder.make_block ()
.previous (send3->hash ())
.destination (nano::keypair ().pub)
.balance (send3->balance ().number () - 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send3->hash ()))
.build_shared ();
.build ();
// Inactive votes
auto vote1 = nano::test::make_vote (key1, { open1, open2, send4 });
@ -569,7 +569,7 @@ TEST (active_transactions, vote_replays)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
ASSERT_NE (nullptr, send1);
// create open block for key receing Gxrb_ratio raw
@ -581,7 +581,7 @@ TEST (active_transactions, vote_replays)
.link (send1->hash ())
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
.build ();
ASSERT_NE (nullptr, open1);
// wait for elections objects to appear in the AEC
@ -616,7 +616,7 @@ TEST (active_transactions, vote_replays)
.link (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (open1->hash ()))
.build_shared ();
.build ();
ASSERT_NE (nullptr, send2);
node.process_active (send2);
ASSERT_TRUE (nano::test::start_elections (system, node, { send2 }));
@ -726,7 +726,7 @@ TEST (active_transactions, republish_winner)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
node1.process_active (send1);
ASSERT_TIMELY (5s, nano::test::exists (node1, { send1 }));
@ -743,7 +743,7 @@ TEST (active_transactions, republish_winner)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
node1.process_active (fork);
ASSERT_TIMELY (5s, node1.active.active (*fork));
}
@ -759,7 +759,7 @@ TEST (active_transactions, republish_winner)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
node1.process_active (fork);
ASSERT_TIMELY (5s, node1.active.active (fork->hash ()));
@ -793,7 +793,7 @@ TEST (active_transactions, fork_filter_cleanup)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_hash))
.build_shared ();
.build ();
std::vector<uint8_t> send_block_bytes{};
{
@ -812,7 +812,7 @@ TEST (active_transactions, fork_filter_cleanup)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_hash))
.build_shared ();
.build ();
node1.process_active (fork);
ASSERT_TIMELY (5s, node1.active.election (fork->qualified_root ()) != nullptr);
@ -882,7 +882,7 @@ TEST (active_transactions, fork_replacement_tally)
.link (keys[i].pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
.build ();
node1.process_active (send);
latest = send->hash ();
auto open = builder.make_block ()
@ -893,7 +893,7 @@ TEST (active_transactions, fork_replacement_tally)
.link (send->hash ())
.sign (keys[i].prv, keys[i].pub)
.work (*system.work.generate (keys[i].pub))
.build_shared ();
.build ();
node1.process_active (open);
// Confirmation
auto vote = nano::test::make_final_vote (nano::dev::genesis_key, { send, open });
@ -910,7 +910,7 @@ TEST (active_transactions, fork_replacement_tally)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
.build ();
// Forks without votes
for (auto i (0); i < reps_count; i++)
@ -923,7 +923,7 @@ TEST (active_transactions, fork_replacement_tally)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
.build ();
node1.process_active (fork);
}
@ -943,7 +943,7 @@ TEST (active_transactions, fork_replacement_tally)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
.build ();
auto vote = nano::test::make_vote (keys[i], { fork }, 0, 0);
node1.vote_processor.vote (vote, std::make_shared<nano::transport::inproc::channel> (node1, node1));
node1.vote_processor.flush ();
@ -1051,7 +1051,7 @@ TEST (active_transactions, confirm_new)
.balance (nano::dev::constants.genesis_amount - 100)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
node1.process_active (send);
ASSERT_TIMELY_EQ (5s, 1, node1.active.size ());
auto & node2 = *system.add_node ();
@ -1081,7 +1081,7 @@ TEST (active_transactions, conflicting_block_vote_existing_election)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
auto fork = builder.make_block ()
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
@ -1090,7 +1090,7 @@ TEST (active_transactions, conflicting_block_vote_existing_election)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
auto vote_fork = nano::test::make_final_vote (nano::dev::genesis_key, { fork });
ASSERT_EQ (nano::block_status::progress, node.process_local (send).value ());
@ -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::block_status::progress, node.process (*send));
ASSERT_EQ (nano::block_status::progress, node.process (*send2));
ASSERT_EQ (nano::block_status::progress, node.process (*send3));
ASSERT_EQ (nano::block_status::progress, node.process (*open));
ASSERT_EQ (nano::block_status::progress, node.process (*receive));
ASSERT_EQ (nano::block_status::progress, node.process (send));
ASSERT_EQ (nano::block_status::progress, node.process (send2));
ASSERT_EQ (nano::block_status::progress, node.process (send3));
ASSERT_EQ (nano::block_status::progress, node.process (open));
ASSERT_EQ (nano::block_status::progress, node.process (receive));
node.scheduler.priority.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
ASSERT_TIMELY (5s, node.active.election (send->qualified_root ()));
@ -1226,7 +1226,7 @@ TEST (active_transactions, activate_inactive)
.balance (nano::dev::constants.genesis_amount - 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
auto send2 = builder.make_block ()
.account (nano::dev::genesis_key.pub)
.previous (send->hash ())
@ -1235,7 +1235,7 @@ TEST (active_transactions, activate_inactive)
.balance (nano::dev::constants.genesis_amount - 2)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send->hash ()))
.build_shared ();
.build ();
auto open = builder.make_block ()
.account (key.pub)
.previous (0)
@ -1244,11 +1244,11 @@ TEST (active_transactions, activate_inactive)
.balance (1)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
.build ();
ASSERT_EQ (nano::block_status::progress, node.process (*send));
ASSERT_EQ (nano::block_status::progress, node.process (*send2));
ASSERT_EQ (nano::block_status::progress, node.process (*open));
ASSERT_EQ (nano::block_status::progress, node.process (send));
ASSERT_EQ (nano::block_status::progress, node.process (send2));
ASSERT_EQ (nano::block_status::progress, node.process (open));
auto election = nano::test::start_election (system, node, send2->hash ());
ASSERT_NE (nullptr, election);
@ -1281,9 +1281,9 @@ TEST (active_transactions, list_active)
.balance (nano::dev::constants.genesis_amount - 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
ASSERT_EQ (nano::block_status::progress, node.process (*send));
ASSERT_EQ (nano::block_status::progress, node.process (send));
auto send2 = builder.make_block ()
.account (nano::dev::genesis_key.pub)
@ -1293,9 +1293,9 @@ TEST (active_transactions, list_active)
.balance (nano::dev::constants.genesis_amount - 2)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send->hash ()))
.build_shared ();
.build ();
ASSERT_EQ (nano::block_status::progress, node.process (*send2));
ASSERT_EQ (nano::block_status::progress, node.process (send2));
auto open = builder.make_block ()
.account (key.pub)
@ -1305,9 +1305,9 @@ TEST (active_transactions, list_active)
.balance (1)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
.build ();
ASSERT_EQ (nano::block_status::progress, node.process (*open));
ASSERT_EQ (nano::block_status::progress, node.process (open));
ASSERT_TRUE (nano::test::start_elections (system, node, { send, send2, open }));
ASSERT_EQ (3, node.active.size ());
@ -1338,9 +1338,9 @@ TEST (active_transactions, vacancy)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
node.active.vacancy_update = [&updated] () { updated = true; };
ASSERT_EQ (nano::block_status::progress, node.process (*send));
ASSERT_EQ (nano::block_status::progress, node.process (send));
ASSERT_EQ (1, node.active.vacancy ());
ASSERT_EQ (0, node.active.size ());
node.scheduler.priority.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ());
@ -1380,8 +1380,8 @@ TEST (active_transactions, fifo)
.balance (nano::dev::constants.genesis_amount - 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_hash))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node.process (*send1));
.build ();
ASSERT_EQ (nano::block_status::progress, node.process (send1));
node.process_confirmed (nano::election_status{ send1 });
ASSERT_TIMELY (5s, node.block_confirmed (send1->hash ()));
@ -1395,8 +1395,8 @@ TEST (active_transactions, fifo)
.balance (nano::dev::constants.genesis_amount - 2)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_hash))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node.process (*send2));
.build ();
ASSERT_EQ (nano::block_status::progress, node.process (send2));
node.process_confirmed (nano::election_status{ send2 });
ASSERT_TIMELY (5s, node.block_confirmed (send2->hash ()));
@ -1408,8 +1408,8 @@ TEST (active_transactions, fifo)
.balance (1)
.sign (key0.prv, key0.pub)
.work (*system.work.generate (key0.pub))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node.process (*receive1));
.build ();
ASSERT_EQ (nano::block_status::progress, node.process (receive1));
auto receive2 = builder.make_block ()
.previous (0)
@ -1419,8 +1419,8 @@ TEST (active_transactions, fifo)
.balance (1)
.sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node.process (*receive2));
.build ();
ASSERT_EQ (nano::block_status::progress, node.process (receive2));
// Ensure first transaction becomes active
node.scheduler.manual.push (receive1);

14
nano/core_test/block.cpp
View file

@ -385,7 +385,7 @@ TEST (block, publish_req_serialization)
.balance (200)
.sign (nano::keypair ().prv, 2)
.work (3)
.build_shared ();
.build ();
nano::publish req{ nano::dev::network_params.network, block };
std::vector<uint8_t> bytes;
{
@ -429,7 +429,7 @@ TEST (state_block, serialization)
.link (4)
.sign (key1.prv, key1.pub)
.work (5)
.build_shared ();
.build ();
ASSERT_EQ (key1.pub, block1->hashables.account);
ASSERT_EQ (nano::block_hash (1), block1->previous ());
ASSERT_EQ (key2.pub, block1->hashables.representative);
@ -489,7 +489,7 @@ TEST (state_block, hashing)
.link (0)
.sign (key.prv, key.pub)
.work (0)
.build_shared ();
.build ();
auto hash (block->hash ());
ASSERT_EQ (hash, block->hash ()); // check cache works
block->hashables.account.bytes[0] ^= 0x1;
@ -551,7 +551,7 @@ TEST (block_uniquer, single)
.link (0)
.sign (key.prv, key.pub)
.work (0)
.build_shared ();
.build ();
auto block2 (std::make_shared<nano::state_block> (*block1));
ASSERT_NE (block1, block2);
ASSERT_EQ (*block1, *block2);
@ -578,7 +578,7 @@ TEST (block_uniquer, cleanup)
.link (0)
.sign (key.prv, key.pub)
.work (0)
.build_shared ();
.build ();
auto block2 = builder
.make_block ()
.account (0)
@ -588,7 +588,7 @@ TEST (block_uniquer, cleanup)
.link (0)
.sign (key.prv, key.pub)
.work (1)
.build_shared ();
.build ();
nano::block_uniquer uniquer;
auto block3 = uniquer.unique (block1);
@ -636,7 +636,7 @@ TEST (block_builder, zeroed_state_block)
.link (0)
.sign (key.prv, key.pub)
.work (0)
.build_shared ();
.build ();
auto zero_block_build = builder.state ().zero ().sign (key.prv, key.pub).build ();
ASSERT_EQ (zero_block_manual->hash (), zero_block_build->hash ());
ASSERT_FALSE (nano::validate_message (key.pub, zero_block_build->hash (), zero_block_build->signature));

24
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::block_status::progress, ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send));
auto receive = builder
.receive ()
.previous (send->hash ())
@ -1029,7 +1029,7 @@ TEST (mdb_block_store, sideband_height)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (send->hash ()))
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive));
auto change = builder
.change ()
.previous (receive->hash ())
@ -1037,7 +1037,7 @@ TEST (mdb_block_store, sideband_height)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (receive->hash ()))
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *change));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change));
auto state_send1 = builder
.state ()
.account (nano::dev::genesis_key.pub)
@ -1048,7 +1048,7 @@ TEST (mdb_block_store, sideband_height)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (change->hash ()))
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_send1));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, state_send1));
auto state_send2 = builder
.state ()
.account (nano::dev::genesis_key.pub)
@ -1059,7 +1059,7 @@ TEST (mdb_block_store, sideband_height)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (state_send1->hash ()))
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_send2));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, state_send2));
auto state_send3 = builder
.state ()
.account (nano::dev::genesis_key.pub)
@ -1070,7 +1070,7 @@ TEST (mdb_block_store, sideband_height)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (state_send2->hash ()))
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_send3));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, state_send3));
auto state_open = builder
.state ()
.account (key1.pub)
@ -1081,7 +1081,7 @@ TEST (mdb_block_store, sideband_height)
.sign (key1.prv, key1.pub)
.work (*pool.generate (key1.pub))
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_open));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, state_open));
auto epoch = builder
.state ()
.account (key1.pub)
@ -1092,7 +1092,7 @@ TEST (mdb_block_store, sideband_height)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (state_open->hash ()))
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch));
ASSERT_EQ (nano::epoch::epoch_1, ledger.version (*epoch));
auto epoch_open = builder
.state ()
@ -1104,7 +1104,7 @@ TEST (mdb_block_store, sideband_height)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (key2.pub))
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *epoch_open));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, epoch_open));
ASSERT_EQ (nano::epoch::epoch_1, ledger.version (*epoch_open));
auto state_receive = builder
.state ()
@ -1116,7 +1116,7 @@ TEST (mdb_block_store, sideband_height)
.sign (key2.prv, key2.pub)
.work (*pool.generate (epoch_open->hash ()))
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *state_receive));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, state_receive));
auto open = builder
.open ()
.source (state_send3->hash ())
@ -1125,7 +1125,7 @@ TEST (mdb_block_store, sideband_height)
.sign (key3.prv, key3.pub)
.work (*pool.generate (key3.pub))
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open));
auto block1 (store.block.get (transaction, nano::dev::genesis->hash ()));
ASSERT_EQ (block1->sideband ().height, 1);
auto block2 (store.block.get (transaction, send->hash ()));
@ -1673,7 +1673,7 @@ TEST (rocksdb_block_store, tombstone_count)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (5)
.build_shared ();
.build ();
// Enqueues a block to be saved in the database
nano::account account{ 1 };
store->account.put (store->tx_begin_write (), account, nano::account_info{});

2
nano/core_test/blockprocessor.cpp
View file

@ -32,7 +32,7 @@ TEST (block_processor, broadcast_block_on_arrival)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
// Adds a block to the first node. process_active() -> (calls) block_processor.add() -> add() ->
// awakes process_block() -> process_batch() -> process_one() -> process_live()
node1->process_active (send1);

226
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::block_status::progress, system.nodes[0]->process (*open));
ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (open));
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*system.nodes[0], nano::transport::socket::endpoint_type_t::server), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = key2.pub;
@ -120,9 +120,9 @@ TEST (bulk_pull, ascending_one_hash)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
node.work_generate_blocking (*block1);
ASSERT_EQ (nano::block_status::progress, node.process (*block1));
ASSERT_EQ (nano::block_status::progress, node.process (block1));
auto socket = std::make_shared<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);
@ -152,9 +152,9 @@ TEST (bulk_pull, ascending_two_account)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
node.work_generate_blocking (*block1);
ASSERT_EQ (nano::block_status::progress, node.process (*block1));
ASSERT_EQ (nano::block_status::progress, node.process (block1));
auto socket = std::make_shared<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);
@ -187,9 +187,9 @@ TEST (bulk_pull, ascending_end)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
node.work_generate_blocking (*block1);
ASSERT_EQ (nano::block_status::progress, node.process (*block1));
ASSERT_EQ (nano::block_status::progress, node.process (block1));
auto socket = std::make_shared<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);
@ -248,16 +248,16 @@ TEST (bulk_pull, count_limit)
.balance (1)
.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::block_status::progress, node0->process (*send1));
.build ();
ASSERT_EQ (nano::block_status::progress, node0->process (send1));
auto receive1 = builder
.receive ()
.previous (send1->hash ())
.source (send1->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node0->process (*receive1));
.build ();
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);
@ -361,7 +361,7 @@ TEST (bootstrap_processor, process_state)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
auto block2 = builder
.make_block ()
.account (nano::dev::genesis_key.pub)
@ -371,12 +371,12 @@ TEST (bootstrap_processor, process_state)
.link (block1->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
node0->work_generate_blocking (*block1);
node0->work_generate_blocking (*block2);
ASSERT_EQ (nano::block_status::progress, node0->process (*block1));
ASSERT_EQ (nano::block_status::progress, node0->process (*block2));
ASSERT_EQ (nano::block_status::progress, node0->process (block1));
ASSERT_EQ (nano::block_status::progress, node0->process (block2));
ASSERT_TIMELY_EQ (5s, nano::test::account_info (*node0, nano::dev::genesis_key.pub).block_count, 3);
auto node1 = system.make_disconnected_node (std::nullopt, node_flags);
@ -443,8 +443,8 @@ TEST (bootstrap_processor, pull_diamond)
.balance (0)
.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::block_status::progress, node0->process (*send1));
.build ();
ASSERT_EQ (nano::block_status::progress, node0->process (send1));
auto open = builder
.open ()
.source (send1->hash ())
@ -452,8 +452,8 @@ TEST (bootstrap_processor, pull_diamond)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node0->process (*open));
.build ();
ASSERT_EQ (nano::block_status::progress, node0->process (open));
auto send2 = builder
.send ()
.previous (open->hash ())
@ -461,16 +461,16 @@ TEST (bootstrap_processor, pull_diamond)
.balance (std::numeric_limits<nano::uint128_t>::max () - 100)
.sign (key.prv, key.pub)
.work (*system.work.generate (open->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node0->process (*send2));
.build ();
ASSERT_EQ (nano::block_status::progress, node0->process (send2));
auto receive = builder
.receive ()
.previous (send1->hash ())
.source (send2->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node0->process (*receive));
.build ();
ASSERT_EQ (nano::block_status::progress, node0->process (receive));
auto node1 = system.make_disconnected_node ();
node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false);
@ -501,7 +501,7 @@ TEST (bootstrap_processor, DISABLED_pull_requeue_network_error)
.link (key1.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
node1->bootstrap_initiator.bootstrap (node2->network.endpoint ());
auto attempt (node1->bootstrap_initiator.current_attempt ());
@ -540,8 +540,8 @@ TEST (bootstrap_processor, push_diamond)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send1));
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (send1));
// open key account receiving all balance of genesis
auto open = builder
@ -551,8 +551,8 @@ TEST (bootstrap_processor, push_diamond)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*open));
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (open));
// send from key to genesis 100 raw
auto send2 = builder
@ -562,8 +562,8 @@ TEST (bootstrap_processor, push_diamond)
.balance (std::numeric_limits<nano::uint128_t>::max () - 100)
.sign (key.prv, key.pub)
.work (*system.work.generate (open->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send2));
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (send2));
// receive the 100 raw on genesis
auto receive = builder
@ -572,8 +572,8 @@ TEST (bootstrap_processor, push_diamond)
.source (send2->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*receive));
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (receive));
nano::node_config config = system.default_config ();
config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled;
@ -613,8 +613,8 @@ TEST (bootstrap_processor, push_diamond_pruning)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send1));
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (send1));
// receive all balance on key
auto open = builder
@ -624,8 +624,8 @@ TEST (bootstrap_processor, push_diamond_pruning)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*open));
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (open));
// 1st bootstrap
node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false);
@ -642,8 +642,8 @@ TEST (bootstrap_processor, push_diamond_pruning)
.balance (std::numeric_limits<nano::uint128_t>::max () - 100)
.sign (key.prv, key.pub)
.work (*system.work.generate (open->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send2));
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (send2));
// receive the 100 raw from key on genesis
auto receive = builder
@ -652,8 +652,8 @@ TEST (bootstrap_processor, push_diamond_pruning)
.source (send2->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*receive));
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (receive));
{
auto transaction (node1->store.tx_begin_write ());
@ -722,7 +722,7 @@ TEST (bootstrap_processor, lazy_hash)
.link (key1.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
auto receive1 = builder
.make_block ()
.account (key1.pub)
@ -732,7 +732,7 @@ TEST (bootstrap_processor, lazy_hash)
.link (send1->hash ())
.sign (key1.prv, key1.pub)
.work (*node0->work_generate_blocking (key1.pub))
.build_shared ();
.build ();
auto send2 = builder
.make_block ()
.account (key1.pub)
@ -742,7 +742,7 @@ TEST (bootstrap_processor, lazy_hash)
.link (key2.pub)
.sign (key1.prv, key1.pub)
.work (*node0->work_generate_blocking (receive1->hash ()))
.build_shared ();
.build ();
auto receive2 = builder
.make_block ()
.account (key2.pub)
@ -752,7 +752,7 @@ TEST (bootstrap_processor, lazy_hash)
.link (send2->hash ())
.sign (key2.prv, key2.pub)
.work (*node0->work_generate_blocking (key2.pub))
.build_shared ();
.build ();
// Processing test chain
node0->block_processor.add (send1);
@ -797,7 +797,7 @@ TEST (bootstrap_processor, lazy_hash_bootstrap_id)
.link (key1.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
auto receive1 = builder
.make_block ()
.account (key1.pub)
@ -807,7 +807,7 @@ TEST (bootstrap_processor, lazy_hash_bootstrap_id)
.link (send1->hash ())
.sign (key1.prv, key1.pub)
.work (*node0->work_generate_blocking (key1.pub))
.build_shared ();
.build ();
auto send2 = builder
.make_block ()
.account (key1.pub)
@ -817,7 +817,7 @@ TEST (bootstrap_processor, lazy_hash_bootstrap_id)
.link (key2.pub)
.sign (key1.prv, key1.pub)
.work (*node0->work_generate_blocking (receive1->hash ()))
.build_shared ();
.build ();
auto receive2 = builder
.make_block ()
.account (key2.pub)
@ -827,7 +827,7 @@ TEST (bootstrap_processor, lazy_hash_bootstrap_id)
.link (send2->hash ())
.sign (key2.prv, key2.pub)
.work (*node0->work_generate_blocking (key2.pub))
.build_shared ();
.build ();
// Processing test chain
node0->block_processor.add (send1);
@ -872,7 +872,7 @@ TEST (bootstrap_processor, lazy_hash_pruning)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
// receive send1
auto receive1 = builder
@ -884,7 +884,7 @@ TEST (bootstrap_processor, lazy_hash_pruning)
.link (send1->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (send1->hash ()))
.build_shared ();
.build ();
// change rep of genesis account to be key1
nano::keypair key1;
@ -897,7 +897,7 @@ TEST (bootstrap_processor, lazy_hash_pruning)
.link (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (receive1->hash ()))
.build_shared ();
.build ();
// change rep of genesis account to be rep2
nano::keypair key2;
@ -910,7 +910,7 @@ TEST (bootstrap_processor, lazy_hash_pruning)
.link (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (change1->hash ()))
.build_shared ();
.build ();
// send Gxrb_ratio from genesis to key1 and genesis rep back to genesis account
auto send2 = builder
@ -922,7 +922,7 @@ TEST (bootstrap_processor, lazy_hash_pruning)
.link (key1.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (change2->hash ()))
.build_shared ();
.build ();
// receive send2 and rep of key1 to be itself
auto receive2 = builder
@ -934,7 +934,7 @@ TEST (bootstrap_processor, lazy_hash_pruning)
.link (send2->hash ())
.sign (key1.prv, key1.pub)
.work (*node0->work_generate_blocking (key1.pub))
.build_shared ();
.build ();
// send Gxrb_ratio raw, all available balance, from key1 to key2
auto send3 = builder
@ -946,7 +946,7 @@ TEST (bootstrap_processor, lazy_hash_pruning)
.link (key2.pub)
.sign (key1.prv, key1.pub)
.work (*node0->work_generate_blocking (receive2->hash ()))
.build_shared ();
.build ();
// receive send3 on key2, set rep of key2 to be itself
auto receive3 = builder
@ -958,7 +958,7 @@ TEST (bootstrap_processor, lazy_hash_pruning)
.link (send3->hash ())
.sign (key2.prv, key2.pub)
.work (*node0->work_generate_blocking (key2.pub))
.build_shared ();
.build ();
std::vector<std::shared_ptr<nano::block>> blocks = { send1, receive1, change1, change2, send2, receive2, send3, receive3 };
ASSERT_TRUE (nano::test::process (*node0, blocks));
@ -1025,7 +1025,7 @@ TEST (bootstrap_processor, lazy_max_pull_count)
.link (key1.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
auto receive1 = builder
.make_block ()
.account (key1.pub)
@ -1035,7 +1035,7 @@ TEST (bootstrap_processor, lazy_max_pull_count)
.link (send1->hash ())
.sign (key1.prv, key1.pub)
.work (*node0->work_generate_blocking (key1.pub))
.build_shared ();
.build ();
auto send2 = builder
.make_block ()
.account (key1.pub)
@ -1045,7 +1045,7 @@ TEST (bootstrap_processor, lazy_max_pull_count)
.link (key2.pub)
.sign (key1.prv, key1.pub)
.work (*node0->work_generate_blocking (receive1->hash ()))
.build_shared ();
.build ();
auto receive2 = builder
.make_block ()
.account (key2.pub)
@ -1055,7 +1055,7 @@ TEST (bootstrap_processor, lazy_max_pull_count)
.link (send2->hash ())
.sign (key2.prv, key2.pub)
.work (*node0->work_generate_blocking (key2.pub))
.build_shared ();
.build ();
auto change1 = builder
.make_block ()
.account (key2.pub)
@ -1065,7 +1065,7 @@ TEST (bootstrap_processor, lazy_max_pull_count)
.link (0)
.sign (key2.prv, key2.pub)
.work (*node0->work_generate_blocking (receive2->hash ()))
.build_shared ();
.build ();
auto change2 = builder
.make_block ()
.account (key2.pub)
@ -1075,7 +1075,7 @@ TEST (bootstrap_processor, lazy_max_pull_count)
.link (0)
.sign (key2.prv, key2.pub)
.work (*node0->work_generate_blocking (change1->hash ()))
.build_shared ();
.build ();
auto change3 = builder
.make_block ()
.account (key2.pub)
@ -1085,7 +1085,7 @@ TEST (bootstrap_processor, lazy_max_pull_count)
.link (0)
.sign (key2.prv, key2.pub)
.work (*node0->work_generate_blocking (change2->hash ()))
.build_shared ();
.build ();
// Processing test chain
node0->block_processor.add (send1);
node0->block_processor.add (receive1);
@ -1129,8 +1129,8 @@ TEST (bootstrap_processor, lazy_unclear_state_link)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send1));
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (send1));
auto send2 = builder
.state ()
.account (nano::dev::genesis_key.pub)
@ -1140,8 +1140,8 @@ TEST (bootstrap_processor, lazy_unclear_state_link)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send2));
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (send2));
auto open = builder
.open ()
.source (send1->hash ())
@ -1149,8 +1149,8 @@ TEST (bootstrap_processor, lazy_unclear_state_link)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*open));
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (open));
auto receive = builder
.state ()
.account (key.pub)
@ -1160,8 +1160,8 @@ TEST (bootstrap_processor, lazy_unclear_state_link)
.link (send2->hash ())
.sign (key.prv, key.pub)
.work (*system.work.generate (open->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*receive));
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (receive));
ASSERT_TIMELY (5s, nano::test::exists (*node1, { send1, send2, open, receive }));
@ -1199,8 +1199,8 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send1));
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (send1));
auto open = builder
.open ()
.source (send1->hash ())
@ -1208,8 +1208,8 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*open));
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (open));
auto send2 = builder
.state ()
.account (key.pub)
@ -1219,8 +1219,8 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing)
.link (key2.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (open->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send2));
.build ();
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);
@ -1258,8 +1258,8 @@ TEST (bootstrap_processor, lazy_destinations)
.link (key1.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send1));
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (send1));
// send Gxrb_ratio raw from genesis to key2
auto send2 = builder
@ -1271,8 +1271,8 @@ TEST (bootstrap_processor, lazy_destinations)
.link (key2.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send2));
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (send2));
// receive send1 on key1
auto open = builder
@ -1282,8 +1282,8 @@ TEST (bootstrap_processor, lazy_destinations)
.account (key1.pub)
.sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*open));
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (open));
// receive send2 on key2
auto state_open = builder
@ -1295,8 +1295,8 @@ TEST (bootstrap_processor, lazy_destinations)
.link (send2->hash ())
.sign (key2.prv, key2.pub)
.work (*system.work.generate (key2.pub))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*state_open));
.build ();
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);
@ -1339,7 +1339,7 @@ TEST (bootstrap_processor, lazy_pruning_missing_block)
.link (key1.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
node1->process_active (send1);
// send from genesis to key2
@ -1352,7 +1352,7 @@ TEST (bootstrap_processor, lazy_pruning_missing_block)
.link (key2.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
.build ();
node1->process_active (send2);
// open account key1
@ -1363,7 +1363,7 @@ TEST (bootstrap_processor, lazy_pruning_missing_block)
.account (key1.pub)
.sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub))
.build_shared ();
.build ();
node1->process_active (open);
// open account key2
@ -1376,7 +1376,7 @@ TEST (bootstrap_processor, lazy_pruning_missing_block)
.link (send2->hash ())
.sign (key2.prv, key2.pub)
.work (*system.work.generate (key2.pub))
.build_shared ();
.build ();
node1->process_active (state_open);
ASSERT_TIMELY (5s, node1->block (state_open->hash ()) != nullptr);
@ -1440,7 +1440,7 @@ TEST (bootstrap_processor, lazy_cancel)
.link (key1.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
// Start lazy bootstrap with last block in chain known
auto node1 = system.make_disconnected_node ();
@ -1481,7 +1481,7 @@ TEST (bootstrap_processor, wallet_lazy_frontier)
.link (key1.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
auto receive1 = builder
.make_block ()
.account (key1.pub)
@ -1491,7 +1491,7 @@ TEST (bootstrap_processor, wallet_lazy_frontier)
.link (send1->hash ())
.sign (key1.prv, key1.pub)
.work (*node0->work_generate_blocking (key1.pub))
.build_shared ();
.build ();
auto send2 = builder
.make_block ()
.account (key1.pub)
@ -1501,7 +1501,7 @@ TEST (bootstrap_processor, wallet_lazy_frontier)
.link (key2.pub)
.sign (key1.prv, key1.pub)
.work (*node0->work_generate_blocking (receive1->hash ()))
.build_shared ();
.build ();
auto receive2 = builder
.make_block ()
.account (key2.pub)
@ -1511,7 +1511,7 @@ TEST (bootstrap_processor, wallet_lazy_frontier)
.link (send2->hash ())
.sign (key2.prv, key2.pub)
.work (*node0->work_generate_blocking (key2.pub))
.build_shared ();
.build ();
// Processing test chain
node0->block_processor.add (send1);
@ -1562,7 +1562,7 @@ TEST (bootstrap_processor, wallet_lazy_pending)
.link (key1.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
auto receive1 = builder
.make_block ()
.account (key1.pub)
@ -1572,7 +1572,7 @@ TEST (bootstrap_processor, wallet_lazy_pending)
.link (send1->hash ())
.sign (key1.prv, key1.pub)
.work (*node0->work_generate_blocking (key1.pub))
.build_shared ();
.build ();
auto send2 = builder
.make_block ()
.account (key1.pub)
@ -1582,7 +1582,7 @@ TEST (bootstrap_processor, wallet_lazy_pending)
.link (key2.pub)
.sign (key1.prv, key1.pub)
.work (*node0->work_generate_blocking (receive1->hash ()))
.build_shared ();
.build ();
// Processing test chain
node0->block_processor.add (send1);
@ -1623,7 +1623,7 @@ TEST (bootstrap_processor, multiple_attempts)
.link (key1.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
auto receive1 = builder
.make_block ()
.account (key1.pub)
@ -1633,7 +1633,7 @@ TEST (bootstrap_processor, multiple_attempts)
.link (send1->hash ())
.sign (key1.prv, key1.pub)
.work (*node1->work_generate_blocking (key1.pub))
.build_shared ();
.build ();
auto send2 = builder
.make_block ()
.account (key1.pub)
@ -1643,7 +1643,7 @@ TEST (bootstrap_processor, multiple_attempts)
.link (key2.pub)
.sign (key1.prv, key1.pub)
.work (*node1->work_generate_blocking (receive1->hash ()))
.build_shared ();
.build ();
auto receive2 = builder
.make_block ()
.account (key2.pub)
@ -1653,7 +1653,7 @@ TEST (bootstrap_processor, multiple_attempts)
.link (send2->hash ())
.sign (key2.prv, key2.pub)
.work (*node1->work_generate_blocking (key2.pub))
.build_shared ();
.build ();
// Processing test chain
node1->block_processor.add (send1);
@ -1742,9 +1742,9 @@ TEST (frontier_req, count)
.link (key1.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
node1->work_generate_blocking (*send1);
ASSERT_EQ (nano::block_status::progress, node1->process (*send1));
ASSERT_EQ (nano::block_status::progress, node1->process (send1));
auto receive1 = builder
.make_block ()
.account (key1.pub)
@ -1754,9 +1754,9 @@ TEST (frontier_req, count)
.link (send1->hash ())
.sign (key1.prv, key1.pub)
.work (0)
.build_shared ();
.build ();
node1->work_generate_blocking (*receive1);
ASSERT_EQ (nano::block_status::progress, node1->process (*receive1));
ASSERT_EQ (nano::block_status::progress, node1->process (receive1));
auto connection (std::make_shared<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);
@ -1837,9 +1837,9 @@ TEST (frontier_req, confirmed_frontier)
.link (key_before_genesis.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
node1->work_generate_blocking (*send1);
ASSERT_EQ (nano::block_status::progress, node1->process (*send1));
ASSERT_EQ (nano::block_status::progress, node1->process (send1));
auto send2 = builder
.make_block ()
.account (nano::dev::genesis_key.pub)
@ -1849,9 +1849,9 @@ TEST (frontier_req, confirmed_frontier)
.link (key_after_genesis.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
node1->work_generate_blocking (*send2);
ASSERT_EQ (nano::block_status::progress, node1->process (*send2));
ASSERT_EQ (nano::block_status::progress, node1->process (send2));
auto receive1 = builder
.make_block ()
.account (key_before_genesis.pub)
@ -1861,9 +1861,9 @@ TEST (frontier_req, confirmed_frontier)
.link (send1->hash ())
.sign (key_before_genesis.prv, key_before_genesis.pub)
.work (0)
.build_shared ();
.build ();
node1->work_generate_blocking (*receive1);
ASSERT_EQ (nano::block_status::progress, node1->process (*receive1));
ASSERT_EQ (nano::block_status::progress, node1->process (receive1));
auto receive2 = builder
.make_block ()
.account (key_after_genesis.pub)
@ -1873,9 +1873,9 @@ TEST (frontier_req, confirmed_frontier)
.link (send2->hash ())
.sign (key_after_genesis.prv, key_after_genesis.pub)
.work (0)
.build_shared ();
.build ();
node1->work_generate_blocking (*receive2);
ASSERT_EQ (nano::block_status::progress, node1->process (*receive2));
ASSERT_EQ (nano::block_status::progress, node1->process (receive2));
// Request for all accounts (confirmed only)
auto connection (std::make_shared<nano::transport::tcp_server> (std::make_shared<nano::transport::socket> (*node1, nano::transport::socket::endpoint_type_t::server), node1));

20
nano/core_test/bootstrap_ascending.cpp
View file

@ -170,8 +170,8 @@ TEST (bootstrap_ascending, account_base)
.balance (nano::dev::constants.genesis_amount - 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node0.process (*send1));
.build ();
ASSERT_EQ (nano::block_status::progress, node0.process (send1));
auto & node1 = *system.add_node (flags);
ASSERT_TIMELY (5s, node1.block (send1->hash ()) != nullptr);
}
@ -193,7 +193,7 @@ TEST (bootstrap_ascending, account_inductive)
.balance (nano::dev::constants.genesis_amount - 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
auto send2 = builder.make_block ()
.account (nano::dev::genesis_key.pub)
.previous (send1->hash ())
@ -202,12 +202,12 @@ TEST (bootstrap_ascending, account_inductive)
.balance (nano::dev::constants.genesis_amount - 2)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
.build ();
// std::cerr << "Genesis: " << nano::dev::genesis->hash ().to_string () << std::endl;
// std::cerr << "Send1: " << send1->hash ().to_string () << std::endl;
// std::cerr << "Send2: " << send2->hash ().to_string () << std::endl;
ASSERT_EQ (nano::block_status::progress, node0.process (*send1));
ASSERT_EQ (nano::block_status::progress, node0.process (*send2));
ASSERT_EQ (nano::block_status::progress, node0.process (send1));
ASSERT_EQ (nano::block_status::progress, node0.process (send2));
auto & node1 = *system.add_node (flags);
ASSERT_TIMELY (50s, node1.block (send2->hash ()) != nullptr);
}
@ -231,7 +231,7 @@ TEST (bootstrap_ascending, trace_base)
.balance (nano::dev::constants.genesis_amount - 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
auto receive1 = builder.make_block ()
.account (key.pub)
.previous (0)
@ -240,7 +240,7 @@ TEST (bootstrap_ascending, trace_base)
.balance (1)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
.build ();
// std::cerr << "Genesis key: " << nano::dev::genesis_key.pub.to_account () << std::endl;
// std::cerr << "Key: " << key.pub.to_account () << std::endl;
// std::cerr << "Genesis: " << nano::dev::genesis->hash ().to_string () << std::endl;
@ -248,8 +248,8 @@ TEST (bootstrap_ascending, trace_base)
// std::cerr << "receive1: " << receive1->hash ().to_string () << std::endl;
auto & node1 = *system.add_node ();
// std::cerr << "--------------- Start ---------------\n";
ASSERT_EQ (nano::block_status::progress, node0.process (*send1));
ASSERT_EQ (nano::block_status::progress, node0.process (*receive1));
ASSERT_EQ (nano::block_status::progress, node0.process (send1));
ASSERT_EQ (nano::block_status::progress, node0.process (receive1));
ASSERT_EQ (node1.store.pending.begin (node1.store.tx_begin_read (), nano::pending_key{ key.pub, 0 }), node1.store.pending.end ());
// std::cerr << "node0: " << node0.network.endpoint () << std::endl;
// std::cerr << "node1: " << node1.network.endpoint () << std::endl;

268
nano/core_test/confirmation_height.cpp
View file

@ -50,7 +50,7 @@ TEST (confirmation_height, single)
.link (key1.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest1))
.build_shared ();
.build ();
// Check confirmation heights before, should be uninitialized (1 for genesis).
nano::confirmation_height_info confirmation_height_info;
@ -199,20 +199,20 @@ TEST (confirmation_height, multiple_accounts)
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send4));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send5));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send4));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send5));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send6));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send6));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive2));
// Check confirmation heights of all the accounts (except genesis) are uninitialized (0),
// as we have any just added them to the ledger and not processed any live transactions yet.
@ -238,7 +238,7 @@ TEST (confirmation_height, multiple_accounts)
.source (send6->hash ())
.sign (key3.prv, key3.pub)
.work (*system.work.generate (open3->hash ()))
.build_shared ();
.build ();
node->process_active (receive3);
auto election = nano::test::start_election (system, *node, receive3->hash ());
ASSERT_NE (nullptr, election);
@ -326,7 +326,7 @@ TEST (confirmation_height, gap_bootstrap)
.link (destination.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
node1.work_generate_blocking (*send1);
auto send2 = builder
.state ()
@ -337,7 +337,7 @@ TEST (confirmation_height, gap_bootstrap)
.link (destination.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
node1.work_generate_blocking (*send2);
auto send3 = builder
.state ()
@ -348,7 +348,7 @@ TEST (confirmation_height, gap_bootstrap)
.link (destination.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
node1.work_generate_blocking (*send3);
auto open1 = builder
.open ()
@ -357,7 +357,7 @@ TEST (confirmation_height, gap_bootstrap)
.account (destination.pub)
.sign (destination.prv, destination.pub)
.work (0)
.build_shared ();
.build ();
node1.work_generate_blocking (*open1);
// Receive
@ -367,7 +367,7 @@ TEST (confirmation_height, gap_bootstrap)
.source (send2->hash ())
.sign (destination.prv, destination.pub)
.work (0)
.build_shared ();
.build ();
node1.work_generate_blocking (*receive1);
auto receive2 = builder
.receive ()
@ -375,7 +375,7 @@ TEST (confirmation_height, gap_bootstrap)
.source (send3->hash ())
.sign (destination.prv, destination.pub)
.work (0)
.build_shared ();
.build ();
node1.work_generate_blocking (*receive2);
node1.block_processor.add (send1);
@ -459,7 +459,7 @@ TEST (confirmation_height, gap_live)
.link (destination.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
node->work_generate_blocking (*send1);
auto send2 = builder
.state ()
@ -470,7 +470,7 @@ TEST (confirmation_height, gap_live)
.link (destination.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
node->work_generate_blocking (*send2);
auto send3 = builder
.state ()
@ -481,7 +481,7 @@ TEST (confirmation_height, gap_live)
.link (destination.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
node->work_generate_blocking (*send3);
auto open1 = builder
@ -491,7 +491,7 @@ TEST (confirmation_height, gap_live)
.account (destination.pub)
.sign (destination.prv, destination.pub)
.work (0)
.build_shared ();
.build ();
node->work_generate_blocking (*open1);
auto receive1 = builder
.receive ()
@ -499,7 +499,7 @@ TEST (confirmation_height, gap_live)
.source (send2->hash ())
.sign (destination.prv, destination.pub)
.work (0)
.build_shared ();
.build ();
node->work_generate_blocking (*receive1);
auto receive2 = builder
.receive ()
@ -507,7 +507,7 @@ TEST (confirmation_height, gap_live)
.source (send3->hash ())
.sign (destination.prv, destination.pub)
.work (0)
.build_shared ();
.build ();
node->work_generate_blocking (*receive2);
node->block_processor.add (send1);
@ -656,7 +656,7 @@ TEST (confirmation_height, send_receive_between_2_accounts)
.source (send5->hash ())
.sign (key1.prv, key1.pub)
.work (*system.work.generate (send4->hash ()))
.build_shared ();
.build ();
nano::keypair key2;
auto send6 = builder
.send ()
@ -669,20 +669,20 @@ TEST (confirmation_height, send_receive_between_2_accounts)
// Unpocketed send
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send4));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send4));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send5));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send6));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send5));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send6));
}
add_callback_stats (*node);
@ -749,7 +749,7 @@ TEST (confirmation_height, send_receive_self)
.source (send1->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
.build ();
auto send2 = builder
.send ()
.previous (receive1->hash ())
@ -779,7 +779,7 @@ TEST (confirmation_height, send_receive_self)
.source (send3->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (receive2->hash ()))
.build_shared ();
.build ();
// Send to another account to prevent automatic receiving on the genesis account
nano::keypair key1;
@ -793,14 +793,14 @@ TEST (confirmation_height, send_receive_self)
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send4));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send4));
}
add_callback_stats (*node);
@ -988,7 +988,7 @@ TEST (confirmation_height, all_block_types)
.link (key1.pub)
.sign (key2.prv, key2.pub)
.work (*system.work.generate (state_receive2->hash ()))
.build_shared ();
.build ();
auto state_send3 = builder
.state ()
.account (key2.pub)
@ -1023,30 +1023,30 @@ TEST (confirmation_height, all_block_types)
{
auto transaction (store.tx_begin_write ());
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_open));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_open));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_receive));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_receive));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *change));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_change));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, change));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_change));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *epoch));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *epoch1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, epoch));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, epoch1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_receive2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_receive2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_send3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_send4));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *state_receive3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_send4));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, state_receive3));
}
add_callback_stats (*node);
@ -1116,8 +1116,8 @@ TEST (confirmation_height, conflict_rollback_cemented)
.balance (nano::dev::constants.genesis_amount - 100)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis_hash))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*fork1a));
.build ();
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 }));
@ -1131,7 +1131,7 @@ TEST (confirmation_height, conflict_rollback_cemented)
.balance (nano::dev::constants.genesis_amount - 100)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (genesis_hash))
.build_shared ();
.build ();
node1->block_processor.force (fork1b);
// node2 already has send2 forced confirmed whilst node1 should have confirmed send1 and therefore we have a cemented fork on node2
@ -1175,7 +1175,7 @@ TEST (confirmation_heightDeathTest, rollback_added_block)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
{
auto transaction (store->tx_begin_write ());
store->initialize (transaction, ledger.cache, ledger.constants);
@ -1215,7 +1215,7 @@ TEST (confirmation_height, observers)
.balance (amount - node1->config.receive_minimum.number ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest1))
.build_shared ();
.build ();
add_callback_stats (*node1);
@ -1265,11 +1265,11 @@ TEST (confirmation_heightDeathTest, modified_chain)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
{
auto transaction (store->tx_begin_write ());
store->initialize (transaction, ledger.cache, ledger.constants);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send));
}
uint64_t batch_write_size = 2048;
@ -1290,7 +1290,7 @@ TEST (confirmation_heightDeathTest, modified_chain)
ASSERT_DEATH_IF_SUPPORTED (bounded_processor.cement_blocks (scoped_write_guard), "");
}
ASSERT_EQ (nano::block_status::progress, ledger.process (store->tx_begin_write (), *send));
ASSERT_EQ (nano::block_status::progress, ledger.process (store->tx_begin_write (), send));
store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () });
nano::confirmation_height_unbounded unbounded_processor (
@ -1342,7 +1342,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
auto open = builder
.state ()
.account (key1.pub)
@ -1352,12 +1352,12 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed)
.link (send->hash ())
.sign (key1.prv, key1.pub)
.work (*pool.generate (key1.pub))
.build_shared ();
.build ();
{
auto transaction (store->tx_begin_write ());
store->initialize (transaction, ledger.cache, ledger.constants);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open));
}
uint64_t batch_write_size = 2048;
@ -1379,7 +1379,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed)
}
// Reset conditions and test with the bounded processor
ASSERT_EQ (nano::block_status::progress, ledger.process (store->tx_begin_write (), *open));
ASSERT_EQ (nano::block_status::progress, ledger.process (store->tx_begin_write (), open));
store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () });
nano::confirmation_height_bounded bounded_processor (
@ -1430,12 +1430,12 @@ TEST (confirmation_height, pending_observer_callbacks)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send->hash ()))
.build_shared ();
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1));
}
add_callback_stats (*node);
@ -1479,10 +1479,10 @@ TEST (confirmation_height, callback_confirmed_history)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send));
}
auto send1 = builder
@ -1492,7 +1492,7 @@ TEST (confirmation_height, callback_confirmed_history)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send->hash ()))
.build_shared ();
.build ();
add_callback_stats (*node);
@ -1567,7 +1567,7 @@ TEST (confirmation_height, dependent_election)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
.build ();
auto send1 = builder
.send ()
.previous (send->hash ())
@ -1575,7 +1575,7 @@ TEST (confirmation_height, dependent_election)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send->hash ()))
.build_shared ();
.build ();
auto send2 = builder
.send ()
.previous (send1->hash ())
@ -1583,12 +1583,12 @@ TEST (confirmation_height, dependent_election)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 3)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2));
}
add_callback_stats (*node);
@ -1725,25 +1725,25 @@ TEST (confirmation_height, cemented_gap_below_receive)
.account (key2.pub)
.sign (key2.prv, key2.pub)
.work (*system.work.generate (key2.pub))
.build_shared ();
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, dummy_send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, dummy_send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, dummy_send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open1));
}
std::vector<nano::block_hash> observer_order;
@ -1885,25 +1885,25 @@ TEST (confirmation_height, cemented_gap_below_no_cache)
.account (key2.pub)
.sign (key2.prv, key2.pub)
.work (*system.work.generate (key2.pub))
.build_shared ();
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, dummy_send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, dummy_send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *dummy_send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send3));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, dummy_send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open1));
}
// Force some blocks to be cemented so that the cached confirmed info variable is empty
@ -1958,8 +1958,8 @@ TEST (confirmation_height, election_winner_details_clearing)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node->process (*send1));
.build ();
ASSERT_EQ (nano::block_status::progress, node->process (send1));
auto const send2 = builder.make_block ()
.previous (send1->hash ())
@ -1967,8 +1967,8 @@ TEST (confirmation_height, election_winner_details_clearing)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node->process (*send2));
.build ();
ASSERT_EQ (nano::block_status::progress, node->process (send2));
auto const send3 = builder.make_block ()
.previous (send2->hash ())
@ -1976,8 +1976,8 @@ TEST (confirmation_height, election_winner_details_clearing)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 3)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send2->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node->process (*send3));
.build ();
ASSERT_EQ (nano::block_status::progress, node->process (send3));
node->process_confirmed (nano::election_status{ send2 });
ASSERT_TIMELY (5s, node->block_confirmed (send2->hash ()));
@ -2016,7 +2016,7 @@ TEST (confirmation_height, election_winner_details_clearing_node_process_confirm
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
// Add to election_winner_details. Use an unrealistic iteration so that it should fall into the else case and do a cleanup
node->active.add_election_winner_details (send->hash (), nullptr);
nano::election_status election;
@ -2050,7 +2050,7 @@ TEST (confirmation_height, unbounded_block_cache_iteration)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
auto send1 = builder
.send ()
.previous (send->hash ())
@ -2058,12 +2058,12 @@ TEST (confirmation_height, unbounded_block_cache_iteration)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio * 2)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (send->hash ()))
.build_shared ();
.build ();
{
auto transaction (store->tx_begin_write ());
store->initialize (transaction, ledger.cache, nano::dev::constants);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1));
}
nano::confirmation_height_processor confirmation_height_processor (ledger, write_database_queue, 10ms, logger, initialized_latch, nano::confirmation_height_mode::unbounded);
@ -2115,7 +2115,7 @@ TEST (confirmation_height, pruned_source)
.link (key1.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
auto open1 = builder
.state ()
.account (key1.pub)
@ -2125,7 +2125,7 @@ TEST (confirmation_height, pruned_source)
.link (send1->hash ())
.sign (key1.prv, key1.pub)
.work (*pool.generate (key1.pub))
.build_shared ();
.build ();
auto send2 = builder
.state ()
.account (key1.pub)
@ -2135,7 +2135,7 @@ TEST (confirmation_height, pruned_source)
.link (key2.pub)
.sign (key1.prv, key1.pub)
.work (*pool.generate (open1->hash ()))
.build_shared ();
.build ();
auto send3 = builder
.state ()
.account (key1.pub)
@ -2145,7 +2145,7 @@ TEST (confirmation_height, pruned_source)
.link (key2.pub)
.sign (key1.prv, key1.pub)
.work (*pool.generate (send2->hash ()))
.build_shared ();
.build ();
auto open2 = builder
.state ()
.account (key2.pub)
@ -2155,15 +2155,15 @@ TEST (confirmation_height, pruned_source)
.link (send2->hash ())
.sign (key2.prv, key2.pub)
.work (*pool.generate (key2.pub))
.build_shared ();
.build ();
{
auto transaction (store->tx_begin_write ());
store->initialize (transaction, ledger.cache, nano::dev::constants);
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open1));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send2));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send3));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open2));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open1));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send3));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open2));
}
uint64_t batch_write_size = 2;
std::atomic<bool> stopped{ false };

6
nano/core_test/confirmation_solicitor.cpp
View file

@ -37,7 +37,7 @@ TEST (confirmation_solicitor, batches)
.balance (nano::dev::constants.genesis_amount - 100)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
send->sideband_set ({});
{
nano::lock_guard<nano::mutex> guard (node2.active.mutex);
@ -87,7 +87,7 @@ TEST (confirmation_solicitor, different_hash)
.balance (nano::dev::constants.genesis_amount - 100)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
send->sideband_set ({});
auto election (std::make_shared<nano::election> (node2, send, nullptr, nullptr, nano::election_behavior::normal));
// Add a vote for something else, not the winner
@ -131,7 +131,7 @@ TEST (confirmation_solicitor, bypass_max_requests_cap)
.balance (nano::dev::constants.genesis_amount - 100)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
send->sideband_set ({});
auto election (std::make_shared<nano::election> (node2, send, nullptr, nullptr, nano::election_behavior::normal));
// Add a vote for something else, not the winner

20
nano/core_test/conflicts.cpp
View file

@ -25,9 +25,9 @@ TEST (conflicts, start_stop)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
node1.work_generate_blocking (*send1);
ASSERT_EQ (nano::block_status::progress, node1.process (*send1));
ASSERT_EQ (nano::block_status::progress, node1.process (send1));
ASSERT_EQ (0, node1.active.size ());
node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ()));
@ -52,11 +52,11 @@ TEST (conflicts, add_existing)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
node1.work_generate_blocking (*send1);
// add the block to ledger as an unconfirmed block
ASSERT_EQ (nano::block_status::progress, node1.process (*send1));
ASSERT_EQ (nano::block_status::progress, node1.process (send1));
// wait for send1 to be inserted in the ledger
ASSERT_TIMELY (5s, node1.block (send1->hash ()));
@ -75,7 +75,7 @@ TEST (conflicts, add_existing)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
node1.work_generate_blocking (*send2);
send2->sideband_set ({});
@ -108,7 +108,7 @@ TEST (conflicts, add_two)
.link (key3.pub)
.sign (key1.prv, key1.pub)
.work (*system.work.generate (open1->hash ()))
.build_shared ();
.build ();
// send 1 raw to account key3 from key2
auto send_b = nano::state_block_builder ()
@ -119,7 +119,7 @@ TEST (conflicts, add_two)
.link (key3.pub)
.sign (key2.prv, key2.pub)
.work (*system.work.generate (open2->hash ()))
.build_shared ();
.build ();
// activate elections for the previous two send blocks (to account3) that we did not forcefully confirm
ASSERT_TRUE (nano::test::process (*node, { send_a, send_b }));
@ -149,7 +149,7 @@ TEST (vote_uniquer, vbh_one)
.link (0)
.sign (key.prv, key.pub)
.work (0)
.build_shared ();
.build ();
std::vector<nano::block_hash> hashes;
hashes.push_back (block->hash ());
auto vote1 = nano::test::make_vote (key, { hashes }, 0, 0);
@ -172,7 +172,7 @@ TEST (vote_uniquer, vbh_two)
.link (0)
.sign (key.prv, key.pub)
.work (0)
.build_shared ();
.build ();
std::vector<nano::block_hash> hashes1;
hashes1.push_back (block1->hash ());
auto block2 = builder
@ -184,7 +184,7 @@ TEST (vote_uniquer, vbh_two)
.link (0)
.sign (key.prv, key.pub)
.work (0)
.build_shared ();
.build ();
std::vector<nano::block_hash> hashes2;
hashes2.push_back (block2->hash ());
auto vote1 = nano::test::make_vote (key, { hashes1 }, 0, 0);

26
nano/core_test/election.cpp
View file

@ -47,7 +47,7 @@ TEST (election, quorum_minimum_flip_success)
.link (key1.pub)
.work (*system.work.generate (latest_hash))
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.build_shared ();
.build ();
nano::keypair key2{};
auto send2 = builder.make_block ()
@ -58,7 +58,7 @@ TEST (election, quorum_minimum_flip_success)
.link (key2.pub)
.work (*system.work.generate (latest_hash))
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.build_shared ();
.build ();
node1.process_active (send1);
ASSERT_TIMELY (5s, node1.active.election (send1->qualified_root ()) != nullptr)
@ -94,7 +94,7 @@ TEST (election, quorum_minimum_flip_fail)
.link (nano::keypair{}.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.build_shared ();
.build ();
auto send2 = builder.make_block ()
.previous (nano::dev::genesis->hash ())
@ -104,7 +104,7 @@ TEST (election, quorum_minimum_flip_fail)
.link (nano::keypair{}.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.build_shared ();
.build ();
// process send1 and wait until its election appears
node.process_active (send1);
@ -145,7 +145,7 @@ TEST (election, quorum_minimum_confirm_success)
.link (key1.pub)
.work (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.build_shared ();
.build ();
node1.work_generate_blocking (*send1);
node1.process_active (send1);
node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
@ -177,7 +177,7 @@ TEST (election, quorum_minimum_confirm_fail)
.link (nano::keypair{}.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.build_shared ();
.build ();
node1.process_active (send1);
auto election = nano::test::start_election (system, node1, send1->hash ());
@ -219,12 +219,12 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks)
.balance (amount)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
.build ();
node1.process_active (send1);
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::block_status::progress, node1.process (*open1));
auto const open1 = nano::open_block_builder{}.make_block ().account (key1.pub).source (send1->hash ()).representative (key1.pub).sign (key1.prv, key1.pub).work (*system.work.generate (key1.pub)).build ();
ASSERT_EQ (nano::block_status::progress, node1.process (open1));
nano::keypair key2;
auto const send2 = builder.make_block ()
@ -233,8 +233,8 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks)
.balance (3)
.sign (key1.prv, key1.pub)
.work (*system.work.generate (open1->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1.process (*send2));
.build ();
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 ();
@ -283,7 +283,7 @@ TEST (election, continuous_voting)
.balance (node1.balance (nano::dev::genesis_key.pub) / 10 * 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
ASSERT_TRUE (nano::test::process (node1, { send1 }));
ASSERT_TRUE (nano::test::start_elections (system, node1, { send1 }, true));
@ -298,7 +298,7 @@ TEST (election, continuous_voting)
.balance (node1.balance (nano::dev::genesis_key.pub) - 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
.build ();
ASSERT_TRUE (nano::test::process (node1, { send2 }));
ASSERT_TIMELY (5s, node1.active.active (*send2));

24
nano/core_test/election_scheduler.cpp
View file

@ -26,8 +26,8 @@ TEST (election_scheduler, activate_one_timely)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), *send1);
.build ();
system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), send1);
system.nodes[0]->scheduler.priority.activate (nano::dev::genesis_key.pub, system.nodes[0]->store.tx_begin_read ());
ASSERT_TIMELY (5s, system.nodes[0]->active.election (send1->qualified_root ()));
}
@ -44,8 +44,8 @@ TEST (election_scheduler, activate_one_flush)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), *send1);
.build ();
system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), send1);
system.nodes[0]->scheduler.priority.activate (nano::dev::genesis_key.pub, system.nodes[0]->store.tx_begin_read ());
ASSERT_TIMELY (5s, system.nodes[0]->active.election (send1->qualified_root ()));
}
@ -86,8 +86,8 @@ TEST (election_scheduler, no_vacancy)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node.process (*send));
.build ();
ASSERT_EQ (nano::block_status::progress, node.process (send));
node.process_confirmed (nano::election_status{ send });
auto receive = builder.make_block ()
@ -98,8 +98,8 @@ TEST (election_scheduler, no_vacancy)
.balance (nano::Gxrb_ratio)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node.process (*receive));
.build ();
ASSERT_EQ (nano::block_status::progress, node.process (receive));
node.process_confirmed (nano::election_status{ receive });
// Second, process two eligible transactions
@ -111,8 +111,8 @@ TEST (election_scheduler, no_vacancy)
.balance (nano::dev::constants.genesis_amount - 2 * nano::Gxrb_ratio)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node.process (*block1));
.build ();
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 ());
@ -127,8 +127,8 @@ TEST (election_scheduler, no_vacancy)
.balance (0)
.sign (key.prv, key.pub)
.work (*system.work.generate (receive->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node.process (*block2));
.build ();
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::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send));
}
ASSERT_TIMELY_EQ (5s, node->active.size (), 1);
}
@ -51,7 +51,7 @@ TEST (frontiers_confirmation, mode)
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send));
}
ASSERT_TIMELY_EQ (5s, node->active.size (), 1);
}
@ -73,7 +73,7 @@ TEST (frontiers_confirmation, mode)
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send));
}
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
std::this_thread::sleep_for (std::chrono::seconds (1));

744
nano/core_test/ledger.cpp
View file

File diff suppressed because it is too large Load diff

4
nano/core_test/message.cpp
View file

@ -20,7 +20,7 @@ std::shared_ptr<nano::block> random_block ()
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (5)
.build_shared ();
.build ();
return block;
}
}
@ -818,4 +818,4 @@ TEST (handshake, signature_v2)
message.v2->salt = nano::random_pool::generate<nano::uint256_union> ();
ASSERT_FALSE (message.validate (cookie));
}
}
}

4
nano/core_test/message_deserializer.cpp
View file

@ -65,7 +65,7 @@ TEST (message_deserializer, exact_confirm_ack)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (*system.work.generate (nano::root (1)))
.build_shared ();
.build ();
auto vote (std::make_shared<nano::vote> (0, nano::keypair ().prv, 0, 0, std::vector<nano::block_hash>{ block->hash () }));
nano::confirm_ack message{ nano::dev::network_params.network, vote };
@ -101,7 +101,7 @@ TEST (message_deserializer, exact_publish)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (*system.work.generate (nano::root (1)))
.build_shared ();
.build ();
nano::publish message{ nano::dev::network_params.network, block };
message_deserializer_success_checker<decltype (message)> (message);

22
nano/core_test/network.cpp
View file

@ -187,7 +187,7 @@ TEST (network, send_discarded_publish)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (*system.work.generate (nano::root (1)))
.build_shared ();
.build ();
{
auto transaction (node1.store.tx_begin_read ());
node1.network.flood_block (block);
@ -213,7 +213,7 @@ TEST (network, send_invalid_publish)
.balance (20)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::root (1)))
.build_shared ();
.build ();
{
auto transaction (node1.store.tx_begin_read ());
node1.network.flood_block (block);
@ -299,7 +299,7 @@ TEST (network, send_insufficient_work)
.balance (20)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
nano::publish publish1{ nano::dev::network_params.network, block1 };
auto tcp_channel (node1.network.tcp_channels.find_node_id (node2.get_node_id ()));
ASSERT_NE (nullptr, tcp_channel);
@ -315,7 +315,7 @@ TEST (network, send_insufficient_work)
.balance (20)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (system.work_generate_limited (block1->hash (), node1.network_params.work.epoch_2_receive, node1.network_params.work.epoch_1 - 1))
.build_shared ();
.build ();
nano::publish publish2{ nano::dev::network_params.network, block2 };
tcp_channel->send (publish2, [] (boost::system::error_code const & ec, size_t size) {});
ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work) != 1);
@ -328,7 +328,7 @@ TEST (network, send_insufficient_work)
.balance (20)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (block2->hash (), node1.network_params.work.epoch_2))
.build_shared ();
.build ();
nano::publish publish3{ nano::dev::network_params.network, block3 };
tcp_channel->send (publish3, [] (boost::system::error_code const & ec, size_t size) {});
ASSERT_EQ (0, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in));
@ -344,7 +344,7 @@ TEST (network, send_insufficient_work)
.link (1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (system.work_generate_limited (block1->hash (), node1.network_params.work.epoch_2_receive, node1.network_params.work.epoch_1 - 1))
.build_shared ();
.build ();
nano::publish publish4{ nano::dev::network_params.network, block4 };
tcp_channel->send (publish4, [] (boost::system::error_code const & ec, size_t size) {});
ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0);
@ -364,9 +364,9 @@ TEST (receivable_processor, confirm_insufficient_pos)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
node1.work_generate_blocking (*block1);
ASSERT_EQ (nano::block_status::progress, node1.process (*block1));
ASSERT_EQ (nano::block_status::progress, node1.process (block1));
node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
nano::keypair key1;
auto vote = nano::test::make_vote (key1, { block1 }, 0, 0);
@ -387,9 +387,9 @@ TEST (receivable_processor, confirm_sufficient_pos)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
node1.work_generate_blocking (*block1);
ASSERT_EQ (nano::block_status::progress, node1.process (*block1));
ASSERT_EQ (nano::block_status::progress, node1.process (block1));
node1.scheduler.priority.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
auto vote = nano::test::make_vote (nano::dev::genesis_key, { block1 }, 0, 0);
nano::confirm_ack con1{ nano::dev::network_params.network, vote };
@ -417,7 +417,7 @@ TEST (receivable_processor, send_with_receive)
.balance (amount - node1.config.receive_minimum.number ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest1))
.build_shared ();
.build ();
ASSERT_EQ (amount, node1.balance (nano::dev::genesis_key.pub));
ASSERT_EQ (0, node1.balance (key2.pub));
ASSERT_EQ (amount, node2.balance (nano::dev::genesis_key.pub));

4
nano/core_test/network_filter.cpp
View file

@ -45,7 +45,7 @@ TEST (network_filter, unit)
.link (nano::public_key ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
one_block (new_block, false);
for (int i = 0; i < 10; ++i)
@ -74,7 +74,7 @@ TEST (network_filter, many)
.link (key1.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
nano::publish message{ nano::dev::network_params.network, block };
auto bytes (message.to_bytes ());

522
nano/core_test/node.cpp
View file

File diff suppressed because it is too large Load diff

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

58
nano/core_test/request_aggregator.cpp
View file

@ -26,7 +26,7 @@ TEST (request_aggregator, one)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
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);
@ -36,7 +36,7 @@ TEST (request_aggregator, one)
ASSERT_TIMELY (3s, node.aggregator.empty ());
// Not yet in the ledger
ASSERT_TIMELY_EQ (3s, 1, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_unknown));
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1));
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1));
node.aggregator.add (dummy_channel, request);
ASSERT_EQ (1, node.aggregator.size ());
// In the ledger but no vote generated yet
@ -72,8 +72,8 @@ TEST (request_aggregator, one_update)
.link (key1.pub)
.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::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1));
.build ();
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 ()
@ -84,8 +84,8 @@ TEST (request_aggregator, one_update)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2));
.build ();
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)
@ -94,8 +94,8 @@ TEST (request_aggregator, one_update)
.link (send1->hash ())
.sign (key1.prv, key1.pub)
.work (*node.work_generate_blocking (key1.pub))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *receive1));
.build ();
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);
@ -138,8 +138,8 @@ TEST (request_aggregator, two)
.link (key1.pub)
.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::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1));
.build ();
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 ()
@ -150,7 +150,7 @@ TEST (request_aggregator, two)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (send1->hash ()))
.build_shared ();
.build ();
auto receive1 = builder.make_block ()
.account (key1.pub)
.previous (0)
@ -159,9 +159,9 @@ TEST (request_aggregator, two)
.link (send1->hash ())
.sign (key1.prv, key1.pub)
.work (*node.work_generate_blocking (key1.pub))
.build_shared ();
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));
.build ();
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send2));
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), receive1));
std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send2->hash (), send2->root ());
request.emplace_back (receive1->hash (), receive1->root ());
@ -215,10 +215,10 @@ TEST (request_aggregator, two_endpoints)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
std::vector<std::pair<nano::block_hash, nano::root>> request;
request.emplace_back (send1->hash (), send1->root ());
ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1));
ASSERT_EQ (nano::block_status::progress, node1.ledger.process (node1.store.tx_begin_write (), send1));
auto dummy_channel1 = std::make_shared<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::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *block));
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), block));
request.emplace_back (block->hash (), block->root ());
}
// Confirm all blocks
@ -324,8 +324,8 @@ TEST (request_aggregator, channel_lifetime)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1));
.build ();
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 ());
{
@ -355,8 +355,8 @@ TEST (request_aggregator, channel_update)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1));
.build ();
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;
@ -395,8 +395,8 @@ TEST (request_aggregator, channel_max_queue)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1));
.build ();
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);
@ -423,8 +423,8 @@ TEST (request_aggregator, unique)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node.work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1));
.build ();
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);
@ -456,16 +456,16 @@ TEST (request_aggregator, cannot_vote)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
auto send2 = builder.make_block ()
.from (*send1)
.previous (send1->hash ())
.balance (send1->balance ().number () - 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node.process (*send1));
ASSERT_EQ (nano::block_status::progress, node.process (*send2));
.build ();
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));

10
nano/core_test/scheduler_buckets.cpp
View file

@ -42,7 +42,7 @@ std::shared_ptr<nano::state_block> & blockzero ()
.link (0)
.sign (keyzero ().prv, keyzero ().pub)
.work (0)
.build_shared ();
.build ();
return result;
}
std::shared_ptr<nano::state_block> & block0 ()
@ -57,7 +57,7 @@ std::shared_ptr<nano::state_block> & block0 ()
.link (0)
.sign (key0 ().prv, key0 ().pub)
.work (0)
.build_shared ();
.build ();
return result;
}
std::shared_ptr<nano::state_block> & block1 ()
@ -72,7 +72,7 @@ std::shared_ptr<nano::state_block> & block1 ()
.link (0)
.sign (key1 ().prv, key1 ().pub)
.work (0)
.build_shared ();
.build ();
return result;
}
std::shared_ptr<nano::state_block> & block2 ()
@ -87,7 +87,7 @@ std::shared_ptr<nano::state_block> & block2 ()
.link (0)
.sign (key2 ().prv, key2 ().pub)
.work (0)
.build_shared ();
.build ();
return result;
}
std::shared_ptr<nano::state_block> & block3 ()
@ -102,7 +102,7 @@ std::shared_ptr<nano::state_block> & block3 ()
.link (0)
.sign (key3 ().prv, key3 ().pub)
.work (0)
.build_shared ();
.build ();
return result;
}

8
nano/core_test/system.cpp
View file

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

16
nano/core_test/unchecked_map.cpp
View file

@ -37,7 +37,7 @@ std::shared_ptr<nano::block> block ()
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
}
}
@ -65,7 +65,7 @@ TEST (block_store, one_bootstrap)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (5)
.build_shared ();
.build ();
unchecked.put (block1->hash (), nano::unchecked_info{ block1 });
auto check_block_is_listed = [&] (nano::block_hash const & block_hash_a) {
return unchecked.get (block_hash_a).size () > 0;
@ -98,7 +98,7 @@ TEST (unchecked, simple)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (5)
.build_shared ();
.build ();
// Asserts the block wasn't added yet to the unchecked table
auto block_listing1 = unchecked.get (block->previous ());
ASSERT_TRUE (block_listing1.empty ());
@ -139,7 +139,7 @@ TEST (unchecked, multiple)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (5)
.build_shared ();
.build ();
// Asserts the block wasn't added yet to the unchecked table
auto block_listing1 = unchecked.get (block->previous ());
ASSERT_TRUE (block_listing1.empty ());
@ -169,7 +169,7 @@ TEST (unchecked, double_put)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (5)
.build_shared ();
.build ();
// Asserts the block wasn't added yet to the unchecked table
auto block_listing1 = unchecked.get (block->previous ());
ASSERT_TRUE (block_listing1.empty ());
@ -201,7 +201,7 @@ TEST (unchecked, multiple_get)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (5)
.build_shared ();
.build ();
auto block2 = builder
.send ()
.previous (3)
@ -209,7 +209,7 @@ TEST (unchecked, multiple_get)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (5)
.build_shared ();
.build ();
auto block3 = builder
.send ()
.previous (5)
@ -217,7 +217,7 @@ TEST (unchecked, multiple_get)
.balance (2)
.sign (nano::keypair ().prv, 4)
.work (5)
.build_shared ();
.build ();
// Add the blocks' info to the unchecked table
unchecked.put (block1->previous (), nano::unchecked_info (block1)); // unchecked1
unchecked.put (block1->hash (), nano::unchecked_info (block1)); // unchecked2

16
nano/core_test/voting.cpp
View file

@ -158,7 +158,7 @@ TEST (vote_spacing, vote_generator)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
auto send2 = builder.make_block ()
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
@ -167,13 +167,13 @@ TEST (vote_spacing, vote_generator)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1));
.build ();
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1));
ASSERT_EQ (0, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts));
node.generator.add (nano::dev::genesis->hash (), send1->hash ());
ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts), 1);
ASSERT_FALSE (node.ledger.rollback (node.store.tx_begin_write (), send1->hash ()));
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2));
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send2));
node.generator.add (nano::dev::genesis->hash (), send2->hash ());
ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_spacing), 1);
ASSERT_EQ (1, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts));
@ -202,7 +202,7 @@ TEST (vote_spacing, rapid)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
auto send2 = builder.make_block ()
.account (nano::dev::genesis_key.pub)
.previous (nano::dev::genesis->hash ())
@ -211,12 +211,12 @@ TEST (vote_spacing, rapid)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send1));
.build ();
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send1));
node.generator.add (nano::dev::genesis->hash (), send1->hash ());
ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts), 1);
ASSERT_FALSE (node.ledger.rollback (node.store.tx_begin_write (), send1->hash ()));
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), *send2));
ASSERT_EQ (nano::block_status::progress, node.ledger.process (node.store.tx_begin_write (), send2));
node.generator.add (nano::dev::genesis->hash (), send2->hash ());
ASSERT_TIMELY_EQ (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_spacing), 1);
ASSERT_TIMELY_EQ (3s, 1, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts));

4
nano/core_test/wallet.cpp
View file

@ -1101,7 +1101,7 @@ TEST (wallet, epoch_2_receive_unopened)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (key.pub, node.network_params.work.epoch_2))
.build ();
ASSERT_EQ (nano::block_status::progress, node.process (*epoch2_unopened));
ASSERT_EQ (nano::block_status::progress, node.process (epoch2_unopened));
wallet.insert_adhoc (key.prv, false);
@ -1162,7 +1162,7 @@ TEST (wallet, search_receivable)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build ();
ASSERT_EQ (nano::block_status::progress, node.process (*send));
ASSERT_EQ (nano::block_status::progress, node.process (send));
// Pending search should start an election
ASSERT_TRUE (node.active.empty ());

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

28
nano/core_test/websocket.cpp
View file

@ -99,7 +99,7 @@ TEST (websocket, confirmation)
.balance (balance)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
.build ();
node1->process_active (send);
}
@ -118,7 +118,7 @@ TEST (websocket, confirmation)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
.build ();
node1->process_active (send);
}
@ -158,7 +158,7 @@ TEST (websocket, started_election)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
nano::publish publish1{ nano::dev::network_params.network, send1 };
auto channel1 = std::make_shared<nano::transport::fake::channel> (*node1);
node1->network.inbound (publish1, channel1);
@ -206,7 +206,7 @@ TEST (websocket, stopped_election)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
nano::publish publish1{ nano::dev::network_params.network, send1 };
auto channel1 = std::make_shared<nano::transport::fake::channel> (*node1);
node1->network.inbound (publish1, channel1);
@ -264,7 +264,7 @@ TEST (websocket, confirmation_options)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
.build ();
node1->process_active (send);
previous = send->hash ();
@ -297,7 +297,7 @@ TEST (websocket, confirmation_options)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
.build ();
node1->process_active (send);
previous = send->hash ();
@ -360,7 +360,7 @@ TEST (websocket, confirmation_options)
.balance (balance)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
.build ();
node1->process_active (send);
previous = send->hash ();
}
@ -406,7 +406,7 @@ TEST (websocket, confirmation_options_votes)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
.build ();
node1->process_active (send);
previous = send->hash ();
@ -493,7 +493,7 @@ TEST (websocket, confirmation_options_sideband)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
.build ();
node1->process_active (send);
previous = send->hash ();
@ -574,7 +574,7 @@ TEST (websocket, confirmation_options_update)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
.build ();
node1->process_active (send);
@ -592,7 +592,7 @@ TEST (websocket, confirmation_options_update)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
.build ();
node1->process_active (send2);
@ -634,7 +634,7 @@ TEST (websocket, vote)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
.build ();
node1->process_active (send);
@ -736,7 +736,7 @@ TEST (websocket, vote_options_representatives)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
.build ();
node1->process_active (send);
};
confirm_block ();
@ -1059,7 +1059,7 @@ TEST (websocket, new_unconfirmed_block)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process_local (send1).value ());

16
nano/lib/blockbuilders.cpp
View file

@ -652,7 +652,7 @@ nano::receive_block_builder & nano::receive_block_builder::source_hex (std::stri
}
template <typename BLOCKTYPE, typename BUILDER>
std::unique_ptr<BLOCKTYPE> nano::abstract_builder<BLOCKTYPE, BUILDER>::build ()
std::shared_ptr<BLOCKTYPE> nano::abstract_builder<BLOCKTYPE, BUILDER>::build ()
{
if (!ec)
{
@ -663,7 +663,7 @@ std::unique_ptr<BLOCKTYPE> nano::abstract_builder<BLOCKTYPE, BUILDER>::build ()
}
template <typename BLOCKTYPE, typename BUILDER>
std::unique_ptr<BLOCKTYPE> nano::abstract_builder<BLOCKTYPE, BUILDER>::build (std::error_code & ec)
std::shared_ptr<BLOCKTYPE> nano::abstract_builder<BLOCKTYPE, BUILDER>::build (std::error_code & ec)
{
if (!this->ec)
{
@ -673,18 +673,6 @@ std::unique_ptr<BLOCKTYPE> nano::abstract_builder<BLOCKTYPE, BUILDER>::build (st
return std::move (block);
}
template <typename BLOCKTYPE, typename BUILDER>
std::shared_ptr<BLOCKTYPE> nano::abstract_builder<BLOCKTYPE, BUILDER>::build_shared ()
{
return std::move (build ());
}
template <typename BLOCKTYPE, typename BUILDER>
std::shared_ptr<BLOCKTYPE> nano::abstract_builder<BLOCKTYPE, BUILDER>::build_shared (std::error_code & ec)
{
return std::move (build (ec));
}
template <typename BLOCKTYPE, typename BUILDER>
nano::abstract_builder<BLOCKTYPE, BUILDER> & nano::abstract_builder<BLOCKTYPE, BUILDER>::work (uint64_t work)
{

12
nano/lib/blockbuilders.hpp
View file

@ -44,14 +44,10 @@ template <typename BLOCKTYPE, typename BUILDER>
class abstract_builder
{
public:
/** Returns the built block as a unique_ptr */
std::unique_ptr<BLOCKTYPE> build ();
/** Returns the built block as a unique_ptr. Any errors are placed in \p ec */
std::unique_ptr<BLOCKTYPE> build (std::error_code & ec);
/** Returns the built block as a shared_ptr */
std::shared_ptr<BLOCKTYPE> build_shared ();
/** Returns the built block as a shared_ptr. Any errors are placed in \p ec */
std::shared_ptr<BLOCKTYPE> build_shared (std::error_code & ec);
/** Returns the built block*/
std::shared_ptr<BLOCKTYPE> build ();
/** Returns the built block. Any errors are placed in \p ec */
std::shared_ptr<BLOCKTYPE> build (std::error_code & ec);
/** Set work value */
abstract_builder & work (uint64_t work);
/** Sign the block using the \p private_key and \p public_key */

4
nano/nano_node/entry.cpp
View file

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

4
nano/node/blockprocessor.cpp
View file

@ -314,9 +314,9 @@ auto nano::block_processor::process_batch (nano::unique_lock<nano::mutex> & lock
nano::block_status nano::block_processor::process_one (store::write_transaction const & transaction_a, context const & context, bool const forced_a)
{
auto const & block = context.block;
auto block = context.block;
auto const hash = block->hash ();
nano::block_status result = node.ledger.process (transaction_a, *block);
nano::block_status result = node.ledger.process (transaction_a, block);
node.stats.inc (nano::stat::type::blockprocessor_result, to_stat_detail (result));
node.stats.inc (nano::stat::type::blockprocessor_source, to_stat_detail (context.source));

4
nano/node/node.cpp
View file

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

4
nano/node/node.hpp
View file

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

40
nano/qt_test/qt.cpp
View file

@ -422,7 +422,7 @@ TEST (wallet, create_send)
std::stringstream istream (json);
boost::property_tree::read_json (istream, tree1);
bool error (false);
nano::state_block send (error, tree1);
auto send = std::make_shared<nano::state_block> (error, tree1);
ASSERT_FALSE (error);
ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (send));
ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (send));
@ -456,7 +456,7 @@ TEST (wallet, create_open_receive)
std::stringstream istream1 (json1);
boost::property_tree::read_json (istream1, tree1);
bool error (false);
nano::state_block open (error, tree1);
auto open = std::make_shared<nano::state_block> (error, tree1);
ASSERT_FALSE (error);
ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (open));
ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (open));
@ -471,7 +471,7 @@ TEST (wallet, create_open_receive)
std::stringstream istream2 (json2);
boost::property_tree::read_json (istream2, tree2);
bool error2 (false);
nano::state_block receive (error2, tree2);
auto receive = std::make_shared<nano::state_block> (error2, tree2);
ASSERT_FALSE (error2);
ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (receive));
ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (receive));
@ -499,7 +499,7 @@ TEST (wallet, create_change)
std::stringstream istream (json);
boost::property_tree::read_json (istream, tree1);
bool error (false);
nano::state_block change (error, tree1);
auto change = std::make_shared<nano::state_block> (error, tree1);
ASSERT_FALSE (error);
ASSERT_EQ (nano::block_status::progress, system.nodes[0]->process (change));
ASSERT_EQ (nano::block_status::old, system.nodes[0]->process (change));
@ -531,11 +531,11 @@ TEST (history, short_text)
store->initialize (transaction, ledger.cache, ledger.constants);
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));
auto send = std::make_shared<nano::send_block> (latest, nano::dev::genesis_key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send));
nano::receive_block receive (send.hash (), send.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ()));
auto receive = std::make_shared<nano::receive_block> (send->hash (), send->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send->hash ()));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive));
nano::change_block change (receive.hash (), key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive.hash ()));
auto change = std::make_shared<nano::change_block> (receive->hash (), key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive->hash ()));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, change));
}
nano_qt::history history (ledger, nano::dev::genesis_key.pub, *wallet);
@ -571,16 +571,16 @@ TEST (history, pruned_source)
auto transaction (store->tx_begin_write ());
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));
auto send1 = std::make_shared<nano::send_block> (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send1));
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 ()));
auto send2 = std::make_shared<nano::send_block> (send1->hash (), key.pub, nano::dev::constants.genesis_amount - 200, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ()));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send2));
nano::receive_block receive (send2.hash (), send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2.hash ()));
auto receive = std::make_shared<nano::receive_block> (send2->hash (), send1->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2->hash ()));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive));
nano::open_block open (send2.hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub));
auto open = std::make_shared<nano::open_block> (send2->hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open));
ASSERT_EQ (1, ledger.pruning_action (transaction, send1.hash (), 2));
next_pruning = send2.hash ();
ASSERT_EQ (1, ledger.pruning_action (transaction, send1->hash (), 2));
next_pruning = send2->hash ();
}
nano_qt::history history1 (ledger, nano::dev::genesis_key.pub, *wallet);
history1.refresh ();
@ -601,10 +601,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));
auto send = std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 200, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send));
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));
auto receive = std::make_shared<nano::state_block> (key.pub, latest_key, key.pub, 200, send->hash (), key.prv, key.pub, *system.work.generate (latest_key));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive));
ASSERT_EQ (1, ledger.pruning_action (transaction, latest, 2));
ASSERT_EQ (1, ledger.pruning_action (transaction, latest_key, 2));
@ -716,8 +716,8 @@ TEST (wallet, republish)
{
auto transaction (system.nodes[0]->store.tx_begin_write ());
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 ();
auto block = std::make_shared<nano::send_block> (latest, key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest));
hash = block->hash ();
ASSERT_EQ (nano::block_status::progress, system.nodes[0]->ledger.process (transaction, block));
}
auto account (nano::dev::genesis_key.pub);
@ -916,7 +916,7 @@ TEST (wallet, DISABLED_synchronizing)
{
auto transaction (system1.nodes[0]->store.tx_begin_write ());
auto latest (system1.nodes[0]->ledger.latest (transaction, nano::dev::genesis->account ()));
nano::send_block send (latest, key1, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system1.work.generate (latest));
auto send = std::make_shared<nano::send_block> (latest, key1, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system1.work.generate (latest));
system1.nodes[0]->ledger.process (transaction, send);
}
ASSERT_EQ (0, wallet->active_status.active.count (nano_qt::status_types::synchronizing));
@ -965,10 +965,10 @@ TEST (wallet, epoch_2_validation)
std::stringstream istream (json);
boost::property_tree::read_json (istream, tree1);
bool error (false);
nano::state_block block (error, tree1);
auto block = std::make_shared<nano::state_block> (error, tree1);
EXPECT_FALSE (error);
EXPECT_EQ (nano::block_status::progress, node->process (block));
return block.hash ();
return block->hash ();
};
auto do_send = [&] (nano::public_key const & destination) -> nano::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::block_status::progress, node->ledger.process (transaction, *block));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, block));
}
auto const rpc_ctx = add_rpc (system, node);
boost::property_tree::ptree request;

234
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::block_status::progress, node->process (*send1));
ASSERT_EQ (nano::block_status::progress, node->process (send1));
ASSERT_TIMELY (5s, !node->active.active (*send1));
auto const rpc_ctx = add_rpc (system, node);
@ -152,7 +152,7 @@ TEST (rpc, account_weight)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*block));
ASSERT_EQ (nano::block_status::progress, node1->process (block));
auto const rpc_ctx = add_rpc (system, node1);
boost::property_tree::ptree request;
request.put ("action", "account_weight");
@ -957,9 +957,9 @@ TEST (rpc, history)
.build ();
{
auto transaction (node0->store.tx_begin_write ());
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *usend));
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *ureceive));
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *uchange));
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, usend));
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, ureceive));
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, uchange));
}
auto const rpc_ctx = add_rpc (system, node0);
boost::property_tree::ptree request;
@ -1041,9 +1041,9 @@ TEST (rpc, account_history)
.build ();
{
auto transaction (node0->store.tx_begin_write ());
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *usend));
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *ureceive));
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, *uchange));
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, usend));
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, ureceive));
ASSERT_EQ (nano::block_status::progress, node0->ledger.process (transaction, uchange));
}
auto const rpc_ctx = add_rpc (system, node0);
{
@ -1183,7 +1183,7 @@ TEST (rpc, history_pruning)
.representative (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
blocks.push_back (change);
// legacy send to itself
@ -1194,7 +1194,7 @@ TEST (rpc, history_pruning)
.balance (nano::dev::constants.genesis_amount - node0->config.receive_minimum.number ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work.generate (change->hash ()))
.build_shared ();
.build ();
blocks.push_back (send);
// legacy receive the legacy self send
@ -1204,7 +1204,7 @@ TEST (rpc, history_pruning)
.source (send->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work.generate (send->hash ()))
.build_shared ();
.build ();
blocks.push_back (receive);
// non legacy self send
@ -1217,7 +1217,7 @@ TEST (rpc, history_pruning)
.link (nano::dev::genesis->account ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (receive->hash ()))
.build_shared ();
.build ();
blocks.push_back (usend);
// non legacy receive of the non legacy self send
@ -1230,7 +1230,7 @@ TEST (rpc, history_pruning)
.link (usend->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (usend->hash ()))
.build_shared ();
.build ();
blocks.push_back (ureceive);
// change genesis to a random rep
@ -1243,7 +1243,7 @@ TEST (rpc, history_pruning)
.link (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node0->work_generate_blocking (ureceive->hash ()))
.build_shared ();
.build ();
blocks.push_back (uchange);
nano::test::process_live (*node0, blocks);
@ -1438,7 +1438,7 @@ TEST (rpc, process_block_async)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
.build ();
std::string json1;
state_send->serialize_json (json1);
request.put ("block", json1);
@ -1556,9 +1556,9 @@ TEST (rpc, process_subtype_open)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send));
ASSERT_EQ (nano::block_status::progress, node2.process (*send));
.build ();
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
@ -1605,9 +1605,9 @@ TEST (rpc, process_subtype_receive)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send));
ASSERT_EQ (nano::block_status::progress, node2.process (*send));
.build ();
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
@ -2227,7 +2227,7 @@ TEST (rpc, block_count_pruning)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest))
.build_shared ();
.build ();
node1->process_active (send1);
auto receive1 = builder
.receive ()
@ -2235,7 +2235,7 @@ TEST (rpc, block_count_pruning)
.source (send1->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (send1->hash ()))
.build_shared ();
.build ();
node1->process_active (receive1);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
ASSERT_TIMELY (5s, node1->block_confirmed (receive1->hash ()));
@ -2497,7 +2497,7 @@ TEST (rpc, bootstrap)
.build ();
{
auto transaction (node1->store.tx_begin_write ());
ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node1->ledger.process (transaction, send));
}
auto const rpc_ctx = add_rpc (system0, node);
boost::property_tree::ptree request;
@ -2782,7 +2782,7 @@ TEST (rpc, bootstrap_any)
.build ();
{
auto transaction (system1.nodes[0]->store.tx_begin_write ());
ASSERT_EQ (nano::block_status::progress, system1.nodes[0]->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, system1.nodes[0]->ledger.process (transaction, send));
}
auto const rpc_ctx = add_rpc (system0, node);
boost::property_tree::ptree request;
@ -2808,7 +2808,7 @@ TEST (rpc, republish)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send));
ASSERT_EQ (nano::block_status::progress, node1->process (send));
auto open = builder
.open ()
.source (send->hash ())
@ -2817,7 +2817,7 @@ TEST (rpc, republish)
.sign (key.prv, key.pub)
.work (*node1->work_generate_blocking (key.pub))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*open));
ASSERT_EQ (nano::block_status::progress, node1->process (open));
auto const rpc_ctx = add_rpc (system, node1);
boost::property_tree::ptree request;
request.put ("action", "republish");
@ -2995,10 +2995,10 @@ TEST (rpc, accounts_balances_unopened_account_with_receivables)
.link (unopened_account.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node->work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send));
}
ASSERT_TIMELY (5s, node->block (send->hash ()));
ASSERT_TIMELY (5s, !node->active.active (*send));
@ -3531,7 +3531,7 @@ TEST (rpc, search_receivable_all)
.build ();
{
auto transaction (node->store.tx_begin_write ());
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *block));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, block));
}
auto const rpc_ctx = add_rpc (system, node);
boost::property_tree::ptree request;
@ -3563,7 +3563,7 @@ TEST (rpc, wallet_republish)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send));
ASSERT_EQ (nano::block_status::progress, node1->process (send));
auto open = builder
.open ()
.source (send->hash ())
@ -3572,7 +3572,7 @@ TEST (rpc, wallet_republish)
.sign (key.prv, key.pub)
.work (*node1->work_generate_blocking (key.pub))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*open));
ASSERT_EQ (nano::block_status::progress, node1->process (open));
auto const rpc_ctx = add_rpc (system, node1);
boost::property_tree::ptree request;
request.put ("action", "wallet_republish");
@ -3607,7 +3607,7 @@ TEST (rpc, delegators)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send));
ASSERT_EQ (nano::block_status::progress, node1->process (send));
auto open = builder
.open ()
.source (send->hash ())
@ -3616,7 +3616,7 @@ TEST (rpc, delegators)
.sign (key.prv, key.pub)
.work (*node1->work_generate_blocking (key.pub))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*open));
ASSERT_EQ (nano::block_status::progress, node1->process (open));
auto const rpc_ctx = add_rpc (system, node1);
boost::property_tree::ptree request;
request.put ("action", "delegators");
@ -3648,7 +3648,7 @@ TEST (rpc, delegators_parameters)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send));
ASSERT_EQ (nano::block_status::progress, node1->process (send));
auto open = builder
.open ()
.source (send->hash ())
@ -3657,7 +3657,7 @@ TEST (rpc, delegators_parameters)
.sign (key.prv, key.pub)
.work (*node1->work_generate_blocking (key.pub))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*open));
ASSERT_EQ (nano::block_status::progress, node1->process (open));
auto const rpc_ctx = add_rpc (system, node1);
// Test with "count" = 2
@ -3758,7 +3758,7 @@ TEST (rpc, delegators_count)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send));
ASSERT_EQ (nano::block_status::progress, node1->process (send));
auto open = builder
.open ()
.source (send->hash ())
@ -3767,7 +3767,7 @@ TEST (rpc, delegators_count)
.sign (key.prv, key.pub)
.work (*node1->work_generate_blocking (key.pub))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*open));
ASSERT_EQ (nano::block_status::progress, node1->process (open));
auto const rpc_ctx = add_rpc (system, node1);
boost::property_tree::ptree request;
request.put ("action", "delegators_count");
@ -3810,7 +3810,7 @@ TEST (rpc, account_info)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send));
ASSERT_EQ (nano::block_status::progress, node1->process (send));
auto time = nano::seconds_since_epoch ();
{
auto transaction = node1->store.tx_begin_write ();
@ -3869,7 +3869,7 @@ TEST (rpc, account_info)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send1));
ASSERT_EQ (nano::block_status::progress, node1->process (send1));
auto send2 = builder
.send ()
.previous (send1->hash ())
@ -3878,7 +3878,7 @@ TEST (rpc, account_info)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (send1->hash ()))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send2));
ASSERT_EQ (nano::block_status::progress, node1->process (send2));
auto state_change = builder
.state ()
@ -3890,7 +3890,7 @@ TEST (rpc, account_info)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (send2->hash ()))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*state_change));
ASSERT_EQ (nano::block_status::progress, node1->process (state_change));
auto open = builder
.open ()
@ -3900,7 +3900,7 @@ TEST (rpc, account_info)
.sign (key1.prv, key1.pub)
.work (*node1->work_generate_blocking (key1.pub))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*open));
ASSERT_EQ (nano::block_status::progress, node1->process (open));
ASSERT_TIMELY (5s, !node1->active.active (*state_change));
ASSERT_TIMELY (5s, !node1->active.active (*open));
}
@ -4018,7 +4018,7 @@ TEST (rpc, json_block_output)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send));
ASSERT_EQ (nano::block_status::progress, node1->process (send));
auto const rpc_ctx = add_rpc (system, node1);
boost::property_tree::ptree request;
request.put ("action", "block_info");
@ -4240,7 +4240,7 @@ TEST (rpc, block_info_successor)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send));
ASSERT_EQ (nano::block_status::progress, node1->process (send));
auto const rpc_ctx = add_rpc (system, node1);
boost::property_tree::ptree request;
request.put ("action", "block_info");
@ -4276,7 +4276,7 @@ TEST (rpc, block_info_pruning)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest))
.build_shared ();
.build ();
node1->process_active (send1);
auto receive1 = builder
.receive ()
@ -4284,7 +4284,7 @@ TEST (rpc, block_info_pruning)
.source (send1->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (send1->hash ()))
.build_shared ();
.build ();
node1->process_active (receive1);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
ASSERT_TIMELY (5s, node1->block_confirmed (receive1->hash ()));
@ -4342,7 +4342,7 @@ TEST (rpc, pruned_exists)
.balance (nano::dev::constants.genesis_amount - nano::Gxrb_ratio)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest))
.build_shared ();
.build ();
node1->process_active (send1);
auto receive1 = builder
.receive ()
@ -4350,7 +4350,7 @@ TEST (rpc, pruned_exists)
.source (send1->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (send1->hash ()))
.build_shared ();
.build ();
node1->process_active (receive1);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
ASSERT_TIMELY (5s, node1->block_confirmed (receive1->hash ()));
@ -4430,7 +4430,7 @@ TEST (rpc, populate_backlog)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node->work_generate_blocking (latest))
.build ();
ASSERT_EQ (nano::block_status::progress, node->process (*send));
ASSERT_EQ (nano::block_status::progress, node->process (send));
auto const rpc_ctx = add_rpc (system, node);
boost::property_tree::ptree request;
@ -4461,7 +4461,7 @@ TEST (rpc, ledger)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node->work_generate_blocking (latest))
.build ();
ASSERT_EQ (nano::block_status::progress, node->process (*send));
ASSERT_EQ (nano::block_status::progress, node->process (send));
auto open = builder
.open ()
.source (send->hash ())
@ -4470,7 +4470,7 @@ TEST (rpc, ledger)
.sign (key.prv, key.pub)
.work (*node->work_generate_blocking (key.pub))
.build ();
ASSERT_EQ (nano::block_status::progress, node->process (*open));
ASSERT_EQ (nano::block_status::progress, node->process (open));
auto time = nano::seconds_since_epoch ();
auto const rpc_ctx = add_rpc (system, node);
boost::property_tree::ptree request;
@ -4544,7 +4544,7 @@ TEST (rpc, ledger)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node->work_generate_blocking (send->hash ()))
.build ();
ASSERT_EQ (nano::block_status::progress, node->process (*send2));
ASSERT_EQ (nano::block_status::progress, node->process (send2));
// When asking for pending, pending amount is taken into account for threshold so the account must show up
request.put ("count", 2);
request.put ("threshold", (send_amount + send2_amount).convert_to<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::block_status::progress, node1->process (*send));
ASSERT_EQ (nano::block_status::progress, node1->process (send));
boost::property_tree::ptree request1;
request1.put ("action", "block_create");
request1.put ("type", "open");
@ -4649,7 +4649,7 @@ TEST (rpc, block_create)
boost::property_tree::read_json (block_stream1, block_l);
auto open_block (nano::deserialize_block_json (block_l));
ASSERT_EQ (open->hash (), open_block->hash ());
ASSERT_EQ (nano::block_status::progress, node1->process (*open));
ASSERT_EQ (nano::block_status::progress, node1->process (open));
request1.put ("representative", key.pub.to_account ());
auto response2 (wait_response (system, rpc_ctx, request1));
std::string open2_hash (response2.get<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::block_status::progress, node1->process (*change));
ASSERT_EQ (nano::block_status::progress, node1->process (change));
auto send2 = builder
.send ()
.previous (send->hash ())
@ -4681,7 +4681,7 @@ TEST (rpc, block_create)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (send->hash ()))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send2));
ASSERT_EQ (nano::block_status::progress, node1->process (send2));
boost::property_tree::ptree request2;
request2.put ("action", "block_create");
request2.put ("type", "receive");
@ -4729,7 +4729,7 @@ TEST (rpc, block_create_state)
ASSERT_NE (nullptr, state_block);
ASSERT_EQ (nano::block_type::state, state_block->type ());
ASSERT_EQ (state_hash, state_block->hash ().to_string ());
auto process_result (node->process (*state_block));
auto process_result (node->process (state_block));
ASSERT_EQ (nano::block_status::progress, process_result);
}
@ -4765,7 +4765,7 @@ TEST (rpc, block_create_state_open)
auto difficulty (nano::dev::network_params.work.difficulty (*state_block));
ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_0, false, true, false)));
ASSERT_TRUE (node->latest (key.pub).is_zero ());
auto process_result (node->process (*state_block));
auto process_result (node->process (state_block));
ASSERT_EQ (nano::block_status::progress, process_result);
ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_0);
ASSERT_TRUE (state_block->sideband ().details.is_receive);
@ -4777,7 +4777,7 @@ TEST (rpc, block_create_state_request_work)
{
// Test work generation for state blocks both with and without previous (in the latter
// case, the account will be used for work generation)
std::unique_ptr<nano::state_block> epoch2;
std::shared_ptr<nano::state_block> epoch2;
{
nano::test::system system (1);
system.upgrade_genesis_epoch (*system.nodes.front (), nano::epoch::epoch_1);
@ -4844,7 +4844,7 @@ TEST (rpc, block_create_open_epoch_v2)
auto difficulty (nano::dev::network_params.work.difficulty (*state_block));
ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false)));
ASSERT_TRUE (node->latest (key.pub).is_zero ());
auto process_result (node->process (*state_block));
auto process_result (node->process (state_block));
ASSERT_EQ (nano::block_status::progress, process_result);
ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2);
ASSERT_TRUE (state_block->sideband ().details.is_receive);
@ -4871,7 +4871,7 @@ TEST (rpc, block_create_receive_epoch_v2)
.sign (key.prv, key.pub)
.work (*node->work_generate_blocking (key.pub))
.build ();
ASSERT_EQ (nano::block_status::progress, node->process (*open));
ASSERT_EQ (nano::block_status::progress, node->process (open));
ASSERT_NE (nullptr, system.upgrade_genesis_epoch (*node, nano::epoch::epoch_2));
auto send_block_2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, nano::Gxrb_ratio));
auto const rpc_ctx = add_rpc (system, node);
@ -4896,7 +4896,7 @@ TEST (rpc, block_create_receive_epoch_v2)
ASSERT_EQ (state_hash, state_block->hash ().to_string ());
auto difficulty (nano::dev::network_params.work.difficulty (*state_block));
ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false)));
auto process_result (node->process (*state_block));
auto process_result (node->process (state_block));
ASSERT_EQ (nano::block_status::progress, process_result);
ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2);
ASSERT_TRUE (state_block->sideband ().details.is_receive);
@ -4924,7 +4924,7 @@ TEST (rpc, block_create_send_epoch_v2)
.sign (key.prv, key.pub)
.work (*node->work_generate_blocking (key.pub))
.build ();
ASSERT_EQ (nano::block_status::progress, node->process (*open));
ASSERT_EQ (nano::block_status::progress, node->process (open));
auto const rpc_ctx = add_rpc (system, node);
boost::property_tree::ptree request;
request.put ("action", "block_create");
@ -4947,7 +4947,7 @@ TEST (rpc, block_create_send_epoch_v2)
ASSERT_EQ (state_hash, state_block->hash ().to_string ());
auto difficulty (nano::dev::network_params.work.difficulty (*state_block));
ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, true, false, false)));
auto process_result (node->process (*state_block));
auto process_result (node->process (state_block));
ASSERT_EQ (nano::block_status::progress, process_result);
ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2);
ASSERT_TRUE (state_block->sideband ().details.is_send);
@ -5048,7 +5048,7 @@ TEST (rpc, wallet_ledger)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node1->work_generate_blocking (latest))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send));
ASSERT_EQ (nano::block_status::progress, node1->process (send));
auto open = builder
.open ()
.source (send->hash ())
@ -5057,7 +5057,7 @@ TEST (rpc, wallet_ledger)
.sign (key.prv, key.pub)
.work (*node1->work_generate_blocking (key.pub))
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (*open));
ASSERT_EQ (nano::block_status::progress, node1->process (open));
auto time = nano::seconds_since_epoch ();
auto const rpc_ctx = add_rpc (system, node1);
boost::property_tree::ptree request;
@ -5221,7 +5221,7 @@ TEST (rpc, confirmation_height_currently_processing)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous_genesis_chain_hash))
.build ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send));
previous_genesis_chain_hash = send->hash ();
}
@ -5340,10 +5340,10 @@ TEST (rpc, block_confirm)
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*node->work_generate_blocking (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
{
auto transaction (node->store.tx_begin_write ());
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1));
}
auto const rpc_ctx = add_rpc (system, node);
boost::property_tree::ptree request;
@ -5445,7 +5445,7 @@ TEST (rpc, unchecked)
.link (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
.build ();
auto open2 = builder
.state ()
.account (key.pub)
@ -5455,7 +5455,7 @@ TEST (rpc, unchecked)
.link (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
.build ();
node->process_active (open);
node->process_active (open2);
// Waits for the last block of the queue to get saved in the database
@ -5497,7 +5497,7 @@ TEST (rpc, unchecked_get)
.link (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
.build ();
node->process_active (open);
// Waits for the open block to get saved in the database
ASSERT_TIMELY_EQ (10s, 1, node->unchecked.count ());
@ -5536,7 +5536,7 @@ TEST (rpc, unchecked_clear)
.link (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
.build ();
node->process_active (open);
boost::property_tree::ptree request{};
// Waits for the open block to get saved in the database
@ -5799,7 +5799,7 @@ TEST (rpc, memory_stats)
.link (0)
.sign (key.prv, key.pub)
.work (0)
.build_shared ();
.build ();
std::vector<nano::block_hash> hashes;
hashes.push_back (block->hash ());
auto vote = nano::test::make_vote (key, { hashes }, 0, 0);
@ -5850,7 +5850,7 @@ TEST (rpc, block_confirmed)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1));
auto open1 = builder
.open ()
@ -5860,7 +5860,7 @@ TEST (rpc, block_confirmed)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open1));
}
// This should not be confirmed
@ -5877,7 +5877,7 @@ TEST (rpc, block_confirmed)
.balance (10)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
.build ();
node->process_active (send);
ASSERT_TRUE (nano::test::start_elections (system, *node, { send }, true));
@ -6143,8 +6143,8 @@ TEST (rpc, epoch_upgrade)
.link (key1.pub)
.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::block_status::progress, node->process (*send1));
.build (); // to opened account
ASSERT_EQ (nano::block_status::progress, node->process (send1));
auto send2 = builder
.state ()
.account (nano::dev::genesis_key.pub)
@ -6154,8 +6154,8 @@ TEST (rpc, epoch_upgrade)
.link (key2.pub)
.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::block_status::progress, node->process (*send2));
.build (); // to unopened account (pending)
ASSERT_EQ (nano::block_status::progress, node->process (send2));
auto send3 = builder
.state ()
.account (nano::dev::genesis_key.pub)
@ -6165,8 +6165,8 @@ TEST (rpc, epoch_upgrade)
.link (0)
.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::block_status::progress, node->process (*send3));
.build (); // to burn (0)
ASSERT_EQ (nano::block_status::progress, node->process (send3));
nano::account max_account (std::numeric_limits<nano::uint256_t>::max ());
auto send4 = builder
.state ()
@ -6177,8 +6177,8 @@ TEST (rpc, epoch_upgrade)
.link (max_account)
.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::block_status::progress, node->process (*send4));
.build (); // to max account
ASSERT_EQ (nano::block_status::progress, node->process (send4));
auto open = builder
.state ()
.account (key1.pub)
@ -6188,8 +6188,8 @@ TEST (rpc, epoch_upgrade)
.link (send1->hash ())
.sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node->process (*open));
.build ();
ASSERT_EQ (nano::block_status::progress, node->process (open));
// Check accounts epochs
{
auto transaction (node->store.tx_begin_read ());
@ -6234,8 +6234,8 @@ TEST (rpc, epoch_upgrade)
.link (0)
.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::block_status::progress, node->process (*send5));
.build (); // to burn (0)
ASSERT_EQ (nano::block_status::progress, node->process (send5));
auto send6 = builder
.state ()
.account (nano::dev::genesis_key.pub)
@ -6245,8 +6245,8 @@ TEST (rpc, epoch_upgrade)
.link (key1.pub)
.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::block_status::progress, node->process (*send6));
.build (); // to key1 (again)
ASSERT_EQ (nano::block_status::progress, node->process (send6));
auto key1_latest (node->latest (key1.pub));
auto send7 = builder
.state ()
@ -6257,8 +6257,8 @@ TEST (rpc, epoch_upgrade)
.link (key3.pub)
.sign (key1.prv, key1.pub)
.work (*system.work.generate (key1_latest))
.build_shared (); // to key3
ASSERT_EQ (nano::block_status::progress, node->process (*send7));
.build (); // to key3
ASSERT_EQ (nano::block_status::progress, node->process (send7));
{
// Check pending entry
auto transaction (node->store.tx_begin_read ());
@ -6306,8 +6306,8 @@ TEST (rpc, epoch_upgrade_multithreaded)
.link (key1.pub)
.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::block_status::progress, node->process (*send1));
.build (); // to opened account
ASSERT_EQ (nano::block_status::progress, node->process (send1));
auto send2 = builder
.state ()
.account (nano::dev::genesis_key.pub)
@ -6317,8 +6317,8 @@ TEST (rpc, epoch_upgrade_multithreaded)
.link (key2.pub)
.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::block_status::progress, node->process (*send2));
.build (); // to unopened account (pending)
ASSERT_EQ (nano::block_status::progress, node->process (send2));
auto send3 = builder
.state ()
.account (nano::dev::genesis_key.pub)
@ -6328,8 +6328,8 @@ TEST (rpc, epoch_upgrade_multithreaded)
.link (0)
.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::block_status::progress, node->process (*send3));
.build (); // to burn (0)
ASSERT_EQ (nano::block_status::progress, node->process (send3));
nano::account max_account (std::numeric_limits<nano::uint256_t>::max ());
auto send4 = builder
.state ()
@ -6340,8 +6340,8 @@ TEST (rpc, epoch_upgrade_multithreaded)
.link (max_account)
.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::block_status::progress, node->process (*send4));
.build (); // to max account
ASSERT_EQ (nano::block_status::progress, node->process (send4));
auto open = builder
.state ()
.account (key1.pub)
@ -6351,8 +6351,8 @@ TEST (rpc, epoch_upgrade_multithreaded)
.link (send1->hash ())
.sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node->process (*open));
.build ();
ASSERT_EQ (nano::block_status::progress, node->process (open));
// Check accounts epochs
{
auto transaction (node->store.tx_begin_read ());
@ -6398,8 +6398,8 @@ TEST (rpc, epoch_upgrade_multithreaded)
.link (0)
.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::block_status::progress, node->process (*send5));
.build (); // to burn (0)
ASSERT_EQ (nano::block_status::progress, node->process (send5));
auto send6 = builder
.state ()
.account (nano::dev::genesis_key.pub)
@ -6409,8 +6409,8 @@ TEST (rpc, epoch_upgrade_multithreaded)
.link (key1.pub)
.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::block_status::progress, node->process (*send6));
.build (); // to key1 (again)
ASSERT_EQ (nano::block_status::progress, node->process (send6));
auto key1_latest (node->latest (key1.pub));
auto send7 = builder
.state ()
@ -6421,8 +6421,8 @@ TEST (rpc, epoch_upgrade_multithreaded)
.link (key3.pub)
.sign (key1.prv, key1.pub)
.work (*system.work.generate (key1_latest))
.build_shared (); // to key3
ASSERT_EQ (nano::block_status::progress, node->process (*send7));
.build (); // to key3
ASSERT_EQ (nano::block_status::progress, node->process (send7));
{
// Check pending entry
auto transaction (node->store.tx_begin_read ());
@ -6470,8 +6470,8 @@ TEST (rpc, account_lazy_start)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*send1));
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (send1));
auto open = builder
.open ()
.source (send1->hash ())
@ -6479,8 +6479,8 @@ TEST (rpc, account_lazy_start)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node1->process (*open));
.build ();
ASSERT_EQ (nano::block_status::progress, node1->process (open));
// Start lazy bootstrap with account
nano::node_config node_config = system.default_config ();
@ -6869,7 +6869,7 @@ TEST (rpc, confirmation_active)
.balance (nano::dev::constants.genesis_amount - 100)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
auto send2 = builder
.send ()
.previous (send1->hash ())
@ -6877,7 +6877,7 @@ TEST (rpc, confirmation_active)
.balance (nano::dev::constants.genesis_amount - 200)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (send1->hash ()))
.build_shared ();
.build ();
node1->process_active (send1);
node1->process_active (send2);
ASSERT_TRUE (nano::test::start_elections (system, *node1, { send1, send2 }));
@ -6913,7 +6913,7 @@ TEST (rpc, confirmation_info)
.balance (nano::dev::constants.genesis_amount - 100)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
node1->process_active (send);
ASSERT_TIMELY (5s, !node1->active.empty ());

6
nano/secure/ledger.cpp
View file

@ -915,11 +915,11 @@ std::optional<nano::pending_info> nano::ledger::pending_info (store::transaction
return std::nullopt;
}
nano::block_status nano::ledger::process (store::write_transaction const & transaction_a, nano::block & block_a)
nano::block_status nano::ledger::process (store::write_transaction const & transaction_a, std::shared_ptr<nano::block> block_a)
{
debug_assert (!constants.work.validate_entry (block_a) || constants.genesis == nano::dev::genesis);
debug_assert (!constants.work.validate_entry (*block_a) || constants.genesis == nano::dev::genesis);
ledger_processor processor (*this, transaction_a);
block_a.visit (processor);
block_a->visit (processor);
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::block_status process (store::write_transaction const &, nano::block &);
nano::block_status process (store::write_transaction const & transaction, std::shared_ptr<nano::block> block);
bool rollback (store::write_transaction const &, nano::block_hash const &, std::vector<std::shared_ptr<nano::block>> &);
bool rollback (store::write_transaction const &, nano::block_hash const &);
void update_account (store::write_transaction const &, nano::account const &, nano::account_info const &, nano::account_info const &);

92
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::block_status::progress, ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send));
auto open = builder
.open ()
.source (send->hash ())
@ -145,7 +145,7 @@ TEST (ledger, deep_account_compute)
.sign (key.prv, key.pub)
.work (*pool.generate (key.pub))
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open));
auto sprevious (send->hash ());
auto rprevious (open->hash ());
for (auto i (0), n (100000); i != n; ++i)
@ -159,7 +159,7 @@ TEST (ledger, deep_account_compute)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (sprevious))
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send));
sprevious = send->hash ();
auto receive = builder
.receive ()
@ -168,7 +168,7 @@ TEST (ledger, deep_account_compute)
.sign (key.prv, key.pub)
.work (*pool.generate (rprevious))
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive));
rprevious = receive->hash ();
if (i % 100 == 0)
{
@ -277,7 +277,7 @@ TEST (node, fork_storm)
previous = send->hash ();
for (auto node_i : system.nodes)
{
auto send_result (node_i->process (*send));
auto send_result (node_i->process (send));
ASSERT_EQ (nano::block_status::progress, send_result);
nano::keypair rep;
auto open = builder
@ -287,9 +287,9 @@ TEST (node, fork_storm)
.account (key.pub)
.sign (key.prv, key.pub)
.work (0)
.build_shared ();
.build ();
node_i->work_generate_blocking (*open);
auto open_result (node_i->process (*open));
auto open_result (node_i->process (open));
ASSERT_EQ (nano::block_status::progress, open_result);
auto transaction (node_i->store.tx_begin_read ());
node_i->network.flood_block (open);
@ -507,7 +507,7 @@ TEST (store, unchecked_load)
.balance (0)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (0)
.build_shared ();
.build ();
constexpr auto num_unchecked = 1'000'000;
for (auto i (0); i < num_unchecked; ++i)
{
@ -618,7 +618,7 @@ TEST (node, mass_vote_by_hash)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous))
.build_shared ();
.build ();
previous = block->hash ();
blocks.push_back (block);
}
@ -660,7 +660,7 @@ TEST (confirmation_height, many_accounts_single_confirmation)
.sign (last_keypair.prv, last_keypair.pub)
.work (*system.work.generate (last_open_hash))
.build ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send));
auto open = builder
.open ()
.source (send->hash ())
@ -669,7 +669,7 @@ TEST (confirmation_height, many_accounts_single_confirmation)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open));
last_open_hash = open->hash ();
last_keypair = key;
}
@ -744,7 +744,7 @@ TEST (confirmation_height, many_accounts_many_confirmations)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_genesis))
.build ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send));
auto open = builder
.open ()
.source (send->hash ())
@ -752,8 +752,8 @@ TEST (confirmation_height, many_accounts_many_confirmations)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open));
.build ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open));
open_blocks.push_back (std::move (open));
latest_genesis = send->hash ();
}
@ -826,8 +826,8 @@ TEST (confirmation_height, long_chains)
.build ();
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open));
}
// Bulk send from genesis account to destination account
@ -845,7 +845,7 @@ TEST (confirmation_height, long_chains)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous_genesis_chain_hash))
.build ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send));
auto receive = builder
.receive ()
.previous (previous_destination_chain_hash)
@ -853,7 +853,7 @@ TEST (confirmation_height, long_chains)
.sign (key1.prv, key1.pub)
.work (*system.work.generate (previous_destination_chain_hash))
.build ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive));
previous_genesis_chain_hash = send->hash ();
previous_destination_chain_hash = receive->hash ();
@ -878,7 +878,7 @@ TEST (confirmation_height, long_chains)
.link (send1->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (previous_genesis_chain_hash))
.build_shared ();
.build ();
// Unpocketed. Send to a non-existing account to prevent auto receives from the wallet adjusting expected confirmation height
nano::keypair key2;
@ -895,9 +895,9 @@ TEST (confirmation_height, long_chains)
{
auto transaction = node->store.tx_begin_write ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *receive1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send2));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, receive1));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send2));
}
// Call block confirm on the existing receive block on the genesis account which will confirm everything underneath on both accounts
@ -962,7 +962,7 @@ TEST (confirmation_height, dynamic_algorithm)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_genesis->hash ()))
.build_shared ();
.build ();
latest_genesis = send;
state_blocks.push_back (send);
}
@ -970,7 +970,7 @@ TEST (confirmation_height, dynamic_algorithm)
auto transaction = node->store.tx_begin_write ();
for (auto const & block : state_blocks)
{
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *block));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, block));
}
}
@ -1028,10 +1028,10 @@ TEST (confirmation_height, dynamic_algorithm_no_transition_while_pending)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_genesis))
.build_shared ();
.build ();
latest_genesis = send->hash ();
state_blocks.push_back (send);
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send));
++num;
};
@ -1116,7 +1116,7 @@ TEST (confirmation_height, many_accounts_send_receive_self)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_genesis))
.build ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send));
auto open = builder
.open ()
.source (send->hash ())
@ -1124,8 +1124,8 @@ TEST (confirmation_height, many_accounts_send_receive_self)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *open));
.build ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, open));
open_blocks.push_back (std::move (open));
latest_genesis = send->hash ();
}
@ -1161,14 +1161,14 @@ TEST (confirmation_height, many_accounts_send_receive_self)
.balance (1)
.sign (keypair.prv, keypair.pub)
.work (*system.work.generate (open_block->hash ()))
.build_shared ());
.build ());
receive_blocks.emplace_back (builder
.receive ()
.previous (send_blocks.back ()->hash ())
.source (send_blocks.back ()->hash ())
.sign (keypair.prv, keypair.pub)
.work (*system.work.generate (send_blocks.back ()->hash ()))
.build_shared ());
.build ());
}
// Now send and receive to self
@ -1263,7 +1263,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (latest_genesis))
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send));
auto open = builder
.open ()
.source (send->hash ())
@ -1271,8 +1271,8 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections)
.account (key.pub)
.sign (key.prv, key.pub)
.work (*pool.generate (key.pub))
.build_shared ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *open));
.build ();
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, open));
open_blocks.push_back (std::move (open));
latest_genesis = send->hash ();
}
@ -1307,17 +1307,17 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections)
.balance (1)
.sign (keypair.prv, keypair.pub)
.work (*system.work.generate (open_block->hash ()))
.build_shared ());
.build ());
receive_blocks.emplace_back (builder
.receive ()
.previous (send_blocks.back ()->hash ())
.source (send_blocks.back ()->hash ())
.sign (keypair.prv, keypair.pub)
.work (*system.work.generate (send_blocks.back ()->hash ()))
.build_shared ());
.build ());
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *send_blocks.back ()));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, *receive_blocks.back ()));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, send_blocks.back ()));
ASSERT_EQ (nano::block_status::progress, ledger.process (transaction, receive_blocks.back ()));
}
}
@ -1523,7 +1523,7 @@ TEST (telemetry, under_load)
.link (key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest_genesis))
.build_shared ();
.build ();
node->process_active (send);
latest_genesis = send->hash ();
auto open = builder
@ -1535,7 +1535,7 @@ TEST (telemetry, under_load)
.link (send->hash ())
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
.build ();
node->process_active (open);
auto latest_key = open->hash ();
@ -1553,7 +1553,7 @@ TEST (telemetry, under_load)
.link (key1.pub)
.sign (keypair.prv, keypair.pub)
.work (*system.work.generate (latest_l))
.build_shared ();
.build ();
latest_l = send->hash ();
node->process_active (send);
}
@ -1688,7 +1688,7 @@ TEST (telemetry, many_nodes)
for (auto node : system.nodes)
{
auto transaction (node->store.tx_begin_write ());
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send));
}
// This is the node which will request metrics from all other nodes
@ -1788,7 +1788,7 @@ TEST (node, mass_epoch_upgrader)
.build (ec);
ASSERT_FALSE (ec);
ASSERT_NE (nullptr, block);
ASSERT_EQ (nano::block_status::progress, node.process (*block));
ASSERT_EQ (nano::block_status::progress, node.process (block));
latest = block->hash ();
info.pending_hash = block->hash ();
}
@ -1812,7 +1812,7 @@ TEST (node, mass_epoch_upgrader)
.build (ec);
ASSERT_FALSE (ec);
ASSERT_NE (nullptr, block);
ASSERT_EQ (nano::block_status::progress, node.process (*block));
ASSERT_EQ (nano::block_status::progress, node.process (block));
}
ASSERT_EQ (1 + total_accounts + opened.size (), node.ledger.cache.block_count);
ASSERT_EQ (1 + opened.size (), node.ledger.cache.account_count);
@ -2042,7 +2042,7 @@ TEST (node, aggressive_flooding)
{
for (auto const & block : genesis_blocks)
{
auto process_result (node_wallet.first->process (*block));
auto process_result (node_wallet.first->process (block));
ASSERT_TRUE (nano::block_status::progress == process_result || nano::block_status::old == process_result);
}
ASSERT_EQ (node1.latest (nano::dev::genesis_key.pub), node_wallet.first->latest (nano::dev::genesis_key.pub));
@ -2146,7 +2146,7 @@ TEST (node, wallet_create_block_confirm_conflicts)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build ();
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, *send));
ASSERT_EQ (nano::block_status::progress, node->ledger.process (transaction, send));
latest = send->hash ();
}
}

8
nano/slow_test/vote_cache.cpp
View file

@ -26,7 +26,7 @@ nano::keypair setup_rep (nano::test::system & system, nano::node & node, nano::u
.balance (balance - amount)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
.build ();
auto open = builder
.open ()
@ -35,7 +35,7 @@ nano::keypair setup_rep (nano::test::system & system, nano::node & node, nano::u
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
.build ();
EXPECT_TRUE (nano::test::process (node, { send, open }));
EXPECT_TRUE (nano::test::start_elections (system, node, { send, open }, true));
@ -81,7 +81,7 @@ std::vector<std::shared_ptr<nano::block>> setup_blocks (nano::test::system & sys
.balance (balance)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (latest))
.build_shared ();
.build ();
auto open = builder
.open ()
@ -90,7 +90,7 @@ std::vector<std::shared_ptr<nano::block>> setup_blocks (nano::test::system & sys
.account (key.pub)
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
.build ();
latest = send->hash ();

14
nano/test_common/chains.cpp
View file

@ -23,7 +23,7 @@ nano::block_list_t nano::test::setup_chain (nano::test::system & system, nano::n
.link (throwaway.pub)
.sign (target.prv, target.pub)
.work (*system.work.generate (latest))
.build_shared ();
.build ();
latest = send->hash ();
@ -63,7 +63,7 @@ std::vector<std::pair<nano::account, nano::block_list_t>> nano::test::setup_chai
.link (key.pub)
.sign (source.prv, source.pub)
.work (*system.work.generate (latest))
.build_shared ();
.build ();
auto open = builder
.state ()
@ -74,7 +74,7 @@ std::vector<std::pair<nano::account, nano::block_list_t>> nano::test::setup_chai
.link (send->hash ())
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
.build ();
latest = send->hash ();
@ -120,7 +120,7 @@ nano::block_list_t nano::test::setup_independent_blocks (nano::test::system & sy
.link (key.pub)
.sign (source.prv, source.pub)
.work (*system.work.generate (latest))
.build_shared ();
.build ();
latest = send->hash ();
@ -133,7 +133,7 @@ nano::block_list_t nano::test::setup_independent_blocks (nano::test::system & sy
.link (send->hash ())
.sign (key.prv, key.pub)
.work (*system.work.generate (key.pub))
.build_shared ();
.build ();
EXPECT_TRUE (nano::test::process (node, { send, open }));
EXPECT_TIMELY (5s, nano::test::exists (node, { send, open })); // Ensure blocks are in the ledger
@ -162,7 +162,7 @@ std::pair<std::shared_ptr<nano::block>, std::shared_ptr<nano::block>> nano::test
.link (dest.pub)
.sign (source.prv, source.pub)
.work (*system.work.generate (latest))
.build_shared ();
.build ();
auto open = nano::block_builder ()
.state ()
@ -173,7 +173,7 @@ std::pair<std::shared_ptr<nano::block>, std::shared_ptr<nano::block>> nano::test
.link (send->hash ())
.sign (dest.prv, dest.pub)
.work (*system.work.generate (dest.pub))
.build_shared ();
.build ();
EXPECT_TRUE (nano::test::process (node, { send, open }));
EXPECT_TRUE (nano::test::start_elections (system, node, { send, open }, force_confirm));

10
nano/test_common/ledger.cpp
View file

@ -12,7 +12,7 @@ nano::test::context::ledger_context::ledger_context (std::deque<std::shared_ptr<
store_m->initialize (tx, ledger_m.cache, ledger_m.constants);
for (auto const & i : blocks_m)
{
auto process_result = ledger_m.process (tx, *i);
auto process_result = ledger_m.process (tx, i);
debug_assert (process_result == nano::block_status::progress);
}
}
@ -56,7 +56,7 @@ auto nano::test::context::ledger_send_receive () -> ledger_context
.link (nano::dev::genesis_key.pub)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
blocks.push_back (send);
auto receive = builder.state ()
.make_block ()
@ -67,7 +67,7 @@ auto nano::test::context::ledger_send_receive () -> ledger_context
.link (send->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (send->hash ()))
.build_shared ();
.build ();
blocks.push_back (receive);
return ledger_context{ std::move (blocks) };
}
@ -84,7 +84,7 @@ auto nano::test::context::ledger_send_receive_legacy () -> ledger_context
.balance (nano::dev::constants.genesis_amount - 1)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (nano::dev::genesis->hash ()))
.build_shared ();
.build ();
blocks.push_back (send);
auto receive = builder.receive ()
.make_block ()
@ -92,7 +92,7 @@ auto nano::test::context::ledger_send_receive_legacy () -> ledger_context
.source (send->hash ())
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*pool.generate (send->hash ()))
.build_shared ();
.build ();
blocks.push_back (receive);
return ledger_context{ std::move (blocks) };
}

12
nano/test_common/system.cpp
View file

@ -40,7 +40,7 @@ std::shared_ptr<nano::node> nano::test::system::add_node (nano::node_config cons
auto node (std::make_shared<nano::node> (io_ctx, nano::unique_path (), node_config_a, work, node_flags_a, node_sequence++));
for (auto i : initialization_blocks)
{
auto result = node->ledger.process (node->store.tx_begin_write (), *i);
auto result = node->ledger.process (node->store.tx_begin_write (), i);
debug_assert (result == nano::block_status::progress);
}
debug_assert (!node->init_error ());
@ -192,7 +192,7 @@ void nano::test::system::ledger_initialization_set (std::vector<nano::keypair> c
.balance (balance)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*work.generate (previous));
initialization_blocks.emplace_back (builder.build_shared ());
initialization_blocks.emplace_back (builder.build ());
previous = initialization_blocks.back ()->hash ();
builder.make_block ();
builder.account (i.pub)
@ -202,7 +202,7 @@ void nano::test::system::ledger_initialization_set (std::vector<nano::keypair> c
.balance (amount)
.sign (i.prv, i.pub)
.work (*work.generate (i.pub));
initialization_blocks.emplace_back (builder.build_shared ());
initialization_blocks.emplace_back (builder.build ());
}
}
@ -239,7 +239,7 @@ uint64_t nano::test::system::work_generate_limited (nano::block_hash const & roo
/** Initiate an epoch upgrade. Writes the epoch block into the ledger and leaves it to
* node background processes (e.g. frontiers confirmation) to cement the block.
*/
std::unique_ptr<nano::state_block> nano::test::upgrade_epoch (nano::work_pool & pool_a, nano::ledger & ledger_a, nano::epoch epoch_a)
std::shared_ptr<nano::state_block> nano::test::upgrade_epoch (nano::work_pool & pool_a, nano::ledger & ledger_a, nano::epoch epoch_a)
{
auto transaction (ledger_a.store.tx_begin_write ());
auto dev_genesis_key = nano::dev::genesis_key;
@ -262,13 +262,13 @@ 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) != nano::block_status::progress;
error = ledger_a.process (transaction, epoch) != nano::block_status::progress;
}
return !error ? std::move (epoch) : nullptr;
}
std::unique_ptr<nano::state_block> nano::test::system::upgrade_genesis_epoch (nano::node & node_a, nano::epoch const epoch_a)
std::shared_ptr<nano::state_block> nano::test::system::upgrade_genesis_epoch (nano::node & node_a, nano::epoch const epoch_a)
{
return upgrade_epoch (work, node_a.ledger, epoch_a);
}

4
nano/test_common/system.hpp
View file

@ -38,7 +38,7 @@ namespace test
void generate_receive (nano::node &);
void generate_send_new (nano::node &, std::vector<nano::account> &);
void generate_send_existing (nano::node &, std::vector<nano::account> &);
std::unique_ptr<nano::state_block> upgrade_genesis_epoch (nano::node &, nano::epoch const);
std::shared_ptr<nano::state_block> upgrade_genesis_epoch (nano::node &, nano::epoch const);
std::shared_ptr<nano::wallet> wallet (size_t);
nano::account account (store::transaction const &, size_t);
/** Generate work with difficulty between \p min_difficulty_a (inclusive) and \p max_difficulty_a (exclusive) */
@ -85,7 +85,7 @@ namespace test
std::vector<std::shared_ptr<nano::block>> initialization_blocks;
};
std::unique_ptr<nano::state_block> upgrade_epoch (nano::work_pool &, nano::ledger &, nano::epoch);
std::shared_ptr<nano::state_block> upgrade_epoch (nano::work_pool &, nano::ledger &, nano::epoch);
void cleanup_dev_directories_on_exit ();
}
}

2
nano/test_common/testutil.cpp
View file

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