diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index cfe8355eaa..142da6b554 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -253,11 +253,11 @@ TEST (active_transactions, inactive_votes_cache_fork) node.vote_processor.vote (vote, std::make_shared (node)); auto channel1 (node.network.udp_channels.create (node.network.endpoint ())); 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 (); ASSERT_NE (nullptr, node.block (send2->hash ())); 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 (); bool confirmed (false); system.deadline_set (5s); diff --git a/nano/core_test/block.cpp b/nano/core_test/block.cpp index cd9e1f38d1..832757989d 100644 --- a/nano/core_test/block.cpp +++ b/nano/core_test/block.cpp @@ -270,7 +270,7 @@ TEST (change_block, deserialize) TEST (frontier_req, serialization) { - nano::frontier_req request1; + nano::frontier_req request1{ nano::dev::network_params.network }; request1.start = 1; request1.age = 2; request1.count = 3; @@ -293,7 +293,7 @@ TEST (block, publish_req_serialization) nano::keypair key1; nano::keypair key2; auto block (std::make_shared (0, key2.pub, 200, nano::keypair ().prv, 2, 3)); - nano::publish req (block); + nano::publish req{ nano::dev::network_params.network, block }; std::vector bytes; { nano::vectorstream stream (bytes); diff --git a/nano/core_test/bootstrap.cpp b/nano/core_test/bootstrap.cpp index 96f19a7abd..b04b41b8f7 100644 --- a/nano/core_test/bootstrap.cpp +++ b/nano/core_test/bootstrap.cpp @@ -12,7 +12,7 @@ TEST (bulk_pull, no_address) { nano::system system (1); auto connection (std::make_shared (std::make_shared (*system.nodes[0]), system.nodes[0])); - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->start = 1; req->end = 2; connection->requests.push (std::unique_ptr{}); @@ -25,10 +25,10 @@ TEST (bulk_pull, genesis_to_end) { nano::system system (1); auto connection (std::make_shared (std::make_shared (*system.nodes[0]), system.nodes[0])); - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis_key.pub; req->end.clear (); - connection->requests.push (std::unique_ptr{}); + connection->requests.push (nullptr); auto request (std::make_shared (connection, std::move (req))); ASSERT_EQ (system.nodes[0]->latest (nano::dev::genesis_key.pub), request->current); ASSERT_EQ (request->request->end, request->request->end); @@ -39,7 +39,7 @@ TEST (bulk_pull, no_end) { nano::system system (1); auto connection (std::make_shared (std::make_shared (*system.nodes[0]), system.nodes[0])); - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis_key.pub; req->end = 1; connection->requests.push (std::unique_ptr{}); @@ -64,7 +64,7 @@ TEST (bulk_pull, end_not_owned) system.nodes[0]->work_generate_blocking (open); ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (open).code); auto connection (std::make_shared (std::make_shared (*system.nodes[0]), system.nodes[0])); - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->start = key2.pub; req->end = nano::dev::genesis->hash (); connection->requests.push (std::unique_ptr{}); @@ -76,7 +76,7 @@ TEST (bulk_pull, none) { nano::system system (1); auto connection (std::make_shared (std::make_shared (*system.nodes[0]), system.nodes[0])); - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis_key.pub; req->end = nano::dev::genesis->hash (); connection->requests.push (std::unique_ptr{}); @@ -89,7 +89,7 @@ TEST (bulk_pull, get_next_on_open) { nano::system system (1); auto connection (std::make_shared (std::make_shared (*system.nodes[0]), system.nodes[0])); - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis_key.pub; req->end.clear (); connection->requests.push (std::unique_ptr{}); @@ -105,7 +105,7 @@ TEST (bulk_pull, by_block) { nano::system system (1); auto connection (std::make_shared (std::make_shared (*system.nodes[0]), system.nodes[0])); - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis->hash (); req->end.clear (); connection->requests.push (std::unique_ptr{}); @@ -122,7 +122,7 @@ TEST (bulk_pull, by_block_single) { nano::system system (1); auto connection (std::make_shared (std::make_shared (*system.nodes[0]), system.nodes[0])); - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis->hash (); req->end = nano::dev::genesis->hash (); connection->requests.push (std::unique_ptr{}); @@ -146,7 +146,7 @@ TEST (bulk_pull, count_limit) ASSERT_EQ (nano::process_result::progress, node0->process (*receive1).code); auto connection (std::make_shared (std::make_shared (*node0), node0)); - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->start = receive1->hash (); req->set_count_present (true); req->count = 2; @@ -1393,7 +1393,7 @@ TEST (frontier_req_response, DISABLED_destruction) { nano::system system (1); auto connection (std::make_shared (nullptr, system.nodes[0])); - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = std::numeric_limitsage)>::max (); req->count = std::numeric_limitscount)>::max (); @@ -1408,7 +1408,7 @@ TEST (frontier_req, begin) { nano::system system (1); auto connection (std::make_shared (std::make_shared (*system.nodes[0]), system.nodes[0])); - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = std::numeric_limitsage)>::max (); req->count = std::numeric_limitscount)>::max (); @@ -1422,7 +1422,7 @@ TEST (frontier_req, end) { nano::system system (1); auto connection (std::make_shared (std::make_shared (*system.nodes[0]), system.nodes[0])); - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->start = nano::dev::genesis_key.pub.number () + 1; req->age = std::numeric_limitsage)>::max (); req->count = std::numeric_limitscount)>::max (); @@ -1464,7 +1464,7 @@ TEST (frontier_req, count) ASSERT_EQ (nano::process_result::progress, node1->process (*receive1).code); auto connection (std::make_shared (std::make_shared (*node1), node1)); - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = std::numeric_limitsage)>::max (); req->count = 1; @@ -1478,7 +1478,7 @@ TEST (frontier_req, time_bound) { nano::system system (1); auto connection (std::make_shared (std::make_shared (*system.nodes[0]), system.nodes[0])); - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = 1; req->count = std::numeric_limitscount)>::max (); @@ -1487,7 +1487,7 @@ TEST (frontier_req, time_bound) ASSERT_EQ (nano::dev::genesis_key.pub, request->current); // Wait 2 seconds until age of account will be > 1 seconds std::this_thread::sleep_for (std::chrono::milliseconds (2100)); - auto req2 (std::make_unique ()); + auto req2 (std::make_unique (nano::dev::network_params.network)); req2->start.clear (); req2->age = 1; req2->count = std::numeric_limitscount)>::max (); @@ -1501,7 +1501,7 @@ TEST (frontier_req, time_cutoff) { nano::system system (1); auto connection (std::make_shared (std::make_shared (*system.nodes[0]), system.nodes[0])); - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = 3; req->count = std::numeric_limitscount)>::max (); @@ -1511,7 +1511,7 @@ TEST (frontier_req, time_cutoff) ASSERT_EQ (nano::dev::genesis->hash (), request->frontier); // Wait 4 seconds until age of account will be > 3 seconds std::this_thread::sleep_for (std::chrono::milliseconds (4100)); - auto req2 (std::make_unique ()); + auto req2 (std::make_unique (nano::dev::network_params.network)); req2->start.clear (); req2->age = 3; req2->count = std::numeric_limitscount)>::max (); @@ -1590,7 +1590,7 @@ TEST (frontier_req, confirmed_frontier) // Request for all accounts (confirmed only) auto connection (std::make_shared (std::make_shared (*node1), node1)); - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = std::numeric_limitsage)>::max (); req->count = std::numeric_limitscount)>::max (); @@ -1604,7 +1604,7 @@ TEST (frontier_req, confirmed_frontier) // Request starting with account before genesis (confirmed only) auto connection2 (std::make_shared (std::make_shared (*node1), node1)); - auto req2 = std::make_unique (); + auto req2 = std::make_unique (nano::dev::network_params.network); req2->start = key_before_genesis.pub; req2->age = std::numeric_limitsage)>::max (); req2->count = std::numeric_limitscount)>::max (); @@ -1618,7 +1618,7 @@ TEST (frontier_req, confirmed_frontier) // Request starting with account after genesis (confirmed only) auto connection3 (std::make_shared (std::make_shared (*node1), node1)); - auto req3 = std::make_unique (); + auto req3 = std::make_unique (nano::dev::network_params.network); req3->start = key_after_genesis.pub; req3->age = std::numeric_limitsage)>::max (); req3->count = std::numeric_limitscount)>::max (); @@ -1632,7 +1632,7 @@ TEST (frontier_req, confirmed_frontier) // Request for all accounts (unconfirmed blocks) auto connection4 (std::make_shared (std::make_shared (*node1), node1)); - auto req4 = std::make_unique (); + auto req4 = std::make_unique (nano::dev::network_params.network); req4->start.clear (); req4->age = std::numeric_limitsage)>::max (); req4->count = std::numeric_limitscount)>::max (); @@ -1644,7 +1644,7 @@ TEST (frontier_req, confirmed_frontier) // Request starting with account after genesis (unconfirmed blocks) auto connection5 (std::make_shared (std::make_shared (*node1), node1)); - auto req5 = std::make_unique (); + auto req5 = std::make_unique (nano::dev::network_params.network); req5->start = key_after_genesis.pub; req5->age = std::numeric_limitsage)>::max (); req5->count = std::numeric_limitscount)>::max (); @@ -1658,7 +1658,7 @@ TEST (frontier_req, confirmed_frontier) nano::blocks_confirm (*node1, { send1, receive1 }, true); ASSERT_TIMELY (5s, node1->block_confirmed (send1->hash ()) && node1->block_confirmed (receive1->hash ())); auto connection6 (std::make_shared (std::make_shared (*node1), node1)); - auto req6 = std::make_unique (); + auto req6 = std::make_unique (nano::dev::network_params.network); req6->start = key_before_genesis.pub; req6->age = std::numeric_limitsage)>::max (); req6->count = std::numeric_limitscount)>::max (); @@ -1674,7 +1674,7 @@ TEST (frontier_req, confirmed_frontier) nano::blocks_confirm (*node1, { send2, receive2 }, true); ASSERT_TIMELY (5s, node1->block_confirmed (send2->hash ()) && node1->block_confirmed (receive2->hash ())); auto connection7 (std::make_shared (std::make_shared (*node1), node1)); - auto req7 = std::make_unique (); + auto req7 = std::make_unique (nano::dev::network_params.network); req7->start = key_after_genesis.pub; req7->age = std::numeric_limitsage)>::max (); req7->count = std::numeric_limitscount)>::max (); @@ -1851,7 +1851,7 @@ TEST (bulk_pull_account, basics) auto connection (std::make_shared (std::make_shared (*system.nodes[0]), system.nodes[0])); { - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->account = key1.pub; req->minimum_amount = 5; req->flags = nano::bulk_pull_account_flags (); @@ -1870,7 +1870,7 @@ TEST (bulk_pull_account, basics) } { - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->account = key1.pub; req->minimum_amount = 0; req->flags = nano::bulk_pull_account_flags::pending_address_only; diff --git a/nano/core_test/confirmation_height.cpp b/nano/core_test/confirmation_height.cpp index 644e1cf601..5b6c41227d 100644 --- a/nano/core_test/confirmation_height.cpp +++ b/nano/core_test/confirmation_height.cpp @@ -654,10 +654,10 @@ TEST (confirmation_height, conflict_rollback_cemented) ASSERT_EQ (1, node1->network.size ()); nano::keypair key1; auto send1 (std::make_shared (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; auto send2 (std::make_shared (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 ())); node1->network.inbound (publish1, channel1); node1->block_processor.flush (); diff --git a/nano/core_test/message.cpp b/nano/core_test/message.cpp index 266f0f141e..67a90f28a0 100644 --- a/nano/core_test/message.cpp +++ b/nano/core_test/message.cpp @@ -8,7 +8,7 @@ TEST (message, keepalive_serialization) { - nano::keepalive request1; + nano::keepalive request1{ nano::dev::network_params.network }; std::vector bytes; { nano::vectorstream stream (bytes); @@ -25,7 +25,7 @@ TEST (message, keepalive_serialization) 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); std::vector bytes; { @@ -44,11 +44,7 @@ TEST (message, keepalive_deserialize) TEST (message, publish_serialization) { - nano::publish publish (std::make_shared (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; + nano::publish publish{ nano::dev::network_params.network, std::make_shared (0, 1, 2, nano::keypair ().prv, 4, 5) }; ASSERT_EQ (nano::block_type::send, publish.header.block_type ()); std::vector bytes; { @@ -58,9 +54,9 @@ TEST (message, publish_serialization) ASSERT_EQ (8, bytes.size ()); ASSERT_EQ (0x52, bytes[0]); ASSERT_EQ (0x41, bytes[1]); - ASSERT_EQ (6, bytes[2]); - ASSERT_EQ (5, bytes[3]); - ASSERT_EQ (4, bytes[4]); + ASSERT_EQ (nano::dev::network_params.network.protocol_version, bytes[2]); + ASSERT_EQ (nano::dev::network_params.network.protocol_version, bytes[3]); + ASSERT_EQ (nano::dev::network_params.network.protocol_version_min, bytes[4]); ASSERT_EQ (static_cast (nano::message_type::publish), bytes[5]); ASSERT_EQ (0x00, bytes[6]); // extensions ASSERT_EQ (static_cast (nano::block_type::send), bytes[7]); @@ -68,9 +64,9 @@ TEST (message, publish_serialization) auto error (false); nano::message_header header (error, stream); ASSERT_FALSE (error); - ASSERT_EQ (4, header.version_min); - ASSERT_EQ (5, header.version_using); - ASSERT_EQ (6, header.version_max); + ASSERT_EQ (nano::dev::network_params.network.protocol_version_min, header.version_min); + ASSERT_EQ (nano::dev::network_params.network.protocol_version, header.version_using); + ASSERT_EQ (nano::dev::network_params.network.protocol_version, header.version_max); ASSERT_EQ (nano::message_type::publish, header.type); } @@ -78,7 +74,7 @@ TEST (message, confirm_ack_serialization) { nano::keypair key1; auto vote (std::make_shared (key1.pub, key1.prv, 0, std::make_shared (0, 1, 2, key1.prv, 4, 5))); - nano::confirm_ack con1 (vote); + nano::confirm_ack con1{ nano::dev::network_params.network, vote }; std::vector bytes; { nano::vectorstream stream1 (bytes); @@ -106,7 +102,7 @@ TEST (message, confirm_ack_hash_serialization) } nano::keypair representative1; auto vote (std::make_shared (representative1.pub, representative1.prv, 0, hashes)); - nano::confirm_ack con1 (vote); + nano::confirm_ack con1{ nano::dev::network_params.network, vote }; std::vector bytes; { nano::vectorstream stream1 (bytes); @@ -134,7 +130,7 @@ TEST (message, confirm_req_serialization) nano::keypair key1; nano::keypair key2; auto block (std::make_shared (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 bytes; { nano::vectorstream stream (bytes); @@ -154,7 +150,7 @@ TEST (message, confirm_req_hash_serialization) nano::keypair key1; nano::keypair key2; 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 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 (open.hash (), open.root ())); - nano::confirm_req req (roots_hashes); + nano::confirm_req req{ nano::dev::network_params.network, roots_hashes }; std::vector bytes; { nano::vectorstream stream (bytes); diff --git a/nano/core_test/message_parser.cpp b/nano/core_test/message_parser.cpp index 5918940e9e..d81050e9bc 100644 --- a/nano/core_test/message_parser.cpp +++ b/nano/core_test/message_parser.cpp @@ -71,7 +71,7 @@ TEST (message_parser, exact_confirm_ack_size) nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, network); auto block (std::make_shared (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1)))); auto vote (std::make_shared (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 bytes; { nano::vectorstream stream (bytes); @@ -105,7 +105,7 @@ TEST (message_parser, exact_confirm_req_size) nano::network_constants network; nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, network); auto block (std::make_shared (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 bytes; { nano::vectorstream stream (bytes); @@ -139,7 +139,7 @@ TEST (message_parser, exact_confirm_req_hash_size) nano::network_constants 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::confirm_req message (block.hash (), block.root ()); + nano::confirm_req message{ nano::dev::network_params.network, block.hash (), block.root () }; std::vector bytes; { nano::vectorstream stream (bytes); @@ -173,7 +173,7 @@ TEST (message_parser, exact_publish_size) nano::network_constants network; nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, network); auto block (std::make_shared (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 bytes; { nano::vectorstream stream (bytes); @@ -206,7 +206,7 @@ TEST (message_parser, exact_keepalive_size) nano::vote_uniquer vote_uniquer (block_uniquer); nano::network_constants 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 bytes; { nano::vectorstream stream (bytes); diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index 8f06af1fa4..50521c0b1b 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -304,7 +304,7 @@ TEST (network, send_insufficient_work_udp) auto & node1 = *system.add_node (node_flags); auto & node2 = *system.add_node (node_flags); auto block (std::make_shared (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); 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)); @@ -319,7 +319,7 @@ TEST (network, send_insufficient_work) auto & node2 = *system.nodes[1]; // Block zero work auto block1 (std::make_shared (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 ()))); 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)); @@ -327,20 +327,20 @@ TEST (network, send_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 auto block2 (std::make_shared (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) {}); 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)); // Legacy block work epoch_1 auto block3 (std::make_shared (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) {}); 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_EQ (1, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in)); // State block work epoch_2_recieve auto block4 (std::make_shared (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) {}); 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)); @@ -357,7 +357,7 @@ TEST (receivable_processor, confirm_insufficient_pos) node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); nano::keypair key1; auto vote (std::make_shared (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 ())); } @@ -370,7 +370,7 @@ TEST (receivable_processor, confirm_sufficient_pos) ASSERT_EQ (nano::process_result::progress, node1.process (*block1).code); node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); auto vote (std::make_shared (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 ())); } @@ -783,7 +783,7 @@ TEST (tcp_listener, tcp_node_id_handshake) auto socket (std::make_shared (*system.nodes[0])); 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))); - 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 ()); std::atomic write_done (false); 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); boost::optional> 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 ()); std::atomic done (false); 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 socket (std::make_shared (*node0)); 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 (*node0, socket); socket->async_connect (node0->bootstrap.endpoint (), [&node_id_handshake, channel] (boost::system::error_code const & ec) { ASSERT_FALSE (ec); @@ -942,7 +942,7 @@ TEST (network, duplicate_detection) auto & node0 (*system.add_node (node_flags)); auto & node1 (*system.add_node (node_flags)); auto udp_channel (std::make_shared (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 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; auto & node (*system.add_node (node_flags)); 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 bytes; { nano::vectorstream stream (bytes); @@ -993,7 +993,7 @@ TEST (network, duplicate_revert_publish) TEST (network, bandwidth_limiter) { 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_limit = 4; // must be multiple of the number of channels nano::node_config node_config (nano::get_available_port (), system.logging); @@ -1254,11 +1254,11 @@ TEST (network, filter) { nano::system system{ 1 }; auto & node1 = *system.nodes[0]; - nano::keepalive keepalive; - keepalive.header.network = nano::networks::nano_dev_network; + nano::keepalive keepalive{ nano::dev::network_params.network }; + const_cast (keepalive.header.network) = nano::networks::nano_dev_network; node1.network.inbound (keepalive, std::make_shared (node1)); ASSERT_EQ (0, node1.stats.count (nano::stat::type::message, nano::stat::detail::invalid_network)); - keepalive.header.network = nano::networks::invalid; + const_cast (keepalive.header.network) = nano::networks::invalid; node1.network.inbound (keepalive, std::make_shared (node1)); ASSERT_EQ (1, node1.stats.count (nano::stat::type::message, nano::stat::detail::invalid_network)); } diff --git a/nano/core_test/network_filter.cpp b/nano/core_test/network_filter.cpp index 90f29c5dad..3f5cc981b8 100644 --- a/nano/core_test/network_filter.cpp +++ b/nano/core_test/network_filter.cpp @@ -11,7 +11,7 @@ TEST (network_filter, unit) nano::ledger_constants constants{ nano::networks::nano_dev_network }; nano::network_filter filter (1); auto one_block = [&filter] (std::shared_ptr 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 ()); nano::bufferstream stream (bytes->data (), bytes->size ()); @@ -78,7 +78,7 @@ TEST (network_filter, many) .work (0) .build_shared (); - nano::publish message (block); + nano::publish message{ nano::dev::network_params.network, block }; auto bytes (message.to_bytes ()); nano::bufferstream stream (bytes->data (), bytes->size ()); diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 6f6331698d..bfa146e886 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -361,7 +361,7 @@ TEST (node, receive_gap) .work (0) .build_shared (); 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.block_processor.flush (); 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) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - nano::publish publish1 (send1); + nano::publish publish1{ nano::dev::network_params.network, send1 }; nano::keypair key2; auto send2 = builder.make_block () .previous (nano::dev::genesis->hash ()) @@ -1200,7 +1200,7 @@ TEST (node, fork_flip) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .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 ())); node1.network.inbound (publish1, channel1); node1.block_processor.flush (); @@ -1258,7 +1258,7 @@ TEST (node, fork_multi_flip) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - nano::publish publish1 (send1); + nano::publish publish1{ nano::dev::network_params.network, send1 }; nano::keypair key2; auto send2 = builder.make_block () .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) .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - nano::publish publish2 (send2); + nano::publish publish2{ nano::dev::network_params.network, send2 }; auto send3 = builder.make_block () .previous (publish2.block->hash ()) .destination (key2.pub) @@ -1275,7 +1275,7 @@ TEST (node, fork_multi_flip) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (publish2.block->hash ())) .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 ())); node2.network.inbound (publish2, 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) .work (*system.work.generate (nano::dev::genesis->hash ())) .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 ())); node1.network.inbound (publish1, channel1); node1.block_processor.flush (); @@ -1385,7 +1385,7 @@ TEST (node, fork_open) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) .build_shared (); - nano::publish publish2 (open1); + nano::publish publish2{ nano::dev::network_params.network, open1 }; node1.network.inbound (publish2, channel1); node1.block_processor.flush (); node1.scheduler.flush (); @@ -1397,7 +1397,7 @@ TEST (node, fork_open) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) .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); node1.network.inbound (publish3, channel1); node1.block_processor.flush (); @@ -1531,7 +1531,7 @@ TEST (node, fork_no_vote_quorum) auto transaction (system.wallet (1)->wallets.tx_begin_read ()); ASSERT_FALSE (system.wallet (1)->store.fetch (transaction, key1, key3)); auto vote (std::make_shared (key1, key3, 0, send2)); - nano::confirm_ack confirm (vote); + nano::confirm_ack confirm{ nano::dev::network_params.network, vote }; std::vector buffer; { nano::vectorstream stream (buffer); @@ -2692,8 +2692,8 @@ TEST (node, local_votes_cache) election->force_confirm (); ASSERT_TIMELY (3s, node.ledger.cache.cemented_count == 3); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); - nano::confirm_req message1 (send1); - nano::confirm_req message2 (send2); + nano::confirm_req message1{ nano::dev::network_params.network, send1 }; + nano::confirm_req message2{ nano::dev::network_params.network, send2 }; auto channel (node.network.udp_channels.create (node.network.endpoint ())); node.network.inbound (message1, channel); 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 ()); 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) { node.network.inbound (message3, channel); @@ -2772,7 +2772,7 @@ TEST (node, local_votes_cache_batch) .build_shared (); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code); std::vector> 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 ())); // Generates and sends one vote for both hashes which is then cached node.network.inbound (message, channel); @@ -2787,10 +2787,10 @@ TEST (node, local_votes_cache_batch) // Test when votes are different node.history.erase (send2->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_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_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 @@ -2807,7 +2807,7 @@ TEST (node, local_votes_cache_generate_new_vote) auto & node (*system.add_node (node_config)); system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); // 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 ())); node.network.inbound (message1, channel); 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); // One of the hashes is cached std::vector> roots_hashes{ std::make_pair (nano::dev::genesis->hash (), nano::dev::genesis->root ()), std::make_pair (send1->hash (), send1->root ()) }; - nano::confirm_req message2 (roots_hashes); + nano::confirm_req message2{ nano::dev::network_params.network, roots_hashes }; node.network.inbound (message2, channel); ASSERT_TIMELY (3s, !node.history.votes (send1->root (), send1->hash ()).empty ()); 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 .build_shared (); 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 ())); auto election (node1.active.election (send1->qualified_root ())); ASSERT_NE (nullptr, election); ASSERT_EQ (1, election->blocks ().size ()); - node1.network.inbound (nano::publish (send3), channel1); - node1.network.inbound (nano::publish (send2), channel1); + node1.network.inbound (nano::publish{ nano::dev::network_params.network, send3 }, channel1); + node1.network.inbound (nano::publish{ nano::dev::network_params.network, send2 }, channel1); ASSERT_TIMELY (3s, election->blocks ().size () > 1); ASSERT_EQ (election->blocks ()[send2->hash ()]->block_signature (), send2->block_signature ()); } diff --git a/nano/core_test/peer_container.cpp b/nano/core_test/peer_container.cpp index 3a4c29908e..94384a5361 100644 --- a/nano/core_test/peer_container.cpp +++ b/nano/core_test/peer_container.cpp @@ -179,8 +179,8 @@ TEST (peer_container, depeer) { nano::system system (1); nano::endpoint endpoint0 (boost::asio::ip::address_v6::loopback (), nano::get_available_port ()); - nano::keepalive message; - message.header.version_using = 1; + nano::keepalive message{ nano::dev::network_params.network }; + const_cast (message.header.version_using) = 1; auto bytes (message.to_bytes ()); nano::message_buffer buffer = { bytes->data (), bytes->size (), endpoint0 }; system.nodes[0]->network.udp_channels.receive_action (&buffer); diff --git a/nano/core_test/telemetry.cpp b/nano/core_test/telemetry.cpp index d44bbf7157..b46e01ad7f 100644 --- a/nano/core_test/telemetry.cpp +++ b/nano/core_test/telemetry.cpp @@ -284,7 +284,7 @@ TEST (telemetry, receive_from_non_listening_channel) { nano::system system; 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 ())); // 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); @@ -412,7 +412,7 @@ TEST (telemetry, dos_tcp) 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 ())); channel->send (message, [] (boost::system::error_code const & ec, size_t size_a) { ASSERT_FALSE (ec); @@ -455,7 +455,7 @@ TEST (telemetry, dos_udp) 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 ())); channel->send (message, [] (boost::system::error_code const & ec, size_t size_a) { ASSERT_FALSE (ec); @@ -532,7 +532,7 @@ TEST (telemetry, max_possible_size) nano::telemetry_data data; 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); 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); // Change anything so that the signed message is incorrect 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); ASSERT_TIMELY (10s, node->stats.count (nano::stat::type::telemetry, nano::stat::detail::invalid_signature) > 0); diff --git a/nano/core_test/websocket.cpp b/nano/core_test/websocket.cpp index 1dc15e078a..f9462d82fa 100644 --- a/nano/core_test/websocket.cpp +++ b/nano/core_test/websocket.cpp @@ -141,7 +141,7 @@ TEST (websocket, stopped_election) // Create election, then erase it, causing a websocket message to be emitted nano::keypair key1; auto send1 (std::make_shared (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 ())); node1->network.inbound (publish1, channel1); node1->block_processor.flush (); diff --git a/nano/node/bootstrap/bootstrap_bulk_pull.cpp b/nano/node/bootstrap/bootstrap_bulk_pull.cpp index bb362799e0..873a490e17 100644 --- a/nano/node/bootstrap/bootstrap_bulk_pull.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_pull.cpp @@ -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); 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) { // Account for new pulls @@ -300,7 +300,7 @@ nano::bulk_pull_account_client::~bulk_pull_account_client () 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.minimum_amount = connection->node->config.receive_minimum; req.flags = nano::bulk_pull_account_flags::pending_hash_and_amount; diff --git a/nano/node/bootstrap/bootstrap_bulk_push.cpp b/nano/node/bootstrap/bootstrap_bulk_push.cpp index 1be43031d3..0a1a19e8bf 100644 --- a/nano/node/bootstrap/bootstrap_bulk_push.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_push.cpp @@ -17,7 +17,7 @@ nano::bulk_push_client::~bulk_push_client () 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 ()); connection->channel->send ( message, [this_l] (boost::system::error_code const & ec, size_t size_a) { diff --git a/nano/node/bootstrap/bootstrap_frontier.cpp b/nano/node/bootstrap/bootstrap_frontier.cpp index 4fad5f6674..6f6daf45b9 100644 --- a/nano/node/bootstrap/bootstrap_frontier.cpp +++ b/nano/node/bootstrap/bootstrap_frontier.cpp @@ -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) { - 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::max ()) ? start_account_a : start_account_a.number () + 1; request.age = frontiers_age_a; request.count = count_a; diff --git a/nano/node/bootstrap/bootstrap_server.cpp b/nano/node/bootstrap/bootstrap_server.cpp index 022cf89366..7a7caf127a 100644 --- a/nano/node/bootstrap/bootstrap_server.cpp +++ b/nano/node/bootstrap/bootstrap_server.cpp @@ -669,10 +669,7 @@ class request_response_visitor : public nano::message_visitor boost::optional> 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)); 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); - 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; + nano::node_id_handshake response_message (connection->node->network_params.network, cookie, response); auto shared_const_buffer = response_message.to_shared_const_buffer (); connection->socket->async_write (shared_const_buffer, [connection = std::weak_ptr (connection)] (boost::system::error_code const & ec, size_t size_a) { if (auto connection_l = connection.lock ()) diff --git a/nano/node/common.cpp b/nano/node/common.cpp index 1b84a7a2c3..0583b588c4 100644 --- a/nano/node/common.cpp +++ b/nano/node/common.cpp @@ -40,8 +40,11 @@ uint64_t nano::ip_address_hash_raw (boost::asio::ip::address const & ip_a, uint1 return result; } -nano::message_header::message_header (nano::message_type type_a) : - network (nano::network_constants::active_network), +nano::message_header::message_header (nano::network_constants const & constants, nano::message_type type_a) : + network{ constants.current_network }, + version_max{ constants.protocol_version }, + version_using{ constants.protocol_version }, + version_min{ constants.protocol_version_min }, type (type_a) { } @@ -88,8 +91,8 @@ bool nano::message_header::deserialize (nano::stream & stream_a) return error; } -nano::message::message (nano::message_type type_a) : - header (type_a) +nano::message::message (nano::network_constants const & constants, nano::message_type type_a) : + header (constants, type_a) { } @@ -535,8 +538,8 @@ bool nano::message_parser::at_end (nano::stream & stream_a) return end; } -nano::keepalive::keepalive () : - message (nano::message_type::keepalive) +nano::keepalive::keepalive (nano::network_constants const & constants) : + message (constants, nano::message_type::keepalive) { nano::endpoint endpoint (boost::asio::ip::address_v6{}, 0); 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 const & block_a) : - message (nano::message_type::publish), +nano::publish::publish (nano::network_constants const & constants, std::shared_ptr const & block_a) : + message (constants, nano::message_type::publish), block (block_a) { 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 const & block_a) : - message (nano::message_type::confirm_req), +nano::confirm_req::confirm_req (nano::network_constants const & constants, std::shared_ptr const & block_a) : + message (constants, nano::message_type::confirm_req), block (block_a) { header.block_type_set (block->type ()); } -nano::confirm_req::confirm_req (std::vector> const & roots_hashes_a) : - message (nano::message_type::confirm_req), +nano::confirm_req::confirm_req (nano::network_constants const & constants, std::vector> const & roots_hashes_a) : + message (constants, nano::message_type::confirm_req), roots_hashes (roots_hashes_a) { // not_a_block (1) block type for hashes + roots request @@ -664,8 +667,8 @@ nano::confirm_req::confirm_req (std::vector (roots_hashes.size ())); } -nano::confirm_req::confirm_req (nano::block_hash const & hash_a, nano::root const & root_a) : - message (nano::message_type::confirm_req), +nano::confirm_req::confirm_req (nano::network_constants const & constants, nano::block_hash const & hash_a, nano::root const & root_a) : + message (constants, nano::message_type::confirm_req), roots_hashes (std::vector> (1, std::make_pair (hash_a, root_a))) { 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 const & vote_a) : - message (nano::message_type::confirm_ack), +nano::confirm_ack::confirm_ack (nano::network_constants const & constants, std::shared_ptr const & vote_a) : + message (constants, nano::message_type::confirm_ack), vote (vote_a) { 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; } -nano::frontier_req::frontier_req () : - message (nano::message_type::frontier_req) +nano::frontier_req::frontier_req (nano::network_constants const & constants) : + 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; } -nano::bulk_pull::bulk_pull () : - message (nano::message_type::bulk_pull) +nano::bulk_pull::bulk_pull (nano::network_constants const & constants) : + 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); } -nano::bulk_pull_account::bulk_pull_account () : - message (nano::message_type::bulk_pull_account) +nano::bulk_pull_account::bulk_pull_account (nano::network_constants const & constants) : + message (constants, nano::message_type::bulk_pull_account) { } @@ -1029,8 +1032,8 @@ bool nano::bulk_pull_account::deserialize (nano::stream & stream_a) return error; } -nano::bulk_push::bulk_push () : - message (nano::message_type::bulk_push) +nano::bulk_push::bulk_push (nano::network_constants const & constants) : + 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); } -nano::telemetry_req::telemetry_req () : - message (nano::message_type::telemetry_req) +nano::telemetry_req::telemetry_req (nano::network_constants const & constants) : + 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); } -nano::telemetry_ack::telemetry_ack () : - message (nano::message_type::telemetry_ack) +nano::telemetry_ack::telemetry_ack (nano::network_constants const & constants) : + 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) : - message (nano::message_type::telemetry_ack), +nano::telemetry_ack::telemetry_ack (nano::network_constants const & constants, nano::telemetry_data const & telemetry_data_a) : + message (constants, nano::message_type::telemetry_ack), 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 @@ -1342,8 +1345,8 @@ nano::node_id_handshake::node_id_handshake (bool & error_a, nano::stream & strea error_a = deserialize (stream_a); } -nano::node_id_handshake::node_id_handshake (boost::optional query, boost::optional> response) : - message (nano::message_type::node_id_handshake), +nano::node_id_handshake::node_id_handshake (nano::network_constants const & constants, boost::optional query, boost::optional> response) : + message (constants, nano::message_type::node_id_handshake), query (query), response (response) { diff --git a/nano/node/common.hpp b/nano/node/common.hpp index c185fe7286..3d29457f46 100644 --- a/nano/node/common.hpp +++ b/nano/node/common.hpp @@ -187,7 +187,7 @@ class message_visitor; class message_header final { public: - explicit message_header (nano::message_type); + message_header (nano::network_constants const &, nano::message_type); message_header (bool &, nano::stream &); void serialize (nano::stream &) const; bool deserialize (nano::stream &); @@ -225,7 +225,7 @@ class message_header final class message { public: - explicit message (nano::message_type); + explicit message (nano::network_constants const &, nano::message_type); explicit message (nano::message_header const &); virtual ~message () = default; virtual void serialize (nano::stream &) const = 0; @@ -279,7 +279,7 @@ class message_parser final class keepalive final : public message { public: - keepalive (); + explicit keepalive (nano::network_constants const & constants); keepalive (bool &, nano::stream &, nano::message_header const &); void visit (nano::message_visitor &) const override; void serialize (nano::stream &) const override; @@ -292,7 +292,7 @@ class publish final : public message { public: publish (bool &, nano::stream &, nano::message_header const &, nano::uint128_t const & = 0, nano::block_uniquer * = nullptr); - explicit publish (std::shared_ptr const &); + publish (nano::network_constants const & constants, std::shared_ptr const &); void visit (nano::message_visitor &) const override; void serialize (nano::stream &) const override; bool deserialize (nano::stream &, nano::block_uniquer * = nullptr); @@ -304,9 +304,9 @@ class confirm_req final : public message { public: confirm_req (bool &, nano::stream &, nano::message_header const &, nano::block_uniquer * = nullptr); - explicit confirm_req (std::shared_ptr const &); - confirm_req (std::vector> const &); - confirm_req (nano::block_hash const &, nano::root const &); + confirm_req (nano::network_constants const & constants, std::shared_ptr const &); + confirm_req (nano::network_constants const & constants, std::vector> const &); + confirm_req (nano::network_constants const & constants, nano::block_hash const &, nano::root const &); void serialize (nano::stream &) const override; bool deserialize (nano::stream &, nano::block_uniquer * = nullptr); void visit (nano::message_visitor &) const override; @@ -320,7 +320,7 @@ class confirm_ack final : public message { public: confirm_ack (bool &, nano::stream &, nano::message_header const &, nano::vote_uniquer * = nullptr); - explicit confirm_ack (std::shared_ptr const &); + confirm_ack (nano::network_constants const & constants, std::shared_ptr const &); void serialize (nano::stream &) const override; void visit (nano::message_visitor &) const override; bool operator== (nano::confirm_ack const &) const; @@ -330,7 +330,7 @@ class confirm_ack final : public message class frontier_req final : public message { public: - frontier_req (); + explicit frontier_req (nano::network_constants const & constants); frontier_req (bool &, nano::stream &, nano::message_header const &); void serialize (nano::stream &) const override; bool deserialize (nano::stream &); @@ -389,7 +389,7 @@ class telemetry_data class telemetry_req final : public message { public: - telemetry_req (); + explicit telemetry_req (nano::network_constants const & constants); explicit telemetry_req (nano::message_header const &); void serialize (nano::stream &) const override; bool deserialize (nano::stream &); @@ -398,9 +398,9 @@ class telemetry_req final : public message class telemetry_ack final : public message { public: - telemetry_ack (); + explicit telemetry_ack (nano::network_constants const & constants); 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 visit (nano::message_visitor &) const override; bool deserialize (nano::stream &); @@ -414,7 +414,7 @@ class bulk_pull final : public message { public: using count_t = uint32_t; - bulk_pull (); + explicit bulk_pull (nano::network_constants const & constants); bulk_pull (bool &, nano::stream &, nano::message_header const &); void serialize (nano::stream &) const override; bool deserialize (nano::stream &); @@ -431,7 +431,7 @@ class bulk_pull final : public message class bulk_pull_account final : public message { public: - bulk_pull_account (); + explicit bulk_pull_account (nano::network_constants const & constants); bulk_pull_account (bool &, nano::stream &, nano::message_header const &); void serialize (nano::stream &) const override; bool deserialize (nano::stream &); @@ -444,7 +444,7 @@ class bulk_pull_account final : public message class bulk_push final : public message { public: - bulk_push (); + explicit bulk_push (nano::network_constants const & constants); explicit bulk_push (nano::message_header const &); void serialize (nano::stream &) const override; bool deserialize (nano::stream &); @@ -454,7 +454,7 @@ class node_id_handshake final : public message { public: node_id_handshake (bool &, nano::stream &, nano::message_header const &); - node_id_handshake (boost::optional, boost::optional>); + node_id_handshake (nano::network_constants const & constants, boost::optional, boost::optional>); void serialize (nano::stream &) const override; bool deserialize (nano::stream &); void visit (nano::message_visitor &) const override; diff --git a/nano/node/confirmation_solicitor.cpp b/nano/node/confirmation_solicitor.cpp index 3faf67f725..235aa6bd24 100644 --- a/nano/node/confirmation_solicitor.cpp +++ b/nano/node/confirmation_solicitor.cpp @@ -31,7 +31,7 @@ bool nano::confirmation_solicitor::broadcast (nano::election const & election_a) if (rebroadcasted++ < max_block_broadcasts) { 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; // Directed broadcasting to principal representatives 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); 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); roots_hashes_l.clear (); } } 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); } } diff --git a/nano/node/network.cpp b/nano/node/network.cpp index b3e284653a..7c90706ddf 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -152,14 +152,14 @@ void nano::network::stop () void nano::network::send_keepalive (std::shared_ptr const & channel_a) { - nano::keepalive message; + nano::keepalive message{ node.network_params.network }; random_fill (message.peers); channel_a->send (message); } void nano::network::send_keepalive_self (std::shared_ptr const & channel_a) { - nano::keepalive message; + nano::keepalive message{ node.network_params.network }; fill_keepalive_self (message.peers); channel_a->send (message); } @@ -172,7 +172,7 @@ void nano::network::send_node_id_handshake (std::shared_ptrfirst, *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 ()) { 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 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); } void nano::network::flood_block_initial (std::shared_ptr 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 ()) { 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 const & bl void nano::network::flood_vote (std::shared_ptr 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))) { i->send (message, nullptr); @@ -218,7 +232,7 @@ void nano::network::flood_vote (std::shared_ptr const & vote_a, floa void nano::network::flood_vote_pr (std::shared_ptr 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 ()) { i.channel->send (message, nullptr, nano::buffer_drop_policy::no_limiter_drop); @@ -252,7 +266,7 @@ void nano::network::flood_block_many (std::deque> b void nano::network::send_confirm_req (std::shared_ptr const & channel_a, std::pair const & hash_root_a) { // 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); } @@ -330,7 +344,7 @@ void nano::network::broadcast_confirm_req_batched_many (std::unordered_mapsecond.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); if (i->second.empty ()) { @@ -516,11 +530,11 @@ class network_message_visitor : public nano::message_visitor // 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. - nano::telemetry_ack telemetry_ack; + nano::telemetry_ack telemetry_ack{ node.network_params.network }; 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); - 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); } diff --git a/nano/node/network.hpp b/nano/node/network.hpp index 598f62e5ad..eb0c771da1 100644 --- a/nano/node/network.hpp +++ b/nano/node/network.hpp @@ -124,18 +124,8 @@ class network final void start (); void stop (); 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) - { - 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_keepalive (float const scale_a = 1.0f); + void flood_keepalive_self (float const scale_a = 0.5f); void flood_vote (std::shared_ptr const &, float scale); void flood_vote_pr (std::shared_ptr const &); // Flood block to all PRs and a random selection of non-PRs diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 9d29cb0e7f..c2d6ad5954 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -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), active (*this, confirmation_height_processor), 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), startup_time (std::chrono::steady_clock::now ()), node_seq (seq) diff --git a/nano/node/request_aggregator.cpp b/nano/node/request_aggregator.cpp index a67c930cbc..6c3d6f7939 100644 --- a/nano/node/request_aggregator.cpp +++ b/nano/node/request_aggregator.cpp @@ -11,9 +11,10 @@ #include #include -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) : - max_delay (network_constants_a.is_dev_network () ? 50 : 300), - small_delay (network_constants_a.is_dev_network () ? 10 : 50), +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) : + config{ config_a }, + 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), stats (stats_a), local_votes (history_a), @@ -150,7 +151,7 @@ bool nano::request_aggregator::empty () void nano::request_aggregator::reply_action (std::shared_ptr const & vote_a, std::shared_ptr const & channel_a) const { - nano::confirm_ack confirm (vote_a); + nano::confirm_ack confirm{ config.network_params.network, vote_a }; channel_a->send (confirm); } @@ -277,7 +278,7 @@ std::pair>, std::vectorhash () != hash) { - nano::publish publish (block); + nano::publish publish (config.network_params.network, block); channel_a->send (publish); } } diff --git a/nano/node/request_aggregator.hpp b/nano/node/request_aggregator.hpp index 52017cabb2..8b8c8186b1 100644 --- a/nano/node/request_aggregator.hpp +++ b/nano/node/request_aggregator.hpp @@ -59,7 +59,7 @@ class request_aggregator final // clang-format on 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 */ void add (std::shared_ptr const & channel_a, std::vector> const & hashes_roots_a); @@ -68,6 +68,7 @@ class request_aggregator final size_t size (); bool empty (); + nano::node_config const & config; const std::chrono::milliseconds max_delay; const std::chrono::milliseconds small_delay; const size_t max_channel_requests; diff --git a/nano/node/telemetry.cpp b/nano/node/telemetry.cpp index e6ed593ac1..3ab166d382 100644 --- a/nano/node/telemetry.cpp +++ b/nano/node/telemetry.cpp @@ -352,7 +352,7 @@ void nano::telemetry::fire_request_message (std::shared_ptr this_w (shared_from_this ()); - nano::telemetry_req message; + nano::telemetry_req message{ network_params.network }; // 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) { if (auto this_l = this_w.lock ()) diff --git a/nano/node/transport/tcp.cpp b/nano/node/transport/tcp.cpp index 85aabe3ecf..6951751b85 100644 --- a/nano/node/transport/tcp.cpp +++ b/nano/node/transport/tcp.cpp @@ -445,7 +445,7 @@ void nano::transport::tcp_channels::purge (std::chrono::steady_clock::time_point void nano::transport::tcp_channels::ongoing_keepalive () { - nano::keepalive message; + nano::keepalive message{ node.network_params.network }; node.network.random_fill (message.peers); nano::unique_lock lock (mutex); // Wake up channels @@ -571,7 +571,7 @@ void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a { // TCP node ID handshake 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 ()) { 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_ptrset_node_id (node_id); channel_a->set_last_packet_received (std::chrono::steady_clock::now ()); boost::optional> 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 ()) { 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 ())); diff --git a/nano/node/transport/transport.cpp b/nano/node/transport/transport.cpp index 2ec3eb6840..75ba49474d 100644 --- a/nano/node/transport/transport.cpp +++ b/nano/node/transport/transport.cpp @@ -102,9 +102,6 @@ nano::transport::channel::channel (nano::node & node_a) : void nano::transport::channel::send (nano::message & message_a, std::function 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; message_a.visit (visitor); auto buffer (message_a.to_shared_const_buffer ()); diff --git a/nano/node/transport/udp.cpp b/nano/node/transport/udp.cpp index c46fce6859..bd975ad650 100644 --- a/nano/node/transport/udp.cpp +++ b/nano/node/transport/udp.cpp @@ -686,7 +686,7 @@ void nano::transport::udp_channels::purge (std::chrono::steady_clock::time_point void nano::transport::udp_channels::ongoing_keepalive () { - nano::keepalive message; + nano::keepalive message{ node.network_params.network }; node.network.random_fill (message.peers); std::vector> send_list; nano::unique_lock lock (mutex);