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

Moving work_difficulty free function on to work_thresholds class.

Browse source
This commit is contained in:
clemahieu 2021-08-08 23:55:00 +01:00
commit 243a4d93dd
No known key found for this signature in database
GPG key ID: 43708520C8DFB938
19 changed files with 63 additions and 61 deletions
Download patch file Download diff file Expand all files Collapse all files

2
nano/core_test/block.cpp
View file

@ -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)

10
nano/core_test/distributed_work.cpp
View file

@ -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);
}

3
nano/core_test/fakes/work_peer.hpp
View file

@ -146,7 +146,8 @@ private:
auto this_l (shared_from_this ());
work_pool.generate (version, hash, request_difficulty, [this_l, hash] (boost::optional<uint64_t> 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));

8
nano/core_test/node.cpp
View file

@ -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);
}
}

2
nano/core_test/system.cpp
View file

@ -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);
}

8
nano/core_test/wallet.cpp
View file

@ -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)

8
nano/core_test/work_pool.cpp
View file

@ -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);
}

3
nano/lib/blocks.cpp
View file

@ -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

14
nano/lib/config.cpp
View file

@ -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.";

1
nano/lib/config.hpp
View file

@ -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;

17
nano/lib/work.cpp
View file

@ -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<boost::optional<uint64_t> (nano::work_version const, nano::root const &, uint64_t, std::atomic<int> &)> opencl_a) :

2
nano/lib/work.hpp
View file

@ -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
{

2
nano/node/distributed_work.cpp
View file

@ -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;

10
nano/node/json_handler.cpp
View file

@ -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");

3
nano/node/openclwork.cpp
View file

@ -455,7 +455,8 @@ boost::optional<uint64_t> 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);

2
nano/node/websocket.cpp
View file

@ -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));

2
nano/qt_test/qt.cpp
View file

@ -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)

22
nano/rpc_test/rpc.cpp
View file

@ -1949,7 +1949,7 @@ TEST (rpc, work_generate)
auto work_text (response.json.get<std::string> ("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<std::string> ("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<std::string> ("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<std::string> ("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<std::string> ("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<std::string> ("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<std::string> ("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<std::string> ("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<uint64_t> 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<double> ("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));

5
nano/test_common/system.cpp
View file

@ -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::state_block> 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)