From b72d2dff623665f42985ef9b6419636ca35a51d1 Mon Sep 17 00:00:00 2001 From: Czarek Nakamoto Date: Sun, 31 Mar 2024 09:19:47 +0200 Subject: [PATCH] feat: split MONERO and WOWNERO prefixed functions So basically: when we open the .so file, we define some symbols, and it appears that if we load something else, with the same symbols, under the same thread we cause some funky behaviour - like calling function a wownero function MONERO_Wallet_address() resulting in a monero address being generated. Needless to say, this is undesired, and a blocker for https://github.com/cypherstack/stack_wallet/pull/818 I'm afraid that this may not solve all of our issues (but will solve some significant roadblocks), because of the "genesis block" issue, as output of nm -gDC release/wownero/x86_64-linux-gnu_libwallet2_api_c.so | grep genesis indicate that these functions may share *something* in common across both WOW and XMR libraries. In a case in which this fix won't be sufficient, I think that the way forward would be to close the dynamic libraries, but before we do that I want to check if maybe there is a change to run multiple wallets at once. --- .gitignore | 16 +- build_single.sh | 10 +- libbridge/.dockerignore | 1 - libbridge/.gitignore | 1 - .../CMakeLists.txt | 0 .../src/main/cpp/helpers.cpp | 0 .../src/main/cpp/helpers.hpp | 0 .../src/main/cpp/wallet2_api_c.cpp | 7 - .../src/main/cpp/wallet2_api_c.h | 0 wownero_libwallet2_api_c/CMakeLists.txt | 1 + .../src/main/cpp/helpers.cpp | 1 + .../src/main/cpp/helpers.hpp | 1 + .../src/main/cpp/wallet2_api_c.cpp | 1651 +++++++++++++++++ .../src/main/cpp/wallet2_api_c.h | 981 ++++++++++ 14 files changed, 2642 insertions(+), 28 deletions(-) delete mode 100644 libbridge/.dockerignore delete mode 100644 libbridge/.gitignore rename {libbridge => monero_libwallet2_api_c}/CMakeLists.txt (100%) rename {libbridge => monero_libwallet2_api_c}/src/main/cpp/helpers.cpp (100%) rename {libbridge => monero_libwallet2_api_c}/src/main/cpp/helpers.hpp (100%) rename {libbridge => monero_libwallet2_api_c}/src/main/cpp/wallet2_api_c.cpp (99%) rename {libbridge => monero_libwallet2_api_c}/src/main/cpp/wallet2_api_c.h (100%) create mode 120000 wownero_libwallet2_api_c/CMakeLists.txt create mode 120000 wownero_libwallet2_api_c/src/main/cpp/helpers.cpp create mode 120000 wownero_libwallet2_api_c/src/main/cpp/helpers.hpp create mode 100644 wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp create mode 100644 wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.h diff --git a/.gitignore b/.gitignore index a32c772f..4d94944d 100644 --- a/.gitignore +++ b/.gitignore @@ -1,14 +1,2 @@ -boost_* -libexpat -libiconv-* -libsodium* -libzmq* -openssl-* -polyseed* -unbound* -utf8proc* -zlib* - -perl-* - -prefix \ No newline at end of file +release/ +build/ \ No newline at end of file diff --git a/build_single.sh b/build_single.sh index 85f1633b..c1aa7470 100755 --- a/build_single.sh +++ b/build_single.sh @@ -3,13 +3,13 @@ set -e repo=$1 if [[ "x$repo" == "x" ]]; then - echo "Usage: $0 monero/wownero" + echo "Usage: $0 monero/wownero $(gcc -dumpmachine) -j$(nproc)" exit 1 fi if [[ "x$repo" != "xwownero" && "x$repo" != "xmonero" ]]; then - echo "Usage: $0 monero/wownero" + echo "Usage: $0 monero/wownero $(gcc -dumpmachine) -j$(nproc)" echo "Invalid target given, only monero and wownero are supported targets" fi @@ -165,7 +165,7 @@ then ${HOST_ABI}-ranlib $PWD/$repo/contrib/depends/${HOST_ABI}/lib/libpolyseed.a fi -pushd libbridge +pushd ${repo}_libwallet2_api_c rm -rf build/${HOST_ABI} || true mkdir -p build/${HOST_ABI} -p cd build/${HOST_ABI} @@ -189,8 +189,8 @@ pushd release/$repo else APPENDIX="${APPENDIX}so" fi - xz -e ../../libbridge/build/${HOST_ABI}/libwallet2_api_c.${APPENDIX} - mv ../../libbridge/build/${HOST_ABI}/libwallet2_api_c.${APPENDIX}.xz ${HOST_ABI}_libwallet2_api_c.${APPENDIX}.xz + xz -e ../../${repo}_libwallet2_api_c/build/${HOST_ABI}/libwallet2_api_c.${APPENDIX} + mv ../../${repo}_libwallet2_api_c/build/${HOST_ABI}/libwallet2_api_c.${APPENDIX}.xz ${HOST_ABI}_libwallet2_api_c.${APPENDIX}.xz # Extra libraries if [[ "$HOST_ABI" == "x86_64-w64-mingw32" || "$HOST_ABI" == "i686-w64-mingw32" ]]; then diff --git a/libbridge/.dockerignore b/libbridge/.dockerignore deleted file mode 100644 index c795b054..00000000 --- a/libbridge/.dockerignore +++ /dev/null @@ -1 +0,0 @@ -build \ No newline at end of file diff --git a/libbridge/.gitignore b/libbridge/.gitignore deleted file mode 100644 index c795b054..00000000 --- a/libbridge/.gitignore +++ /dev/null @@ -1 +0,0 @@ -build \ No newline at end of file diff --git a/libbridge/CMakeLists.txt b/monero_libwallet2_api_c/CMakeLists.txt similarity index 100% rename from libbridge/CMakeLists.txt rename to monero_libwallet2_api_c/CMakeLists.txt diff --git a/libbridge/src/main/cpp/helpers.cpp b/monero_libwallet2_api_c/src/main/cpp/helpers.cpp similarity index 100% rename from libbridge/src/main/cpp/helpers.cpp rename to monero_libwallet2_api_c/src/main/cpp/helpers.cpp diff --git a/libbridge/src/main/cpp/helpers.hpp b/monero_libwallet2_api_c/src/main/cpp/helpers.hpp similarity index 100% rename from libbridge/src/main/cpp/helpers.hpp rename to monero_libwallet2_api_c/src/main/cpp/helpers.hpp diff --git a/libbridge/src/main/cpp/wallet2_api_c.cpp b/monero_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp similarity index 99% rename from libbridge/src/main/cpp/wallet2_api_c.cpp rename to monero_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp index 9208765a..c24e3dbf 100644 --- a/libbridge/src/main/cpp/wallet2_api_c.cpp +++ b/monero_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp @@ -4,14 +4,7 @@ #include "helpers.hpp" #include #include - -#ifdef FLAVOR_MONERO #include "../../../../monero/src/wallet/api/wallet2_api.h" -#endif - -#ifdef FLAVOR_WOWNERO -#include "../../../../wownero/src/wallet/api/wallet2_api.h" -#endif #ifdef __cplusplus diff --git a/libbridge/src/main/cpp/wallet2_api_c.h b/monero_libwallet2_api_c/src/main/cpp/wallet2_api_c.h similarity index 100% rename from libbridge/src/main/cpp/wallet2_api_c.h rename to monero_libwallet2_api_c/src/main/cpp/wallet2_api_c.h diff --git a/wownero_libwallet2_api_c/CMakeLists.txt b/wownero_libwallet2_api_c/CMakeLists.txt new file mode 120000 index 00000000..73b40ff6 --- /dev/null +++ b/wownero_libwallet2_api_c/CMakeLists.txt @@ -0,0 +1 @@ +../monero_libwallet2_api_c/CMakeLists.txt \ No newline at end of file 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 00000000..524768bf --- /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 00000000..99d2733a --- /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 00000000..65769aa1 --- /dev/null +++ b/wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp @@ -0,0 +1,1651 @@ +#include +#include "wallet2_api_c.h" +#include +#include "helpers.hpp" +#include +#include +#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(pendingTx_ptr); + return pendingTx->status(); +} +const char* WOWNERO_PendingTransaction_errorString(void* pendingTx_ptr) { + Monero::PendingTransaction *pendingTx = reinterpret_cast(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(pendingTx_ptr); + return pendingTx->commit(std::string(filename), overwrite); +} +uint64_t WOWNERO_PendingTransaction_amount(void* pendingTx_ptr) { + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + return pendingTx->amount(); +} +uint64_t WOWNERO_PendingTransaction_dust(void* pendingTx_ptr) { + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + return pendingTx->dust(); +} +uint64_t WOWNERO_PendingTransaction_fee(void* pendingTx_ptr) { + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + return pendingTx->fee(); +} +const char* WOWNERO_PendingTransaction_txid(void* pendingTx_ptr, const char* separator) { + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + std::vector txid = pendingTx->txid(); + return vectorToString(txid, std::string(separator)); +} +uint64_t WOWNERO_PendingTransaction_txCount(void* pendingTx_ptr) { + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + return pendingTx->txCount(); +} +const char* WOWNERO_PendingTransaction_subaddrAccount(void* pendingTx_ptr, const char* separator) { + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + std::vector 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(pendingTx_ptr); + std::vector> subaddrIndices = pendingTx->subaddrIndices(); + return vectorToString(subaddrIndices, std::string(separator)); +} +const char* WOWNERO_PendingTransaction_multisigSignData(void* pendingTx_ptr) { + Monero::PendingTransaction *pendingTx = reinterpret_cast(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(pendingTx_ptr); + return pendingTx->signMultisigTx(); +} +const char* WOWNERO_PendingTransaction_signersKeys(void* pendingTx_ptr, const char* separator) { + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + std::vector txid = pendingTx->signersKeys(); + return vectorToString(txid, std::string(separator)); +} + +// UnsignedTransaction + +int WOWNERO_UnsignedTransaction_status(void* unsignedTx_ptr) { + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return unsignedTx->status(); +} +const char* WOWNERO_UnsignedTransaction_errorString(void* unsignedTx_ptr) { + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(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(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(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(unsignedTx_ptr); + return vectorToString(unsignedTx->mixin(), std::string(separator)); +} +const char* WOWNERO_UnsignedTransaction_confirmationMessage(void* unsignedTx_ptr) { + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(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(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(unsignedTx_ptr); + return vectorToString(unsignedTx->recipientAddress(), std::string(separator)); +} +uint64_t WOWNERO_UnsignedTransaction_minMixinCount(void* unsignedTx_ptr) { + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return unsignedTx->minMixinCount(); +} +uint64_t WOWNERO_UnsignedTransaction_txCount(void* unsignedTx_ptr) { + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return unsignedTx->txCount(); +} +bool WOWNERO_UnsignedTransaction_sign(void* unsignedTx_ptr, const char* signedFileName) { + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return unsignedTx->sign(std::string(signedFileName)); +} + +// TransactionInfo +int WOWNERO_TransactionInfo_direction(void* txInfo_ptr) { + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->direction(); +} +bool WOWNERO_TransactionInfo_isPending(void* txInfo_ptr) { + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->isPending(); +} +bool WOWNERO_TransactionInfo_isFailed(void* txInfo_ptr) { + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->isFailed(); +} +bool WOWNERO_TransactionInfo_isCoinbase(void* txInfo_ptr) { + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->isCoinbase(); +} +uint64_t WOWNERO_TransactionInfo_amount(void* txInfo_ptr) { + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->amount(); +} +uint64_t WOWNERO_TransactionInfo_fee(void* txInfo_ptr) { + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->fee(); +} +uint64_t WOWNERO_TransactionInfo_blockHeight(void* txInfo_ptr) { + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->blockHeight(); +} +const char* WOWNERO_TransactionInfo_description(void* txInfo_ptr) { + Monero::TransactionInfo *txInfo = reinterpret_cast(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(txInfo_ptr); + std::set subaddrIndex = txInfo->subaddrIndex(); + return vectorToString(subaddrIndex, std::string(separator)); +} +uint32_t WOWNERO_TransactionInfo_subaddrAccount(void* txInfo_ptr) { + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->subaddrAccount(); +} +const char* WOWNERO_TransactionInfo_label(void* txInfo_ptr) { + Monero::TransactionInfo *txInfo = reinterpret_cast(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(txInfo_ptr); + return txInfo->confirmations(); +} +uint64_t WOWNERO_TransactionInfo_unlockTime(void* txInfo_ptr) { + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->unlockTime(); +} +const char* WOWNERO_TransactionInfo_hash(void* txInfo_ptr) { + Monero::TransactionInfo *txInfo = reinterpret_cast(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(txInfo_ptr); + return txInfo->timestamp(); +} +const char* WOWNERO_TransactionInfo_paymentId(void* txInfo_ptr) { + Monero::TransactionInfo *txInfo = reinterpret_cast(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(txInfo_ptr); + return txInfo->transfers().size(); +} + +uint64_t WOWNERO_TransactionInfo_transfers_amount(void* txInfo_ptr, int index) { + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->transfers()[index].amount; +} + +const char* WOWNERO_TransactionInfo_transfers_address(void* txInfo_ptr, int index) { + Monero::TransactionInfo *txInfo = reinterpret_cast(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(txHistory_ptr); + return txHistory->count(); +} +void* WOWNERO_TransactionHistory_transaction(void* txHistory_ptr, int index) { + Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); + return reinterpret_cast(txHistory->transaction(index)); +} +void* WOWNERO_TransactionHistory_transactionById(void* txHistory_ptr, const char* id) { + Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); + return reinterpret_cast(txHistory->transaction(std::string(id))); +} + +void WOWNERO_TransactionHistory_refresh(void* txHistory_ptr) { + Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); + return txHistory->refresh(); +} +void WOWNERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, const char* note) { + Monero::TransactionHistory *txHistory = reinterpret_cast(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(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(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(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(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(addressBookRow_ptr); + return addressBookRow->getRowId(); +} + +// AddressBook +// virtual std::vector getAll() const = 0; +int WOWNERO_AddressBook_getAll_size(void* addressBook_ptr) { + Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); + return addressBook->getAll().size(); +} +void* WOWNERO_AddressBook_getAll_byIndex(void* addressBook_ptr, int index) { + Monero::AddressBook *addressBook = reinterpret_cast(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(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(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(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(addressBook_ptr); + return addressBook->refresh(); +} +// virtual std::string errorString() const = 0; +const char* WOWNERO_AddressBook_errorString(void* addressBook_ptr) { + Monero::AddressBook *addressBook = reinterpret_cast(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(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(addressBook_ptr); + return addressBook->lookupPaymentID(std::string(payment_id)); +} + +// CoinsInfo +uint64_t WOWNERO_CoinsInfo_blockHeight(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->blockHeight(); +} +// virtual std::string hash() const = 0; +const char* WOWNERO_CoinsInfo_hash(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast(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(coinsInfo_ptr); + return coinsInfo->internalOutputIndex(); +} +// virtual uint64_t globalOutputIndex() const = 0; +uint64_t WOWNERO_CoinsInfo_globalOutputIndex(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->globalOutputIndex(); +} +// virtual bool spent() const = 0; +bool WOWNERO_CoinsInfo_spent(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->spent(); +} +// virtual bool frozen() const = 0; +bool WOWNERO_CoinsInfo_frozen(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->frozen(); +} +// virtual uint64_t spentHeight() const = 0; +uint64_t WOWNERO_CoinsInfo_spentHeight(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->spentHeight(); +} +// virtual uint64_t amount() const = 0; +uint64_t WOWNERO_CoinsInfo_amount(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->amount(); +} +// virtual bool rct() const = 0; +bool WOWNERO_CoinsInfo_rct(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->rct(); +} +// virtual bool keyImageKnown() const = 0; +bool WOWNERO_CoinsInfo_keyImageKnown(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->keyImageKnown(); +} +// virtual size_t pkIndex() const = 0; +size_t WOWNERO_CoinsInfo_pkIndex(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->pkIndex(); +} +// virtual uint32_t subaddrIndex() const = 0; +uint32_t WOWNERO_CoinsInfo_subaddrIndex(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->subaddrIndex(); +} +// virtual uint32_t subaddrAccount() const = 0; +uint32_t WOWNERO_CoinsInfo_subaddrAccount(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->subaddrAccount(); +} +// virtual std::string address() const = 0; +const char* WOWNERO_CoinsInfo_address(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast(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(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(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(coinsInfo_ptr); + return coinsInfo->unlockTime(); +} +// virtual bool unlocked() const = 0; +bool WOWNERO_CoinsInfo_unlocked(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->internalOutputIndex(); +} +// virtual std::string pubKey() const = 0; +const char* WOWNERO_CoinsInfo_pubKey(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast(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(coinsInfo_ptr); + return coinsInfo->internalOutputIndex(); +} +// virtual std::string description() const = 0; +const char* WOWNERO_CoinsInfo_description(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast(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(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(coins_ptr); + return coins->coin(index); +} + +int WOWNERO_Coins_getAll_size(void* coins_ptr) { + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->getAll().size(); +} +void* WOWNERO_Coins_getAll_byIndex(void* coins_ptr, int index) { + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->getAll()[index]; +} + +// virtual std::vector getAll() const = 0; +// virtual void refresh() = 0; +void WOWNERO_Coins_refresh(void* coins_ptr) { + Monero::Coins *coins = reinterpret_cast(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(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(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(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(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(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(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(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(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(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(subaddressRow_ptr); + return subaddressRow->getRowId(); +} + +// Subaddress + +int WOWNERO_Subaddress_getAll_size(void* subaddress_ptr) { + Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); + return subaddress->getAll().size(); +} +void* WOWNERO_Subaddress_getAll_byIndex(void* subaddress_ptr, int index) { + Monero::Subaddress *subaddress = reinterpret_cast(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(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(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(subaddress_ptr); + return subaddress->refresh(accountIndex); +} + +// SubaddressAccountRow + +// std::string extra; +const char* WOWNERO_SubaddressAccountRow_extra(void* subaddressAccountRow_ptr) { + Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(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(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(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(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(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(subaddressAccountRow_ptr); + return subaddressAccountRow->getRowId(); +} + +// struct SubaddressAccount +// { +// virtual ~SubaddressAccount() = 0; +// virtual std::vector getAll() const = 0; +int WOWNERO_SubaddressAccount_getAll_size(void* subaddressAccount_ptr) { + Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); + return subaddress->getAll().size(); +} +void* WOWNERO_SubaddressAccount_getAll_byIndex(void* subaddressAccount_ptr, int index) { + Monero::SubaddressAccount *subaddress = reinterpret_cast(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(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(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(subaddressAccount_ptr); + return subaddress->refresh(); +} + +// MultisigState + +// bool isMultisig; +bool WOWNERO_MultisigState_isMultisig(void* multisigState_ptr) { + Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); + return multisigState->isMultisig; +} +// bool isReady; +bool WOWNERO_MultisigState_isReady(void* multisigState_ptr) { + Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); + return multisigState->isReady; +} +// uint32_t threshold; +uint32_t WOWNERO_MultisigState_threshold(void* multisigState_ptr) { + Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); + return multisigState->threshold; +} +// uint32_t total; +uint32_t WOWNERO_MultisigState_total(void* multisigState_ptr) { + Monero::MultisigState *multisigState = reinterpret_cast(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(deviceProgress_ptr); + return deviceProgress->progress(); +} +// virtual bool indeterminate() const { return m_indeterminate; } +bool WOWNERO_DeviceProgress_indeterminate(void* deviceProgress_ptr) { + Monero::DeviceProgress *deviceProgress = reinterpret_cast(deviceProgress_ptr); + return deviceProgress->indeterminate(); +} + +// Wallet + +const char* WOWNERO_Wallet_seed(void* wallet_ptr, const char* seed_offset) { + Monero::Wallet *wallet = reinterpret_cast(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(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(wallet_ptr); + return wallet->setSeedLanguage(std::string(arg)); +} + +int WOWNERO_Wallet_status(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->status(); +} + +const char* WOWNERO_Wallet_errorString(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(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(wallet_ptr); + return wallet->setPassword(std::string(password)); +} + +const char* WOWNERO_Wallet_getPassword(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(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(wallet_ptr); + return wallet->setDevicePin(std::string(pin)); +} + +bool WOWNERO_Wallet_setDevicePassphrase(void* wallet_ptr, const char* passphrase) { + Monero::Wallet *wallet = reinterpret_cast(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(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(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(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(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(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(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(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(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(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(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(wallet_ptr); + wallet->stop(); +} + +bool WOWNERO_Wallet_store(void* wallet_ptr, const char* path) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->store(std::string(path)); +} +const char* WOWNERO_Wallet_filename(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(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(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(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(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(wallet_ptr); + return wallet->setRefreshFromBlockHeight(refresh_from_block_height); +} + +uint64_t WOWNERO_Wallet_getRefreshFromBlockHeight(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->getRefreshFromBlockHeight(); +} + +void WOWNERO_Wallet_setRecoveringFromSeed(void* wallet_ptr, bool recoveringFromSeed) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setRecoveringFromSeed(recoveringFromSeed); +} +void WOWNERO_Wallet_setRecoveringFromDevice(void* wallet_ptr, bool recoveringFromDevice) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setRecoveringFromDevice(recoveringFromDevice); +} +void WOWNERO_Wallet_setSubaddressLookahead(void* wallet_ptr, uint32_t major, uint32_t minor) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setSubaddressLookahead(major, minor); +} + +bool WOWNERO_Wallet_connectToDaemon(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->connectToDaemon(); +} +int WOWNERO_Wallet_connected(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->connected(); +} +void WOWNERO_Wallet_setTrustedDaemon(void* wallet_ptr, bool arg) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setTrustedDaemon(arg); +} +bool WOWNERO_Wallet_trustedDaemon(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->trustedDaemon(); +} +bool WOWNERO_Wallet_setProxy(void* wallet_ptr, const char* address) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setProxy(std::string(address)); +} + +uint64_t WOWNERO_Wallet_balance(void* wallet_ptr, uint32_t accountIndex) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->balance(accountIndex); +} + +uint64_t WOWNERO_Wallet_unlockedBalance(void* wallet_ptr, uint32_t accountIndex) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->unlockedBalance(accountIndex); +} + +uint64_t WOWNERO_Wallet_viewOnlyBalance(void* wallet_ptr, uint32_t accountIndex) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->viewOnlyBalance(accountIndex); +} + +// TODO +bool WOWNERO_Wallet_watchOnly(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->watchOnly(); +} +bool WOWNERO_Wallet_isDeterministic(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->isDeterministic(); +} +uint64_t WOWNERO_Wallet_blockChainHeight(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->blockChainHeight(); +} +uint64_t WOWNERO_Wallet_approximateBlockChainHeight(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->approximateBlockChainHeight(); +} +uint64_t WOWNERO_Wallet_estimateBlockChainHeight(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->estimateBlockChainHeight(); +} +uint64_t WOWNERO_Wallet_daemonBlockChainHeight(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(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(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(wallet_ptr); + return wallet->daemonBlockChainTargetHeight(); +} +bool WOWNERO_Wallet_synchronized(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(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(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(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(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(wallet_ptr); + return wallet->startRefresh(); +} +void WOWNERO_Wallet_pauseRefresh(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->pauseRefresh(); +} +bool WOWNERO_Wallet_refresh(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->refresh(); +} +void WOWNERO_Wallet_refreshAsync(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->refreshAsync(); +} +bool WOWNERO_Wallet_rescanBlockchain(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->rescanBlockchain(); +} +void WOWNERO_Wallet_rescanBlockchainAsync(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->rescanBlockchainAsync(); +} +void WOWNERO_Wallet_setAutoRefreshInterval(void* wallet_ptr, int millis) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setAutoRefreshInterval(millis); +} +int WOWNERO_Wallet_autoRefreshInterval(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->autoRefreshInterval(); +} +void WOWNERO_Wallet_addSubaddressAccount(void* wallet_ptr, const char* label) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->addSubaddressAccount(std::string(label)); +} +size_t WOWNERO_Wallet_numSubaddressAccounts(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->numSubaddressAccounts(); +} +size_t WOWNERO_Wallet_numSubaddresses(void* wallet_ptr, uint32_t accountIndex) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->numSubaddresses(accountIndex); +} +void WOWNERO_Wallet_addSubaddress(void* wallet_ptr, uint32_t accountIndex, const char* label) { + Monero::Wallet *wallet = reinterpret_cast(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(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(wallet_ptr); + return wallet->setSubaddressLabel(accountIndex, addressIndex, std::string(label)); +} +const char* WOWNERO_Wallet_getMultisigInfo(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(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(wallet_ptr); + Monero::optional optAmount; + if (amount != 0) { + optAmount = amount; + } + std::set subaddr_indices = {}; + std::set 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(wallet_ptr); + return wallet->loadUnsignedTx(std::string(fileName)); +} +bool WOWNERO_Wallet_submitTransaction(void* wallet_ptr, const char* fileName) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->submitTransaction(std::string(fileName)); +} +bool WOWNERO_Wallet_hasUnknownKeyImages(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->hasUnknownKeyImages(); +} +bool WOWNERO_Wallet_exportKeyImages(void* wallet_ptr, const char* filename, bool all) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->exportKeyImages(std::string(filename), all); +} +bool WOWNERO_Wallet_importKeyImages(void* wallet_ptr, const char* filename) { + Monero::Wallet *wallet = reinterpret_cast(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(wallet_ptr); + return wallet->exportOutputs(std::string(filename), all); +} +bool WOWNERO_Wallet_importOutputs(void* wallet_ptr, const char* filename) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->importOutputs(std::string(filename)); +} +// virtual bool setupBackgroundSync(const BackgroundSyncType background_sync_type, const std::string &wallet_password, const optional &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(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(wallet_ptr); + return wallet->getBackgroundSyncType(); +} +// virtual bool startBackgroundSync() = 0; +bool WOWNERO_Wallet_startBackgroundSync(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(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(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(wallet_ptr); + return wallet->hasUnknownKeyImages(); +} +// virtual bool isBackgroundWallet() const = 0; +bool WOWNERO_Wallet_isBackgroundWallet(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->isBackgroundWallet(); +} +void* WOWNERO_Wallet_history(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->history(); +} +void* WOWNERO_Wallet_addressBook(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->addressBook(); +} +// virtual Coins * coins() = 0; +void* WOWNERO_Wallet_coins(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->coins(); +} +// virtual Subaddress * subaddress() = 0; +void* WOWNERO_Wallet_subaddress(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->subaddress(); +} +// virtual SubaddressAccount * subaddressAccount() = 0; +void* WOWNERO_Wallet_subaddressAccount(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->subaddressAccount(); +} +// virtual uint32_t defaultMixin() const = 0; +uint32_t WOWNERO_Wallet_defaultMixin(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(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(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(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(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 ¬e) = 0; +bool WOWNERO_Wallet_setUserNote(void* wallet_ptr, const char* txid, const char* note) { + Monero::Wallet *wallet = reinterpret_cast(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(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(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(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(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(wallet_ptr); + return wallet->rescanSpent(); +} + +void WOWNERO_Wallet_setOffline(void* wallet_ptr, bool offline) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setOffline(offline); +} +// virtual bool isOffline() const = 0; +bool WOWNERO_Wallet_isOffline(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->isOffline(); +} + +void WOWNERO_Wallet_segregatePreForkOutputs(void* wallet_ptr, bool segregate) { + Monero::Wallet *wallet = reinterpret_cast(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(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(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(wallet_ptr); + return wallet->lockKeysFile(); +} +// virtual bool unlockKeysFile() = 0; +bool WOWNERO_Wallet_unlockKeysFile(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->unlockKeysFile(); +} +// virtual bool isKeysFileLocked() = 0; +bool WOWNERO_Wallet_isKeysFileLocked(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->isKeysFileLocked(); +} +// virtual Device getDeviceType() const = 0; +int WOWNERO_Wallet_getDeviceType(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(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(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(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(wallet_ptr); + return wallet->getBytesReceived(); +} +uint64_t WOWNERO_Wallet_getBytesSent(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast(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(wm_ptr); + Monero::Wallet *wallet = wm->createWallet( + std::string(path), + std::string(password), + std::string(language), + static_cast(networkType)); + return reinterpret_cast(wallet); +} + +void* WOWNERO_WalletManager_openWallet(void* wm_ptr, const char* path, const char* password, int networkType) { + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + Monero::Wallet *wallet = wm->openWallet( + std::string(path), + std::string(password), + static_cast(networkType)); + return reinterpret_cast(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(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(networkType), + restoreHeight, + kdfRounds, + std::string(seedOffset)); + return reinterpret_cast(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(wm_ptr); + Monero::Wallet *wallet = wm->createWalletFromKeys( + std::string(path), + std::string(password), + std::string(language), + static_cast(nettype), + restoreHeight, + std::string(addressString), + std::string(viewKeyString), + std::string(spendKeyString)); + return reinterpret_cast(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(wm_ptr); + return wm->createWalletFromPolyseed(std::string(path), + std::string(password), + static_cast(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(wm_ptr); + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wm->closeWallet(wallet, store); +} + +bool WOWNERO_WalletManager_walletExists(void* wm_ptr, const char* path) { + Monero::WalletManager *wm = reinterpret_cast(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(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 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(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(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(wm_ptr); + return wm->setDaemonAddress(std::string(address)); +} + +bool WOWNERO_WalletManager_setProxy(void* wm_ptr, const char* address) { + Monero::WalletManager *wm = reinterpret_cast(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(wm_ptr); + return wm->blockchainHeight(); +} +// virtual uint64_t blockchainTargetHeight() = 0; +uint64_t WOWNERO_WalletManager_blockchainTargetHeight(void* wm_ptr) { + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->blockchainTargetHeight(); +} +// virtual uint64_t networkDifficulty() = 0; +uint64_t WOWNERO_WalletManager_networkDifficulty(void* wm_ptr) { + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->networkDifficulty(); +} +// virtual double miningHashRate() = 0; +double WOWNERO_WalletManager_miningHashRate(void* wm_ptr) { + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->miningHashRate(); +} +// virtual uint64_t blockTarget() = 0; +uint64_t WOWNERO_WalletManager_blockTarget(void* wm_ptr) { + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->blockTarget(); +} +// virtual bool isMining() = 0; +bool WOWNERO_WalletManager_isMining(void* wm_ptr) { + Monero::WalletManager *wm = reinterpret_cast(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(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(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(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(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(&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(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 00000000..8e67d4b3 --- /dev/null +++ b/wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.h @@ -0,0 +1,981 @@ +/* +#include + +#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 +#include +#include +#include + +#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 +// 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 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 subaddrAccount() const = 0; +extern ADDAPI const char* WOWNERO_PendingTransaction_subaddrAccount(void* pendingTx_ptr, const char* separator); +// virtual std::vector> 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 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 amount() const = 0; +extern ADDAPI const char* WOWNERO_UnsignedTransaction_amount(void* unsignedTx_ptr, const char* separator); +// virtual std::vector fee() const = 0; +extern ADDAPI const char* WOWNERO_UnsignedTransaction_fee(void* unsignedTx_ptr, const char* separator); +// virtual std::vector 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 paymentId() const = 0; +extern ADDAPI const char* WOWNERO_UnsignedTransaction_paymentId(void* unsignedTx_ptr, const char* separator); +// virtual std::vector 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 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 & 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 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 ¬e) = 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 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 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 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 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 onDevicePinRequest() { +// throw std::runtime_error("Not supported"); +// } +// virtual optional onDevicePassphraseRequest(bool & on_device) { +// on_device = true; +// return optional(); +// } +// 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 &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& info, uint32_t threshold) = 0; +// virtual std::string exchangeMultisigKeys(const std::vector &info, const bool force_update_use_with_caution) = 0; +// virtual bool exportMultisigImages(std::string& images) = 0; +// virtual size_t importMultisigImages(const std::vector& images) = 0; +// virtual bool hasMultisigPartialKeyImages() const = 0; +// virtual PendingTransaction* restoreMultisigTransaction(const std::string& signData) = 0; +// virtual PendingTransaction * createTransactionMultDest(const std::vector &dst_addr, const std::string &payment_id, +// optional> amount, uint32_t mixin_count, +// PendingTransaction::Priority = PendingTransaction::Priority_Low, +// uint32_t subaddr_account = 0, +// std::set subaddr_indices = {}) = 0; +// virtual PendingTransaction * createTransaction(const std::string &dst_addr, const std::string &payment_id, +// optional amount, uint32_t mixin_count, +// PendingTransaction::Priority = PendingTransaction::Priority_Low, +// uint32_t subaddr_account = 0, +// std::set subaddr_indices = {}, +// const std::set &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> &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 &txids) = 0; +// virtual bool setupBackgroundSync(const BackgroundSyncType background_sync_type, const std::string &wallet_password, const optional &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 ¬e) = 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 &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 &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 &ring) const = 0; +// virtual bool getRings(const std::string &txid, std::vector>> &rings) const = 0; +// virtual bool setRing(const std::string &key_image, const std::vector &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 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 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