diff options
Diffstat (limited to 'libbridge')
| -rw-r--r-- | libbridge/CMakeLists.txt | 24 | ||||
| -rw-r--r-- | libbridge/src/main/cpp/helpers.cpp | 15 | ||||
| -rw-r--r-- | libbridge/src/main/cpp/helpers.hpp | 3 | ||||
| -rw-r--r-- | libbridge/src/main/cpp/wallet2_api.h | 82 | ||||
| -rw-r--r-- | libbridge/src/main/cpp/wallet2_api_c.cpp | 283 | ||||
| -rw-r--r-- | libbridge/src/main/cpp/wallet2_api_c.h | 98 |
6 files changed, 417 insertions, 88 deletions
diff --git a/libbridge/CMakeLists.txt b/libbridge/CMakeLists.txt index 4729bb1..23e1f5e 100644 --- a/libbridge/CMakeLists.txt +++ b/libbridge/CMakeLists.txt @@ -72,6 +72,26 @@ set_target_properties(boost_wserialization PROPERTIES IMPORTED_LOCATION ${EXTERNAL_LIBS_DIR}/prefix/lib/libboost_wserialization.a) ############# +# Polyseed +############# + +add_library(polyseed STATIC IMPORTED) +set_target_properties(polyseed PROPERTIES IMPORTED_LOCATION + ${EXTERNAL_LIBS_DIR}/prefix/lib/libpolyseed.a) + +add_library(polyseed-wrapper STATIC IMPORTED) +set_target_properties(polyseed-wrapper PROPERTIES IMPORTED_LOCATION + ${EXTERNAL_LIBS_DIR}/monero/build/release/src/polyseed/libpolyseed_wrapper.a) + +############# +# Utf8proc +############# + +add_library(utf8proc STATIC IMPORTED) +set_target_properties(utf8proc PROPERTIES IMPORTED_LOCATION + ${EXTERNAL_LIBS_DIR}/prefix/lib/libutf8proc.a) + +############# # Monero ############# @@ -237,6 +257,10 @@ target_link_libraries( wallet2_api_c boost_thread boost_wserialization + polyseed + polyseed-wrapper + utf8proc + ssl crypto diff --git a/libbridge/src/main/cpp/helpers.cpp b/libbridge/src/main/cpp/helpers.cpp index 064ce36..04befc6 100644 --- a/libbridge/src/main/cpp/helpers.cpp +++ b/libbridge/src/main/cpp/helpers.cpp @@ -143,3 +143,18 @@ const char* vectorToString(const std::set<uint32_t>& intSet, const std::string s memcpy(buffer, str.c_str(), size + 1); return buffer; } + +std::set<std::string> splitString(const std::string& str, const std::string& delim) { + std::set<std::string> tokens; + if (str.empty()) return tokens; + size_t pos = 0; + std::string token; + std::string content = str; // Copy of str so we can safely erase content + while ((pos = content.find(delim)) != std::string::npos) { + token = content.substr(0, pos); + tokens.insert(token); + content.erase(0, pos + delim.length()); + } + tokens.insert(content); // Inserting the last token + return tokens; +}
\ No newline at end of file diff --git a/libbridge/src/main/cpp/helpers.hpp b/libbridge/src/main/cpp/helpers.hpp index 5d9b4a4..45fa624 100644 --- a/libbridge/src/main/cpp/helpers.hpp +++ b/libbridge/src/main/cpp/helpers.hpp @@ -7,4 +7,5 @@ const char* vectorToString(const std::vector<std::string>& vec, const std::strin const char* vectorToString(const std::vector<uint32_t>& vec, const std::string separator); const char* vectorToString(const std::vector<uint64_t>& vec, const std::string separator); const char* vectorToString(const std::vector<std::set<uint32_t>>& vec, const std::string separator); -const char* vectorToString(const std::set<uint32_t>& intSet, const std::string separator);
\ No newline at end of file +const char* vectorToString(const std::set<uint32_t>& intSet, const std::string separator); +std::set<std::string> splitString(const std::string& str, const std::string& delim);
\ No newline at end of file diff --git a/libbridge/src/main/cpp/wallet2_api.h b/libbridge/src/main/cpp/wallet2_api.h index 646e585..5612c66 100644 --- a/libbridge/src/main/cpp/wallet2_api.h +++ b/libbridge/src/main/cpp/wallet2_api.h @@ -38,6 +38,7 @@ #include <ctime> #include <iostream> #include <stdexcept> +#include <cstdint> // Public interface for libwallet library namespace Monero { @@ -287,6 +288,7 @@ struct CoinsInfo virtual bool unlocked() const = 0; virtual std::string pubKey() const = 0; virtual bool coinbase() const = 0; + virtual std::string description() const = 0; }; struct Coins @@ -296,9 +298,12 @@ struct Coins virtual CoinsInfo * coin(int index) const = 0; virtual std::vector<CoinsInfo*> getAll() const = 0; virtual void refresh() = 0; + virtual void setFrozen(std::string public_key) = 0; virtual void setFrozen(int index) = 0; + virtual void thaw(std::string public_key) = 0; virtual void thaw(int index) = 0; virtual bool isTransferUnlocked(uint64_t unlockTime, uint64_t blockHeight) = 0; + virtual void setDescription(const std::string &public_key, const std::string &description) = 0; }; struct SubaddressRow { @@ -485,6 +490,12 @@ struct Wallet ConnectionStatus_WrongVersion }; + enum BackgroundSyncType { + BackgroundSync_Off = 0, + BackgroundSync_ReusePassword = 1, + BackgroundSync_CustomPassword = 2 + }; + virtual ~Wallet() = 0; virtual std::string seed(const std::string& seed_offset = "") const = 0; virtual std::string getSeedLanguage() const = 0; @@ -660,6 +671,7 @@ struct Wallet result += unlockedBalance(i); return result; } + virtual uint64_t viewOnlyBalance(uint32_t accountIndex, const std::vector<std::string> &key_images = {}) const = 0; /** * @brief watchOnly - checks if wallet is watch only @@ -740,6 +752,10 @@ struct Wallet static void warning(const std::string &category, const std::string &str); static void error(const std::string &category, const std::string &str); + virtual bool getPolyseed(std::string &seed, std::string &passphrase) const = 0; + static bool createPolyseed(std::string &seed_words, std::string &err, const std::string &language = "English"); + static std::vector<std::pair<std::string, std::string>> getPolyseedLanguages(); + /** * @brief StartRefresh - Start/resume refresh thread (refresh every 10 seconds) */ @@ -883,7 +899,8 @@ struct Wallet optional<std::vector<uint64_t>> amount, uint32_t mixin_count, PendingTransaction::Priority = PendingTransaction::Priority_Low, uint32_t subaddr_account = 0, - std::set<uint32_t> subaddr_indices = {}) = 0; + std::set<uint32_t> subaddr_indices = {}, + const std::set<std::string> &preferred_inputs = {}) = 0; /*! * \brief createTransaction creates transaction. if dst_addr is an integrated address, payment_id is ignored @@ -902,7 +919,8 @@ struct Wallet optional<uint64_t> amount, uint32_t mixin_count, PendingTransaction::Priority = PendingTransaction::Priority_Low, uint32_t subaddr_account = 0, - std::set<uint32_t> subaddr_indices = {}) = 0; + std::set<uint32_t> subaddr_indices = {}, + const std::set<std::string> &preferred_inputs = {}) = 0; /*! * \brief createSweepUnmixableTransaction creates transaction with unmixable outputs. @@ -940,6 +958,8 @@ struct Wallet virtual uint64_t estimateTransactionFee(const std::vector<std::pair<std::string, uint64_t>> &destinations, PendingTransaction::Priority priority) const = 0; + virtual bool hasUnknownKeyImages() const = 0; + /*! * \brief exportKeyImages - exports key images to file * \param filename @@ -976,6 +996,43 @@ struct Wallet */ virtual bool scanTransactions(const std::vector<std::string> &txids) = 0; + /*! + * \brief setupBackgroundSync - setup background sync mode with just a view key + * \param background_sync_type - the mode the wallet background syncs in + * \param wallet_password + * \param background_cache_password - custom password to encrypt background cache, only needed for custom password background sync type + * \return - true on success + */ + virtual bool setupBackgroundSync(const BackgroundSyncType background_sync_type, const std::string &wallet_password, const optional<std::string> &background_cache_password) = 0; + + /*! + * \brief getBackgroundSyncType - get mode the wallet background syncs in + * \return - the type, or off if type is unknown + */ + virtual BackgroundSyncType getBackgroundSyncType() const = 0; + + /** + * @brief startBackgroundSync - sync the chain in the background with just view key + */ + virtual bool startBackgroundSync() = 0; + + /** + * @brief stopBackgroundSync - bring back spend key and process background synced txs + * \param wallet_password + */ + virtual bool stopBackgroundSync(const std::string &wallet_password) = 0; + + /** + * @brief isBackgroundSyncing - returns true if the wallet is background syncing + */ + virtual bool isBackgroundSyncing() const = 0; + + /** + * @brief isBackgroundWallet - returns true if the wallet is a background wallet + */ + virtual bool isBackgroundWallet() const = 0; + + virtual TransactionHistory * history() = 0; virtual AddressBook * addressBook() = 0; virtual Coins * coins() = 0; @@ -1298,6 +1355,27 @@ struct WalletManager WalletListener * listener = nullptr) = 0; /*! + * \brief creates a wallet from a polyseed mnemonic phrase + * \param path Name of the wallet file to be created + * \param password Password of wallet file + * \param nettype Network type + * \param mnemonic Polyseed mnemonic + * \param passphrase Optional seed offset passphrase + * \param newWallet Whether it is a new wallet + * \param restoreHeight Override the embedded restore height + * \param kdf_rounds Number of rounds for key derivation function + * @return + */ + virtual Wallet * createWalletFromPolyseed(const std::string &path, + const std::string &password, + NetworkType nettype, + const std::string &mnemonic, + const std::string &passphrase = "", + bool newWallet = true, + uint64_t restore_height = 0, + uint64_t kdf_rounds = 1) = 0; + + /*! * \brief Closes wallet. In case operation succeeded, wallet object deleted. in case operation failed, wallet object not deleted * \param wallet previously opened / created wallet instance * \return None diff --git a/libbridge/src/main/cpp/wallet2_api_c.cpp b/libbridge/src/main/cpp/wallet2_api_c.cpp index ce9c210..5659bb4 100644 --- a/libbridge/src/main/cpp/wallet2_api_c.cpp +++ b/libbridge/src/main/cpp/wallet2_api_c.cpp @@ -475,6 +475,15 @@ bool MONERO_CoinsInfo_coinbase(void* coinsInfo_ptr) { Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); return coinsInfo->internalOutputIndex(); } +// virtual std::string description() const = 0; +const char* MONERO_CoinsInfo_description(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + std::string str = coinsInfo->description(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} // coins @@ -490,12 +499,27 @@ void* MONERO_Coins_coin(void* coins_ptr, int index) { Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr); return coins->coin(index); } + +int MONERO_Coins_getAll_size(void* coins_ptr) { + Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr); + return coins->getAll().size(); +} +void* MONERO_Coins_getAll_byIndex(void* coins_ptr, int index) { + Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr); + return coins->getAll()[index]; +} + // virtual std::vector<CoinsInfo*> getAll() const = 0; // virtual void refresh() = 0; void MONERO_Coins_refresh(void* coins_ptr) { Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr); return coins->refresh(); } +// virtual void setFrozen(std::string public_key) = 0; +void MONERO_Coins_setFrozenByPublicKey(void* coins_ptr, const char* public_key) { + Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr); + return coins->setFrozen(std::string(public_key)); +} // virtual void setFrozen(int index) = 0; void MONERO_Coins_setFrozen(void* coins_ptr, int index) { Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr); @@ -506,11 +530,21 @@ void MONERO_Coins_thaw(void* coins_ptr, int index) { Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr); return coins->thaw(index); } +// virtual void thaw(std::string public_key) = 0; +void MONERO_Coins_thawByPublicKey(void* coins_ptr, const char* public_key) { + Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr); + return coins->thaw(std::string(public_key)); +} // virtual bool isTransferUnlocked(uint64_t unlockTime, uint64_t blockHeight) = 0; bool MONERO_Coins_isTransferUnlocked(void* coins_ptr, uint64_t unlockTime, uint64_t blockHeight) { Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr); return coins->isTransferUnlocked(unlockTime, blockHeight); } +// virtual void setDescription(const std::string &public_key, const std::string &description) = 0; +void MONERO_Coins_setDescription(void* coins_ptr, const char* public_key, const char* description) { + Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr); + coins->setDescription(std::string(public_key), std::string(description)); +} // SubaddressRow @@ -923,6 +957,11 @@ uint64_t MONERO_Wallet_unlockedBalance(void* wallet_ptr, uint32_t accountIndex) return wallet->unlockedBalance(accountIndex); } +uint64_t MONERO_Wallet_viewOnlyBalance(void* wallet_ptr, uint32_t accountIndex) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->viewOnlyBalance(accountIndex); +} + // TODO bool MONERO_Wallet_watchOnly(void* wallet_ptr) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); @@ -955,30 +994,17 @@ uint64_t MONERO_Wallet_daemonBlockChainHeight_cached(void* wallet_ptr) { return daemonBlockChainHeight_cached; } -uint64_t daemonBlockChainHeight_cahceSleepTime = 1; -bool daemonBlockChainHeight_cahceIsEnabled = false; +bool daemonBlockChainHeight_cacheIsEnabled = false; -void MONERO_Wallet_daemonBlockChainHeight_runThread(void* wallet_ptr) { +void MONERO_Wallet_daemonBlockChainHeight_runThread(void* wallet_ptr, int seconds) { while (true) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); daemonBlockChainHeight_cached = wallet->daemonBlockChainHeight(); - sleep(daemonBlockChainHeight_cahceSleepTime); - std::cout << "MONERO: TICK: MONERO_Wallet_daemonBlockChainHeight_runThread: " << daemonBlockChainHeight_cached << std::endl; + sleep(seconds); + std::cout << "MONERO: TICK: MONERO_Wallet_daemonBlockChainHeight_runThread(" << seconds << "): " << daemonBlockChainHeight_cached << std::endl; } } -bool MONERO_Wallet_daemonBlockChainHeight_enableRefresh(void* wallet_ptr, int seconds) { - if (seconds < 1) { - seconds = 1; - } - daemonBlockChainHeight_cahceSleepTime = seconds; - if (daemonBlockChainHeight_cahceIsEnabled == true) { - return true; - } - daemonBlockChainHeight_cahceIsEnabled = true; - std::thread t1(MONERO_Wallet_daemonBlockChainHeight_runThread, wallet_ptr); - return true; -} uint64_t MONERO_Wallet_daemonBlockChainTargetHeight(void* wallet_ptr) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return wallet->daemonBlockChainTargetHeight(); @@ -1048,6 +1074,29 @@ void MONERO_Wallet_init3(void* wallet_ptr, const char* argv0, const char* defaul Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return wallet->init(argv0, default_log_base_name, log_path, console); } +const char* MONERO_Wallet_getPolyseed(void* wallet_ptr, const char* passphrase) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + std::string seed = ""; + std::string _passphrase = std::string(passphrase); + wallet->getPolyseed(seed, _passphrase); + std::string str = seed; + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// static bool createPolyseed(std::string &seed_words, std::string &err, const std::string &language = "English"); +const char* MONERO_Wallet_createPolyseed() { + std::string seed_words = ""; + std::string err; + Monero::Wallet::createPolyseed(seed_words, err); + std::string str = seed_words; + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} + void MONERO_Wallet_startRefresh(void* wallet_ptr) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return wallet->startRefresh(); @@ -1120,12 +1169,24 @@ const char* MONERO_Wallet_getMultisigInfo(void* wallet_ptr) { void* MONERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id, uint64_t amount, uint32_t mixin_count, int pendingTransactionPriority, - uint32_t subaddr_account) { + uint32_t subaddr_account, + const char* preferredInputs, const char* separator) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + Monero::optional<uint64_t> optAmount; + if (amount != 0) { + optAmount = amount; + } + std::set<uint32_t> subaddr_indices = {}; + std::set<std::string> preferred_inputs = splitString(std::string(preferredInputs), std::string(separator)); + wallet->info("MONERO_C", "TEST"); + wallet->info("MONERO_C", preferredInputs); + wallet->info("MONERO_C", std::to_string(preferred_inputs.size())); + auto oneInput = *(preferred_inputs.begin()); + wallet->info("MONERO_C", oneInput); return wallet->createTransaction(std::string(dst_addr), std::string(payment_id), - amount, mixin_count, + optAmount, mixin_count, Monero::PendingTransaction::Priority_Low, - subaddr_account /*, subaddr_indices */); + subaddr_account, subaddr_indices, preferred_inputs); } void* MONERO_Wallet_loadUnsignedTx(void* wallet_ptr, const char* fileName) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); @@ -1135,6 +1196,10 @@ bool MONERO_Wallet_submitTransaction(void* wallet_ptr, const char* fileName) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return wallet->submitTransaction(std::string(fileName)); } +bool MONERO_Wallet_hasUnknownKeyImages(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->hasUnknownKeyImages(); +} bool MONERO_Wallet_exportKeyImages(void* wallet_ptr, const char* filename, bool all) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return wallet->exportKeyImages(std::string(filename), all); @@ -1151,6 +1216,36 @@ bool MONERO_Wallet_importOutputs(void* wallet_ptr, const char* filename) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return wallet->importOutputs(std::string(filename)); } +// virtual bool setupBackgroundSync(const BackgroundSyncType background_sync_type, const std::string &wallet_password, const optional<std::string> &background_cache_password) = 0; +bool MONERO_Wallet_setupBackgroundSync(void* wallet_ptr, int background_sync_type, const char* wallet_password, const char* background_cache_password) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->setupBackgroundSync(Monero::Wallet::BackgroundSyncType::BackgroundSync_CustomPassword, std::string(wallet_password), std::string(background_cache_password)); +} +// virtual BackgroundSyncType getBackgroundSyncType() const = 0; +int MONERO_Wallet_getBackgroundSyncType(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->getBackgroundSyncType(); +} +// virtual bool startBackgroundSync() = 0; +bool MONERO_Wallet_startBackgroundSync(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->startBackgroundSync(); +} +// virtual bool stopBackgroundSync(const std::string &wallet_password) = 0; +bool MONERO_Wallet_stopBackgroundSync(void* wallet_ptr, const char* wallet_password) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->stopBackgroundSync(std::string(wallet_password)); +} +// virtual bool isBackgroundSyncing() const = 0; +bool MONERO_Wallet_isBackgroundSyncing(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->hasUnknownKeyImages(); +} +// virtual bool isBackgroundWallet() const = 0; +bool MONERO_Wallet_isBackgroundWallet(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->isBackgroundWallet(); +} void* MONERO_Wallet_history(void* wallet_ptr) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return wallet->history(); @@ -1300,9 +1395,10 @@ uint64_t MONERO_Wallet_getBytesSent(void* wallet_ptr) { return wallet->getBytesSent(); } -void* MONERO_WalletManager_createWallet(const char* path, const char* password, const char* language, int networkType) { - Monero::Wallet *wallet = - Monero::WalletManagerFactory::getWalletManager()->createWallet( + +void* MONERO_WalletManager_createWallet(void* wm_ptr, const char* path, const char* password, const char* language, int networkType) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); + Monero::Wallet *wallet = wm->createWallet( std::string(path), std::string(password), std::string(language), @@ -1310,20 +1406,20 @@ void* MONERO_WalletManager_createWallet(const char* path, const char* password, return reinterpret_cast<void*>(wallet); } -void* MONERO_WalletManager_openWallet(const char* path, const char* password, int networkType) { - Monero::Wallet *wallet = - Monero::WalletManagerFactory::getWalletManager()->openWallet( +void* MONERO_WalletManager_openWallet(void* wm_ptr, const char* path, const char* password, int networkType) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); + Monero::Wallet *wallet = wm->openWallet( std::string(path), std::string(password), static_cast<Monero::NetworkType>(networkType)); return reinterpret_cast<void*>(wallet); } -void* MONERO_WalletManager_recoveryWallet(const char* path, const char* password, const char* mnemonic, int networkType, uint64_t restoreHeight, uint64_t kdfRounds, const char* seedOffset) { +void* MONERO_WalletManager_recoveryWallet(void* wm_ptr, const char* path, const char* password, const char* mnemonic, int networkType, uint64_t restoreHeight, uint64_t kdfRounds, const char* seedOffset) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); // (const std::string &path, const std::string &password, const std::string &mnemonic, // NetworkType nettype = MAINNET, uint64_t restoreHeight = 0, uint64_t kdf_rounds = 1, // const std::string &seed_offset = {}) - Monero::Wallet *wallet = - Monero::WalletManagerFactory::getWalletManager()->recoveryWallet( + Monero::Wallet *wallet = wm->recoveryWallet( std::string(path), std::string(password), std::string(mnemonic), @@ -1333,85 +1429,136 @@ void* MONERO_WalletManager_recoveryWallet(const char* path, const char* password std::string(seedOffset)); return reinterpret_cast<void*>(wallet); } +// virtual Wallet * createWalletFromKeys(const std::string &path, +// const std::string &password, +// const std::string &language, +// NetworkType nettype, +// uint64_t restoreHeight, +// const std::string &addressString, +// const std::string &viewKeyString, +// const std::string &spendKeyString = "", +// uint64_t kdf_rounds = 1) = 0; +void* MONERO_WalletManager_createWalletFromKeys(void* wm_ptr, const char* path, const char* password, const char* language, int nettype, uint64_t restoreHeight, const char* addressString, const char* viewKeyString, const char* spendKeyString, uint64_t kdf_rounds) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); + Monero::Wallet *wallet = wm->createWalletFromKeys( + std::string(path), + std::string(password), + std::string(language), + static_cast<Monero::NetworkType>(nettype), + restoreHeight, + std::string(addressString), + std::string(viewKeyString), + std::string(spendKeyString)); + return reinterpret_cast<void*>(wallet); +} -bool MONERO_WalletManager_closeWallet(void* wallet_ptr, bool store) { +void* MONERO_WalletManager_createWalletFromPolyseed(void* wm_ptr, const char* path, const char* password, + int nettype, const char* mnemonic, const char* passphrase, + bool newWallet, uint64_t restore_height, uint64_t kdf_rounds) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); + return wm->createWalletFromPolyseed(std::string(path), + std::string(password), + static_cast<Monero::NetworkType>(nettype), + std::string(mnemonic), + std::string(passphrase), + newWallet, + restore_height, + kdf_rounds); +} + + +bool MONERO_WalletManager_closeWallet(void* wm_ptr, void* wallet_ptr, bool store) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); - return Monero::WalletManagerFactory::getWalletManager()->closeWallet( - wallet, - store); + return wm->closeWallet(wallet, store); } -bool MONERO_WalletManager_walletExists(const char* path) { - return Monero::WalletManagerFactory::getWalletManager()->walletExists(std::string(path)); +bool MONERO_WalletManager_walletExists(void* wm_ptr, const char* path) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); + return wm->walletExists(std::string(path)); } // virtual bool verifyWalletPassword(const std::string &keys_file_name, const std::string &password, bool no_spend_key, uint64_t kdf_rounds = 1) const = 0; -bool MONERO_WalletManager_verifyWalletPassword(const char* keys_file_name, const char* password, bool no_spend_key, uint64_t kdf_rounds) { - return Monero::WalletManagerFactory::getWalletManager()->verifyWalletPassword(std::string(keys_file_name), std::string(password), no_spend_key, kdf_rounds); +bool MONERO_WalletManager_verifyWalletPassword(void* wm_ptr, const char* keys_file_name, const char* password, bool no_spend_key, uint64_t kdf_rounds) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); + return wm->verifyWalletPassword(std::string(keys_file_name), std::string(password), no_spend_key, kdf_rounds); } // virtual bool queryWalletDevice(Wallet::Device& device_type, const std::string &keys_file_name, const std::string &password, uint64_t kdf_rounds = 1) const = 0; // bool MONERO_WalletManager_queryWalletDevice(int device_type, const char* keys_file_name, const char* password, uint64_t kdf_rounds) { // return Monero::WalletManagerFactory::getWalletManager()->queryWalletDevice(device_type, std::string(keys_file_name), std::string(password), kdf_rounds); //} // virtual std::vector<std::string> findWallets(const std::string &path) = 0; -const char* MONERO_WalletManager_findWallets(const char* path, const char* separator) { - return vectorToString(Monero::WalletManagerFactory::getWalletManager()->findWallets(std::string(path)), std::string(separator)); +const char* MONERO_WalletManager_findWallets(void* wm_ptr, const char* path, const char* separator) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); + return vectorToString(wm->findWallets(std::string(path)), std::string(separator)); } -const char* MONERO_WalletManager_errorString() { - std::string str = Monero::WalletManagerFactory::getWalletManager()->errorString(); +const char* MONERO_WalletManager_errorString(void* wm_ptr) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); + std::string str = wm->errorString(); const std::string::size_type size = str.size(); char *buffer = new char[size + 1]; //we need extra char for NUL memcpy(buffer, str.c_str(), size + 1); return buffer; } -void MONERO_WalletManager_setDaemonAddress(const char* address) { - return Monero::WalletManagerFactory::getWalletManager()->setDaemonAddress(std::string(address)); +void MONERO_WalletManager_setDaemonAddress(void* wm_ptr, const char* address) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); + return wm->setDaemonAddress(std::string(address)); } -bool MONERO_WalletManager_setProxy(const char* address) { - return Monero::WalletManagerFactory::getWalletManager()->setProxy(std::string(address)); +bool MONERO_WalletManager_setProxy(void* wm_ptr, const char* address) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); + return wm->setProxy(std::string(address)); } // virtual bool connected(uint32_t *version = NULL) = 0; // virtual uint64_t blockchainHeight() = 0; -uint64_t MONERO_WalletManager_blockchainHeight() { - return Monero::WalletManagerFactory::getWalletManager()->blockchainHeight(); +uint64_t MONERO_WalletManager_blockchainHeight(void* wm_ptr) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); + return wm->blockchainHeight(); } // virtual uint64_t blockchainTargetHeight() = 0; -uint64_t MONERO_WalletManager_blockchainTargetHeight() { - return Monero::WalletManagerFactory::getWalletManager()->blockchainTargetHeight(); +uint64_t MONERO_WalletManager_blockchainTargetHeight(void* wm_ptr) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); + return wm->blockchainTargetHeight(); } // virtual uint64_t networkDifficulty() = 0; -uint64_t MONERO_WalletManager_networkDifficulty() { - return Monero::WalletManagerFactory::getWalletManager()->networkDifficulty(); +uint64_t MONERO_WalletManager_networkDifficulty(void* wm_ptr) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); + return wm->networkDifficulty(); } // virtual double miningHashRate() = 0; -double MONERO_WalletManager_miningHashRate() { - return Monero::WalletManagerFactory::getWalletManager()->miningHashRate(); +double MONERO_WalletManager_miningHashRate(void* wm_ptr) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); + return wm->miningHashRate(); } // virtual uint64_t blockTarget() = 0; -uint64_t MONERO_WalletManager_blockTarget() { - return Monero::WalletManagerFactory::getWalletManager()->blockTarget(); +uint64_t MONERO_WalletManager_blockTarget(void* wm_ptr) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); + return wm->blockTarget(); } // virtual bool isMining() = 0; -bool MONERO_WalletManager_isMining() { - return Monero::WalletManagerFactory::getWalletManager()->isMining(); +bool MONERO_WalletManager_isMining(void* wm_ptr) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); + return wm->isMining(); } // virtual bool startMining(const std::string &address, uint32_t threads = 1, bool background_mining = false, bool ignore_battery = true) = 0; -bool MONERO_WalletManager_startMining(const char* address, uint32_t threads, bool backgroundMining, bool ignoreBattery) { - return Monero::WalletManagerFactory::getWalletManager()->startMining(std::string(address), threads, backgroundMining, ignoreBattery); +bool MONERO_WalletManager_startMining(void* wm_ptr, const char* address, uint32_t threads, bool backgroundMining, bool ignoreBattery) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); + return wm->startMining(std::string(address), threads, backgroundMining, ignoreBattery); } // virtual bool stopMining() = 0; -bool MONERO_WalletManager_stopMining(const char* address) { - return Monero::WalletManagerFactory::getWalletManager()->stopMining(); +bool MONERO_WalletManager_stopMining(void* wm_ptr, const char* address) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); + return wm->stopMining(); } // virtual std::string resolveOpenAlias(const std::string &address, bool &dnssec_valid) const = 0; -const char* MONERO_WalletManager_resolveOpenAlias(const char* address, bool dnssec_valid) { - std::string str = Monero::WalletManagerFactory::getWalletManager()->resolveOpenAlias(std::string(address), dnssec_valid); +const char* MONERO_WalletManager_resolveOpenAlias(void* wm_ptr, const char* address, bool dnssec_valid) { + Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr); + std::string str = wm->resolveOpenAlias(std::string(address), dnssec_valid); const std::string::size_type size = str.size(); char *buffer = new char[size + 1]; //we need extra char for NUL memcpy(buffer, str.c_str(), size + 1); @@ -1420,6 +1567,11 @@ const char* MONERO_WalletManager_resolveOpenAlias(const char* address, bool dnss // WalletManagerFactory +void* MONERO_WalletManagerFactory_getWalletManager() { + Monero::WalletManager *wm = Monero::WalletManagerFactory::getWalletManager(); + return reinterpret_cast<void*>(wm); +} + void MONERO_WalletManagerFactory_setLogLevel(int level) { Monero::WalletManagerFactory::setLogLevel(level); } @@ -1466,6 +1618,11 @@ const char* MONERO_DEBUG_test5_std() { return text2; } +bool MONERO_DEBUG_isPointerNull(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return (wallet != NULL); +} + #ifdef __cplusplus } #endif diff --git a/libbridge/src/main/cpp/wallet2_api_c.h b/libbridge/src/main/cpp/wallet2_api_c.h index e38c51b..300d3ca 100644 --- a/libbridge/src/main/cpp/wallet2_api_c.h +++ b/libbridge/src/main/cpp/wallet2_api_c.h @@ -293,6 +293,8 @@ bool MONERO_CoinsInfo_unlocked(void* coinsInfo_ptr); const char* MONERO_CoinsInfo_pubKey(void* coinsInfo_ptr); // virtual bool coinbase() const = 0; bool MONERO_CoinsInfo_coinbase(void* coinsInfo_ptr); +// virtual std::string description() const = 0; +const char* MONERO_CoinsInfo_description(void* coinsInfo_ptr); // }; // struct Coins // { @@ -302,14 +304,22 @@ int MONERO_Coins_count(void* coins_ptr); // virtual CoinsInfo * coin(int index) const = 0; void* MONERO_Coins_coin(void* coins_ptr, int index); // virtual std::vector<CoinsInfo*> getAll() const = 0; +int MONERO_Coins_getAll_size(void* coins_ptr); +void* MONERO_Coins_getAll_byIndex(void* coins_ptr, int index); // virtual void refresh() = 0; void MONERO_Coins_refresh(void* coins_ptr); +// virtual void setFrozen(std::string public_key) = 0; +void MONERO_Coins_setFrozenByPublicKey(void* coins_ptr, const char* public_key); // virtual void setFrozen(int index) = 0; void MONERO_Coins_setFrozen(void* coins_ptr, int index); // virtual void thaw(int index) = 0; void MONERO_Coins_thaw(void* coins_ptr, int index); +// virtual void thaw(std::string public_key) = 0; +void MONERO_Coins_thawByPublicKey(void* coins_ptr, const char* public_key); // virtual bool isTransferUnlocked(uint64_t unlockTime, uint64_t blockHeight) = 0; bool MONERO_Coins_isTransferUnlocked(void* coins_ptr, uint64_t unlockTime, uint64_t blockHeight); +// virtual void setDescription(const std::string &public_key, const std::string &description) = 0; +void MONERO_Coins_setDescription(void* coins_ptr, const char* public_key, const char* description); // }; // struct SubaddressRow { // public: @@ -467,6 +477,14 @@ const int WalletConnectionStatus_Connected = 1; // ConnectionStatus_WrongVersion const int WalletConnectionStatus_WrongVersion = 2; // }; +// enum BackgroundSyncType { +// BackgroundSync_Off = 0, +const int WalletBackgroundSync_Off = 0; +// BackgroundSync_ReusePassword = 1, +const int WalletBackgroundSync_ReusePassword = 1; +// BackgroundSync_CustomPassword = 2 +const int BackgroundSync_CustomPassword = 2; +// }; // virtual ~Wallet() = 0; // virtual std::string seed(const std::string& seed_offset = "") const = 0; const char* MONERO_Wallet_seed(void* wallet_ptr, const char* seed_offset); @@ -561,6 +579,8 @@ uint64_t MONERO_Wallet_unlockedBalance(void* wallet_ptr, uint32_t accountIndex); // return result; // } // virtual bool watchOnly() const = 0; +// virtual uint64_t viewOnlyBalance(uint32_t accountIndex, const std::vector<std::string> &key_images = {}) const = 0; +uint64_t MONERO_Wallet_viewOnlyBalance(void* wallet_ptr, uint32_t accountIndex); bool MONERO_Wallet_watchOnly(void* wallet_ptr); // virtual bool isDeterministic() const = 0; bool MONERO_Wallet_isDeterministic(void* wallet_ptr); @@ -573,7 +593,7 @@ uint64_t MONERO_Wallet_estimateBlockChainHeight(void* wallet_ptr); // virtual uint64_t daemonBlockChainHeight() const = 0; uint64_t MONERO_Wallet_daemonBlockChainHeight(void* wallet_ptr); uint64_t MONERO_Wallet_daemonBlockChainHeight_cached(void* wallet_ptr); -bool MONERO_Wallet_daemonBlockChainHeight_enableRefresh(void* wallet_ptr, int seconds); +void MONERO_Wallet_daemonBlockChainHeight_runThread(void* wallet_ptr, int seconds); // virtual uint64_t daemonBlockChainTargetHeight() const = 0; uint64_t MONERO_Wallet_daemonBlockChainTargetHeight(void* wallet_ptr); // virtual bool synchronized() const = 0; @@ -617,6 +637,10 @@ void MONERO_Wallet_init3(void* wallet_ptr, const char* argv0, const char* defaul // static void warning(const std::string &category, const std::string &str); // static void error(const std::string &category, const std::string &str); // virtual void startRefresh() = 0; +// virtual bool getPolyseed(std::string &seed, std::string &passphrase) const = 0; +const char* MONERO_Wallet_getPolyseed(void* wallet_ptr, const char* passphrase); +// static bool createPolyseed(std::string &seed_words, std::string &err, const std::string &language = "English"); +const char* MONERO_Wallet_createPolyseed(); void MONERO_Wallet_startRefresh(void* wallet_ptr); // virtual void pauseRefresh() = 0; void MONERO_Wallet_pauseRefresh(void* wallet_ptr); @@ -662,11 +686,13 @@ const char* MONERO_Wallet_getMultisigInfo(void* wallet_ptr); // optional<uint64_t> amount, uint32_t mixin_count, // PendingTransaction::Priority = PendingTransaction::Priority_Low, // uint32_t subaddr_account = 0, -// std::set<uint32_t> subaddr_indices = {}) = 0; +// std::set<uint32_t> subaddr_indices = {}, +// const std::set<std::string> &preferred_inputs = {) = 0; void* MONERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id, uint64_t amount, uint32_t mixin_count, int pendingTransactionPriority, - uint32_t subaddr_account); // std::nullopt + uint32_t subaddr_account, + const char* preferredInputs, const char* separator); // virtual PendingTransaction * createSweepUnmixableTransaction() = 0; // virtual UnsignedTransaction * loadUnsignedTx(const std::string &unsigned_filename) = 0; void* MONERO_Wallet_loadUnsignedTx(void* wallet_ptr, const char* unsigned_filename); @@ -675,6 +701,8 @@ bool MONERO_Wallet_submitTransaction(void* wallet_ptr, const char* fileName); // virtual void disposeTransaction(PendingTransaction * t) = 0; // virtual uint64_t estimateTransactionFee(const std::vector<std::pair<std::string, uint64_t>> &destinations, // PendingTransaction::Priority priority) const = 0; +// virtual bool hasUnknownKeyImages() const = 0; +bool MONERO_Wallet_hasUnknownKeyImages(void* wallet_ptr); // virtual bool exportKeyImages(const std::string &filename, bool all = false) = 0; bool MONERO_Wallet_exportKeyImages(void* wallet_ptr, const char* filename, bool all); // virtual bool importKeyImages(const std::string &filename) = 0; @@ -684,6 +712,18 @@ bool MONERO_Wallet_exportOutputs(void* wallet_ptr, const char* filename, bool al // virtual bool importOutputs(const std::string &filename) = 0; bool MONERO_Wallet_importOutputs(void* wallet_ptr, const char* filename); // virtual bool scanTransactions(const std::vector<std::string> &txids) = 0; +// virtual bool setupBackgroundSync(const BackgroundSyncType background_sync_type, const std::string &wallet_password, const optional<std::string> &background_cache_password) = 0; +bool MONERO_Wallet_setupBackgroundSync(void* wallet_ptr, int background_sync_type, const char* wallet_password, const char* background_cache_password); +// virtual BackgroundSyncType getBackgroundSyncType() const = 0; +int MONERO_Wallet_getBackgroundSyncType(void* wallet_ptr); +// virtual bool startBackgroundSync() = 0; +bool MONERO_Wallet_startBackgroundSync(void* wallet_ptr); +// virtual bool stopBackgroundSync(const std::string &wallet_password) = 0; +bool MONERO_Wallet_stopBackgroundSync(void* wallet_ptr, const char* wallet_password); +// virtual bool isBackgroundSyncing() const = 0; +bool MONERO_Wallet_isBackgroundSyncing(void* wallet_ptr); +// virtual bool isBackgroundWallet() const = 0; +bool MONERO_Wallet_isBackgroundWallet(void* wallet_ptr); // virtual TransactionHistory * history() = 0; void* MONERO_Wallet_history(void* wallet_ptr); // virtual AddressBook * addressBook() = 0; @@ -766,13 +806,13 @@ uint64_t MONERO_Wallet_getBytesSent(void* wallet_ptr); // struct WalletManager // { // virtual Wallet * createWallet(const std::string &path, const std::string &password, const std::string &language, NetworkType nettype, uint64_t kdf_rounds = 1) = 0; -void* MONERO_WalletManager_createWallet(const char* path, const char* password, const char* language, int networkType); +void* MONERO_WalletManager_createWallet(void* wm_ptr, const char* path, const char* password, const char* language, int networkType); // Wallet * createWallet(const std::string &path, const std::string &password, const std::string &language, bool testnet = false) // deprecated // { // return createWallet(path, password, language, testnet ? TESTNET : MAINNET); // } // virtual Wallet * openWallet(const std::string &path, const std::string &password, NetworkType nettype, uint64_t kdf_rounds = 1, WalletListener * listener = nullptr) = 0; -void* MONERO_WalletManager_openWallet(const char* path, const char* password, int networkType); +void* MONERO_WalletManager_openWallet(void* wm_ptr, const char* path, const char* password, int networkType); // Wallet * openWallet(const std::string &path, const std::string &password, bool testnet = false) // deprecated // { // return openWallet(path, password, testnet ? TESTNET : MAINNET); @@ -780,7 +820,7 @@ void* MONERO_WalletManager_openWallet(const char* path, const char* password, in // virtual Wallet * recoveryWallet(const std::string &path, const std::string &password, const std::string &mnemonic, // NetworkType nettype = MAINNET, uint64_t restoreHeight = 0, uint64_t kdf_rounds = 1, // const std::string &seed_offset = {}) = 0; -void* MONERO_WalletManager_recoveryWallet(const char* path, const char* password, const char* mnemonic, int networkType, uint64_t restoreHeight, uint64_t kdfRounds, const char* seedOffset); +void* MONERO_WalletManager_recoveryWallet(void* wm_ptr, const char* path, const char* password, const char* mnemonic, int networkType, uint64_t restoreHeight, uint64_t kdfRounds, const char* seedOffset); // Wallet * recoveryWallet(const std::string &path, const std::string &password, const std::string &mnemonic, // bool testnet = false, uint64_t restoreHeight = 0) // deprecated // { @@ -800,6 +840,7 @@ void* MONERO_WalletManager_recoveryWallet(const char* path, const char* password // const std::string &viewKeyString, // const std::string &spendKeyString = "", // uint64_t kdf_rounds = 1) = 0; +void* MONERO_WalletManager_createWalletFromKeys(void* wm_ptr, const char* path, const char* password, const char* language, int nettype, uint64_t restoreHeight, const char* addressString, const char* viewKeyString, const char* spendKeyString, uint64_t kdf_rounds); // Wallet * createWalletFromKeys(const std::string &path, // const std::string &password, // const std::string &language, @@ -836,46 +877,57 @@ void* MONERO_WalletManager_recoveryWallet(const char* path, const char* password // const std::string &subaddressLookahead = "", // uint64_t kdf_rounds = 1, // WalletListener * listener = nullptr) = 0; +// virtual Wallet * createWalletFromPolyseed(const std::string &path, +// const std::string &password, +// NetworkType nettype, +// const std::string &mnemonic, +// const std::string &passphrase = "", +// bool newWallet = true, +// uint64_t restore_height = 0, +// uint64_t kdf_rounds = 1) = 0; +void* MONERO_WalletManager_createWalletFromPolyseed(void* wm_ptr, const char* path, const char* password, + int nettype, const char* mnemonic, const char* passphrase, + bool newWallet, uint64_t restore_height, uint64_t kdf_rounds); // virtual bool closeWallet(Wallet *wallet, bool store = true) = 0; -bool MONERO_WalletManager_closeWallet(void* wallet_ptr, bool store); +bool MONERO_WalletManager_closeWallet(void* wm_ptr, void* wallet_ptr, bool store); // virtual bool walletExists(const std::string &path) = 0; -bool MONERO_WalletManager_walletExists(const char* path); +bool MONERO_WalletManager_walletExists(void* wm_ptr, const char* path); // virtual bool verifyWalletPassword(const std::string &keys_file_name, const std::string &password, bool no_spend_key, uint64_t kdf_rounds = 1) const = 0; -bool MONERO_WalletManager_verifyWalletPassword(const char* keys_file_name, const char* password, bool no_spend_key, uint64_t kdf_rounds); +bool MONERO_WalletManager_verifyWalletPassword(void* wm_ptr, const char* keys_file_name, const char* password, bool no_spend_key, uint64_t kdf_rounds); // virtual bool queryWalletDevice(Wallet::Device& device_type, const std::string &keys_file_name, const std::string &password, uint64_t kdf_rounds = 1) const = 0; // bool MONERO_WalletManager_queryWalletDevice(int device_type, const char* keys_file_name, const char* password, uint64_t kdf_rounds); // virtual std::vector<std::string> findWallets(const std::string &path) = 0; -const char* MONERO_WalletManager_findWallets(const char* path, const char* separator); +const char* MONERO_WalletManager_findWallets(void* wm_ptr, const char* path, const char* separator); // virtual std::string errorString() const = 0; -const char* MONERO_WalletManager_errorString(); +const char* MONERO_WalletManager_errorString(void* wm_ptr); // virtual void setDaemonAddress(const std::string &address) = 0; -void MONERO_WalletManager_setDaemonAddress(const char* address); +void MONERO_WalletManager_setDaemonAddress(void* wm_ptr, const char* address); // virtual bool connected(uint32_t *version = NULL) = 0; // virtual uint64_t blockchainHeight() = 0; -uint64_t MONERO_WalletManager_blockchainHeight(); +uint64_t MONERO_WalletManager_blockchainHeight(void* wm_ptr); // virtual uint64_t blockchainTargetHeight() = 0; -uint64_t MONERO_WalletManager_blockchainTargetHeight(); +uint64_t MONERO_WalletManager_blockchainTargetHeight(void* wm_ptr); // virtual uint64_t networkDifficulty() = 0; -uint64_t MONERO_WalletManager_networkDifficulty(); +uint64_t MONERO_WalletManager_networkDifficulty(void* wm_ptr); // virtual double miningHashRate() = 0; -double MONERO_WalletManager_miningHashRate(); +double MONERO_WalletManager_miningHashRate(void* wm_ptr); // virtual uint64_t blockTarget() = 0; -uint64_t MONERO_WalletManager_blockTarget(); +uint64_t MONERO_WalletManager_blockTarget(void* wm_ptr); // virtual bool isMining() = 0; -bool MONERO_WalletManager_isMining(); +bool MONERO_WalletManager_isMining(void* wm_ptr); // virtual bool startMining(const std::string &address, uint32_t threads = 1, bool background_mining = false, bool ignore_battery = true) = 0; -bool MONERO_WalletManager_startMining(const char* address, uint32_t threads, bool backgroundMining, bool ignoreBattery); +bool MONERO_WalletManager_startMining(void* wm_ptr, const char* address, uint32_t threads, bool backgroundMining, bool ignoreBattery); // virtual bool stopMining() = 0; -bool MONERO_WalletManager_stopMining(const char* address); +bool MONERO_WalletManager_stopMining(void* wm_ptr, const char* address); // virtual std::string resolveOpenAlias(const std::string &address, bool &dnssec_valid) const = 0; -const char* MONERO_WalletManager_resolveOpenAlias(const char* address, bool dnssec_valid); +const char* MONERO_WalletManager_resolveOpenAlias(void* wm_ptr, const char* address, bool dnssec_valid); // static std::tuple<bool, std::string, std::string, std::string, std::string> checkUpdates( // const std::string &software, // std::string subdir, // const char *buildtag = nullptr, // const char *current_version = nullptr); // virtual bool setProxy(const std::string &address) = 0; -bool MONERO_WalletManager_setProxy(const char* address); +bool MONERO_WalletManager_setProxy(void* wm_ptr, const char* address); // }; int LogLevel_Silent = -1; @@ -900,6 +952,7 @@ int LogLevel_Max = 4; // LogLevel_Max = LogLevel_4 // }; // static WalletManager * getWalletManager(); +void* MONERO_WalletManagerFactory_getWalletManager(); // static void setLogLevel(int level); void MONERO_WalletManagerFactory_setLogLevel(int level); // static void setLogCategories(const std::string &categories); @@ -914,6 +967,7 @@ uint64_t MONERO_DEBUG_test3(uint64_t x); void* MONERO_DEBUG_test4(uint64_t x); const char* MONERO_DEBUG_test5(); const char* MONERO_DEBUG_test5_std(); +bool MONERO_DEBUG_isPointerNull(void* wallet_ptr); #ifdef __cplusplus } |