@@ -90,14 +90,10 @@ monero::monero_version PyMoneroDaemonRpc::get_version() {
9090}
9191
9292bool PyMoneroDaemonRpc::is_trusted () {
93- PyMoneroPathRequest request (" get_height" );
94- std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request (request);
95-
96- if (response->m_response == boost::none) throw std::runtime_error (" Invalid Monero JSONRPC response" );
97- auto res = response->m_response .get ();
98- auto _res = std::make_shared<PyMoneroGetHeightResponse>();
99- PyMoneroGetHeightResponse::from_property_tree (res, _res);
100- return !_res->m_untrusted .get ();
93+ auto res = m_rpc->send_path_request (" get_height" );
94+ auto get_height_response = std::make_shared<PyMoneroGetHeightResponse>();
95+ PyMoneroGetHeightResponse::from_property_tree (res, get_height_response);
96+ return !get_height_response->m_untrusted .get ();
10197}
10298
10399uint64_t PyMoneroDaemonRpc::get_height () {
@@ -289,16 +285,14 @@ std::vector<std::string> PyMoneroDaemonRpc::get_block_hashes(const std::vector<s
289285std::vector<std::shared_ptr<monero::monero_tx>> PyMoneroDaemonRpc::get_txs (const std::vector<std::string>& tx_hashes, bool prune) {
290286 if (tx_hashes.empty ()) throw std::runtime_error (" Must provide an array of transaction hashes" );
291287 auto params = std::make_shared<PyMoneroGetTxsParams>(tx_hashes, prune);
292- PyMoneroPathRequest request (" get_transactions" , params);
293- std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request (request);
294- try { check_response_status (response); }
288+ auto res = m_rpc->send_path_request (" get_transactions" , params);
289+ try { check_response_status (res); }
295290 catch (const std::exception& ex) {
296291 if (std::string (ex.what ()).find (" Failed to parse hex representation of transaction hash" ) != std::string::npos) {
297292 throw std::runtime_error (" Invalid transaction hash" );
298293 }
299294 throw ;
300295 }
301- auto res = response->m_response .get ();
302296 std::vector<std::shared_ptr<monero::monero_tx>> txs;
303297 PyMoneroTx::from_property_tree (res, txs);
304298 return txs;
@@ -336,16 +330,13 @@ std::shared_ptr<PyMoneroFeeEstimate> PyMoneroDaemonRpc::get_fee_estimate(uint64_
336330
337331std::shared_ptr<PyMoneroSubmitTxResult> PyMoneroDaemonRpc::submit_tx_hex (const std::string& tx_hex, bool do_not_relay) {
338332 auto params = std::make_shared<PyMoneroSubmitTxParams>(tx_hex, do_not_relay);
339- PyMoneroPathRequest request (" send_raw_transaction" , params);
340- std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request (request);
341- if (response->m_response == boost::none) throw std::runtime_error (" Invalid Monero JSONRPC response" );
342- auto res = response->m_response .get ();
333+ auto res = m_rpc->send_path_request (" send_raw_transaction" , params);
343334 auto sum = std::make_shared<PyMoneroSubmitTxResult>();
344335 PyMoneroSubmitTxResult::from_property_tree (res, sum);
345336
346337 // set m_is_good based on status
347338 try {
348- check_response_status (response );
339+ check_response_status (res );
349340 sum->m_is_good = true ;
350341 } catch (...) {
351342 sum->m_is_good = false ;
@@ -367,20 +358,14 @@ std::shared_ptr<PyMoneroTxPoolStats> PyMoneroDaemonRpc::get_tx_pool_stats() {
367358}
368359
369360std::vector<std::shared_ptr<monero::monero_tx>> PyMoneroDaemonRpc::get_tx_pool () {
370- PyMoneroPathRequest request (" get_transaction_pool" );
371- std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request (request);
372- if (response->m_response == boost::none) throw std::runtime_error (" Invalid Monero JSONRPC response" );
373- auto res = response->m_response .get ();
361+ auto res = m_rpc->send_path_request (" get_transaction_pool" );
374362 std::vector<std::shared_ptr<monero::monero_tx>> pool;
375363 PyMoneroTx::from_property_tree (res, pool);
376364 return pool;
377365}
378366
379367std::vector<std::string> PyMoneroDaemonRpc::get_tx_pool_hashes () {
380- PyMoneroPathRequest request (" get_transaction_pool_hashes" );
381- std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request (request);
382- if (response->m_response == boost::none) throw std::runtime_error (" Invalid Monero RPC response" );
383- auto res = response->m_response .get ();
368+ auto res = m_rpc->send_path_request (" get_transaction_pool_hashes" );
384369 return PyMoneroTxHashes::from_property_tree (res);
385370}
386371
@@ -404,10 +389,8 @@ void PyMoneroDaemonRpc::flush_tx_pool(const std::string &hash) {
404389std::vector<PyMoneroKeyImageSpentStatus> PyMoneroDaemonRpc::get_key_image_spent_statuses (const std::vector<std::string>& key_images) {
405390 if (key_images.empty ()) throw std::runtime_error (" Must provide key images to check the status of" );
406391 auto params = std::make_shared<PyMoneroIsKeyImageSpentParams>(key_images);
407- PyMoneroPathRequest request (" is_key_image_spent" , params);
408- std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request (request);
409- check_response_status (response);
410- auto res = response->m_response .get ();
392+ auto res = m_rpc->send_path_request (" is_key_image_spent" , params);
393+ check_response_status (res);
411394 std::vector<PyMoneroKeyImageSpentStatus> statuses;
412395 for (auto it = res.begin (); it != res.end (); ++it) {
413396 std::string key = it->first ;
@@ -484,10 +467,7 @@ std::vector<std::shared_ptr<PyMoneroAltChain>> PyMoneroDaemonRpc::get_alt_chains
484467}
485468
486469std::vector<std::string> PyMoneroDaemonRpc::get_alt_block_hashes () {
487- PyMoneroPathRequest request (" get_alt_blocks_hashes" );
488- std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request (request);
489- if (response->m_response == boost::none) throw std::runtime_error (" Invalid Monero JSONRPC response" );
490- auto res = response->m_response .get ();
470+ auto res = m_rpc->send_path_request (" get_alt_blocks_hashes" );
491471 std::vector<std::string> hashes;
492472 PyMoneroGetAltBlocksHashesResponse::from_property_tree (res, hashes);
493473 return hashes;
@@ -541,12 +521,7 @@ std::vector<std::shared_ptr<PyMoneroPeer>> PyMoneroDaemonRpc::get_peers() {
541521}
542522
543523std::vector<std::shared_ptr<PyMoneroPeer>> PyMoneroDaemonRpc::get_known_peers () {
544- PyMoneroPathRequest request (" get_peer_list" );
545- std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request (request);
546-
547- if (response->m_response == boost::none) throw std::runtime_error (" Invalid Monero JSONRPC response" );
548- auto res = response->m_response .get ();
549-
524+ auto res = m_rpc->send_path_request (" get_peer_list" );
550525 std::vector<std::shared_ptr<PyMoneroPeer>> peers;
551526 PyMoneroPeer::from_property_tree (res, peers);
552527 return peers;
@@ -556,18 +531,16 @@ void PyMoneroDaemonRpc::set_outgoing_peer_limit(int limit) {
556531 if (limit < 0 ) throw std::runtime_error (" Outgoing peer limit must be >= 0" );
557532 auto params = std::make_shared<PyMoneroPeerLimits>();
558533 params->m_out_peers = limit;
559- PyMoneroPathRequest request (" out_peers" , params);
560- std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request (request);
561- check_response_status (response);
534+ auto res = m_rpc->send_path_request (" out_peers" , params);
535+ check_response_status (res);
562536}
563537
564538void PyMoneroDaemonRpc::set_incoming_peer_limit (int limit) {
565539 if (limit < 0 ) throw std::runtime_error (" Incoming peer limit must be >= 0" );
566540 auto params = std::make_shared<PyMoneroPeerLimits>();
567541 params->m_in_peers = limit;
568- PyMoneroPathRequest request (" in_peers" , params);
569- std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request (request);
570- check_response_status (response);
542+ auto res = m_rpc->send_path_request (" in_peers" , params);
543+ check_response_status (res);
571544}
572545
573546std::vector<std::shared_ptr<PyMoneroBan>> PyMoneroDaemonRpc::get_peer_bans () {
@@ -587,23 +560,19 @@ void PyMoneroDaemonRpc::start_mining(const std::string &address, int num_threads
587560 if (address.empty ()) throw std::runtime_error (" Must provide address to mine to" );
588561 if (num_threads <= 0 ) throw std::runtime_error (" Number of threads must be an integer greater than 0" );
589562 auto params = std::make_shared<PyMoneroStartMiningParams>(address, num_threads, is_background, ignore_battery);
590- PyMoneroPathRequest request (" start_mining" , params);
591- auto response = m_rpc->send_path_request (request);
592- check_response_status (response);
563+ auto res = m_rpc->send_path_request (" start_mining" , params);
564+ check_response_status (res);
593565}
594566
595567void PyMoneroDaemonRpc::stop_mining () {
596- PyMoneroPathRequest request (" stop_mining" );
597- auto response = m_rpc->send_path_request (request);
598- check_response_status (response);
568+ auto res = m_rpc->send_path_request (" stop_mining" );
569+ check_response_status (res);
599570}
600571
601572std::shared_ptr<PyMoneroMiningStatus> PyMoneroDaemonRpc::get_mining_status () {
602- PyMoneroPathRequest request (" mining_status" );
603- auto response = m_rpc->send_path_request (request);
604- check_response_status (response);
573+ auto res = m_rpc->send_path_request (" mining_status" );
574+ check_response_status (res);
605575 auto result = std::make_shared<PyMoneroMiningStatus>();
606- auto res = response->m_response .get ();
607576 PyMoneroMiningStatus::from_property_tree (res, result);
608577 return result;
609578}
@@ -625,30 +594,25 @@ std::shared_ptr<PyMoneroPruneResult> PyMoneroDaemonRpc::prune_blockchain(bool ch
625594
626595std::shared_ptr<PyMoneroDaemonUpdateCheckResult> PyMoneroDaemonRpc::check_for_update () {
627596 auto params = std::make_shared<PyMoneroDownloadUpdateParams>(" check" );
628- PyMoneroPathRequest request (" update" , params);
629- auto response = m_rpc->send_path_request (request);
630- check_response_status (response);
597+ auto res = m_rpc->send_path_request (" update" , params);
598+ check_response_status (res);
631599 auto result = std::make_shared<PyMoneroDaemonUpdateCheckResult>();
632- auto res = response->m_response .get ();
633600 PyMoneroDaemonUpdateCheckResult::from_property_tree (res, result);
634601 return result;
635602}
636603
637604std::shared_ptr<PyMoneroDaemonUpdateDownloadResult> PyMoneroDaemonRpc::download_update (const std::string& path) {
638605 auto params = std::make_shared<PyMoneroDownloadUpdateParams>(" download" , path);
639- PyMoneroPathRequest request (" update" , params);
640- auto response = m_rpc->send_path_request (request);
641- check_response_status (response);
606+ auto res = m_rpc->send_path_request (" update" , params);
607+ check_response_status (res);
642608 auto result = std::make_shared<PyMoneroDaemonUpdateDownloadResult>();
643- auto res = response->m_response .get ();
644609 PyMoneroDaemonUpdateDownloadResult::from_property_tree (res, result);
645610 return result;
646611}
647612
648613void PyMoneroDaemonRpc::stop () {
649- PyMoneroPathRequest request (" stop_daemon" );
650- std::shared_ptr<PyMoneroPathResponse> response = m_rpc->send_path_request (request);
651- check_response_status (response);
614+ auto res = m_rpc->send_path_request (" stop_daemon" );
615+ check_response_status (res);
652616}
653617
654618std::shared_ptr<monero::monero_block_header> PyMoneroDaemonRpc::wait_for_next_block_header () {
@@ -674,21 +638,17 @@ std::shared_ptr<monero::monero_block_header> PyMoneroDaemonRpc::wait_for_next_bl
674638}
675639
676640std::shared_ptr<PyMoneroBandwithLimits> PyMoneroDaemonRpc::get_bandwidth_limits () {
677- PyMoneroPathRequest request (" get_limit" );
678- auto response = m_rpc->send_path_request (request);
679- check_response_status (response);
680- auto res = response->m_response .get ();
641+ auto res = m_rpc->send_path_request (" get_limit" );
642+ check_response_status (res);
681643 auto limits = std::make_shared<PyMoneroBandwithLimits>();
682644 PyMoneroBandwithLimits::from_property_tree (res, limits);
683645 return limits;
684646}
685647
686648std::shared_ptr<PyMoneroBandwithLimits> PyMoneroDaemonRpc::set_bandwidth_limits (int up, int down) {
687649 auto limits = std::make_shared<PyMoneroBandwithLimits>(up, down);
688- PyMoneroPathRequest request (" set_limit" , limits);
689- auto response = m_rpc->send_path_request (request);
690- check_response_status (response);
691- auto res = response->m_response .get ();
650+ auto res = m_rpc->send_path_request (" set_limit" , limits);
651+ check_response_status (res);
692652 PyMoneroBandwithLimits::from_property_tree (res, limits);
693653 return limits;
694654}
0 commit comments