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

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.

Browse source
This commit is contained in:
clemahieu 2021-08-10 23:10:10 +01:00
commit 54fb102b9f
No known key found for this signature in database
GPG key ID: 43708520C8DFB938
32 changed files with 208 additions and 201 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 (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)

28
nano/core_test/difficulty.cpp
View file

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

34
nano/core_test/distributed_work.cpp
View file

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

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

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

4
nano/core_test/ledger.cpp
View file

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

6
nano/core_test/network.cpp
View file

@ -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<nano::send_block> (block1->hash (), 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.network.publish_thresholds.epoch_2_receive, node1.network_params.network.publish_thresholds.epoch_1 - 1)));
auto block2 (std::make_shared<nano::send_block> (block1->hash (), 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.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<nano::send_block> (block2->hash (), 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (block2->hash (), node1.network_params.network.publish_thresholds.epoch_2)));
auto block3 (std::make_shared<nano::send_block> (block2->hash (), 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (block2->hash (), node1.network_params.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::state_block> (nano::dev::genesis_key.pub, block1->hash (), nano::dev::genesis_key.pub, 20, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.network.publish_thresholds.epoch_2_receive, node1.network_params.network.publish_thresholds.epoch_1 - 1)));
auto block4 (std::make_shared<nano::state_block> (nano::dev::genesis_key.pub, block1->hash (), nano::dev::genesis_key.pub, 20, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.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);

16
nano/core_test/node.cpp
View file

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

6
nano/core_test/system.cpp
View file

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

24
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::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<nano::uint128_t>::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;

30
nano/core_test/work_pool.cpp
View file

@ -19,7 +19,7 @@ TEST (work, one)
nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits<unsigned>::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<unsigned>::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<uint64_t> work_a) {
nano::work_version::work_1, key, nano::dev::network_params.work.base, [&done] (boost::optional<uint64_t> 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<uint64_t>) {});
pool.generate (nano::work_version::work_1, key2, nano::dev::network_params.network.publish_thresholds.base, [] (boost::optional<uint64_t>) {});
pool.generate (nano::work_version::work_1, key3, nano::dev::network_params.network.publish_thresholds.base, [] (boost::optional<uint64_t>) {});
pool.generate (nano::work_version::work_1, key4, nano::dev::network_params.network.publish_thresholds.base, [] (boost::optional<uint64_t>) {});
pool.generate (nano::work_version::work_1, key5, nano::dev::network_params.network.publish_thresholds.base, [] (boost::optional<uint64_t>) {});
pool.generate (nano::work_version::work_1, key6, nano::dev::network_params.network.publish_thresholds.base, [] (boost::optional<uint64_t>) {});
pool.generate (nano::work_version::work_1, key1, nano::dev::network_params.work.base, [] (boost::optional<uint64_t>) {});
pool.generate (nano::work_version::work_1, key2, nano::dev::network_params.work.base, [] (boost::optional<uint64_t>) {});
pool.generate (nano::work_version::work_1, key3, nano::dev::network_params.work.base, [] (boost::optional<uint64_t>) {});
pool.generate (nano::work_version::work_1, key4, nano::dev::network_params.work.base, [] (boost::optional<uint64_t>) {});
pool.generate (nano::work_version::work_1, key5, nano::dev::network_params.work.base, [] (boost::optional<uint64_t>) {});
pool.generate (nano::work_version::work_1, key6, nano::dev::network_params.work.base, [] (boost::optional<uint64_t>) {});
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);
}

8
nano/lib/config.hpp
View file

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

6
nano/lib/work.cpp
View file

@ -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<uint64_t> 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<uint64_t> nano::work_pool::generate (nano::root const & root_a, uint64_t difficulty_a)

2
nano/nano_node/daemon.cpp
View file

@ -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<int> & ticket_a) {
return opencl->generate_work (version_a, root_a, difficulty_a, ticket_a);
}

32
nano/nano_node/entry.cpp
View file

