From 416716d6e7d206172905670576f39610a05e41a1 Mon Sep 17 00:00:00 2001 From: everoddandeven Date: Sat, 28 Mar 2026 14:59:28 +0100 Subject: [PATCH] Refactory wallet and daemon rpc data model --- src/cpp/daemon/py_monero_daemon_model.cpp | 15 +-- src/cpp/daemon/py_monero_daemon_model.h | 3 +- src/cpp/wallet/py_monero_wallet_model.cpp | 45 +------ src/cpp/wallet/py_monero_wallet_model.h | 41 +----- src/cpp/wallet/py_monero_wallet_rpc.cpp | 152 +++++++++------------- src/cpp/wallet/py_monero_wallet_rpc.h | 2 + 6 files changed, 74 insertions(+), 184 deletions(-) diff --git a/src/cpp/daemon/py_monero_daemon_model.cpp b/src/cpp/daemon/py_monero_daemon_model.cpp index 5f3fe40..056a972 100644 --- a/src/cpp/daemon/py_monero_daemon_model.cpp +++ b/src/cpp/daemon/py_monero_daemon_model.cpp @@ -767,10 +767,7 @@ void PyMoneroDaemonInfo::from_property_tree(const boost::property_tree::ptree& n else if (key == std::string("adjusted_time")) info->m_adjusted_timestamp = it->second.get_value(); else if (key == std::string("target")) info->m_target = it->second.get_value(); else if (key == std::string("target_height")) info->m_target_height = it->second.get_value(); - else if (key == std::string("top_block_hash") || key == std::string("top_hash")) { - std::string top_hash = it->second.data(); - if (!top_hash.empty()) info->m_top_block_hash = top_hash; - } + else if ((key == std::string("top_block_hash") || key == std::string("top_hash")) && !it->second.data().empty()) info->m_top_block_hash = it->second.data(); else if (key == std::string("tx_count")) info->m_num_txs = it->second.get_value(); else if (key == std::string("tx_pool_size")) info->m_num_txs_pool = it->second.get_value(); else if (key == std::string("was_bootstrap_ever_used")) info->m_was_bootstrap_ever_used = it->second.get_value(); @@ -792,10 +789,7 @@ void PyMoneroDaemonSyncInfo::from_property_tree(const boost::property_tree::ptre // TODO implement overview field //else if (key == std::string("overview") && !it->second.data().empty()) info->m_overview = it->second.data(); else if (key == std::string("credits")) info->m_credits = it->second.get_value(); - else if (key == std::string("top_hash")) { - std::string top_hash = it->second.data(); - if (!top_hash.empty()) info->m_top_block_hash = top_hash; - } + else if (key == std::string("top_hash") && !it->second.data().empty()) info->m_top_block_hash = it->second.data(); } } @@ -811,10 +805,7 @@ void PyMoneroHardForkInfo::from_property_tree(const boost::property_tree::ptree& else if (key == std::string("window")) info->m_window = it->second.get_value(); else if (key == std::string("voting")) info->m_voting = it->second.get_value(); else if (key == std::string("credits")) info->m_credits = it->second.get_value(); - else if (key == std::string("top_hash")) { - std::string top_hash = it->second.data(); - if (!top_hash.empty()) info->m_top_block_hash = top_hash; - } + else if (key == std::string("top_hash") && !it->second.data().empty()) info->m_top_block_hash = it->second.data(); } } diff --git a/src/cpp/daemon/py_monero_daemon_model.h b/src/cpp/daemon/py_monero_daemon_model.h index 2f922dd..a41481d 100644 --- a/src/cpp/daemon/py_monero_daemon_model.h +++ b/src/cpp/daemon/py_monero_daemon_model.h @@ -50,7 +50,7 @@ class PyMoneroDownloadUpdateParams : public PyMoneroRequestParams { rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override; }; -class PyMoneroStartMiningParams : public PyMoneroRequestParams { +class PyMoneroStartMiningParams : public PyMoneroJsonRequestParams { public: boost::optional m_address; boost::optional m_num_threads; @@ -58,6 +58,7 @@ class PyMoneroStartMiningParams : public PyMoneroRequestParams { boost::optional m_ignore_battery; PyMoneroStartMiningParams(const std::string& address, int num_threads, bool is_background, bool ignore_battery); + PyMoneroStartMiningParams(int num_threads, bool is_background, bool ignore_battery): m_num_threads(num_threads), m_is_background(is_background), m_ignore_battery(ignore_battery) { } rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override; }; diff --git a/src/cpp/wallet/py_monero_wallet_model.cpp b/src/cpp/wallet/py_monero_wallet_model.cpp index cd2d717..eeee49b 100644 --- a/src/cpp/wallet/py_monero_wallet_model.cpp +++ b/src/cpp/wallet/py_monero_wallet_model.cpp @@ -274,10 +274,6 @@ PyMoneroCreateOpenWalletParams::PyMoneroCreateOpenWalletParams(const boost::opti m_autosave_current(autosave_current) { } -PyMoneroGetAccountsParams::PyMoneroGetAccountsParams(const std::string& tag): m_tag(tag) { - if (tag.empty()) m_tag = boost::none; -} - PyMoneroReserveProofParams::PyMoneroReserveProofParams(const std::string &message, bool all): m_all(all), m_message(message) { } @@ -1191,12 +1187,15 @@ void PyMoneroSubaddress::from_rpc_property_tree(const boost::property_tree::ptre void PyMoneroSubaddress::from_rpc_property_tree(const boost::property_tree::ptree& node, std::vector>& subaddresses) { for (boost::property_tree::ptree::const_iterator it = node.begin(); it != node.end(); ++it) { std::string key = it->first; - if (key == std::string("per_subaddress")) { + bool rpc_subaddresses = key == std::string("addresses"); + + if (key == std::string("per_subaddress") || rpc_subaddresses) { auto per_subaddress_node = it->second; for (auto it2 = per_subaddress_node.begin(); it2 != per_subaddress_node.end(); ++it2) { auto sub = std::make_shared(); - from_property_tree(it2->second, sub); + if (rpc_subaddresses) from_rpc_property_tree(it2->second, sub); + else from_property_tree(it2->second, sub); subaddresses.push_back(sub); } } @@ -1528,16 +1527,6 @@ rapidjson::Value PyMoneroSplitIntegratedAddressParams::to_rapidjson_val(rapidjso return root; } -rapidjson::Value PyMoneroWalletStartMiningParams::to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const { - rapidjson::Value root(rapidjson::kObjectType); - rapidjson::Value value_str(rapidjson::kStringType); - rapidjson::Value value_num(rapidjson::kNumberType); - if (m_num_threads != boost::none) monero_utils::add_json_member("threads_count", m_num_threads.get(), allocator, root, value_num); - if (m_is_background != boost::none) monero_utils::add_json_member("do_background_mining", m_is_background.get(), allocator, root); - if (m_ignore_battery != boost::none) monero_utils::add_json_member("ignore_battery", m_ignore_battery.get(), allocator, root); - return root; -} - rapidjson::Value PyMoneroPrepareMultisigParams::to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const { rapidjson::Value root(rapidjson::kObjectType); if (m_enable_multisig_experimental != boost::none) monero_utils::add_json_member("enable_multisig_experimental", m_enable_multisig_experimental.get(), allocator, root); @@ -1618,12 +1607,6 @@ rapidjson::Value PyMoneroWalletAttributeParams::to_rapidjson_val(rapidjson::Docu return root; } -rapidjson::Value PyMoneroScanTxParams::to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const { - rapidjson::Value root(rapidjson::kObjectType); - if (!m_tx_hashes.empty()) root.AddMember("txids", monero_utils::to_rapidjson_val(allocator, m_tx_hashes), allocator); - return root; -} - rapidjson::Value PyMoneroSetDaemonParams::to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const { rapidjson::Value root(rapidjson::kObjectType); rapidjson::Value value_str(rapidjson::kStringType); @@ -1647,19 +1630,12 @@ rapidjson::Value PyMoneroAutoRefreshParams::to_rapidjson_val(rapidjson::Document return root; } -rapidjson::Value PyMoneroSetAccountTagDescriptionParams::to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const { - rapidjson::Value root(rapidjson::kObjectType); - rapidjson::Value value_str(rapidjson::kStringType); - if (m_tag != boost::none) monero_utils::add_json_member("tag", m_tag.get(), allocator, root, value_str); - if (m_label != boost::none) monero_utils::add_json_member("label", m_label.get(), allocator, root, value_str); - return root; -} - rapidjson::Value PyMoneroTagAccountsParams::to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const { rapidjson::Value root(rapidjson::kObjectType); rapidjson::Value value_str(rapidjson::kStringType); if (m_tag != boost::none) monero_utils::add_json_member("tag", m_tag.get(), allocator, root, value_str); - if (!m_account_indices.empty()) root.AddMember("accounts", monero_utils::to_rapidjson_val(allocator, m_account_indices), allocator); + if (m_label != boost::none) monero_utils::add_json_member("label", m_label.get(), allocator, root, value_str); + if (!m_account_indices.empty()) root.AddMember("accounts", monero_utils::to_rapidjson_val(allocator, m_account_indices), allocator); return root; } @@ -1683,13 +1659,6 @@ rapidjson::Value PyMoneroAddressBookEntryParams::to_rapidjson_val(rapidjson::Doc return root; } -rapidjson::Value PyMoneroGetAccountsParams::to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const { - rapidjson::Value root(rapidjson::kObjectType); - rapidjson::Value value_str(rapidjson::kStringType); - if (m_tag != boost::none) monero_utils::add_json_member("tag", m_tag.get(), allocator, root, value_str); - return root; -} - rapidjson::Value PyMoneroVerifySignMessageParams::to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const { rapidjson::Value root(rapidjson::kObjectType); rapidjson::Value value_str(rapidjson::kStringType); diff --git a/src/cpp/wallet/py_monero_wallet_model.h b/src/cpp/wallet/py_monero_wallet_model.h index b19da5b..6292824 100644 --- a/src/cpp/wallet/py_monero_wallet_model.h +++ b/src/cpp/wallet/py_monero_wallet_model.h @@ -240,17 +240,6 @@ class PyMoneroSplitIntegratedAddressParams : public PyMoneroJsonRequestParams { rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override; }; -class PyMoneroWalletStartMiningParams : public PyMoneroJsonRequestParams { -public: - boost::optional m_num_threads; - boost::optional m_is_background; - boost::optional m_ignore_battery; - - PyMoneroWalletStartMiningParams(int num_threads, bool is_background, bool ignore_battery): m_num_threads(num_threads), m_is_background(is_background), m_ignore_battery(ignore_battery) { } - - rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override; -}; - class PyMoneroPrepareMultisigParams : public PyMoneroJsonRequestParams { public: // TODO monero-docs document this parameter @@ -414,15 +403,6 @@ class PyMoneroWalletAttributeParams : public PyMoneroJsonRequestParams { static void from_property_tree(const boost::property_tree::ptree& node, const std::shared_ptr& attributes); }; -class PyMoneroScanTxParams : public PyMoneroJsonRequestParams { -public: - std::vector m_tx_hashes; - - PyMoneroScanTxParams(const std::vector& tx_hashes): m_tx_hashes(tx_hashes) { } - - rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override; -}; - class PyMoneroSetDaemonParams : public PyMoneroJsonRequestParams { public: boost::optional m_address; @@ -448,21 +428,13 @@ class PyMoneroAutoRefreshParams : public PyMoneroJsonRequestParams { rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override; }; -class PyMoneroSetAccountTagDescriptionParams : public PyMoneroJsonRequestParams { -public: - boost::optional m_tag; - boost::optional m_label; - - PyMoneroSetAccountTagDescriptionParams(const std::string& tag, const std::string& label): m_tag(tag), m_label(label) { } - - rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override; -}; - class PyMoneroTagAccountsParams : public PyMoneroJsonRequestParams { public: std::vector m_account_indices; boost::optional m_tag; + boost::optional m_label; + PyMoneroTagAccountsParams(const std::string& tag, const std::string& label = ""): m_tag(tag), m_label(label) { } PyMoneroTagAccountsParams(const std::vector& account_indices): m_account_indices(account_indices) { } PyMoneroTagAccountsParams(const std::string& tag, const std::vector& account_indices): m_tag(tag), m_account_indices(account_indices) { } @@ -512,15 +484,6 @@ class PyMoneroWalletBalance { PyMoneroWalletBalance(uint64_t balance = 0, uint64_t unlocked_balance = 0): m_balance(balance), m_unlocked_balance(unlocked_balance) { } }; -class PyMoneroGetAccountsParams : public PyMoneroJsonRequestParams { -public: - boost::optional m_tag; - - PyMoneroGetAccountsParams(const std::string& tag); - - rapidjson::Value to_rapidjson_val(rapidjson::Document::AllocatorType& allocator) const override; -}; - class PyMoneroVerifySignMessageParams : public PyMoneroJsonRequestParams { public: boost::optional m_data; diff --git a/src/cpp/wallet/py_monero_wallet_rpc.cpp b/src/cpp/wallet/py_monero_wallet_rpc.cpp index 78f4e18..2b42fae 100644 --- a/src/cpp/wallet/py_monero_wallet_rpc.cpp +++ b/src/cpp/wallet/py_monero_wallet_rpc.cpp @@ -487,8 +487,7 @@ uint64_t PyMoneroWalletRpc::get_height_by_date(uint16_t year, uint8_t month, uin throw std::runtime_error("monero-wallet-rpc does not support getting a height by date"); } -monero_sync_result PyMoneroWalletRpc::sync() { - auto params = std::make_shared(); +monero_sync_result PyMoneroWalletRpc::refresh(const std::shared_ptr& params) { boost::lock_guard lock(m_sync_mutex); try { auto node = m_rpc->send_json_request("refresh", params); @@ -509,6 +508,11 @@ monero_sync_result PyMoneroWalletRpc::sync() { } } +monero_sync_result PyMoneroWalletRpc::sync() { + auto params = std::make_shared(); + return refresh(params); +} + monero_sync_result PyMoneroWalletRpc::sync(monero_wallet_listener& listener) { throw std::runtime_error("Monero Wallet RPC does not support reporting sync progress"); } @@ -519,24 +523,7 @@ monero_sync_result PyMoneroWalletRpc::sync(uint64_t start_height, monero_wallet_ monero_sync_result PyMoneroWalletRpc::sync(uint64_t start_height) { auto params = std::make_shared(start_height); - boost::lock_guard lock(m_sync_mutex); - try { - auto node = m_rpc->send_json_request("refresh", params); - poll(); - monero_sync_result sync_result(0, false); - - for (auto it = node.begin(); it != node.end(); ++it) { - std::string key = it->first; - - if (key == std::string("blocks_fetched")) sync_result.m_num_blocks_fetched = it->second.get_value(); - else if (key == std::string("received_money")) sync_result.m_received_money = it->second.get_value(); - } - - return sync_result; - } catch (const PyMoneroRpcError& ex) { - if (ex.message == std::string("no connection to daemon")) throw PyMoneroError("Wallet is not connected to daemon"); - throw; - } + return refresh(params); } void PyMoneroWalletRpc::start_syncing(uint64_t sync_period_in_ms) { @@ -562,7 +549,7 @@ void PyMoneroWalletRpc::stop_syncing() { 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); + auto params = std::make_shared(tx_hashes); m_rpc->send_json_request("scan_tx", params); poll(); } @@ -627,7 +614,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); + auto params = std::make_shared(tag); auto node = m_rpc->send_json_request("get_accounts", params); std::vector accounts; PyMoneroAccount::from_property_tree(node, accounts); @@ -702,22 +689,16 @@ std::vector PyMoneroWalletRpc::get_subaddresses(const uint32_ auto params = std::make_shared(account_idx, subaddress_indices); auto node = m_rpc->send_json_request("get_address", params); std::vector subaddresses; + std::vector> subaddresses_ptr; + PyMoneroSubaddress::from_rpc_property_tree(node, subaddresses_ptr); - // initialize subaddresses - for (auto it = node.begin(); it != node.end(); ++it) { - std::string key = it->first; - if (key == std::string("addresses")) { - auto node2 = it->second; - for (auto it2 = node2.begin(); it2 != node2.end(); ++it2) { - auto subaddress = std::make_shared(); - PyMoneroSubaddress::from_rpc_property_tree(it2->second, subaddress); - subaddress->m_account_index = account_idx; - subaddresses.push_back(*subaddress); - } - break; - } + for(const auto& subaddress_ptr : subaddresses_ptr) { + subaddress_ptr->m_account_index = account_idx; + subaddresses.push_back(*subaddress_ptr); } + // initialize subaddresses + // fetch and initialize subaddress balances if (!skip_balances) { // these fields are not initialized if subaddress is unused and therefore not returned from `get_balance` @@ -1150,6 +1131,16 @@ monero_message_signature_result PyMoneroWalletRpc::verify_message(const std::str return *sig_result; } +void normalize_wallet_error(const PyMoneroRpcError& ex) { + // normalize error message + if (ex.code == -1 && std::string(ex.what()).find("basic_string") != std::string::npos) { + throw PyMoneroRpcError(-1, "Must provide signature to check tx proof"); + } else if (ex.code == -8 && ex.what() == std::string("TX ID has invalid format")) { + throw PyMoneroRpcError(-8, "TX hash has invalid format"); + } + throw; +} + std::string PyMoneroWalletRpc::get_tx_key(const std::string& tx_hash) const { try { auto params = std::make_shared(tx_hash); @@ -1162,97 +1153,79 @@ std::string PyMoneroWalletRpc::get_tx_key(const std::string& tx_hash) const { return it->second.data(); } } - - throw std::runtime_error("Could not get tx key"); } catch (const PyMoneroRpcError& ex) { - if (ex.code == -8 && ex.what() == std::string("TX ID has invalid format")) { - // normalize error message - throw PyMoneroRpcError(-8, "TX hash has invalid format"); - } - throw; + normalize_wallet_error(ex); } + + throw std::runtime_error("Could not get tx key"); } std::shared_ptr PyMoneroWalletRpc::check_tx_key(const std::string& tx_hash, const std::string& tx_key, const std::string& address) const { + auto check = std::make_shared(); try { auto params = std::make_shared(tx_hash, tx_key, address); 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); - return check; } catch (const PyMoneroRpcError& ex) { - if (ex.code == -8 && ex.what() == std::string("TX ID has invalid format")) { - // normalize error message - throw PyMoneroRpcError(-8, "TX hash has invalid format"); - } - throw; + normalize_wallet_error(ex); } + + return check; } std::string PyMoneroWalletRpc::get_tx_proof(const std::string& tx_hash, const std::string& address, const std::string& message) const { + std::string tx_proof; try { auto params = std::make_shared(tx_hash, message); params->m_address = address; auto node = m_rpc->send_json_request("get_tx_proof", params); - return PyMoneroReserveProofSignature::from_property_tree(node); + tx_proof = PyMoneroReserveProofSignature::from_property_tree(node); } catch (const PyMoneroRpcError& ex) { - if (ex.code == -8 && ex.what() == std::string("TX ID has invalid format")) { - // normalize error message - throw PyMoneroRpcError(-8, "TX hash has invalid format"); - } - throw; + normalize_wallet_error(ex); } + + return tx_proof; } 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 { + auto check = std::make_shared(); try { auto params = std::make_shared(tx_hash, address, message, signature); auto node = m_rpc->send_json_request("check_tx_proof", params); - auto check = std::make_shared(); PyMoneroCheckTxProof::from_property_tree(node, check); - return check; } catch (const PyMoneroRpcError& ex) { - // normalize error message - if (ex.code == -1 && std::string(ex.what()).find("basic_string") != std::string::npos) { - throw PyMoneroRpcError(-1, "Must provide signature to check tx proof"); - } - if (ex.code == -8 && ex.what() == std::string("TX ID has invalid format")) { - throw PyMoneroRpcError(-8, "TX hash has invalid format"); - } - throw; + normalize_wallet_error(ex); } + + return check; } std::string PyMoneroWalletRpc::get_spend_proof(const std::string& tx_hash, const std::string& message) const { + std::string spend_proof; try { auto params = std::make_shared(tx_hash, message); auto node = m_rpc->send_json_request("get_spend_proof", params); - return PyMoneroReserveProofSignature::from_property_tree(node); + spend_proof = PyMoneroReserveProofSignature::from_property_tree(node); } catch (const PyMoneroRpcError& ex) { - if (ex.code == -8 && ex.what() == std::string("TX ID has invalid format")) { - // normalize error message - throw PyMoneroRpcError(-8, "TX hash has invalid format"); - } - throw; + normalize_wallet_error(ex); } + + return spend_proof; } bool PyMoneroWalletRpc::check_spend_proof(const std::string& tx_hash, const std::string& message, const std::string& signature) const { + auto proof = std::make_shared(); try { auto params = std::make_shared(tx_hash, message); params->m_signature = signature; 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; } catch (const PyMoneroRpcError& ex) { - if (ex.code == -8 && ex.what() == std::string("TX ID has invalid format")) { - // normalize error message - throw PyMoneroRpcError(-8, "TX hash has invalid format"); - } - throw; + normalize_wallet_error(ex); } + + return proof->m_is_good; } std::string PyMoneroWalletRpc::get_reserve_proof_wallet(const std::string& message) const { @@ -1374,7 +1347,7 @@ 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); + auto params = std::make_shared(tag, label); m_rpc->send_json_request("set_account_tag_description", params); } @@ -1417,9 +1390,8 @@ 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)); - auto response = m_rpc->send_json_request("start_mining", params); - // TODO PyMoneroDaemonRpc::check_response_status(response); + auto params = std::make_shared(num_threads.value_or(0), background_mining.value_or(false), ignore_battery.value_or(false)); + m_rpc->send_json_request("start_mining", params); } void PyMoneroWalletRpc::stop_mining() { @@ -1874,18 +1846,10 @@ std::vector PyMoneroWalletRpc::get_subaddress_indices(uint32_t account auto params = std::make_shared(account_idx); 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) { - std::string key = it->first; - if (key == std::string("addresses")) { - auto node2 = it->second; - for (auto it2 = node2.begin(); it2 != node2.end(); ++it2) { - auto subaddress = std::make_shared(); - PyMoneroSubaddress::from_rpc_property_tree(it2->second, subaddress); - subadress_indices.push_back(subaddress->m_index.get()); - } - break; - } + std::vector> subaddresses; + PyMoneroSubaddress::from_rpc_property_tree(node, subaddresses); + for (const auto& subaddress : subaddresses) { + subadress_indices.push_back(subaddress->m_index.get()); } return subadress_indices; } diff --git a/src/cpp/wallet/py_monero_wallet_rpc.h b/src/cpp/wallet/py_monero_wallet_rpc.h index 353d5fb..70e7bf2 100644 --- a/src/cpp/wallet/py_monero_wallet_rpc.h +++ b/src/cpp/wallet/py_monero_wallet_rpc.h @@ -166,6 +166,8 @@ class PyMoneroWalletRpc : public PyMoneroWallet { PyMoneroWalletRpc* create_wallet_from_seed(const std::shared_ptr &conf); PyMoneroWalletRpc* create_wallet_from_keys(const std::shared_ptr &config); + monero_sync_result refresh(const std::shared_ptr& params); + std::map> get_account_indices(bool get_subaddress_indices) const; std::vector get_subaddress_indices(uint32_t account_idx) const; std::vector> get_outputs_aux(const monero_output_query& query) const;