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

Convert boost::optional to std::optional for distributed work generation.

Browse source
This commit is contained in:
Colin LeMahieu 2024-03-06 15:39:50 +00:00
commit 76ebe9afa8
No known key found for this signature in database
GPG key ID: 43708520C8DFB938
13 changed files with 78 additions and 74 deletions
Download patch file Download diff file Expand all files Collapse all files

38
nano/core_test/distributed_work.cpp
View file

@ -18,10 +18,10 @@ TEST (distributed_work, no_peers)
nano::test::system system (1); nano::test::system system (1);
auto node (system.nodes[0]); auto node (system.nodes[0]);
nano::block_hash hash{ 1 }; nano::block_hash hash{ 1 };
boost::optional<uint64_t> work; std::optional<uint64_t> work;
std::atomic<bool> done{ false }; std::atomic<bool> done{ false };
auto callback = [&work, &done] (boost::optional<uint64_t> work_a) { auto callback = [&work, &done] (std::optional<uint64_t> work_a) {
ASSERT_TRUE (work_a.is_initialized ()); ASSERT_TRUE (work_a.has_value ());
work = work_a; work = work_a;
done = true; done = true;
}; };
@ -54,8 +54,8 @@ TEST (distributed_work, no_peers_cancel)
auto & node = *system.add_node (node_config); auto & node = *system.add_node (node_config);
nano::block_hash hash{ 1 }; nano::block_hash hash{ 1 };
bool done{ false }; bool done{ false };
auto callback_to_cancel = [&done] (boost::optional<uint64_t> work_a) { auto callback_to_cancel = [&done] (std::optional<uint64_t> work_a) {
ASSERT_FALSE (work_a.is_initialized ()); ASSERT_FALSE (work_a.has_value ());
done = true; 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.work.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));
@ -83,8 +83,8 @@ TEST (distributed_work, no_peers_multi)
nano::block_hash hash{ 1 }; nano::block_hash hash{ 1 };
unsigned total{ 10 }; unsigned total{ 10 };
std::atomic<unsigned> count{ 0 }; std::atomic<unsigned> count{ 0 };
auto callback = [&count] (boost::optional<uint64_t> work_a) { auto callback = [&count] (std::optional<uint64_t> work_a) {
ASSERT_TRUE (work_a.is_initialized ()); ASSERT_TRUE (work_a.has_value ());
++count; ++count;
}; };
// Test many works for the same root // Test many works for the same root
@ -125,10 +125,10 @@ TEST (distributed_work, peer)
auto node (system.add_node (node_config)); auto node (system.add_node (node_config));
ASSERT_FALSE (node->local_work_generation_enabled ()); ASSERT_FALSE (node->local_work_generation_enabled ());
nano::block_hash hash{ 1 }; nano::block_hash hash{ 1 };
boost::optional<uint64_t> work; std::optional<uint64_t> work;
std::atomic<bool> done{ false }; std::atomic<bool> done{ false };
auto callback = [&work, &done] (boost::optional<uint64_t> work_a) { auto callback = [&work, &done] (std::optional<uint64_t> work_a) {
ASSERT_TRUE (work_a.is_initialized ()); ASSERT_TRUE (work_a.has_value ());
work = work_a; work = work_a;
done = true; done = true;
}; };
@ -151,10 +151,10 @@ TEST (distributed_work, peer_malicious)
auto node (system.nodes[0]); auto node (system.nodes[0]);
ASSERT_TRUE (node->local_work_generation_enabled ()); ASSERT_TRUE (node->local_work_generation_enabled ());
nano::block_hash hash{ 1 }; nano::block_hash hash{ 1 };
boost::optional<uint64_t> work; std::optional<uint64_t> work;
std::atomic<bool> done{ false }; std::atomic<bool> done{ false };
auto callback = [&work, &done] (boost::optional<uint64_t> work_a) { auto callback = [&work, &done] (std::optional<uint64_t> work_a) {
ASSERT_TRUE (work_a.is_initialized ()); ASSERT_TRUE (work_a.has_value ());
work = work_a; work = work_a;
done = true; done = true;
}; };
@ -194,10 +194,10 @@ TEST (distributed_work, DISABLED_peer_multi)
auto node (system.nodes[0]); auto node (system.nodes[0]);
ASSERT_TRUE (node->local_work_generation_enabled ()); ASSERT_TRUE (node->local_work_generation_enabled ());
nano::block_hash hash{ 1 }; nano::block_hash hash{ 1 };
boost::optional<uint64_t> work; std::optional<uint64_t> work;
std::atomic<bool> done{ false }; std::atomic<bool> done{ false };
auto callback = [&work, &done] (boost::optional<uint64_t> work_a) { auto callback = [&work, &done] (std::optional<uint64_t> work_a) {
ASSERT_TRUE (work_a.is_initialized ()); ASSERT_TRUE (work_a.has_value ());
work = work_a; work = work_a;
done = true; done = true;
}; };
@ -233,10 +233,10 @@ TEST (distributed_work, fail_resolve)
nano::test::system system (1); nano::test::system system (1);
auto node (system.nodes[0]); auto node (system.nodes[0]);
nano::block_hash hash{ 1 }; nano::block_hash hash{ 1 };
boost::optional<uint64_t> work; std::optional<uint64_t> work;
std::atomic<bool> done{ false }; std::atomic<bool> done{ false };
auto callback = [&work, &done] (boost::optional<uint64_t> work_a) { auto callback = [&work, &done] (std::optional<uint64_t> work_a) {
ASSERT_TRUE (work_a.is_initialized ()); ASSERT_TRUE (work_a.has_value ());
work = work_a; work = work_a;
done = true; done = true;
}; };

