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