More functions ported over to monero_c.

Some leftovers are still present - but shouldn't contain anything
that is required by anonero

1 files changed, 883 insertions, 21 deletions

diff --git a/libbridge/src/main/cpp/wallet2_api_c.cpp b/libbridge/src/main/cpp/wallet2_api_c.cpp
index 9e8d9fa..2a7cc13 100644
--- a/libbridge/src/main/cpp/wallet2_api_c.cpp
+++ b/libbridge/src/main/cpp/wallet2_api_c.cpp
@@ -9,23 +9,6 @@ extern "C"
 {
 #endif
 
-#include <android/log.h>
-#define LOG_TAG "wallet2_api_c"
-#define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG,__VA_ARGS__)
-#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG  , LOG_TAG,__VA_ARGS__)
-#define LOGI(...) __android_log_print(ANDROID_LOG_INFO   , LOG_TAG,__VA_ARGS__)
-#define LOGW(...) __android_log_print(ANDROID_LOG_WARN   , LOG_TAG,__VA_ARGS__)
-#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR  , LOG_TAG,__VA_ARGS__)
-
-#ifdef __cplusplus
-}
-#endif
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
 // PendingTransaction
 
 int MONERO_PendingTransaction_status(void* pendingTx_ptr) {
@@ -92,6 +75,62 @@ const char* MONERO_PendingTransaction_signersKeys(void* pendingTx_ptr, const cha
     std::vector<std::string> txid = pendingTx->signersKeys();
     return vectorToString(txid, std::string(separator));
 }
+
+// UnsignedTransaction
+
+int MONERO_UnsignedTransaction_status(void* unsignedTx_ptr) {
+    Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr);
+    return unsignedTx->status();
+}
+const char* MONERO_UnsignedTransaction_errorString(void* unsignedTx_ptr) {
+    Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr);
+    std::string str = unsignedTx->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;
+}
+const char* MONERO_UnsignedTransaction_amount(void* unsignedTx_ptr, const char* separator) {
+    Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr);
+    return vectorToString(unsignedTx->amount(), std::string(separator));
+}
+const char* MONERO_UnsignedTransaction_fee(void* unsignedTx_ptr, const char* separator) {
+    Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr);
+    return vectorToString(unsignedTx->fee(), std::string(separator));
+}
+const char* MONERO_UnsignedTransaction_mixin(void* unsignedTx_ptr, const char* separator) {
+    Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr);
+    return vectorToString(unsignedTx->mixin(), std::string(separator));
+}
+const char* MONERO_UnsignedTransaction_confirmationMessage(void* unsignedTx_ptr) {
+    Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr);
+    std::string str = unsignedTx->confirmationMessage();
+    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;
+}
+const char* MONERO_UnsignedTransaction_paymentId(void* unsignedTx_ptr, const char* separator) {
+    Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr);
+    return vectorToString(unsignedTx->paymentId(), std::string(separator));
+}
+const char* MONERO_UnsignedTransaction_recipientAddress(void* unsignedTx_ptr, const char* separator) {
+    Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr);
+    return vectorToString(unsignedTx->recipientAddress(), std::string(separator));
+}
+uint64_t MONERO_UnsignedTransaction_minMixinCount(void* unsignedTx_ptr) {
+    Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr);
+    return unsignedTx->minMixinCount();
+}
+uint64_t MONERO_UnsignedTransaction_txCount(void* unsignedTx_ptr) {
+    Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr);
+    return unsignedTx->txCount();
+}
+bool MONERO_UnsignedTransaction_sign(void* unsignedTx_ptr, const char* signedFileName) {
+    Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr);
+    return unsignedTx->sign(std::string(signedFileName));
+}
+
 // TransactionInfo
 int MONERO_TransactionInfo_direction(void* txInfo_ptr) {
     Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
@@ -129,6 +168,11 @@ const char* MONERO_TransactionInfo_description(void* txInfo_ptr) {
     memcpy(buffer, str.c_str(), size + 1);
     return buffer;
 }
+const char* MONERO_TransactionInfo_subaddrIndex(void* txInfo_ptr, const char* separator) {
+    Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+    std::set<uint32_t> subaddrIndex = txInfo->subaddrIndex();
+    return vectorToString(subaddrIndex, std::string(separator));
+}
 uint32_t MONERO_TransactionInfo_subaddrAccount(void* txInfo_ptr) {
     Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
     return txInfo->subaddrAccount();
@@ -170,6 +214,28 @@ const char* MONERO_TransactionInfo_paymentId(void* txInfo_ptr) {
     return buffer;
 }
 
+int MONERO_TransactionInfo_transfers_count(void* txInfo_ptr) {
+    Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+    return txInfo->transfers().size();
+}
+
+uint64_t MONERO_TransactionInfo_transfers_amount(void* txInfo_ptr, int index) {
+    Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+    return txInfo->transfers()[index].amount;
+}
+
+const char* MONERO_TransactionInfo_transfers_address(void* txInfo_ptr, int index) {
+    Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+    std::string str = txInfo->transfers()[index].address;
+    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;
+}
+
+
+
+
 // TransactionHistory
 int MONERO_TransactionHistory_count(void* txHistory_ptr) {
     Monero::TransactionHistory *txHistory = reinterpret_cast<Monero::TransactionHistory*>(txHistory_ptr);
@@ -179,6 +245,19 @@ void* MONERO_TransactionHistory_transaction(void* txHistory_ptr, int index) {
     Monero::TransactionHistory *txHistory = reinterpret_cast<Monero::TransactionHistory*>(txHistory_ptr);
     return reinterpret_cast<void*>(txHistory->transaction(index));
 }
+void* MONERO_TransactionHistory_transactionById(void* txHistory_ptr, const char* id) {
+    Monero::TransactionHistory *txHistory = reinterpret_cast<Monero::TransactionHistory*>(txHistory_ptr);
+    return reinterpret_cast<void*>(txHistory->transaction(std::string(id)));
+}
+
+size_t MONERO_TransactionHistory_getAll_size(void* txHistory_ptr) {
+    Monero::TransactionHistory *txHistory = reinterpret_cast<Monero::TransactionHistory*>(txHistory_ptr);
+    return txHistory->getAll().size();
+}
+void* MONERO_TransactionHistory_getAll_single(void* txHistory_ptr, int id) {
+    Monero::TransactionHistory *txHistory = reinterpret_cast<Monero::TransactionHistory*>(txHistory_ptr);
+    return txHistory->getAll()[0];
+}
 void MONERO_TransactionHistory_refresh(void* txHistory_ptr) {
     Monero::TransactionHistory *txHistory = reinterpret_cast<Monero::TransactionHistory*>(txHistory_ptr);
     return txHistory->refresh();
@@ -188,8 +267,437 @@ void MONERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid,
     return txHistory->setTxNote(std::string(txid), std::string(note));
 }
 
-// Wallet
+// AddressBokRow
+
+//     std::string extra;
+const char* MONERO_AddressBookRow_extra(void* addressBookRow_ptr) {
+    Monero::AddressBookRow *addressBookRow = reinterpret_cast<Monero::AddressBookRow*>(addressBookRow_ptr);
+    std::string str = addressBookRow->extra;
+    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;
+}
+//     std::string getAddress() const {return m_address;} 
+const char* MONERO_AddressBookRow_getAddress(void* addressBookRow_ptr) {
+    Monero::AddressBookRow *addressBookRow = reinterpret_cast<Monero::AddressBookRow*>(addressBookRow_ptr);
+    std::string str = addressBookRow->getAddress();
+    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;
+}
+//     std::string getDescription() const {return m_description;} 
+const char* MONERO_AddressBookRow_getDescription(void* addressBookRow_ptr) {
+    Monero::AddressBookRow *addressBookRow = reinterpret_cast<Monero::AddressBookRow*>(addressBookRow_ptr);
+    std::string str = addressBookRow->getDescription();
+    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;
+}
+//     std::string getPaymentId() const {return m_paymentId;} 
+const char* MONERO_AddressBookRow_getPaymentId(void* addressBookRow_ptr) {
+    Monero::AddressBookRow *addressBookRow = reinterpret_cast<Monero::AddressBookRow*>(addressBookRow_ptr);
+    std::string str = addressBookRow->getPaymentId();
+    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;
+}
+//     std::size_t getRowId() const {return m_rowId;}
+size_t MONERO_AddressBookRow_getRowId(void* addressBookRow_ptr) {
+    Monero::AddressBookRow *addressBookRow = reinterpret_cast<Monero::AddressBookRow*>(addressBookRow_ptr);
+    return addressBookRow->getRowId();
+}
+
+// AddressBook
+//     virtual std::vector<AddressBookRow*> getAll() const = 0;
+int MONERO_AddressBook_getAll_size(void* addressBook_ptr) {
+    Monero::AddressBook *addressBook = reinterpret_cast<Monero::AddressBook*>(addressBook_ptr);
+    return addressBook->getAll().size();
+}
+void* MONERO_AddressBook_getAll_byIndex(void* addressBook_ptr, int index) {
+    Monero::AddressBook *addressBook = reinterpret_cast<Monero::AddressBook*>(addressBook_ptr);
+    return addressBook->getAll()[index];
+}
+//     virtual bool addRow(const std::string &dst_addr , const std::string &payment_id, const std::string &description) = 0;  
+bool MONERO_AddressBook_addRow(void* addressBook_ptr, const char* dst_addr , const char* payment_id, const char* description) {
+    Monero::AddressBook *addressBook = reinterpret_cast<Monero::AddressBook*>(addressBook_ptr);
+    return addressBook->addRow(std::string(dst_addr), std::string(payment_id), std::string(description));
+}
+//     virtual bool deleteRow(std::size_t rowId) = 0;
+bool MONERO_AddressBook_deleteRow(void* addressBook_ptr, size_t rowId) {
+    Monero::AddressBook *addressBook = reinterpret_cast<Monero::AddressBook*>(addressBook_ptr);
+    return addressBook->deleteRow(rowId);
+}
+//     virtual bool setDescription(std::size_t index, const std::string &description) = 0;
+bool MONERO_AddressBook_setDescription(void* addressBook_ptr, size_t rowId, const char* description) {
+    Monero::AddressBook *addressBook = reinterpret_cast<Monero::AddressBook*>(addressBook_ptr);
+    return addressBook->setDescription(rowId, std::string(description));
+}
+//     virtual void refresh() = 0;  
+void MONERO_AddressBook_refresh(void* addressBook_ptr) {
+    Monero::AddressBook *addressBook = reinterpret_cast<Monero::AddressBook*>(addressBook_ptr);
+    return addressBook->refresh();
+}
+//     virtual std::string errorString() const = 0;
+const char* MONERO_AddressBook_errorString(void* addressBook_ptr) {
+    Monero::AddressBook *addressBook = reinterpret_cast<Monero::AddressBook*>(addressBook_ptr);
+    std::string str = addressBook->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;
+}
+//     virtual int errorCode() const = 0;
+int MONERO_AddressBook_errorCode(void* addressBook_ptr) {
+    Monero::AddressBook *addressBook = reinterpret_cast<Monero::AddressBook*>(addressBook_ptr);
+    return addressBook->errorCode();
+}
+//     virtual int lookupPaymentID(const std::string &payment_id) const = 0;
+int MONERO_AddressBook_lookupPaymentID(void* addressBook_ptr, const char* payment_id) {
+    Monero::AddressBook *addressBook = reinterpret_cast<Monero::AddressBook*>(addressBook_ptr);
+    return addressBook->lookupPaymentID(std::string(payment_id));
+}
+
+// CoinsInfo
+uint64_t MONERO_CoinsInfo_blockHeight(void* coinsInfo_ptr) {
+    Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+    return coinsInfo->blockHeight();
+}
+//     virtual std::string hash() const = 0;
+const char* MONERO_CoinsInfo_hash(void* coinsInfo_ptr) {
+    Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+    std::string str = coinsInfo->hash();
+    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;
+}
+//     virtual size_t internalOutputIndex() const = 0;
+size_t MONERO_CoinsInfo_internalOutputIndex(void* coinsInfo_ptr) {
+    Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+    return coinsInfo->internalOutputIndex();
+}
+//     virtual uint64_t globalOutputIndex() const = 0;
+uint64_t MONERO_CoinsInfo_globalOutputIndex(void* coinsInfo_ptr) {
+    Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+    return coinsInfo->globalOutputIndex();
+}
+//     virtual bool spent() const = 0;
+bool MONERO_CoinsInfo_spent(void* coinsInfo_ptr) {
+    Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+    return coinsInfo->spent();
+}
+//     virtual bool frozen() const = 0;
+bool MONERO_CoinsInfo_frozen(void* coinsInfo_ptr) {
+    Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+    return coinsInfo->frozen();
+}
+//     virtual uint64_t spentHeight() const = 0;
+uint64_t MONERO_CoinsInfo_spentHeight(void* coinsInfo_ptr) {
+    Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+    return coinsInfo->spentHeight();
+}
+//     virtual uint64_t amount() const = 0;
+uint64_t MONERO_CoinsInfo_amount(void* coinsInfo_ptr) {
+    Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+    return coinsInfo->amount();
+}
+//     virtual bool rct() const = 0;
+bool MONERO_CoinsInfo_rct(void* coinsInfo_ptr) {
+    Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+    return coinsInfo->rct();
+}
+//     virtual bool keyImageKnown() const = 0;
+bool MONERO_CoinsInfo_keyImageKnown(void* coinsInfo_ptr) {
+    Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+    return coinsInfo->keyImageKnown();
+}
+//     virtual size_t pkIndex() const = 0;
+size_t MONERO_CoinsInfo_pkIndex(void* coinsInfo_ptr) {
+    Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+    return coinsInfo->pkIndex();
+}
+//     virtual uint32_t subaddrIndex() const = 0;
+uint32_t MONERO_CoinsInfo_subaddrIndex(void* coinsInfo_ptr) {
+    Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+    return coinsInfo->subaddrIndex();
+}
+//     virtual uint32_t subaddrAccount() const = 0;
+uint32_t MONERO_CoinsInfo_subaddrAccount(void* coinsInfo_ptr) {
+    Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+    return coinsInfo->subaddrAccount();
+}
+//     virtual std::string address() const = 0;
+const char* MONERO_CoinsInfo_address(void* coinsInfo_ptr) {
+    Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+    std::string str = coinsInfo->address();
+    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;
+}
+//     virtual std::string addressLabel() const = 0;
+const char* MONERO_CoinsInfo_addressLabel(void* coinsInfo_ptr) {
+    Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+    std::string str = coinsInfo->addressLabel();
+    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;
+}
+//     virtual std::string keyImage() const = 0;
+const char* MONERO_CoinsInfo_keyImage(void* coinsInfo_ptr) {
+    Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+    std::string str = coinsInfo->keyImage();
+    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;
+}
+//     virtual uint64_t unlockTime() const = 0;
+uint64_t MONERO_CoinsInfo_unlockTime(void* coinsInfo_ptr) {
+    Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+    return coinsInfo->unlockTime();
+}
+//     virtual bool unlocked() const = 0;
+bool MONERO_CoinsInfo_unlocked(void* coinsInfo_ptr) {
+    Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+    return coinsInfo->internalOutputIndex();
+}
+//     virtual std::string pubKey() const = 0;
+const char* MONERO_CoinsInfo_pubKey(void* coinsInfo_ptr) {
+    Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+    std::string str = coinsInfo->pubKey();
+    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;
+}
+//     virtual bool coinbase() const = 0;
+bool MONERO_CoinsInfo_coinbase(void* coinsInfo_ptr) {
+    Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+    return coinsInfo->internalOutputIndex();
+}
+
+
+// coins
+
+//     virtual ~Coins() = 0;
+//     virtual int count() const = 0;
+int MONERO_Coins_count(void* coins_ptr) {
+    Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr);
+    return coins->count();
+}
+//     virtual CoinsInfo * coin(int index)  const = 0;
+void* MONERO_Coins_coin(void* coins_ptr, int index) {
+    Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr);
+    return coins->coin(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(int index) = 0;
+void MONERO_Coins_setFrozen(void* coins_ptr, int index) {
+    Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr);
+    return coins->setFrozen(index);
+}
+//     virtual void thaw(int index) = 0;
+void MONERO_Coins_thaw(void* coins_ptr, int index) {
+    Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr);
+    return coins->thaw(index);
+}
+//     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);
+}
+
+// SubaddressRow
+
+//     std::string extra;
+const char* MONERO_SubaddressRow_extra(void* subaddressRow_ptr) {
+    Monero::SubaddressRow *subaddressRow = reinterpret_cast<Monero::SubaddressRow*>(subaddressRow_ptr);
+    std::string str = subaddressRow->extra;
+    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;
+}
+//     std::string getAddress() const {return m_address;}
+const char* MONERO_SubaddressRow_getAddress(void* subaddressRow_ptr) {
+    Monero::SubaddressRow *subaddressRow = reinterpret_cast<Monero::SubaddressRow*>(subaddressRow_ptr);
+    std::string str = subaddressRow->getAddress();
+    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;
+}
+//     std::string getLabel() const {return m_label;}
+const char* MONERO_SubaddressRow_getLabel(void* subaddressRow_ptr) {
+    Monero::SubaddressRow *subaddressRow = reinterpret_cast<Monero::SubaddressRow*>(subaddressRow_ptr);
+    std::string str = subaddressRow->getLabel();
+    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;
+}
+//     std::size_t getRowId() const {return m_rowId;}
+size_t MONERO_SubaddressRow_getRowId(void* subaddressRow_ptr) {
+    Monero::SubaddressRow *subaddressRow = reinterpret_cast<Monero::SubaddressRow*>(subaddressRow_ptr);
+    return subaddressRow->getRowId();
+}
+
+// Subaddress
+
+int MONERO_Subaddress_getAll_size(void* subaddress_ptr) {
+    Monero::Subaddress *subaddress = reinterpret_cast<Monero::Subaddress*>(subaddress_ptr);
+    return subaddress->getAll().size();
+}
+void* MONERO_Subaddress_getAll_byIndex(void* subaddress_ptr, int index) {
+    Monero::Subaddress *subaddress = reinterpret_cast<Monero::Subaddress*>(subaddress_ptr);
+    return subaddress->getAll()[index];
+}
+//     virtual void addRow(uint32_t accountIndex, const std::string &label) = 0;
+void MONERO_Subaddress_addRow(void* subaddress_ptr, uint32_t accountIndex, const char* label) {
+    Monero::Subaddress *subaddress = reinterpret_cast<Monero::Subaddress*>(subaddress_ptr);
+    return subaddress->addRow(accountIndex, std::string(label));
+}
+//     virtual void setLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0;
+void MONERO_Subaddress_setLabel(void* subaddress_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label) {
+    Monero::Subaddress *subaddress = reinterpret_cast<Monero::Subaddress*>(subaddress_ptr);
+    return subaddress->setLabel(accountIndex, addressIndex, std::string(label));
+}
+//     virtual void refresh(uint32_t accountIndex) = 0;
+void MONERO_Subaddress_refresh(void* subaddress_ptr, uint32_t accountIndex) {
+    Monero::Subaddress *subaddress = reinterpret_cast<Monero::Subaddress*>(subaddress_ptr);
+    return subaddress->refresh(accountIndex);
+}
+
+// SubaddressAccountRow
+
+//     std::string extra;
+const char* MONERO_SubaddressAccountRow_extra(void* subaddressAccountRow_ptr) {
+    Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast<Monero::SubaddressAccountRow*>(subaddressAccountRow_ptr);
+    std::string str = subaddressAccountRow->extra;
+    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;
+}
+//     std::string getAddress() const {return m_address;}
+const char* MONERO_SubaddressAccountRow_getAddress(void* subaddressAccountRow_ptr) {
+    Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast<Monero::SubaddressAccountRow*>(subaddressAccountRow_ptr);
+    std::string str = subaddressAccountRow->getAddress();
+    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;
+}
+//     std::string getLabel() const {return m_label;}
+const char* MONERO_SubaddressAccountRow_getLabel(void* subaddressAccountRow_ptr) {
+    Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast<Monero::SubaddressAccountRow*>(subaddressAccountRow_ptr);
+    std::string str = subaddressAccountRow->getLabel();
+    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;
+}
+//     std::string getBalance() const {return m_balance;}
+const char* MONERO_SubaddressAccountRow_getBalance(void* subaddressAccountRow_ptr) {
+    Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast<Monero::SubaddressAccountRow*>(subaddressAccountRow_ptr);
+    std::string str = subaddressAccountRow->getBalance();
+    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;
+}
+//     std::string getUnlockedBalance() const {return m_unlockedBalance;}
+const char* MONERO_SubaddressAccountRow_getUnlockedBalance(void* subaddressAccountRow_ptr) {
+    Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast<Monero::SubaddressAccountRow*>(subaddressAccountRow_ptr);
+    std::string str = subaddressAccountRow->getUnlockedBalance();
+    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;
+}
+//     std::size_t getRowId() const {return m_rowId;}
+size_t MONERO_SubaddressAccountRow_getRowId(void* subaddressAccountRow_ptr) {
+    Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast<Monero::SubaddressAccountRow*>(subaddressAccountRow_ptr);
+    return subaddressAccountRow->getRowId();
+}
+
+// struct SubaddressAccount
+// {
+//     virtual ~SubaddressAccount() = 0;
+//     virtual std::vector<SubaddressAccountRow*> getAll() const = 0;
+int MONERO_SubaddressAccount_getAll_size(void* subaddressAccount_ptr) {
+    Monero::SubaddressAccount *subaddress = reinterpret_cast<Monero::SubaddressAccount*>(subaddressAccount_ptr);
+    return subaddress->getAll().size();
+}
+void* MONERO_SubaddressAccount_getAll_byIndex(void* subaddressAccount_ptr, int index) {
+    Monero::SubaddressAccount *subaddress = reinterpret_cast<Monero::SubaddressAccount*>(subaddressAccount_ptr);
+    return subaddress->getAll()[index];
+}
+//     virtual void addRow(const std::string &label) = 0;
+void MONERO_SubaddressAccount_addRow(void* subaddressAccount_ptr, const char* label) {
+    Monero::SubaddressAccount *subaddress = reinterpret_cast<Monero::SubaddressAccount*>(subaddressAccount_ptr);
+    return subaddress->addRow(std::string(label));
+}
+//     virtual void setLabel(uint32_t accountIndex, const std::string &label) = 0;
+void MONERO_SubaddressAccount_setLabel(void* subaddressAccount_ptr, uint32_t accountIndex, const char* label) {
+    Monero::SubaddressAccount *subaddress = reinterpret_cast<Monero::SubaddressAccount*>(subaddressAccount_ptr);
+    return subaddress->setLabel(accountIndex, std::string(label));
+}
+//     virtual void refresh() = 0;
+void MONERO_SubaddressAccount_refresh(void* subaddressAccount_ptr) {
+    Monero::SubaddressAccount *subaddress = reinterpret_cast<Monero::SubaddressAccount*>(subaddressAccount_ptr);
+    return subaddress->refresh();
+}
+
+// MultisigState
+
+//     bool isMultisig;
+bool MONERO_MultisigState_isMultisig(void* multisigState_ptr) {
+    Monero::MultisigState *multisigState = reinterpret_cast<Monero::MultisigState*>(multisigState_ptr);
+    return multisigState->isMultisig;
+}
+//     bool isReady;
+bool MONERO_MultisigState_isReady(void* multisigState_ptr) {
+    Monero::MultisigState *multisigState = reinterpret_cast<Monero::MultisigState*>(multisigState_ptr);
+    return multisigState->isReady;
+}
+//     uint32_t threshold;
+uint32_t MONERO_MultisigState_threshold(void* multisigState_ptr) {
+    Monero::MultisigState *multisigState = reinterpret_cast<Monero::MultisigState*>(multisigState_ptr);
+    return multisigState->threshold;
+}
+//     uint32_t total;
+uint32_t MONERO_MultisigState_total(void* multisigState_ptr) {
+    Monero::MultisigState *multisigState = reinterpret_cast<Monero::MultisigState*>(multisigState_ptr);
+    return multisigState->total;
+}
 