14
nano/core_test/node.cpp
View file

@ -48,19 +48,19 @@ TEST (node, work_generate)
{ {
auto difficulty = nano::difficulty::from_multiplier (1.5, node.network_params.work.base); auto difficulty = nano::difficulty::from_multiplier (1.5, node.network_params.work.base);
auto work = node.work_generate_blocking (version, root, difficulty); auto work = node.work_generate_blocking (version, root, difficulty);
ASSERT_TRUE (work.is_initialized ()); ASSERT_TRUE (work.has_value ());
ASSERT_GE (nano::dev::network_params.work.difficulty (version, root, *work), difficulty); ASSERT_GE (nano::dev::network_params.work.difficulty (version, root, work.value ()), difficulty);
} }
{ {
auto difficulty = nano::difficulty::from_multiplier (0.5, node.network_params.work.base); auto difficulty = nano::difficulty::from_multiplier (0.5, node.network_params.work.base);
boost::optional<uint64_t> work; std::optional<uint64_t> work;
do do
{ {
work = node.work_generate_blocking (version, root, difficulty); work = node.work_generate_blocking (version, root, difficulty);
} while (nano::dev::network_params.work.difficulty (version, root, *work) >= node.network_params.work.base); } while (nano::dev::network_params.work.difficulty (version, root, work.value ()) >= node.network_params.work.base);
ASSERT_TRUE (work.is_initialized ()); ASSERT_TRUE (work.has_value ());
ASSERT_GE (nano::dev::network_params.work.difficulty (version, root, *work), difficulty); ASSERT_GE (nano::dev::network_params.work.difficulty (version, root, work.value ()), difficulty);
ASSERT_FALSE (nano::dev::network_params.work.difficulty (version, root, *work) >= node.network_params.work.base); ASSERT_FALSE (nano::dev::network_params.work.difficulty (version, root, work.value ()) >= node.network_params.work.base);
} }
} }

4
nano/core_test/websocket.cpp
View file

