summaryrefslogtreecommitdiff
path: root/wownero_libwallet2_api_c/src/main
diff options
context:
space:
mode:
Diffstat (limited to 'wownero_libwallet2_api_c/src/main')
l---------wownero_libwallet2_api_c/src/main/cpp/helpers.cpp1
l---------wownero_libwallet2_api_c/src/main/cpp/helpers.hpp1
-rw-r--r--wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp1651
-rw-r--r--wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.h981
4 files changed, 2634 insertions, 0 deletions
diff --git a/wownero_libwallet2_api_c/src/main/cpp/helpers.cpp b/wownero_libwallet2_api_c/src/main/cpp/helpers.cpp
new file mode 120000
index 0000000..524768b
--- /dev/null
+++ b/wownero_libwallet2_api_c/src/main/cpp/helpers.cpp
@@ -0,0 +1 @@
+../../../../monero_libwallet2_api_c/src/main/cpp/helpers.cpp \ No newline at end of file
diff --git a/wownero_libwallet2_api_c/src/main/cpp/helpers.hpp b/wownero_libwallet2_api_c/src/main/cpp/helpers.hpp
new file mode 120000
index 0000000..99d2733
--- /dev/null
+++ b/wownero_libwallet2_api_c/src/main/cpp/helpers.hpp
@@ -0,0 +1 @@
+../../../../monero_libwallet2_api_c/src/main/cpp/helpers.hpp \ No newline at end of file
diff --git a/wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp b/wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp
new file mode 100644
index 0000000..65769aa
--- /dev/null
+++ b/wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp
@@ -0,0 +1,1651 @@
+#include <inttypes.h>
+#include "wallet2_api_c.h"
+#include <unistd.h>
+#include "helpers.hpp"
+#include <cstring>
+#include <thread>
+#include "../../../../wownero/src/wallet/api/wallet2_api.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+// PendingTransaction
+
+int WOWNERO_PendingTransaction_status(void* pendingTx_ptr) {
+ Monero::PendingTransaction *pendingTx = reinterpret_cast<Monero::PendingTransaction*>(pendingTx_ptr);
+ return pendingTx->status();
+}
+const char* WOWNERO_PendingTransaction_errorString(void* pendingTx_ptr) {
+ Monero::PendingTransaction *pendingTx = reinterpret_cast<Monero::PendingTransaction*>(pendingTx_ptr);
+ std::string str = pendingTx->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;
+}
+bool WOWNERO_PendingTransaction_commit(void* pendingTx_ptr, const char* filename, bool overwrite) {
+ Monero::PendingTransaction *pendingTx = reinterpret_cast<Monero::PendingTransaction*>(pendingTx_ptr);
+ return pendingTx->commit(std::string(filename), overwrite);
+}
+uint64_t WOWNERO_PendingTransaction_amount(void* pendingTx_ptr) {
+ Monero::PendingTransaction *pendingTx = reinterpret_cast<Monero::PendingTransaction*>(pendingTx_ptr);
+ return pendingTx->amount();
+}
+uint64_t WOWNERO_PendingTransaction_dust(void* pendingTx_ptr) {
+ Monero::PendingTransaction *pendingTx = reinterpret_cast<Monero::PendingTransaction*>(pendingTx_ptr);
+ return pendingTx->dust();
+}
+uint64_t WOWNERO_PendingTransaction_fee(void* pendingTx_ptr) {
+ Monero::PendingTransaction *pendingTx = reinterpret_cast<Monero::PendingTransaction*>(pendingTx_ptr);
+ return pendingTx->fee();
+}
+const char* WOWNERO_PendingTransaction_txid(void* pendingTx_ptr, const char* separator) {
+ Monero::PendingTransaction *pendingTx = reinterpret_cast<Monero::PendingTransaction*>(pendingTx_ptr);
+ std::vector<std::string> txid = pendingTx->txid();
+ return vectorToString(txid, std::string(separator));
+}
+uint64_t WOWNERO_PendingTransaction_txCount(void* pendingTx_ptr) {
+ Monero::PendingTransaction *pendingTx = reinterpret_cast<Monero::PendingTransaction*>(pendingTx_ptr);
+ return pendingTx->txCount();
+}
+const char* WOWNERO_PendingTransaction_subaddrAccount(void* pendingTx_ptr, const char* separator) {
+ Monero::PendingTransaction *pendingTx = reinterpret_cast<Monero::PendingTransaction*>(pendingTx_ptr);
+ std::vector<uint32_t> subaddrAccount = pendingTx->subaddrAccount();
+ return vectorToString(subaddrAccount, std::string(separator));
+}
+const char* WOWNERO_PendingTransaction_subaddrIndices(void* pendingTx_ptr, const char* separator) {
+ Monero::PendingTransaction *pendingTx = reinterpret_cast<Monero::PendingTransaction*>(pendingTx_ptr);
+ std::vector<std::set<uint32_t>> subaddrIndices = pendingTx->subaddrIndices();
+ return vectorToString(subaddrIndices, std::string(separator));
+}
+const char* WOWNERO_PendingTransaction_multisigSignData(void* pendingTx_ptr) {
+ Monero::PendingTransaction *pendingTx = reinterpret_cast<Monero::PendingTransaction*>(pendingTx_ptr);
+ std::string str = pendingTx->multisigSignData();
+ 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 WOWNERO_PendingTransaction_signMultisigTx(void* pendingTx_ptr) {
+ Monero::PendingTransaction *pendingTx = reinterpret_cast<Monero::PendingTransaction*>(pendingTx_ptr);
+ return pendingTx->signMultisigTx();
+}
+const char* WOWNERO_PendingTransaction_signersKeys(void* pendingTx_ptr, const char* separator) {
+ Monero::PendingTransaction *pendingTx = reinterpret_cast<Monero::PendingTransaction*>(pendingTx_ptr);
+ std::vector<std::string> txid = pendingTx->signersKeys();
+ return vectorToString(txid, std::string(separator));
+}
+
+// UnsignedTransaction
+
+int WOWNERO_UnsignedTransaction_status(void* unsignedTx_ptr) {
+ Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr);
+ return unsignedTx->status();
+}
+const char* WOWNERO_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* WOWNERO_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* WOWNERO_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* WOWNERO_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* WOWNERO_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* WOWNERO_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* WOWNERO_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 WOWNERO_UnsignedTransaction_minMixinCount(void* unsignedTx_ptr) {
+ Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr);
+ return unsignedTx->minMixinCount();
+}
+uint64_t WOWNERO_UnsignedTransaction_txCount(void* unsignedTx_ptr) {
+ Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr);
+ return unsignedTx->txCount();
+}
+bool WOWNERO_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 WOWNERO_TransactionInfo_direction(void* txInfo_ptr) {
+ Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+ return txInfo->direction();
+}
+bool WOWNERO_TransactionInfo_isPending(void* txInfo_ptr) {
+ Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+ return txInfo->isPending();
+}
+bool WOWNERO_TransactionInfo_isFailed(void* txInfo_ptr) {
+ Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+ return txInfo->isFailed();
+}
+bool WOWNERO_TransactionInfo_isCoinbase(void* txInfo_ptr) {
+ Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+ return txInfo->isCoinbase();
+}
+uint64_t WOWNERO_TransactionInfo_amount(void* txInfo_ptr) {
+ Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+ return txInfo->amount();
+}
+uint64_t WOWNERO_TransactionInfo_fee(void* txInfo_ptr) {
+ Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+ return txInfo->fee();
+}
+uint64_t WOWNERO_TransactionInfo_blockHeight(void* txInfo_ptr) {
+ Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+ return txInfo->blockHeight();
+}
+const char* WOWNERO_TransactionInfo_description(void* txInfo_ptr) {
+ Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+ std::string str = txInfo->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;
+}
+const char* WOWNERO_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 WOWNERO_TransactionInfo_subaddrAccount(void* txInfo_ptr) {
+ Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+ return txInfo->subaddrAccount();
+}
+const char* WOWNERO_TransactionInfo_label(void* txInfo_ptr) {
+ Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+ std::string str = txInfo->label();
+ 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 WOWNERO_TransactionInfo_confirmations(void* txInfo_ptr) {
+ Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+ return txInfo->confirmations();
+}
+uint64_t WOWNERO_TransactionInfo_unlockTime(void* txInfo_ptr) {
+ Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+ return txInfo->unlockTime();
+}
+const char* WOWNERO_TransactionInfo_hash(void* txInfo_ptr) {
+ Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+ std::string str = txInfo->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;
+}
+uint64_t WOWNERO_TransactionInfo_timestamp(void* txInfo_ptr) {
+ Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+ return txInfo->timestamp();
+}
+const char* WOWNERO_TransactionInfo_paymentId(void* txInfo_ptr) {
+ Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+ std::string str = txInfo->paymentId();
+ 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 WOWNERO_TransactionInfo_transfers_count(void* txInfo_ptr) {
+ Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+ return txInfo->transfers().size();
+}
+
+uint64_t WOWNERO_TransactionInfo_transfers_amount(void* txInfo_ptr, int index) {
+ Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr);
+ return txInfo->transfers()[index].amount;
+}
+
+const char* WOWNERO_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 WOWNERO_TransactionHistory_count(void* txHistory_ptr) {
+ Monero::TransactionHistory *txHistory = reinterpret_cast<Monero::TransactionHistory*>(txHistory_ptr);
+ return txHistory->count();
+}
+void* WOWNERO_TransactionHistory_transaction(void* txHistory_ptr, int index) {
+ Monero::TransactionHistory *txHistory = reinterpret_cast<Monero::TransactionHistory*>(txHistory_ptr);
+ return reinterpret_cast<void*>(txHistory->transaction(index));
+}
+void* WOWNERO_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)));
+}
+
+void WOWNERO_TransactionHistory_refresh(void* txHistory_ptr) {
+ Monero::TransactionHistory *txHistory = reinterpret_cast<Monero::TransactionHistory*>(txHistory_ptr);
+ return txHistory->refresh();
+}
+void WOWNERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, const char* note) {
+ Monero::TransactionHistory *txHistory = reinterpret_cast<Monero::TransactionHistory*>(txHistory_ptr);
+ return txHistory->setTxNote(std::string(txid), std::string(note));
+}
+
+// AddressBokRow
+
+// std::string extra;
+const char* WOWNERO_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* WOWNERO_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* WOWNERO_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* WOWNERO_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 WOWNERO_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 WOWNERO_AddressBook_getAll_size(void* addressBook_ptr) {
+ Monero::AddressBook *addressBook = reinterpret_cast<Monero::AddressBook*>(addressBook_ptr);
+ return addressBook->getAll().size();
+}
+void* WOWNERO_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 WOWNERO_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 WOWNERO_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 WOWNERO_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 WOWNERO_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* WOWNERO_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 WOWNERO_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 WOWNERO_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 WOWNERO_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* WOWNERO_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 WOWNERO_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 WOWNERO_CoinsInfo_globalOutputIndex(void* coinsInfo_ptr) {
+ Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+ return coinsInfo->globalOutputIndex();
+}
+// virtual bool spent() const = 0;
+bool WOWNERO_CoinsInfo_spent(void* coinsInfo_ptr) {
+ Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+ return coinsInfo->spent();
+}
+// virtual bool frozen() const = 0;
+bool WOWNERO_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 WOWNERO_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 WOWNERO_CoinsInfo_amount(void* coinsInfo_ptr) {
+ Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+ return coinsInfo->amount();
+}
+// virtual bool rct() const = 0;
+bool WOWNERO_CoinsInfo_rct(void* coinsInfo_ptr) {
+ Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+ return coinsInfo->rct();
+}
+// virtual bool keyImageKnown() const = 0;
+bool WOWNERO_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 WOWNERO_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 WOWNERO_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 WOWNERO_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* WOWNERO_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* WOWNERO_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* WOWNERO_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 WOWNERO_CoinsInfo_unlockTime(void* coinsInfo_ptr) {
+ Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr);
+ return coinsInfo->unlockTime();
+}
+// virtual bool unlocked() const = 0;
+bool WOWNERO_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* WOWNERO_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 WOWNERO_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* WOWNERO_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
+
+// virtual ~Coins() = 0;
+// virtual int count() const = 0;
+int WOWNERO_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* WOWNERO_Coins_coin(void* coins_ptr, int index) {
+ Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr);
+ return coins->coin(index);
+}
+
+int WOWNERO_Coins_getAll_size(void* coins_ptr) {
+ Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr);
+ return coins->getAll().size();
+}
+void* WOWNERO_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 WOWNERO_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 WOWNERO_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 WOWNERO_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 WOWNERO_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 WOWNERO_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 WOWNERO_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 WOWNERO_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
+
+// std::string extra;
+const char* WOWNERO_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* WOWNERO_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* WOWNERO_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 WOWNERO_SubaddressRow_getRowId(void* subaddressRow_ptr) {
+ Monero::SubaddressRow *subaddressRow = reinterpret_cast<Monero::SubaddressRow*>(subaddressRow_ptr);
+ return subaddressRow->getRowId();
+}
+
+// Subaddress
+
+int WOWNERO_Subaddress_getAll_size(void* subaddress_ptr) {
+ Monero::Subaddress *subaddress = reinterpret_cast<Monero::Subaddress*>(subaddress_ptr);
+ return subaddress->getAll().size();
+}
+void* WOWNERO_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 WOWNERO_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 WOWNERO_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 WOWNERO_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* WOWNERO_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* WOWNERO_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* WOWNERO_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* WOWNERO_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* WOWNERO_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 WOWNERO_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 WOWNERO_SubaddressAccount_getAll_size(void* subaddressAccount_ptr) {
+ Monero::SubaddressAccount *subaddress = reinterpret_cast<Monero::SubaddressAccount*>(subaddressAccount_ptr);
+ return subaddress->getAll().size();
+}
+void* WOWNERO_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 WOWNERO_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 WOWNERO_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 WOWNERO_SubaddressAccount_refresh(void* subaddressAccount_ptr) {
+ Monero::SubaddressAccount *subaddress = reinterpret_cast<Monero::SubaddressAccount*>(subaddressAccount_ptr);
+ return subaddress->refresh();
+}
+
+// MultisigState
+
+// bool isMultisig;
+bool WOWNERO_MultisigState_isMultisig(void* multisigState_ptr) {
+ Monero::MultisigState *multisigState = reinterpret_cast<Monero::MultisigState*>(multisigState_ptr);
+ return multisigState->isMultisig;
+}
+// bool isReady;
+bool WOWNERO_MultisigState_isReady(void* multisigState_ptr) {
+ Monero::MultisigState *multisigState = reinterpret_cast<Monero::MultisigState*>(multisigState_ptr);
+ return multisigState->isReady;
+}
+// uint32_t threshold;
+uint32_t WOWNERO_MultisigState_threshold(void* multisigState_ptr) {
+ Monero::MultisigState *multisigState = reinterpret_cast<Monero::MultisigState*>(multisigState_ptr);
+ return multisigState->threshold;
+}
+// uint32_t total;
+uint32_t WOWNERO_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 WOWNERO_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 WOWNERO_DeviceProgress_indeterminate(void* deviceProgress_ptr) {
+ Monero::DeviceProgress *deviceProgress = reinterpret_cast<Monero::DeviceProgress*>(deviceProgress_ptr);
+ return deviceProgress->indeterminate();
+}
+
+// Wallet
+
+const char* WOWNERO_Wallet_seed(void* wallet_ptr, const char* seed_offset) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ std::string str = wallet->seed(std::string(seed_offset));
+ 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* WOWNERO_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 WOWNERO_Wallet_setSeedLanguage(void* wallet_ptr, const char* arg) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->setSeedLanguage(std::string(arg));
+}
+
+int WOWNERO_Wallet_status(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->status();
+}
+
+const char* WOWNERO_Wallet_errorString(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ std::string str = wallet->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;
+}
+
+
+bool WOWNERO_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* WOWNERO_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 WOWNERO_Wallet_setDevicePin(void* wallet_ptr, const char* pin) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->setDevicePin(std::string(pin));
+}
+
+bool WOWNERO_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* WOWNERO_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);
+ 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* WOWNERO_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 WOWNERO_Wallet_nettype(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->nettype();
+}
+uint8_t WOWNERO_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* WOWNERO_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* WOWNERO_Wallet_secretViewKey(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ std::string str = wallet->secretViewKey();
+ 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* WOWNERO_Wallet_publicViewKey(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ std::string str = wallet->publicViewKey();
+ 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* WOWNERO_Wallet_secretSpendKey(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ std::string str = wallet->secretSpendKey();
+ 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* WOWNERO_Wallet_publicSpendKey(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ std::string str = wallet->publicSpendKey();
+ 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* WOWNERO_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 WOWNERO_Wallet_stop(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ wallet->stop();
+}
+
+bool WOWNERO_Wallet_store(void* wallet_ptr, const char* path) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->store(std::string(path));
+}
+const char* WOWNERO_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;
+}
+const char* WOWNERO_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 WOWNERO_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 WOWNERO_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 WOWNERO_Wallet_setRefreshFromBlockHeight(void* wallet_ptr, uint64_t refresh_from_block_height) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->setRefreshFromBlockHeight(refresh_from_block_height);
+}
+
+uint64_t WOWNERO_Wallet_getRefreshFromBlockHeight(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->getRefreshFromBlockHeight();
+}
+
+void WOWNERO_Wallet_setRecoveringFromSeed(void* wallet_ptr, bool recoveringFromSeed) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->setRecoveringFromSeed(recoveringFromSeed);
+}
+void WOWNERO_Wallet_setRecoveringFromDevice(void* wallet_ptr, bool recoveringFromDevice) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->setRecoveringFromDevice(recoveringFromDevice);
+}
+void WOWNERO_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 WOWNERO_Wallet_connectToDaemon(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->connectToDaemon();
+}
+int WOWNERO_Wallet_connected(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->connected();
+}
+void WOWNERO_Wallet_setTrustedDaemon(void* wallet_ptr, bool arg) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->setTrustedDaemon(arg);
+}
+bool WOWNERO_Wallet_trustedDaemon(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->trustedDaemon();
+}
+bool WOWNERO_Wallet_setProxy(void* wallet_ptr, const char* address) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->setProxy(std::string(address));
+}
+
+uint64_t WOWNERO_Wallet_balance(void* wallet_ptr, uint32_t accountIndex) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->balance(accountIndex);
+}
+
+uint64_t WOWNERO_Wallet_unlockedBalance(void* wallet_ptr, uint32_t accountIndex) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->unlockedBalance(accountIndex);
+}
+
+uint64_t WOWNERO_Wallet_viewOnlyBalance(void* wallet_ptr, uint32_t accountIndex) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->viewOnlyBalance(accountIndex);
+}
+
+// TODO
+bool WOWNERO_Wallet_watchOnly(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->watchOnly();
+}
+bool WOWNERO_Wallet_isDeterministic(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->isDeterministic();
+}
+uint64_t WOWNERO_Wallet_blockChainHeight(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->blockChainHeight();
+}
+uint64_t WOWNERO_Wallet_approximateBlockChainHeight(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->approximateBlockChainHeight();
+}
+uint64_t WOWNERO_Wallet_estimateBlockChainHeight(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->estimateBlockChainHeight();
+}
+uint64_t WOWNERO_Wallet_daemonBlockChainHeight(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->daemonBlockChainHeight();
+}
+
+uint64_t daemonBlockChainHeight_cached = 0;
+
+uint64_t WOWNERO_Wallet_daemonBlockChainHeight_cached(void* wallet_ptr) {
+ return daemonBlockChainHeight_cached;
+}
+
+bool daemonBlockChainHeight_cacheIsEnabled = false;
+
+
+void WOWNERO_Wallet_daemonBlockChainHeight_runThread(void* wallet_ptr, int seconds) {
+ while (true) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ daemonBlockChainHeight_cached = wallet->daemonBlockChainHeight();
+ sleep(seconds);
+ std::cout << "MONERO: TICK: WOWNERO_Wallet_daemonBlockChainHeight_runThread(" << seconds << "): " << daemonBlockChainHeight_cached << std::endl;
+ }
+}
+uint64_t WOWNERO_Wallet_daemonBlockChainTargetHeight(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->daemonBlockChainTargetHeight();
+}
+bool WOWNERO_Wallet_synchronized(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->synchronized();
+}
+
+const char* WOWNERO_Wallet_displayAmount(uint64_t amount) {
+ 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 WOWNERO_Wallet_amountFromString(const char* amount) {
+ return Monero::Wallet::amountFromString(amount);
+}
+// static uint64_t amountFromDouble(double amount);
+uint64_t WOWNERO_Wallet_amountFromDouble(double amount) {
+ return Monero::Wallet::amountFromDouble(amount);
+}
+// static std::string genPaymentId();
+const char* WOWNERO_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 WOWNERO_Wallet_paymentIdValid(const char* paiment_id) {
+ return Monero::Wallet::paymentIdValid(std::string(paiment_id));
+}
+bool WOWNERO_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 WOWNERO_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* WOWNERO_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* WOWNERO_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 WOWNERO_Wallet_maximumAllowedAmount() {
+ return Monero::Wallet::maximumAllowedAmount();
+}
+
+void WOWNERO_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);
+}
+const char* WOWNERO_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* WOWNERO_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 WOWNERO_Wallet_startRefresh(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->startRefresh();
+}
+void WOWNERO_Wallet_pauseRefresh(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->pauseRefresh();
+}
+bool WOWNERO_Wallet_refresh(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->refresh();
+}
+void WOWNERO_Wallet_refreshAsync(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->refreshAsync();
+}
+bool WOWNERO_Wallet_rescanBlockchain(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->rescanBlockchain();
+}
+void WOWNERO_Wallet_rescanBlockchainAsync(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->rescanBlockchainAsync();
+}
+void WOWNERO_Wallet_setAutoRefreshInterval(void* wallet_ptr, int millis) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->setAutoRefreshInterval(millis);
+}
+int WOWNERO_Wallet_autoRefreshInterval(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->autoRefreshInterval();
+}
+void WOWNERO_Wallet_addSubaddressAccount(void* wallet_ptr, const char* label) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->addSubaddressAccount(std::string(label));
+}
+size_t WOWNERO_Wallet_numSubaddressAccounts(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->numSubaddressAccounts();
+}
+size_t WOWNERO_Wallet_numSubaddresses(void* wallet_ptr, uint32_t accountIndex) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->numSubaddresses(accountIndex);
+}
+void WOWNERO_Wallet_addSubaddress(void* wallet_ptr, uint32_t accountIndex, const char* label) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->addSubaddress(accountIndex, std::string(label));
+}
+const char* WOWNERO_Wallet_getSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ std::string str = wallet->getSubaddressLabel(accountIndex, addressIndex);
+ 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 WOWNERO_Wallet_setSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->setSubaddressLabel(accountIndex, addressIndex, std::string(label));
+}
+const char* WOWNERO_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;
+}
+
+Monero::PendingTransaction::Priority PendingTransaction_Priority_fromInt(int value) {
+ switch(value) {
+ case 0: return Monero::PendingTransaction::Priority::Priority_Default;
+ case 1: return Monero::PendingTransaction::Priority::Priority_Low;
+ case 2: return Monero::PendingTransaction::Priority::Priority_Medium;
+ case 3: return Monero::PendingTransaction::Priority::Priority_High;
+ default: return Monero::PendingTransaction::Priority::Priority_Default;
+ }
+}
+
+void* WOWNERO_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,
+ 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));
+ return wallet->createTransaction(std::string(dst_addr), std::string(payment_id),
+ optAmount, mixin_count,
+ PendingTransaction_Priority_fromInt(pendingTransactionPriority),
+ subaddr_account, subaddr_indices, preferred_inputs);
+}
+
+
+void* WOWNERO_Wallet_loadUnsignedTx(void* wallet_ptr, const char* fileName) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->loadUnsignedTx(std::string(fileName));
+}
+bool WOWNERO_Wallet_submitTransaction(void* wallet_ptr, const char* fileName) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->submitTransaction(std::string(fileName));
+}
+bool WOWNERO_Wallet_hasUnknownKeyImages(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->hasUnknownKeyImages();
+}
+bool WOWNERO_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);
+}
+bool WOWNERO_Wallet_importKeyImages(void* wallet_ptr, const char* filename) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->importKeyImages(std::string(filename));
+}
+bool WOWNERO_Wallet_exportOutputs(void* wallet_ptr, const char* filename, bool all) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->exportOutputs(std::string(filename), all);
+}
+bool WOWNERO_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 WOWNERO_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 WOWNERO_Wallet_getBackgroundSyncType(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->getBackgroundSyncType();
+}
+// virtual bool startBackgroundSync() = 0;
+bool WOWNERO_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 WOWNERO_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 WOWNERO_Wallet_isBackgroundSyncing(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->hasUnknownKeyImages();
+}
+// virtual bool isBackgroundWallet() const = 0;
+bool WOWNERO_Wallet_isBackgroundWallet(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->isBackgroundWallet();
+}
+void* WOWNERO_Wallet_history(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->history();
+}
+void* WOWNERO_Wallet_addressBook(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->addressBook();
+}
+// virtual Coins * coins() = 0;
+void* WOWNERO_Wallet_coins(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->coins();
+}
+// virtual Subaddress * subaddress() = 0;
+void* WOWNERO_Wallet_subaddress(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->subaddress();
+}
+// virtual SubaddressAccount * subaddressAccount() = 0;
+void* WOWNERO_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 WOWNERO_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 WOWNERO_Wallet_setDefaultMixin(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 WOWNERO_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* WOWNERO_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 WOWNERO_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* WOWNERO_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;
+}
+
+const char* WOWNERO_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;
+}
+
+const char* WOWNERO_Wallet_signMessage(void* wallet_ptr, const char* message, const char* address) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ std::string str = wallet->signMessage(std::string(message), std::string(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;
+}
+
+bool WOWNERO_Wallet_verifySignedMessage(void* wallet_ptr, const char* message, const char* address, const char* signature) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ bool v = wallet->verifySignedMessage(std::string(message), std::string(address), std::string(signature));
+ return v;
+}
+
+bool WOWNERO_Wallet_rescanSpent(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->rescanSpent();
+}
+
+void WOWNERO_Wallet_setOffline(void* wallet_ptr, bool offline) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->setOffline(offline);
+}
+// virtual bool isOffline() const = 0;
+bool WOWNERO_Wallet_isOffline(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->isOffline();
+}
+
+void WOWNERO_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 WOWNERO_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 WOWNERO_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 WOWNERO_Wallet_lockKeysFile(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->lockKeysFile();
+}
+// virtual bool unlockKeysFile() = 0;
+bool WOWNERO_Wallet_unlockKeysFile(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->unlockKeysFile();
+}
+// virtual bool isKeysFileLocked() = 0;
+bool WOWNERO_Wallet_isKeysFileLocked(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->isKeysFileLocked();
+}
+// virtual Device getDeviceType() const = 0;
+int WOWNERO_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 WOWNERO_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* WOWNERO_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* WOWNERO_Wallet_reconnectDevice(void* wallet_ptr);
+
+uint64_t WOWNERO_Wallet_getBytesReceived(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->getBytesReceived();
+}
+uint64_t WOWNERO_Wallet_getBytesSent(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return wallet->getBytesSent();
+}
+
+
+void* WOWNERO_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),
+ static_cast<Monero::NetworkType>(networkType));
+ return reinterpret_cast<void*>(wallet);
+}
+
+void* WOWNERO_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* WOWNERO_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 = wm->recoveryWallet(
+ std::string(path),
+ std::string(password),
+ std::string(mnemonic),
+ static_cast<Monero::NetworkType>(networkType),
+ restoreHeight,
+ kdfRounds,
+ 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* WOWNERO_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);
+}
+
+void* WOWNERO_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 WOWNERO_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 wm->closeWallet(wallet, store);
+}
+
+bool WOWNERO_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 WOWNERO_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 WOWNERO_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* WOWNERO_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* WOWNERO_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 WOWNERO_WalletManager_setDaemonAddress(void* wm_ptr, const char* address) {
+ Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr);
+ return wm->setDaemonAddress(std::string(address));
+}
+
+bool WOWNERO_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 WOWNERO_WalletManager_blockchainHeight(void* wm_ptr) {
+ Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr);
+ return wm->blockchainHeight();
+}
+// virtual uint64_t blockchainTargetHeight() = 0;
+uint64_t WOWNERO_WalletManager_blockchainTargetHeight(void* wm_ptr) {
+ Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr);
+ return wm->blockchainTargetHeight();
+}
+// virtual uint64_t networkDifficulty() = 0;
+uint64_t WOWNERO_WalletManager_networkDifficulty(void* wm_ptr) {
+ Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr);
+ return wm->networkDifficulty();
+}
+// virtual double miningHashRate() = 0;
+double WOWNERO_WalletManager_miningHashRate(void* wm_ptr) {
+ Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr);
+ return wm->miningHashRate();
+}
+// virtual uint64_t blockTarget() = 0;
+uint64_t WOWNERO_WalletManager_blockTarget(void* wm_ptr) {
+ Monero::WalletManager *wm = reinterpret_cast<Monero::WalletManager*>(wm_ptr);
+ return wm->blockTarget();
+}
+// virtual bool isMining() = 0;
+bool WOWNERO_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 WOWNERO_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 WOWNERO_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* WOWNERO_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);
+ return buffer;
+}
+
+// WalletManagerFactory
+
+void* WOWNERO_WalletManagerFactory_getWalletManager() {
+ Monero::WalletManager *wm = Monero::WalletManagerFactory::getWalletManager();
+ return reinterpret_cast<void*>(wm);
+}
+
+void WOWNERO_WalletManagerFactory_setLogLevel(int level) {
+ Monero::WalletManagerFactory::setLogLevel(level);
+}
+
+// DEBUG functions
+
+// As it turns out we need a bit more functions to make sure that the library is working.
+// 0) void
+// 1) bool
+// 2) int
+// 3) uint64_t
+// 4) void*
+// 5) const char*
+
+void WOWNERO_DEBUG_test0() {
+ return;
+}
+
+bool WOWNERO_DEBUG_test1(bool x) {
+ return x;
+}
+
+int WOWNERO_DEBUG_test2(int x) {
+ return x;
+}
+
+uint64_t WOWNERO_DEBUG_test3(uint64_t x) {
+ return x;
+}
+
+void* WOWNERO_DEBUG_test4(uint64_t x) {
+ int y = x;
+ return reinterpret_cast<void*>(&y);
+}
+
+const char* WOWNERO_DEBUG_test5() {
+ const char *text = "This is a const char* text";
+ return text;
+}
+
+const char* WOWNERO_DEBUG_test5_std() {
+ std::string text ("This is a std::string text");
+ const char *text2 = "This is a text";
+ return text2;
+}
+
+bool WOWNERO_DEBUG_isPointerNull(void* wallet_ptr) {
+ Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr);
+ return (wallet != NULL);
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.h b/wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.h
new file mode 100644
index 0000000..8e67d4b
--- /dev/null
+++ b/wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.h
@@ -0,0 +1,981 @@
+/*
+#include <android/log.h>
+
+#define LOG_TAG "[NDK]"
+#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__)
+*/
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <unistd.h>
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifdef __MINGW32__
+ #define ADDAPI __declspec(dllexport)
+#else
+ #define ADDAPI
+#endif
+
+// namespace Monero {
+// enum NetworkType : uint8_t {
+// MAINNET = 0,
+const int NetworkType_MAINNET = 0;
+// TESTNET,
+const int NetworkType_TESTNET = 1;
+// STAGENET
+const int NetworkType_STAGENET = 2;
+// };
+// namespace Utils {
+// bool isAddressLocal(const std::string &hostaddr);
+// void onStartup();
+// }
+// template<typename T>
+// class optional {
+// public:
+// optional(): set(false) {}
+// optional(const T &t): t(t), set(true) {}
+// const T &operator*() const { return t; }
+// T &operator*() { return t; }
+// operator bool() const { return set; }
+// private:
+// T t;
+// bool set;
+// };
+
+// struct PendingTransaction
+// {
+// enum Status {
+// Status_Ok,
+const int PendingTransactionStatus_Ok = 0;
+// Status_Error,
+const int PendingTransactionStatus_Error = 1;
+// Status_Critical
+const int PendingTransactionStatus_Critical = 2;
+// };
+// enum Priority {
+// Priority_Default = 0,
+const int Priority_Default = 0;
+// Priority_Low = 1,
+const int Priority_Low = 1;
+// Priority_Medium = 2,
+const int Priority_Medium = 2;
+// Priority_High = 3,
+const int Priority_High = 3;
+// Priority_Last
+const int Priority_Last = 4;
+// };
+// virtual ~PendingTransaction() = 0;
+// virtual int status() const = 0;
+extern ADDAPI int WOWNERO_PendingTransaction_status(void* pendingTx_ptr);
+// virtual std::string errorString() const = 0;
+extern ADDAPI const char* WOWNERO_PendingTransaction_errorString(void* pendingTx_ptr);
+// virtual bool commit(const std::string &filename = "", bool overwrite = false) = 0;
+extern ADDAPI bool WOWNERO_PendingTransaction_commit(void* pendingTx_ptr, const char* filename, bool overwrite);
+// virtual uint64_t amount() const = 0;
+extern ADDAPI uint64_t WOWNERO_PendingTransaction_amount(void* pendingTx_ptr);
+// virtual uint64_t dust() const = 0;
+extern ADDAPI uint64_t WOWNERO_PendingTransaction_dust(void* pendingTx_ptr);
+// virtual uint64_t fee() const = 0;
+extern ADDAPI uint64_t WOWNERO_PendingTransaction_fee(void* pendingTx_ptr);
+// virtual std::vector<std::string> txid() const = 0;
+extern ADDAPI const char* WOWNERO_PendingTransaction_txid(void* pendingTx_ptr, const char* separator);
+// virtual uint64_t txCount() const = 0;
+extern ADDAPI uint64_t WOWNERO_PendingTransaction_txCount(void* pendingTx_ptr);
+// virtual std::vector<uint32_t> subaddrAccount() const = 0;
+extern ADDAPI const char* WOWNERO_PendingTransaction_subaddrAccount(void* pendingTx_ptr, const char* separator);
+// virtual std::vector<std::set<uint32_t>> subaddrIndices() const = 0;
+extern ADDAPI const char* WOWNERO_PendingTransaction_subaddrIndices(void* pendingTx_ptr, const char* separator);
+// virtual std::string multisigSignData() = 0;
+extern ADDAPI const char* WOWNERO_PendingTransaction_multisigSignData(void* pendingTx_ptr);
+// virtual void signMultisigTx() = 0;
+extern ADDAPI void WOWNERO_PendingTransaction_signMultisigTx(void* pendingTx_ptr);
+// virtual std::vector<std::string> signersKeys() const = 0;
+extern ADDAPI const char* WOWNERO_PendingTransaction_signersKeys(void* pendingTx_ptr, const char* separator);
+// };
+
+// struct UnsignedTransaction
+// {
+// enum Status {
+// Status_Ok,
+const int UnsignedTransactionStatus_Ok = 0;
+// Status_Error,
+const int UnsignedTransactionStatus_Error = 1;
+// Status_Critical
+const int UnsignedTransactionStatus_Critical = 2;
+// };
+// virtual ~UnsignedTransaction() = 0;
+// virtual int status() const = 0;
+extern ADDAPI int WOWNERO_UnsignedTransaction_status(void* unsignedTx_ptr);
+// virtual std::string errorString() const = 0;
+extern ADDAPI const char* WOWNERO_UnsignedTransaction_errorString(void* unsignedTx_ptr);
+// virtual std::vector<uint64_t> amount() const = 0;
+extern ADDAPI const char* WOWNERO_UnsignedTransaction_amount(void* unsignedTx_ptr, const char* separator);
+// virtual std::vector<uint64_t> fee() const = 0;
+extern ADDAPI const char* WOWNERO_UnsignedTransaction_fee(void* unsignedTx_ptr, const char* separator);
+// virtual std::vector<uint64_t> mixin() const = 0;
+extern ADDAPI const char* WOWNERO_UnsignedTransaction_mixin(void* unsignedTx_ptr, const char* separator);
+// virtual std::string confirmationMessage() const = 0;
+extern ADDAPI const char* WOWNERO_UnsignedTransaction_confirmationMessage(void* unsignedTx_ptr);
+// virtual std::vector<std::string> paymentId() const = 0;
+extern ADDAPI const char* WOWNERO_UnsignedTransaction_paymentId(void* unsignedTx_ptr, const char* separator);
+// virtual std::vector<std::string> recipientAddress() const = 0;
+extern ADDAPI const char* WOWNERO_UnsignedTransaction_recipientAddress(void* unsignedTx_ptr, const char* separator);
+// virtual uint64_t minMixinCount() const = 0;
+extern ADDAPI uint64_t WOWNERO_UnsignedTransaction_minMixinCount(void* unsignedTx_ptr);
+// virtual uint64_t txCount() const = 0;
+extern ADDAPI uint64_t WOWNERO_UnsignedTransaction_txCount(void* unsignedTx_ptr);
+// virtual bool sign(const std::string &signedFileName) = 0;
+extern ADDAPI bool WOWNERO_UnsignedTransaction_sign(void* unsignedTx_ptr, const char* signedFileName);
+// };
+// struct TransactionInfo
+// {
+// enum Direction {
+// Direction_In,
+const int TransactionInfoDirection_In = 0;
+// Direction_Out
+const int TransactionInfoDirection_Out = 1;
+// };
+// struct Transfer {
+// Transfer(uint64_t _amount, const std::string &address);
+// const uint64_t amount;
+// const std::string address;
+// };
+// virtual ~TransactionInfo() = 0;
+// virtual int direction() const = 0;
+extern ADDAPI int WOWNERO_TransactionInfo_direction(void* txInfo_ptr);
+// virtual bool isPending() const = 0;
+extern ADDAPI bool WOWNERO_TransactionInfo_isPending(void* txInfo_ptr);
+// virtual bool isFailed() const = 0;
+extern ADDAPI bool WOWNERO_TransactionInfo_isFailed(void* txInfo_ptr);
+// virtual bool isCoinbase() const = 0;
+extern ADDAPI bool WOWNERO_TransactionInfo_isCoinbase(void* txInfo_ptr);
+// virtual uint64_t amount() const = 0;
+extern ADDAPI uint64_t WOWNERO_TransactionInfo_amount(void* txInfo_ptr);
+// virtual uint64_t fee() const = 0;
+extern ADDAPI uint64_t WOWNERO_TransactionInfo_fee(void* txInfo_ptr);
+// virtual uint64_t blockHeight() const = 0;
+extern ADDAPI uint64_t WOWNERO_TransactionInfo_blockHeight(void* txInfo_ptr);
+// virtual std::string description() const = 0;
+extern ADDAPI const char* WOWNERO_TransactionInfo_description(void* txInfo_ptr);
+// virtual std::set<uint32_t> subaddrIndex() const = 0;
+extern ADDAPI const char* WOWNERO_TransactionInfo_subaddrIndex(void* txInfo_ptr, const char* separator);
+// virtual uint32_t subaddrAccount() const = 0;
+extern ADDAPI uint32_t WOWNERO_TransactionInfo_subaddrAccount(void* txInfo_ptr);
+// virtual std::string label() const = 0;
+extern ADDAPI const char* WOWNERO_TransactionInfo_label(void* txInfo_ptr);
+// virtual uint64_t confirmations() const = 0;
+extern ADDAPI uint64_t WOWNERO_TransactionInfo_confirmations(void* txInfo_ptr);
+// virtual uint64_t unlockTime() const = 0;
+extern ADDAPI uint64_t WOWNERO_TransactionInfo_unlockTime(void* txInfo_ptr);
+// virtual std::string hash() const = 0;
+extern ADDAPI const char* WOWNERO_TransactionInfo_hash(void* txInfo_ptr);
+// virtual std::time_t timestamp() const = 0;
+extern ADDAPI uint64_t WOWNERO_TransactionInfo_timestamp(void* txInfo_ptr);
+// virtual std::string paymentId() const = 0;
+extern ADDAPI const char* WOWNERO_TransactionInfo_paymentId(void* txInfo_ptr);
+// virtual const std::vector<Transfer> & transfers() const = 0;
+extern ADDAPI int WOWNERO_TransactionInfo_transfers_count(void* txInfo_ptr);
+extern ADDAPI uint64_t WOWNERO_TransactionInfo_transfers_amount(void* txInfo_ptr, int index);
+extern ADDAPI const char* WOWNERO_TransactionInfo_transfers_address(void* txInfo_ptr, int address);
+// };
+// struct TransactionHistory
+// {
+// virtual ~TransactionHistory() = 0;
+// virtual int count() const = 0;
+extern ADDAPI int WOWNERO_TransactionHistory_count(void* txHistory_ptr);
+// virtual TransactionInfo * transaction(int index) const = 0;
+extern ADDAPI void* WOWNERO_TransactionHistory_transaction(void* txHistory_ptr, int index);
+// virtual TransactionInfo * transaction(const std::string &id) const = 0;
+extern ADDAPI void* WOWNERO_TransactionHistory_transactionById(void* txHistory_ptr, const char* id);
+// virtual std::vector<TransactionInfo*> getAll() const = 0;
+// virtual void refresh() = 0;
+extern ADDAPI void WOWNERO_TransactionHistory_refresh(void* txHistory_ptr);
+// virtual void setTxNote(const std::string &txid, const std::string &note) = 0;
+extern ADDAPI void WOWNERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, const char* note);
+// };
+// struct AddressBookRow {
+// public:
+// AddressBookRow(std::size_t _rowId, const std::string &_address, const std::string &_paymentId, const std::string &_description):
+// m_rowId(_rowId),
+// m_address(_address),
+// m_paymentId(_paymentId),
+// m_description(_description) {}
+
+// private:
+// std::size_t m_rowId;
+// std::string m_address;
+// std::string m_paymentId;
+// std::string m_description;
+// public:
+// std::string extra;
+extern ADDAPI const char* WOWNERO_AddressBookRow_extra(void* addressBookRow_ptr);
+// std::string getAddress() const {return m_address;}
+extern ADDAPI const char* WOWNERO_AddressBookRow_getAddress(void* addressBookRow_ptr);
+// std::string getDescription() const {return m_description;}
+extern ADDAPI const char* WOWNERO_AddressBookRow_getDescription(void* addressBookRow_ptr);
+// std::string getPaymentId() const {return m_paymentId;}
+extern ADDAPI const char* WOWNERO_AddressBookRow_getPaymentId(void* addressBookRow_ptr);
+// std::size_t getRowId() const {return m_rowId;}
+extern ADDAPI size_t WOWNERO_AddressBookRow_getRowId(void* addressBookRow_ptr);
+// };
+// struct AddressBook
+// {
+// enum ErrorCode {
+// Status_Ok,
+const int AddressBookErrorCodeStatus_Ok = 0;
+// General_Error,
+const int AddressBookErrorCodeGeneral_Error = 1;
+// Invalid_Address,
+const int AddressBookErrorCodeInvalid_Address = 2;
+// Invalid_Payment_Id
+const int AddressBookErrorCodeInvalidPaymentId = 3;
+// };
+// virtual ~AddressBook() = 0;
+// virtual std::vector<AddressBookRow*> getAll() const = 0;
+extern ADDAPI int WOWNERO_AddressBook_getAll_size(void* addressBook_ptr);
+extern ADDAPI void* WOWNERO_AddressBook_getAll_byIndex(void* addressBook_ptr, int index);
+// virtual bool addRow(const std::string &dst_addr , const std::string &payment_id, const std::string &description) = 0;
+extern ADDAPI bool WOWNERO_AddressBook_addRow(void* addressBook_ptr, const char* dst_addr , const char* payment_id, const char* description);
+// virtual bool deleteRow(std::size_t rowId) = 0;
+extern ADDAPI bool WOWNERO_AddressBook_deleteRow(void* addressBook_ptr, size_t rowId);
+// virtual bool setDescription(std::size_t index, const std::string &description) = 0;
+extern ADDAPI bool WOWNERO_AddressBook_setDescription(void* addressBook_ptr, size_t rowId, const char* description);
+// virtual void refresh() = 0;
+extern ADDAPI void WOWNERO_AddressBook_refresh(void* addressBook_ptr);
+// virtual std::string errorString() const = 0;
+extern ADDAPI const char* WOWNERO_AddressBook_errorString(void* addressBook_ptr);
+// virtual int errorCode() const = 0;
+extern ADDAPI int WOWNERO_AddressBook_errorCode(void* addressBook_ptr);
+// virtual int lookupPaymentID(const std::string &payment_id) const = 0;
+extern ADDAPI int WOWNERO_AddressBook_lookupPaymentID(void* addressBook_ptr, const char* payment_id);
+// };
+// struct CoinsInfo
+// {
+// virtual ~CoinsInfo() = 0;
+// virtual uint64_t blockHeight() const = 0;
+extern ADDAPI uint64_t WOWNERO_CoinsInfo_blockHeight(void* coinsInfo_ptr);
+// virtual std::string hash() const = 0;
+extern ADDAPI const char* WOWNERO_CoinsInfo_hash(void* coinsInfo_ptr);
+// virtual size_t internalOutputIndex() const = 0;
+extern ADDAPI size_t WOWNERO_CoinsInfo_internalOutputIndex(void* coinsInfo_ptr);
+// virtual uint64_t globalOutputIndex() const = 0;
+extern ADDAPI uint64_t WOWNERO_CoinsInfo_globalOutputIndex(void* coinsInfo_ptr);
+// virtual bool spent() const = 0;
+extern ADDAPI bool WOWNERO_CoinsInfo_spent(void* coinsInfo_ptr);
+// virtual bool frozen() const = 0;
+extern ADDAPI bool WOWNERO_CoinsInfo_frozen(void* coinsInfo_ptr);
+// virtual uint64_t spentHeight() const = 0;
+extern ADDAPI uint64_t WOWNERO_CoinsInfo_spentHeight(void* coinsInfo_ptr);
+// virtual uint64_t amount() const = 0;
+extern ADDAPI uint64_t WOWNERO_CoinsInfo_amount(void* coinsInfo_ptr);
+// virtual bool rct() const = 0;
+extern ADDAPI bool WOWNERO_CoinsInfo_rct(void* coinsInfo_ptr);
+// virtual bool keyImageKnown() const = 0;
+extern ADDAPI bool WOWNERO_CoinsInfo_keyImageKnown(void* coinsInfo_ptr);
+// virtual size_t pkIndex() const = 0;
+extern ADDAPI size_t WOWNERO_CoinsInfo_pkIndex(void* coinsInfo_ptr);
+// virtual uint32_t subaddrIndex() const = 0;
+extern ADDAPI uint32_t WOWNERO_CoinsInfo_subaddrIndex(void* coinsInfo_ptr);
+// virtual uint32_t subaddrAccount() const = 0;
+extern ADDAPI uint32_t WOWNERO_CoinsInfo_subaddrAccount(void* coinsInfo_ptr);
+// virtual std::string address() const = 0;
+extern ADDAPI const char* WOWNERO_CoinsInfo_address(void* coinsInfo_ptr);
+// virtual std::string addressLabel() const = 0;
+extern ADDAPI const char* WOWNERO_CoinsInfo_addressLabel(void* coinsInfo_ptr);
+// virtual std::string keyImage() const = 0;
+extern ADDAPI const char* WOWNERO_CoinsInfo_keyImage(void* coinsInfo_ptr);
+// virtual uint64_t unlockTime() const = 0;
+extern ADDAPI uint64_t WOWNERO_CoinsInfo_unlockTime(void* coinsInfo_ptr);
+// virtual bool unlocked() const = 0;
+extern ADDAPI bool WOWNERO_CoinsInfo_unlocked(void* coinsInfo_ptr);
+// virtual std::string pubKey() const = 0;
+extern ADDAPI const char* WOWNERO_CoinsInfo_pubKey(void* coinsInfo_ptr);
+// virtual bool coinbase() const = 0;
+extern ADDAPI bool WOWNERO_CoinsInfo_coinbase(void* coinsInfo_ptr);
+// virtual std::string description() const = 0;
+extern ADDAPI const char* WOWNERO_CoinsInfo_description(void* coinsInfo_ptr);
+// };
+// struct Coins
+// {
+// virtual ~Coins() = 0;
+// virtual int count() const = 0;
+extern ADDAPI int WOWNERO_Coins_count(void* coins_ptr);
+// virtual CoinsInfo * coin(int index) const = 0;
+extern ADDAPI void* WOWNERO_Coins_coin(void* coins_ptr, int index);
+// virtual std::vector<CoinsInfo*> getAll() const = 0;
+extern ADDAPI int WOWNERO_Coins_getAll_size(void* coins_ptr);
+extern ADDAPI void* WOWNERO_Coins_getAll_byIndex(void* coins_ptr, int index);
+// virtual void refresh() = 0;
+extern ADDAPI void WOWNERO_Coins_refresh(void* coins_ptr);
+// virtual void setFrozen(std::string public_key) = 0;
+extern ADDAPI void WOWNERO_Coins_setFrozenByPublicKey(void* coins_ptr, const char* public_key);
+// virtual void setFrozen(int index) = 0;
+extern ADDAPI void WOWNERO_Coins_setFrozen(void* coins_ptr, int index);
+// virtual void thaw(int index) = 0;
+extern ADDAPI void WOWNERO_Coins_thaw(void* coins_ptr, int index);
+// virtual void thaw(std::string public_key) = 0;
+extern ADDAPI void WOWNERO_Coins_thawByPublicKey(void* coins_ptr, const char* public_key);
+// virtual bool isTransferUnlocked(uint64_t unlockTime, uint64_t blockHeight) = 0;
+extern ADDAPI bool WOWNERO_Coins_isTransferUnlocked(void* coins_ptr, uint64_t unlockTime, uint64_t blockHeight);
+// virtual void setDescription(const std::string &public_key, const std::string &description) = 0;
+extern ADDAPI void WOWNERO_Coins_setDescription(void* coins_ptr, const char* public_key, const char* description);
+// };
+// struct SubaddressRow {
+// public:
+// SubaddressRow(std::size_t _rowId, const std::string &_address, const std::string &_label):
+// m_rowId(_rowId),
+// m_address(_address),
+// m_label(_label) {}
+
+// private:
+// std::size_t m_rowId;
+// std::string m_address;
+// std::string m_label;
+// public:
+// std::string extra;
+extern ADDAPI const char* WOWNERO_SubaddressRow_extra(void* subaddressRow_ptr);
+// std::string getAddress() const {return m_address;}
+extern ADDAPI const char* WOWNERO_SubaddressRow_getAddress(void* subaddressRow_ptr);
+// std::string getLabel() const {return m_label;}
+extern ADDAPI const char* WOWNERO_SubaddressRow_getLabel(void* subaddressRow_ptr);
+// std::size_t getRowId() const {return m_rowId;}
+extern ADDAPI size_t WOWNERO_SubaddressRow_getRowId(void* subaddressRow_ptr);
+// };
+
+// struct Subaddress
+// {
+// virtual ~Subaddress() = 0;
+// virtual std::vector<SubaddressRow*> getAll() const = 0;
+extern ADDAPI int WOWNERO_Subaddress_getAll_size(void* subaddress_ptr);
+extern ADDAPI void* WOWNERO_Subaddress_getAll_byIndex(void* subaddress_ptr, int index);
+// virtual void addRow(uint32_t accountIndex, const std::string &label) = 0;
+extern ADDAPI void WOWNERO_Subaddress_addRow(void* subaddress_ptr, uint32_t accountIndex, const char* label);
+// virtual void setLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0;
+extern ADDAPI void WOWNERO_Subaddress_setLabel(void* subaddress_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label);
+// virtual void refresh(uint32_t accountIndex) = 0;
+extern ADDAPI void WOWNERO_Subaddress_refresh(void* subaddress_ptr, uint32_t accountIndex);
+// };
+
+// struct SubaddressAccountRow {
+// public:
+// SubaddressAccountRow(std::size_t _rowId, const std::string &_address, const std::string &_label, const std::string &_balance, const std::string &_unlockedBalance):
+// m_rowId(_rowId),
+// m_address(_address),
+// m_label(_label),
+// m_balance(_balance),
+// m_unlockedBalance(_unlockedBalance) {}
+
+// private:
+// std::size_t m_rowId;
+// std::string m_address;
+// std::string m_label;
+// std::string m_balance;
+// std::string m_unlockedBalance;
+// public:
+// std::string extra;
+extern ADDAPI const char* WOWNERO_SubaddressAccountRow_extra(void* subaddressAccountRow_ptr);
+// std::string getAddress() const {return m_address;}
+extern ADDAPI const char* WOWNERO_SubaddressAccountRow_getAddress(void* subaddressAccountRow_ptr);
+// std::string getLabel() const {return m_label;}
+extern ADDAPI const char* WOWNERO_SubaddressAccountRow_getLabel(void* subaddressAccountRow_ptr);
+// std::string getBalance() const {return m_balance;}
+extern ADDAPI const char* WOWNERO_SubaddressAccountRow_getBalance(void* subaddressAccountRow_ptr);
+// std::string getUnlockedBalance() const {return m_unlockedBalance;}
+extern ADDAPI const char* WOWNERO_SubaddressAccountRow_getUnlockedBalance(void* subaddressAccountRow_ptr);
+// std::size_t getRowId() const {return m_rowId;}
+extern ADDAPI size_t WOWNERO_SubaddressAccountRow_getRowId(void* subaddressAccountRow_ptr);
+// };
+
+// struct SubaddressAccount
+// {
+// virtual ~SubaddressAccount() = 0;
+// virtual std::vector<SubaddressAccountRow*> getAll() const = 0;
+extern ADDAPI int WOWNERO_SubaddressAccount_getAll_size(void* subaddressAccount_ptr);
+extern ADDAPI void* WOWNERO_SubaddressAccount_getAll_byIndex(void* subaddressAccount_ptr, int index);
+// virtual void addRow(const std::string &label) = 0;
+extern ADDAPI void WOWNERO_SubaddressAccount_addRow(void* subaddressAccount_ptr, const char* label);
+// virtual void setLabel(uint32_t accountIndex, const std::string &label) = 0;
+extern ADDAPI void WOWNERO_SubaddressAccount_setLabel(void* subaddressAccount_ptr, uint32_t accountIndex, const char* label);
+// virtual void refresh() = 0;
+extern ADDAPI void WOWNERO_SubaddressAccount_refresh(void* subaddressAccount_ptr);
+// };
+
+// struct MultisigState {
+// MultisigState() : isMultisig(false), isReady(false), threshold(0), total(0) {}
+
+// bool isMultisig;
+extern ADDAPI bool WOWNERO_MultisigState_isMultisig(void* multisigState_ptr);
+// bool isReady;
+extern ADDAPI bool WOWNERO_MultisigState_isReady(void* multisigState_ptr);
+// uint32_t threshold;
+extern ADDAPI uint32_t WOWNERO_MultisigState_threshold(void* multisigState_ptr);
+// uint32_t total;
+extern ADDAPI uint32_t WOWNERO_MultisigState_total(void* multisigState_ptr);
+// };
+
+
+// struct DeviceProgress {
+// DeviceProgress(): m_progress(0), m_indeterminate(false) {}
+// DeviceProgress(double progress, bool indeterminate=false): m_progress(progress), m_indeterminate(indeterminate) {}
+
+// virtual double progress() const { return m_progress; }
+extern ADDAPI bool WOWNERO_DeviceProgress_progress(void* deviceProgress_ptr);
+// virtual bool indeterminate() const { return m_indeterminate; }
+extern ADDAPI bool WOWNERO_DeviceProgress_indeterminate(void* deviceProgress_ptr);
+
+// protected:
+// double m_progress;
+// bool m_indeterminate;
+// };
+
+// struct Wallet;
+// struct WalletListener
+// {
+// virtual ~WalletListener() = 0;
+// virtual void moneySpent(const std::string &txId, uint64_t amount) = 0;
+// virtual void moneyReceived(const std::string &txId, uint64_t amount) = 0;
+// virtual void unconfirmedMoneyReceived(const std::string &txId, uint64_t amount) = 0;
+// virtual void newBlock(uint64_t height) = 0;
+// virtual void updated() = 0;
+// virtual void refreshed() = 0;
+// virtual void onDeviceButtonRequest(uint64_t code) { (void)code; }
+// virtual void onDeviceButtonPressed() { }
+// virtual optional<std::string> onDevicePinRequest() {
+// throw std::runtime_error("Not supported");
+// }
+// virtual optional<std::string> onDevicePassphraseRequest(bool & on_device) {
+// on_device = true;
+// return optional<std::string>();
+// }
+// virtual void onDeviceProgress(const DeviceProgress & event) { (void)event; };
+// virtual void onSetWallet(Wallet * wallet) { (void)wallet; };
+// };
+// struct Wallet
+// {
+// enum Device {
+// Device_Software = 0,
+const int WalletDevice_Software = 0;
+// Device_Ledger = 1,
+const int WalletDevice_Ledger = 1;
+// Device_Trezor = 2
+const int WalletDevice_Trezor = 2;
+// };
+// enum Status {
+// Status_Ok,
+const int WalletStatus_Ok = 0;
+// Status_Error,
+const int WalletStatus_Error = 1;
+// Status_Critical
+const int WalletStatus_Critical = 2;
+// };
+// enum ConnectionStatus {
+// ConnectionStatus_Disconnected,
+const int WalletConnectionStatus_Disconnected = 0;
+// ConnectionStatus_Connected,
+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;
+extern ADDAPI const char* WOWNERO_Wallet_seed(void* wallet_ptr, const char* seed_offset);
+// virtual std::string getSeedLanguage() const = 0;
+extern ADDAPI const char* WOWNERO_Wallet_getSeedLanguage(void* wallet_ptr);
+// virtual void setSeedLanguage(const std::string &arg) = 0;
+extern ADDAPI void WOWNERO_Wallet_setSeedLanguage(void* wallet_ptr, const char* arg);
+// virtual int status() const = 0;
+extern ADDAPI int WOWNERO_Wallet_status(void* wallet_ptr);
+// virtual std::string errorString() const = 0;
+extern ADDAPI const char* WOWNERO_Wallet_errorString(void* wallet_ptr);
+// virtual void statusWithErrorString(int& status, std::string& errorString) const = 0;
+// virtual bool setPassword(const std::string &password) = 0;
+extern ADDAPI bool WOWNERO_Wallet_setPassword(void* wallet_ptr, const char* password);
+// virtual const std::string& getPassword() const = 0;
+extern ADDAPI const char* WOWNERO_Wallet_getPassword(void* wallet_ptr);
+// virtual bool setDevicePin(const std::string &pin) { (void)pin; return false; };
+extern ADDAPI bool WOWNERO_Wallet_setDevicePin(void* wallet_ptr, const char* pin);
+// virtual bool setDevicePassphrase(const std::string &passphrase) { (void)passphrase; return false; };
+extern ADDAPI bool WOWNERO_Wallet_setDevicePassphrase(void* wallet_ptr, const char* passphrase);
+// virtual std::string address(uint32_t accountIndex = 0, uint32_t addressIndex = 0) const = 0;
+extern ADDAPI const char* WOWNERO_Wallet_address(void* wallet_ptr, uint64_t accountIndex, uint64_t addressIndex);
+// std::string mainAddress() const { return address(0, 0); }
+// virtual std::string path() const = 0;
+extern ADDAPI const char* WOWNERO_Wallet_path(void* wallet_ptr);
+// virtual NetworkType nettype() const = 0;
+extern ADDAPI int WOWNERO_Wallet_nettype(void* wallet_ptr);
+// bool mainnet() const { return nettype() == MAINNET; }
+// bool testnet() const { return nettype() == TESTNET; }
+// bool stagenet() const { return nettype() == STAGENET; }
+// virtual void hardForkInfo(uint8_t &version, uint64_t &earliest_height) const = 0;
+// virtual bool useForkRules(uint8_t version, int64_t early_blocks) const = 0;
+extern ADDAPI uint8_t WOWNERO_Wallet_useForkRules(void* wallet_ptr, uint8_t version, int64_t early_blocks);
+// virtual std::string integratedAddress(const std::string &payment_id) const = 0;
+extern ADDAPI const char* WOWNERO_Wallet_integratedAddress(void* wallet_ptr, const char* payment_id);
+// virtual std::string secretViewKey() const = 0;
+extern ADDAPI const char* WOWNERO_Wallet_secretViewKey(void* wallet_ptr);
+// virtual std::string publicViewKey() const = 0;
+extern ADDAPI const char* WOWNERO_Wallet_publicViewKey(void* wallet_ptr);
+// virtual std::string secretSpendKey() const = 0;
+extern ADDAPI const char* WOWNERO_Wallet_secretSpendKey(void* wallet_ptr);
+// virtual std::string publicSpendKey() const = 0;
+extern ADDAPI const char* WOWNERO_Wallet_publicSpendKey(void* wallet_ptr);
+// virtual std::string publicMultisigSignerKey() const = 0;
+extern ADDAPI const char* WOWNERO_Wallet_publicMultisigSignerKey(void* wallet_ptr);
+// virtual void stop() = 0;
+extern ADDAPI void WOWNERO_Wallet_stop(void* wallet_ptr);
+// virtual bool store(const std::string &path) = 0;
+extern ADDAPI bool WOWNERO_Wallet_store(void* wallet_ptr, const char* path);
+// virtual std::string filename() const = 0;
+extern ADDAPI const char* WOWNERO_Wallet_filename(void* wallet_ptr);
+// virtual std::string keysFilename() const = 0;
+extern ADDAPI const char* WOWNERO_Wallet_keysFilename(void* wallet_ptr);
+// 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;
+extern ADDAPI bool WOWNERO_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);
+// virtual bool createWatchOnly(const std::string &path, const std::string &password, const std::string &language) const = 0;
+extern ADDAPI bool WOWNERO_Wallet_createWatchOnly(void* wallet_ptr, const char* path, const char* password, const char* language);
+// virtual void setRefreshFromBlockHeight(uint64_t refresh_from_block_height) = 0;
+extern ADDAPI void WOWNERO_Wallet_setRefreshFromBlockHeight(void* wallet_ptr, uint64_t refresh_from_block_height);
+// virtual uint64_t getRefreshFromBlockHeight() const = 0;
+extern ADDAPI uint64_t WOWNERO_Wallet_getRefreshFromBlockHeight(void* wallet_ptr);
+// virtual void setRecoveringFromSeed(bool recoveringFromSeed) = 0;
+extern ADDAPI void WOWNERO_Wallet_setRecoveringFromSeed(void* wallet_ptr, bool recoveringFromSeed);
+// virtual void setRecoveringFromDevice(bool recoveringFromDevice) = 0;
+extern ADDAPI void WOWNERO_Wallet_setRecoveringFromDevice(void* wallet_ptr, bool recoveringFromDevice);
+// virtual void setSubaddressLookahead(uint32_t major, uint32_t minor) = 0;
+extern ADDAPI void WOWNERO_Wallet_setSubaddressLookahead(void* wallet_ptr, uint32_t major, uint32_t minor);
+// virtual bool connectToDaemon() = 0;
+extern ADDAPI bool WOWNERO_Wallet_connectToDaemon(void* wallet_ptr);
+// virtual ConnectionStatus connected() const = 0;
+extern ADDAPI int WOWNERO_Wallet_connected(void* wallet_ptr);
+// virtual void setTrustedDaemon(bool arg) = 0;
+extern ADDAPI void WOWNERO_Wallet_setTrustedDaemon(void* wallet_ptr, bool arg);
+// virtual bool trustedDaemon() const = 0;
+extern ADDAPI bool WOWNERO_Wallet_trustedDaemon(void* wallet_ptr);
+// virtual bool setProxy(const std::string &address) = 0;
+extern ADDAPI bool WOWNERO_Wallet_setProxy(void* wallet_ptr, const char* address);
+// virtual uint64_t balance(uint32_t accountIndex = 0) const = 0;
+extern ADDAPI uint64_t WOWNERO_Wallet_balance(void* wallet_ptr, uint32_t accountIndex);
+// uint64_t balanceAll() const {
+// uint64_t result = 0;
+// for (uint32_t i = 0; i < numSubaddressAccounts(); ++i)
+// result += balance(i);
+// return result;
+// }
+// virtual uint64_t unlockedBalance(uint32_t accountIndex = 0) const = 0;
+extern ADDAPI uint64_t WOWNERO_Wallet_unlockedBalance(void* wallet_ptr, uint32_t accountIndex);
+// uint64_t unlockedBalanceAll() const {
+// uint64_t result = 0;
+// for (uint32_t i = 0; i < numSubaddressAccounts(); ++i)
+// result += unlockedBalance(i);
+// return result;
+// }
+// virtual bool watchOnly() const = 0;
+// virtual uint64_t viewOnlyBalance(uint32_t accountIndex, const std::vector<std::string> &key_images = {}) const = 0;
+extern ADDAPI uint64_t WOWNERO_Wallet_viewOnlyBalance(void* wallet_ptr, uint32_t accountIndex);
+extern ADDAPI bool WOWNERO_Wallet_watchOnly(void* wallet_ptr);
+// virtual bool isDeterministic() const = 0;
+extern ADDAPI bool WOWNERO_Wallet_isDeterministic(void* wallet_ptr);
+// virtual uint64_t blockChainHeight() const = 0;
+extern ADDAPI uint64_t WOWNERO_Wallet_blockChainHeight(void* wallet_ptr);
+// virtual uint64_t approximateBlockChainHeight() const = 0;
+extern ADDAPI uint64_t WOWNERO_Wallet_approximateBlockChainHeight(void* wallet_ptr);
+// virtual uint64_t estimateBlockChainHeight() const = 0;
+extern ADDAPI uint64_t WOWNERO_Wallet_estimateBlockChainHeight(void* wallet_ptr);
+// virtual uint64_t daemonBlockChainHeight() const = 0;
+extern ADDAPI uint64_t WOWNERO_Wallet_daemonBlockChainHeight(void* wallet_ptr);
+extern ADDAPI uint64_t WOWNERO_Wallet_daemonBlockChainHeight_cached(void* wallet_ptr);
+extern ADDAPI void WOWNERO_Wallet_daemonBlockChainHeight_runThread(void* wallet_ptr, int seconds);
+// virtual uint64_t daemonBlockChainTargetHeight() const = 0;
+extern ADDAPI uint64_t WOWNERO_Wallet_daemonBlockChainTargetHeight(void* wallet_ptr);
+// virtual bool synchronized() const = 0;
+extern ADDAPI bool WOWNERO_Wallet_synchronized(void* wallet_ptr);
+// static std::string displayAmount(uint64_t amount);
+extern ADDAPI const char* WOWNERO_Wallet_displayAmount(uint64_t amount);
+// static uint64_t amountFromString(const std::string &amount);
+extern ADDAPI uint64_t WOWNERO_Wallet_amountFromString(const char* amount);
+// static uint64_t amountFromDouble(double amount);
+extern ADDAPI uint64_t WOWNERO_Wallet_amountFromDouble(double amount);
+// static std::string genPaymentId();
+extern ADDAPI const char* WOWNERO_Wallet_genPaymentId();
+// static bool paymentIdValid(const std::string &paiment_id);
+extern ADDAPI bool WOWNERO_Wallet_paymentIdValid(const char* paiment_id);
+// static bool addressValid(const std::string &str, NetworkType nettype);
+extern ADDAPI bool WOWNERO_Wallet_addressValid(const char* str, int nettype);
+// static bool addressValid(const std::string &str, bool testnet) // deprecated
+// {
+// return addressValid(str, testnet ? TESTNET : MAINNET);
+// }
+extern ADDAPI bool WOWNERO_Wallet_keyValid(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype);
+extern ADDAPI const char* WOWNERO_Wallet_keyValid_error(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype);
+// static bool keyValid(const std::string &secret_key_string, const std::string &address_string, bool isViewKey, NetworkType nettype, std::string &error);
+// static bool keyValid(const std::string &secret_key_string, const std::string &address_string, bool isViewKey, bool testnet, std::string &error) // deprecated
+// {
+// return keyValid(secret_key_string, address_string, isViewKey, testnet ? TESTNET : MAINNET, error);
+// }
+// static std::string paymentIdFromAddress(const std::string &str, NetworkType nettype);
+extern ADDAPI const char* WOWNERO_Wallet_paymentIdFromAddress(const char* strarg, int nettype);
+// static std::string paymentIdFromAddress(const std::string &str, bool testnet) // deprecated
+// {
+// return paymentIdFromAddress(str, testnet ? TESTNET : MAINNET);
+// }
+// static uint64_t maximumAllowedAmount();
+extern ADDAPI uint64_t WOWNERO_Wallet_maximumAllowedAmount();
+// static void init(const char *argv0, const char *default_log_base_name) { init(argv0, default_log_base_name, "", true); }
+// static void init(const char *argv0, const char *default_log_base_name, const std::string &log_path, bool console);
+extern ADDAPI void WOWNERO_Wallet_init3(void* wallet_ptr, const char* argv0, const char* default_log_base_name, const char* log_path, bool console);
+// static void debug(const std::string &category, const std::string &str);
+// static void info(const std::string &category, const std::string &str);
+// 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;
+extern ADDAPI const char* WOWNERO_Wallet_getPolyseed(void* wallet_ptr, const char* passphrase);
+// static bool createPolyseed(std::string &seed_words, std::string &err, const std::string &language = "English");
+extern ADDAPI const char* WOWNERO_Wallet_createPolyseed();
+extern ADDAPI void WOWNERO_Wallet_startRefresh(void* wallet_ptr);
+// virtual void pauseRefresh() = 0;
+extern ADDAPI void WOWNERO_Wallet_pauseRefresh(void* wallet_ptr);
+// virtual bool refresh() = 0;
+extern ADDAPI bool WOWNERO_Wallet_refresh(void* wallet_ptr);
+// virtual void refreshAsync() = 0;
+extern ADDAPI void WOWNERO_Wallet_refreshAsync(void* wallet_ptr);
+// virtual bool rescanBlockchain() = 0;
+extern ADDAPI bool WOWNERO_Wallet_rescanBlockchain(void* wallet_ptr);
+// virtual void rescanBlockchainAsync() = 0;
+extern ADDAPI void WOWNERO_Wallet_rescanBlockchainAsync(void* wallet_ptr);
+// virtual void setAutoRefreshInterval(int millis) = 0;
+extern ADDAPI void WOWNERO_Wallet_setAutoRefreshInterval(void* wallet_ptr, int millis);
+// virtual int autoRefreshInterval() const = 0;
+extern ADDAPI int WOWNERO_Wallet_autoRefreshInterval(void* wallet_ptr);
+// virtual void addSubaddressAccount(const std::string& label) = 0;
+extern ADDAPI void WOWNERO_Wallet_addSubaddressAccount(void* wallet_ptr, const char* label);
+// virtual size_t numSubaddressAccounts() const = 0;
+extern ADDAPI size_t WOWNERO_Wallet_numSubaddressAccounts(void* wallet_ptr);
+// virtual size_t numSubaddresses(uint32_t accountIndex) const = 0;
+extern ADDAPI size_t WOWNERO_Wallet_numSubaddresses(void* wallet_ptr, uint32_t accountIndex);
+// virtual void addSubaddress(uint32_t accountIndex, const std::string& label) = 0;
+extern ADDAPI void WOWNERO_Wallet_addSubaddress(void* wallet_ptr, uint32_t accountIndex, const char* label);
+// virtual std::string getSubaddressLabel(uint32_t accountIndex, uint32_t addressIndex) const = 0;
+extern ADDAPI const char* WOWNERO_Wallet_getSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex);
+// virtual void setSubaddressLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0;
+extern ADDAPI void WOWNERO_Wallet_setSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label);
+// virtual MultisigState multisig() const = 0;
+// virtual std::string getMultisigInfo() const = 0;
+extern ADDAPI const char* WOWNERO_Wallet_getMultisigInfo(void* wallet_ptr);
+// virtual std::string makeMultisig(const std::vector<std::string>& info, uint32_t threshold) = 0;
+// virtual std::string exchangeMultisigKeys(const std::vector<std::string> &info, const bool force_update_use_with_caution) = 0;
+// virtual bool exportMultisigImages(std::string& images) = 0;
+// virtual size_t importMultisigImages(const std::vector<std::string>& images) = 0;
+// virtual bool hasMultisigPartialKeyImages() const = 0;
+// virtual PendingTransaction* restoreMultisigTransaction(const std::string& signData) = 0;
+// virtual PendingTransaction * createTransactionMultDest(const std::vector<std::string> &dst_addr, const std::string &payment_id,
+// 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;
+// virtual PendingTransaction * createTransaction(const std::string &dst_addr, const std::string &payment_id,
+// optional<uint64_t> amount, uint32_t mixin_count,
+// PendingTransaction::Priority = PendingTransaction::Priority_Low,
+// uint32_t subaddr_account = 0,
+// std::set<uint32_t> subaddr_indices = {},
+// const std::set<std::string> &preferred_inputs = {) = 0;
+extern ADDAPI void* WOWNERO_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,
+ const char* preferredInputs, const char* separator);
+// virtual PendingTransaction * createSweepUnmixableTransaction() = 0;
+// virtual UnsignedTransaction * loadUnsignedTx(const std::string &unsigned_filename) = 0;
+extern ADDAPI void* WOWNERO_Wallet_loadUnsignedTx(void* wallet_ptr, const char* unsigned_filename);
+// virtual bool submitTransaction(const std::string &fileName) = 0;
+extern ADDAPI bool WOWNERO_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;
+extern ADDAPI bool WOWNERO_Wallet_hasUnknownKeyImages(void* wallet_ptr);
+// virtual bool exportKeyImages(const std::string &filename, bool all = false) = 0;
+extern ADDAPI bool WOWNERO_Wallet_exportKeyImages(void* wallet_ptr, const char* filename, bool all);
+// virtual bool importKeyImages(const std::string &filename) = 0;
+extern ADDAPI bool WOWNERO_Wallet_importKeyImages(void* wallet_ptr, const char* filename);
+// virtual bool exportOutputs(const std::string &filename, bool all = false) = 0;
+extern ADDAPI bool WOWNERO_Wallet_exportOutputs(void* wallet_ptr, const char* filename, bool all);
+// virtual bool importOutputs(const std::string &filename) = 0;
+extern ADDAPI bool WOWNERO_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;
+extern ADDAPI bool WOWNERO_Wallet_setupBackgroundSync(void* wallet_ptr, int background_sync_type, const char* wallet_password, const char* background_cache_password);
+// virtual BackgroundSyncType getBackgroundSyncType() const = 0;
+extern ADDAPI int WOWNERO_Wallet_getBackgroundSyncType(void* wallet_ptr);
+// virtual bool startBackgroundSync() = 0;
+extern ADDAPI bool WOWNERO_Wallet_startBackgroundSync(void* wallet_ptr);
+// virtual bool stopBackgroundSync(const std::string &wallet_password) = 0;
+extern ADDAPI bool WOWNERO_Wallet_stopBackgroundSync(void* wallet_ptr, const char* wallet_password);
+// virtual bool isBackgroundSyncing() const = 0;
+extern ADDAPI bool WOWNERO_Wallet_isBackgroundSyncing(void* wallet_ptr);
+// virtual bool isBackgroundWallet() const = 0;
+extern ADDAPI bool WOWNERO_Wallet_isBackgroundWallet(void* wallet_ptr);
+// virtual TransactionHistory * history() = 0;
+extern ADDAPI void* WOWNERO_Wallet_history(void* wallet_ptr);
+// virtual AddressBook * addressBook() = 0;
+extern ADDAPI void* WOWNERO_Wallet_addressBook(void* wallet_ptr);
+// virtual Coins * coins() = 0;
+extern ADDAPI void* WOWNERO_Wallet_coins(void* wallet_ptr);
+// virtual Subaddress * subaddress() = 0;
+extern ADDAPI void* WOWNERO_Wallet_subaddress(void* wallet_ptr);
+// virtual SubaddressAccount * subaddressAccount() = 0;
+extern ADDAPI void* WOWNERO_Wallet_subaddressAccount(void* wallet_ptr);
+// virtual void setListener(WalletListener *) = 0;
+// virtual uint32_t defaultMixin() const = 0;
+extern ADDAPI uint32_t WOWNERO_Wallet_defaultMixin(void* wallet_ptr);
+// virtual void setDefaultMixin(uint32_t arg) = 0;
+extern ADDAPI void WOWNERO_Wallet_setDefaultMixin(void* wallet_ptr, uint32_t arg);
+// virtual bool setCacheAttribute(const std::string &key, const std::string &val) = 0;
+extern ADDAPI bool WOWNERO_Wallet_setCacheAttribute(void* wallet_ptr, const char* key, const char* val);
+// virtual std::string getCacheAttribute(const std::string &key) const = 0;
+extern ADDAPI const char* WOWNERO_Wallet_getCacheAttribute(void* wallet_ptr, const char* key);
+// virtual bool setUserNote(const std::string &txid, const std::string &note) = 0;
+extern ADDAPI bool WOWNERO_Wallet_setUserNote(void* wallet_ptr, const char* txid, const char* note);
+// virtual std::string getUserNote(const std::string &txid) const = 0;
+extern ADDAPI const char* WOWNERO_Wallet_getUserNote(void* wallet_ptr, const char* txid);
+// virtual std::string getTxKey(const std::string &txid) const = 0;
+extern ADDAPI const char* WOWNERO_Wallet_getTxKey(void* wallet_ptr, const char* txid);
+// virtual bool checkTxKey(const std::string &txid, std::string tx_key, const std::string &address, uint64_t &received, bool &in_pool, uint64_t &confirmations) = 0;
+// virtual std::string getTxProof(const std::string &txid, const std::string &address, const std::string &message) const = 0;
+// virtual bool checkTxProof(const std::string &txid, const std::string &address, const std::string &message, const std::string &signature, bool &good, uint64_t &received, bool &in_pool, uint64_t &confirmations) = 0;
+// virtual std::string getSpendProof(const std::string &txid, const std::string &message) const = 0;
+// virtual bool checkSpendProof(const std::string &txid, const std::string &message, const std::string &signature, bool &good) const = 0;
+// virtual std::string getReserveProof(bool all, uint32_t account_index, uint64_t amount, const std::string &message) const = 0;
+// virtual bool checkReserveProof(const std::string &address, const std::string &message, const std::string &signature, bool &good, uint64_t &total, uint64_t &spent) const = 0;
+// virtual std::string signMessage(const std::string &message, const std::string &address = "") = 0;
+extern ADDAPI const char* WOWNERO_Wallet_signMessage(void* wallet_ptr, const char* message, const char* address);
+// virtual bool verifySignedMessage(const std::string &message, const std::string &addres, const std::string &signature) const = 0;
+extern ADDAPI bool WOWNERO_Wallet_verifySignedMessage(void* wallet_ptr, const char* message, const char* address, const char* signature);
+// virtual std::string signMultisigParticipant(const std::string &message) const = 0;
+// virtual bool verifyMessageWithPublicKey(const std::string &message, const std::string &publicKey, const std::string &signature) const = 0;
+// virtual bool parse_uri(const std::string &uri, std::string &address, std::string &payment_id, uint64_t &amount, std::string &tx_description, std::string &recipient_name, std::vector<std::string> &unknown_parameters, std::string &error) = 0;
+// virtual std::string make_uri(const std::string &address, const std::string &payment_id, uint64_t amount, const std::string &tx_description, const std::string &recipient_name, std::string &error) const = 0;
+// virtual std::string getDefaultDataDir() const = 0;
+// virtual bool rescanSpent() = 0;
+extern ADDAPI bool WOWNERO_Wallet_rescanSpent(void* wallet_ptr);
+// virtual void setOffline(bool offline) = 0;
+extern ADDAPI void WOWNERO_Wallet_setOffline(void* wallet_ptr, bool offline);
+// virtual bool isOffline() const = 0;
+extern ADDAPI bool WOWNERO_Wallet_isOffline(void* wallet_ptr);
+// virtual bool blackballOutputs(const std::vector<std::string> &outputs, bool add) = 0;
+// virtual bool blackballOutput(const std::string &amount, const std::string &offset) = 0;
+// virtual bool unblackballOutput(const std::string &amount, const std::string &offset) = 0;
+// virtual bool getRing(const std::string &key_image, std::vector<uint64_t> &ring) const = 0;
+// virtual bool getRings(const std::string &txid, std::vector<std::pair<std::string, std::vector<uint64_t>>> &rings) const = 0;
+// virtual bool setRing(const std::string &key_image, const std::vector<uint64_t> &ring, bool relative) = 0;
+// virtual void segregatePreForkOutputs(bool segregate) = 0;
+extern ADDAPI void WOWNERO_Wallet_segregatePreForkOutputs(void* wallet_ptr, bool segregate);
+// virtual void segregationHeight(uint64_t height) = 0;
+extern ADDAPI void WOWNERO_Wallet_segregationHeight(void* wallet_ptr, uint64_t height);
+// virtual void keyReuseMitigation2(bool mitigation) = 0;
+extern ADDAPI void WOWNERO_Wallet_keyReuseMitigation2(void* wallet_ptr, bool 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;
+extern ADDAPI bool WOWNERO_Wallet_lockKeysFile(void* wallet_ptr);
+// virtual bool unlockKeysFile() = 0;
+extern ADDAPI bool WOWNERO_Wallet_unlockKeysFile(void* wallet_ptr);
+// virtual bool isKeysFileLocked() = 0;
+extern ADDAPI bool WOWNERO_Wallet_isKeysFileLocked(void* wallet_ptr);
+// virtual Device getDeviceType() const = 0;
+extern ADDAPI int WOWNERO_Wallet_getDeviceType(void* wallet_ptr);
+// virtual uint64_t coldKeyImageSync(uint64_t &spent, uint64_t &unspent) = 0;
+extern ADDAPI uint64_t WOWNERO_Wallet_coldKeyImageSync(void* wallet_ptr, uint64_t spent, uint64_t unspent);
+// virtual void deviceShowAddress(uint32_t accountIndex, uint32_t addressIndex, const std::string &paymentId) = 0;
+extern ADDAPI const char* WOWNERO_Wallet_deviceShowAddress(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex);
+// virtual bool reconnectDevice() = 0;
+extern ADDAPI const char* WOWNERO_Wallet_reconnectDevice(void* wallet_ptr);
+// virtual uint64_t getBytesReceived() = 0;
+extern ADDAPI uint64_t WOWNERO_Wallet_getBytesReceived(void* wallet_ptr);
+// virtual uint64_t getBytesSent() = 0;
+extern ADDAPI uint64_t WOWNERO_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;
+extern ADDAPI void* WOWNERO_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;
+extern ADDAPI void* WOWNERO_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);
+// }
+// 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;
+extern ADDAPI void* WOWNERO_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
+// {
+// return recoveryWallet(path, password, mnemonic, testnet ? TESTNET : MAINNET, restoreHeight);
+// }
+// virtual Wallet * recoveryWallet(const std::string &path, const std::string &mnemonic, NetworkType nettype, uint64_t restoreHeight = 0) = 0;
+// Wallet * recoveryWallet(const std::string &path, const std::string &mnemonic, bool testnet = false, uint64_t restoreHeight = 0) // deprecated
+// {
+// return recoveryWallet(path, mnemonic, testnet ? TESTNET : MAINNET, restoreHeight);
+// }
+// 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;
+extern ADDAPI void* WOWNERO_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,
+// bool testnet,
+// uint64_t restoreHeight,
+// const std::string &addressString,
+// const std::string &viewKeyString,
+// const std::string &spendKeyString = "") // deprecated
+// {
+// return createWalletFromKeys(path, password, language, testnet ? TESTNET : MAINNET, restoreHeight, addressString, viewKeyString, spendKeyString);
+// }
+// virtual Wallet * createWalletFromKeys(const std::string &path,
+// const std::string &language,
+// NetworkType nettype,
+// uint64_t restoreHeight,
+// const std::string &addressString,
+// const std::string &viewKeyString,
+// const std::string &spendKeyString = "") = 0;
+// Wallet * createWalletFromKeys(const std::string &path,
+// const std::string &language,
+// bool testnet,
+// uint64_t restoreHeight,
+// const std::string &addressString,
+// const std::string &viewKeyString,
+// const std::string &spendKeyString = "") // deprecated
+// {
+// return createWalletFromKeys(path, language, testnet ? TESTNET : MAINNET, restoreHeight, addressString, viewKeyString, spendKeyString);
+// }
+// virtual Wallet * createWalletFromDevice(const std::string &path,
+// const std::string &password,
+// NetworkType nettype,
+// const std::string &deviceName,
+// uint64_t restoreHeight = 0,
+// 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;
+extern ADDAPI void* WOWNERO_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;
+extern ADDAPI bool WOWNERO_WalletManager_closeWallet(void* wm_ptr, void* wallet_ptr, bool store);
+// virtual bool walletExists(const std::string &path) = 0;
+extern ADDAPI bool WOWNERO_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;
+extern ADDAPI bool WOWNERO_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;
+extern ADDAPI bool WOWNERO_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;
+extern ADDAPI const char* WOWNERO_WalletManager_findWallets(void* wm_ptr, const char* path, const char* separator);
+// virtual std::string errorString() const = 0;
+extern ADDAPI const char* WOWNERO_WalletManager_errorString(void* wm_ptr);
+// virtual void setDaemonAddress(const std::string &address) = 0;
+extern ADDAPI void WOWNERO_WalletManager_setDaemonAddress(void* wm_ptr, const char* address);
+// virtual bool connected(uint32_t *version = NULL) = 0;
+// virtual uint64_t blockchainHeight() = 0;
+extern ADDAPI uint64_t WOWNERO_WalletManager_blockchainHeight(void* wm_ptr);
+// virtual uint64_t blockchainTargetHeight() = 0;
+extern ADDAPI uint64_t WOWNERO_WalletManager_blockchainTargetHeight(void* wm_ptr);
+// virtual uint64_t networkDifficulty() = 0;
+extern ADDAPI uint64_t WOWNERO_WalletManager_networkDifficulty(void* wm_ptr);
+// virtual double miningHashRate() = 0;
+extern ADDAPI double WOWNERO_WalletManager_miningHashRate(void* wm_ptr);
+// virtual uint64_t blockTarget() = 0;
+extern ADDAPI uint64_t WOWNERO_WalletManager_blockTarget(void* wm_ptr);
+// virtual bool isMining() = 0;
+extern ADDAPI bool WOWNERO_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;
+extern ADDAPI bool WOWNERO_WalletManager_startMining(void* wm_ptr, const char* address, uint32_t threads, bool backgroundMining, bool ignoreBattery);
+// virtual bool stopMining() = 0;
+extern ADDAPI bool WOWNERO_WalletManager_stopMining(void* wm_ptr, const char* address);
+// virtual std::string resolveOpenAlias(const std::string &address, bool &dnssec_valid) const = 0;
+extern ADDAPI const char* WOWNERO_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;
+extern ADDAPI bool WOWNERO_WalletManager_setProxy(void* wm_ptr, const char* address);
+// };
+
+int LogLevel_Silent = -1;
+int LogLevel_0 = 0;
+int LogLevel_1 = 1;
+int LogLevel_2 = 2;
+int LogLevel_3 = 3;
+int LogLevel_4 = 4;
+int LogLevel_Min = -1;
+int LogLevel_Max = 4;
+
+// struct WalletManagerFactory
+// {
+// enum LogLevel {
+// LogLevel_Silent = -1,
+// LogLevel_0 = 0,
+// LogLevel_1 = 1,
+// LogLevel_2 = 2,
+// LogLevel_3 = 3,
+// LogLevel_4 = 4,
+// LogLevel_Min = LogLevel_Silent,
+// LogLevel_Max = LogLevel_4
+// };
+// static WalletManager * getWalletManager();
+extern ADDAPI void* WOWNERO_WalletManagerFactory_getWalletManager();
+// static void setLogLevel(int level);
+extern ADDAPI void WOWNERO_WalletManagerFactory_setLogLevel(int level);
+// static void setLogCategories(const std::string &categories);
+extern ADDAPI void WOWNERO_WalletManagerFactory_setLogCategories(const char* categories);
+// };
+// }
+
+extern ADDAPI void WOWNERO_DEBUG_test0();
+extern ADDAPI bool WOWNERO_DEBUG_test1(bool x);
+extern ADDAPI int WOWNERO_DEBUG_test2(int x);
+extern ADDAPI uint64_t WOWNERO_DEBUG_test3(uint64_t x);
+extern ADDAPI void* WOWNERO_DEBUG_test4(uint64_t x);
+extern ADDAPI const char* WOWNERO_DEBUG_test5();
+extern ADDAPI const char* WOWNERO_DEBUG_test5_std();
+extern ADDAPI bool WOWNERO_DEBUG_isPointerNull(void* wallet_ptr);
+
+#ifdef __cplusplus
+}
+#endif \ No newline at end of file
generated by cgit v1.2.3 (git 2.39.1) at 2026-05-09 22:26:18 +0000