Merge pull request 'Configure Renovate' (#3) from renovate/configure into anonero

Reviewed-on: https://git.mrcyjanek.net/mrcyjanek/monero_c/pulls/3

5 files changed, 393 insertions, 88 deletions

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
 }