+// DeviceProgress
+
+
+//     virtual double progress() const { return m_progress; }
+bool MONERO_DeviceProgress_progress(void* deviceProgress_ptr) {
+    Monero::DeviceProgress *deviceProgress = reinterpret_cast<Monero::DeviceProgress*>(deviceProgress_ptr);
+    return deviceProgress->progress();
+}
+//     virtual bool indeterminate() const { return m_indeterminate; }
+bool MONERO_DeviceProgress_indeterminate(void* deviceProgress_ptr) {
+    Monero::DeviceProgress *deviceProgress = reinterpret_cast<Monero::DeviceProgress*>(deviceProgress_ptr);
+    return deviceProgress->indeterminate();
+}
+
+// Wallet
 
 const char* MONERO_Wallet_seed(void* wallet_ptr) {
     Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
@@ -200,6 +708,20 @@ const char* MONERO_Wallet_seed(void* wallet_ptr) {
     return buffer;
 }
 
+const char* MONERO_Wallet_getSeedLanguage(void* wallet_ptr) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    std::string str = wallet->getSeedLanguage();
+    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_setSeedLanguage(void* wallet_ptr, const char* arg) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->setSeedLanguage(std::string(arg));
+}
+
 int MONERO_Wallet_status(void* wallet_ptr) {
     Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
     return wallet->status();
@@ -214,6 +736,31 @@ const char* MONERO_Wallet_errorString(void* wallet_ptr) {
     return buffer;
 }
 
+
+bool MONERO_Wallet_setPassword(void* wallet_ptr, const char* password) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->setPassword(std::string(password));
+}
+
+const char* MONERO_Wallet_getPassword(void* wallet_ptr) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    std::string str = wallet->getPassword();
+    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;
+}
+
+bool MONERO_Wallet_setDevicePin(void* wallet_ptr, const char* pin) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->setDevicePin(std::string(pin));
+}
+
+bool MONERO_Wallet_setDevicePassphrase(void* wallet_ptr, const char* passphrase) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->setDevicePassphrase(std::string(passphrase));
+}
+
 const char* MONERO_Wallet_address(void* wallet_ptr, uint64_t accountIndex, uint64_t addressIndex) {
     Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
     std::string str = wallet->address(accountIndex, addressIndex);
@@ -223,6 +770,31 @@ const char* MONERO_Wallet_address(void* wallet_ptr, uint64_t accountIndex, uint6
     return buffer;
 }
 
+const char* MONERO_Wallet_path(void* wallet_ptr) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    std::string str = wallet->path();
+    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;
+}
+int MONERO_Wallet_nettype(void* wallet_ptr) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->nettype();
+}
+uint8_t MONERO_Wallet_useForkRules(void* wallet_ptr, uint8_t version, int64_t early_blocks) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->useForkRules(version, early_blocks);
+}
+const char* MONERO_Wallet_integratedAddress(void* wallet_ptr, const char* payment_id) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    std::string str = wallet->integratedAddress(std::string(payment_id));
+    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;
+}
+
 const char* MONERO_Wallet_secretViewKey(void* wallet_ptr) {
     Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
     std::string str = wallet->secretViewKey();
@@ -258,6 +830,14 @@ const char* MONERO_Wallet_publicSpendKey(void* wallet_ptr) {
     memcpy(buffer, str.c_str(), size + 1);
     return buffer;
 }
+const char* MONERO_Wallet_publicMultisigSignerKey(void* wallet_ptr) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    std::string str = wallet->publicMultisigSignerKey();
+    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_stop(void* wallet_ptr) {
     Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
@@ -268,12 +848,32 @@ bool MONERO_Wallet_store(void* wallet_ptr, const char* path) {
     Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
     return wallet->store(std::string(path));
 }
+bool MONERO_Wallet_filename(void* wallet_ptr) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    std::string str = wallet->filename();
+    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;
+}
+bool MONERO_Wallet_keysFilename(void* wallet_ptr) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    std::string str = wallet->keysFilename();
+    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;
+}
 
 //     virtual bool init(const std::string &daemon_address, uint64_t upper_transaction_size_limit = 0, const std::string &daemon_username = "", const std::string &daemon_password = "", bool use_ssl = false, bool lightWallet = false, const std::string &proxy_address = "") = 0;
 bool MONERO_Wallet_init(void* wallet_ptr, const char* daemon_address, uint64_t upper_transaction_size_limit, const char* daemon_username, const char* daemon_password, bool use_ssl, bool lightWallet, const char* proxy_address) {
     Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
     return wallet->init(std::string(daemon_address), upper_transaction_size_limit, std::string(daemon_username), std::string(daemon_password), use_ssl, lightWallet, std::string(proxy_address));
 }