@ -796,7 +796,7 @@ TEST (websocket, work)
// Generate work // Generate work
nano::block_hash hash{ 1 }; nano::block_hash hash{ 1 };
auto work (node1->work_generate_blocking (hash)); auto work (node1->work_generate_blocking (hash));
ASSERT_TRUE (work.is_initialized ()); ASSERT_TRUE (work.has_value ());
// Wait for the work notification // Wait for the work notification
ASSERT_TIMELY_EQ (5s, future.wait_for (0s), std::future_status::ready); ASSERT_TIMELY_EQ (5s, future.wait_for (0s), std::future_status::ready);
@ -827,7 +827,7 @@ TEST (websocket, work)
nano::from_string_hex (result.get<std::string> ("difficulty"), result_difficulty); nano::from_string_hex (result.get<std::string> ("difficulty"), result_difficulty);
ASSERT_GE (result_difficulty, node1->default_difficulty (nano::work_version::work_1)); ASSERT_GE (result_difficulty, node1->default_difficulty (nano::work_version::work_1));
ASSERT_NEAR (result.get<double> ("multiplier"), nano::difficulty::to_multiplier (result_difficulty, node1->default_difficulty (nano::work_version::work_1)), 1e-6); ASSERT_NEAR (result.get<double> ("multiplier"), nano::difficulty::to_multiplier (result_difficulty, node1->default_difficulty (nano::work_version::work_1)), 1e-6);
ASSERT_EQ (result.get<std::string> ("work"), nano::to_string_hex (work.get ())); ASSERT_EQ (result.get<std::string> ("work"), nano::to_string_hex (work.value ()));
ASSERT_EQ (1, contents.count ("bad_peers")); ASSERT_EQ (1, contents.count ("bad_peers"));
auto & bad_peers = contents.get_child ("bad_peers"); auto & bad_peers = contents.get_child ("bad_peers");

12
nano/node/distributed_work.cpp
View file

@ -68,7 +68,7 @@ void nano::distributed_work::start ()
else if (need_resolve.empty () && request.callback) else if (need_resolve.empty () && request.callback)
{ {
status = work_generation_status::failure_local; status = work_generation_status::failure_local;
request.callback (boost::none); request.callback (std::nullopt);
} }
for (auto const & peer : need_resolve) for (auto const & peer : need_resolve)
{ {
@ -117,7 +117,7 @@ void nano::distributed_work::start_local ()
this_l->status = work_generation_status::failure_local; this_l->status = work_generation_status::failure_local;
if (this_l->request.callback) if (this_l->request.callback)
{ {
this_l->request.callback (boost::none); this_l->request.callback (std::nullopt);
} }
} }
this_l->stop_once (false); this_l->stop_once (false);
@ -143,9 +143,9 @@ void nano::distributed_work::do_request (nano::tcp_endpoint const & endpoint_a)
rpc_request.put ("action", "work_generate"); rpc_request.put ("action", "work_generate");
rpc_request.put ("hash", this_l->request.root.to_string ()); rpc_request.put ("hash", this_l->request.root.to_string ());
rpc_request.put ("difficulty", nano::to_string_hex (this_l->request.difficulty)); rpc_request.put ("difficulty", nano::to_string_hex (this_l->request.difficulty));
if (this_l->request.account.is_initialized ()) if (this_l->request.account.has_value ())
{ {
rpc_request.put ("account", this_l->request.account.get ().to_account ()); rpc_request.put ("account", this_l->request.account.value ().to_account ());
} }
std::stringstream ostream; std::stringstream ostream;
boost::property_tree::write_json (ostream, rpc_request); boost::property_tree::write_json (ostream, rpc_request);
@ -373,7 +373,7 @@ void nano::distributed_work::cancel ()
status = work_generation_status::cancelled; status = work_generation_status::cancelled;
if (request.callback) if (request.callback)
{ {
request.callback (boost::none); request.callback (std::nullopt);
} }
stop_once (true); stop_once (true);
} }
@ -411,7 +411,7 @@ void nano::distributed_work::handle_failure ()
} }
if (error_l && request_l.callback) if (error_l && request_l.callback)
{ {
request_l.callback (boost::none); request_l.callback (std::nullopt);
} }
}); });
} }

6
nano/node/distributed_work.hpp
View file

@ -9,6 +9,8 @@
#include <nano/lib/work.hpp> #include <nano/lib/work.hpp>
#include <nano/node/common.hpp> #include <nano/node/common.hpp>
#include <optional>
using request_type = boost::beast::http::request<boost::beast::http::string_body>; using request_type = boost::beast::http::request<boost::beast::http::string_body>;
namespace boost namespace boost
@ -28,8 +30,8 @@ struct work_request final
nano::work_version version; nano::work_version version;
nano::root root; nano::root root;
uint64_t difficulty; uint64_t difficulty;
boost::optional<nano::account> const account; std::optional<nano::account> const account;
std::function<void (boost::optional<uint64_t>)> callback; std::function<void (std::optional<uint64_t>)> callback;
std::vector<std::pair<std::string, uint16_t>> const peers; std::vector<std::pair<std::string, uint16_t>> const peers;
}; };

2
nano/node/distributed_work_factory.cpp
View file

