From 243a4d93dd4048e45dd4be9dfe502eb6d80c23b8 Mon Sep 17 00:00:00 2001 From: clemahieu Date: Sun, 8 Aug 2021 23:55:00 +0100 Subject: [PATCH] Moving work_difficulty free function on to work_thresholds class. --- nano/core_test/block.cpp | 2 +- nano/core_test/distributed_work.cpp | 10 +++++----- nano/core_test/fakes/work_peer.hpp | 3 ++- nano/core_test/node.cpp | 8 ++++---- nano/core_test/system.cpp | 2 +- nano/core_test/wallet.cpp | 8 ++++---- nano/core_test/work_pool.cpp | 8 ++++---- nano/lib/blocks.cpp | 3 ++- nano/lib/config.cpp | 14 ++++++++++++++ nano/lib/config.hpp | 1 + nano/lib/work.cpp | 17 +---------------- nano/lib/work.hpp | 2 -- nano/node/distributed_work.cpp | 2 +- nano/node/json_handler.cpp | 10 +++++----- nano/node/openclwork.cpp | 3 ++- nano/node/websocket.cpp | 2 +- nano/qt_test/qt.cpp | 2 +- nano/rpc_test/rpc.cpp | 22 +++++++++++----------- nano/test_common/system.cpp | 5 +++-- 19 files changed, 63 insertions(+), 61 deletions(-) diff --git a/nano/core_test/block.cpp b/nano/core_test/block.cpp index 83275798..ead77f0c 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 (block.difficulty (), nano::work_difficulty (block.work_version (), block.root (), block.block_work ())); + ASSERT_EQ (block.difficulty (), nano::dev::network_params.network.publish_thresholds.difficulty (block.work_version (), block.root (), block.block_work ())); } TEST (state_block, serialization) diff --git a/nano/core_test/distributed_work.cpp b/nano/core_test/distributed_work.cpp index 9cf30333..8c3a6701 100644 --- a/nano/core_test/distributed_work.cpp +++ b/nano/core_test/distributed_work.cpp @@ -27,7 +27,7 @@ TEST (distributed_work, no_peers) }; 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_TIMELY (5s, done); - ASSERT_GE (nano::work_difficulty (nano::work_version::work_1, hash, *work), node->network_params.network.publish_thresholds.base); + ASSERT_GE (nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, hash, *work), node->network_params.network.publish_thresholds.base); // should only be removed after cleanup ASSERT_EQ (1, node->distributed_work.size ()); while (node->distributed_work.size () > 0) @@ -138,7 +138,7 @@ TEST (distributed_work, peer) 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_TIMELY (5s, done); - ASSERT_GE (nano::work_difficulty (nano::work_version::work_1, hash, *work), node->network_params.network.publish_thresholds.base); + 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_EQ (1, work_peer->generations_good); ASSERT_EQ (0, work_peer->generations_bad); ASSERT_NO_ERROR (system.poll ()); @@ -164,7 +164,7 @@ TEST (distributed_work, peer_malicious) 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_TIMELY (5s, done); - ASSERT_GE (nano::work_difficulty (nano::work_version::work_1, hash, *work), node->network_params.network.publish_thresholds.base); + 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_TIMELY (5s, malicious_peer->generations_bad >= 1); // make sure it was *not* the malicious peer that replied ASSERT_EQ (0, malicious_peer->generations_good); @@ -210,7 +210,7 @@ TEST (distributed_work, peer_multi) 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_TIMELY (5s, done); - ASSERT_GE (nano::work_difficulty (nano::work_version::work_1, hash, *work), node->network_params.network.publish_thresholds.base); + 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_TIMELY (5s, slow_peer->cancels == 1); ASSERT_EQ (0, malicious_peer->generations_good); ASSERT_EQ (1, malicious_peer->generations_bad); @@ -241,5 +241,5 @@ TEST (distributed_work, fail_resolve) 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_TIMELY (5s, done); - ASSERT_GE (nano::work_difficulty (nano::work_version::work_1, hash, *work), node->network_params.network.publish_thresholds.base); + ASSERT_GE (nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, hash, *work), node->network_params.network.publish_thresholds.base); } diff --git a/nano/core_test/fakes/work_peer.hpp b/nano/core_test/fakes/work_peer.hpp index 4e03504e..82a64e97 100644 --- a/nano/core_test/fakes/work_peer.hpp +++ b/nano/core_test/fakes/work_peer.hpp @@ -146,7 +146,8 @@ private: auto this_l (shared_from_this ()); work_pool.generate (version, hash, request_difficulty, [this_l, hash] (boost::optional work_a) { auto result = work_a.value_or (0); - auto result_difficulty (nano::work_difficulty (this_l->version, hash, result)); + static nano::network_constants constants; + auto result_difficulty (constants.publish_thresholds.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)); diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index d69f1e18..8a03fa97 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -39,7 +39,7 @@ TEST (node, work_generate) auto difficulty = nano::difficulty::from_multiplier (1.5, node.network_params.network.publish_thresholds.base); auto work = node.work_generate_blocking (version, root, difficulty); ASSERT_TRUE (work.is_initialized ()); - ASSERT_TRUE (nano::work_difficulty (version, root, *work) >= difficulty); + ASSERT_TRUE (nano::dev::network_params.network.publish_thresholds.difficulty (version, root, *work) >= difficulty); } { auto difficulty = nano::difficulty::from_multiplier (0.5, node.network_params.network.publish_thresholds.base); @@ -47,10 +47,10 @@ TEST (node, work_generate) do { work = node.work_generate_blocking (version, root, difficulty); - } while (nano::work_difficulty (version, root, *work) >= node.network_params.network.publish_thresholds.base); + } while (nano::dev::network_params.network.publish_thresholds.difficulty (version, root, *work) >= node.network_params.network.publish_thresholds.base); ASSERT_TRUE (work.is_initialized ()); - ASSERT_TRUE (nano::work_difficulty (version, root, *work) >= difficulty); - ASSERT_FALSE (nano::work_difficulty (version, root, *work) >= node.network_params.network.publish_thresholds.base); + 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); } } diff --git a/nano/core_test/system.cpp b/nano/core_test/system.cpp index 7ea6dd7d..c084d955 100644 --- a/nano/core_test/system.cpp +++ b/nano/core_test/system.cpp @@ -15,7 +15,7 @@ TEST (system, work_generate_limited) for (int i = 0; i < 5; ++i) { auto work = system.work_generate_limited (key, min, max); - auto difficulty = nano::work_difficulty (nano::work_version::work_1, key, work); + auto difficulty = nano::dev::network_params.network.publish_thresholds.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 0548e7b7..0c0a463e 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::work_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.network.publish_thresholds.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::work_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.network.publish_thresholds.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::work_difficulty (nano::work_version::work_1, block2->hash (), work1) < threshold; + again = nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, block2->hash (), work1) < threshold; } } - ASSERT_GE (nano::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); } TEST (wallet, insert_locked) diff --git a/nano/core_test/work_pool.cpp b/nano/core_test/work_pool.cpp index 22328873..6c18ac48 100644 --- a/nano/core_test/work_pool.cpp +++ b/nano/core_test/work_pool.cpp @@ -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::work_difficulty (nano::work_version::work_1, root, result), difficulty); + ASSERT_GE (nano::dev::network_params.network.publish_thresholds.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::work_difficulty (nano::work_version::work_1, root, work1); + result_difficulty1 = nano::dev::network_params.network.publish_thresholds.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::work_difficulty (nano::work_version::work_1, root, work2); + result_difficulty2 = nano::dev::network_params.network.publish_thresholds.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::work_difficulty (nano::work_version::work_1, root, work); + result_difficulty = nano::dev::network_params.network.publish_thresholds.difficulty (nano::work_version::work_1, root, work); } while (result_difficulty > difficulty2); ASSERT_GT (result_difficulty, difficulty1); } diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index 4515b78d..b803bfa2 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -85,7 +85,8 @@ nano::work_version nano::block::work_version () const uint64_t nano::block::difficulty () const { - return nano::work_difficulty (this->work_version (), this->root (), this->block_work ()); + static nano::network_constants constants; + return constants.publish_thresholds.difficulty (this->work_version (), this->root (), this->block_work ()); } nano::block_hash nano::block::generate_hash () const diff --git a/nano/lib/config.cpp b/nano/lib/config.cpp index ca7e95a7..2470d457 100644 --- a/nano/lib/config.cpp +++ b/nano/lib/config.cpp @@ -180,6 +180,20 @@ uint64_t nano::work_thresholds::threshold_base (nano::work_version const version return result; } +uint64_t nano::work_thresholds::difficulty (nano::work_version const version_a, nano::root const & root_a, uint64_t const work_a) +{ + uint64_t result{ 0 }; + switch (version_a) + { + case nano::work_version::work_1: + result = value (root_a, work_a); + break; + default: + debug_assert (false && "Invalid version specified to work_difficulty"); + } + return result; +} + namespace nano { const char * network_constants::active_network_err_msg = "Invalid network. Valid values are live, test, beta and dev."; diff --git a/nano/lib/config.hpp b/nano/lib/config.hpp index 50cea18c..2629bd0b 100644 --- a/nano/lib/config.hpp +++ b/nano/lib/config.hpp @@ -118,6 +118,7 @@ public: uint64_t value (nano::root const & root_a, uint64_t work_a); double normalized_multiplier (double const, uint64_t const); double denormalized_multiplier (double const, uint64_t const); + uint64_t difficulty (nano::work_version const, nano::root const &, uint64_t const); /** Network work thresholds. Define these inline as constexpr when moving to cpp17. */ static const nano::work_thresholds publish_full; diff --git a/nano/lib/work.cpp b/nano/lib/work.cpp index 0fcd7524..c5079972 100644 --- a/nano/lib/work.cpp +++ b/nano/lib/work.cpp @@ -31,22 +31,7 @@ bool nano::work_validate_entry (nano::block const & block_a) bool nano::work_validate_entry (nano::work_version const version_a, nano::root const & root_a, uint64_t const work_a) { static nano::network_constants network_constants; - return nano::work_difficulty (version_a, root_a, work_a) < network_constants.publish_thresholds.threshold_entry (version_a, nano::block_type::state); -} - -uint64_t nano::work_difficulty (nano::work_version const version_a, nano::root const & root_a, uint64_t const work_a) -{ - static nano::network_constants network_constants; - uint64_t result{ 0 }; - switch (version_a) - { - case nano::work_version::work_1: - result = network_constants.publish_thresholds.value (root_a, work_a); - break; - default: - debug_assert (false && "Invalid version specified to work_difficulty"); - } - return result; + return network_constants.publish_thresholds.difficulty (version_a, root_a, work_a) < network_constants.publish_thresholds.threshold_entry (version_a, nano::block_type::state); } nano::work_pool::work_pool (nano::network_constants & network_constants, unsigned max_threads_a, std::chrono::nanoseconds pow_rate_limiter_a, std::function (nano::work_version const, nano::root const &, uint64_t, std::atomic &)> opencl_a) : diff --git a/nano/lib/work.hpp b/nano/lib/work.hpp index 7b3599de..d97c9b20 100644 --- a/nano/lib/work.hpp +++ b/nano/lib/work.hpp @@ -21,8 +21,6 @@ enum class block_type : uint8_t; bool work_validate_entry (nano::block const &); bool work_validate_entry (nano::work_version const, nano::root const &, uint64_t const); -uint64_t work_difficulty (nano::work_version const, nano::root const &, uint64_t const); - class opencl_work; class work_item final { diff --git a/nano/node/distributed_work.cpp b/nano/node/distributed_work.cpp index 540459d6..f06ef17e 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::work_difficulty (request.version, request.root, work) >= request.difficulty) + if (nano::dev::network_params.network.publish_thresholds.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 25ce7901..068ce851 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -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 (nano::work_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.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)) { rpc_l->ec = nano::error_common::invalid_work; } @@ -3284,7 +3284,7 @@ void nano::json_handler::receive () head = account; } nano::block_details details (epoch, false, true, false); - if (nano::work_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.network.publish_thresholds.difficulty (nano::work_version::work_1, head, work) < node.network_params.network.publish_thresholds.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 (nano::work_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.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)) { ec = nano::error_common::invalid_work; } @@ -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 (nano::work_difficulty (work_version, hash, work)); + auto result_difficulty (rpc_l->node.network_params.network.publish_thresholds.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,7 +5045,7 @@ 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 (nano::work_difficulty (work_version, hash, work)); + auto result_difficulty (node.network_params.network.publish_thresholds.difficulty (work_version, hash, work)); if (request.count ("difficulty")) { response_l.put ("valid", (result_difficulty >= difficulty) ? "1" : "0"); diff --git a/nano/node/openclwork.cpp b/nano/node/openclwork.cpp index 755c476a..48a3ed8d 100644 --- a/nano/node/openclwork.cpp +++ b/nano/node/openclwork.cpp @@ -455,7 +455,8 @@ boost::optional nano::opencl_work::generate_work (nano::work_version c uint64_t result (0); unsigned thread_count (config.threads); size_t work_size[] = { thread_count, 0, 0 }; - while (nano::work_difficulty (version_a, root_a, result) < difficulty_a && !error && ticket_a == ticket_l) + static nano::network_constants constants; + while (constants.publish_thresholds.difficulty (version_a, root_a, result) < difficulty_a && !error && ticket_a == ticket_l) { result = rand.next (); cl_int write_error1 = clEnqueueWriteBuffer (queue, attempt_buffer, false, 0, sizeof (uint64_t), &result, 0, nullptr, nullptr); diff --git a/nano/node/websocket.cpp b/nano/node/websocket.cpp index 84d701b6..f99f7f2d 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::work_difficulty (version_a, root_a, work_a)); + auto result_difficulty_l (nano::dev::network_params.network.publish_thresholds.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_test/qt.cpp b/nano/qt_test/qt.cpp index bbadd1ca..33b1acc6 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::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)); + 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)); } TEST (wallet, backup_seed) diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 985ecdbe..49d7b82f 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -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::work_difficulty (nano::work_version::work_1, hash, work)); + auto result_difficulty (nano::dev::network_params.network.publish_thresholds.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::work_difficulty (nano::work_version::work_1, hash, work)); + auto result_difficulty (nano::dev::network_params.network.publish_thresholds.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::work_difficulty (nano::work_version::work_1, hash, work)); + auto result_difficulty (nano::dev::network_params.network.publish_thresholds.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::work_difficulty (nano::work_version::work_1, hash, work)); + auto result_difficulty (nano::dev::network_params.network.publish_thresholds.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::work_difficulty (nano::work_version::work_1, hash, block.block_work ())); + auto block_difficulty (nano::dev::network_params.network.publish_thresholds.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 ()); @@ -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::work_difficulty (nano::work_version::work_1, hash, work)); + auto result_difficulty (nano::dev::network_params.network.publish_thresholds.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)); @@ -2167,7 +2167,7 @@ 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::work_difficulty (nano::work_version::work_1, hash, work)); + auto result_difficulty (nano::dev::network_params.network.publish_thresholds.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)); @@ -2215,7 +2215,7 @@ TEST (rpc, work_peer_bad) ASSERT_TRUE (work_a.is_initialized ()); work = *work_a; }); - ASSERT_TIMELY (5s, nano::work_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.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)); } TEST (rpc, work_peer_one) @@ -2231,7 +2231,7 @@ TEST (rpc, work_peer_one) ASSERT_TRUE (work_a.is_initialized ()); work = *work_a; }); - ASSERT_TIMELY (5s, nano::work_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.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)); } TEST (rpc, work_peer_many) @@ -2258,7 +2258,7 @@ TEST (rpc, work_peer_many) node1.work_generate (nano::work_version::work_1, key1.pub, node1.network_params.network.publish_thresholds.base, [&work = works[i]] (boost::optional work_a) { work = *work_a; }); - while (nano::work_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.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)) { system1.poll (); system2.poll (); @@ -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::work_difficulty (nano::work_version::work_1, hash, work1)); + auto result_difficulty (nano::dev::network_params.network.publish_thresholds.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)); diff --git a/nano/test_common/system.cpp b/nano/test_common/system.cpp index c38af4fb..ecc4623e 100644 --- a/nano/test_common/system.cpp +++ b/nano/test_common/system.cpp @@ -202,10 +202,11 @@ uint64_t nano::system::work_generate_limited (nano::block_hash const & root_a, u { debug_assert (min_a > 0); uint64_t result = 0; + static nano::network_constants constants; do { result = *work.generate (root_a, min_a); - } while (nano::work_difficulty (nano::work_version::work_1, root_a, result) >= max_a); + } while (constants.publish_thresholds.difficulty (nano::work_version::work_1, root_a, result) >= max_a); return result; } @@ -219,7 +220,7 @@ std::unique_ptr nano::upgrade_epoch (nano::work_pool & pool_a nano::state_block_builder builder; std::error_code ec; - nano::network_constants constants; + static nano::network_constants constants; auto epoch = builder .account (dev_genesis_key.pub) .previous (latest)