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

Initializing message_header version and network fields from nano::network_constants in order to eliminate guesswork of setting these values before serializing.

Browse source
This commit is contained in:
clemahieu 2021-08-05 14:31:27 +01:00
commit 84603066bf
No known key found for this signature in database
GPG key ID: 43708520C8DFB938
28 changed files with 199 additions and 200 deletions
Download patch file Download diff file Expand all files Collapse all files

4
nano/core_test/active_transactions.cpp
View file

@ -253,11 +253,11 @@ TEST (active_transactions, inactive_votes_cache_fork)
node.vote_processor.vote (vote, std::make_shared<nano::transport::channel_loopback> (node)); node.vote_processor.vote (vote, std::make_shared<nano::transport::channel_loopback> (node));
auto channel1 (node.network.udp_channels.create (node.network.endpoint ())); auto channel1 (node.network.udp_channels.create (node.network.endpoint ()));
ASSERT_TIMELY (5s, node.active.inactive_votes_cache_size () == 1); ASSERT_TIMELY (5s, node.active.inactive_votes_cache_size () == 1);
node.network.inbound (nano::publish (send2), channel1); node.network.inbound (nano::publish{ nano::dev::network_params.network, send2 }, channel1);
node.block_processor.flush (); node.block_processor.flush ();
ASSERT_NE (nullptr, node.block (send2->hash ())); ASSERT_NE (nullptr, node.block (send2->hash ()));
node.scheduler.flush (); // Start election, otherwise conflicting block won't be inserted into election node.scheduler.flush (); // Start election, otherwise conflicting block won't be inserted into election
node.network.inbound (nano::publish (send1), channel1); node.network.inbound (nano::publish{ nano::dev::network_params.network, send1 }, channel1);
node.block_processor.flush (); node.block_processor.flush ();
bool confirmed (false); bool confirmed (false);
system.deadline_set (5s); system.deadline_set (5s);

4
nano/core_test/block.cpp
View file

@ -270,7 +270,7 @@ TEST (change_block, deserialize)
TEST (frontier_req, serialization) TEST (frontier_req, serialization)
{ {
nano::frontier_req request1; nano::frontier_req request1{ nano::dev::network_params.network };
request1.start = 1; request1.start = 1;
request1.age = 2; request1.age = 2;
request1.count = 3; request1.count = 3;
@ -293,7 +293,7 @@ TEST (block, publish_req_serialization)
nano::keypair key1; nano::keypair key1;
nano::keypair key2; nano::keypair key2;
auto block (std::make_shared<nano::send_block> (0, key2.pub, 200, nano::keypair ().prv, 2, 3)); auto block (std::make_shared<nano::send_block> (0, key2.pub, 200, nano::keypair ().prv, 2, 3));
nano::publish req (block); nano::publish req{ nano::dev::network_params.network, block };
std::vector<uint8_t> bytes; std::vector<uint8_t> bytes;
{ {
nano::vectorstream stream (bytes); nano::vectorstream stream (bytes);

54
nano/core_test/bootstrap.cpp
View file

@ -12,7 +12,7 @@ TEST (bulk_pull, no_address)
{ {
nano::system system (1); nano::system system (1);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0])); auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> (); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = 1; req->start = 1;
req->end = 2; req->end = 2;
connection->requests.push (std::unique_ptr<nano::message>{}); connection->requests.push (std::unique_ptr<nano::message>{});
@ -25,10 +25,10 @@ TEST (bulk_pull, genesis_to_end)
{ {
nano::system system (1); nano::system system (1);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0])); auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> (); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = nano::dev::genesis_key.pub; req->start = nano::dev::genesis_key.pub;
req->end.clear (); req->end.clear ();
connection->requests.push (std::unique_ptr<nano::message>{}); connection->requests.push (nullptr);
auto request (std::make_shared<nano::bulk_pull_server> (connection, std::move (req))); auto request (std::make_shared<nano::bulk_pull_server> (connection, std::move (req)));
ASSERT_EQ (system.nodes[0]->latest (nano::dev::genesis_key.pub), request->current); ASSERT_EQ (system.nodes[0]->latest (nano::dev::genesis_key.pub), request->current);
ASSERT_EQ (request->request->end, request->request->end); ASSERT_EQ (request->request->end, request->request->end);
@ -39,7 +39,7 @@ TEST (bulk_pull, no_end)
{ {
nano::system system (1); nano::system system (1);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0])); auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> (); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = nano::dev::genesis_key.pub; req->start = nano::dev::genesis_key.pub;
req->end = 1; req->end = 1;
connection->requests.push (std::unique_ptr<nano::message>{}); connection->requests.push (std::unique_ptr<nano::message>{});
@ -64,7 +64,7 @@ TEST (bulk_pull, end_not_owned)
system.nodes[0]->work_generate_blocking (open); system.nodes[0]->work_generate_blocking (open);
ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (open).code); ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (open).code);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0])); auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> (); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = key2.pub; req->start = key2.pub;
req->end = nano::dev::genesis->hash (); req->end = nano::dev::genesis->hash ();
connection->requests.push (std::unique_ptr<nano::message>{}); connection->requests.push (std::unique_ptr<nano::message>{});
@ -76,7 +76,7 @@ TEST (bulk_pull, none)
{ {
nano::system system (1); nano::system system (1);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0])); auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> (); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = nano::dev::genesis_key.pub; req->start = nano::dev::genesis_key.pub;
req->end = nano::dev::genesis->hash (); req->end = nano::dev::genesis->hash ();
connection->requests.push (std::unique_ptr<nano::message>{}); connection->requests.push (std::unique_ptr<nano::message>{});
@ -89,7 +89,7 @@ TEST (bulk_pull, get_next_on_open)
{ {
nano::system system (1); nano::system system (1);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0])); auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> (); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = nano::dev::genesis_key.pub; req->start = nano::dev::genesis_key.pub;
req->end.clear (); req->end.clear ();
connection->requests.push (std::unique_ptr<nano::message>{}); connection->requests.push (std::unique_ptr<nano::message>{});
@ -105,7 +105,7 @@ TEST (bulk_pull, by_block)
{ {
nano::system system (1); nano::system system (1);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0])); auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> (); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = nano::dev::genesis->hash (); req->start = nano::dev::genesis->hash ();
req->end.clear (); req->end.clear ();
connection->requests.push (std::unique_ptr<nano::message>{}); connection->requests.push (std::unique_ptr<nano::message>{});
@ -122,7 +122,7 @@ TEST (bulk_pull, by_block_single)
{ {
nano::system system (1); nano::system system (1);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0])); auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
auto req = std::make_unique<nano::bulk_pull> (); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = nano::dev::genesis->hash (); req->start = nano::dev::genesis->hash ();
req->end = nano::dev::genesis->hash (); req->end = nano::dev::genesis->hash ();
connection->requests.push (std::unique_ptr<nano::message>{}); connection->requests.push (std::unique_ptr<nano::message>{});
@ -146,7 +146,7 @@ TEST (bulk_pull, count_limit)
ASSERT_EQ (nano::process_result::progress, node0->process (*receive1).code); ASSERT_EQ (nano::process_result::progress, node0->process (*receive1).code);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node0), node0)); auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node0), node0));
auto req = std::make_unique<nano::bulk_pull> (); auto req = std::make_unique<nano::bulk_pull> (nano::dev::network_params.network);
req->start = receive1->hash (); req->start = receive1->hash ();
req->set_count_present (true); req->set_count_present (true);
req->count = 2; req->count = 2;
@ -1393,7 +1393,7 @@ TEST (frontier_req_response, DISABLED_destruction)
{ {
nano::system system (1); nano::system system (1);
auto connection (std::make_shared<nano::bootstrap_server> (nullptr, system.nodes[0])); auto connection (std::make_shared<nano::bootstrap_server> (nullptr, system.nodes[0]));
auto req = std::make_unique<nano::frontier_req> (); auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req->start.clear (); req->start.clear ();
req->age = std::numeric_limits<decltype (req->age)>::max (); req->age = std::numeric_limits<decltype (req->age)>::max ();
req->count = std::numeric_limits<decltype (req->count)>::max (); req->count = std::numeric_limits<decltype (req->count)>::max ();
@ -1408,7 +1408,7 @@ TEST (frontier_req, begin)
{ {
nano::system system (1); nano::system system (1);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0])); auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
auto req = std::make_unique<nano::frontier_req> (); auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req->start.clear (); req->start.clear ();
req->age = std::numeric_limits<decltype (req->age)>::max (); req->age = std::numeric_limits<decltype (req->age)>::max ();
req->count = std::numeric_limits<decltype (req->count)>::max (); req->count = std::numeric_limits<decltype (req->count)>::max ();
@ -1422,7 +1422,7 @@ TEST (frontier_req, end)
{ {
nano::system system (1); nano::system system (1);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0])); auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
auto req = std::make_unique<nano::frontier_req> (); auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req->start = nano::dev::genesis_key.pub.number () + 1; req->start = nano::dev::genesis_key.pub.number () + 1;
req->age = std::numeric_limits<decltype (req->age)>::max (); req->age = std::numeric_limits<decltype (req->age)>::max ();
req->count = std::numeric_limits<decltype (req->count)>::max (); req->count = std::numeric_limits<decltype (req->count)>::max ();
@ -1464,7 +1464,7 @@ TEST (frontier_req, count)
ASSERT_EQ (nano::process_result::progress, node1->process (*receive1).code); ASSERT_EQ (nano::process_result::progress, node1->process (*receive1).code);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node1), node1)); auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node1), node1));
auto req = std::make_unique<nano::frontier_req> (); auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req->start.clear (); req->start.clear ();
req->age = std::numeric_limits<decltype (req->age)>::max (); req->age = std::numeric_limits<decltype (req->age)>::max ();
req->count = 1; req->count = 1;
@ -1478,7 +1478,7 @@ TEST (frontier_req, time_bound)
{ {
nano::system system (1); nano::system system (1);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0])); auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
auto req = std::make_unique<nano::frontier_req> (); auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req->start.clear (); req->start.clear ();
req->age = 1; req->age = 1;
req->count = std::numeric_limits<decltype (req->count)>::max (); req->count = std::numeric_limits<decltype (req->count)>::max ();
@ -1487,7 +1487,7 @@ TEST (frontier_req, time_bound)
ASSERT_EQ (nano::dev::genesis_key.pub, request->current); ASSERT_EQ (nano::dev::genesis_key.pub, request->current);
// Wait 2 seconds until age of account will be > 1 seconds // Wait 2 seconds until age of account will be > 1 seconds
std::this_thread::sleep_for (std::chrono::milliseconds (2100)); std::this_thread::sleep_for (std::chrono::milliseconds (2100));
auto req2 (std::make_unique<nano::frontier_req> ()); auto req2 (std::make_unique<nano::frontier_req> (nano::dev::network_params.network));
req2->start.clear (); req2->start.clear ();
req2->age = 1; req2->age = 1;
req2->count = std::numeric_limits<decltype (req2->count)>::max (); req2->count = std::numeric_limits<decltype (req2->count)>::max ();
@ -1501,7 +1501,7 @@ TEST (frontier_req, time_cutoff)
{ {
nano::system system (1); nano::system system (1);
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0])); auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
auto req = std::make_unique<nano::frontier_req> (); auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req->start.clear (); req->start.clear ();
req->age = 3; req->age = 3;
req->count = std::numeric_limits<decltype (req->count)>::max (); req->count = std::numeric_limits<decltype (req->count)>::max ();
@ -1511,7 +1511,7 @@ TEST (frontier_req, time_cutoff)
ASSERT_EQ (nano::dev::genesis->hash (), request->frontier); ASSERT_EQ (nano::dev::genesis->hash (), request->frontier);
// Wait 4 seconds until age of account will be > 3 seconds // Wait 4 seconds until age of account will be > 3 seconds
std::this_thread::sleep_for (std::chrono::milliseconds (4100)); std::this_thread::sleep_for (std::chrono::milliseconds (4100));
auto req2 (std::make_unique<nano::frontier_req> ()); auto req2 (std::make_unique<nano::frontier_req> (nano::dev::network_params.network));
req2->start.clear (); req2->start.clear ();
req2->age = 3; req2->age = 3;
req2->count = std::numeric_limits<decltype (req2->count)>::max (); req2->count = std::numeric_limits<decltype (req2->count)>::max ();
@ -1590,7 +1590,7 @@ TEST (frontier_req, confirmed_frontier)
// Request for all accounts (confirmed only) // Request for all accounts (confirmed only)
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node1), node1)); auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node1), node1));
auto req = std::make_unique<nano::frontier_req> (); auto req = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req->start.clear (); req->start.clear ();
req->age = std::numeric_limits<decltype (req->age)>::max (); req->age = std::numeric_limits<decltype (req->age)>::max ();
req->count = std::numeric_limits<decltype (req->count)>::max (); req->count = std::numeric_limits<decltype (req->count)>::max ();
@ -1604,7 +1604,7 @@ TEST (frontier_req, confirmed_frontier)
// Request starting with account before genesis (confirmed only) // Request starting with account before genesis (confirmed only)
auto connection2 (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node1), node1)); auto connection2 (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node1), node1));
auto req2 = std::make_unique<nano::frontier_req> (); auto req2 = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req2->start = key_before_genesis.pub; req2->start = key_before_genesis.pub;
req2->age = std::numeric_limits<decltype (req2->age)>::max (); req2->age = std::numeric_limits<decltype (req2->age)>::max ();
req2->count = std::numeric_limits<decltype (req2->count)>::max (); req2->count = std::numeric_limits<decltype (req2->count)>::max ();
@ -1618,7 +1618,7 @@ TEST (frontier_req, confirmed_frontier)
// Request starting with account after genesis (confirmed only) // Request starting with account after genesis (confirmed only)
auto connection3 (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node1), node1)); auto connection3 (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node1), node1));
auto req3 = std::make_unique<nano::frontier_req> (); auto req3 = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req3->start = key_after_genesis.pub; req3->start = key_after_genesis.pub;
req3->age = std::numeric_limits<decltype (req3->age)>::max (); req3->age = std::numeric_limits<decltype (req3->age)>::max ();
req3->count = std::numeric_limits<decltype (req3->count)>::max (); req3->count = std::numeric_limits<decltype (req3->count)>::max ();
@ -1632,7 +1632,7 @@ TEST (frontier_req, confirmed_frontier)
// Request for all accounts (unconfirmed blocks) // Request for all accounts (unconfirmed blocks)
auto connection4 (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node1), node1)); auto connection4 (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node1), node1));
auto req4 = std::make_unique<nano::frontier_req> (); auto req4 = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req4->start.clear (); req4->start.clear ();
req4->age = std::numeric_limits<decltype (req4->age)>::max (); req4->age = std::numeric_limits<decltype (req4->age)>::max ();
req4->count = std::numeric_limits<decltype (req4->count)>::max (); req4->count = std::numeric_limits<decltype (req4->count)>::max ();
@ -1644,7 +1644,7 @@ TEST (frontier_req, confirmed_frontier)
// Request starting with account after genesis (unconfirmed blocks) // Request starting with account after genesis (unconfirmed blocks)
auto connection5 (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node1), node1)); auto connection5 (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node1), node1));
auto req5 = std::make_unique<nano::frontier_req> (); auto req5 = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req5->start = key_after_genesis.pub; req5->start = key_after_genesis.pub;
req5->age = std::numeric_limits<decltype (req5->age)>::max (); req5->age = std::numeric_limits<decltype (req5->age)>::max ();
req5->count = std::numeric_limits<decltype (req5->count)>::max (); req5->count = std::numeric_limits<decltype (req5->count)>::max ();
@ -1658,7 +1658,7 @@ TEST (frontier_req, confirmed_frontier)
nano::blocks_confirm (*node1, { send1, receive1 }, true); nano::blocks_confirm (*node1, { send1, receive1 }, true);
ASSERT_TIMELY (5s, node1->block_confirmed (send1->hash ()) && node1->block_confirmed (receive1->hash ())); ASSERT_TIMELY (5s, node1->block_confirmed (send1->hash ()) && node1->block_confirmed (receive1->hash ()));
auto connection6 (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node1), node1)); auto connection6 (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node1), node1));
auto req6 = std::make_unique<nano::frontier_req> (); auto req6 = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req6->start = key_before_genesis.pub; req6->start = key_before_genesis.pub;
req6->age = std::numeric_limits<decltype (req6->age)>::max (); req6->age = std::numeric_limits<decltype (req6->age)>::max ();
req6->count = std::numeric_limits<decltype (req6->count)>::max (); req6->count = std::numeric_limits<decltype (req6->count)>::max ();
@ -1674,7 +1674,7 @@ TEST (frontier_req, confirmed_frontier)
nano::blocks_confirm (*node1, { send2, receive2 }, true); nano::blocks_confirm (*node1, { send2, receive2 }, true);
ASSERT_TIMELY (5s, node1->block_confirmed (send2->hash ()) && node1->block_confirmed (receive2->hash ())); ASSERT_TIMELY (5s, node1->block_confirmed (send2->hash ()) && node1->block_confirmed (receive2->hash ()));
auto connection7 (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node1), node1)); auto connection7 (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*node1), node1));
auto req7 = std::make_unique<nano::frontier_req> (); auto req7 = std::make_unique<nano::frontier_req> (nano::dev::network_params.network);
req7->start = key_after_genesis.pub; req7->start = key_after_genesis.pub;
req7->age = std::numeric_limits<decltype (req7->age)>::max (); req7->age = std::numeric_limits<decltype (req7->age)>::max ();
req7->count = std::numeric_limits<decltype (req7->count)>::max (); req7->count = std::numeric_limits<decltype (req7->count)>::max ();
@ -1851,7 +1851,7 @@ TEST (bulk_pull_account, basics)
auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0])); auto connection (std::make_shared<nano::bootstrap_server> (std::make_shared<nano::socket> (*system.nodes[0]), system.nodes[0]));
{ {
auto req = std::make_unique<nano::bulk_pull_account> (); auto req = std::make_unique<nano::bulk_pull_account> (nano::dev::network_params.network);
req->account = key1.pub; req->account = key1.pub;
req->minimum_amount = 5; req->minimum_amount = 5;
req->flags = nano::bulk_pull_account_flags (); req->flags = nano::bulk_pull_account_flags ();
@ -1870,7 +1870,7 @@ TEST (bulk_pull_account, basics)
} }
{ {
auto req = std::make_unique<nano::bulk_pull_account> (); auto req = std::make_unique<nano::bulk_pull_account> (nano::dev::network_params.network);
req->account = key1.pub; req->account = key1.pub;
req->minimum_amount = 0; req->minimum_amount = 0;
req->flags = nano::bulk_pull_account_flags::pending_address_only; req->flags = nano::bulk_pull_account_flags::pending_address_only;

4
nano/core_test/confirmation_height.cpp
View file

@ -654,10 +654,10 @@ TEST (confirmation_height, conflict_rollback_cemented)
ASSERT_EQ (1, node1->network.size ()); ASSERT_EQ (1, node1->network.size ());
nano::keypair key1; nano::keypair key1;
auto send1 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); auto send1 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
nano::publish publish1 (send1); nano::publish publish1{ nano::dev::network_params.network, send1 };
nano::keypair key2; nano::keypair key2;
auto send2 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key2.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); auto send2 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key2.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
nano::publish publish2 (send2); nano::publish publish2{ nano::dev::network_params.network, send2 };
auto channel1 (node1->network.udp_channels.create (node1->network.endpoint ())); auto channel1 (node1->network.udp_channels.create (node1->network.endpoint ()));
node1->network.inbound (publish1, channel1); node1->network.inbound (publish1, channel1);
node1->block_processor.flush (); node1->block_processor.flush ();