@ -12,7 +12,7 @@ nano::distributed_work_factory::~distributed_work_factory ()
stop (); stop ();
} }
bool nano::distributed_work_factory::make (nano::work_version const version_a, nano::root const & root_a, std::vector<std::pair<std::string, uint16_t>> const & peers_a, uint64_t difficulty_a, std::function<void (boost::optional<uint64_t>)> const & callback_a, boost::optional<nano::account> const & account_a) bool nano::distributed_work_factory::make (nano::work_version const version_a, nano::root const & root_a, std::vector<std::pair<std::string, uint16_t>> const & peers_a, uint64_t difficulty_a, std::function<void (std::optional<uint64_t>)> const & callback_a, std::optional<nano::account> const & account_a)
{ {
return make (std::chrono::seconds (1), nano::work_request{ version_a, root_a, difficulty_a, account_a, callback_a, peers_a }); return make (std::chrono::seconds (1), nano::work_request{ version_a, root_a, difficulty_a, account_a, callback_a, peers_a });
} }

3
nano/node/distributed_work_factory.hpp
View file

@ -4,6 +4,7 @@
#include <atomic> #include <atomic>
#include <functional> #include <functional>
#include <optional>
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
@ -20,7 +21,7 @@ class distributed_work_factory final
public: public:
distributed_work_factory (nano::node &); distributed_work_factory (nano::node &);
~distributed_work_factory (); ~distributed_work_factory ();
bool make (nano::work_version const, nano::root const &, std::vector<std::pair<std::string, uint16_t>> const &, uint64_t, std::function<void (boost::optional<uint64_t>)> const &, boost::optional<nano::account> const & = boost::none); bool make (nano::work_version const, nano::root const &, std::vector<std::pair<std::string, uint16_t>> const &, uint64_t, std::function<void (std::optional<uint64_t>)> const &, std::optional<nano::account> const & = std::nullopt);
bool make (std::chrono::seconds const &, nano::work_request const &); bool make (std::chrono::seconds const &, nano::work_request const &);
void cancel (nano::root const &); void cancel (nano::root const &);
void cleanup_finished (); void cleanup_finished ();

8
nano/node/json_handler.cpp
View file