+bool MONERO_Wallet_createWatchOnly(void* wallet_ptr, const char* path, const char* password, const char* language) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->createWatchOnly(std::string(path), std::string(password), std::string(language));
+}
 
 void MONERO_Wallet_setRefreshFromBlockHeight(void* wallet_ptr, uint64_t refresh_from_block_height) {
     Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
@@ -284,6 +884,20 @@ uint64_t MONERO_Wallet_getRefreshFromBlockHeight(void* wallet_ptr) {
     Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
     return wallet->getRefreshFromBlockHeight();
 }
+
+void MONERO_Wallet_setRecoveringFromSeed(void* wallet_ptr, bool recoveringFromSeed) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->setRecoveringFromSeed(recoveringFromSeed);
+}
+void MONERO_Wallet_setRecoveringFromDevice(void* wallet_ptr, bool recoveringFromDevice) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->setRecoveringFromDevice(recoveringFromDevice);
+}
+void MONERO_Wallet_setSubaddressLookahead(void* wallet_ptr, uint32_t major, uint32_t minor) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->setSubaddressLookahead(major, minor);
+}
+
 bool MONERO_Wallet_connectToDaemon(void* wallet_ptr) {
     Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
     return wallet->connectToDaemon();
@@ -292,6 +906,14 @@ int MONERO_Wallet_connected(void* wallet_ptr) {
     Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
     return wallet->connected();
 }
+void MONERO_Wallet_setTrustedDaemon(void* wallet_ptr, bool arg) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->setTrustedDaemon(arg);
+}
+bool MONERO_Wallet_trustedDaemon(void* wallet_ptr) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->trustedDaemon();
+}
 bool MONERO_Wallet_setProxy(void* wallet_ptr, const char* address) {
     Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
     return wallet->setProxy(std::string(address));
@@ -340,18 +962,63 @@ bool MONERO_Wallet_synchronized(void* wallet_ptr) {
     Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
     return wallet->synchronized();
 }
+
 const char* MONERO_Wallet_displayAmount(uint64_t amount) {
-    // Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
     std::string str = Monero::Wallet::displayAmount(amount);
     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 uint64_t amountFromString(const std::string &amount);
+uint64_t MONERO_Wallet_amountFromString(const char* amount) {
+    return Monero::Wallet::amountFromString(amount);
+}
+//     static uint64_t amountFromDouble(double amount);
+uint64_t MONERO_Wallet_amountFromDouble(double amount) {
+    return Monero::Wallet::amountFromDouble(amount);
+}
+//     static std::string genPaymentId();
+const char* MONERO_Wallet_genPaymentId() {
+    std::string str = Monero::Wallet::genPaymentId();
+    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 paymentIdValid(const std::string &paiment_id);
+bool MONERO_Wallet_paymentIdValid(const char* paiment_id) {
+    return Monero::Wallet::paymentIdValid(std::string(paiment_id));
+}
 bool MONERO_Wallet_addressValid(const char* str, int nettype) {
     // Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
     return Monero::Wallet::addressValid(std::string(str), nettype);
 }
+
+bool MONERO_Wallet_keyValid(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype) {
+    std::string error;
+    return Monero::Wallet::keyValid(std::string(secret_key_string), std::string(address_string), isViewKey, nettype, error);
+}
+const char* MONERO_Wallet_keyValid_error(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype)  {
+    std::string str;
+    Monero::Wallet::keyValid(std::string(secret_key_string), std::string(address_string), isViewKey, nettype, str);
+    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;
+}
+const char* MONERO_Wallet_paymentIdFromAddress(const char* strarg, int nettype) {
+    std::string str = Monero::Wallet::paymentIdFromAddress(std::string(strarg), nettype);
+    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;
+}
+uint64_t MONERO_Wallet_maximumAllowedAmount() {
+    return Monero::Wallet::maximumAllowedAmount();
+}
+
 void MONERO_Wallet_init3(void* wallet_ptr, const char* argv0, const char* default_log_base_name, const char* log_path, bool console) {
     Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
     return wallet->init(argv0, default_log_base_name, log_path, console);
@@ -417,6 +1084,14 @@ void MONERO_Wallet_setSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, u
     Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
     return wallet->setSubaddressLabel(accountIndex, addressIndex, std::string(label));
 }
+const char* MONERO_Wallet_getMultisigInfo(void* wallet_ptr) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    std::string str = wallet->getMultisigInfo();
+    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_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id,
                                                     uint64_t amount, uint32_t mixin_count,
                                                     int pendingTransactionPriority,
@@ -427,6 +1102,10 @@ void* MONERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, co
                                         Monero::PendingTransaction::Priority_Low,
                                         subaddr_account /*, subaddr_indices */);
 }
+void* MONERO_Wallet_loadUnsignedTx(void* wallet_ptr, const char* fileName) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->loadUnsignedTx(std::string(fileName));
+}
 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));