32
nano/core_test/message.cpp
View file

@ -8,7 +8,7 @@
TEST (message, keepalive_serialization) TEST (message, keepalive_serialization)
{ {
nano::keepalive request1; nano::keepalive request1{ nano::dev::network_params.network };
std::vector<uint8_t> bytes; std::vector<uint8_t> bytes;
{ {
nano::vectorstream stream (bytes); nano::vectorstream stream (bytes);
@ -25,7 +25,7 @@ TEST (message, keepalive_serialization)
TEST (message, keepalive_deserialize) TEST (message, keepalive_deserialize)
{ {
nano::keepalive message1; nano::keepalive message1{ nano::dev::network_params.network };
message1.peers[0] = nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000); message1.peers[0] = nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000);
std::vector<uint8_t> bytes; std::vector<uint8_t> bytes;
{ {
@ -44,11 +44,7 @@ TEST (message, keepalive_deserialize)
TEST (message, publish_serialization) TEST (message, publish_serialization)
{ {
nano::publish publish (std::make_shared<nano::send_block> (0, 1, 2, nano::keypair ().prv, 4, 5)); nano::publish publish{ nano::dev::network_params.network, std::make_shared<nano::send_block> (0, 1, 2, nano::keypair ().prv, 4, 5) };
publish.header.network = nano::networks::nano_dev_network;
publish.header.version_max = 6;
publish.header.version_using = 5;
publish.header.version_min = 4;
ASSERT_EQ (nano::block_type::send, publish.header.block_type ()); ASSERT_EQ (nano::block_type::send, publish.header.block_type ());
std::vector<uint8_t> bytes; std::vector<uint8_t> bytes;
{ {
@ -58,9 +54,9 @@ TEST (message, publish_serialization)
ASSERT_EQ (8, bytes.size ()); ASSERT_EQ (8, bytes.size ());
ASSERT_EQ (0x52, bytes[0]); ASSERT_EQ (0x52, bytes[0]);
ASSERT_EQ (0x41, bytes[1]); ASSERT_EQ (0x41, bytes[1]);
ASSERT_EQ (6, bytes[2]); ASSERT_EQ (nano::dev::network_params.network.protocol_version, bytes[2]);
ASSERT_EQ (5, bytes[3]); ASSERT_EQ (nano::dev::network_params.network.protocol_version, bytes[3]);
ASSERT_EQ (4, bytes[4]); ASSERT_EQ (nano::dev::network_params.network.protocol_version_min, bytes[4]);
ASSERT_EQ (static_cast<uint8_t> (nano::message_type::publish), bytes[5]); ASSERT_EQ (static_cast<uint8_t> (nano::message_type::publish), bytes[5]);
ASSERT_EQ (0x00, bytes[6]); // extensions ASSERT_EQ (0x00, bytes[6]); // extensions
ASSERT_EQ (static_cast<uint8_t> (nano::block_type::send), bytes[7]); ASSERT_EQ (static_cast<uint8_t> (nano::block_type::send), bytes[7]);
@ -68,9 +64,9 @@ TEST (message, publish_serialization)
auto error (false); auto error (false);
nano::message_header header (error, stream); nano::message_header header (error, stream);
ASSERT_FALSE (error); ASSERT_FALSE (error);
ASSERT_EQ (4, header.version_min); ASSERT_EQ (nano::dev::network_params.network.protocol_version_min, header.version_min);
ASSERT_EQ (5, header.version_using); ASSERT_EQ (nano::dev::network_params.network.protocol_version, header.version_using);
ASSERT_EQ (6, header.version_max); ASSERT_EQ (nano::dev::network_params.network.protocol_version, header.version_max);
ASSERT_EQ (nano::message_type::publish, header.type); ASSERT_EQ (nano::message_type::publish, header.type);
} }
@ -78,7 +74,7 @@ TEST (message, confirm_ack_serialization)
{ {
nano::keypair key1; nano::keypair key1;
auto vote (std::make_shared<nano::vote> (key1.pub, key1.prv, 0, std::make_shared<nano::send_block> (0, 1, 2, key1.prv, 4, 5))); auto vote (std::make_shared<nano::vote> (key1.pub, key1.prv, 0, std::make_shared<nano::send_block> (0, 1, 2, key1.prv, 4, 5)));
nano::confirm_ack con1 (vote); nano::confirm_ack con1{ nano::dev::network_params.network, vote };
std::vector<uint8_t> bytes; std::vector<uint8_t> bytes;
{ {
nano::vectorstream stream1 (bytes); nano::vectorstream stream1 (bytes);
@ -106,7 +102,7 @@ TEST (message, confirm_ack_hash_serialization)
} }
nano::keypair representative1; nano::keypair representative1;
auto vote (std::make_shared<nano::vote> (representative1.pub, representative1.prv, 0, hashes)); auto vote (std::make_shared<nano::vote> (representative1.pub, representative1.prv, 0, hashes));
nano::confirm_ack con1 (vote); nano::confirm_ack con1{ nano::dev::network_params.network, vote };
std::vector<uint8_t> bytes; std::vector<uint8_t> bytes;
{ {
nano::vectorstream stream1 (bytes); nano::vectorstream stream1 (bytes);
@ -134,7 +130,7 @@ TEST (message, confirm_req_serialization)
nano::keypair key1; nano::keypair key1;
nano::keypair key2; nano::keypair key2;
auto block (std::make_shared<nano::send_block> (0, key2.pub, 200, nano::keypair ().prv, 2, 3)); auto block (std::make_shared<nano::send_block> (0, key2.pub, 200, nano::keypair ().prv, 2, 3));
nano::confirm_req req (block); nano::confirm_req req{ nano::dev::network_params.network, block };
std::vector<uint8_t> bytes; std::vector<uint8_t> bytes;
{ {
nano::vectorstream stream (bytes); nano::vectorstream stream (bytes);
@ -154,7 +150,7 @@ TEST (message, confirm_req_hash_serialization)
nano::keypair key1; nano::keypair key1;
nano::keypair key2; nano::keypair key2;
nano::send_block block (1, key2.pub, 200, nano::keypair ().prv, 2, 3); nano::send_block block (1, key2.pub, 200, nano::keypair ().prv, 2, 3);
nano::confirm_req req (block.hash (), block.root ()); nano::confirm_req req{ nano::dev::network_params.network, block.hash (), block.root () };
std::vector<uint8_t> bytes; std::vector<uint8_t> bytes;
{ {
nano::vectorstream stream (bytes); nano::vectorstream stream (bytes);
@ -187,7 +183,7 @@ TEST (message, confirm_req_hash_batch_serialization)
roots_hashes.push_back (std::make_pair (block.hash (), block.root ())); roots_hashes.push_back (std::make_pair (block.hash (), block.root ()));
} }
roots_hashes.push_back (std::make_pair (open.hash (), open.root ())); roots_hashes.push_back (std::make_pair (open.hash (), open.root ()));
nano::confirm_req req (roots_hashes); nano::confirm_req req{ nano::dev::network_params.network, roots_hashes };
std::vector<uint8_t> bytes; std::vector<uint8_t> bytes;
{ {
nano::vectorstream stream (bytes); nano::vectorstream stream (bytes);

10
nano/core_test/message_parser.cpp
View file

@ -71,7 +71,7 @@ TEST (message_parser, exact_confirm_ack_size)
nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, network); nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, network);
auto block (std::make_shared<nano::send_block> (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1)))); auto block (std::make_shared<nano::send_block> (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1))));
auto vote (std::make_shared<nano::vote> (0, nano::keypair ().prv, 0, std::move (block))); auto vote (std::make_shared<nano::vote> (0, nano::keypair ().prv, 0, std::move (block)));
nano::confirm_ack message (vote); nano::confirm_ack message{ nano::dev::network_params.network, vote };
std::vector<uint8_t> bytes; std::vector<uint8_t> bytes;
{ {
nano::vectorstream stream (bytes); nano::vectorstream stream (bytes);
@ -105,7 +105,7 @@ TEST (message_parser, exact_confirm_req_size)
nano::network_constants network; nano::network_constants network;
nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, network); nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, network);
auto block (std::make_shared<nano::send_block> (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1)))); auto block (std::make_shared<nano::send_block> (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1))));
nano::confirm_req message (std::move (block)); nano::confirm_req message{ nano::dev::network_params.network, block };
std::vector<uint8_t> bytes; std::vector<uint8_t> bytes;
{ {
nano::vectorstream stream (bytes); nano::vectorstream stream (bytes);
@ -139,7 +139,7 @@ TEST (message_parser, exact_confirm_req_hash_size)
nano::network_constants network; nano::network_constants network;
nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, network); nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, network);
nano::send_block block (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1))); nano::send_block block (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1)));
nano::confirm_req message (block.hash (), block.root ()); nano::confirm_req message{ nano::dev::network_params.network, block.hash (), block.root () };
std::vector<uint8_t> bytes; std::vector<uint8_t> bytes;
{ {
nano::vectorstream stream (bytes); nano::vectorstream stream (bytes);
@ -173,7 +173,7 @@ TEST (message_parser, exact_publish_size)
nano::network_constants network; nano::network_constants network;
nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, network); nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, network);
auto block (std::make_shared<nano::send_block> (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1)))); auto block (std::make_shared<nano::send_block> (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1))));
nano::publish message (std::move (block)); nano::publish message{ nano::dev::network_params.network, block };
std::vector<uint8_t> bytes; std::vector<uint8_t> bytes;
{ {
nano::vectorstream stream (bytes); nano::vectorstream stream (bytes);
@ -206,7 +206,7 @@ TEST (message_parser, exact_keepalive_size)
nano::vote_uniquer vote_uniquer (block_uniquer); nano::vote_uniquer vote_uniquer (block_uniquer);
nano::network_constants network; nano::network_constants network;
nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, network); nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, network);
nano::keepalive message; nano::keepalive message{ nano::dev::network_params.network };
std::vector<uint8_t> bytes; std::vector<uint8_t> bytes;
{ {
nano::vectorstream stream (bytes); nano::vectorstream stream (bytes);

32
nano/core_test/network.cpp
View file

@ -304,7 +304,7 @@ TEST (network, send_insufficient_work_udp)
auto & node1 = *system.add_node (node_flags); auto & node1 = *system.add_node (node_flags);
auto & node2 = *system.add_node (node_flags); auto & node2 = *system.add_node (node_flags);
auto block (std::make_shared<nano::send_block> (0, 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); auto block (std::make_shared<nano::send_block> (0, 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
nano::publish publish (block); nano::publish publish{ nano::dev::network_params.network, block };
nano::transport::channel_udp channel (node1.network.udp_channels, node2.network.endpoint (), node1.network_params.network.protocol_version); nano::transport::channel_udp channel (node1.network.udp_channels, node2.network.endpoint (), node1.network_params.network.protocol_version);
channel.send (publish, [] (boost::system::error_code const & ec, size_t size) {}); channel.send (publish, [] (boost::system::error_code const & ec, size_t size) {});
ASSERT_EQ (0, node1.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work)); ASSERT_EQ (0, node1.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work));
@ -319,7 +319,7 @@ TEST (network, send_insufficient_work)
auto & node2 = *system.nodes[1]; auto & node2 = *system.nodes[1];
// Block zero work // Block zero work
auto block1 (std::make_shared<nano::send_block> (0, 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); auto block1 (std::make_shared<nano::send_block> (0, 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0));
nano::publish publish1 (block1); nano::publish publish1{ nano::dev::network_params.network, block1 };
auto tcp_channel (node1.network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node2.network.endpoint ()))); auto tcp_channel (node1.network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node2.network.endpoint ())));
tcp_channel->send (publish1, [] (boost::system::error_code const & ec, size_t size) {}); tcp_channel->send (publish1, [] (boost::system::error_code const & ec, size_t size) {});
ASSERT_EQ (0, node1.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work)); ASSERT_EQ (0, node1.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work));
@ -327,20 +327,20 @@ TEST (network, send_insufficient_work)
ASSERT_EQ (1, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work)); ASSERT_EQ (1, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work));
// Legacy block work between epoch_2_recieve & epoch_1 // Legacy block work between epoch_2_recieve & epoch_1
auto block2 (std::make_shared<nano::send_block> (block1->hash (), 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.network.publish_thresholds.epoch_2_receive, node1.network_params.network.publish_thresholds.epoch_1 - 1))); auto block2 (std::make_shared<nano::send_block> (block1->hash (), 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.network.publish_thresholds.epoch_2_receive, node1.network_params.network.publish_thresholds.epoch_1 - 1)));
nano::publish publish2 (block2); nano::publish publish2{ nano::dev::network_params.network, block2 };
tcp_channel->send (publish2, [] (boost::system::error_code const & ec, size_t size) {}); 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); ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work) != 1);
ASSERT_EQ (2, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work)); ASSERT_EQ (2, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work));
// Legacy block work epoch_1 // Legacy block work epoch_1
auto block3 (std::make_shared<nano::send_block> (block2->hash (), 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (block2->hash (), node1.network_params.network.publish_thresholds.epoch_2))); auto block3 (std::make_shared<nano::send_block> (block2->hash (), 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (block2->hash (), node1.network_params.network.publish_thresholds.epoch_2)));
nano::publish publish3 (block3); nano::publish publish3{ nano::dev::network_params.network, block3 };
tcp_channel->send (publish3, [] (boost::system::error_code const & ec, size_t size) {}); 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)); ASSERT_EQ (0, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in));
ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0); ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0);
ASSERT_EQ (1, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in)); ASSERT_EQ (1, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in));
// State block work epoch_2_recieve // State block work epoch_2_recieve
auto block4 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, block1->hash (), nano::dev::genesis_key.pub, 20, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.network.publish_thresholds.epoch_2_receive, node1.network_params.network.publish_thresholds.epoch_1 - 1))); auto block4 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, block1->hash (), nano::dev::genesis_key.pub, 20, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.network.publish_thresholds.epoch_2_receive, node1.network_params.network.publish_thresholds.epoch_1 - 1)));
nano::publish publish4 (block4); nano::publish publish4{ nano::dev::network_params.network, block4 };
tcp_channel->send (publish4, [] (boost::system::error_code const & ec, size_t size) {}); 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); ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0);
ASSERT_EQ (1, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in)); ASSERT_EQ (1, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in));
@ -357,7 +357,7 @@ TEST (receivable_processor, confirm_insufficient_pos)
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
nano::keypair key1; nano::keypair key1;
auto vote (std::make_shared<nano::vote> (key1.pub, key1.prv, 0, block1)); auto vote (std::make_shared<nano::vote> (key1.pub, key1.prv, 0, block1));
nano::confirm_ack con1 (vote); nano::confirm_ack con1{ nano::dev::network_params.network, vote };
node1.network.inbound (con1, node1.network.udp_channels.create (node1.network.endpoint ())); node1.network.inbound (con1, node1.network.udp_channels.create (node1.network.endpoint ()));
} }
@ -370,7 +370,7 @@ TEST (receivable_processor, confirm_sufficient_pos)
ASSERT_EQ (nano::process_result::progress, node1.process (*block1).code); ASSERT_EQ (nano::process_result::progress, node1.process (*block1).code);
node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ());
auto vote (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, block1)); auto vote (std::make_shared<nano::vote> (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, block1));
nano::confirm_ack con1 (vote); nano::confirm_ack con1{ nano::dev::network_params.network, vote };
node1.network.inbound (con1, node1.network.udp_channels.create (node1.network.endpoint ())); node1.network.inbound (con1, node1.network.udp_channels.create (node1.network.endpoint ()));
} }
@ -783,7 +783,7 @@ TEST (tcp_listener, tcp_node_id_handshake)
auto socket (std::make_shared<nano::socket> (*system.nodes[0])); auto socket (std::make_shared<nano::socket> (*system.nodes[0]));
auto bootstrap_endpoint (system.nodes[0]->bootstrap.endpoint ()); auto bootstrap_endpoint (system.nodes[0]->bootstrap.endpoint ());
auto cookie (system.nodes[0]->network.syn_cookies.assign (nano::transport::map_tcp_to_endpoint (bootstrap_endpoint))); auto cookie (system.nodes[0]->network.syn_cookies.assign (nano::transport::map_tcp_to_endpoint (bootstrap_endpoint)));
nano::node_id_handshake node_id_handshake (cookie, boost::none); nano::node_id_handshake node_id_handshake{ nano::dev::network_params.network, cookie, boost::none };
auto input (node_id_handshake.to_shared_const_buffer ()); auto input (node_id_handshake.to_shared_const_buffer ());
std::atomic<bool> write_done (false); std::atomic<bool> write_done (false);
socket->async_connect (bootstrap_endpoint, [&input, socket, &write_done] (boost::system::error_code const & ec) { socket->async_connect (bootstrap_endpoint, [&input, socket, &write_done] (boost::system::error_code const & ec) {
@ -798,7 +798,7 @@ TEST (tcp_listener, tcp_node_id_handshake)
ASSERT_TIMELY (5s, write_done); ASSERT_TIMELY (5s, write_done);
boost::optional<std::pair<nano::account, nano::signature>> response_zero (std::make_pair (nano::account (0), nano::signature (0))); boost::optional<std::pair<nano::account, nano::signature>> response_zero (std::make_pair (nano::account (0), nano::signature (0)));
nano::node_id_handshake node_id_handshake_response (boost::none, response_zero); nano::node_id_handshake node_id_handshake_response{ nano::dev::network_params.network, boost::none, response_zero };
auto output (node_id_handshake_response.to_bytes ()); auto output (node_id_handshake_response.to_bytes ());
std::atomic<bool> done (false); std::atomic<bool> done (false);
socket->async_read (output, output->size (), [&output, &done] (boost::system::error_code const & ec, size_t size_a) { socket->async_read (output, output->size (), [&output, &done] (boost::system::error_code const & ec, size_t size_a) {
@ -838,7 +838,7 @@ TEST (tcp_listener, tcp_listener_timeout_node_id_handshake)
auto node0 (system.nodes[0]); auto node0 (system.nodes[0]);
auto socket (std::make_shared<nano::socket> (*node0)); auto socket (std::make_shared<nano::socket> (*node0));
auto cookie (node0->network.syn_cookies.assign (nano::transport::map_tcp_to_endpoint (node0->bootstrap.endpoint ()))); auto cookie (node0->network.syn_cookies.assign (nano::transport::map_tcp_to_endpoint (node0->bootstrap.endpoint ())));
nano::node_id_handshake node_id_handshake (cookie, boost::none); nano::node_id_handshake node_id_handshake{ nano::dev::network_params.network, cookie, boost::none };
auto channel = std::make_shared<nano::transport::channel_tcp> (*node0, socket); auto channel = std::make_shared<nano::transport::channel_tcp> (*node0, socket);
socket->async_connect (node0->bootstrap.endpoint (), [&node_id_handshake, channel] (boost::system::error_code const & ec) { socket->async_connect (node0->bootstrap.endpoint (), [&node_id_handshake, channel] (boost::system::error_code const & ec) {
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
@ -942,7 +942,7 @@ TEST (network, duplicate_detection)
auto & node0 (*system.add_node (node_flags)); auto & node0 (*system.add_node (node_flags));
auto & node1 (*system.add_node (node_flags)); auto & node1 (*system.add_node (node_flags));
auto udp_channel (std::make_shared<nano::transport::channel_udp> (node0.network.udp_channels, node1.network.endpoint (), node1.network_params.network.protocol_version)); auto udp_channel (std::make_shared<nano::transport::channel_udp> (node0.network.udp_channels, node1.network.endpoint (), node1.network_params.network.protocol_version));
nano::publish publish (nano::dev::genesis); nano::publish publish{ nano::dev::network_params.network, nano::dev::genesis };
// Publish duplicate detection through UDP // Publish duplicate detection through UDP
ASSERT_EQ (0, node1.stats.count (nano::stat::type::filter, nano::stat::detail::duplicate_publish)); ASSERT_EQ (0, node1.stats.count (nano::stat::type::filter, nano::stat::detail::duplicate_publish));
@ -964,7 +964,7 @@ TEST (network, duplicate_revert_publish)
node_flags.block_processor_full_size = 0; node_flags.block_processor_full_size = 0;
auto & node (*system.add_node (node_flags)); auto & node (*system.add_node (node_flags));
ASSERT_TRUE (node.block_processor.full ()); ASSERT_TRUE (node.block_processor.full ());
nano::publish publish (nano::dev::genesis); nano::publish publish{ nano::dev::network_params.network, nano::dev::genesis };
std::vector<uint8_t> bytes; std::vector<uint8_t> bytes;
{ {
nano::vectorstream stream (bytes); nano::vectorstream stream (bytes);
@ -993,7 +993,7 @@ TEST (network, duplicate_revert_publish)
TEST (network, bandwidth_limiter) TEST (network, bandwidth_limiter)
{ {
nano::system system; nano::system system;
nano::publish message (nano::dev::genesis); nano::publish message{ nano::dev::network_params.network, nano::dev::genesis };
auto message_size = message.to_bytes ()->size (); auto message_size = message.to_bytes ()->size ();
auto message_limit = 4; // must be multiple of the number of channels auto message_limit = 4; // must be multiple of the number of channels
nano::node_config node_config (nano::get_available_port (), system.logging); nano::node_config node_config (nano::get_available_port (), system.logging);
@ -1254,11 +1254,11 @@ TEST (network, filter)
{ {
nano::system system{ 1 }; nano::system system{ 1 };
auto & node1 = *system.nodes[0]; auto & node1 = *system.nodes[0];
nano::keepalive keepalive; nano::keepalive keepalive{ nano::dev::network_params.network };
keepalive.header.network = nano::networks::nano_dev_network; const_cast<nano::networks &> (keepalive.header.network) = nano::networks::nano_dev_network;
node1.network.inbound (keepalive, std::make_shared<nano::transport::channel_loopback> (node1)); node1.network.inbound (keepalive, std::make_shared<nano::transport::channel_loopback> (node1));
ASSERT_EQ (0, node1.stats.count (nano::stat::type::message, nano::stat::detail::invalid_network)); ASSERT_EQ (0, node1.stats.count (nano::stat::type::message, nano::stat::detail::invalid_network));
keepalive.header.network = nano::networks::invalid; const_cast<nano::networks &> (keepalive.header.network) = nano::networks::invalid;
node1.network.inbound (keepalive, std::make_shared<nano::transport::channel_loopback> (node1)); node1.network.inbound (keepalive, std::make_shared<nano::transport::channel_loopback> (node1));
ASSERT_EQ (1, node1.stats.count (nano::stat::type::message, nano::stat::detail::invalid_network)); ASSERT_EQ (1, node1.stats.count (nano::stat::type::message, nano::stat::detail::invalid_network));
} }

4
nano/core_test/network_filter.cpp
View file

@ -11,7 +11,7 @@ TEST (network_filter, unit)
nano::ledger_constants constants{ nano::networks::nano_dev_network }; nano::ledger_constants constants{ nano::networks::nano_dev_network };
nano::network_filter filter (1); nano::network_filter filter (1);
auto one_block = [&filter] (std::shared_ptr<nano::block> const & block_a, bool expect_duplicate_a) { auto one_block = [&filter] (std::shared_ptr<nano::block> const & block_a, bool expect_duplicate_a) {
nano::publish message (block_a); nano::publish message{ nano::dev::network_params.network, block_a };
auto bytes (message.to_bytes ()); auto bytes (message.to_bytes ());
nano::bufferstream stream (bytes->data (), bytes->size ()); nano::bufferstream stream (bytes->data (), bytes->size ());
@ -78,7 +78,7 @@ TEST (network_filter, many)
.work (0) .work (0)
.build_shared (); .build_shared ();
nano::publish message (block); nano::publish message{ nano::dev::network_params.network, block };
auto bytes (message.to_bytes ()); auto bytes (message.to_bytes ());
nano::bufferstream stream (bytes->data (), bytes->size ()); nano::bufferstream stream (bytes->data (), bytes->size ());

42
nano/core_test/node.cpp
View file

@ -361,7 +361,7 @@ TEST (node, receive_gap)
.work (0) .work (0)
.build_shared (); .build_shared ();
node1.work_generate_blocking (*block); node1.work_generate_blocking (*block);
nano::publish message (block); nano::publish message{ nano::dev::network_params.network, block };
node1.network.inbound (message, node1.network.udp_channels.create (node1.network.endpoint ())); node1.network.inbound (message, node1.network.udp_channels.create (node1.network.endpoint ()));
node1.block_processor.flush (); node1.block_processor.flush ();
ASSERT_EQ (1, node1.gap_cache.size ()); ASSERT_EQ (1, node1.gap_cache.size ());
@ -1191,7 +1191,7 @@ TEST (node, fork_flip)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared (); .build_shared ();
nano::publish publish1 (send1); nano::publish publish1{ nano::dev::network_params.network, send1 };
nano::keypair key2; nano::keypair key2;
auto send2 = builder.make_block () auto send2 = builder.make_block ()
.previous (nano::dev::genesis->hash ()) .previous (nano::dev::genesis->hash ())
@ -1200,7 +1200,7 @@ TEST (node, fork_flip)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared (); .build_shared ();
nano::publish publish2 (send2); nano::publish publish2{ nano::dev::network_params.network, send2 };
auto channel1 (node1.network.udp_channels.create (node1.network.endpoint ())); auto channel1 (node1.network.udp_channels.create (node1.network.endpoint ()));
node1.network.inbound (publish1, channel1); node1.network.inbound (publish1, channel1);
node1.block_processor.flush (); node1.block_processor.flush ();
@ -1258,7 +1258,7 @@ TEST (node, fork_multi_flip)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared (); .build_shared ();
nano::publish publish1 (send1); nano::publish publish1{ nano::dev::network_params.network, send1 };
nano::keypair key2; nano::keypair key2;
auto send2 = builder.make_block () auto send2 = builder.make_block ()
.previous (nano::dev::genesis->hash ()) .previous (nano::dev::genesis->hash ())
@ -1267,7 +1267,7 @@ TEST (node, fork_multi_flip)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared (); .build_shared ();
nano::publish publish2 (send2); nano::publish publish2{ nano::dev::network_params.network, send2 };
auto send3 = builder.make_block () auto send3 = builder.make_block ()
.previous (publish2.block->hash ()) .previous (publish2.block->hash ())
.destination (key2.pub) .destination (key2.pub)
@ -1275,7 +1275,7 @@ TEST (node, fork_multi_flip)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (publish2.block->hash ())) .work (*system.work.generate (publish2.block->hash ()))
.build_shared (); .build_shared ();
nano::publish publish3 (send3); nano::publish publish3{ nano::dev::network_params.network, send3 };
node1.network.inbound (publish1, node1.network.udp_channels.create (node1.network.endpoint ())); node1.network.inbound (publish1, node1.network.udp_channels.create (node1.network.endpoint ()));
node2.network.inbound (publish2, node2.network.udp_channels.create (node2.network.endpoint ())); node2.network.inbound (publish2, node2.network.udp_channels.create (node2.network.endpoint ()));
node2.network.inbound (publish3, node2.network.udp_channels.create (node2.network.endpoint ())); node2.network.inbound (publish3, node2.network.udp_channels.create (node2.network.endpoint ()));
@ -1368,7 +1368,7 @@ TEST (node, fork_open)
.sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub)
.work (*system.work.generate (nano::dev::genesis->hash ())) .work (*system.work.generate (nano::dev::genesis->hash ()))
.build_shared (); .build_shared ();
nano::publish publish1 (send1); nano::publish publish1{ nano::dev::network_params.network, send1 };
auto channel1 (node1.network.udp_channels.create (node1.network.endpoint ())); auto channel1 (node1.network.udp_channels.create (node1.network.endpoint ()));
node1.network.inbound (publish1, channel1); node1.network.inbound (publish1, channel1);
node1.block_processor.flush (); node1.block_processor.flush ();
@ -1385,7 +1385,7 @@ TEST (node, fork_open)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub)) .work (*system.work.generate (key1.pub))
.build_shared (); .build_shared ();
nano::publish publish2 (open1); nano::publish publish2{ nano::dev::network_params.network, open1 };
node1.network.inbound (publish2, channel1); node1.network.inbound (publish2, channel1);
node1.block_processor.flush (); node1.block_processor.flush ();
node1.scheduler.flush (); node1.scheduler.flush ();
@ -1397,7 +1397,7 @@ TEST (node, fork_open)
.sign (key1.prv, key1.pub) .sign (key1.prv, key1.pub)
.work (*system.work.generate (key1.pub)) .work (*system.work.generate (key1.pub))
.build_shared (); .build_shared ();
nano::publish publish3 (open2); nano::publish publish3{ nano::dev::network_params.network, open2 };
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
node1.network.inbound (publish3, channel1); node1.network.inbound (publish3, channel1);
node1.block_processor.flush (); node1.block_processor.flush ();
@ -1531,7 +1531,7 @@ TEST (node, fork_no_vote_quorum)
auto transaction (system.wallet (1)->wallets.tx_begin_read ()); auto transaction (system.wallet (1)->wallets.tx_begin_read ());
ASSERT_FALSE (system.wallet (1)->store.fetch (transaction, key1, key3)); ASSERT_FALSE (system.wallet (1)->store.fetch (transaction, key1, key3));
auto vote (std::make_shared<nano::vote> (key1, key3, 0, send2)); auto vote (std::make_shared<nano::vote> (key1, key3, 0, send2));
nano::confirm_ack confirm (vote); nano::confirm_ack confirm{ nano::dev::network_params.network, vote };
std::vector<uint8_t> buffer; std::vector<uint8_t> buffer;
{ {
nano::vectorstream stream (buffer); nano::vectorstream stream (buffer);
@ -2692,8 +2692,8 @@ TEST (node, local_votes_cache)
election->force_confirm (); election->force_confirm ();
ASSERT_TIMELY (3s, node.ledger.cache.cemented_count == 3); ASSERT_TIMELY (3s, node.ledger.cache.cemented_count == 3);
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
nano::confirm_req message1 (send1); nano::confirm_req message1{ nano::dev::network_params.network, send1 };
nano::confirm_req message2 (send2); nano::confirm_req message2{ nano::dev::network_params.network, send2 };
auto channel (node.network.udp_channels.create (node.network.endpoint ())); auto channel (node.network.udp_channels.create (node.network.endpoint ()));
node.network.inbound (message1, channel); node.network.inbound (message1, channel);
ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_generated_votes) == 1); ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_generated_votes) == 1);
@ -2715,7 +2715,7 @@ TEST (node, local_votes_cache)
auto transaction (node.store.tx_begin_write ()); auto transaction (node.store.tx_begin_write ());
ASSERT_EQ (nano::process_result::progress, node.ledger.process (transaction, *send3).code); ASSERT_EQ (nano::process_result::progress, node.ledger.process (transaction, *send3).code);
} }
nano::confirm_req message3 (send3); nano::confirm_req message3{ nano::dev::network_params.network, send3 };
for (auto i (0); i < 100; ++i) for (auto i (0); i < 100; ++i)
{ {
node.network.inbound (message3, channel); node.network.inbound (message3, channel);
@ -2772,7 +2772,7 @@ TEST (node, local_votes_cache_batch)
.build_shared (); .build_shared ();
ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code);
std::vector<std::pair<nano::block_hash, nano::root>> batch{ { send2->hash (), send2->root () }, { receive1->hash (), receive1->root () } }; std::vector<std::pair<nano::block_hash, nano::root>> batch{ { send2->hash (), send2->root () }, { receive1->hash (), receive1->root () } };
nano::confirm_req message (batch); nano::confirm_req message{ nano::dev::network_params.network, batch };
auto channel (node.network.udp_channels.create (node.network.endpoint ())); auto channel (node.network.udp_channels.create (node.network.endpoint ()));
// Generates and sends one vote for both hashes which is then cached // Generates and sends one vote for both hashes which is then cached
node.network.inbound (message, channel); node.network.inbound (message, channel);
@ -2787,10 +2787,10 @@ TEST (node, local_votes_cache_batch)
// Test when votes are different // Test when votes are different
node.history.erase (send2->root ()); node.history.erase (send2->root ());
node.history.erase (receive1->root ()); node.history.erase (receive1->root ());
node.network.inbound (nano::confirm_req (send2->hash (), send2->root ()), channel); node.network.inbound (nano::confirm_req{ nano::dev::network_params.network, send2->hash (), send2->root () }, channel);
ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out) == 3); ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out) == 3);
ASSERT_EQ (3, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out)); ASSERT_EQ (3, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out));
node.network.inbound (nano::confirm_req (receive1->hash (), receive1->root ()), channel); node.network.inbound (nano::confirm_req{ nano::dev::network_params.network, receive1->hash (), receive1->root () }, channel);
ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out) == 4); ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out) == 4);
ASSERT_EQ (4, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out)); ASSERT_EQ (4, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out));
// There are two different votes, so both should be sent in response // There are two different votes, so both should be sent in response
@ -2807,7 +2807,7 @@ TEST (node, local_votes_cache_generate_new_vote)
auto & node (*system.add_node (node_config)); auto & node (*system.add_node (node_config));
system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv);
// Repsond with cached vote // Repsond with cached vote
nano::confirm_req message1 (nano::dev::genesis); nano::confirm_req message1{ nano::dev::network_params.network, nano::dev::genesis };
auto channel (node.network.udp_channels.create (node.network.endpoint ())); auto channel (node.network.udp_channels.create (node.network.endpoint ()));
node.network.inbound (message1, channel); node.network.inbound (message1, channel);
ASSERT_TIMELY (3s, !node.history.votes (nano::dev::genesis->root (), nano::dev::genesis->hash ()).empty ()); ASSERT_TIMELY (3s, !node.history.votes (nano::dev::genesis->root (), nano::dev::genesis->hash ()).empty ());
@ -2828,7 +2828,7 @@ TEST (node, local_votes_cache_generate_new_vote)
ASSERT_EQ (nano::process_result::progress, node.process (*send1).code); ASSERT_EQ (nano::process_result::progress, node.process (*send1).code);
// One of the hashes is cached // One of the hashes is cached
std::vector<std::pair<nano::block_hash, nano::root>> roots_hashes{ std::make_pair (nano::dev::genesis->hash (), nano::dev::genesis->root ()), std::make_pair (send1->hash (), send1->root ()) }; std::vector<std::pair<nano::block_hash, nano::root>> roots_hashes{ std::make_pair (nano::dev::genesis->hash (), nano::dev::genesis->root ()), std::make_pair (send1->hash (), send1->root ()) };
nano::confirm_req message2 (roots_hashes); nano::confirm_req message2{ nano::dev::network_params.network, roots_hashes };
node.network.inbound (message2, channel); node.network.inbound (message2, channel);
ASSERT_TIMELY (3s, !node.history.votes (send1->root (), send1->hash ()).empty ()); ASSERT_TIMELY (3s, !node.history.votes (send1->root (), send1->hash ()).empty ());
auto votes2 (node.history.votes (send1->root (), send1->hash ())); auto votes2 (node.history.votes (send1->root (), send1->hash ()));
@ -3231,13 +3231,13 @@ TEST (node, fork_election_invalid_block_signature)
.sign (nano::dev::genesis_key.prv, 0) // Invalid signature .sign (nano::dev::genesis_key.prv, 0) // Invalid signature
.build_shared (); .build_shared ();
auto channel1 (node1.network.udp_channels.create (node1.network.endpoint ())); auto channel1 (node1.network.udp_channels.create (node1.network.endpoint ()));
node1.network.inbound (nano::publish (send1), channel1); node1.network.inbound (nano::publish{ nano::dev::network_params.network, send1 }, channel1);
ASSERT_TIMELY (5s, node1.active.active (send1->qualified_root ())); ASSERT_TIMELY (5s, node1.active.active (send1->qualified_root ()));
auto election (node1.active.election (send1->qualified_root ())); auto election (node1.active.election (send1->qualified_root ()));
ASSERT_NE (nullptr, election); ASSERT_NE (nullptr, election);
ASSERT_EQ (1, election->blocks ().size ()); ASSERT_EQ (1, election->blocks ().size ());
node1.network.inbound (nano::publish (send3), channel1); node1.network.inbound (nano::publish{ nano::dev::network_params.network, send3 }, channel1);
node1.network.inbound (nano::publish (send2), channel1); node1.network.inbound (nano::publish{ nano::dev::network_params.network, send2 }, channel1);
ASSERT_TIMELY (3s, election->blocks ().size () > 1); ASSERT_TIMELY (3s, election->blocks ().size () > 1);
ASSERT_EQ (election->blocks ()[send2->hash ()]->block_signature (), send2->block_signature ()); ASSERT_EQ (election->blocks ()[send2->hash ()]->block_signature (), send2->block_signature ());
} }