@ -1613,10 +1613,10 @@ void nano::json_handler::block_create ()
// Wrapper from argument to lambda capture, to extend the block's scope // Wrapper from argument to lambda capture, to extend the block's scope
auto get_callback_l = [rpc_l, block_response_put_l] (std::shared_ptr<nano::block> const & block_a) { auto get_callback_l = [rpc_l, block_response_put_l] (std::shared_ptr<nano::block> const & block_a) {
// Callback upon work generation success or failure // Callback upon work generation success or failure
return [block_a, rpc_l, block_response_put_l] (boost::optional<uint64_t> const & work_a) { return [block_a, rpc_l, block_response_put_l] (std::optional<uint64_t> const & work_a) {
if (block_a != nullptr) if (block_a != nullptr)
{ {
if (work_a.is_initialized ()) if (work_a.has_value ())
{ {
block_a->block_work_set (*work_a); block_a->block_work_set (*work_a);
block_response_put_l (*block_a); block_response_put_l (*block_a);
@ -4994,7 +4994,7 @@ void nano::json_handler::wallet_work_get ()
void nano::json_handler::work_generate () void nano::json_handler::work_generate ()
{ {
boost::optional<nano::account> account; std::optional<nano::account> account;
auto account_opt (request.get_optional<std::string> ("account")); auto account_opt (request.get_optional<std::string> ("account"));
// Default to work_1 if not specified // Default to work_1 if not specified
auto work_version (work_version_optional_impl (nano::work_version::work_1)); auto work_version (work_version_optional_impl (nano::work_version::work_1));
@ -5046,7 +5046,7 @@ void nano::json_handler::work_generate ()
{ {
auto use_peers (request.get<bool> ("use_peers", false)); auto use_peers (request.get<bool> ("use_peers", false));
auto rpc_l (shared_from_this ()); auto rpc_l (shared_from_this ());
auto callback = [rpc_l, hash, work_version, this] (boost::optional<uint64_t> const & work_a) { auto callback = [rpc_l, hash, work_version, this] (std::optional<uint64_t> const & work_a) {
if (work_a) if (work_a)
{ {
boost::property_tree::ptree response_l; boost::property_tree::ptree response_l;

22
nano/node/node.cpp
View file

@ -1078,50 +1078,50 @@ bool nano::node::work_generation_enabled (std::vector<std::pair<std::string, uin
return !peers_a.empty () || local_work_generation_enabled (); return !peers_a.empty () || local_work_generation_enabled ();
} }
boost::optional<uint64_t> nano::node::work_generate_blocking (nano::block & block_a, uint64_t difficulty_a) std::optional<uint64_t> nano::node::work_generate_blocking (nano::block & block_a, uint64_t difficulty_a)
{ {
auto opt_work_l (work_generate_blocking (block_a.work_version (), block_a.root (), difficulty_a, block_a.account ())); auto opt_work_l (work_generate_blocking (block_a.work_version (), block_a.root (), difficulty_a, block_a.account ()));
if (opt_work_l.is_initialized ()) if (opt_work_l.has_value ())
{ {
block_a.block_work_set (*opt_work_l); block_a.block_work_set (opt_work_l.value ());
} }
return opt_work_l; return opt_work_l;
} }
void nano::node::work_generate (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::function<void (boost::optional<uint64_t>)> callback_a, boost::optional<nano::account> const & account_a, bool secondary_work_peers_a) void nano::node::work_generate (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::function<void (std::optional<uint64_t>)> callback_a, std::optional<nano::account> const & account_a, bool secondary_work_peers_a)
{ {
auto const & peers_l (secondary_work_peers_a ? config.secondary_work_peers : config.work_peers); auto const & peers_l (secondary_work_peers_a ? config.secondary_work_peers : config.work_peers);
if (distributed_work.make (version_a, root_a, peers_l, difficulty_a, callback_a, account_a)) if (distributed_work.make (version_a, root_a, peers_l, difficulty_a, callback_a, account_a))
{ {
// Error in creating the job (either stopped or work generation is not possible) // Error in creating the job (either stopped or work generation is not possible)
callback_a (boost::none); callback_a (std::nullopt);
} }
} }
boost::optional<uint64_t> nano::node::work_generate_blocking (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, boost::optional<nano::account> const & account_a) std::optional<uint64_t> nano::node::work_generate_blocking (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::optional<nano::account> const & account_a)
{ {
std::promise<boost::optional<uint64_t>> promise; std::promise<std::optional<uint64_t>> promise;
work_generate ( work_generate (
version_a, root_a, difficulty_a, [&promise] (boost::optional<uint64_t> opt_work_a) { version_a, root_a, difficulty_a, [&promise] (std::optional<uint64_t> opt_work_a) {
promise.set_value (opt_work_a); promise.set_value (opt_work_a);
}, },
account_a); account_a);
return promise.get_future ().get (); return promise.get_future ().get ();
} }
boost::optional<uint64_t> nano::node::work_generate_blocking (nano::block & block_a) std::optional<uint64_t> nano::node::work_generate_blocking (nano::block & block_a)
{ {
debug_assert (network_params.network.is_dev_network ()); debug_assert (network_params.network.is_dev_network ());
return work_generate_blocking (block_a, default_difficulty (nano::work_version::work_1)); return work_generate_blocking (block_a, default_difficulty (nano::work_version::work_1));
} }
boost::optional<uint64_t> nano::node::work_generate_blocking (nano::root const & root_a) std::optional<uint64_t> nano::node::work_generate_blocking (nano::root const & root_a)
{ {
debug_assert (network_params.network.is_dev_network ()); debug_assert (network_params.network.is_dev_network ());
return work_generate_blocking (root_a, default_difficulty (nano::work_version::work_1)); return work_generate_blocking (root_a, default_difficulty (nano::work_version::work_1));
} }
boost::optional<uint64_t> nano::node::work_generate_blocking (nano::root const & root_a, uint64_t difficulty_a) std::optional<uint64_t> nano::node::work_generate_blocking (nano::root const & root_a, uint64_t difficulty_a)
{ {
debug_assert (network_params.network.is_dev_network ()); debug_assert (network_params.network.is_dev_network ());
return work_generate_blocking (nano::work_version::work_1, root_a, difficulty_a); return work_generate_blocking (nano::work_version::work_1, root_a, difficulty_a);

13
nano/node/node.hpp
View file

@ -43,6 +43,7 @@
#include <atomic> #include <atomic>
#include <memory> #include <memory>
#include <optional>
#include <vector> #include <vector>
namespace nano namespace nano
@ -111,9 +112,9 @@ public:
bool local_work_generation_enabled () const; bool local_work_generation_enabled () const;
bool work_generation_enabled () const; bool work_generation_enabled () const;
bool work_generation_enabled (std::vector<std::pair<std::string, uint16_t>> const &) const; bool work_generation_enabled (std::vector<std::pair<std::string, uint16_t>> const &) const;
boost::optional<uint64_t> work_generate_blocking (nano::block &, uint64_t); std::optional<uint64_t> work_generate_blocking (nano::block &, uint64_t);
boost::optional<uint64_t> work_generate_blocking (nano::work_version const, nano::root const &, uint64_t, boost::optional<nano::account> const & = boost::none); std::optional<uint64_t> work_generate_blocking (nano::work_version const, nano::root const &, uint64_t, std::optional<nano::account> const & = std::nullopt);
void work_generate (nano::work_version const, nano::root const &, uint64_t, std::function<void (boost::optional<uint64_t>)>, boost::optional<nano::account> const & = boost::none, bool const = false); void work_generate (nano::work_version const, nano::root const &, uint64_t, std::function<void (std::optional<uint64_t>)>, std::optional<nano::account> const & = std::nullopt, bool const = false);
void add_initial_peers (); void add_initial_peers ();
void start_election (std::shared_ptr<nano::block> const & block); void start_election (std::shared_ptr<nano::block> const & block);
bool block_confirmed (nano::block_hash const &); bool block_confirmed (nano::block_hash const &);
@ -199,11 +200,11 @@ public:
// For tests only // For tests only
unsigned node_seq; unsigned node_seq;
// For tests only // For tests only
boost::optional<uint64_t> work_generate_blocking (nano::block &); std::optional<uint64_t> work_generate_blocking (nano::block &);
// For tests only // For tests only
boost::optional<uint64_t> work_generate_blocking (nano::root const &, uint64_t); std::optional<uint64_t> work_generate_blocking (nano::root const &, uint64_t);
// For tests only // For tests only
boost::optional<uint64_t> work_generate_blocking (nano::root const &); std::optional<uint64_t> work_generate_blocking (nano::root const &);
public: // Testing convenience functions public: // Testing convenience functions
/** /**

6
nano/node/wallet.cpp
View file

@ -1050,7 +1050,7 @@ bool nano::wallet::action_complete (std::shared_ptr<nano::block> const & block_a
account_a.to_account ()); account_a.to_account ());
debug_assert (required_difficulty <= wallets.node.max_work_generate_difficulty (block_a->work_version ())); debug_assert (required_difficulty <= wallets.node.max_work_generate_difficulty (block_a->work_version ()));
error = !wallets.node.work_generate_blocking (*block_a, required_difficulty).is_initialized (); error = !wallets.node.work_generate_blocking (*block_a, required_difficulty).has_value ();
} }
if (!error) if (!error)
{ {
@ -1298,12 +1298,12 @@ void nano::wallet::work_cache_blocking (nano::account const & account_a, nano::r
{ {
auto difficulty (wallets.node.default_difficulty (nano::work_version::work_1)); auto difficulty (wallets.node.default_difficulty (nano::work_version::work_1));
auto opt_work_l (wallets.node.work_generate_blocking (nano::work_version::work_1, root_a, difficulty, account_a)); auto opt_work_l (wallets.node.work_generate_blocking (nano::work_version::work_1, root_a, difficulty, account_a));
if (opt_work_l.is_initialized ()) if (opt_work_l.has_value ())
{ {
auto transaction_l (wallets.tx_begin_write ()); auto transaction_l (wallets.tx_begin_write ());
if (live () && store.exists (transaction_l, account_a)) if (live () && store.exists (transaction_l, account_a))
{ {
work_update (transaction_l, account_a, root_a, *opt_work_l); work_update (transaction_l, account_a, root_a, opt_work_l.value ());
} }
} }
else if (!wallets.node.stopped) else if (!wallets.node.stopped)

8
nano/qt/qt.cpp
View file

@ -2253,7 +2253,7 @@ void nano_qt::block_creation::create_send ()
details.is_send = true; details.is_send = true;
details.epoch = info.epoch (); details.epoch = info.epoch ();
auto const required_difficulty{ wallet.node.network_params.work.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 ()) if (wallet.node.work_generate_blocking (send, required_difficulty).has_value ())
{ {
std::string block_l; std::string block_l;
send.serialize_json (block_l); send.serialize_json (block_l);
@ -2337,7 +2337,7 @@ void nano_qt::block_creation::create_receive ()
details.is_receive = true; details.is_receive = true;
details.epoch = std::max (info.epoch (), pending.epoch); details.epoch = std::max (info.epoch (), pending.epoch);
auto required_difficulty{ wallet.node.network_params.work.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 ()) if (wallet.node.work_generate_blocking (receive, required_difficulty).has_value ())
{ {
std::string block_l; std::string block_l;
receive.serialize_json (block_l); receive.serialize_json (block_l);
@ -2420,7 +2420,7 @@ void nano_qt::block_creation::create_change ()
nano::block_details details; nano::block_details details;
details.epoch = info.epoch (); details.epoch = info.epoch ();
auto const required_difficulty{ wallet.node.network_params.work.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 ()) if (wallet.node.work_generate_blocking (change, required_difficulty).has_value ())
{ {
std::string block_l; std::string block_l;
change.serialize_json (block_l); change.serialize_json (block_l);
@ -2502,7 +2502,7 @@ void nano_qt::block_creation::create_open ()
details.is_receive = true; details.is_receive = true;
details.epoch = pending.epoch; details.epoch = pending.epoch;
auto const required_difficulty{ wallet.node.network_params.work.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 ()) if (wallet.node.work_generate_blocking (open, required_difficulty).has_value ())
{ {
std::string block_l; std::string block_l;
open.serialize_json (block_l); open.serialize_json (block_l);

14
nano/rpc_test/rpc.cpp
View file

@ -2088,9 +2088,9 @@ TEST (rpc, work_peer_bad)
auto const rpc_ctx = add_rpc (system, node1); auto const rpc_ctx = add_rpc (system, node1);
nano::block_hash hash1 (1); nano::block_hash hash1 (1);
std::atomic<uint64_t> work (0); std::atomic<uint64_t> work (0);
node2.work_generate (nano::work_version::work_1, hash1, node2.network_params.work.base, [&work] (boost::optional<uint64_t> work_a) { node2.work_generate (nano::work_version::work_1, hash1, node2.network_params.work.base, [&work] (std::optional<uint64_t> work_a) {
ASSERT_TRUE (work_a.is_initialized ()); ASSERT_TRUE (work_a.has_value ());
work = *work_a; work = work_a.value ();
}); });
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)); 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));
} }
@ -2107,9 +2107,9 @@ TEST (rpc, DISABLED_work_peer_one)
node2.config.work_peers.emplace_back (node1->network.endpoint ().address ().to_string (), rpc_ctx.rpc->listening_port ()); node2.config.work_peers.emplace_back (node1->network.endpoint ().address ().to_string (), rpc_ctx.rpc->listening_port ());
nano::keypair key1; nano::keypair key1;
std::atomic<uint64_t> work (0); std::atomic<uint64_t> work (0);
node2.work_generate (nano::work_version::work_1, key1.pub, node1->network_params.work.base, [&work] (boost::optional<uint64_t> work_a) { node2.work_generate (nano::work_version::work_1, key1.pub, node1->network_params.work.base, [&work] (std::optional<uint64_t> work_a) {
ASSERT_TRUE (work_a.is_initialized ()); ASSERT_TRUE (work_a.has_value ());
work = *work_a; work = work_a.value ();
}); });
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)); 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));
} }
@ -2138,7 +2138,7 @@ TEST (rpc, DISABLED_work_peer_many)
for (auto & work : works) for (auto & work : works)
{ {
nano::keypair key1; nano::keypair key1;
node1.work_generate (nano::work_version::work_1, key1.pub, node1.network_params.work.base, [&work] (boost::optional<uint64_t> work_a) { node1.work_generate (nano::work_version::work_1, key1.pub, node1.network_params.work.base, [&work] (std::optional<uint64_t> work_a) {
work = *work_a; work = *work_a;
}); });
while (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)) while (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))