@@ -449,9 +1128,80 @@ bool MONERO_Wallet_importOutputs(void* wallet_ptr, const char* filename) {
 }
 void* MONERO_Wallet_history(void* wallet_ptr) {
     Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
-    return reinterpret_cast<void*>(wallet->history());
+    return wallet->history();
+}
+void* MONERO_Wallet_addressBook(void* wallet_ptr) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->addressBook();
+}
+//     virtual Coins * coins() = 0;
+void* MONERO_Wallet_coins(void* wallet_ptr) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->coins();
+}
+//     virtual Subaddress * subaddress() = 0;
+void* MONERO_Wallet_subaddress(void* wallet_ptr) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->subaddress();
+}
+//     virtual SubaddressAccount * subaddressAccount() = 0;
+void* MONERO_Wallet_subaddressAccount(void* wallet_ptr) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->subaddressAccount();
+}
+//     virtual uint32_t defaultMixin() const = 0;
+uint32_t MONERO_Wallet_defaultMixin(void* wallet_ptr) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->defaultMixin();
+}
+//     virtual void setDefaultMixin(uint32_t arg) = 0;
+void MONERO_Wallet_setTefaultMixin(void* wallet_ptr, uint32_t arg) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->setDefaultMixin(arg);
+}
+//     virtual bool setCacheAttribute(const std::string &key, const std::string &val) = 0;
+bool MONERO_Wallet_setCacheAttribute(void* wallet_ptr, const char* key, const char* val) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->setCacheAttribute(std::string(key), std::string(val));
+}
+//     virtual std::string getCacheAttribute(const std::string &key) const = 0;
+const char* MONERO_Wallet_getCacheAttribute(void* wallet_ptr, const char* key) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    std::string str = wallet->getCacheAttribute(std::string(key));
+    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;
+}
+//     virtual bool setUserNote(const std::string &txid, const std::string &note) = 0;
+bool MONERO_Wallet_setUserNote(void* wallet_ptr, const char* txid, const char* note) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->setUserNote(std::string(txid), std::string(note));
+}
+//     virtual std::string getUserNote(const std::string &txid) const = 0;
+const char* MONERO_Wallet_getUserNote(void* wallet_ptr, const char* txid) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    std::string str = wallet->getUserNote(std::string(txid));
+    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;
 }