4
nano/core_test/peer_container.cpp
View file

@ -179,8 +179,8 @@ TEST (peer_container, depeer)
{ {
nano::system system (1); nano::system system (1);
nano::endpoint endpoint0 (boost::asio::ip::address_v6::loopback (), nano::get_available_port ()); nano::endpoint endpoint0 (boost::asio::ip::address_v6::loopback (), nano::get_available_port ());
nano::keepalive message; nano::keepalive message{ nano::dev::network_params.network };
message.header.version_using = 1; const_cast<uint8_t &> (message.header.version_using) = 1;
auto bytes (message.to_bytes ()); auto bytes (message.to_bytes ());
nano::message_buffer buffer = { bytes->data (), bytes->size (), endpoint0 }; nano::message_buffer buffer = { bytes->data (), bytes->size (), endpoint0 };
system.nodes[0]->network.udp_channels.receive_action (&buffer); system.nodes[0]->network.udp_channels.receive_action (&buffer);

10
nano/core_test/telemetry.cpp
View file

@ -284,7 +284,7 @@ TEST (telemetry, receive_from_non_listening_channel)
{ {
nano::system system; nano::system system;
auto node = system.add_node (); auto node = system.add_node ();
nano::telemetry_ack message (nano::telemetry_data{}); nano::telemetry_ack message{ nano::dev::network_params.network, nano::telemetry_data{} };
node->network.inbound (message, node->network.udp_channels.create (node->network.endpoint ())); node->network.inbound (message, node->network.udp_channels.create (node->network.endpoint ()));
// We have not sent a telemetry_req message to this endpoint, so shouldn't count telemetry_ack received from it. // We have not sent a telemetry_req message to this endpoint, so shouldn't count telemetry_ack received from it.
ASSERT_EQ (node->telemetry->telemetry_data_size (), 0); ASSERT_EQ (node->telemetry->telemetry_data_size (), 0);
@ -412,7 +412,7 @@ TEST (telemetry, dos_tcp)
wait_peer_connections (system); wait_peer_connections (system);
nano::telemetry_req message; nano::telemetry_req message{ nano::dev::network_params.network };
auto channel = node_client->network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node_server->network.endpoint ())); auto channel = node_client->network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node_server->network.endpoint ()));
channel->send (message, [] (boost::system::error_code const & ec, size_t size_a) { channel->send (message, [] (boost::system::error_code const & ec, size_t size_a) {
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
@ -455,7 +455,7 @@ TEST (telemetry, dos_udp)
wait_peer_connections (system); wait_peer_connections (system);
nano::telemetry_req message; nano::telemetry_req message{ nano::dev::network_params.network };
auto channel (node_client->network.udp_channels.create (node_server->network.endpoint ())); auto channel (node_client->network.udp_channels.create (node_server->network.endpoint ()));
channel->send (message, [] (boost::system::error_code const & ec, size_t size_a) { channel->send (message, [] (boost::system::error_code const & ec, size_t size_a) {
ASSERT_FALSE (ec); ASSERT_FALSE (ec);
@ -532,7 +532,7 @@ TEST (telemetry, max_possible_size)
nano::telemetry_data data; nano::telemetry_data data;
data.unknown_data.resize (nano::message_header::telemetry_size_mask.to_ulong () - nano::telemetry_data::latest_size); data.unknown_data.resize (nano::message_header::telemetry_size_mask.to_ulong () - nano::telemetry_data::latest_size);
nano::telemetry_ack message (data); nano::telemetry_ack message{ nano::dev::network_params.network, data };
wait_peer_connections (system); wait_peer_connections (system);
auto channel = node_client->network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node_server->network.endpoint ())); auto channel = node_client->network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node_server->network.endpoint ()));
@ -651,7 +651,7 @@ TEST (telemetry, remove_peer_invalid_signature)
auto telemetry_data = nano::local_telemetry_data (node->ledger, node->network, node->config.bandwidth_limit, node->network_params, node->startup_time, node->default_difficulty (nano::work_version::work_1), node->node_id); auto telemetry_data = nano::local_telemetry_data (node->ledger, node->network, node->config.bandwidth_limit, node->network_params, node->startup_time, node->default_difficulty (nano::work_version::work_1), node->node_id);
// Change anything so that the signed message is incorrect // Change anything so that the signed message is incorrect
telemetry_data.block_count = 0; telemetry_data.block_count = 0;
auto telemetry_ack = nano::telemetry_ack (telemetry_data); auto telemetry_ack = nano::telemetry_ack{ nano::dev::network_params.network, telemetry_data };
node->network.inbound (telemetry_ack, channel); node->network.inbound (telemetry_ack, channel);
ASSERT_TIMELY (10s, node->stats.count (nano::stat::type::telemetry, nano::stat::detail::invalid_signature) > 0); ASSERT_TIMELY (10s, node->stats.count (nano::stat::type::telemetry, nano::stat::detail::invalid_signature) > 0);

2
nano/core_test/websocket.cpp
View file

@ -141,7 +141,7 @@ TEST (websocket, stopped_election)
// Create election, then erase it, causing a websocket message to be emitted // Create election, then erase it, causing a websocket message to be emitted
nano::keypair key1; nano::keypair key1;
auto send1 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); auto send1 (std::make_shared<nano::send_block> (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())));
nano::publish publish1 (send1); nano::publish publish1{ nano::dev::network_params.network, send1 };
auto channel1 (node1->network.udp_channels.create (node1->network.endpoint ())); auto channel1 (node1->network.udp_channels.create (node1->network.endpoint ()));
node1->network.inbound (publish1, channel1); node1->network.inbound (publish1, channel1);
node1->block_processor.flush (); node1->block_processor.flush ();

4
nano/node/bootstrap/bootstrap_bulk_pull.cpp
View file

@ -58,7 +58,7 @@ void nano::bulk_pull_client::request ()
{ {
debug_assert (!pull.head.is_zero () || pull.retry_limit <= connection->node->network_params.bootstrap.lazy_retry_limit); debug_assert (!pull.head.is_zero () || pull.retry_limit <= connection->node->network_params.bootstrap.lazy_retry_limit);
expected = pull.head; expected = pull.head;
nano::bulk_pull req; nano::bulk_pull req{ connection->node->network_params.network };
if (pull.head == pull.head_original && pull.attempts % 4 < 3) if (pull.head == pull.head_original && pull.attempts % 4 < 3)
{ {
// Account for new pulls // Account for new pulls
@ -300,7 +300,7 @@ nano::bulk_pull_account_client::~bulk_pull_account_client ()
void nano::bulk_pull_account_client::request () void nano::bulk_pull_account_client::request ()
{ {
nano::bulk_pull_account req; nano::bulk_pull_account req{ connection->node->network_params.network };
req.account = account; req.account = account;
req.minimum_amount = connection->node->config.receive_minimum; req.minimum_amount = connection->node->config.receive_minimum;
req.flags = nano::bulk_pull_account_flags::pending_hash_and_amount; req.flags = nano::bulk_pull_account_flags::pending_hash_and_amount;

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

@ -17,7 +17,7 @@ nano::bulk_push_client::~bulk_push_client ()
void nano::bulk_push_client::start () void nano::bulk_push_client::start ()
{ {
nano::bulk_push message; nano::bulk_push message{ connection->node->network_params.network };
auto this_l (shared_from_this ()); auto this_l (shared_from_this ());
connection->channel->send ( connection->channel->send (
message, [this_l] (boost::system::error_code const & ec, size_t size_a) { message, [this_l] (boost::system::error_code const & ec, size_t size_a) {

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

@ -14,7 +14,7 @@ constexpr size_t nano::frontier_req_client::size_frontier;
void nano::frontier_req_client::run (nano::account const & start_account_a, uint32_t const frontiers_age_a, uint32_t const count_a) void nano::frontier_req_client::run (nano::account const & start_account_a, uint32_t const frontiers_age_a, uint32_t const count_a)
{ {
nano::frontier_req request; nano::frontier_req request{ connection->node->network_params.network };
request.start = (start_account_a.is_zero () || start_account_a.number () == std::numeric_limits<nano::uint256_t>::max ()) ? start_account_a : start_account_a.number () + 1; request.start = (start_account_a.is_zero () || start_account_a.number () == std::numeric_limits<nano::uint256_t>::max ()) ? start_account_a : start_account_a.number () + 1;
request.age = frontiers_age_a; request.age = frontiers_age_a;
request.count = count_a; request.count = count_a;

5
nano/node/bootstrap/bootstrap_server.cpp
View file

@ -669,10 +669,7 @@ public:
boost::optional<std::pair<nano::account, nano::signature>> response (std::make_pair (connection->node->node_id.pub, nano::sign_message (connection->node->node_id.prv, connection->node->node_id.pub, *message_a.query))); boost::optional<std::pair<nano::account, nano::signature>> response (std::make_pair (connection->node->node_id.pub, nano::sign_message (connection->node->node_id.prv, connection->node->node_id.pub, *message_a.query)));
debug_assert (!nano::validate_message (response->first, *message_a.query, response->second)); debug_assert (!nano::validate_message (response->first, *message_a.query, response->second));
auto cookie (connection->node->network.syn_cookies.assign (nano::transport::map_tcp_to_endpoint (connection->remote_endpoint))); auto cookie (connection->node->network.syn_cookies.assign (nano::transport::map_tcp_to_endpoint (connection->remote_endpoint)));
nano::node_id_handshake response_message (cookie, response); nano::node_id_handshake response_message (connection->node->network_params.network, cookie, response);
response_message.header.version_max = connection->node->network_params.network.protocol_version;
response_message.header.version_using = connection->node->network_params.network.protocol_version;
response_message.header.version_min = connection->node->network_params.network.protocol_version_min;
auto shared_const_buffer = response_message.to_shared_const_buffer (); auto shared_const_buffer = response_message.to_shared_const_buffer ();
connection->socket->async_write (shared_const_buffer, [connection = std::weak_ptr<nano::bootstrap_server> (connection)] (boost::system::error_code const & ec, size_t size_a) { connection->socket->async_write (shared_const_buffer, [connection = std::weak_ptr<nano::bootstrap_server> (connection)] (boost::system::error_code const & ec, size_t size_a) {
if (auto connection_l = connection.lock ()) if (auto connection_l = connection.lock ())

67
nano/node/common.cpp
View file

@ -40,8 +40,11 @@ uint64_t nano::ip_address_hash_raw (boost::asio::ip::address const & ip_a, uint1
return result; return result;
} }
nano::message_header::message_header (nano::message_type type_a) : nano::message_header::message_header (nano::network_constants const & constants, nano::message_type type_a) :
network (nano::network_constants::active_network), network{ constants.current_network },
version_max{ constants.protocol_version },
version_using{ constants.protocol_version },
version_min{ constants.protocol_version_min },
type (type_a) type (type_a)
{ {
} }
@ -88,8 +91,8 @@ bool nano::message_header::deserialize (nano::stream & stream_a)
return error; return error;
} }
nano::message::message (nano::message_type type_a) : nano::message::message (nano::network_constants const & constants, nano::message_type type_a) :
header (type_a) header (constants, type_a)
{ {
} }
@ -535,8 +538,8 @@ bool nano::message_parser::at_end (nano::stream & stream_a)
return end; return end;
} }
nano::keepalive::keepalive () : nano::keepalive::keepalive (nano::network_constants const & constants) :
message (nano::message_type::keepalive) message (constants, nano::message_type::keepalive)
{ {
nano::endpoint endpoint (boost::asio::ip::address_v6{}, 0); nano::endpoint endpoint (boost::asio::ip::address_v6{}, 0);
for (auto i (peers.begin ()), n (peers.end ()); i != n; ++i) for (auto i (peers.begin ()), n (peers.end ()); i != n; ++i)
@ -606,8 +609,8 @@ nano::publish::publish (bool & error_a, nano::stream & stream_a, nano::message_h
} }
} }
nano::publish::publish (std::shared_ptr<nano::block> const & block_a) : nano::publish::publish (nano::network_constants const & constants, std::shared_ptr<nano::block> const & block_a) :
message (nano::message_type::publish), message (constants, nano::message_type::publish),
block (block_a) block (block_a)
{ {
header.block_type_set (block->type ()); header.block_type_set (block->type ());
@ -647,15 +650,15 @@ nano::confirm_req::confirm_req (bool & error_a, nano::stream & stream_a, nano::m
} }
} }
nano::confirm_req::confirm_req (std::shared_ptr<nano::block> const & block_a) : nano::confirm_req::confirm_req (nano::network_constants const & constants, std::shared_ptr<nano::block> const & block_a) :
message (nano::message_type::confirm_req), message (constants, nano::message_type::confirm_req),
block (block_a) block (block_a)
{ {
header.block_type_set (block->type ()); header.block_type_set (block->type ());
} }
nano::confirm_req::confirm_req (std::vector<std::pair<nano::block_hash, nano::root>> const & roots_hashes_a) : nano::confirm_req::confirm_req (nano::network_constants const & constants, std::vector<std::pair<nano::block_hash, nano::root>> const & roots_hashes_a) :
message (nano::message_type::confirm_req), message (constants, nano::message_type::confirm_req),
roots_hashes (roots_hashes_a) roots_hashes (roots_hashes_a)
{ {
// not_a_block (1) block type for hashes + roots request // not_a_block (1) block type for hashes + roots request
@ -664,8 +667,8 @@ nano::confirm_req::confirm_req (std::vector<std::pair<nano::block_hash, nano::ro
header.count_set (static_cast<uint8_t> (roots_hashes.size ())); header.count_set (static_cast<uint8_t> (roots_hashes.size ()));
} }
nano::confirm_req::confirm_req (nano::block_hash const & hash_a, nano::root const & root_a) : nano::confirm_req::confirm_req (nano::network_constants const & constants, nano::block_hash const & hash_a, nano::root const & root_a) :
message (nano::message_type::confirm_req), message (constants, nano::message_type::confirm_req),
roots_hashes (std::vector<std::pair<nano::block_hash, nano::root>> (1, std::make_pair (hash_a, root_a))) roots_hashes (std::vector<std::pair<nano::block_hash, nano::root>> (1, std::make_pair (hash_a, root_a)))
{ {
debug_assert (!roots_hashes.empty ()); debug_assert (!roots_hashes.empty ());
@ -788,8 +791,8 @@ nano::confirm_ack::confirm_ack (bool & error_a, nano::stream & stream_a, nano::m
} }
} }
nano::confirm_ack::confirm_ack (std::shared_ptr<nano::vote> const & vote_a) : nano::confirm_ack::confirm_ack (nano::network_constants const & constants, std::shared_ptr<nano::vote> const & vote_a) :
message (nano::message_type::confirm_ack), message (constants, nano::message_type::confirm_ack),
vote (vote_a) vote (vote_a)
{ {
debug_assert (!vote_a->blocks.empty ()); debug_assert (!vote_a->blocks.empty ());
@ -838,8 +841,8 @@ size_t nano::confirm_ack::size (nano::block_type type_a, size_t count)
return result; return result;
} }
nano::frontier_req::frontier_req () : nano::frontier_req::frontier_req (nano::network_constants const & constants) :
message (nano::message_type::frontier_req) message (constants, nano::message_type::frontier_req)
{ {
} }
@ -888,8 +891,8 @@ bool nano::frontier_req::operator== (nano::frontier_req const & other_a) const
return start == other_a.start && age == other_a.age && count == other_a.count; return start == other_a.start && age == other_a.age && count == other_a.count;
} }
nano::bulk_pull::bulk_pull () : nano::bulk_pull::bulk_pull (nano::network_constants const & constants) :
message (nano::message_type::bulk_pull) message (constants, nano::message_type::bulk_pull)
{ {
} }
@ -984,8 +987,8 @@ void nano::bulk_pull::set_count_present (bool value_a)
header.extensions.set (count_present_flag, value_a); header.extensions.set (count_present_flag, value_a);
} }
nano::bulk_pull_account::bulk_pull_account () : nano::bulk_pull_account::bulk_pull_account (nano::network_constants const & constants) :
message (nano::message_type::bulk_pull_account) message (constants, nano::message_type::bulk_pull_account)
{ {
} }
@ -1029,8 +1032,8 @@ bool nano::bulk_pull_account::deserialize (nano::stream & stream_a)
return error; return error;
} }
nano::bulk_push::bulk_push () : nano::bulk_push::bulk_push (nano::network_constants const & constants) :
message (nano::message_type::bulk_push) message (constants, nano::message_type::bulk_push)
{ {
} }
@ -1055,8 +1058,8 @@ void nano::bulk_push::visit (nano::message_visitor & visitor_a) const
visitor_a.bulk_push (*this); visitor_a.bulk_push (*this);
} }
nano::telemetry_req::telemetry_req () : nano::telemetry_req::telemetry_req (nano::network_constants const & constants) :
message (nano::message_type::telemetry_req) message (constants, nano::message_type::telemetry_req)
{ {
} }
@ -1081,8 +1084,8 @@ void nano::telemetry_req::visit (nano::message_visitor & visitor_a) const
visitor_a.telemetry_req (*this); visitor_a.telemetry_req (*this);
} }
nano::telemetry_ack::telemetry_ack () : nano::telemetry_ack::telemetry_ack (nano::network_constants const & constants) :
message (nano::message_type::telemetry_ack) message (constants, nano::message_type::telemetry_ack)
{ {
} }
@ -1095,8 +1098,8 @@ nano::telemetry_ack::telemetry_ack (bool & error_a, nano::stream & stream_a, nan
} }
} }
nano::telemetry_ack::telemetry_ack (nano::telemetry_data const & telemetry_data_a) : nano::telemetry_ack::telemetry_ack (nano::network_constants const & constants, nano::telemetry_data const & telemetry_data_a) :
message (nano::message_type::telemetry_ack), message (constants, nano::message_type::telemetry_ack),
data (telemetry_data_a) data (telemetry_data_a)
{ {
debug_assert (telemetry_data::size + telemetry_data_a.unknown_data.size () <= message_header::telemetry_size_mask.to_ulong ()); // Maximum size the mask allows debug_assert (telemetry_data::size + telemetry_data_a.unknown_data.size () <= message_header::telemetry_size_mask.to_ulong ()); // Maximum size the mask allows
@ -1342,8 +1345,8 @@ nano::node_id_handshake::node_id_handshake (bool & error_a, nano::stream & strea
error_a = deserialize (stream_a); error_a = deserialize (stream_a);
} }
nano::node_id_handshake::node_id_handshake (boost::optional<nano::uint256_union> query, boost::optional<std::pair<nano::account, nano::signature>> response) : nano::node_id_handshake::node_id_handshake (nano::network_constants const & constants, boost::optional<nano::uint256_union> query, boost::optional<std::pair<nano::account, nano::signature>> response) :
message (nano::message_type::node_id_handshake), message (constants, nano::message_type::node_id_handshake),
query (query), query (query),
response (response) response (response)
{ {

32
nano/node/common.hpp
View file

@ -187,7 +187,7 @@ class message_visitor;
class message_header final class message_header final
{ {
public: public:
explicit message_header (nano::message_type); message_header (nano::network_constants const &, nano::message_type);
message_header (bool &, nano::stream &); message_header (bool &, nano::stream &);
void serialize (nano::stream &) const; void serialize (nano::stream &) const;
bool deserialize (nano::stream &); bool deserialize (nano::stream &);
@ -225,7 +225,7 @@ public:
class message class message
{ {
public: public:
explicit message (nano::message_type); explicit message (nano::network_constants const &, nano::message_type);
explicit message (nano::message_header const &); explicit message (nano::message_header const &);
virtual ~message () = default; virtual ~message () = default;
virtual void serialize (nano::stream &) const = 0; virtual void serialize (nano::stream &) const = 0;
@ -279,7 +279,7 @@ public:
class keepalive final : public message class keepalive final : public message
{ {
public: public:
keepalive (); explicit keepalive (nano::network_constants const & constants);
keepalive (bool &, nano::stream &, nano::message_header const &); keepalive (bool &, nano::stream &, nano::message_header const &);
void visit (nano::message_visitor &) const override; void visit (nano::message_visitor &) const override;
void serialize (nano::stream &) const override; void serialize (nano::stream &) const override;
@ -292,7 +292,7 @@ class publish final : public message
{ {
public: public:
publish (bool &, nano::stream &, nano::message_header const &, nano::uint128_t const & = 0, nano::block_uniquer * = nullptr); publish (bool &, nano::stream &, nano::message_header const &, nano::uint128_t const & = 0, nano::block_uniquer * = nullptr);
explicit publish (std::shared_ptr<nano::block> const &); publish (nano::network_constants const & constants, std::shared_ptr<nano::block> const &);
void visit (nano::message_visitor &) const override; void visit (nano::message_visitor &) const override;
void serialize (nano::stream &) const override; void serialize (nano::stream &) const override;
bool deserialize (nano::stream &, nano::block_uniquer * = nullptr); bool deserialize (nano::stream &, nano::block_uniquer * = nullptr);
@ -304,9 +304,9 @@ class confirm_req final : public message
{ {
public: public:
confirm_req (bool &, nano::stream &, nano::message_header const &, nano::block_uniquer * = nullptr); confirm_req (bool &, nano::stream &, nano::message_header const &, nano::block_uniquer * = nullptr);
explicit confirm_req (std::shared_ptr<nano::block> const &); confirm_req (nano::network_constants const & constants, std::shared_ptr<nano::block> const &);
confirm_req (std::vector<std::pair<nano::block_hash, nano::root>> const &); confirm_req (nano::network_constants const & constants, std::vector<std::pair<nano::block_hash, nano::root>> const &);
confirm_req (nano::block_hash const &, nano::root const &); confirm_req (nano::network_constants const & constants, nano::block_hash const &, nano::root const &);
void serialize (nano::stream &) const override; void serialize (nano::stream &) const override;
bool deserialize (nano::stream &, nano::block_uniquer * = nullptr); bool deserialize (nano::stream &, nano::block_uniquer * = nullptr);
void visit (nano::message_visitor &) const override; void visit (nano::message_visitor &) const override;
@ -320,7 +320,7 @@ class confirm_ack final : public message
{ {
public: public:
confirm_ack (bool &, nano::stream &, nano::message_header const &, nano::vote_uniquer * = nullptr); confirm_ack (bool &, nano::stream &, nano::message_header const &, nano::vote_uniquer * = nullptr);
explicit confirm_ack (std::shared_ptr<nano::vote> const &); confirm_ack (nano::network_constants const & constants, std::shared_ptr<nano::vote> const &);
void serialize (nano::stream &) const override; void serialize (nano::stream &) const override;
void visit (nano::message_visitor &) const override; void visit (nano::message_visitor &) const override;
bool operator== (nano::confirm_ack const &) const; bool operator== (nano::confirm_ack const &) const;
@ -330,7 +330,7 @@ public:
class frontier_req final : public message class frontier_req final : public message
{ {
public: public:
frontier_req (); explicit frontier_req (nano::network_constants const & constants);
frontier_req (bool &, nano::stream &, nano::message_header const &); frontier_req (bool &, nano::stream &, nano::message_header const &);
void serialize (nano::stream &) const override; void serialize (nano::stream &) const override;
bool deserialize (nano::stream &); bool deserialize (nano::stream &);
@ -389,7 +389,7 @@ private:
class telemetry_req final : public message class telemetry_req final : public message
{ {
public: public:
telemetry_req (); explicit telemetry_req (nano::network_constants const & constants);
explicit telemetry_req (nano::message_header const &); explicit telemetry_req (nano::message_header const &);
void serialize (nano::stream &) const override; void serialize (nano::stream &) const override;
bool deserialize (nano::stream &); bool deserialize (nano::stream &);
@ -398,9 +398,9 @@ public:
class telemetry_ack final : public message class telemetry_ack final : public message
{ {
public: public:
telemetry_ack (); explicit telemetry_ack (nano::network_constants const & constants);
telemetry_ack (bool &, nano::stream &, nano::message_header const &); telemetry_ack (bool &, nano::stream &, nano::message_header const &);
explicit telemetry_ack (telemetry_data const &); telemetry_ack (nano::network_constants const & constants, telemetry_data const &);
void serialize (nano::stream &) const override; void serialize (nano::stream &) const override;
void visit (nano::message_visitor &) const override; void visit (nano::message_visitor &) const override;
bool deserialize (nano::stream &); bool deserialize (nano::stream &);
@ -414,7 +414,7 @@ class bulk_pull final : public message
{ {
public: public:
using count_t = uint32_t; using count_t = uint32_t;
bulk_pull (); explicit bulk_pull (nano::network_constants const & constants);
bulk_pull (bool &, nano::stream &, nano::message_header const &); bulk_pull (bool &, nano::stream &, nano::message_header const &);
void serialize (nano::stream &) const override; void serialize (nano::stream &) const override;
bool deserialize (nano::stream &); bool deserialize (nano::stream &);
@ -431,7 +431,7 @@ public:
class bulk_pull_account final : public message class bulk_pull_account final : public message
{ {
public: public:
bulk_pull_account (); explicit bulk_pull_account (nano::network_constants const & constants);
bulk_pull_account (bool &, nano::stream &, nano::message_header const &); bulk_pull_account (bool &, nano::stream &, nano::message_header const &);
void serialize (nano::stream &) const override; void serialize (nano::stream &) const override;
bool deserialize (nano::stream &); bool deserialize (nano::stream &);
@ -444,7 +444,7 @@ public:
class bulk_push final : public message class bulk_push final : public message
{ {
public: public:
bulk_push (); explicit bulk_push (nano::network_constants const & constants);
explicit bulk_push (nano::message_header const &); explicit bulk_push (nano::message_header const &);
void serialize (nano::stream &) const override; void serialize (nano::stream &) const override;
bool deserialize (nano::stream &); bool deserialize (nano::stream &);
@ -454,7 +454,7 @@ class node_id_handshake final : public message
{ {
public: public:
node_id_handshake (bool &, nano::stream &, nano::message_header const &); node_id_handshake (bool &, nano::stream &, nano::message_header const &);
node_id_handshake (boost::optional<nano::uint256_union>, boost::optional<std::pair<nano::account, nano::signature>>); node_id_handshake (nano::network_constants const & constants, boost::optional<nano::uint256_union>, boost::optional<std::pair<nano::account, nano::signature>>);
void serialize (nano::stream &) const override; void serialize (nano::stream &) const override;
bool deserialize (nano::stream &); bool deserialize (nano::stream &);
void visit (nano::message_visitor &) const override; void visit (nano::message_visitor &) const override;

6
nano/node/confirmation_solicitor.cpp
View file

@ -31,7 +31,7 @@ bool nano::confirmation_solicitor::broadcast (nano::election const & election_a)
if (rebroadcasted++ < max_block_broadcasts) if (rebroadcasted++ < max_block_broadcasts)
{ {
auto const & hash (election_a.status.winner->hash ()); auto const & hash (election_a.status.winner->hash ());
nano::publish winner (election_a.status.winner); nano::publish winner{ config.network_params.network, election_a.status.winner };
unsigned count = 0; unsigned count = 0;
// Directed broadcasting to principal representatives // Directed broadcasting to principal representatives
for (auto i (representatives_broadcasts.begin ()), n (representatives_broadcasts.end ()); i != n && count < max_election_broadcasts; ++i) for (auto i (representatives_broadcasts.begin ()), n (representatives_broadcasts.end ()); i != n && count < max_election_broadcasts; ++i)
@ -98,14 +98,14 @@ void nano::confirmation_solicitor::flush ()
roots_hashes_l.push_back (root_hash); roots_hashes_l.push_back (root_hash);
if (roots_hashes_l.size () == nano::network::confirm_req_hashes_max) if (roots_hashes_l.size () == nano::network::confirm_req_hashes_max)
{ {
nano::confirm_req req (roots_hashes_l); nano::confirm_req req{ config.network_params.network, roots_hashes_l };
channel->send (req); channel->send (req);
roots_hashes_l.clear (); roots_hashes_l.clear ();
} }
} }
if (!roots_hashes_l.empty ()) if (!roots_hashes_l.empty ())
{ {
nano::confirm_req req (roots_hashes_l); nano::confirm_req req{ config.network_params.network, roots_hashes_l };
channel->send (req); channel->send (req);
} }
} }

36
nano/node/network.cpp
View file

@ -152,14 +152,14 @@ void nano::network::stop ()
void nano::network::send_keepalive (std::shared_ptr<nano::transport::channel> const & channel_a) void nano::network::send_keepalive (std::shared_ptr<nano::transport::channel> const & channel_a)
{ {
nano::keepalive message; nano::keepalive message{ node.network_params.network };
random_fill (message.peers); random_fill (message.peers);
channel_a->send (message); channel_a->send (message);
} }
void nano::network::send_keepalive_self (std::shared_ptr<nano::transport::channel> const & channel_a) void nano::network::send_keepalive_self (std::shared_ptr<nano::transport::channel> const & channel_a)
{ {
nano::keepalive message; nano::keepalive message{ node.network_params.network };
fill_keepalive_self (message.peers); fill_keepalive_self (message.peers);
channel_a->send (message); channel_a->send (message);
} }
@ -172,7 +172,7 @@ void nano::network::send_node_id_handshake (std::shared_ptr<nano::transport::cha
response = std::make_pair (node.node_id.pub, nano::sign_message (node.node_id.prv, node.node_id.pub, *respond_to)); response = std::make_pair (node.node_id.pub, nano::sign_message (node.node_id.prv, node.node_id.pub, *respond_to));
debug_assert (!nano::validate_message (response->first, *respond_to, response->second)); debug_assert (!nano::validate_message (response->first, *respond_to, response->second));
} }
nano::node_id_handshake message (query, response); nano::node_id_handshake message{ node.network_params.network, query, response };
if (node.config.logging.network_node_id_handshake_logging ()) if (node.config.logging.network_node_id_handshake_logging ())
{ {
node.logger.try_log (boost::str (boost::format ("Node ID handshake sent with node ID %1% to %2%: query %3%, respond_to %4% (signature %5%)") % node.node_id.pub.to_node_id () % channel_a->get_endpoint () % (query ? query->to_string () : std::string ("[none]")) % (respond_to ? respond_to->to_string () : std::string ("[none]")) % (response ? response->second.to_string () : std::string ("[none]")))); node.logger.try_log (boost::str (boost::format ("Node ID handshake sent with node ID %1% to %2%: query %3%, respond_to %4% (signature %5%)") % node.node_id.pub.to_node_id () % channel_a->get_endpoint () % (query ? query->to_string () : std::string ("[none]")) % (respond_to ? respond_to->to_string () : std::string ("[none]")) % (response ? response->second.to_string () : std::string ("[none]"))));
@ -188,15 +188,29 @@ void nano::network::flood_message (nano::message & message_a, nano::buffer_drop_
} }
} }
void nano::network::flood_keepalive (float const scale_a)
{
nano::keepalive message{ node.network_params.network };
random_fill (message.peers);
flood_message (message, nano::buffer_drop_policy::limiter, scale_a);
}
void nano::network::flood_keepalive_self (float const scale_a)
{
nano::keepalive message{ node.network_params.network };
fill_keepalive_self (message.peers);
flood_message (message, nano::buffer_drop_policy::limiter, scale_a);
}
void nano::network::flood_block (std::shared_ptr<nano::block> const & block_a, nano::buffer_drop_policy const drop_policy_a) void nano::network::flood_block (std::shared_ptr<nano::block> const & block_a, nano::buffer_drop_policy const drop_policy_a)
{ {
nano::publish message (block_a); nano::publish message (node.network_params.network, block_a);
flood_message (message, drop_policy_a); flood_message (message, drop_policy_a);
} }
void nano::network::flood_block_initial (std::shared_ptr<nano::block> const & block_a) void nano::network::flood_block_initial (std::shared_ptr<nano::block> const & block_a)
{ {
nano::publish message (block_a); nano::publish message (node.network_params.network, block_a);
for (auto const & i : node.rep_crawler.principal_representatives ()) for (auto const & i : node.rep_crawler.principal_representatives ())
{ {
i.channel->send (message, nullptr, nano::buffer_drop_policy::no_limiter_drop); i.channel->send (message, nullptr, nano::buffer_drop_policy::no_limiter_drop);
@ -209,7 +223,7 @@ void nano::network::flood_block_initial (std::shared_ptr<nano::block> const & bl
void nano::network::flood_vote (std::shared_ptr<nano::vote> const & vote_a, float scale) void nano::network::flood_vote (std::shared_ptr<nano::vote> const & vote_a, float scale)
{ {
nano::confirm_ack message (vote_a); nano::confirm_ack message{ node.network_params.network, vote_a };
for (auto & i : list (fanout (scale))) for (auto & i : list (fanout (scale)))
{ {
i->send (message, nullptr); i->send (message, nullptr);
@ -218,7 +232,7 @@ void nano::network::flood_vote (std::shared_ptr<nano::vote> const & vote_a, floa
void nano::network::flood_vote_pr (std::shared_ptr<nano::vote> const & vote_a) void nano::network::flood_vote_pr (std::shared_ptr<nano::vote> const & vote_a)
{ {
nano::confirm_ack message (vote_a); nano::confirm_ack message{ node.network_params.network, vote_a };
for (auto const & i : node.rep_crawler.principal_representatives ()) for (auto const & i : node.rep_crawler.principal_representatives ())
{ {
i.channel->send (message, nullptr, nano::buffer_drop_policy::no_limiter_drop); i.channel->send (message, nullptr, nano::buffer_drop_policy::no_limiter_drop);
@ -252,7 +266,7 @@ void nano::network::flood_block_many (std::deque<std::shared_ptr<nano::block>> b
void nano::network::send_confirm_req (std::shared_ptr<nano::transport::channel> const & channel_a, std::pair<nano::block_hash, nano::block_hash> const & hash_root_a) void nano::network::send_confirm_req (std::shared_ptr<nano::transport::channel> const & channel_a, std::pair<nano::block_hash, nano::block_hash> const & hash_root_a)
{ {
// Confirmation request with hash + root // Confirmation request with hash + root
nano::confirm_req req (hash_root_a.first, hash_root_a.second); nano::confirm_req req (node.network_params.network, hash_root_a.first, hash_root_a.second);
channel_a->send (req); channel_a->send (req);
} }
@ -330,7 +344,7 @@ void nano::network::broadcast_confirm_req_batched_many (std::unordered_map<std::
roots_hashes_l.push_back (i->second.front ()); roots_hashes_l.push_back (i->second.front ());
i->second.pop_front (); i->second.pop_front ();
} }
nano::confirm_req req (roots_hashes_l); nano::confirm_req req{ node.network_params.network, roots_hashes_l };
i->first->send (req); i->first->send (req);
if (i->second.empty ()) if (i->second.empty ())
{ {
@ -516,11 +530,11 @@ public:
// Send an empty telemetry_ack if we do not want, just to acknowledge that we have received the message to // Send an empty telemetry_ack if we do not want, just to acknowledge that we have received the message to
// remove any timeouts on the server side waiting for a message. // remove any timeouts on the server side waiting for a message.
nano::telemetry_ack telemetry_ack; nano::telemetry_ack telemetry_ack{ node.network_params.network };
if (!node.flags.disable_providing_telemetry_metrics) if (!node.flags.disable_providing_telemetry_metrics)
{ {
auto telemetry_data = nano::local_telemetry_data (node.ledger, node.network, node.config.bandwidth_limit, node.network_params, node.startup_time, node.default_difficulty (nano::work_version::work_1), node.node_id); auto telemetry_data = nano::local_telemetry_data (node.ledger, node.network, node.config.bandwidth_limit, node.network_params, node.startup_time, node.default_difficulty (nano::work_version::work_1), node.node_id);
telemetry_ack = nano::telemetry_ack (telemetry_data); telemetry_ack = nano::telemetry_ack{ node.network_params.network, telemetry_data };
} }
channel->send (telemetry_ack, nullptr, nano::buffer_drop_policy::no_socket_drop); channel->send (telemetry_ack, nullptr, nano::buffer_drop_policy::no_socket_drop);
} }

14
nano/node/network.hpp
View file

@ -124,18 +124,8 @@ public:
void start (); void start ();
void stop (); void stop ();
void flood_message (nano::message &, nano::buffer_drop_policy const = nano::buffer_drop_policy::limiter, float const = 1.0f); void flood_message (nano::message &, nano::buffer_drop_policy const = nano::buffer_drop_policy::limiter, float const = 1.0f);
void flood_keepalive (float const scale_a = 1.0f) void flood_keepalive (float const scale_a = 1.0f);
{ void flood_keepalive_self (float const scale_a = 0.5f);
nano::keepalive message;
random_fill (message.peers);
flood_message (message, nano::buffer_drop_policy::limiter, scale_a);
}
void flood_keepalive_self (float const scale_a = 0.5f)
{
nano::keepalive message;
fill_keepalive_self (message.peers);
flood_message (message, nano::buffer_drop_policy::limiter, scale_a);
}
void flood_vote (std::shared_ptr<nano::vote> const &, float scale); void flood_vote (std::shared_ptr<nano::vote> const &, float scale);
void flood_vote_pr (std::shared_ptr<nano::vote> const &); void flood_vote_pr (std::shared_ptr<nano::vote> const &);
// Flood block to all PRs and a random selection of non-PRs // Flood block to all PRs and a random selection of non-PRs

2
nano/node/node.cpp
View file

@ -119,7 +119,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path co
confirmation_height_processor (ledger, write_database_queue, config.conf_height_processor_batch_min_time, config.logging, logger, node_initialized_latch, flags.confirmation_height_processor_mode), confirmation_height_processor (ledger, write_database_queue, config.conf_height_processor_batch_min_time, config.logging, logger, node_initialized_latch, flags.confirmation_height_processor_mode),
active (*this, confirmation_height_processor), active (*this, confirmation_height_processor),
scheduler{ *this }, scheduler{ *this },
aggregator (network_params.network, config, stats, active.generator, active.final_generator, history, ledger, wallets, active), aggregator (config, stats, active.generator, active.final_generator, history, ledger, wallets, active),
wallets (wallets_store.init_error (), *this), wallets (wallets_store.init_error (), *this),
startup_time (std::chrono::steady_clock::now ()), startup_time (std::chrono::steady_clock::now ()),
node_seq (seq) node_seq (seq)

11
nano/node/request_aggregator.cpp
View file

@ -11,9 +11,10 @@
#include <nano/secure/ledger.hpp> #include <nano/secure/ledger.hpp>
#include <nano/secure/store.hpp> #include <nano/secure/store.hpp>
nano::request_aggregator::request_aggregator (nano::network_constants const & network_constants_a, nano::node_config const & config_a, nano::stat & stats_a, nano::vote_generator & generator_a, nano::vote_generator & final_generator_a, nano::local_vote_history & history_a, nano::ledger & ledger_a, nano::wallets & wallets_a, nano::active_transactions & active_a) : nano::request_aggregator::request_aggregator (nano::node_config const & config_a, nano::stat & stats_a, nano::vote_generator & generator_a, nano::vote_generator & final_generator_a, nano::local_vote_history & history_a, nano::ledger & ledger_a, nano::wallets & wallets_a, nano::active_transactions & active_a) :
max_delay (network_constants_a.is_dev_network () ? 50 : 300), config{ config_a },
small_delay (network_constants_a.is_dev_network () ? 10 : 50), max_delay (config_a.network_params.network.is_dev_network () ? 50 : 300),
small_delay (config_a.network_params.network.is_dev_network () ? 10 : 50),
max_channel_requests (config_a.max_queued_requests), max_channel_requests (config_a.max_queued_requests),
stats (stats_a), stats (stats_a),
local_votes (history_a), local_votes (history_a),
@ -150,7 +151,7 @@ bool nano::request_aggregator::empty ()
void nano::request_aggregator::reply_action (std::shared_ptr<nano::vote> const & vote_a, std::shared_ptr<nano::transport::channel> const & channel_a) const void nano::request_aggregator::reply_action (std::shared_ptr<nano::vote> const & vote_a, std::shared_ptr<nano::transport::channel> const & channel_a) const
{ {
nano::confirm_ack confirm (vote_a); nano::confirm_ack confirm{ config.network_params.network, vote_a };
channel_a->send (confirm); channel_a->send (confirm);
} }
@ -277,7 +278,7 @@ std::pair<std::vector<std::shared_ptr<nano::block>>, std::vector<std::shared_ptr
// Let the node know about the alternative block // Let the node know about the alternative block
if (block->hash () != hash) if (block->hash () != hash)
{ {
nano::publish publish (block); nano::publish publish (config.network_params.network, block);
channel_a->send (publish); channel_a->send (publish);
} }
} }

3
nano/node/request_aggregator.hpp
View file

@ -59,7 +59,7 @@ class request_aggregator final
// clang-format on // clang-format on
public: public:
request_aggregator (nano::network_constants const &, nano::node_config const & config, nano::stat & stats_a, nano::vote_generator &, nano::vote_generator &, nano::local_vote_history &, nano::ledger &, nano::wallets &, nano::active_transactions &); request_aggregator (nano::node_config const & config, nano::stat & stats_a, nano::vote_generator &, nano::vote_generator &, nano::local_vote_history &, nano::ledger &, nano::wallets &, nano::active_transactions &);
/** Add a new request by \p channel_a for hashes \p hashes_roots_a */ /** Add a new request by \p channel_a for hashes \p hashes_roots_a */
void add (std::shared_ptr<nano::transport::channel> const & channel_a, std::vector<std::pair<nano::block_hash, nano::root>> const & hashes_roots_a); void add (std::shared_ptr<nano::transport::channel> const & channel_a, std::vector<std::pair<nano::block_hash, nano::root>> const & hashes_roots_a);
@ -68,6 +68,7 @@ public:
size_t size (); size_t size ();
bool empty (); bool empty ();
nano::node_config const & config;
const std::chrono::milliseconds max_delay; const std::chrono::milliseconds max_delay;
const std::chrono::milliseconds small_delay; const std::chrono::milliseconds small_delay;
const size_t max_channel_requests; const size_t max_channel_requests;

2
nano/node/telemetry.cpp
View file

@ -352,7 +352,7 @@ void nano::telemetry::fire_request_message (std::shared_ptr<nano::transport::cha
} }
std::weak_ptr<nano::telemetry> this_w (shared_from_this ()); std::weak_ptr<nano::telemetry> this_w (shared_from_this ());
nano::telemetry_req message; nano::telemetry_req message{ network_params.network };
// clang-format off // clang-format off
channel_a->send (message, [this_w, endpoint = channel_a->get_endpoint (), round_l](boost::system::error_code const & ec, size_t size_a) { channel_a->send (message, [this_w, endpoint = channel_a->get_endpoint (), round_l](boost::system::error_code const & ec, size_t size_a) {
if (auto this_l = this_w.lock ()) if (auto this_l = this_w.lock ())

6
nano/node/transport/tcp.cpp
View file

@ -445,7 +445,7 @@ void nano::transport::tcp_channels::purge (std::chrono::steady_clock::time_point
void nano::transport::tcp_channels::ongoing_keepalive () void nano::transport::tcp_channels::ongoing_keepalive ()
{ {
nano::keepalive message; nano::keepalive message{ node.network_params.network };
node.network.random_fill (message.peers); node.network.random_fill (message.peers);
nano::unique_lock<nano::mutex> lock (mutex); nano::unique_lock<nano::mutex> lock (mutex);
// Wake up channels // Wake up channels
@ -571,7 +571,7 @@ void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a
{ {
// TCP node ID handshake // TCP node ID handshake
auto cookie (node_l->network.syn_cookies.assign (endpoint_a)); auto cookie (node_l->network.syn_cookies.assign (endpoint_a));
nano::node_id_handshake message (cookie, boost::none); nano::node_id_handshake message (node_l->network_params.network, cookie, boost::none);
if (node_l->config.logging.network_node_id_handshake_logging ()) if (node_l->config.logging.network_node_id_handshake_logging ())
{ {
node_l->logger.try_log (boost::str (boost::format ("Node ID handshake request sent with node ID %1% to %2%: query %3%") % node_l->node_id.pub.to_node_id () % endpoint_a % (*cookie).to_string ())); node_l->logger.try_log (boost::str (boost::format ("Node ID handshake request sent with node ID %1% to %2%: query %3%") % node_l->node_id.pub.to_node_id () % endpoint_a % (*cookie).to_string ()));
@ -669,7 +669,7 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptr<n
channel_a->set_node_id (node_id); channel_a->set_node_id (node_id);
channel_a->set_last_packet_received (std::chrono::steady_clock::now ()); channel_a->set_last_packet_received (std::chrono::steady_clock::now ());
boost::optional<std::pair<nano::account, nano::signature>> response (std::make_pair (node_l->node_id.pub, nano::sign_message (node_l->node_id.prv, node_l->node_id.pub, *message.query))); boost::optional<std::pair<nano::account, nano::signature>> response (std::make_pair (node_l->node_id.pub, nano::sign_message (node_l->node_id.prv, node_l->node_id.pub, *message.query)));
nano::node_id_handshake response_message (boost::none, response); nano::node_id_handshake response_message (node_l->network_params.network, boost::none, response);
if (node_l->config.logging.network_node_id_handshake_logging ()) if (node_l->config.logging.network_node_id_handshake_logging ())
{ {
node_l->logger.try_log (boost::str (boost::format ("Node ID handshake response sent with node ID %1% to %2%: query %3%") % node_l->node_id.pub.to_node_id () % endpoint_a % (*message.query).to_string ())); node_l->logger.try_log (boost::str (boost::format ("Node ID handshake response sent with node ID %1% to %2%: query %3%") % node_l->node_id.pub.to_node_id () % endpoint_a % (*message.query).to_string ()));

3
nano/node/transport/transport.cpp
View file

@ -102,9 +102,6 @@ nano::transport::channel::channel (nano::node & node_a) :
void nano::transport::channel::send (nano::message & message_a, std::function<void (boost::system::error_code const &, size_t)> const & callback_a, nano::buffer_drop_policy drop_policy_a) void nano::transport::channel::send (nano::message & message_a, std::function<void (boost::system::error_code const &, size_t)> const & callback_a, nano::buffer_drop_policy drop_policy_a)
{ {
message_a.header.version_max = node.network_params.network.protocol_version;
message_a.header.version_using = node.network_params.network.protocol_version;
message_a.header.version_min = node.network_params.network.protocol_version_min;
callback_visitor visitor; callback_visitor visitor;
message_a.visit (visitor); message_a.visit (visitor);
auto buffer (message_a.to_shared_const_buffer ()); auto buffer (message_a.to_shared_const_buffer ());

2
nano/node/transport/udp.cpp
View file

@ -686,7 +686,7 @@ void nano::transport::udp_channels::purge (std::chrono::steady_clock::time_point
void nano::transport::udp_channels::ongoing_keepalive () void nano::transport::udp_channels::ongoing_keepalive ()
{ {
nano::keepalive message; nano::keepalive message{ node.network_params.network };
node.network.random_fill (message.peers); node.network.random_fill (message.peers);
std::vector<std::shared_ptr<nano::transport::channel_udp>> send_list; std::vector<std::shared_ptr<nano::transport::channel_udp>> send_list;
nano::unique_lock<nano::mutex> lock (mutex); nano::unique_lock<nano::mutex> lock (mutex);