From 46d91d828e57da585d1a27062e64eb9e071c3663 Mon Sep 17 00:00:00 2001 From: everoddandeven Date: Sat, 28 Mar 2026 08:57:04 +0100 Subject: [PATCH] Refactory send request --- src/cpp/common/py_monero_common.cpp | 2 + src/cpp/common/py_monero_common.h | 16 + src/cpp/daemon/py_monero_daemon_rpc.cpp | 277 ++++------------- src/cpp/wallet/py_monero_wallet_rpc.cpp | 389 ++++++------------------ 4 files changed, 170 insertions(+), 514 deletions(-) diff --git a/src/cpp/common/py_monero_common.cpp b/src/cpp/common/py_monero_common.cpp index 92a774c..72506f7 100644 --- a/src/cpp/common/py_monero_common.cpp +++ b/src/cpp/common/py_monero_common.cpp @@ -166,6 +166,7 @@ PyMoneroPathRequest::PyMoneroPathRequest(const std::string& method, const boost: PyMoneroPathRequest::PyMoneroPathRequest(const std::string& method, const std::shared_ptr& params): m_params(params) { m_method = method; + if (params == nullptr) m_params = std::make_shared(); } PyMoneroBinaryRequest::PyMoneroBinaryRequest(const std::string& method, const boost::optional& params) { @@ -212,6 +213,7 @@ PyMoneroJsonRequest::PyMoneroJsonRequest(const std::string& method, const std::s m_id("0"), m_params(params) { m_method = method; + if (params == nullptr) m_params = boost::none; } diff --git a/src/cpp/common/py_monero_common.h b/src/cpp/common/py_monero_common.h index ff1b780..cd428c2 100644 --- a/src/cpp/common/py_monero_common.h +++ b/src/cpp/common/py_monero_common.h @@ -281,6 +281,14 @@ class PyMoneroRpcConnection : public monero::monero_rpc_connection { bool is_connected() const; bool check_connection(const boost::optional& timeout_ms = boost::none); + inline const boost::property_tree::ptree send_json_request(const std::string& path, const std::shared_ptr& params = nullptr) { + PyMoneroJsonRequest request(path, params); + auto response = send_json_request(request); + + if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); + return response->m_result.get(); + } + inline const std::shared_ptr send_json_request(const PyMoneroJsonRequest &request, std::chrono::milliseconds timeout = std::chrono::seconds(15)) { PyMoneroJsonResponse response; @@ -290,6 +298,14 @@ class PyMoneroRpcConnection : public monero::monero_rpc_connection { return std::make_shared(response); } + inline const boost::property_tree::ptree send_path_request(const std::string& path, const std::shared_ptr& params = nullptr) { + PyMoneroPathRequest request(path, params); + auto response = send_path_request(request); + + if (response->m_response == boost::none) throw std::runtime_error("Invalid Monero path response"); + return response->m_response.get(); + } + inline const std::shared_ptr send_path_request(const PyMoneroPathRequest &request, std::chrono::milliseconds timeout = std::chrono::seconds(15)) { PyMoneroPathResponse response; diff --git a/src/cpp/daemon/py_monero_daemon_rpc.cpp b/src/cpp/daemon/py_monero_daemon_rpc.cpp index 840ceb2..ce240e1 100644 --- a/src/cpp/daemon/py_monero_daemon_rpc.cpp +++ b/src/cpp/daemon/py_monero_daemon_rpc.cpp @@ -83,63 +83,36 @@ bool PyMoneroDaemonRpc::is_connected() { } monero::monero_version PyMoneroDaemonRpc::get_version() { - PyMoneroJsonRequest request("get_version"); - std::shared_ptr response = m_rpc->send_json_request(request); - - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); - + auto res = m_rpc->send_json_request("get_version"); std::shared_ptr info = std::make_shared(); PyMoneroVersion::from_property_tree(res, info); return *info; } bool PyMoneroDaemonRpc::is_trusted() { - PyMoneroPathRequest request("get_height"); - std::shared_ptr response = m_rpc->send_path_request(request); - - if (response->m_response == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_response.get(); - auto _res = std::make_shared(); - PyMoneroGetHeightResponse::from_property_tree(res, _res); - return !_res->m_untrusted.get(); + auto res = m_rpc->send_path_request("get_height"); + auto get_height_response = std::make_shared(); + PyMoneroGetHeightResponse::from_property_tree(res, get_height_response); + return !get_height_response->m_untrusted.get(); } uint64_t PyMoneroDaemonRpc::get_height() { - PyMoneroJsonRequest request("get_block_count"); - std::shared_ptr response = m_rpc->send_json_request(request); - - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); - + auto res = m_rpc->send_json_request("get_block_count"); std::shared_ptr result = std::make_shared(); PyMoneroGetBlockCountResult::from_property_tree(res, result); - if (result->m_count == boost::none) throw std::runtime_error("Could not get height"); - return result->m_count.get(); } std::string PyMoneroDaemonRpc::get_block_hash(uint64_t height) { std::shared_ptr params = std::make_shared(height); - - PyMoneroJsonRequest request("on_get_block_hash", params); - std::shared_ptr response = m_rpc->send_json_request(request); - - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); - + auto res = m_rpc->send_json_request("on_get_block_hash", params); return res.data(); } std::shared_ptr PyMoneroDaemonRpc::get_block_template(const std::string& wallet_address, int reserve_size) { auto params = std::make_shared(wallet_address, reserve_size); - PyMoneroJsonRequest request("get_block_template", params); - std::shared_ptr response = m_rpc->send_json_request(request); - - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); - + auto res = m_rpc->send_json_request("get_block_template", params); std::shared_ptr tmplt = std::make_shared(); PyMoneroBlockTemplate::from_property_tree(res, tmplt); return tmplt; @@ -147,24 +120,14 @@ std::shared_ptr PyMoneroDaemonRpc::get_block_template(con std::shared_ptr PyMoneroDaemonRpc::get_block_template(const std::string& wallet_address) { auto params = std::make_shared(wallet_address); - PyMoneroJsonRequest request("get_block_template", params); - std::shared_ptr response = m_rpc->send_json_request(request); - - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); - + auto res = m_rpc->send_json_request("get_block_template", params); std::shared_ptr tmplt = std::make_shared(); PyMoneroBlockTemplate::from_property_tree(res, tmplt); return tmplt; } std::shared_ptr PyMoneroDaemonRpc::get_last_block_header() { - PyMoneroJsonRequest request("get_last_block_header"); - std::shared_ptr response = m_rpc->send_json_request(request); - - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); - + auto res = m_rpc->send_json_request("get_last_block_header"); std::shared_ptr header = std::make_shared(); PyMoneroBlockHeader::from_property_tree(res, header); return header; @@ -172,13 +135,7 @@ std::shared_ptr PyMoneroDaemonRpc::get_last_block_h std::shared_ptr PyMoneroDaemonRpc::get_block_header_by_hash(const std::string& hash) { std::shared_ptr params = std::make_shared(hash); - - PyMoneroJsonRequest request("get_block_header_by_hash", params); - - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); - + auto res = m_rpc->send_json_request("get_block_header_by_hash", params); std::shared_ptr header = std::make_shared(); PyMoneroBlockHeader::from_property_tree(res, header); return header; @@ -186,13 +143,7 @@ std::shared_ptr PyMoneroDaemonRpc::get_block_header std::shared_ptr PyMoneroDaemonRpc::get_block_header_by_height(uint64_t height) { std::shared_ptr params = std::make_shared(height); - - PyMoneroJsonRequest request("get_block_header_by_height", params); - - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); - + auto res = m_rpc->send_json_request("get_block_header_by_height", params); std::shared_ptr header = std::make_shared(); PyMoneroBlockHeader::from_property_tree(res, header); return header; @@ -200,12 +151,7 @@ std::shared_ptr PyMoneroDaemonRpc::get_block_header std::vector> PyMoneroDaemonRpc::get_block_headers_by_range(uint64_t start_height, uint64_t end_height) { auto params = std::make_shared(start_height, end_height); - PyMoneroJsonRequest request("get_block_headers_range", params); - - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); - + auto res = m_rpc->send_json_request("get_block_headers_range", params); std::vector> headers; PyMoneroBlockHeader::from_property_tree(res, headers); return headers; @@ -213,12 +159,7 @@ std::vector> PyMoneroDaemonRpc::get std::shared_ptr PyMoneroDaemonRpc::get_block_by_hash(const std::string& hash) { std::shared_ptr params = std::make_shared(hash); - - PyMoneroJsonRequest request("get_block", params); - - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); + auto res = m_rpc->send_json_request("get_block", params); auto block = std::make_shared(); PyMoneroBlock::from_property_tree(res, block); return block; @@ -246,12 +187,7 @@ std::vector> PyMoneroDaemonRpc::get_blocks std::shared_ptr PyMoneroDaemonRpc::get_block_by_height(uint64_t height) { std::shared_ptr params = std::make_shared(height); - - PyMoneroJsonRequest request("get_block", params); - - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); + auto res = m_rpc->send_json_request("get_block", params); auto block = std::make_shared(); PyMoneroBlock::from_property_tree(res, block); return block; @@ -349,16 +285,14 @@ std::vector PyMoneroDaemonRpc::get_block_hashes(const std::vector> PyMoneroDaemonRpc::get_txs(const std::vector& tx_hashes, bool prune) { if (tx_hashes.empty()) throw std::runtime_error("Must provide an array of transaction hashes"); auto params = std::make_shared(tx_hashes, prune); - PyMoneroPathRequest request("get_transactions", params); - std::shared_ptr response = m_rpc->send_path_request(request); - try { check_response_status(response); } + auto res = m_rpc->send_path_request("get_transactions", params); + try { check_response_status(res); } catch (const std::exception& ex) { if (std::string(ex.what()).find("Failed to parse hex representation of transaction hash") != std::string::npos) { throw std::runtime_error("Invalid transaction hash"); } throw; } - auto res = response->m_response.get(); std::vector> txs; PyMoneroTx::from_property_tree(res, txs); return txs; @@ -380,10 +314,7 @@ std::vector PyMoneroDaemonRpc::get_tx_hexes(const std::vector PyMoneroDaemonRpc::get_miner_tx_sum(uint64_t height, uint64_t num_blocks) { auto params = std::make_shared(height, num_blocks); - PyMoneroJsonRequest request("get_coinbase_tx_sum", params); - std::shared_ptr response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); + auto res = m_rpc->send_json_request("get_coinbase_tx_sum", params); auto sum = std::make_shared(); PyMoneroMinerTxSum::from_property_tree(res, sum); return sum; @@ -391,10 +322,7 @@ std::shared_ptr PyMoneroDaemonRpc::get_miner_tx_sum(uint64_t std::shared_ptr PyMoneroDaemonRpc::get_fee_estimate(uint64_t grace_blocks) { auto params = std::make_shared(grace_blocks); - PyMoneroJsonRequest request("get_fee_estimate", params); - std::shared_ptr response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); + auto res = m_rpc->send_json_request("get_fee_estimate", params); auto estimate = std::make_shared(); PyMoneroFeeEstimate::from_property_tree(res, estimate); return estimate; @@ -402,16 +330,13 @@ std::shared_ptr PyMoneroDaemonRpc::get_fee_estimate(uint64_ std::shared_ptr PyMoneroDaemonRpc::submit_tx_hex(const std::string& tx_hex, bool do_not_relay) { auto params = std::make_shared(tx_hex, do_not_relay); - PyMoneroPathRequest request("send_raw_transaction", params); - std::shared_ptr response = m_rpc->send_path_request(request); - if (response->m_response == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_response.get(); + auto res = m_rpc->send_path_request("send_raw_transaction", params); auto sum = std::make_shared(); PyMoneroSubmitTxResult::from_property_tree(res, sum); // set m_is_good based on status try { - check_response_status(response); + check_response_status(res); sum->m_is_good = true; } catch (...) { sum->m_is_good = false; @@ -421,44 +346,33 @@ std::shared_ptr PyMoneroDaemonRpc::submit_tx_hex(const s void PyMoneroDaemonRpc::relay_txs_by_hash(const std::vector& tx_hashes) { auto params = std::make_shared(tx_hashes); - PyMoneroJsonRequest request("relay_tx", params); - std::shared_ptr response = m_rpc->send_json_request(request); - check_response_status(response); + auto res = m_rpc->send_json_request("relay_tx", params); + check_response_status(res); } std::shared_ptr PyMoneroDaemonRpc::get_tx_pool_stats() { - PyMoneroPathRequest request("get_transaction_pool_stats"); - std::shared_ptr response = m_rpc->send_path_request(request); - if (response->m_response == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_response.get(); + auto res = m_rpc->send_path_request("get_transaction_pool_stats"); auto stats = std::make_shared(); PyMoneroTxPoolStats::from_property_tree(res, stats); return stats; } std::vector> PyMoneroDaemonRpc::get_tx_pool() { - PyMoneroPathRequest request("get_transaction_pool"); - std::shared_ptr response = m_rpc->send_path_request(request); - if (response->m_response == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_response.get(); + auto res = m_rpc->send_path_request("get_transaction_pool"); std::vector> pool; PyMoneroTx::from_property_tree(res, pool); return pool; } std::vector PyMoneroDaemonRpc::get_tx_pool_hashes() { - PyMoneroPathRequest request("get_transaction_pool_hashes"); - std::shared_ptr response = m_rpc->send_path_request(request); - if (response->m_response == boost::none) throw std::runtime_error("Invalid Monero RPC response"); - auto res = response->m_response.get(); + auto res = m_rpc->send_path_request("get_transaction_pool_hashes"); return PyMoneroTxHashes::from_property_tree(res); } void PyMoneroDaemonRpc::flush_tx_pool(const std::vector &hashes) { auto params = std::make_shared(hashes); - PyMoneroJsonRequest request("flush_txpool", params); - std::shared_ptr response = m_rpc->send_json_request(request); - check_response_status(response); + auto res = m_rpc->send_json_request("flush_txpool", params); + check_response_status(res); } void PyMoneroDaemonRpc::flush_tx_pool() { @@ -475,10 +389,8 @@ void PyMoneroDaemonRpc::flush_tx_pool(const std::string &hash) { std::vector PyMoneroDaemonRpc::get_key_image_spent_statuses(const std::vector& key_images) { if (key_images.empty()) throw std::runtime_error("Must provide key images to check the status of"); auto params = std::make_shared(key_images); - PyMoneroPathRequest request("is_key_image_spent", params); - std::shared_ptr response = m_rpc->send_path_request(request); - check_response_status(response); - auto res = response->m_response.get(); + auto res = m_rpc->send_path_request("is_key_image_spent", params); + check_response_status(res); std::vector statuses; for (auto it = res.begin(); it != res.end(); ++it) { std::string key = it->first; @@ -507,44 +419,28 @@ std::vector> PyMoneroDaemonRpc::get_outpu std::vector> PyMoneroDaemonRpc::get_output_histogram(const std::vector& amounts, const boost::optional& min_count, const boost::optional& max_count, const boost::optional& is_unlocked, const boost::optional& recent_cutoff) { auto params = std::make_shared(amounts, min_count, max_count, is_unlocked, recent_cutoff); - PyMoneroJsonRequest request("get_output_histogram", params); - std::shared_ptr response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); + auto res = m_rpc->send_json_request("get_output_histogram", params); std::vector> entries; PyMoneroOutputHistogramEntry::from_property_tree(res, entries); return entries; } std::shared_ptr PyMoneroDaemonRpc::get_info() { - PyMoneroJsonRequest request("get_info"); - std::shared_ptr response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); + auto res = m_rpc->send_json_request("get_info"); std::shared_ptr info = std::make_shared(); PyMoneroDaemonInfo::from_property_tree(res, info); return info; } std::shared_ptr PyMoneroDaemonRpc::get_sync_info() { - PyMoneroJsonRequest request("sync_info"); - std::shared_ptr response = m_rpc->send_json_request(request); - - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); - + auto res = m_rpc->send_json_request("sync_info"); std::shared_ptr info = std::make_shared(); PyMoneroDaemonSyncInfo::from_property_tree(res, info); return info; } std::shared_ptr PyMoneroDaemonRpc::get_hard_fork_info() { - PyMoneroJsonRequest request("hard_fork_info"); - std::shared_ptr response = m_rpc->send_json_request(request); - - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); - + auto res = m_rpc->send_json_request("hard_fork_info"); std::shared_ptr info = std::make_shared(); PyMoneroHardForkInfo::from_property_tree(res, info); return info; @@ -552,12 +448,7 @@ std::shared_ptr PyMoneroDaemonRpc::get_hard_fork_info() { std::vector> PyMoneroDaemonRpc::get_alt_chains() { std::vector> result; - - PyMoneroJsonRequest request("get_alternate_chains"); - std::shared_ptr response = m_rpc->send_json_request(request); - - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); + auto res = m_rpc->send_json_request("get_alternate_chains"); for (boost::property_tree::ptree::const_iterator it = res.begin(); it != res.end(); ++it) { std::string key = it->first; @@ -576,10 +467,7 @@ std::vector> PyMoneroDaemonRpc::get_alt_chains } std::vector PyMoneroDaemonRpc::get_alt_block_hashes() { - PyMoneroPathRequest request("get_alt_blocks_hashes"); - std::shared_ptr response = m_rpc->send_path_request(request); - if (response->m_response == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_response.get(); + auto res = m_rpc->send_path_request("get_alt_blocks_hashes"); std::vector hashes; PyMoneroGetAltBlocksHashesResponse::from_property_tree(res, hashes); return hashes; @@ -626,24 +514,14 @@ int PyMoneroDaemonRpc::reset_upload_limit() { } std::vector> PyMoneroDaemonRpc::get_peers() { - PyMoneroJsonRequest request("get_connections"); - std::shared_ptr response = m_rpc->send_json_request(request); - - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); - + auto res = m_rpc->send_json_request("get_connections"); std::vector> peers; PyMoneroPeer::from_property_tree(res, peers); return peers; } std::vector> PyMoneroDaemonRpc::get_known_peers() { - PyMoneroPathRequest request("get_peer_list"); - std::shared_ptr response = m_rpc->send_path_request(request); - - if (response->m_response == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_response.get(); - + auto res = m_rpc->send_path_request("get_peer_list"); std::vector> peers; PyMoneroPeer::from_property_tree(res, peers); return peers; @@ -653,27 +531,20 @@ void PyMoneroDaemonRpc::set_outgoing_peer_limit(int limit) { if (limit < 0) throw std::runtime_error("Outgoing peer limit must be >= 0"); auto params = std::make_shared(); params->m_out_peers = limit; - PyMoneroPathRequest request("out_peers", params); - std::shared_ptr response = m_rpc->send_path_request(request); - check_response_status(response); + auto res = m_rpc->send_path_request("out_peers", params); + check_response_status(res); } void PyMoneroDaemonRpc::set_incoming_peer_limit(int limit) { if (limit < 0) throw std::runtime_error("Incoming peer limit must be >= 0"); auto params = std::make_shared(); params->m_in_peers = limit; - PyMoneroPathRequest request("in_peers", params); - std::shared_ptr response = m_rpc->send_path_request(request); - check_response_status(response); + auto res = m_rpc->send_path_request("in_peers", params); + check_response_status(res); } std::vector> PyMoneroDaemonRpc::get_peer_bans() { - PyMoneroJsonRequest request("get_bans"); - std::shared_ptr response = m_rpc->send_json_request(request); - - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); - + auto res = m_rpc->send_json_request("get_bans"); std::vector> bans; PyMoneroBan::from_property_tree(res, bans); return bans; @@ -681,32 +552,27 @@ std::vector> PyMoneroDaemonRpc::get_peer_bans() { void PyMoneroDaemonRpc::set_peer_bans(const std::vector>& bans) { auto params = std::make_shared(bans); - PyMoneroJsonRequest request("set_bans", params); - std::shared_ptr response = m_rpc->send_json_request(request); - check_response_status(response); + auto res = m_rpc->send_json_request("set_bans", params); + check_response_status(res); } void PyMoneroDaemonRpc::start_mining(const std::string &address, int num_threads, bool is_background, bool ignore_battery) { if (address.empty()) throw std::runtime_error("Must provide address to mine to"); if (num_threads <= 0) throw std::runtime_error("Number of threads must be an integer greater than 0"); auto params = std::make_shared(address, num_threads, is_background, ignore_battery); - PyMoneroPathRequest request("start_mining", params); - auto response = m_rpc->send_path_request(request); - check_response_status(response); + auto res = m_rpc->send_path_request("start_mining", params); + check_response_status(res); } void PyMoneroDaemonRpc::stop_mining() { - PyMoneroPathRequest request("stop_mining"); - auto response = m_rpc->send_path_request(request); - check_response_status(response); + auto res = m_rpc->send_path_request("stop_mining"); + check_response_status(res); } std::shared_ptr PyMoneroDaemonRpc::get_mining_status() { - PyMoneroPathRequest request("mining_status"); - auto response = m_rpc->send_path_request(request); - check_response_status(response); + auto res = m_rpc->send_path_request("mining_status"); + check_response_status(res); auto result = std::make_shared(); - auto res = response->m_response.get(); PyMoneroMiningStatus::from_property_tree(res, result); return result; } @@ -714,19 +580,13 @@ std::shared_ptr PyMoneroDaemonRpc::get_mining_status() { void PyMoneroDaemonRpc::submit_blocks(const std::vector& block_blobs) { if (block_blobs.empty()) throw std::runtime_error("Must provide an array of mined block blobs to submit"); auto params = std::make_shared(block_blobs); - PyMoneroJsonRequest request("submit_block", params); - std::shared_ptr response = m_rpc->send_json_request(request); - check_response_status(response); + auto res = m_rpc->send_json_request("submit_block", params); + check_response_status(res); } std::shared_ptr PyMoneroDaemonRpc::prune_blockchain(bool check) { auto params = std::make_shared(check); - PyMoneroJsonRequest request("prune_blockchain", params); - std::shared_ptr response = m_rpc->send_json_request(request); - - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); - + auto res = m_rpc->send_json_request("prune_blockchain", params); std::shared_ptr result = std::make_shared(); PyMoneroPruneResult::from_property_tree(res, result); return result; @@ -734,30 +594,25 @@ std::shared_ptr PyMoneroDaemonRpc::prune_blockchain(bool ch std::shared_ptr PyMoneroDaemonRpc::check_for_update() { auto params = std::make_shared("check"); - PyMoneroPathRequest request("update", params); - auto response = m_rpc->send_path_request(request); - check_response_status(response); + auto res = m_rpc->send_path_request("update", params); + check_response_status(res); auto result = std::make_shared(); - auto res = response->m_response.get(); PyMoneroDaemonUpdateCheckResult::from_property_tree(res, result); return result; } std::shared_ptr PyMoneroDaemonRpc::download_update(const std::string& path) { auto params = std::make_shared("download", path); - PyMoneroPathRequest request("update", params); - auto response = m_rpc->send_path_request(request); - check_response_status(response); + auto res = m_rpc->send_path_request("update", params); + check_response_status(res); auto result = std::make_shared(); - auto res = response->m_response.get(); PyMoneroDaemonUpdateDownloadResult::from_property_tree(res, result); return result; } void PyMoneroDaemonRpc::stop() { - PyMoneroPathRequest request("stop_daemon"); - std::shared_ptr response = m_rpc->send_path_request(request); - check_response_status(response); + auto res = m_rpc->send_path_request("stop_daemon"); + check_response_status(res); } std::shared_ptr PyMoneroDaemonRpc::wait_for_next_block_header() { @@ -783,10 +638,8 @@ std::shared_ptr PyMoneroDaemonRpc::wait_for_next_bl } std::shared_ptr PyMoneroDaemonRpc::get_bandwidth_limits() { - PyMoneroPathRequest request("get_limit"); - auto response = m_rpc->send_path_request(request); - check_response_status(response); - auto res = response->m_response.get(); + auto res = m_rpc->send_path_request("get_limit"); + check_response_status(res); auto limits = std::make_shared(); PyMoneroBandwithLimits::from_property_tree(res, limits); return limits; @@ -794,10 +647,8 @@ std::shared_ptr PyMoneroDaemonRpc::get_bandwidth_limits( std::shared_ptr PyMoneroDaemonRpc::set_bandwidth_limits(int up, int down) { auto limits = std::make_shared(up, down); - PyMoneroPathRequest request("set_limit", limits); - auto response = m_rpc->send_path_request(request); - check_response_status(response); - auto res = response->m_response.get(); + auto res = m_rpc->send_path_request("set_limit", limits); + check_response_status(res); PyMoneroBandwithLimits::from_property_tree(res, limits); return limits; } diff --git a/src/cpp/wallet/py_monero_wallet_rpc.cpp b/src/cpp/wallet/py_monero_wallet_rpc.cpp index 96c475b..78f4e18 100644 --- a/src/cpp/wallet/py_monero_wallet_rpc.cpp +++ b/src/cpp/wallet/py_monero_wallet_rpc.cpp @@ -222,8 +222,7 @@ PyMoneroWalletRpc* PyMoneroWalletRpc::open_wallet(const std::shared_ptrm_password != boost::none) password = config->m_password.get(); auto params = std::make_shared(path, password); - PyMoneroJsonRequest request("open_wallet", params); - m_rpc->send_json_request(request); + m_rpc->send_json_request("open_wallet", params); clear(); if (config->m_connection_manager != boost::none) { @@ -285,11 +284,7 @@ PyMoneroWalletRpc* PyMoneroWalletRpc::create_wallet(const std::shared_ptr PyMoneroWalletRpc::get_seed_languages() const { - PyMoneroJsonRequest request("get_languages"); - std::shared_ptr response = m_rpc->send_json_request(request); - - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("get_languages"); std::vector languages; for (auto it = node.begin(); it != node.end(); ++it) { @@ -308,8 +303,7 @@ std::vector PyMoneroWalletRpc::get_seed_languages() const { } void PyMoneroWalletRpc::stop() { - PyMoneroJsonRequest request("stop_wallet"); - m_rpc->send_json_request(request); + m_rpc->send_json_request("stop_wallet"); } bool PyMoneroWalletRpc::is_view_only() const { @@ -363,8 +357,7 @@ void PyMoneroWalletRpc::set_daemon_connection(const boost::optionalm_ssl_allow_any_cert = ssl_options->m_ssl_allow_any_cert; } - PyMoneroJsonRequest request("set_daemon", params); - m_rpc->send_json_request(request); + m_rpc->send_json_request("set_daemon", params); if (connection == boost::none || connection->m_uri == boost::none || connection->m_uri->empty()) { m_daemon_connection = nullptr; @@ -390,12 +383,7 @@ bool PyMoneroWalletRpc::is_connected_to_daemon() const { } monero::monero_version PyMoneroWalletRpc::get_version() const { - PyMoneroJsonRequest request("get_version"); - std::shared_ptr response = m_rpc->send_json_request(request); - - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); - + auto res = m_rpc->send_json_request("get_version"); std::shared_ptr info = std::make_shared(); PyMoneroVersion::from_property_tree(res, info); return *info; @@ -463,12 +451,7 @@ std::string PyMoneroWalletRpc::get_address(const uint32_t account_idx, const uin monero_subaddress PyMoneroWalletRpc::get_address_index(const std::string& address) const { auto params = std::make_shared(address); - PyMoneroJsonRequest request("get_address_index", params); - std::shared_ptr response = m_rpc->send_json_request(request); - - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); - + auto res = m_rpc->send_json_request("get_address_index", params); auto tmplt = std::make_shared(); PyMoneroSubaddress::from_property_tree(res, tmplt); return *tmplt; @@ -476,12 +459,7 @@ monero_subaddress PyMoneroWalletRpc::get_address_index(const std::string& addres monero_integrated_address PyMoneroWalletRpc::get_integrated_address(const std::string& standard_address, const std::string& payment_id) const { auto params = std::make_shared(standard_address, payment_id); - PyMoneroJsonRequest request("make_integrated_address", params); - std::shared_ptr response = m_rpc->send_json_request(request); - - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); - + auto res = m_rpc->send_json_request("make_integrated_address", params); auto tmplt = std::make_shared(); PyMoneroIntegratedAddress::from_property_tree(res, tmplt); return decode_integrated_address(tmplt->m_integrated_address); @@ -489,10 +467,7 @@ monero_integrated_address PyMoneroWalletRpc::get_integrated_address(const std::s monero_integrated_address PyMoneroWalletRpc::decode_integrated_address(const std::string& integrated_address) const { auto params = std::make_shared(integrated_address); - PyMoneroJsonRequest request("split_integrated_address", params); - std::shared_ptr response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); + auto res = m_rpc->send_json_request("split_integrated_address", params); auto tmplt = std::make_shared(); PyMoneroIntegratedAddress::from_property_tree(res, tmplt); tmplt->m_integrated_address = integrated_address; @@ -500,10 +475,7 @@ monero_integrated_address PyMoneroWalletRpc::decode_integrated_address(const std } uint64_t PyMoneroWalletRpc::get_height() const { - PyMoneroJsonRequest request("get_height"); - std::shared_ptr response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); + auto res = m_rpc->send_json_request("get_height"); return PyMoneroWalletGetHeightResponse::from_property_tree(res); } @@ -519,11 +491,8 @@ monero_sync_result PyMoneroWalletRpc::sync() { auto params = std::make_shared(); boost::lock_guard lock(m_sync_mutex); try { - PyMoneroJsonRequest request("refresh", params); - auto response = m_rpc->send_json_request(request); + auto node = m_rpc->send_json_request("refresh", params); poll(); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); monero_sync_result sync_result(0, false); for (auto it = node.begin(); it != node.end(); ++it) { @@ -552,11 +521,8 @@ monero_sync_result PyMoneroWalletRpc::sync(uint64_t start_height) { auto params = std::make_shared(start_height); boost::lock_guard lock(m_sync_mutex); try { - PyMoneroJsonRequest request("refresh", params); - auto response = m_rpc->send_json_request(request); + auto node = m_rpc->send_json_request("refresh", params); poll(); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); monero_sync_result sync_result(0, false); for (auto it = node.begin(); it != node.end(); ++it) { @@ -579,8 +545,7 @@ void PyMoneroWalletRpc::start_syncing(uint64_t sync_period_in_ms) { // send rpc request auto params = std::make_shared(true, sync_period_in_seconds); - PyMoneroJsonRequest request("auto_refresh", params); - auto response = m_rpc->send_json_request(request); + m_rpc->send_json_request("auto_refresh", params); // update sync period for poller m_sync_period_in_ms = sync_period_in_ms; @@ -592,26 +557,22 @@ void PyMoneroWalletRpc::start_syncing(uint64_t sync_period_in_ms) { void PyMoneroWalletRpc::stop_syncing() { auto params = std::make_shared(false); - PyMoneroJsonRequest request("auto_refresh", params); - m_rpc->send_json_request(request); + m_rpc->send_json_request("auto_refresh", params); } void PyMoneroWalletRpc::scan_txs(const std::vector& tx_hashes) { if (tx_hashes.empty()) throw std::runtime_error("No tx hashes given to scan"); auto params = std::make_shared(tx_hashes); - PyMoneroJsonRequest request("scan_tx", params); - m_rpc->send_json_request(request); + m_rpc->send_json_request("scan_tx", params); poll(); } void PyMoneroWalletRpc::rescan_spent() { - PyMoneroJsonRequest request("rescan_spent"); - m_rpc->send_json_request(request); + m_rpc->send_json_request("rescan_spent"); } void PyMoneroWalletRpc::rescan_blockchain() { - PyMoneroJsonRequest request("rescan_blockchain"); - m_rpc->send_json_request(request); + m_rpc->send_json_request("rescan_blockchain"); } uint64_t PyMoneroWalletRpc::get_balance() const { @@ -667,10 +628,7 @@ std::vector PyMoneroWalletRpc::get_accounts(bool include_subaddr std::vector PyMoneroWalletRpc::get_accounts(bool include_subaddresses, const std::string& tag, bool skip_balances) const { auto params = std::make_shared(tag); - PyMoneroJsonRequest request("get_accounts", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("get_accounts", params); std::vector accounts; PyMoneroAccount::from_property_tree(node, accounts); if (include_subaddresses) { @@ -691,10 +649,7 @@ std::vector PyMoneroWalletRpc::get_accounts(bool include_subaddr if (!skip_balances) { auto params2 = std::make_shared(true); - PyMoneroJsonRequest request2("get_balance", params2); - auto response2 = m_rpc->send_json_request(request2); - if (response2->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node2 = response2->m_result.get(); + auto node2 = m_rpc->send_json_request("get_balance", params2); auto bal_res = std::make_shared(); PyMoneroGetBalanceResponse::from_property_tree(node2, bal_res); for (const auto &subaddress : bal_res->m_per_subaddress) { @@ -717,10 +672,7 @@ std::vector PyMoneroWalletRpc::get_accounts(bool include_subaddr monero_account PyMoneroWalletRpc::create_account(const std::string& label) { auto params = std::make_shared(label); - PyMoneroJsonRequest request("create_account", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("create_account", params); monero_account res; res.m_balance = 0; res.m_unlocked_balance = 0; @@ -748,10 +700,7 @@ monero_account PyMoneroWalletRpc::create_account(const std::string& label) { std::vector PyMoneroWalletRpc::get_subaddresses(const uint32_t account_idx, const std::vector& subaddress_indices, bool skip_balances) const { // fetch subaddresses auto params = std::make_shared(account_idx, subaddress_indices); - PyMoneroJsonRequest request("get_address", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("get_address", params); std::vector subaddresses; // initialize subaddresses @@ -780,10 +729,7 @@ std::vector PyMoneroWalletRpc::get_subaddresses(const uint32_ } // fetch and initialize balances - PyMoneroJsonRequest request2("get_balance", params); - auto response2 = m_rpc->send_json_request(request); - if (response2->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node2 = response2->m_result.get(); + auto node2 = m_rpc->send_json_request("get_balance", params); std::vector> subaddresses2; PyMoneroSubaddress::from_rpc_property_tree(node2, subaddresses2); @@ -832,10 +778,7 @@ monero_subaddress PyMoneroWalletRpc::get_subaddress(const uint32_t account_idx, monero_subaddress PyMoneroWalletRpc::create_subaddress(uint32_t account_idx, const std::string& label) { auto params = std::make_shared(account_idx, label); - PyMoneroJsonRequest request("create_address", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("create_address", params); monero_subaddress sub; sub.m_account_index = account_idx; if (!label.empty()) sub.m_label = label; @@ -856,16 +799,12 @@ monero_subaddress PyMoneroWalletRpc::create_subaddress(uint32_t account_idx, con void PyMoneroWalletRpc::set_subaddress_label(uint32_t account_idx, uint32_t subaddress_idx, const std::string& label) { auto params = std::make_shared(account_idx, subaddress_idx, label); - PyMoneroJsonRequest request("label_address", params); - m_rpc->send_json_request(request); + m_rpc->send_json_request("label_address", params); } std::string PyMoneroWalletRpc::export_outputs(bool all) const { auto params = std::make_shared(all); - PyMoneroJsonRequest request("export_outputs", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("export_outputs", params); for (auto it = node.begin(); it != node.end(); ++it) { std::string key = it->first; @@ -878,10 +817,7 @@ std::string PyMoneroWalletRpc::export_outputs(bool all) const { int PyMoneroWalletRpc::import_outputs(const std::string& outputs_hex) { auto params = std::make_shared(outputs_hex); - PyMoneroJsonRequest request("import_outputs", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("import_outputs", params); int num_imported = 0; for (auto it = node.begin(); it != node.end(); ++it) { @@ -898,10 +834,7 @@ int PyMoneroWalletRpc::import_outputs(const std::string& outputs_hex) { std::vector> PyMoneroWalletRpc::export_key_images(bool all) const { auto params = std::make_shared(all); - PyMoneroJsonRequest request("export_key_images", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("export_key_images", params); std::vector> key_images; PyMoneroKeyImage::from_property_tree(node, key_images); return key_images; @@ -909,10 +842,7 @@ std::vector> PyMoneroWalletRpc::export_key_ima std::shared_ptr PyMoneroWalletRpc::import_key_images(const std::vector>& key_images) { auto params = std::make_shared(key_images); - PyMoneroJsonRequest request("import_key_images", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("import_key_images", params); auto import_result = std::make_shared(); PyMoneroKeyImageImportResult::from_property_tree(node, import_result); return import_result; @@ -920,22 +850,17 @@ std::shared_ptr PyMoneroWalletRpc::import_key_im void PyMoneroWalletRpc::freeze_output(const std::string& key_image) { auto params = std::make_shared(key_image); - PyMoneroJsonRequest request("freeze", params); - m_rpc->send_json_request(request); + m_rpc->send_json_request("freeze", params); } void PyMoneroWalletRpc::thaw_output(const std::string& key_image) { auto params = std::make_shared(key_image); - PyMoneroJsonRequest request("thaw", params); - m_rpc->send_json_request(request); + m_rpc->send_json_request("thaw", params); } bool PyMoneroWalletRpc::is_output_frozen(const std::string& key_image) { auto params = std::make_shared(key_image); - PyMoneroJsonRequest request("frozen", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("frozen", params); for(auto it = node.begin(); it != node.end(); ++it) { std::string key = it->first; @@ -947,10 +872,7 @@ bool PyMoneroWalletRpc::is_output_frozen(const std::string& key_image) { } monero_tx_priority PyMoneroWalletRpc::get_default_fee_priority() const { - PyMoneroJsonRequest request("get_default_fee_priority"); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("get_default_fee_priority"); for(auto it = node.begin(); it != node.end(); ++it) { std::string key = it->first; @@ -995,17 +917,14 @@ std::vector> PyMoneroWalletRpc::create_txs(con std::string request_path = "transfer"; if (bool_equals_2(true, config.m_can_split)) request_path = "transfer_split"; - PyMoneroJsonRequest request(request_path, params); - std::shared_ptr response; + boost::property_tree::ptree node; try { - response = m_rpc->send_json_request(request); + node = m_rpc->send_json_request(request_path, params); } catch (const PyMoneroRpcError& ex) { std::string message = ex.what(); if (message.find("WALLET_RPC_ERROR_CODE_WRONG_ADDRESS") != std::string::npos) throw PyMoneroError("Invalid destination address"); throw; } - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); // pre-initialize txs iff present. multisig and view-only wallets will have tx set without transactions std::vector> txs; @@ -1136,10 +1055,7 @@ std::shared_ptr PyMoneroWalletRpc::sweep_output(const monero_t if (destinations[0]->m_amount != boost::none) throw std::runtime_error("Cannot specify amount to sweep"); auto params = std::make_shared(config); - PyMoneroJsonRequest request("sweep_single", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("sweep_single", params); if (bool_equals_2(true, config.m_relay)) poll(); auto set = std::make_shared(); auto tx = std::make_shared(); @@ -1150,11 +1066,8 @@ std::shared_ptr PyMoneroWalletRpc::sweep_output(const monero_t std::vector> PyMoneroWalletRpc::sweep_dust(bool relay) { auto params = std::make_shared(relay); - PyMoneroJsonRequest request("sweep_dust", params); - auto response = m_rpc->send_json_request(request); + auto node = m_rpc->send_json_request("sweep_dust", params); if (relay) poll(); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); auto set = std::make_shared(); PyMoneroTxSet::from_sent_txs(node, set); return set->m_txs; @@ -1167,10 +1080,7 @@ std::vector PyMoneroWalletRpc::relay_txs(const std::vector(tx_metadata); - PyMoneroJsonRequest request("relay_tx", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("relay_tx", params); for (auto it = node.begin(); it != node.end(); ++it) { std::string key = it->first; @@ -1185,10 +1095,7 @@ monero_tx_set PyMoneroWalletRpc::describe_tx_set(const monero_tx_set& tx_set) { auto params = std::make_shared(); params->m_multisig_txset = tx_set.m_multisig_tx_hex; params->m_unsigned_txset = tx_set.m_unsigned_tx_hex; - PyMoneroJsonRequest request("describe_transfer", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("describe_transfer", params); auto set = std::make_shared(); PyMoneroTxSet::from_describe_transfer(node, set); return *set; @@ -1196,10 +1103,7 @@ monero_tx_set PyMoneroWalletRpc::describe_tx_set(const monero_tx_set& tx_set) { monero_tx_set PyMoneroWalletRpc::sign_txs(const std::string& unsigned_tx_hex) { auto params = std::make_shared(unsigned_tx_hex); - PyMoneroJsonRequest request("sign_transfer", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("sign_transfer", params); auto set = std::make_shared(); PyMoneroTxSet::from_sent_txs(node, set); return *set; @@ -1207,10 +1111,7 @@ monero_tx_set PyMoneroWalletRpc::sign_txs(const std::string& unsigned_tx_hex) { std::vector PyMoneroWalletRpc::submit_txs(const std::string& signed_tx_hex) { auto params = std::make_shared(signed_tx_hex); - PyMoneroJsonRequest request("submit_transfer", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("submit_transfer", params); poll(); std::vector hashes; @@ -1231,22 +1132,16 @@ std::vector PyMoneroWalletRpc::submit_txs(const std::string& signed std::string PyMoneroWalletRpc::sign_message(const std::string& msg, monero_message_signature_type signature_type, uint32_t account_idx, uint32_t subaddress_idx) const { auto params = std::make_shared(msg, signature_type, account_idx, subaddress_idx); - PyMoneroJsonRequest request("sign", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("sign", params); return PyMoneroReserveProofSignature::from_property_tree(node); } monero_message_signature_result PyMoneroWalletRpc::verify_message(const std::string& msg, const std::string& address, const std::string& signature) const { auto params = std::make_shared(msg, address, signature); - PyMoneroJsonRequest request("verify", params); auto sig_result = std::make_shared(); sig_result->m_is_good = false; try { - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("verify", params); PyMoneroMessageSignatureResult::from_property_tree(node, sig_result); } catch (const PyMoneroRpcError& ex) { if (ex.code != -2) throw; @@ -1258,10 +1153,8 @@ monero_message_signature_result PyMoneroWalletRpc::verify_message(const std::str std::string PyMoneroWalletRpc::get_tx_key(const std::string& tx_hash) const { try { auto params = std::make_shared(tx_hash); - PyMoneroJsonRequest request("get_tx_key", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("get_tx_key", params); + for (auto it = node.begin(); it != node.end(); ++it) { std::string key = it->first; @@ -1283,10 +1176,7 @@ std::string PyMoneroWalletRpc::get_tx_key(const std::string& tx_hash) const { std::shared_ptr PyMoneroWalletRpc::check_tx_key(const std::string& tx_hash, const std::string& tx_key, const std::string& address) const { try { auto params = std::make_shared(tx_hash, tx_key, address); - PyMoneroJsonRequest request("check_tx_key", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("check_tx_key", params); auto check = std::make_shared(); check->m_is_good = true; PyMoneroCheckTxProof::from_property_tree(node, check); @@ -1304,10 +1194,7 @@ std::string PyMoneroWalletRpc::get_tx_proof(const std::string& tx_hash, const st try { auto params = std::make_shared(tx_hash, message); params->m_address = address; - PyMoneroJsonRequest request("get_tx_proof", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("get_tx_proof", params); return PyMoneroReserveProofSignature::from_property_tree(node); } catch (const PyMoneroRpcError& ex) { if (ex.code == -8 && ex.what() == std::string("TX ID has invalid format")) { @@ -1321,10 +1208,7 @@ std::string PyMoneroWalletRpc::get_tx_proof(const std::string& tx_hash, const st std::shared_ptr PyMoneroWalletRpc::check_tx_proof(const std::string& tx_hash, const std::string& address, const std::string& message, const std::string& signature) const { try { auto params = std::make_shared(tx_hash, address, message, signature); - PyMoneroJsonRequest request("check_tx_proof", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("check_tx_proof", params); auto check = std::make_shared(); PyMoneroCheckTxProof::from_property_tree(node, check); return check; @@ -1343,10 +1227,7 @@ std::shared_ptr PyMoneroWalletRpc::check_tx_proof(const std::st std::string PyMoneroWalletRpc::get_spend_proof(const std::string& tx_hash, const std::string& message) const { try { auto params = std::make_shared(tx_hash, message); - PyMoneroJsonRequest request("get_spend_proof", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("get_spend_proof", params); return PyMoneroReserveProofSignature::from_property_tree(node); } catch (const PyMoneroRpcError& ex) { if (ex.code == -8 && ex.what() == std::string("TX ID has invalid format")) { @@ -1361,10 +1242,7 @@ bool PyMoneroWalletRpc::check_spend_proof(const std::string& tx_hash, const std: try { auto params = std::make_shared(tx_hash, message); params->m_signature = signature; - PyMoneroJsonRequest request("check_spend_proof", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("check_spend_proof", params); auto proof = std::make_shared(); PyMoneroCheckReserve::from_property_tree(node, proof); return proof->m_is_good; @@ -1379,28 +1257,19 @@ bool PyMoneroWalletRpc::check_spend_proof(const std::string& tx_hash, const std: std::string PyMoneroWalletRpc::get_reserve_proof_wallet(const std::string& message) const { auto params = std::make_shared(message); - PyMoneroJsonRequest request("get_reserve_proof", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("get_reserve_proof", params); return PyMoneroReserveProofSignature::from_property_tree(node); } std::string PyMoneroWalletRpc::get_reserve_proof_account(uint32_t account_idx, uint64_t amount, const std::string& message) const { auto params = std::make_shared(account_idx, amount, message); - PyMoneroJsonRequest request("get_reserve_proof", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("get_reserve_proof", params); return PyMoneroReserveProofSignature::from_property_tree(node); } std::shared_ptr PyMoneroWalletRpc::check_reserve_proof(const std::string& address, const std::string& message, const std::string& signature) const { auto params = std::make_shared(address, message, signature); - PyMoneroJsonRequest request("check_reserve_proof", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("check_reserve_proof", params); auto proof = std::make_shared(); PyMoneroCheckReserve::from_property_tree(node, proof); return proof; @@ -1416,10 +1285,7 @@ std::string PyMoneroWalletRpc::get_tx_note(const std::string& tx_hash) const { std::vector PyMoneroWalletRpc::get_tx_notes(const std::vector& tx_hashes) const { auto params = std::make_shared(tx_hashes); - PyMoneroJsonRequest request("get_tx_notes", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("get_tx_notes", params); std::vector notes; for (auto it = node.begin(); it != node.end(); ++it) { @@ -1448,16 +1314,12 @@ void PyMoneroWalletRpc::set_tx_note(const std::string& tx_hash, const std::strin void PyMoneroWalletRpc::set_tx_notes(const std::vector& tx_hashes, const std::vector& notes) { auto params = std::make_shared(tx_hashes, notes); - PyMoneroJsonRequest request("set_tx_notes", params); - m_rpc->send_json_request(request); + m_rpc->send_json_request("set_tx_notes", params); } std::vector PyMoneroWalletRpc::get_address_book_entries(const std::vector& indices) const { auto params = std::make_shared(indices); - PyMoneroJsonRequest request("get_address_book", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("get_address_book", params); std::vector> entries_ptr; PyMoneroAddressBookEntry::from_property_tree(node, entries_ptr); std::vector entries; @@ -1471,10 +1333,7 @@ std::vector PyMoneroWalletRpc::get_address_book_entri uint64_t PyMoneroWalletRpc::add_address_book_entry(const std::string& address, const std::string& description) { auto params = std::make_shared(address, description); - PyMoneroJsonRequest request("add_address_book", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("add_address_book", params); for (auto it = node.begin(); it != node.end(); ++it) { std::string key = it->first; @@ -1489,33 +1348,26 @@ uint64_t PyMoneroWalletRpc::add_address_book_entry(const std::string& address, c void PyMoneroWalletRpc::edit_address_book_entry(uint64_t index, bool set_address, const std::string& address, bool set_description, const std::string& description) { auto params = std::make_shared(index, set_address, address, set_description, description); - PyMoneroJsonRequest request("edit_address_book", params); - m_rpc->send_json_request(request); + m_rpc->send_json_request("edit_address_book", params); } void PyMoneroWalletRpc::delete_address_book_entry(uint64_t index) { auto params = std::make_shared(index); - PyMoneroJsonRequest request("delete_address_book", params); - m_rpc->send_json_request(request); + m_rpc->send_json_request("delete_address_book", params); } void PyMoneroWalletRpc::tag_accounts(const std::string& tag, const std::vector& account_indices) { auto params = std::make_shared(tag, account_indices); - PyMoneroJsonRequest request("tag_accounts", params); - m_rpc->send_json_request(request); + m_rpc->send_json_request("tag_accounts", params); } void PyMoneroWalletRpc::untag_accounts(const std::vector& account_indices) { auto params = std::make_shared(account_indices); - PyMoneroJsonRequest request("untag_accounts", params); - m_rpc->send_json_request(request); + m_rpc->send_json_request("untag_accounts", params); } std::vector> PyMoneroWalletRpc::get_account_tags() { - PyMoneroJsonRequest request("get_account_tags"); - std::shared_ptr response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); + auto res = m_rpc->send_json_request("get_account_tags"); std::vector> account_tags; PyMoneroAccountTag::from_property_tree(res, account_tags); return account_tags; @@ -1523,25 +1375,18 @@ std::vector> PyMoneroWalletRpc::get_account_ void PyMoneroWalletRpc::set_account_tag_label(const std::string& tag, const std::string& label) { auto params = std::make_shared(tag, label); - PyMoneroJsonRequest request("set_account_tag_description", params); - m_rpc->send_json_request(request); + m_rpc->send_json_request("set_account_tag_description", params); } std::string PyMoneroWalletRpc::get_payment_uri(const monero_tx_config& config) const { auto params = std::make_shared(config); - PyMoneroJsonRequest request("make_uri", params); - std::shared_ptr response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); + auto res = m_rpc->send_json_request("make_uri", params); return PyMoneroGetPaymentUriResponse::from_property_tree(res); } std::shared_ptr PyMoneroWalletRpc::parse_payment_uri(const std::string& uri) const { auto params = std::make_shared(uri); - PyMoneroJsonRequest request("parse_uri", params); - std::shared_ptr response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); + auto res = m_rpc->send_json_request("parse_uri", params); auto uri_response = std::make_shared(); PyMoneroParsePaymentUriResponse::from_property_tree(res, uri_response); return uri_response->to_tx_config(); @@ -1549,17 +1394,13 @@ std::shared_ptr PyMoneroWalletRpc::parse_payment_uri(const std void PyMoneroWalletRpc::set_attribute(const std::string& key, const std::string& val) { auto params = std::make_shared(key, val); - PyMoneroJsonRequest request("set_attribute", params); - m_rpc->send_json_request(request); + m_rpc->send_json_request("set_attribute", params); } bool PyMoneroWalletRpc::get_attribute(const std::string& key, std::string& value) const { try { auto params = std::make_shared(key); - PyMoneroJsonRequest request("get_attribute", params); - std::shared_ptr response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); + auto res = m_rpc->send_json_request("get_attribute", params); PyMoneroWalletAttributeParams::from_property_tree(res, params); if (params->m_value == boost::none) return false; value = params->m_value.get(); @@ -1577,31 +1418,23 @@ bool PyMoneroWalletRpc::get_attribute(const std::string& key, std::string& value void PyMoneroWalletRpc::start_mining(boost::optional num_threads, boost::optional background_mining, boost::optional ignore_battery) { auto params = std::make_shared(num_threads.value_or(0), background_mining.value_or(false), ignore_battery.value_or(false)); - PyMoneroJsonRequest request("start_mining", params); - auto response = m_rpc->send_json_request(request); + auto response = m_rpc->send_json_request("start_mining", params); // TODO PyMoneroDaemonRpc::check_response_status(response); } void PyMoneroWalletRpc::stop_mining() { - PyMoneroJsonRequest request("stop_mining"); - m_rpc->send_json_request(request); + m_rpc->send_json_request("stop_mining"); } bool PyMoneroWalletRpc::is_multisig_import_needed() const { - PyMoneroJsonRequest request("get_balance"); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); + auto res = m_rpc->send_json_request("get_balance"); auto balance = std::make_shared(); PyMoneroGetBalanceResponse::from_property_tree(res, balance); return bool_equals_2(true, balance->m_multisig_import_needed); } monero_multisig_info PyMoneroWalletRpc::get_multisig_info() const { - PyMoneroJsonRequest request("is_multisig"); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); + auto res = m_rpc->send_json_request("is_multisig"); auto info = std::make_shared(); PyMoneroMultisigInfo::from_property_tree(res, info); return *info; @@ -1609,59 +1442,41 @@ monero_multisig_info PyMoneroWalletRpc::get_multisig_info() const { std::string PyMoneroWalletRpc::prepare_multisig() { auto params = std::make_shared(); - PyMoneroJsonRequest request("prepare_multisig", params); - auto response = m_rpc->send_json_request(request); + auto res = m_rpc->send_json_request("prepare_multisig", params); clear_address_cache(); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); return PyMoneroPrepareMakeMultisigResponse::from_property_tree(res); } std::string PyMoneroWalletRpc::make_multisig(const std::vector& multisig_hexes, int threshold, const std::string& password) { auto params = std::make_shared(multisig_hexes, threshold, password); - PyMoneroJsonRequest request("make_multisig", params); - auto response = m_rpc->send_json_request(request); + auto res = m_rpc->send_json_request("make_multisig", params); clear_address_cache(); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); return PyMoneroPrepareMakeMultisigResponse::from_property_tree(res); } monero_multisig_init_result PyMoneroWalletRpc::exchange_multisig_keys(const std::vector& multisig_hexes, const std::string& password) { auto params = std::make_shared(multisig_hexes, password); - PyMoneroJsonRequest request("exchange_multisig_keys", params); - auto response = m_rpc->send_json_request(request); + auto res = m_rpc->send_json_request("exchange_multisig_keys", params); clear_address_cache(); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); auto multisig_init = std::make_shared(); PyMoneroMultisigInitResult::from_property_tree(res, multisig_init); return *multisig_init; } std::string PyMoneroWalletRpc::export_multisig_hex() { - PyMoneroJsonRequest request("export_multisig_info"); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); + auto res = m_rpc->send_json_request("export_multisig_info"); return PyMoneroExportMultisigHexResponse::from_property_tree(res); } int PyMoneroWalletRpc::import_multisig_hex(const std::vector& multisig_hexes) { auto params = std::make_shared(multisig_hexes); - PyMoneroJsonRequest request("import_multisig_info", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); + auto res = m_rpc->send_json_request("import_multisig_info", params); return PyMoneroImportMultisigHexResponse::from_property_tree(res); } monero_multisig_sign_result PyMoneroWalletRpc::sign_multisig_tx_hex(const std::string& multisig_tx_hex) { auto params = std::make_shared(multisig_tx_hex); - PyMoneroJsonRequest request("sign_multisig", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); + auto res = m_rpc->send_json_request("sign_multisig", params); auto multisig_result = std::make_shared(); PyMoneroMultisigSignResult::from_property_tree(res, multisig_result); return *multisig_result; @@ -1669,22 +1484,17 @@ monero_multisig_sign_result PyMoneroWalletRpc::sign_multisig_tx_hex(const std::s std::vector PyMoneroWalletRpc::submit_multisig_tx_hex(const std::string& signed_multisig_tx_hex) { auto params = std::make_shared(signed_multisig_tx_hex); - PyMoneroJsonRequest request("submit_multisig", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); + auto res = m_rpc->send_json_request("submit_multisig", params); return PyMoneroSubmitMultisigTxHexResponse::from_property_tree(res); } void PyMoneroWalletRpc::change_password(const std::string& old_password, const std::string& new_password) { auto params = std::make_shared(old_password, new_password); - PyMoneroJsonRequest request("change_wallet_password", params); - m_rpc->send_json_request(request); + m_rpc->send_json_request("change_wallet_password", params); } void PyMoneroWalletRpc::save() { - PyMoneroJsonRequest request("store"); - m_rpc->send_json_request(request); + m_rpc->send_json_request("store"); } bool PyMoneroWalletRpc::is_closed() const { @@ -1701,8 +1511,7 @@ void PyMoneroWalletRpc::close(bool save) { MTRACE("PyMoneroWalletRpc::close()"); clear(); auto params = std::make_shared(save); - PyMoneroJsonRequest request("close_wallet", params); - m_rpc->send_json_request(request); + m_rpc->send_json_request("close_wallet", params); } std::shared_ptr PyMoneroWalletRpc::get_balances(boost::optional account_idx, boost::optional subaddress_idx) const { @@ -1722,10 +1531,7 @@ std::shared_ptr PyMoneroWalletRpc::get_balances(boost::op } else { auto params = std::make_shared(account_idx.get(), subaddress_idx); - PyMoneroJsonRequest request("get_balance", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto res = response->m_result.get(); + auto res = m_rpc->send_json_request("get_balance", params); auto bal_res = std::make_shared(); PyMoneroGetBalanceResponse::from_property_tree(res, bal_res); @@ -1759,8 +1565,7 @@ PyMoneroWalletRpc* PyMoneroWalletRpc::create_wallet_random(const std::shared_ptr std::string language = config.m_language.get(); auto params = std::make_shared(filename, password, language); - PyMoneroJsonRequest request("create_wallet", params); - try { m_rpc->send_json_request(request); } + try { m_rpc->send_json_request("create_wallet", params); } catch (const PyMoneroRpcError& ex) { handle_create_wallet_error(ex, filename); } clear(); m_path = config.m_path.get(); @@ -1781,8 +1586,7 @@ PyMoneroWalletRpc* PyMoneroWalletRpc::create_wallet_from_seed(const std::shared_ if (config.m_save_current != boost::none) autosave_current = config.m_save_current.get(); if (config.m_is_multisig != boost::none) enable_multisig_experimental = config.m_is_multisig.get(); auto params = std::make_shared(filename, password, seed, seed_offset, restore_height, language, autosave_current, enable_multisig_experimental); - PyMoneroJsonRequest request("restore_deterministic_wallet", params); - try { m_rpc->send_json_request(request); } + try { m_rpc->send_json_request("restore_deterministic_wallet", params); } catch (const PyMoneroRpcError& ex) { handle_create_wallet_error(ex, filename); } clear(); m_path = config.m_path.get(); @@ -1803,8 +1607,7 @@ PyMoneroWalletRpc* PyMoneroWalletRpc::create_wallet_from_keys(const std::shared_ bool autosave_current = false; if (config->m_save_current != boost::none) autosave_current = config->m_save_current.get(); auto params = std::make_shared(filename, password, address, view_key, spend_key, restore_height, autosave_current); - PyMoneroJsonRequest request("generate_from_keys", params); - try { m_rpc->send_json_request(request); } + try { m_rpc->send_json_request("generate_from_keys", params); } catch (const PyMoneroRpcError& ex) { handle_create_wallet_error(ex, filename); } clear(); m_path = config->m_path.get(); @@ -1813,11 +1616,7 @@ PyMoneroWalletRpc* PyMoneroWalletRpc::create_wallet_from_keys(const std::shared_ std::string PyMoneroWalletRpc::query_key(const std::string& key_type) const { auto params = std::make_shared(key_type); - PyMoneroJsonRequest request("query_key", params); - std::shared_ptr response = m_rpc->send_json_request(request); - - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("query_key", params); for (boost::property_tree::ptree::const_iterator it = node.begin(); it != node.end(); ++it) { std::string key = it->first; @@ -1852,10 +1651,7 @@ std::vector> PyMoneroWalletRpc::sweep_account( auto params = std::make_shared(config); params->m_get_tx_key = boost::none; params->m_get_tx_keys = true; - PyMoneroJsonRequest request("sweep_all", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("sweep_all", params); if (bool_equals_2(true, config.m_relay)) poll(); std::vector> txs; auto set = std::make_shared(); @@ -2076,10 +1872,7 @@ std::map> PyMoneroWalletRpc::get_account_indices std::vector PyMoneroWalletRpc::get_subaddress_indices(uint32_t account_idx) const { // fetch subaddresses auto params = std::make_shared(account_idx); - PyMoneroJsonRequest request("get_address", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("get_address", params); std::vector subadress_indices; // TODO refactory for (auto it = node.begin(); it != node.end(); ++it) { @@ -2175,10 +1968,7 @@ std::vector> PyMoneroWalletRpc::get_transfers_a } // build txs using `get_transfers` - PyMoneroJsonRequest request("get_transfers", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("get_transfers", params); PyMoneroTxWallet::from_property_tree_with_transfer_and_merge(node, tx_map, block_map); @@ -2281,10 +2071,7 @@ std::vector> PyMoneroWalletRpc::get_output params->m_account_index = account_idx; params->m_subaddr_indices = kv.second; // send request - PyMoneroJsonRequest request("incoming_transfers", params); - auto response = m_rpc->send_json_request(request); - if (response->m_result == boost::none) throw std::runtime_error("Invalid Monero JSONRPC response"); - auto node = response->m_result.get(); + auto node = m_rpc->send_json_request("incoming_transfers", params); // convert response to txs with outputs and merge PyMoneroTxWallet::from_property_tree_with_output_and_merge(node, tx_map, block_map);