@ -325,7 +325,7 @@ int main (int argc, char * const * argv)
if (!key.decode_hex (key_it->second.as<std::string> ()))
{
nano::keypair genesis (key.to_string ());
nano::work_pool work{ nano::dev::network_params.network, std::numeric_limits<unsigned>::max () };
nano::work_pool work{ network_params.network, std::numeric_limits<unsigned>::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<nano::uint128_t>::max ());
nano::open_block genesis_block (reinterpret_cast<const nano::block_hash &> (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<const nano::block_hash &> (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::nanoseconds> (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<int> &) {
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<unsigned>::max () };
nano::work_pool work{ network_params.network, std::numeric_limits<unsigned>::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 ())));
}

2
nano/nano_wallet/entry.cpp
View file

@ -106,7 +106,7 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost
std::shared_ptr<nano::node> node;
std::shared_ptr<nano_qt::wallet> 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<int> &) {
return opencl->generate_work (version_a, root_a, difficulty_a);
}

6
nano/node/blockprocessor.cpp
View file

@ -105,7 +105,7 @@ void nano::block_processor::add (std::shared_ptr<nano::block> 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;
}

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

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

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

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

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

@ -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<nano::message> (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<std::shared_ptr<nano::block>> (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);

6
nano/node/common.cpp
View file

@ -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<std::shared_ptr<nano::block>> (vote_block));
if (network.publish_thresholds.validate_entry (*block))
if (network.work.validate_entry (*block))
{
status = parse_status::insufficient_work;
break;

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

24
nano/node/json_handler.cpp
View file

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

10
nano/node/node.cpp
View file

@ -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<uint64_t> & counter, std::shared_ptr<nano::block> 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<nano::block> 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<nano::block> epoch = builder.state ()

6
nano/node/wallet.cpp
View file

@ -1043,8 +1043,8 @@ bool nano::wallet::action_complete (std::shared_ptr<nano::block> 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));

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

10
nano/qt/qt.cpp
View file

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

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

92
nano/rpc_test/rpc.cpp
View file

@ -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<std::string> ("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<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::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<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::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<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::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<std::string> ("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<std::string> ("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<uint64_t> work_a) {
system.work.generate (nano::work_version::work_1, hash1, node1->network_params.work.base, [&done] (boost::optional<uint64_t> 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<uint64_t> work (0);
node2.work_generate (nano::work_version::work_1, hash1, node2.network_params.network.publish_thresholds.base, [&work] (boost::optional<uint64_t> work_a) {
node2.work_generate (nano::work_version::work_1, hash1, node2.network_params.work.base, [&work] (boost::optional<uint64_t> 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<uint64_t> work (0);
node2.work_generate (nano::work_version::work_1, key1.pub, node1->network_params.network.publish_thresholds.base, [&work] (boost::optional<uint64_t> work_a) {
node2.work_generate (nano::work_version::work_1, key1.pub, node1->network_params.work.base, [&work] (boost::optional<uint64_t> 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<uint64_t> work_a) {
node1.work_generate (nano::work_version::work_1, key1.pub, node1.network_params.work.base, [&work = works[i]] (boost::optional<uint64_t> 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<double> ("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<bool> ("valid"));
ASSERT_EQ (result_difficulty >= node1->default_difficulty (nano::work_version::work_1), response.get<bool> ("valid_all"));
ASSERT_EQ (result_difficulty >= node1->network_params.network.publish_thresholds.epoch_2_receive, response.get<bool> ("valid_all"));
ASSERT_EQ (result_difficulty >= node1->network_params.work.epoch_2_receive, response.get<bool> ("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<double> ("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<std::string> ("hash"));
ASSERT_EQ (send.hash ().to_string (), send_hash);
std::string send_difficulty (response.get<std::string> ("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<std::string> ("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"));
}

8
nano/secure/common.cpp
View file

@ -86,7 +86,13 @@ nano::ledger_constants & nano::dev::constants{ nano::dev::network_params.ledger
std::shared_ptr<nano::block> & 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;

15
nano/secure/common.hpp
View file

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

8
nano/slow_test/node.cpp
View file

@ -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<nano::keypair> keys (num_blocks);
nano::state_block_builder builder;
std::vector<std::shared_ptr<nano::state_block>> 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<std::shared_ptr<nano::state_block>> 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];

4
nano/test_common/system.cpp
View file

@ -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::state_block> 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 };