-//     virtual void setOffline(bool offline) = 0;
+
+const char* MONERO_Wallet_getTxKey(void* wallet_ptr, const char* txid) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    std::string str = wallet->getTxKey(std::string(txid));
+    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;
+}
+
+bool MONERO_Wallet_rescanSpent(void* wallet_ptr) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->rescanSpent();
+}
+
 void MONERO_Wallet_setOffline(void* wallet_ptr, bool offline) {
     Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
     return wallet->setOffline(offline);
@@ -462,6 +1212,60 @@ bool MONERO_Wallet_isOffline(void* wallet_ptr) {
     return wallet->isOffline();
 }
 
+void MONERO_Wallet_segregatePreForkOutputs(void* wallet_ptr, bool segregate) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->segregatePreForkOutputs(segregate);
+}
+//     virtual void segregationHeight(uint64_t height) = 0;
+void MONERO_Wallet_segregationHeight(void* wallet_ptr, uint64_t height) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->segregationHeight(height);
+}
+//     virtual void keyReuseMitigation2(bool mitigation) = 0;
+void MONERO_Wallet_keyReuseMitigation2(void* wallet_ptr, bool mitigation) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->keyReuseMitigation2(mitigation);
+}
+//     virtual bool lightWalletLogin(bool &isNewWallet) const = 0;
+//     virtual bool lightWalletImportWalletRequest(std::string &payment_id, uint64_t &fee, bool &new_request, bool &request_fulfilled, std::string &payment_address, std::string &status) = 0;
+//     virtual bool lockKeysFile() = 0;
+bool MONERO_Wallet_lockKeysFile(void* wallet_ptr) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->lockKeysFile();
+}
+//     virtual bool unlockKeysFile() = 0;
+bool MONERO_Wallet_unlockKeysFile(void* wallet_ptr) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->unlockKeysFile();
+}
+//     virtual bool isKeysFileLocked() = 0;
+bool MONERO_Wallet_isKeysFileLocked(void* wallet_ptr) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->isKeysFileLocked();
+}
+//     virtual Device getDeviceType() const = 0;
+int MONERO_Wallet_getDeviceType(void* wallet_ptr) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->getDeviceType();
+}
+//     virtual uint64_t coldKeyImageSync(uint64_t &spent, uint64_t &unspent) = 0;
+uint64_t MONERO_Wallet_coldKeyImageSync(void* wallet_ptr, uint64_t spent, uint64_t unspent) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    return wallet->coldKeyImageSync(spent, unspent);
+}
+//     virtual void deviceShowAddress(uint32_t accountIndex, uint32_t addressIndex, const std::string &paymentId) = 0;
+const char* MONERO_Wallet_deviceShowAddress(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex) {
+    Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+    std::string str = "";
+    wallet->deviceShowAddress(accountIndex, addressIndex, str);
+    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;
+}
+//     virtual bool reconnectDevice() = 0;
+const char* MONERO_Wallet_reconnectDevice(void* wallet_ptr);
+
 uint64_t MONERO_Wallet_getBytesReceived(void* wallet_ptr) {
     Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
     return wallet->getBytesReceived();
@@ -515,6 +1319,21 @@ bool MONERO_WalletManager_closeWallet(void* wallet_ptr, bool store) {
 bool MONERO_WalletManager_walletExists(const char* path) {
     return Monero::WalletManagerFactory::getWalletManager()->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);
+}
+//     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_errorString() {
     std::string str = Monero::WalletManagerFactory::getWalletManager()->errorString();
     const std::string::size_type size = str.size();
@@ -531,6 +1350,49 @@ bool MONERO_WalletManager_setProxy(const char* address) {
     return Monero::WalletManagerFactory::getWalletManager()->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();
+}
+//     virtual uint64_t blockchainTargetHeight() = 0;
+uint64_t MONERO_WalletManager_blockchainTargetHeight() {
+    return Monero::WalletManagerFactory::getWalletManager()->blockchainTargetHeight();
+}
+//     virtual uint64_t networkDifficulty() = 0;
+uint64_t MONERO_WalletManager_networkDifficulty() {
+    return Monero::WalletManagerFactory::getWalletManager()->networkDifficulty();
+}
+//     virtual double miningHashRate() = 0;
+double MONERO_WalletManager_miningHashRate() {
+    return Monero::WalletManagerFactory::getWalletManager()->miningHashRate();
+}
+//     virtual uint64_t blockTarget() = 0;
+uint64_t MONERO_WalletManager_blockTarget() {
+    return Monero::WalletManagerFactory::getWalletManager()->blockTarget();
+}
+//     virtual bool isMining() = 0;
+bool MONERO_WalletManager_isMining() {
+    return Monero::WalletManagerFactory::getWalletManager()->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);
+}
+//     virtual bool stopMining() = 0;
+bool MONERO_WalletManager_stopMining(const char* address) {
+    return Monero::WalletManagerFactory::getWalletManager()->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 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;
+}
+
 // WalletManagerFactory
 
 void MONERO_WalletManagerFactory_setLogLevel(int level) {