From 54fb102b9f172fb2a05efce054a675ef3e92b31f Mon Sep 17 00:00:00 2001 From: clemahieu Date: Tue, 10 Aug 2021 23:10:10 +0100 Subject: [PATCH] Moving work_thresholds in to their own object within network_params and including a referencing it within ledger_constants and network_constants instead of creating copies. --- nano/core_test/block.cpp | 2 +- nano/core_test/difficulty.cpp | 28 +++---- nano/core_test/distributed_work.cpp | 34 ++++---- nano/core_test/fakes/work_peer.hpp | 6 +- nano/core_test/ledger.cpp | 4 +- nano/core_test/network.cpp | 6 +- nano/core_test/node.cpp | 16 ++-- nano/core_test/system.cpp | 6 +- nano/core_test/wallet.cpp | 24 +++--- nano/core_test/work_pool.cpp | 30 +++---- nano/lib/config.hpp | 8 +- nano/lib/work.cpp | 6 +- nano/nano_node/daemon.cpp | 2 +- nano/nano_node/entry.cpp | 32 +++---- nano/nano_wallet/entry.cpp | 2 +- nano/node/blockprocessor.cpp | 6 +- nano/node/bootstrap/bootstrap_bulk_pull.cpp | 2 +- nano/node/bootstrap/bootstrap_bulk_push.cpp | 2 +- nano/node/bootstrap/bootstrap_server.cpp | 4 +- nano/node/common.cpp | 6 +- nano/node/distributed_work.cpp | 2 +- nano/node/json_handler.cpp | 24 +++--- nano/node/node.cpp | 10 +-- nano/node/wallet.cpp | 6 +- nano/node/websocket.cpp | 2 +- nano/qt/qt.cpp | 10 +-- nano/qt_test/qt.cpp | 2 +- nano/rpc_test/rpc.cpp | 92 ++++++++++----------- nano/secure/common.cpp | 8 +- nano/secure/common.hpp | 15 ++-- nano/slow_test/node.cpp | 8 +- nano/test_common/system.cpp | 4 +- 32 files changed, 208 insertions(+), 201 deletions(-) diff --git a/nano/core_test/block.cpp b/nano/core_test/block.cpp index e4e5fb58..3e2274d8 100644 --- a/nano/core_test/block.cpp +++ b/nano/core_test/block.cpp @@ -312,7 +312,7 @@ TEST (block, publish_req_serialization) TEST (block, difficulty) { nano::send_block block (0, 1, 2, nano::keypair ().prv, 4, 5); - ASSERT_EQ (nano::dev::network_params.network.publish_thresholds.difficulty (block), nano::dev::network_params.network.publish_thresholds.difficulty (block.work_version (), block.root (), block.block_work ())); + ASSERT_EQ (nano::dev::network_params.work.difficulty (block), nano::dev::network_params.work.difficulty (block.work_version (), block.root (), block.block_work ())); } TEST (state_block, serialization) diff --git a/nano/core_test/difficulty.cpp b/nano/core_test/difficulty.cpp index 9f2fe0d9..75a4bd04 100644 --- a/nano/core_test/difficulty.cpp +++ b/nano/core_test/difficulty.cpp @@ -128,23 +128,23 @@ TEST (difficulty, network_constants) ASSERT_NEAR (1., nano::difficulty::to_multiplier (dev_thresholds.epoch_2, dev_thresholds.base), 1e-10); nano::work_version version{ nano::work_version::work_1 }; - ASSERT_EQ (nano::dev::network_params.network.publish_thresholds.base, nano::dev::network_params.network.publish_thresholds.epoch_2); - ASSERT_EQ (nano::dev::network_params.network.publish_thresholds.base, nano::dev::network_params.network.publish_thresholds.threshold_base (version)); - ASSERT_EQ (nano::dev::network_params.network.publish_thresholds.entry, nano::dev::network_params.network.publish_thresholds.threshold_entry (version, nano::block_type::state)); - ASSERT_EQ (nano::dev::network_params.network.publish_thresholds.epoch_1, nano::dev::network_params.network.publish_thresholds.threshold_entry (version, nano::block_type::send)); - ASSERT_EQ (nano::dev::network_params.network.publish_thresholds.epoch_1, nano::dev::network_params.network.publish_thresholds.threshold_entry (version, nano::block_type::receive)); - ASSERT_EQ (nano::dev::network_params.network.publish_thresholds.epoch_1, nano::dev::network_params.network.publish_thresholds.threshold_entry (version, nano::block_type::open)); - ASSERT_EQ (nano::dev::network_params.network.publish_thresholds.epoch_1, nano::dev::network_params.network.publish_thresholds.threshold_entry (version, nano::block_type::change)); - ASSERT_EQ (nano::dev::network_params.network.publish_thresholds.epoch_1, nano::dev::network_params.network.publish_thresholds.threshold (version, nano::block_details (nano::epoch::epoch_0, false, false, false))); - ASSERT_EQ (nano::dev::network_params.network.publish_thresholds.epoch_1, nano::dev::network_params.network.publish_thresholds.threshold (version, nano::block_details (nano::epoch::epoch_1, false, false, false))); - ASSERT_EQ (nano::dev::network_params.network.publish_thresholds.epoch_1, nano::dev::network_params.network.publish_thresholds.threshold (version, nano::block_details (nano::epoch::epoch_1, false, false, false))); + ASSERT_EQ (nano::dev::network_params.work.base, nano::dev::network_params.work.epoch_2); + ASSERT_EQ (nano::dev::network_params.work.base, nano::dev::network_params.work.threshold_base (version)); + ASSERT_EQ (nano::dev::network_params.work.entry, nano::dev::network_params.work.threshold_entry (version, nano::block_type::state)); + ASSERT_EQ (nano::dev::network_params.work.epoch_1, nano::dev::network_params.work.threshold_entry (version, nano::block_type::send)); + ASSERT_EQ (nano::dev::network_params.work.epoch_1, nano::dev::network_params.work.threshold_entry (version, nano::block_type::receive)); + ASSERT_EQ (nano::dev::network_params.work.epoch_1, nano::dev::network_params.work.threshold_entry (version, nano::block_type::open)); + ASSERT_EQ (nano::dev::network_params.work.epoch_1, nano::dev::network_params.work.threshold_entry (version, nano::block_type::change)); + ASSERT_EQ (nano::dev::network_params.work.epoch_1, nano::dev::network_params.work.threshold (version, nano::block_details (nano::epoch::epoch_0, false, false, false))); + ASSERT_EQ (nano::dev::network_params.work.epoch_1, nano::dev::network_params.work.threshold (version, nano::block_details (nano::epoch::epoch_1, false, false, false))); + ASSERT_EQ (nano::dev::network_params.work.epoch_1, nano::dev::network_params.work.threshold (version, nano::block_details (nano::epoch::epoch_1, false, false, false))); // Send [+ change] - ASSERT_EQ (nano::dev::network_params.network.publish_thresholds.epoch_2, nano::dev::network_params.network.publish_thresholds.threshold (version, nano::block_details (nano::epoch::epoch_2, true, false, false))); + ASSERT_EQ (nano::dev::network_params.work.epoch_2, nano::dev::network_params.work.threshold (version, nano::block_details (nano::epoch::epoch_2, true, false, false))); // Change - ASSERT_EQ (nano::dev::network_params.network.publish_thresholds.epoch_2, nano::dev::network_params.network.publish_thresholds.threshold (version, nano::block_details (nano::epoch::epoch_2, false, false, false))); + ASSERT_EQ (nano::dev::network_params.work.epoch_2, nano::dev::network_params.work.threshold (version, nano::block_details (nano::epoch::epoch_2, false, false, false))); // Receive [+ change] / Open - ASSERT_EQ (nano::dev::network_params.network.publish_thresholds.epoch_2_receive, nano::dev::network_params.network.publish_thresholds.threshold (version, nano::block_details (nano::epoch::epoch_2, false, true, false))); + ASSERT_EQ (nano::dev::network_params.work.epoch_2_receive, nano::dev::network_params.work.threshold (version, nano::block_details (nano::epoch::epoch_2, false, true, false))); // Epoch - ASSERT_EQ (nano::dev::network_params.network.publish_thresholds.epoch_2_receive, nano::dev::network_params.network.publish_thresholds.threshold (version, nano::block_details (nano::epoch::epoch_2, false, false, true))); + ASSERT_EQ (nano::dev::network_params.work.epoch_2_receive, nano::dev::network_params.work.threshold (version, nano::block_details (nano::epoch::epoch_2, false, false, true))); } diff --git a/nano/core_test/distributed_work.cpp b/nano/core_test/distributed_work.cpp index 00fbbcbb..ce0cfddc 100644 --- a/nano/core_test/distributed_work.cpp +++ b/nano/core_test/distributed_work.cpp @@ -10,7 +10,7 @@ TEST (distributed_work, stopped) { nano::system system (1); system.nodes[0]->distributed_work.stop (); - ASSERT_TRUE (system.nodes[0]->distributed_work.make (nano::work_version::work_1, nano::block_hash (), {}, nano::dev::network_params.network.publish_thresholds.base, {})); + ASSERT_TRUE (system.nodes[0]->distributed_work.make (nano::work_version::work_1, nano::block_hash (), {}, nano::dev::network_params.work.base, {})); } TEST (distributed_work, no_peers) @@ -25,9 +25,9 @@ TEST (distributed_work, no_peers) work = work_a; done = true; }; - ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, node->config.work_peers, node->network_params.network.publish_thresholds.base, callback, nano::account ())); + ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, node->config.work_peers, node->network_params.work.base, callback, nano::account ())); ASSERT_TIMELY (5s, done); - ASSERT_GE (nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, hash, *work), node->network_params.network.publish_thresholds.base); + ASSERT_GE (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, *work), node->network_params.work.base); // should only be removed after cleanup ASSERT_EQ (1, node->distributed_work.size ()); while (node->distributed_work.size () > 0) @@ -43,7 +43,7 @@ TEST (distributed_work, no_peers_disabled) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.work_threads = 0; auto & node = *system.add_node (node_config); - ASSERT_TRUE (node.distributed_work.make (nano::work_version::work_1, nano::block_hash (), node.config.work_peers, nano::dev::network_params.network.publish_thresholds.base, {})); + ASSERT_TRUE (node.distributed_work.make (nano::work_version::work_1, nano::block_hash (), node.config.work_peers, nano::dev::network_params.work.base, {})); } TEST (distributed_work, no_peers_cancel) @@ -58,7 +58,7 @@ TEST (distributed_work, no_peers_cancel) ASSERT_FALSE (work_a.is_initialized ()); done = true; }; - ASSERT_FALSE (node.distributed_work.make (nano::work_version::work_1, hash, node.config.work_peers, nano::difficulty::from_multiplier (1e6, node.network_params.network.publish_thresholds.base), callback_to_cancel)); + ASSERT_FALSE (node.distributed_work.make (nano::work_version::work_1, hash, node.config.work_peers, nano::difficulty::from_multiplier (1e6, node.network_params.work.base), callback_to_cancel)); ASSERT_EQ (1, node.distributed_work.size ()); // cleanup should not cancel or remove an ongoing work node.distributed_work.cleanup_finished (); @@ -70,7 +70,7 @@ TEST (distributed_work, no_peers_cancel) // now using observer done = false; - ASSERT_FALSE (node.distributed_work.make (nano::work_version::work_1, hash, node.config.work_peers, nano::difficulty::from_multiplier (1e6, node.network_params.network.publish_thresholds.base), callback_to_cancel)); + ASSERT_FALSE (node.distributed_work.make (nano::work_version::work_1, hash, node.config.work_peers, nano::difficulty::from_multiplier (1e6, node.network_params.work.base), callback_to_cancel)); ASSERT_EQ (1, node.distributed_work.size ()); node.observers.work_cancel.notify (hash); ASSERT_TIMELY (20s, done && node.distributed_work.size () == 0); @@ -90,7 +90,7 @@ TEST (distributed_work, no_peers_multi) // Test many works for the same root for (unsigned i{ 0 }; i < total; ++i) { - ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, node->config.work_peers, nano::difficulty::from_multiplier (10, node->network_params.network.publish_thresholds.base), callback)); + ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, node->config.work_peers, nano::difficulty::from_multiplier (10, node->network_params.work.base), callback)); } ASSERT_TIMELY (5s, count == total); system.deadline_set (5s); @@ -104,7 +104,7 @@ TEST (distributed_work, no_peers_multi) for (unsigned i{ 0 }; i < total; ++i) { nano::block_hash hash_i (i + 1); - ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash_i, node->config.work_peers, node->network_params.network.publish_thresholds.base, callback)); + ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash_i, node->config.work_peers, node->network_params.work.base, callback)); } ASSERT_TIMELY (5s, count == total); system.deadline_set (5s); @@ -136,9 +136,9 @@ TEST (distributed_work, peer) work_peer->start (); decltype (node->config.work_peers) peers; peers.emplace_back ("::ffff:127.0.0.1", work_peer->port ()); - ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, peers, node->network_params.network.publish_thresholds.base, callback, nano::account ())); + ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, peers, node->network_params.work.base, callback, nano::account ())); ASSERT_TIMELY (5s, done); - ASSERT_GE (nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, hash, *work), node->network_params.network.publish_thresholds.base); + ASSERT_GE (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, *work), node->network_params.work.base); ASSERT_EQ (1, work_peer->generations_good); ASSERT_EQ (0, work_peer->generations_bad); ASSERT_NO_ERROR (system.poll ()); @@ -162,9 +162,9 @@ TEST (distributed_work, peer_malicious) malicious_peer->start (); decltype (node->config.work_peers) peers; peers.emplace_back ("::ffff:127.0.0.1", malicious_peer->port ()); - ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, peers, node->network_params.network.publish_thresholds.base, callback, nano::account ())); + ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, peers, node->network_params.work.base, callback, nano::account ())); ASSERT_TIMELY (5s, done); - ASSERT_GE (nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, hash, *work), node->network_params.network.publish_thresholds.base); + ASSERT_GE (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, *work), node->network_params.work.base); ASSERT_TIMELY (5s, malicious_peer->generations_bad >= 1); // make sure it was *not* the malicious peer that replied ASSERT_EQ (0, malicious_peer->generations_good); @@ -179,7 +179,7 @@ TEST (distributed_work, peer_malicious) auto malicious_peer2 (std::make_shared (node->work, node->io_ctx, nano::get_available_port (), work_peer_type::malicious)); malicious_peer2->start (); peers[0].second = malicious_peer2->port (); - ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, peers, node->network_params.network.publish_thresholds.base, {}, nano::account ())); + ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, peers, node->network_params.work.base, {}, nano::account ())); ASSERT_TIMELY (5s, malicious_peer2->generations_bad >= 2); node->distributed_work.cancel (hash); ASSERT_EQ (0, malicious_peer2->cancels); @@ -208,9 +208,9 @@ TEST (distributed_work, peer_multi) peers.emplace_back ("localhost", malicious_peer->port ()); peers.emplace_back ("localhost", slow_peer->port ()); peers.emplace_back ("localhost", good_peer->port ()); - ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, peers, node->network_params.network.publish_thresholds.base, callback, nano::account ())); + ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, peers, node->network_params.work.base, callback, nano::account ())); ASSERT_TIMELY (5s, done); - ASSERT_GE (nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, hash, *work), node->network_params.network.publish_thresholds.base); + ASSERT_GE (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, *work), node->network_params.work.base); ASSERT_TIMELY (5s, slow_peer->cancels == 1); ASSERT_EQ (0, malicious_peer->generations_good); ASSERT_EQ (1, malicious_peer->generations_bad); @@ -239,7 +239,7 @@ TEST (distributed_work, fail_resolve) }; decltype (node->config.work_peers) peers; peers.emplace_back ("beeb.boop.123z", 0); - ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, peers, node->network_params.network.publish_thresholds.base, callback, nano::account ())); + ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, peers, node->network_params.work.base, callback, nano::account ())); ASSERT_TIMELY (5s, done); - ASSERT_GE (nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, hash, *work), node->network_params.network.publish_thresholds.base); + ASSERT_GE (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, *work), node->network_params.work.base); } diff --git a/nano/core_test/fakes/work_peer.hpp b/nano/core_test/fakes/work_peer.hpp index 5192b8b1..7544f910 100644 --- a/nano/core_test/fakes/work_peer.hpp +++ b/nano/core_test/fakes/work_peer.hpp @@ -141,14 +141,14 @@ private: if (type == work_peer_type::good) { auto hash = hash_a; - auto request_difficulty = work_pool.network_constants.publish_thresholds.threshold_base (version); + auto request_difficulty = work_pool.network_constants.work.threshold_base (version); work_pool.generate (version, hash, request_difficulty, [this_l = shared_from_this (), hash] (boost::optional work_a) { auto result = work_a.value_or (0); - auto result_difficulty (this_l->work_pool.network_constants.publish_thresholds.difficulty (this_l->version, hash, result)); + auto result_difficulty (this_l->work_pool.network_constants.work.difficulty (this_l->version, hash, result)); ptree::ptree message_l; message_l.put ("work", nano::to_string_hex (result)); message_l.put ("difficulty", nano::to_string_hex (result_difficulty)); - message_l.put ("multiplier", nano::to_string (nano::difficulty::to_multiplier (result_difficulty, this_l->work_pool.network_constants.publish_thresholds.threshold_base (this_l->version)))); + message_l.put ("multiplier", nano::to_string (nano::difficulty::to_multiplier (result_difficulty, this_l->work_pool.network_constants.work.threshold_base (this_l->version)))); message_l.put ("hash", hash.to_string ()); std::stringstream ostream; ptree::write_json (ostream, message_l); diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index 7fbd351e..6cb0bdd8 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -2893,9 +2893,9 @@ TEST (ledger, work_validation) // With random work the block doesn't pass, then modifies the block with sufficient work and ensures a correct result auto process_block = [&store, &ledger, &pool] (nano::block & block_a, nano::block_details const details_a) { - auto threshold = nano::dev::network_params.network.publish_thresholds.threshold (block_a.work_version (), details_a); + auto threshold = nano::dev::network_params.work.threshold (block_a.work_version (), details_a); // Rarely failed with random work, so modify until it doesn't have enough difficulty - while (nano::dev::network_params.network.publish_thresholds.difficulty (block_a) >= threshold) + while (nano::dev::network_params.work.difficulty (block_a) >= threshold) { block_a.block_work_set (block_a.block_work () + 1); } diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index 50521c0b..94b39eff 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -326,20 +326,20 @@ TEST (network, send_insufficient_work) ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work) != 0); 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))); + 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.work.epoch_2_receive, node1.network_params.work.epoch_1 - 1))); 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))); + 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.work.epoch_2))); 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))); + 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.work.epoch_2_receive, node1.network_params.work.epoch_1 - 1))); 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); diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index 3c55c62b..6d80f659 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -36,21 +36,21 @@ TEST (node, work_generate) nano::block_hash root{ 1 }; nano::work_version version{ nano::work_version::work_1 }; { - auto difficulty = nano::difficulty::from_multiplier (1.5, node.network_params.network.publish_thresholds.base); + auto difficulty = nano::difficulty::from_multiplier (1.5, node.network_params.work.base); auto work = node.work_generate_blocking (version, root, difficulty); ASSERT_TRUE (work.is_initialized ()); - ASSERT_TRUE (nano::dev::network_params.network.publish_thresholds.difficulty (version, root, *work) >= difficulty); + ASSERT_TRUE (nano::dev::network_params.work.difficulty (version, root, *work) >= difficulty); } { - auto difficulty = nano::difficulty::from_multiplier (0.5, node.network_params.network.publish_thresholds.base); + auto difficulty = nano::difficulty::from_multiplier (0.5, node.network_params.work.base); boost::optional work; do { work = node.work_generate_blocking (version, root, difficulty); - } while (nano::dev::network_params.network.publish_thresholds.difficulty (version, root, *work) >= node.network_params.network.publish_thresholds.base); + } while (nano::dev::network_params.work.difficulty (version, root, *work) >= node.network_params.work.base); ASSERT_TRUE (work.is_initialized ()); - ASSERT_TRUE (nano::dev::network_params.network.publish_thresholds.difficulty (version, root, *work) >= difficulty); - ASSERT_FALSE (nano::dev::network_params.network.publish_thresholds.difficulty (version, root, *work) >= node.network_params.network.publish_thresholds.base); + ASSERT_TRUE (nano::dev::network_params.work.difficulty (version, root, *work) >= difficulty); + ASSERT_FALSE (nano::dev::network_params.work.difficulty (version, root, *work) >= node.network_params.work.base); } } @@ -4550,7 +4550,7 @@ TEST (node, deferred_dependent_elections) ASSERT_TIMELY (2s, node2.block (send2->hash ())); // Re-processing older blocks with updated work also does not start an election - node.work_generate_blocking (*open, nano::dev::network_params.network.publish_thresholds.difficulty (*open) + 1); + node.work_generate_blocking (*open, nano::dev::network_params.work.difficulty (*open) + 1); node.process_local (open); node.block_processor.flush (); node.scheduler.flush (); @@ -4563,7 +4563,7 @@ TEST (node, deferred_dependent_elections) ASSERT_FALSE (node.active.active (open->qualified_root ())); /// The election was dropped but it's still not possible to restart it - node.work_generate_blocking (*open, nano::dev::network_params.network.publish_thresholds.difficulty (*open) + 1); + node.work_generate_blocking (*open, nano::dev::network_params.work.difficulty (*open) + 1); ASSERT_FALSE (node.active.active (open->qualified_root ())); node.process_local (open); node.block_processor.flush (); diff --git a/nano/core_test/system.cpp b/nano/core_test/system.cpp index c084d955..fd129c89 100644 --- a/nano/core_test/system.cpp +++ b/nano/core_test/system.cpp @@ -10,12 +10,12 @@ TEST (system, work_generate_limited) { nano::system system; nano::block_hash key (1); - auto min = nano::dev::network_params.network.publish_thresholds.entry; - auto max = nano::dev::network_params.network.publish_thresholds.base; + auto min = nano::dev::network_params.work.entry; + auto max = nano::dev::network_params.work.base; for (int i = 0; i < 5; ++i) { auto work = system.work_generate_limited (key, min, max); - auto difficulty = nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, key, work); + auto difficulty = nano::dev::network_params.work.difficulty (nano::work_version::work_1, key, work); ASSERT_GE (difficulty, min); ASSERT_LT (difficulty, max); } diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp index 82a18a55..295e0262 100644 --- a/nano/core_test/wallet.cpp +++ b/nano/core_test/wallet.cpp @@ -645,7 +645,7 @@ TEST (wallet, work) uint64_t work (0); if (!wallet->store.work_get (transaction, nano::dev::genesis_key.pub, work)) { - done = nano::dev::network_params.network.publish_thresholds.difficulty (nano::dev::genesis->work_version (), nano::dev::genesis->hash (), work) >= system.nodes[0]->default_difficulty (nano::dev::genesis->work_version ()); + done = nano::dev::network_params.work.difficulty (nano::dev::genesis->work_version (), nano::dev::genesis->hash (), work) >= system.nodes[0]->default_difficulty (nano::dev::genesis->work_version ()); } ASSERT_NO_ERROR (system.poll ()); } @@ -675,7 +675,7 @@ TEST (wallet, work_generate) ASSERT_NO_ERROR (system.poll ()); auto block_transaction (node1.store.tx_begin_read ()); auto transaction (system.wallet (0)->wallets.tx_begin_read ()); - again = wallet->store.work_get (transaction, account1, work1) || nano::dev::network_params.network.publish_thresholds.difficulty (block->work_version (), node1.ledger.latest_root (block_transaction, account1), work1) < node1.default_difficulty (block->work_version ()); + again = wallet->store.work_get (transaction, account1, work1) || nano::dev::network_params.work.difficulty (block->work_version (), node1.ledger.latest_root (block_transaction, account1), work1) < node1.default_difficulty (block->work_version ()); } } @@ -705,10 +705,10 @@ TEST (wallet, work_cache_delayed) ASSERT_NO_ERROR (system.poll ()); if (!wallet->store.work_get (node1.wallets.tx_begin_read (), account1, work1)) { - again = nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, block2->hash (), work1) < threshold; + again = nano::dev::network_params.work.difficulty (nano::work_version::work_1, block2->hash (), work1) < threshold; } } - ASSERT_GE (nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, block2->hash (), work1), threshold); + ASSERT_GE (nano::dev::network_params.work.difficulty (nano::work_version::work_1, block2->hash (), work1), threshold); } TEST (wallet, insert_locked) @@ -822,7 +822,7 @@ TEST (wallet, no_work) auto block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, std::numeric_limits::max (), false)); ASSERT_NE (nullptr, block); ASSERT_NE (0, block->block_work ()); - ASSERT_GE (nano::dev::network_params.network.publish_thresholds.difficulty (*block), nano::dev::network_params.network.publish_thresholds.threshold (block->work_version (), block->sideband ().details)); + ASSERT_GE (nano::dev::network_params.work.difficulty (*block), nano::dev::network_params.work.threshold (block->work_version (), block->sideband ().details)); auto transaction (system.wallet (0)->wallets.tx_begin_read ()); uint64_t cached_work (0); system.wallet (0)->store.work_get (transaction, nano::dev::genesis_key.pub, cached_work); @@ -1022,9 +1022,9 @@ TEST (wallet, epoch_2_validation) auto receive = wallet.receive_action (send->hash (), nano::dev::genesis_key.pub, amount, send->link ().as_account (), 1); ASSERT_NE (nullptr, receive); - if (nano::dev::network_params.network.publish_thresholds.difficulty (*receive) < node.network_params.network.publish_thresholds.base) + if (nano::dev::network_params.work.difficulty (*receive) < node.network_params.work.base) { - ASSERT_GE (nano::dev::network_params.network.publish_thresholds.difficulty (*receive), node.network_params.network.publish_thresholds.epoch_2_receive); + ASSERT_GE (nano::dev::network_params.work.difficulty (*receive), node.network_params.work.epoch_2_receive); ASSERT_EQ (nano::epoch::epoch_2, receive->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_2, receive->sideband ().source_epoch); break; @@ -1074,9 +1074,9 @@ TEST (wallet, epoch_2_receive_propagation) auto receive2 = wallet.receive_action (send2->hash (), key.pub, amount, send2->link ().as_account (), 1); ASSERT_NE (nullptr, receive2); - if (nano::dev::network_params.network.publish_thresholds.difficulty (*receive2) < node.network_params.network.publish_thresholds.base) + if (nano::dev::network_params.work.difficulty (*receive2) < node.network_params.work.base) { - ASSERT_GE (nano::dev::network_params.network.publish_thresholds.difficulty (*receive2), node.network_params.network.publish_thresholds.epoch_2_receive); + ASSERT_GE (nano::dev::network_params.work.difficulty (*receive2), node.network_params.work.epoch_2_receive); ASSERT_EQ (nano::epoch::epoch_2, node.store.block.version (node.store.tx_begin_read (), receive2->hash ())); ASSERT_EQ (nano::epoch::epoch_2, receive2->sideband ().source_epoch); break; @@ -1112,16 +1112,16 @@ TEST (wallet, epoch_2_receive_unopened) auto send1 = wallet.send_action (nano::dev::genesis_key.pub, key.pub, amount, 1); // Upgrade unopened account to epoch_2 - auto epoch2_unopened = nano::state_block (key.pub, 0, 0, 0, node.network_params.ledger.epochs.link (nano::epoch::epoch_2), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (key.pub, node.network_params.network.publish_thresholds.epoch_2)); + auto epoch2_unopened = nano::state_block (key.pub, 0, 0, 0, node.network_params.ledger.epochs.link (nano::epoch::epoch_2), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (key.pub, node.network_params.work.epoch_2)); ASSERT_EQ (nano::process_result::progress, node.process (epoch2_unopened).code); wallet.insert_adhoc (key.prv, false); auto receive1 = wallet.receive_action (send1->hash (), key.pub, amount, send1->link ().as_account (), 1); ASSERT_NE (nullptr, receive1); - if (nano::dev::network_params.network.publish_thresholds.difficulty (*receive1) < node.network_params.network.publish_thresholds.base) + if (nano::dev::network_params.work.difficulty (*receive1) < node.network_params.work.base) { - ASSERT_GE (nano::dev::network_params.network.publish_thresholds.difficulty (*receive1), node.network_params.network.publish_thresholds.epoch_2_receive); + ASSERT_GE (nano::dev::network_params.work.difficulty (*receive1), node.network_params.work.epoch_2_receive); ASSERT_EQ (nano::epoch::epoch_2, node.store.block.version (node.store.tx_begin_read (), receive1->hash ())); ASSERT_EQ (nano::epoch::epoch_1, receive1->sideband ().source_epoch); break; diff --git a/nano/core_test/work_pool.cpp b/nano/core_test/work_pool.cpp index 1487b79d..db66d44b 100644 --- a/nano/core_test/work_pool.cpp +++ b/nano/core_test/work_pool.cpp @@ -19,7 +19,7 @@ TEST (work, one) nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::change_block block (1, 1, nano::keypair ().prv, 3, 4); block.block_work_set (*pool.generate (block.root ())); - ASSERT_LT (nano::dev::network_params.network.publish_thresholds.threshold_base (block.work_version ()), nano::dev::network_params.network.publish_thresholds.difficulty (block)); + ASSERT_LT (nano::dev::network_params.work.threshold_base (block.work_version ()), nano::dev::network_params.work.difficulty (block)); } TEST (work, disabled) @@ -33,9 +33,9 @@ TEST (work, validate) { nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::send_block send_block (1, 1, 2, nano::keypair ().prv, 4, 6); - ASSERT_LT (nano::dev::network_params.network.publish_thresholds.difficulty (send_block), nano::dev::network_params.network.publish_thresholds.threshold_base (send_block.work_version ())); + ASSERT_LT (nano::dev::network_params.work.difficulty (send_block), nano::dev::network_params.work.threshold_base (send_block.work_version ())); send_block.block_work_set (*pool.generate (send_block.root ())); - ASSERT_LT (nano::dev::network_params.network.publish_thresholds.threshold_base (send_block.work_version ()), nano::dev::network_params.network.publish_thresholds.difficulty (send_block)); + ASSERT_LT (nano::dev::network_params.work.threshold_base (send_block.work_version ()), nano::dev::network_params.work.difficulty (send_block)); } TEST (work, cancel) @@ -47,7 +47,7 @@ TEST (work, cancel) { nano::root key (1); pool.generate ( - nano::work_version::work_1, key, nano::dev::network_params.network.publish_thresholds.base, [&done] (boost::optional work_a) { + nano::work_version::work_1, key, nano::dev::network_params.work.base, [&done] (boost::optional work_a) { done = !work_a; }); pool.cancel (key); @@ -65,12 +65,12 @@ TEST (work, cancel_many) nano::root key4 (1); nano::root key5 (3); nano::root key6 (1); - pool.generate (nano::work_version::work_1, key1, nano::dev::network_params.network.publish_thresholds.base, [] (boost::optional) {}); - pool.generate (nano::work_version::work_1, key2, nano::dev::network_params.network.publish_thresholds.base, [] (boost::optional) {}); - pool.generate (nano::work_version::work_1, key3, nano::dev::network_params.network.publish_thresholds.base, [] (boost::optional) {}); - pool.generate (nano::work_version::work_1, key4, nano::dev::network_params.network.publish_thresholds.base, [] (boost::optional) {}); - pool.generate (nano::work_version::work_1, key5, nano::dev::network_params.network.publish_thresholds.base, [] (boost::optional) {}); - pool.generate (nano::work_version::work_1, key6, nano::dev::network_params.network.publish_thresholds.base, [] (boost::optional) {}); + pool.generate (nano::work_version::work_1, key1, nano::dev::network_params.work.base, [] (boost::optional) {}); + pool.generate (nano::work_version::work_1, key2, nano::dev::network_params.work.base, [] (boost::optional) {}); + pool.generate (nano::work_version::work_1, key3, nano::dev::network_params.work.base, [] (boost::optional) {}); + pool.generate (nano::work_version::work_1, key4, nano::dev::network_params.work.base, [] (boost::optional) {}); + pool.generate (nano::work_version::work_1, key5, nano::dev::network_params.work.base, [] (boost::optional) {}); + pool.generate (nano::work_version::work_1, key6, nano::dev::network_params.work.base, [] (boost::optional) {}); pool.cancel (key1); } @@ -85,7 +85,7 @@ TEST (work, opencl) if (!environment.platforms.empty () && !environment.platforms.begin ()->devices.empty ()) { nano::opencl_config config (0, 0, 16 * 1024); - auto opencl (nano::opencl_work::create (true, config, logger, nano::dev::network_params.network.publish_thresholds)); + auto opencl (nano::opencl_work::create (true, config, logger, nano::dev::network_params.work)); if (opencl != nullptr) { // 0 threads, should add 1 for managing OpenCL @@ -100,7 +100,7 @@ TEST (work, opencl) { nano::random_pool::generate_block (root.bytes.data (), root.bytes.size ()); auto result (*pool.generate (nano::work_version::work_1, root, difficulty)); - ASSERT_GE (nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, root, result), difficulty); + ASSERT_GE (nano::dev::network_params.work.difficulty (nano::work_version::work_1, root, result), difficulty); difficulty += difficulty_add; } } @@ -141,14 +141,14 @@ TEST (work, difficulty) do { auto work1 = *pool.generate (nano::work_version::work_1, root, difficulty1); - result_difficulty1 = nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, root, work1); + result_difficulty1 = nano::dev::network_params.work.difficulty (nano::work_version::work_1, root, work1); } while (result_difficulty1 > difficulty2); ASSERT_GT (result_difficulty1, difficulty1); uint64_t result_difficulty2 (0); do { auto work2 = *pool.generate (nano::work_version::work_1, root, difficulty2); - result_difficulty2 = nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, root, work2); + result_difficulty2 = nano::dev::network_params.work.difficulty (nano::work_version::work_1, root, work2); } while (result_difficulty2 > difficulty3); ASSERT_GT (result_difficulty2, difficulty2); } @@ -170,7 +170,7 @@ TEST (work, eco_pow) do { auto work = *pool.generate (nano::work_version::work_1, root, difficulty1); - result_difficulty = nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, root, work); + result_difficulty = nano::dev::network_params.work.difficulty (nano::work_version::work_1, root, work); } while (result_difficulty > difficulty2); ASSERT_GT (result_difficulty, difficulty1); } diff --git a/nano/lib/config.hpp b/nano/lib/config.hpp index f0b84bb5..9f75fc00 100644 --- a/nano/lib/config.hpp +++ b/nano/lib/config.hpp @@ -134,9 +134,9 @@ public: class network_constants { public: - network_constants (nano::networks network_a) : + network_constants (nano::work_thresholds & work, nano::networks network_a) : current_network (network_a), - publish_thresholds (is_live_network () ? nano::work_thresholds::publish_full : is_beta_network () ? nano::work_thresholds::publish_beta : is_test_network () ? nano::work_thresholds::publish_test : nano::work_thresholds::publish_dev) + work{ work } { // A representative is classified as principal based on its weight and this factor principal_weight_factor = 1000; // 0.1% @@ -160,7 +160,7 @@ public: /** The network this param object represents. This may differ from the global active network; this is needed for certain --debug... commands */ nano::networks current_network{ nano::network_constants::active_network }; - nano::work_thresholds publish_thresholds; + nano::work_thresholds & work; unsigned principal_weight_factor; uint16_t default_node_port; @@ -235,7 +235,7 @@ public: return error; } - const char * get_current_network_as_string () const + const char * get_current_network_as_string () { return is_live_network () ? "live" : is_beta_network () ? "beta" : is_test_network () ? "test" : "dev"; } diff --git a/nano/lib/work.cpp b/nano/lib/work.cpp index 8a2d7f45..f6afc6ca 100644 --- a/nano/lib/work.cpp +++ b/nano/lib/work.cpp @@ -90,7 +90,7 @@ void nano::work_pool::loop (uint64_t thread) if (opt_work.is_initialized ()) { work = *opt_work; - output = network_constants.publish_thresholds.value (current_l.item, work); + output = network_constants.work.value (current_l.item, work); } else { @@ -123,7 +123,7 @@ void nano::work_pool::loop (uint64_t thread) { // If the ticket matches what we started with, we're the ones that found the solution debug_assert (output >= current_l.difficulty); - debug_assert (current_l.difficulty == 0 || network_constants.publish_thresholds.value (current_l.item, work) == output); + debug_assert (current_l.difficulty == 0 || network_constants.work.value (current_l.item, work) == output); // Signal other threads to stop their work next time they check ticket ++ticket; pending.pop_front (); @@ -201,7 +201,7 @@ void nano::work_pool::generate (nano::work_version const version_a, nano::root c boost::optional nano::work_pool::generate (nano::root const & root_a) { debug_assert (network_constants.is_dev_network ()); - return generate (nano::work_version::work_1, root_a, network_constants.publish_thresholds.base); + return generate (nano::work_version::work_1, root_a, network_constants.work.base); } boost::optional nano::work_pool::generate (nano::root const & root_a, uint64_t difficulty_a) diff --git a/nano/nano_node/daemon.cpp b/nano/nano_node/daemon.cpp index 6d504c86..e329f0b3 100644 --- a/nano/nano_node/daemon.cpp +++ b/nano/nano_node/daemon.cpp @@ -60,7 +60,7 @@ void nano_daemon::daemon::run (boost::filesystem::path const & data_path, nano:: config.node.logging.init (data_path); nano::logger_mt logger{ config.node.logging.min_time_between_log_output }; boost::asio::io_context io_ctx; - auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, logger, config.node.network_params.network.publish_thresholds)); + auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, logger, config.node.network_params.work)); nano::work_pool opencl_work (config.node.network_params.network, config.node.work_threads, config.node.pow_sleep_interval, opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic & ticket_a) { return opencl->generate_work (version_a, root_a, difficulty_a, ticket_a); } diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index 83954349..0cd59c44 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -325,7 +325,7 @@ int main (int argc, char * const * argv) if (!key.decode_hex (key_it->second.as ())) { nano::keypair genesis (key.to_string ()); - nano::work_pool work{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::work_pool work{ network_params.network, std::numeric_limits::max () }; std::cout << "Genesis: " << genesis.prv.to_string () << "\n" << "Public: " << genesis.pub.to_string () << "\n" << "Account: " << genesis.pub.to_account () << "\n"; @@ -341,7 +341,7 @@ int main (int argc, char * const * argv) << "Account: " << rep.pub.to_account () << "\n"; } nano::uint128_t balance (std::numeric_limits::max ()); - nano::open_block genesis_block (reinterpret_cast (genesis.pub), genesis.pub, genesis.pub, genesis.prv, genesis.pub, *work.generate (nano::work_version::work_1, genesis.pub, network_params.network.publish_thresholds.epoch_1)); + nano::open_block genesis_block (reinterpret_cast (genesis.pub), genesis.pub, genesis.pub, genesis.prv, genesis.pub, *work.generate (nano::work_version::work_1, genesis.pub, network_params.work.epoch_1)); std::cout << genesis_block.to_json (); std::cout.flush (); nano::block_hash previous (genesis_block.hash ()); @@ -353,7 +353,7 @@ int main (int argc, char * const * argv) { debug_assert (balance > weekly_distribution); balance = balance < (weekly_distribution * 2) ? 0 : balance - weekly_distribution; - nano::send_block send (previous, landing.pub, balance, genesis.prv, genesis.pub, *work.generate (nano::work_version::work_1, previous, network_params.network.publish_thresholds.epoch_1)); + nano::send_block send (previous, landing.pub, balance, genesis.prv, genesis.pub, *work.generate (nano::work_version::work_1, previous, network_params.work.epoch_1)); previous = send.hash (); std::cout << send.to_json (); std::cout.flush (); @@ -515,7 +515,7 @@ int main (int argc, char * const * argv) uint64_t count{ 10000000U }; // 10M for (uint64_t i (0); i < count; ++i) { - valid = network_params.network.publish_thresholds.value (hash, i) > difficulty; + valid = network_params.work.value (hash, i) > difficulty; } std::ostringstream oss (valid ? "true" : "false"); // IO forces compiler to not dismiss the variable auto total_time (std::chrono::duration_cast (std::chrono::steady_clock::now () - start).count ()); @@ -607,7 +607,7 @@ int main (int argc, char * const * argv) { nano::logger_mt logger; nano::opencl_config config (platform, device, threads); - auto opencl (nano::opencl_work::create (true, config, logger, network_params.network.publish_thresholds)); + auto opencl (nano::opencl_work::create (true, config, logger, network_params.work)); nano::work_pool work_pool{ network_params.network, 0, std::chrono::nanoseconds (0), opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic &) { return opencl->generate_work (version_a, root_a, difficulty_a); } @@ -914,7 +914,7 @@ int main (int argc, char * const * argv) .balance (genesis_balance) .link (keys[i].pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1)) + .work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.work.epoch_1)) .build (); genesis_latest = send->hash (); @@ -927,7 +927,7 @@ int main (int argc, char * const * argv) .balance (balances[i]) .link (genesis_latest) .sign (keys[i].prv, keys[i].pub) - .work (*node->work.generate (nano::work_version::work_1, keys[i].pub, node->network_params.network.publish_thresholds.epoch_1)) + .work (*node->work.generate (nano::work_version::work_1, keys[i].pub, node->network_params.work.epoch_1)) .build (); frontiers[i] = open->hash (); @@ -948,7 +948,7 @@ int main (int argc, char * const * argv) .balance (balances[j]) .link (keys[other].pub) .sign (keys[j].prv, keys[j].pub) - .work (*node->work.generate (nano::work_version::work_1, frontiers[j], node->network_params.network.publish_thresholds.epoch_1)) + .work (*node->work.generate (nano::work_version::work_1, frontiers[j], node->network_params.work.epoch_1)) .build (); frontiers[j] = send->hash (); @@ -963,7 +963,7 @@ int main (int argc, char * const * argv) .balance (balances[other]) .link (frontiers[j].as_block_hash ()) .sign (keys[other].prv, keys[other].pub) - .work (*node->work.generate (nano::work_version::work_1, frontiers[other], node->network_params.network.publish_thresholds.epoch_1)) + .work (*node->work.generate (nano::work_version::work_1, frontiers[other], node->network_params.work.epoch_1)) .build (); frontiers[other] = receive->hash (); @@ -1027,7 +1027,7 @@ int main (int argc, char * const * argv) .balance (genesis_balance) .link (keys[i].pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1)) + .work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.work.epoch_1)) .build (); genesis_latest = send->hash (); @@ -1040,7 +1040,7 @@ int main (int argc, char * const * argv) .balance (balance) .link (genesis_latest) .sign (keys[i].prv, keys[i].pub) - .work (*node->work.generate (nano::work_version::work_1, keys[i].pub, node->network_params.network.publish_thresholds.epoch_1)) + .work (*node->work.generate (nano::work_version::work_1, keys[i].pub, node->network_params.work.epoch_1)) .build (); node->ledger.process (transaction, *open); @@ -1059,7 +1059,7 @@ int main (int argc, char * const * argv) .balance (genesis_balance) .link (destination.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1)) + .work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.work.epoch_1)) .build (); genesis_latest = send->hash (); @@ -1124,7 +1124,7 @@ int main (int argc, char * const * argv) std::cout << boost::str (boost::format ("Starting generating %1% blocks...\n") % (count * 2)); boost::asio::io_context io_ctx1; boost::asio::io_context io_ctx2; - nano::work_pool work{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::work_pool work{ network_params.network, std::numeric_limits::max () }; nano::logging logging; auto path1 (nano::unique_path ()); auto path2 (nano::unique_path ()); @@ -1164,7 +1164,7 @@ int main (int argc, char * const * argv) .balance (genesis_balance) .link (key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*work.generate (nano::work_version::work_1, genesis_latest, nano::dev::network_params.network.publish_thresholds.epoch_1)) + .work (*work.generate (nano::work_version::work_1, genesis_latest, nano::dev::network_params.work.epoch_1)) .build (); genesis_latest = send->hash (); @@ -1176,7 +1176,7 @@ int main (int argc, char * const * argv) .balance (1) .link (genesis_latest) .sign (key.prv, key.pub) - .work (*work.generate (nano::work_version::work_1, key.pub, nano::dev::network_params.network.publish_thresholds.epoch_1)) + .work (*work.generate (nano::work_version::work_1, key.pub, nano::dev::network_params.work.epoch_1)) .build (); blocks.push_back (std::move (send)); @@ -1564,7 +1564,7 @@ int main (int argc, char * const * argv) } } // Check if block work value is correct - if (node->network_params.network.publish_thresholds.difficulty (*block) < node->network_params.network.publish_thresholds.threshold (block->work_version (), block->sideband ().details)) + if (node->network_params.work.difficulty (*block) < node->network_params.work.threshold (block->work_version (), block->sideband ().details)) { print_error_message (boost::str (boost::format ("Invalid work for block %1% value: %2%\n") % hash.to_string () % nano::to_string_hex (block->block_work ()))); } diff --git a/nano/nano_wallet/entry.cpp b/nano/nano_wallet/entry.cpp index 1ee061be..def208f9 100644 --- a/nano/nano_wallet/entry.cpp +++ b/nano/nano_wallet/entry.cpp @@ -106,7 +106,7 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost std::shared_ptr node; std::shared_ptr gui; nano::set_application_icon (application); - auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, logger, config.node.network_params.network.publish_thresholds)); + auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, logger, config.node.network_params.work)); nano::work_pool work{ config.node.network_params.network, config.node.work_threads, config.node.pow_sleep_interval, opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic &) { return opencl->generate_work (version_a, root_a, difficulty_a); } diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index e74fb6e8..b9d59dbb 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -105,7 +105,7 @@ void nano::block_processor::add (std::shared_ptr const & block_a, u void nano::block_processor::add (nano::unchecked_info const & info_a) { - debug_assert (!node.network_params.network.publish_thresholds.validate_entry (*info_a.block)); + debug_assert (!node.network_params.work.validate_entry (*info_a.block)); bool quarter_full (size () > node.flags.block_processor_full_size / 4); if (info_a.verified == nano::signature_verification::unknown && (info_a.block->type () == nano::block_type::state || info_a.block->type () == nano::block_type::open || !info_a.account.is_zero ())) { @@ -124,7 +124,7 @@ void nano::block_processor::add (nano::unchecked_info const & info_a) void nano::block_processor::add_local (nano::unchecked_info const & info_a) { release_assert (info_a.verified == nano::signature_verification::unknown && (info_a.block->type () == nano::block_type::state || !info_a.account.is_zero ())); - debug_assert (!node.network_params.network.publish_thresholds.validate_entry (*info_a.block)); + debug_assert (!node.network_params.work.validate_entry (*info_a.block)); state_block_signature_verification.add (info_a); } @@ -501,7 +501,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction { if (node.config.logging.ledger_logging ()) { - node.logger.try_log (boost::str (boost::format ("Insufficient work for %1% : %2% (difficulty %3%)") % hash.to_string () % nano::to_string_hex (block->block_work ()) % nano::to_string_hex (node.network_params.network.publish_thresholds.difficulty (*block)))); + node.logger.try_log (boost::str (boost::format ("Insufficient work for %1% : %2% (difficulty %3%)") % hash.to_string () % nano::to_string_hex (block->block_work ()) % nano::to_string_hex (node.network_params.work.difficulty (*block)))); } break; } diff --git a/nano/node/bootstrap/bootstrap_bulk_pull.cpp b/nano/node/bootstrap/bootstrap_bulk_pull.cpp index 53a83b37..53301c14 100644 --- a/nano/node/bootstrap/bootstrap_bulk_pull.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_pull.cpp @@ -208,7 +208,7 @@ void nano::bulk_pull_client::received_block (boost::system::error_code const & e { nano::bufferstream stream (connection->receive_buffer->data (), size_a); auto block (nano::deserialize_block (stream, type_a)); - if (block != nullptr && !connection->node->network_params.network.publish_thresholds.validate_entry (*block)) + if (block != nullptr && !connection->node->network_params.work.validate_entry (*block)) { auto hash (block->hash ()); if (connection->node->config.logging.bulk_pull_logging ()) diff --git a/nano/node/bootstrap/bootstrap_bulk_push.cpp b/nano/node/bootstrap/bootstrap_bulk_push.cpp index 50e28bfc..f784ee01 100644 --- a/nano/node/bootstrap/bootstrap_bulk_push.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_push.cpp @@ -232,7 +232,7 @@ void nano::bulk_push_server::received_block (boost::system::error_code const & e { nano::bufferstream stream (receive_buffer->data (), size_a); auto block (nano::deserialize_block (stream, type_a)); - if (block != nullptr && !connection->node->network_params.network.publish_thresholds.validate_entry (*block)) + if (block != nullptr && !connection->node->network_params.work.validate_entry (*block)) { connection->node->process_active (std::move (block)); throttled_receive (); diff --git a/nano/node/bootstrap/bootstrap_server.cpp b/nano/node/bootstrap/bootstrap_server.cpp index 264f32ef..ccf0fe87 100644 --- a/nano/node/bootstrap/bootstrap_server.cpp +++ b/nano/node/bootstrap/bootstrap_server.cpp @@ -426,7 +426,7 @@ void nano::bootstrap_server::receive_publish_action (boost::system::error_code c { if (is_realtime_connection ()) { - if (!node->network_params.network.publish_thresholds.validate_entry (*request->block)) + if (!node->network_params.work.validate_entry (*request->block)) { add_request (std::unique_ptr (request.release ())); } @@ -494,7 +494,7 @@ void nano::bootstrap_server::receive_confirm_ack_action (boost::system::error_co if (!vote_block.which ()) { auto const & block (boost::get> (vote_block)); - if (node->network_params.network.publish_thresholds.validate_entry (*block)) + if (node->network_params.work.validate_entry (*block)) { process_vote = false; node->stats.inc_detail_only (nano::stat::type::error, nano::stat::detail::insufficient_work); diff --git a/nano/node/common.cpp b/nano/node/common.cpp index 7ea7d9f1..c564d75e 100644 --- a/nano/node/common.cpp +++ b/nano/node/common.cpp @@ -424,7 +424,7 @@ void nano::message_parser::deserialize_publish (nano::stream & stream_a, nano::m nano::publish incoming (error, stream_a, header_a, digest_a, &block_uniquer); if (!error && at_end (stream_a)) { - if (!network.publish_thresholds.validate_entry (*incoming.block)) + if (!network.work.validate_entry (*incoming.block)) { visitor.publish (incoming); } @@ -445,7 +445,7 @@ void nano::message_parser::deserialize_confirm_req (nano::stream & stream_a, nan nano::confirm_req incoming (error, stream_a, header_a, &block_uniquer); if (!error && at_end (stream_a)) { - if (incoming.block == nullptr || !network.publish_thresholds.validate_entry (*incoming.block)) + if (incoming.block == nullptr || !network.work.validate_entry (*incoming.block)) { visitor.confirm_req (incoming); } @@ -471,7 +471,7 @@ void nano::message_parser::deserialize_confirm_ack (nano::stream & stream_a, nan if (!vote_block.which ()) { auto const & block (boost::get> (vote_block)); - if (network.publish_thresholds.validate_entry (*block)) + if (network.work.validate_entry (*block)) { status = parse_status::insufficient_work; break; diff --git a/nano/node/distributed_work.cpp b/nano/node/distributed_work.cpp index f06ef17e..2583b641 100644 --- a/nano/node/distributed_work.cpp +++ b/nano/node/distributed_work.cpp @@ -239,7 +239,7 @@ void nano::distributed_work::success (std::string const & body_a, nano::tcp_endp uint64_t work; if (!nano::from_string_hex (work_text, work)) { - if (nano::dev::network_params.network.publish_thresholds.difficulty (request.version, request.root, work) >= request.difficulty) + if (nano::dev::network_params.work.difficulty (request.version, request.root, work) >= request.difficulty) { error = false; node.unresponsive_work_peers = false; diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index 1bee4224..76ba7c08 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -414,7 +414,7 @@ uint64_t nano::json_handler::difficulty_ledger (nano::block const & block_a) details_found = true; } } - return details_found ? node.network_params.network.publish_thresholds.threshold (block_a.work_version (), details) : node.default_difficulty (block_a.work_version ()); + return details_found ? node.network_params.work.threshold (block_a.work_version (), details) : node.default_difficulty (block_a.work_version ()); } double nano::json_handler::multiplier_optional_impl (nano::work_version const version_a, uint64_t & difficulty) @@ -829,7 +829,7 @@ void nano::json_handler::account_representative_set () if (!rpc_l->ec) { nano::block_details details (info.epoch (), false, false, false); - if (rpc_l->node.network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, info.head, work) < rpc_l->node.network_params.network.publish_thresholds.threshold (nano::work_version::work_1, details)) + if (rpc_l->node.network_params.work.difficulty (nano::work_version::work_1, info.head, work) < rpc_l->node.network_params.work.threshold (nano::work_version::work_1, details)) { rpc_l->ec = nano::error_common::invalid_work; } @@ -1027,7 +1027,7 @@ void nano::json_handler::active_difficulty () auto const multiplier_active = 1.0; auto const default_difficulty (node.default_difficulty (nano::work_version::work_1)); auto const default_receive_difficulty (node.default_receive_difficulty (nano::work_version::work_1)); - auto const receive_current_denormalized (node.network_params.network.publish_thresholds.denormalized_multiplier (multiplier_active, node.network_params.network.publish_thresholds.epoch_2_receive)); + auto const receive_current_denormalized (node.network_params.work.denormalized_multiplier (multiplier_active, node.network_params.work.epoch_2_receive)); response_l.put ("deprecated", "1"); response_l.put ("network_minimum", nano::to_string_hex (default_difficulty)); response_l.put ("network_receive_minimum", nano::to_string_hex (default_receive_difficulty)); @@ -1481,7 +1481,7 @@ void nano::json_handler::block_create () auto block_response_put_l = [rpc_l, this] (nano::block const & block_a) { boost::property_tree::ptree response_l; response_l.put ("hash", block_a.hash ().to_string ()); - response_l.put ("difficulty", nano::to_string_hex (rpc_l->node.network_params.network.publish_thresholds.difficulty (block_a))); + response_l.put ("difficulty", nano::to_string_hex (rpc_l->node.network_params.work.difficulty (block_a))); bool json_block_l = request.get ("json_block", false); if (json_block_l) { @@ -3123,7 +3123,7 @@ void nano::json_handler::process () } if (!rpc_l->ec) { - if (!rpc_l->node.network_params.network.publish_thresholds.validate_entry (*block)) + if (!rpc_l->node.network_params.work.validate_entry (*block)) { if (!is_async) { @@ -3284,7 +3284,7 @@ void nano::json_handler::receive () head = account; } nano::block_details details (epoch, false, true, false); - if (node.network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, head, work) < node.network_params.network.publish_thresholds.threshold (nano::work_version::work_1, details)) + if (node.network_params.work.difficulty (nano::work_version::work_1, head, work) < node.network_params.work.threshold (nano::work_version::work_1, details)) { ec = nano::error_common::invalid_work; } @@ -3628,7 +3628,7 @@ void nano::json_handler::send () if (!ec && work) { nano::block_details details (info.epoch (), true, false, false); - if (node.network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, info.head, work) < node.network_params.network.publish_thresholds.threshold (nano::work_version::work_1, details)) + if (node.network_params.work.difficulty (nano::work_version::work_1, info.head, work) < node.network_params.work.threshold (nano::work_version::work_1, details)) { ec = nano::error_common::invalid_work; } @@ -4872,7 +4872,7 @@ void nano::json_handler::work_generate () auto hash (hash_impl ()); auto difficulty (difficulty_optional_impl (work_version)); multiplier_optional_impl (work_version, difficulty); - if (!ec && (difficulty > node.max_work_generate_difficulty (work_version) || difficulty < node.network_params.network.publish_thresholds.threshold_entry (work_version, nano::block_type::state))) + if (!ec && (difficulty > node.max_work_generate_difficulty (work_version) || difficulty < node.network_params.work.threshold_entry (work_version, nano::block_type::state))) { ec = nano::error_rpc::difficulty_limit; } @@ -4901,7 +4901,7 @@ void nano::json_handler::work_generate () difficulty = difficulty_ledger (*block); } // If optional block difficulty is higher than requested difficulty, send error - if (!ec && node.network_params.network.publish_thresholds.difficulty (*block) >= difficulty) + if (!ec && node.network_params.work.difficulty (*block) >= difficulty) { ec = nano::error_rpc::block_work_enough; } @@ -4919,7 +4919,7 @@ void nano::json_handler::work_generate () uint64_t work (work_a.value ()); response_l.put ("work", nano::to_string_hex (work)); std::stringstream ostream; - auto result_difficulty (rpc_l->node.network_params.network.publish_thresholds.difficulty (work_version, hash, work)); + auto result_difficulty (rpc_l->node.network_params.work.difficulty (work_version, hash, work)); response_l.put ("difficulty", nano::to_string_hex (result_difficulty)); auto result_multiplier = nano::difficulty::to_multiplier (result_difficulty, node.default_difficulty (work_version)); response_l.put ("multiplier", nano::to_string (result_multiplier)); @@ -5045,13 +5045,13 @@ void nano::json_handler::work_validate () * * valid_receive: the work is valid for a receive block in an epoch_2 upgraded account */ - auto result_difficulty (node.network_params.network.publish_thresholds.difficulty (work_version, hash, work)); + auto result_difficulty (node.network_params.work.difficulty (work_version, hash, work)); if (request.count ("difficulty")) { response_l.put ("valid", (result_difficulty >= difficulty) ? "1" : "0"); } response_l.put ("valid_all", (result_difficulty >= node.default_difficulty (work_version)) ? "1" : "0"); - response_l.put ("valid_receive", (result_difficulty >= node.network_params.network.publish_thresholds.threshold (work_version, nano::block_details (nano::epoch::epoch_2, false, true, false))) ? "1" : "0"); + response_l.put ("valid_receive", (result_difficulty >= node.network_params.work.threshold (work_version, nano::block_details (nano::epoch::epoch_2, false, true, false))) ? "1" : "0"); response_l.put ("difficulty", nano::to_string_hex (result_difficulty)); auto result_multiplier = nano::difficulty::to_multiplier (result_difficulty, node.default_difficulty (work_version)); response_l.put ("multiplier", nano::to_string (result_multiplier)); diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 7bdf6b75..5dd6149b 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -1114,7 +1114,7 @@ uint64_t nano::node::default_difficulty (nano::work_version const version_a) con switch (version_a) { case nano::work_version::work_1: - result = network_params.network.publish_thresholds.threshold_base (version_a); + result = network_params.work.threshold_base (version_a); break; default: debug_assert (false && "Invalid version specified to default_difficulty"); @@ -1128,7 +1128,7 @@ uint64_t nano::node::default_receive_difficulty (nano::work_version const versio switch (version_a) { case nano::work_version::work_1: - result = network_params.network.publish_thresholds.epoch_2_receive; + result = network_params.work.epoch_2_receive; break; default: debug_assert (false && "Invalid version specified to default_receive_difficulty"); @@ -1459,7 +1459,7 @@ void nano::node::epoch_upgrader_impl (nano::raw_key const & prv_a, nano::epoch e auto upgrader_process = [] (nano::node & node_a, std::atomic & counter, std::shared_ptr const & epoch, uint64_t difficulty, nano::public_key const & signer_a, nano::root const & root_a, nano::account const & account_a) { epoch->block_work_set (node_a.work_generate_blocking (nano::work_version::work_1, root_a, difficulty).value_or (0)); bool valid_signature (!nano::validate_message (signer_a, epoch->hash (), epoch->block_signature ())); - bool valid_work (node_a.network_params.network.publish_thresholds.difficulty (*epoch) >= difficulty); + bool valid_work (node_a.network_params.work.difficulty (*epoch) >= difficulty); nano::process_result result (nano::process_result::old); if (valid_signature && valid_work) { @@ -1546,7 +1546,7 @@ void nano::node::epoch_upgrader_impl (nano::raw_key const & prv_a, nano::epoch e if (!store.account.get (transaction, account, info) && info.epoch () < epoch_a) { ++attempts; - auto difficulty (network_params.network.publish_thresholds.threshold (nano::work_version::work_1, nano::block_details (epoch_a, false, false, true))); + auto difficulty (network_params.work.threshold (nano::work_version::work_1, nano::block_details (epoch_a, false, false, true))); nano::root const & root (info.head); std::shared_ptr epoch = builder.state () .account (account) @@ -1624,7 +1624,7 @@ void nano::node::epoch_upgrader_impl (nano::raw_key const & prv_a, nano::epoch e { ++attempts; release_assert (nano::epochs::is_sequential (info.epoch, epoch_a)); - auto difficulty (network_params.network.publish_thresholds.threshold (nano::work_version::work_1, nano::block_details (epoch_a, false, false, true))); + auto difficulty (network_params.work.threshold (nano::work_version::work_1, nano::block_details (epoch_a, false, false, true))); nano::root const & root (key.account); nano::account const & account (key.account); std::shared_ptr epoch = builder.state () diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp index 267b3527..c187dee6 100644 --- a/nano/node/wallet.cpp +++ b/nano/node/wallet.cpp @@ -1043,8 +1043,8 @@ bool nano::wallet::action_complete (std::shared_ptr const & block_a wallets.delayed_work->erase (account_a); if (block_a != nullptr) { - auto required_difficulty{ wallets.node.network_params.network.publish_thresholds.threshold (block_a->work_version (), details_a) }; - if (wallets.node.network_params.network.publish_thresholds.difficulty (*block_a) < required_difficulty) + auto required_difficulty{ wallets.node.network_params.work.threshold (block_a->work_version (), details_a) }; + if (wallets.node.network_params.work.difficulty (*block_a) < required_difficulty) { wallets.node.logger.try_log (boost::str (boost::format ("Cached or provided work for block %1% account %2% is invalid, regenerating") % block_a->hash ().to_string () % account_a.to_account ())); debug_assert (required_difficulty <= wallets.node.max_work_generate_difficulty (block_a->work_version ())); @@ -1130,7 +1130,7 @@ void nano::wallet::send_async (nano::account const & source_a, nano::account con // Update work for account if latest root is root_a void nano::wallet::work_update (nano::transaction const & transaction_a, nano::account const & account_a, nano::root const & root_a, uint64_t work_a) { - debug_assert (!wallets.node.network_params.network.publish_thresholds.validate_entry (nano::work_version::work_1, root_a, work_a)); + debug_assert (!wallets.node.network_params.work.validate_entry (nano::work_version::work_1, root_a, work_a)); debug_assert (store.exists (transaction_a, account_a)); auto block_transaction (wallets.node.store.tx_begin_read ()); auto latest (wallets.node.ledger.latest_root (block_transaction, account_a)); diff --git a/nano/node/websocket.cpp b/nano/node/websocket.cpp index f99f7f2d..c1b724d6 100644 --- a/nano/node/websocket.cpp +++ b/nano/node/websocket.cpp @@ -809,7 +809,7 @@ nano::websocket::message nano::websocket::message_builder::work_generation (nano boost::property_tree::ptree result_l; result_l.put ("source", peer_a); result_l.put ("work", nano::to_string_hex (work_a)); - auto result_difficulty_l (nano::dev::network_params.network.publish_thresholds.difficulty (version_a, root_a, work_a)); + auto result_difficulty_l (nano::dev::network_params.work.difficulty (version_a, root_a, work_a)); result_l.put ("difficulty", nano::to_string_hex (result_difficulty_l)); auto result_multiplier_l (nano::difficulty::to_multiplier (result_difficulty_l, publish_threshold_a)); result_l.put ("multiplier", nano::to_string (result_multiplier_l)); diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp index d0e043fb..d847c490 100644 --- a/nano/qt/qt.cpp +++ b/nano/qt/qt.cpp @@ -2003,7 +2003,7 @@ nano_qt::block_entry::block_entry (nano_qt::wallet & wallet_a) : { show_label_ok (*status); this->status->setText (""); - if (!this->wallet.node.network_params.network.publish_thresholds.validate_entry (*block_l)) + if (!this->wallet.node.network_params.work.validate_entry (*block_l)) { this->wallet.node.process_active (std::move (block_l)); } @@ -2241,7 +2241,7 @@ void nano_qt::block_creation::create_send () nano::block_details details; details.is_send = true; details.epoch = info.epoch (); - auto const required_difficulty{ wallet.node.network_params.network.publish_thresholds.threshold (send.work_version (), details) }; + auto const required_difficulty{ wallet.node.network_params.work.threshold (send.work_version (), details) }; if (wallet.node.work_generate_blocking (send, required_difficulty).is_initialized ()) { std::string block_l; @@ -2325,7 +2325,7 @@ void nano_qt::block_creation::create_receive () nano::block_details details; details.is_receive = true; details.epoch = std::max (info.epoch (), pending.epoch); - auto required_difficulty{ wallet.node.network_params.network.publish_thresholds.threshold (receive.work_version (), details) }; + auto required_difficulty{ wallet.node.network_params.work.threshold (receive.work_version (), details) }; if (wallet.node.work_generate_blocking (receive, required_difficulty).is_initialized ()) { std::string block_l; @@ -2408,7 +2408,7 @@ void nano_qt::block_creation::create_change () nano::state_block change (account_l, info.head, representative_l, info.balance, 0, key, account_l, 0); nano::block_details details; details.epoch = info.epoch (); - auto const required_difficulty{ wallet.node.network_params.network.publish_thresholds.threshold (change.work_version (), details) }; + auto const required_difficulty{ wallet.node.network_params.work.threshold (change.work_version (), details) }; if (wallet.node.work_generate_blocking (change, required_difficulty).is_initialized ()) { std::string block_l; @@ -2490,7 +2490,7 @@ void nano_qt::block_creation::create_open () nano::block_details details; details.is_receive = true; details.epoch = pending.epoch; - auto const required_difficulty{ wallet.node.network_params.network.publish_thresholds.threshold (open.work_version (), details) }; + auto const required_difficulty{ wallet.node.network_params.work.threshold (open.work_version (), details) }; if (wallet.node.work_generate_blocking (open, required_difficulty).is_initialized ()) { std::string block_l; diff --git a/nano/qt_test/qt.cpp b/nano/qt_test/qt.cpp index 33b1acc6..6ca12200 100644 --- a/nano/qt_test/qt.cpp +++ b/nano/qt_test/qt.cpp @@ -835,7 +835,7 @@ TEST (wallet, seed_work_generation) ASSERT_NO_ERROR (ec); } auto transaction (system.nodes[0]->store.tx_begin_read ()); - ASSERT_GE (nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, system.nodes[0]->ledger.latest_root (transaction, pub), work), system.nodes[0]->default_difficulty (nano::work_version::work_1)); + ASSERT_GE (nano::dev::network_params.work.difficulty (nano::work_version::work_1, system.nodes[0]->ledger.latest_root (transaction, pub), work), system.nodes[0]->default_difficulty (nano::work_version::work_1)); } TEST (wallet, backup_seed) diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 134757e8..4b4f070c 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -524,9 +524,9 @@ TEST (rpc, send_epoch_2) system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv, false); - auto target_difficulty = nano::dev::network_params.network.publish_thresholds.threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_2, true, false, false)); - ASSERT_LT (node->network_params.network.publish_thresholds.entry, target_difficulty); - auto min_difficulty = node->network_params.network.publish_thresholds.entry; + auto target_difficulty = nano::dev::network_params.work.threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_2, true, false, false)); + ASSERT_LT (node->network_params.work.entry, target_difficulty); + auto min_difficulty = node->network_params.work.entry; auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; @@ -1636,13 +1636,13 @@ TEST (rpc, process_ledger_insufficient_work) nano::system system; auto node = add_ipc_enabled_node (system); auto [rpc, rpc_ctx] = add_rpc (system, node); - ASSERT_LT (node->network_params.network.publish_thresholds.entry, node->network_params.network.publish_thresholds.epoch_1); + ASSERT_LT (node->network_params.work.entry, node->network_params.work.epoch_1); auto latest (node->latest (nano::dev::genesis_key.pub)); - auto min_difficulty = node->network_params.network.publish_thresholds.entry; - auto max_difficulty = node->network_params.network.publish_thresholds.epoch_1; + auto min_difficulty = node->network_params.work.entry; + auto max_difficulty = node->network_params.work.epoch_1; nano::state_block send (nano::dev::genesis->account (), latest, nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::Gxrb_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, system.work_generate_limited (latest, min_difficulty, max_difficulty)); - ASSERT_LT (nano::dev::network_params.network.publish_thresholds.difficulty (send), max_difficulty); - ASSERT_GE (nano::dev::network_params.network.publish_thresholds.difficulty (send), min_difficulty); + ASSERT_LT (nano::dev::network_params.work.difficulty (send), max_difficulty); + ASSERT_GE (nano::dev::network_params.work.difficulty (send), min_difficulty); boost::property_tree::ptree request; request.put ("action", "process"); std::string json; @@ -1949,7 +1949,7 @@ TEST (rpc, work_generate) auto work_text (response.json.get ("work")); uint64_t work; ASSERT_FALSE (nano::from_string_hex (work_text, work)); - auto result_difficulty (nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, hash, work)); + auto result_difficulty (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, work)); auto response_difficulty_text (response.json.get ("difficulty")); uint64_t response_difficulty; ASSERT_FALSE (nano::from_string_hex (response_difficulty_text, response_difficulty)); @@ -1980,7 +1980,7 @@ TEST (rpc, work_generate_difficulty) auto work_text (response.get ("work")); uint64_t work; ASSERT_FALSE (nano::from_string_hex (work_text, work)); - auto result_difficulty (nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, hash, work)); + auto result_difficulty (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, work)); auto response_difficulty_text (response.get ("difficulty")); uint64_t response_difficulty; ASSERT_FALSE (nano::from_string_hex (response_difficulty_text, response_difficulty)); @@ -1997,7 +1997,7 @@ TEST (rpc, work_generate_difficulty) auto work_text (response.get ("work")); uint64_t work; ASSERT_FALSE (nano::from_string_hex (work_text, work)); - auto result_difficulty (nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, hash, work)); + auto result_difficulty (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, work)); ASSERT_GE (result_difficulty, difficulty); } { @@ -2031,7 +2031,7 @@ TEST (rpc, work_generate_multiplier) ASSERT_TRUE (work_text.is_initialized ()); uint64_t work; ASSERT_FALSE (nano::from_string_hex (*work_text, work)); - auto result_difficulty (nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, hash, work)); + auto result_difficulty (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, work)); auto response_difficulty_text (response.get ("difficulty")); uint64_t response_difficulty; ASSERT_FALSE (nano::from_string_hex (response_difficulty_text, response_difficulty)); @@ -2062,7 +2062,7 @@ TEST (rpc, work_generate_block_high) nano::keypair key; nano::state_block block (key.pub, 0, nano::dev::genesis_key.pub, nano::Gxrb_ratio, 123, key.prv, key.pub, *node->work_generate_blocking (key.pub)); nano::block_hash hash (block.root ().as_block_hash ()); - auto block_difficulty (nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, hash, block.block_work ())); + auto block_difficulty (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, block.block_work ())); boost::property_tree::ptree request; request.put ("action", "work_generate"); request.put ("hash", hash.to_string ()); @@ -2087,7 +2087,7 @@ TEST (rpc, work_generate_block_low) auto threshold (node->default_difficulty (block.work_version ())); block.block_work_set (system.work_generate_limited (block.root ().as_block_hash (), threshold, nano::difficulty::from_multiplier (node->config.max_work_generate_multiplier / 10, threshold))); nano::block_hash hash (block.root ().as_block_hash ()); - auto block_difficulty (nano::dev::network_params.network.publish_thresholds.difficulty (block)); + auto block_difficulty (nano::dev::network_params.work.difficulty (block)); boost::property_tree::ptree request; request.put ("action", "work_generate"); request.put ("hash", hash.to_string ()); @@ -2103,7 +2103,7 @@ TEST (rpc, work_generate_block_low) uint64_t work; ASSERT_FALSE (nano::from_string_hex (*work_text, work)); ASSERT_NE (block.block_work (), work); - auto result_difficulty (nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, hash, work)); + auto result_difficulty (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, work)); auto response_difficulty_text (response.get ("difficulty")); uint64_t response_difficulty; ASSERT_FALSE (nano::from_string_hex (response_difficulty_text, response_difficulty)); @@ -2147,7 +2147,7 @@ TEST (rpc, work_generate_block_ledger_epoch_2) auto send_block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, nano::Gxrb_ratio)); ASSERT_NE (nullptr, send_block); nano::state_block block (key.pub, 0, nano::dev::genesis_key.pub, nano::Gxrb_ratio, send_block->hash (), key.prv, key.pub, 0); - auto threshold (nano::dev::network_params.network.publish_thresholds.threshold (block.work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false))); + auto threshold (nano::dev::network_params.work.threshold (block.work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false))); block.block_work_set (system.work_generate_limited (block.root ().as_block_hash (), 1, threshold - 1)); nano::block_hash hash (block.root ().as_block_hash ()); auto [rpc, rpc_ctx] = add_rpc (system, node); @@ -2167,13 +2167,13 @@ TEST (rpc, work_generate_block_ledger_epoch_2) ASSERT_TRUE (work_text.is_initialized ()); uint64_t work; ASSERT_FALSE (nano::from_string_hex (*work_text, work)); - auto result_difficulty (nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, hash, work)); + auto result_difficulty (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, work)); auto response_difficulty_text (response.get ("difficulty")); uint64_t response_difficulty; ASSERT_FALSE (nano::from_string_hex (response_difficulty_text, response_difficulty)); ASSERT_EQ (result_difficulty, response_difficulty); - ASSERT_GE (result_difficulty, node->network_params.network.publish_thresholds.epoch_2_receive); - finished = result_difficulty < node->network_params.network.publish_thresholds.epoch_1; + ASSERT_GE (result_difficulty, node->network_params.work.epoch_2_receive); + finished = result_difficulty < node->network_params.work.epoch_1; ASSERT_LT (++iteration, 200); } } @@ -2191,7 +2191,7 @@ TEST (rpc, work_cancel) system.deadline_set (10s); while (!done) { - system.work.generate (nano::work_version::work_1, hash1, node1->network_params.network.publish_thresholds.base, [&done] (boost::optional work_a) { + system.work.generate (nano::work_version::work_1, hash1, node1->network_params.work.base, [&done] (boost::optional work_a) { done = !work_a; }); auto response1 (wait_response (system, rpc, request1)); @@ -2211,11 +2211,11 @@ TEST (rpc, work_peer_bad) auto [rpc, rpc_ctx] = add_rpc (system, node1); nano::block_hash hash1 (1); std::atomic work (0); - node2.work_generate (nano::work_version::work_1, hash1, node2.network_params.network.publish_thresholds.base, [&work] (boost::optional work_a) { + node2.work_generate (nano::work_version::work_1, hash1, node2.network_params.work.base, [&work] (boost::optional work_a) { ASSERT_TRUE (work_a.is_initialized ()); work = *work_a; }); - ASSERT_TIMELY (5s, nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, hash1, work) >= nano::dev::network_params.network.publish_thresholds.threshold_base (nano::work_version::work_1)); + ASSERT_TIMELY (5s, nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash1, work) >= nano::dev::network_params.work.threshold_base (nano::work_version::work_1)); } TEST (rpc, work_peer_one) @@ -2227,11 +2227,11 @@ TEST (rpc, work_peer_one) node2.config.work_peers.push_back (std::make_pair (node1->network.endpoint ().address ().to_string (), rpc->config.port)); nano::keypair key1; std::atomic work (0); - node2.work_generate (nano::work_version::work_1, key1.pub, node1->network_params.network.publish_thresholds.base, [&work] (boost::optional work_a) { + node2.work_generate (nano::work_version::work_1, key1.pub, node1->network_params.work.base, [&work] (boost::optional work_a) { ASSERT_TRUE (work_a.is_initialized ()); work = *work_a; }); - ASSERT_TIMELY (5s, nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, key1.pub, work) >= nano::dev::network_params.network.publish_thresholds.threshold_base (nano::work_version::work_1)); + ASSERT_TIMELY (5s, nano::dev::network_params.work.difficulty (nano::work_version::work_1, key1.pub, work) >= nano::dev::network_params.work.threshold_base (nano::work_version::work_1)); } TEST (rpc, work_peer_many) @@ -2255,10 +2255,10 @@ TEST (rpc, work_peer_many) for (auto i (0); i < works.size (); ++i) { nano::keypair key1; - node1.work_generate (nano::work_version::work_1, key1.pub, node1.network_params.network.publish_thresholds.base, [&work = works[i]] (boost::optional work_a) { + node1.work_generate (nano::work_version::work_1, key1.pub, node1.network_params.work.base, [&work = works[i]] (boost::optional work_a) { work = *work_a; }); - while (nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, key1.pub, works[i]) < nano::dev::network_params.network.publish_thresholds.threshold_base (nano::work_version::work_1)) + while (nano::dev::network_params.work.difficulty (nano::work_version::work_1, key1.pub, works[i]) < nano::dev::network_params.work.threshold_base (nano::work_version::work_1)) { system1.poll (); system2.poll (); @@ -2542,9 +2542,9 @@ TEST (rpc, account_representative_set_epoch_2) system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv, false); - auto target_difficulty = nano::dev::network_params.network.publish_thresholds.threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_2, false, false, false)); - ASSERT_LT (node->network_params.network.publish_thresholds.entry, target_difficulty); - auto min_difficulty = node->network_params.network.publish_thresholds.entry; + auto target_difficulty = nano::dev::network_params.work.threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_2, false, false, false)); + ASSERT_LT (node->network_params.work.entry, target_difficulty); + auto min_difficulty = node->network_params.work.entry; auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; @@ -2744,7 +2744,7 @@ TEST (rpc, work_validate) double multiplier (response.get ("multiplier")); ASSERT_NEAR (multiplier, nano::difficulty::to_multiplier (difficulty, node1->default_difficulty (nano::work_version::work_1)), 1e-6); } - auto result_difficulty (nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, hash, work1)); + auto result_difficulty (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, work1)); ASSERT_GE (result_difficulty, node1->default_difficulty (nano::work_version::work_1)); request.put ("work", nano::to_string_hex (work1)); request.put ("difficulty", nano::to_string_hex (result_difficulty)); @@ -2761,7 +2761,7 @@ TEST (rpc, work_validate) auto response (wait_response (system, rpc, request)); ASSERT_EQ (result_difficulty >= difficulty4, response.get ("valid")); ASSERT_EQ (result_difficulty >= node1->default_difficulty (nano::work_version::work_1), response.get ("valid_all")); - ASSERT_EQ (result_difficulty >= node1->network_params.network.publish_thresholds.epoch_2_receive, response.get ("valid_all")); + ASSERT_EQ (result_difficulty >= node1->network_params.work.epoch_2_receive, response.get ("valid_all")); } uint64_t work3 (*node1->work_generate_blocking (hash, difficulty4)); request.put ("work", nano::to_string_hex (work3)); @@ -2779,8 +2779,8 @@ TEST (rpc, work_validate_epoch_2) auto node = add_ipc_enabled_node (system); auto epoch1 = system.upgrade_genesis_epoch (*node, nano::epoch::epoch_1); ASSERT_NE (nullptr, epoch1); - ASSERT_EQ (node->network_params.network.publish_thresholds.epoch_2, node->network_params.network.publish_thresholds.base); - auto work = system.work_generate_limited (epoch1->hash (), node->network_params.network.publish_thresholds.epoch_1, node->network_params.network.publish_thresholds.base); + ASSERT_EQ (node->network_params.work.epoch_2, node->network_params.work.base); + auto work = system.work_generate_limited (epoch1->hash (), node->network_params.work.epoch_1, node->network_params.work.base); auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "work_validate"); @@ -2795,7 +2795,7 @@ TEST (rpc, work_validate_epoch_2) uint64_t difficulty{ 0 }; ASSERT_FALSE (nano::from_string_hex (difficulty_text, difficulty)); double multiplier (response.get ("multiplier")); - ASSERT_NEAR (multiplier, nano::difficulty::to_multiplier (difficulty, node->network_params.network.publish_thresholds.epoch_2), 1e-6); + ASSERT_NEAR (multiplier, nano::difficulty::to_multiplier (difficulty, node->network_params.work.epoch_2), 1e-6); }; // After upgrading, the higher difficulty is used to validate and calculate the multiplier rpc_ctx->io_scope->reset (); @@ -4228,7 +4228,7 @@ TEST (rpc, block_create) std::string send_hash (response.get ("hash")); ASSERT_EQ (send.hash ().to_string (), send_hash); std::string send_difficulty (response.get ("difficulty")); - ASSERT_EQ (nano::to_string_hex (nano::dev::network_params.network.publish_thresholds.difficulty (send)), send_difficulty); + ASSERT_EQ (nano::to_string_hex (nano::dev::network_params.work.difficulty (send)), send_difficulty); auto send_text (response.get ("block")); boost::property_tree::ptree block_l; std::stringstream block_stream (send_text); @@ -4360,8 +4360,8 @@ TEST (rpc, block_create_state_open) ASSERT_NE (nullptr, state_block); ASSERT_EQ (nano::block_type::state, state_block->type ()); ASSERT_EQ (state_hash, state_block->hash ().to_string ()); - auto difficulty (nano::dev::network_params.network.publish_thresholds.difficulty (*state_block)); - ASSERT_GT (difficulty, nano::dev::network_params.network.publish_thresholds.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_0, false, true, false))); + auto difficulty (nano::dev::network_params.work.difficulty (*state_block)); + ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_0, false, true, false))); ASSERT_TRUE (node->latest (key.pub).is_zero ()); rpc_ctx->io_scope->reset (); auto process_result (node->process (*state_block)); @@ -4406,7 +4406,7 @@ TEST (rpc, block_create_state_request_work) boost::property_tree::read_json (block_stream, block_l); auto block (nano::deserialize_block_json (block_l)); ASSERT_NE (nullptr, block); - ASSERT_GE (nano::dev::network_params.network.publish_thresholds.difficulty (*block), node->default_difficulty (nano::work_version::work_1)); + ASSERT_GE (nano::dev::network_params.work.difficulty (*block), node->default_difficulty (nano::work_version::work_1)); } } @@ -4440,8 +4440,8 @@ TEST (rpc, block_create_open_epoch_v2) ASSERT_NE (nullptr, state_block); ASSERT_EQ (nano::block_type::state, state_block->type ()); ASSERT_EQ (state_hash, state_block->hash ().to_string ()); - auto difficulty (nano::dev::network_params.network.publish_thresholds.difficulty (*state_block)); - ASSERT_GT (difficulty, nano::dev::network_params.network.publish_thresholds.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false))); + auto difficulty (nano::dev::network_params.work.difficulty (*state_block)); + ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false))); ASSERT_TRUE (node->latest (key.pub).is_zero ()); rpc_ctx->io_scope->reset (); auto process_result (node->process (*state_block)); @@ -4484,8 +4484,8 @@ TEST (rpc, block_create_receive_epoch_v2) ASSERT_NE (nullptr, state_block); ASSERT_EQ (nano::block_type::state, state_block->type ()); ASSERT_EQ (state_hash, state_block->hash ().to_string ()); - auto difficulty (nano::dev::network_params.network.publish_thresholds.difficulty (*state_block)); - ASSERT_GT (difficulty, nano::dev::network_params.network.publish_thresholds.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false))); + auto difficulty (nano::dev::network_params.work.difficulty (*state_block)); + ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false))); rpc_ctx->io_scope->reset (); auto process_result (node->process (*state_block)); ASSERT_EQ (nano::process_result::progress, process_result.code); @@ -4526,8 +4526,8 @@ TEST (rpc, block_create_send_epoch_v2) ASSERT_NE (nullptr, state_block); ASSERT_EQ (nano::block_type::state, state_block->type ()); ASSERT_EQ (state_hash, state_block->hash ().to_string ()); - auto difficulty (nano::dev::network_params.network.publish_thresholds.difficulty (*state_block)); - ASSERT_GT (difficulty, nano::dev::network_params.network.publish_thresholds.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, true, false, false))); + auto difficulty (nano::dev::network_params.work.difficulty (*state_block)); + ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, true, false, false))); rpc_ctx->io_scope->reset (); auto process_result (node->process (*state_block)); ASSERT_EQ (nano::process_result::progress, process_result.code); @@ -5450,7 +5450,7 @@ TEST (rpc, active_difficulty) nano::system system; auto node = add_ipc_enabled_node (system); auto [rpc, rpc_ctx] = add_rpc (system, node); - ASSERT_EQ (node->default_difficulty (nano::work_version::work_1), node->network_params.network.publish_thresholds.epoch_2); + ASSERT_EQ (node->default_difficulty (nano::work_version::work_1), node->network_params.work.epoch_2); boost::property_tree::ptree request; request.put ("action", "active_difficulty"); auto expected_multiplier{ 1.0 }; @@ -5474,7 +5474,7 @@ TEST (rpc, active_difficulty) uint64_t network_receive_current; ASSERT_FALSE (nano::from_string_hex (network_receive_current_text, network_receive_current)); auto network_receive_current_multiplier (nano::difficulty::to_multiplier (network_receive_current, network_receive_minimum)); - auto network_receive_current_normalized_multiplier (nano::dev::network_params.network.publish_thresholds.normalized_multiplier (network_receive_current_multiplier, network_receive_minimum)); + auto network_receive_current_normalized_multiplier (nano::dev::network_params.work.normalized_multiplier (network_receive_current_multiplier, network_receive_minimum)); ASSERT_NEAR (network_receive_current_normalized_multiplier, multiplier, 1e-6); ASSERT_EQ (response.not_found (), response.find ("difficulty_trend")); } diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp index 2cac2130..95d52d5b 100644 --- a/nano/secure/common.cpp +++ b/nano/secure/common.cpp @@ -86,7 +86,13 @@ nano::ledger_constants & nano::dev::constants{ nano::dev::network_params.ledger std::shared_ptr & nano::dev::genesis = nano::dev::constants.genesis; nano::network_params::network_params (nano::networks network_a) : - network (network_a), ledger (network.publish_thresholds, network.network ()), voting (network), node (network), portmapping (network), bootstrap (network) + work{ network_a == nano::networks::nano_live_network ? nano::work_thresholds::publish_full : network_a == nano::networks::nano_beta_network ? nano::work_thresholds::publish_beta : network_a == nano::networks::nano_test_network ? nano::work_thresholds::publish_test : nano::work_thresholds::publish_dev }, + network{ work, network_a }, + ledger{ work, network_a }, + voting{ network }, + node{ network }, + portmapping{ network }, + bootstrap{ network } { unsigned constexpr kdf_full_work = 64 * 1024; unsigned constexpr kdf_dev_work = 8; diff --git a/nano/secure/common.hpp b/nano/secure/common.hpp index dbbf982d..10c678c9 100644 --- a/nano/secure/common.hpp +++ b/nano/secure/common.hpp @@ -439,13 +439,14 @@ public: network_params (nano::networks network_a); unsigned kdf_work; - network_constants network; - ledger_constants ledger; - random_constants random; - voting_constants voting; - node_constants node; - portmapping_constants portmapping; - bootstrap_constants bootstrap; + nano::work_thresholds work; + nano::network_constants network; + nano::ledger_constants ledger; + nano::random_constants random; + nano::voting_constants voting; + nano::node_constants node; + nano::portmapping_constants portmapping; + nano::bootstrap_constants bootstrap; }; enum class confirmation_height_mode diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp index 22b5fb9b..1af73d1e 100644 --- a/nano/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -1609,7 +1609,7 @@ TEST (node, mass_epoch_upgrader) .link (info.key.pub) .representative (nano::dev::genesis_key.pub) .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) - .work (*node.work_generate_blocking (latest, nano::dev::network_params.network.publish_thresholds.threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_0, false, false, false)))) + .work (*node.work_generate_blocking (latest, node_config.network_params.work.threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_0, false, false, false)))) .build (ec); ASSERT_FALSE (ec); ASSERT_NE (nullptr, block); @@ -1633,7 +1633,7 @@ TEST (node, mass_epoch_upgrader) .link (info.pending_hash) .representative (info.key.pub) .sign (info.key.prv, info.key.pub) - .work (*node.work_generate_blocking (info.key.pub, nano::dev::network_params.network.publish_thresholds.threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_0, false, false, false)))) + .work (*node.work_generate_blocking (info.key.pub, node_config.network_params.work.threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_0, false, false, false)))) .build (ec); ASSERT_FALSE (ec); ASSERT_NE (nullptr, block); @@ -1723,7 +1723,7 @@ TEST (node, mass_block_new) std::vector keys (num_blocks); nano::state_block_builder builder; std::vector> send_blocks; - auto send_threshold (nano::dev::network_params.network.publish_thresholds.threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_2, true, false, false))); + auto send_threshold (nano::dev::network_params.work.threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_2, true, false, false))); auto latest_genesis = node.latest (nano::dev::genesis_key.pub); for (auto i = 0; i < num_blocks; ++i) { @@ -1746,7 +1746,7 @@ TEST (node, mass_block_new) std::cout << "Send blocks time: " << timer.stop ().count () << " " << timer.unit () << "\n\n"; std::vector> open_blocks; - auto receive_threshold (nano::dev::network_params.network.publish_thresholds.threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_2, false, true, false))); + auto receive_threshold (nano::dev::network_params.work.threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_2, false, true, false))); for (auto i = 0; i < num_blocks; ++i) { auto const & key = keys[i]; diff --git a/nano/test_common/system.cpp b/nano/test_common/system.cpp index 24fd99e1..170ba9d3 100644 --- a/nano/test_common/system.cpp +++ b/nano/test_common/system.cpp @@ -205,7 +205,7 @@ uint64_t nano::system::work_generate_limited (nano::block_hash const & root_a, u do { result = *work.generate (root_a, min_a); - } while (work.network_constants.publish_thresholds.difficulty (nano::work_version::work_1, root_a, result) >= max_a); + } while (work.network_constants.work.difficulty (nano::work_version::work_1, root_a, result) >= max_a); return result; } @@ -226,7 +226,7 @@ std::unique_ptr nano::upgrade_epoch (nano::work_pool & pool_a .link (ledger_a.epoch_link (epoch_a)) .representative (dev_genesis_key.pub) .sign (dev_genesis_key.prv, dev_genesis_key.pub) - .work (*pool_a.generate (latest, pool_a.network_constants.publish_thresholds.threshold (nano::work_version::work_1, nano::block_details (epoch_a, false, false, true)))) + .work (*pool_a.generate (latest, pool_a.network_constants.work.threshold (nano::work_version::work_1, nano::block_details (epoch_a, false, false, true)))) .build (ec); bool error{ true };