diff options
| -rw-r--r-- | .github/workflows/android.yml | 3 | ||||
| -rw-r--r-- | libbridge/src/main/cpp/helpers.cpp | 64 | ||||
| -rw-r--r-- | libbridge/src/main/cpp/helpers.hpp | 4 | ||||
| -rw-r--r-- | libbridge/src/main/cpp/wallet2_api_c.cpp | 904 | ||||
| -rw-r--r-- | libbridge/src/main/cpp/wallet2_api_c.h | 183 |
5 files changed, 1125 insertions, 33 deletions
diff --git a/.github/workflows/android.yml b/.github/workflows/android.yml index 8940cfd..4eb16bc 100644 --- a/.github/workflows/android.yml +++ b/.github/workflows/android.yml @@ -401,8 +401,7 @@ jobs: && cd libbridge \ && mkdir build \ && cd build \ - && env CC=clang CXX=clang++ cmake -DANDROID_ABI=${{ matrix.full_arch }} .. \ - && make -j${NPROC} + && env CC=clang CXX=clang++ cmake -DANDROID_ABI=${{ matrix.full_arch }} .. - name: Build libbridge (2/2) make run: | cd ${{ github.workspace }} \ diff --git a/libbridge/src/main/cpp/helpers.cpp b/libbridge/src/main/cpp/helpers.cpp index c19c39d..ffb96f2 100644 --- a/libbridge/src/main/cpp/helpers.cpp +++ b/libbridge/src/main/cpp/helpers.cpp @@ -14,6 +14,7 @@ const char* vectorToString(const std::vector<std::string>& vec, const std::strin std::string result; for (const auto& str : vec) { result += str; + result += separator; } const char* cstr = result.c_str(); return cstr; @@ -27,7 +28,7 @@ const char* vectorToString(const std::vector<uint32_t>& vec, const std::string s size += snprintf(nullptr, 0, "%u", vec[i]); // Add comma and space for all elements except the last one if (i < vec.size() - 1) { - size += 2; // comma and space + size += separator.size(); // comma and space } } @@ -46,8 +47,43 @@ const char* vectorToString(const std::vector<uint32_t>& vec, const std::string s current += written; // Add comma and space for all elements except the last one if (i < vec.size() - 1) { - strcpy(current, ", "); - current += 2; + strcpy(current, separator.c_str()); + current += separator.size(); + } + } + + return result; +} + +const char* vectorToString(const std::vector<uint64_t>& vec, const std::string separator) { + // Calculate the size needed for the result string + size_t size = 0; + for (size_t i = 0; i < vec.size(); ++i) { + // Calculate the number of digits in each element + size += snprintf(nullptr, 0, "%lu", vec[i]); + // Add comma and space for all elements except the last one + if (i < vec.size() - 1) { + size += separator.size(); // comma and space + } + } + + // Allocate memory for the result string + char* result = static_cast<char*>(malloc(size + 1)); + if (result == nullptr) { + // Handle memory allocation failure + return nullptr; + } + + // Fill in the result string + char* current = result; + for (size_t i = 0; i < vec.size(); ++i) { + // Convert each element to string and copy to the result string + int written = snprintf(current, size + 1, "%lu", vec[i]); + current += written; + // Add comma and space for all elements except the last one + if (i < vec.size() - 1) { + strcpy(current, separator.c_str()); + current += separator.size(); } } @@ -84,3 +120,25 @@ const char* vectorToString(const std::vector<std::set<uint32_t>>& vec, const std memcpy(buffer, str.c_str(), size + 1); return buffer; } + +// Function to convert std::set<uint32_t> to a string +const char* vectorToString(const std::set<uint32_t>& intSet, const std::string separator) { + // Check if the set is empty + if (intSet.empty()) { + return ""; + } + + // Use a stringstream to concatenate elements with commas + std::ostringstream oss; + auto it = intSet.begin(); + oss << *it; + for (++it; it != intSet.end(); ++it) { + oss << ", " << *it; + } + + std::string str = oss.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; +} diff --git a/libbridge/src/main/cpp/helpers.hpp b/libbridge/src/main/cpp/helpers.hpp index 0f79677..5d9b4a4 100644 --- a/libbridge/src/main/cpp/helpers.hpp +++ b/libbridge/src/main/cpp/helpers.hpp @@ -5,4 +5,6 @@ const char* vectorToString(const std::vector<std::string>& vec, const std::string separator); const char* vectorToString(const std::vector<uint32_t>& vec, const std::string separator); -const char* vectorToString(const std::vector<std::set<uint32_t>>& vec, const std::string separator);
\ No newline at end of file +const char* vectorToString(const std::vector<uint64_t>& vec, const std::string separator); +const char* vectorToString(const std::vector<std::set<uint32_t>>& vec, const std::string separator); +const char* vectorToString(const std::set<uint32_t>& intSet, const std::string separator);
\ No newline at end of file diff --git a/libbridge/src/main/cpp/wallet2_api_c.cpp b/libbridge/src/main/cpp/wallet2_api_c.cpp index 9e8d9fa..2a7cc13 100644 --- a/libbridge/src/main/cpp/wallet2_api_c.cpp +++ b/libbridge/src/main/cpp/wallet2_api_c.cpp @@ -9,23 +9,6 @@ extern "C" { #endif -#include <android/log.h> -#define LOG_TAG "wallet2_api_c" -#define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG,__VA_ARGS__) -#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG , LOG_TAG,__VA_ARGS__) -#define LOGI(...) __android_log_print(ANDROID_LOG_INFO , LOG_TAG,__VA_ARGS__) -#define LOGW(...) __android_log_print(ANDROID_LOG_WARN , LOG_TAG,__VA_ARGS__) -#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR , LOG_TAG,__VA_ARGS__) - -#ifdef __cplusplus -} -#endif - -#ifdef __cplusplus -extern "C" -{ -#endif - // PendingTransaction int MONERO_PendingTransaction_status(void* pendingTx_ptr) { @@ -92,6 +75,62 @@ const char* MONERO_PendingTransaction_signersKeys(void* pendingTx_ptr, const cha std::vector<std::string> txid = pendingTx->signersKeys(); return vectorToString(txid, std::string(separator)); } + +// UnsignedTransaction + +int MONERO_UnsignedTransaction_status(void* unsignedTx_ptr) { + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr); + return unsignedTx->status(); +} +const char* MONERO_UnsignedTransaction_errorString(void* unsignedTx_ptr) { + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr); + std::string str = unsignedTx->errorString(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +const char* MONERO_UnsignedTransaction_amount(void* unsignedTx_ptr, const char* separator) { + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr); + return vectorToString(unsignedTx->amount(), std::string(separator)); +} +const char* MONERO_UnsignedTransaction_fee(void* unsignedTx_ptr, const char* separator) { + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr); + return vectorToString(unsignedTx->fee(), std::string(separator)); +} +const char* MONERO_UnsignedTransaction_mixin(void* unsignedTx_ptr, const char* separator) { + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr); + return vectorToString(unsignedTx->mixin(), std::string(separator)); +} +const char* MONERO_UnsignedTransaction_confirmationMessage(void* unsignedTx_ptr) { + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr); + std::string str = unsignedTx->confirmationMessage(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +const char* MONERO_UnsignedTransaction_paymentId(void* unsignedTx_ptr, const char* separator) { + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr); + return vectorToString(unsignedTx->paymentId(), std::string(separator)); +} +const char* MONERO_UnsignedTransaction_recipientAddress(void* unsignedTx_ptr, const char* separator) { + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr); + return vectorToString(unsignedTx->recipientAddress(), std::string(separator)); +} +uint64_t MONERO_UnsignedTransaction_minMixinCount(void* unsignedTx_ptr) { + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr); + return unsignedTx->minMixinCount(); +} +uint64_t MONERO_UnsignedTransaction_txCount(void* unsignedTx_ptr) { + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr); + return unsignedTx->txCount(); +} +bool MONERO_UnsignedTransaction_sign(void* unsignedTx_ptr, const char* signedFileName) { + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast<Monero::UnsignedTransaction*>(unsignedTx_ptr); + return unsignedTx->sign(std::string(signedFileName)); +} + // TransactionInfo int MONERO_TransactionInfo_direction(void* txInfo_ptr) { Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr); @@ -129,6 +168,11 @@ const char* MONERO_TransactionInfo_description(void* txInfo_ptr) { memcpy(buffer, str.c_str(), size + 1); return buffer; } +const char* MONERO_TransactionInfo_subaddrIndex(void* txInfo_ptr, const char* separator) { + Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr); + std::set<uint32_t> subaddrIndex = txInfo->subaddrIndex(); + return vectorToString(subaddrIndex, std::string(separator)); +} uint32_t MONERO_TransactionInfo_subaddrAccount(void* txInfo_ptr) { Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr); return txInfo->subaddrAccount(); @@ -170,6 +214,28 @@ const char* MONERO_TransactionInfo_paymentId(void* txInfo_ptr) { return buffer; } +int MONERO_TransactionInfo_transfers_count(void* txInfo_ptr) { + Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr); + return txInfo->transfers().size(); +} + +uint64_t MONERO_TransactionInfo_transfers_amount(void* txInfo_ptr, int index) { + Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr); + return txInfo->transfers()[index].amount; +} + +const char* MONERO_TransactionInfo_transfers_address(void* txInfo_ptr, int index) { + Monero::TransactionInfo *txInfo = reinterpret_cast<Monero::TransactionInfo*>(txInfo_ptr); + std::string str = txInfo->transfers()[index].address; + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} + + + + // TransactionHistory int MONERO_TransactionHistory_count(void* txHistory_ptr) { Monero::TransactionHistory *txHistory = reinterpret_cast<Monero::TransactionHistory*>(txHistory_ptr); @@ -179,6 +245,19 @@ void* MONERO_TransactionHistory_transaction(void* txHistory_ptr, int index) { Monero::TransactionHistory *txHistory = reinterpret_cast<Monero::TransactionHistory*>(txHistory_ptr); return reinterpret_cast<void*>(txHistory->transaction(index)); } +void* MONERO_TransactionHistory_transactionById(void* txHistory_ptr, const char* id) { + Monero::TransactionHistory *txHistory = reinterpret_cast<Monero::TransactionHistory*>(txHistory_ptr); + return reinterpret_cast<void*>(txHistory->transaction(std::string(id))); +} + +size_t MONERO_TransactionHistory_getAll_size(void* txHistory_ptr) { + Monero::TransactionHistory *txHistory = reinterpret_cast<Monero::TransactionHistory*>(txHistory_ptr); + return txHistory->getAll().size(); +} +void* MONERO_TransactionHistory_getAll_single(void* txHistory_ptr, int id) { + Monero::TransactionHistory *txHistory = reinterpret_cast<Monero::TransactionHistory*>(txHistory_ptr); + return txHistory->getAll()[0]; +} void MONERO_TransactionHistory_refresh(void* txHistory_ptr) { Monero::TransactionHistory *txHistory = reinterpret_cast<Monero::TransactionHistory*>(txHistory_ptr); return txHistory->refresh(); @@ -188,8 +267,437 @@ void MONERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, return txHistory->setTxNote(std::string(txid), std::string(note)); } -// Wallet +// AddressBokRow + +// std::string extra; +const char* MONERO_AddressBookRow_extra(void* addressBookRow_ptr) { + Monero::AddressBookRow *addressBookRow = reinterpret_cast<Monero::AddressBookRow*>(addressBookRow_ptr); + std::string str = addressBookRow->extra; + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// std::string getAddress() const {return m_address;} +const char* MONERO_AddressBookRow_getAddress(void* addressBookRow_ptr) { + Monero::AddressBookRow *addressBookRow = reinterpret_cast<Monero::AddressBookRow*>(addressBookRow_ptr); + std::string str = addressBookRow->getAddress(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// std::string getDescription() const {return m_description;} +const char* MONERO_AddressBookRow_getDescription(void* addressBookRow_ptr) { + Monero::AddressBookRow *addressBookRow = reinterpret_cast<Monero::AddressBookRow*>(addressBookRow_ptr); + std::string str = addressBookRow->getDescription(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// std::string getPaymentId() const {return m_paymentId;} +const char* MONERO_AddressBookRow_getPaymentId(void* addressBookRow_ptr) { + Monero::AddressBookRow *addressBookRow = reinterpret_cast<Monero::AddressBookRow*>(addressBookRow_ptr); + std::string str = addressBookRow->getPaymentId(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// std::size_t getRowId() const {return m_rowId;} +size_t MONERO_AddressBookRow_getRowId(void* addressBookRow_ptr) { + Monero::AddressBookRow *addressBookRow = reinterpret_cast<Monero::AddressBookRow*>(addressBookRow_ptr); + return addressBookRow->getRowId(); +} + +// AddressBook +// virtual std::vector<AddressBookRow*> getAll() const = 0; +int MONERO_AddressBook_getAll_size(void* addressBook_ptr) { + Monero::AddressBook *addressBook = reinterpret_cast<Monero::AddressBook*>(addressBook_ptr); + return addressBook->getAll().size(); +} +void* MONERO_AddressBook_getAll_byIndex(void* addressBook_ptr, int index) { + Monero::AddressBook *addressBook = reinterpret_cast<Monero::AddressBook*>(addressBook_ptr); + return addressBook->getAll()[index]; +} +// virtual bool addRow(const std::string &dst_addr , const std::string &payment_id, const std::string &description) = 0; +bool MONERO_AddressBook_addRow(void* addressBook_ptr, const char* dst_addr , const char* payment_id, const char* description) { + Monero::AddressBook *addressBook = reinterpret_cast<Monero::AddressBook*>(addressBook_ptr); + return addressBook->addRow(std::string(dst_addr), std::string(payment_id), std::string(description)); +} +// virtual bool deleteRow(std::size_t rowId) = 0; +bool MONERO_AddressBook_deleteRow(void* addressBook_ptr, size_t rowId) { + Monero::AddressBook *addressBook = reinterpret_cast<Monero::AddressBook*>(addressBook_ptr); + return addressBook->deleteRow(rowId); +} +// virtual bool setDescription(std::size_t index, const std::string &description) = 0; +bool MONERO_AddressBook_setDescription(void* addressBook_ptr, size_t rowId, const char* description) { + Monero::AddressBook *addressBook = reinterpret_cast<Monero::AddressBook*>(addressBook_ptr); + return addressBook->setDescription(rowId, std::string(description)); +} +// virtual void refresh() = 0; +void MONERO_AddressBook_refresh(void* addressBook_ptr) { + Monero::AddressBook *addressBook = reinterpret_cast<Monero::AddressBook*>(addressBook_ptr); + return addressBook->refresh(); +} +// virtual std::string errorString() const = 0; +const char* MONERO_AddressBook_errorString(void* addressBook_ptr) { + Monero::AddressBook *addressBook = reinterpret_cast<Monero::AddressBook*>(addressBook_ptr); + std::string str = addressBook->errorString(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// virtual int errorCode() const = 0; +int MONERO_AddressBook_errorCode(void* addressBook_ptr) { + Monero::AddressBook *addressBook = reinterpret_cast<Monero::AddressBook*>(addressBook_ptr); + return addressBook->errorCode(); +} +// virtual int lookupPaymentID(const std::string &payment_id) const = 0; +int MONERO_AddressBook_lookupPaymentID(void* addressBook_ptr, const char* payment_id) { + Monero::AddressBook *addressBook = reinterpret_cast<Monero::AddressBook*>(addressBook_ptr); + return addressBook->lookupPaymentID(std::string(payment_id)); +} + +// CoinsInfo +uint64_t MONERO_CoinsInfo_blockHeight(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + return coinsInfo->blockHeight(); +} +// virtual std::string hash() const = 0; +const char* MONERO_CoinsInfo_hash(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + std::string str = coinsInfo->hash(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// virtual size_t internalOutputIndex() const = 0; +size_t MONERO_CoinsInfo_internalOutputIndex(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + return coinsInfo->internalOutputIndex(); +} +// virtual uint64_t globalOutputIndex() const = 0; +uint64_t MONERO_CoinsInfo_globalOutputIndex(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + return coinsInfo->globalOutputIndex(); +} +// virtual bool spent() const = 0; +bool MONERO_CoinsInfo_spent(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + return coinsInfo->spent(); +} +// virtual bool frozen() const = 0; +bool MONERO_CoinsInfo_frozen(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + return coinsInfo->frozen(); +} +// virtual uint64_t spentHeight() const = 0; +uint64_t MONERO_CoinsInfo_spentHeight(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + return coinsInfo->spentHeight(); +} +// virtual uint64_t amount() const = 0; +uint64_t MONERO_CoinsInfo_amount(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + return coinsInfo->amount(); +} +// virtual bool rct() const = 0; +bool MONERO_CoinsInfo_rct(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + return coinsInfo->rct(); +} +// virtual bool keyImageKnown() const = 0; +bool MONERO_CoinsInfo_keyImageKnown(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + return coinsInfo->keyImageKnown(); +} +// virtual size_t pkIndex() const = 0; +size_t MONERO_CoinsInfo_pkIndex(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + return coinsInfo->pkIndex(); +} +// virtual uint32_t subaddrIndex() const = 0; +uint32_t MONERO_CoinsInfo_subaddrIndex(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + return coinsInfo->subaddrIndex(); +} +// virtual uint32_t subaddrAccount() const = 0; +uint32_t MONERO_CoinsInfo_subaddrAccount(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + return coinsInfo->subaddrAccount(); +} +// virtual std::string address() const = 0; +const char* MONERO_CoinsInfo_address(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + std::string str = coinsInfo->address(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// virtual std::string addressLabel() const = 0; +const char* MONERO_CoinsInfo_addressLabel(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + std::string str = coinsInfo->addressLabel(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// virtual std::string keyImage() const = 0; +const char* MONERO_CoinsInfo_keyImage(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + std::string str = coinsInfo->keyImage(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// virtual uint64_t unlockTime() const = 0; +uint64_t MONERO_CoinsInfo_unlockTime(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + return coinsInfo->unlockTime(); +} +// virtual bool unlocked() const = 0; +bool MONERO_CoinsInfo_unlocked(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + return coinsInfo->internalOutputIndex(); +} +// virtual std::string pubKey() const = 0; +const char* MONERO_CoinsInfo_pubKey(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + std::string str = coinsInfo->pubKey(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// virtual bool coinbase() const = 0; +bool MONERO_CoinsInfo_coinbase(void* coinsInfo_ptr) { + Monero::CoinsInfo *coinsInfo = reinterpret_cast<Monero::CoinsInfo*>(coinsInfo_ptr); + return coinsInfo->internalOutputIndex(); +} + + +// coins + +// virtual ~Coins() = 0; +// virtual int count() const = 0; +int MONERO_Coins_count(void* coins_ptr) { + Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr); + return coins->count(); +} +// virtual CoinsInfo * coin(int index) const = 0; +void* MONERO_Coins_coin(void* coins_ptr, int index) { + Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr); + return coins->coin(index); +} +// virtual std::vector<CoinsInfo*> getAll() const = 0; +// virtual void refresh() = 0; +void MONERO_Coins_refresh(void* coins_ptr) { + Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr); + return coins->refresh(); +} +// virtual void setFrozen(int index) = 0; +void MONERO_Coins_setFrozen(void* coins_ptr, int index) { + Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr); + return coins->setFrozen(index); +} +// virtual void thaw(int index) = 0; +void MONERO_Coins_thaw(void* coins_ptr, int index) { + Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr); + return coins->thaw(index); +} +// virtual bool isTransferUnlocked(uint64_t unlockTime, uint64_t blockHeight) = 0; +bool MONERO_Coins_isTransferUnlocked(void* coins_ptr, uint64_t unlockTime, uint64_t blockHeight) { + Monero::Coins *coins = reinterpret_cast<Monero::Coins*>(coins_ptr); + return coins->isTransferUnlocked(unlockTime, blockHeight); +} + +// SubaddressRow + +// std::string extra; +const char* MONERO_SubaddressRow_extra(void* subaddressRow_ptr) { + Monero::SubaddressRow *subaddressRow = reinterpret_cast<Monero::SubaddressRow*>(subaddressRow_ptr); + std::string str = subaddressRow->extra; + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// std::string getAddress() const {return m_address;} +const char* MONERO_SubaddressRow_getAddress(void* subaddressRow_ptr) { + Monero::SubaddressRow *subaddressRow = reinterpret_cast<Monero::SubaddressRow*>(subaddressRow_ptr); + std::string str = subaddressRow->getAddress(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// std::string getLabel() const {return m_label;} +const char* MONERO_SubaddressRow_getLabel(void* subaddressRow_ptr) { + Monero::SubaddressRow *subaddressRow = reinterpret_cast<Monero::SubaddressRow*>(subaddressRow_ptr); + std::string str = subaddressRow->getLabel(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// std::size_t getRowId() const {return m_rowId;} +size_t MONERO_SubaddressRow_getRowId(void* subaddressRow_ptr) { + Monero::SubaddressRow *subaddressRow = reinterpret_cast<Monero::SubaddressRow*>(subaddressRow_ptr); + return subaddressRow->getRowId(); +} + +// Subaddress + +int MONERO_Subaddress_getAll_size(void* subaddress_ptr) { + Monero::Subaddress *subaddress = reinterpret_cast<Monero::Subaddress*>(subaddress_ptr); + return subaddress->getAll().size(); +} +void* MONERO_Subaddress_getAll_byIndex(void* subaddress_ptr, int index) { + Monero::Subaddress *subaddress = reinterpret_cast<Monero::Subaddress*>(subaddress_ptr); + return subaddress->getAll()[index]; +} +// virtual void addRow(uint32_t accountIndex, const std::string &label) = 0; +void MONERO_Subaddress_addRow(void* subaddress_ptr, uint32_t accountIndex, const char* label) { + Monero::Subaddress *subaddress = reinterpret_cast<Monero::Subaddress*>(subaddress_ptr); + return subaddress->addRow(accountIndex, std::string(label)); +} +// virtual void setLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0; +void MONERO_Subaddress_setLabel(void* subaddress_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label) { + Monero::Subaddress *subaddress = reinterpret_cast<Monero::Subaddress*>(subaddress_ptr); + return subaddress->setLabel(accountIndex, addressIndex, std::string(label)); +} +// virtual void refresh(uint32_t accountIndex) = 0; +void MONERO_Subaddress_refresh(void* subaddress_ptr, uint32_t accountIndex) { + Monero::Subaddress *subaddress = reinterpret_cast<Monero::Subaddress*>(subaddress_ptr); + return subaddress->refresh(accountIndex); +} + +// SubaddressAccountRow + +// std::string extra; +const char* MONERO_SubaddressAccountRow_extra(void* subaddressAccountRow_ptr) { + Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast<Monero::SubaddressAccountRow*>(subaddressAccountRow_ptr); + std::string str = subaddressAccountRow->extra; + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// std::string getAddress() const {return m_address;} +const char* MONERO_SubaddressAccountRow_getAddress(void* subaddressAccountRow_ptr) { + Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast<Monero::SubaddressAccountRow*>(subaddressAccountRow_ptr); + std::string str = subaddressAccountRow->getAddress(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// std::string getLabel() const {return m_label;} +const char* MONERO_SubaddressAccountRow_getLabel(void* subaddressAccountRow_ptr) { + Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast<Monero::SubaddressAccountRow*>(subaddressAccountRow_ptr); + std::string str = subaddressAccountRow->getLabel(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// std::string getBalance() const {return m_balance;} +const char* MONERO_SubaddressAccountRow_getBalance(void* subaddressAccountRow_ptr) { + Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast<Monero::SubaddressAccountRow*>(subaddressAccountRow_ptr); + std::string str = subaddressAccountRow->getBalance(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// std::string getUnlockedBalance() const {return m_unlockedBalance;} +const char* MONERO_SubaddressAccountRow_getUnlockedBalance(void* subaddressAccountRow_ptr) { + Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast<Monero::SubaddressAccountRow*>(subaddressAccountRow_ptr); + std::string str = subaddressAccountRow->getUnlockedBalance(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// std::size_t getRowId() const {return m_rowId;} +size_t MONERO_SubaddressAccountRow_getRowId(void* subaddressAccountRow_ptr) { + Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast<Monero::SubaddressAccountRow*>(subaddressAccountRow_ptr); + return subaddressAccountRow->getRowId(); +} + +// struct SubaddressAccount +// { +// virtual ~SubaddressAccount() = 0; +// virtual std::vector<SubaddressAccountRow*> getAll() const = 0; +int MONERO_SubaddressAccount_getAll_size(void* subaddressAccount_ptr) { + Monero::SubaddressAccount *subaddress = reinterpret_cast<Monero::SubaddressAccount*>(subaddressAccount_ptr); + return subaddress->getAll().size(); +} +void* MONERO_SubaddressAccount_getAll_byIndex(void* subaddressAccount_ptr, int index) { + Monero::SubaddressAccount *subaddress = reinterpret_cast<Monero::SubaddressAccount*>(subaddressAccount_ptr); + return subaddress->getAll()[index]; +} +// virtual void addRow(const std::string &label) = 0; +void MONERO_SubaddressAccount_addRow(void* subaddressAccount_ptr, const char* label) { + Monero::SubaddressAccount *subaddress = reinterpret_cast<Monero::SubaddressAccount*>(subaddressAccount_ptr); + return subaddress->addRow(std::string(label)); +} +// virtual void setLabel(uint32_t accountIndex, const std::string &label) = 0; +void MONERO_SubaddressAccount_setLabel(void* subaddressAccount_ptr, uint32_t accountIndex, const char* label) { + Monero::SubaddressAccount *subaddress = reinterpret_cast<Monero::SubaddressAccount*>(subaddressAccount_ptr); + return subaddress->setLabel(accountIndex, std::string(label)); +} +// virtual void refresh() = 0; +void MONERO_SubaddressAccount_refresh(void* subaddressAccount_ptr) { + Monero::SubaddressAccount *subaddress = reinterpret_cast<Monero::SubaddressAccount*>(subaddressAccount_ptr); + return subaddress->refresh(); +} + +// MultisigState + +// bool isMultisig; +bool MONERO_MultisigState_isMultisig(void* multisigState_ptr) { + Monero::MultisigState *multisigState = reinterpret_cast<Monero::MultisigState*>(multisigState_ptr); + return multisigState->isMultisig; +} +// bool isReady; +bool MONERO_MultisigState_isReady(void* multisigState_ptr) { + Monero::MultisigState *multisigState = reinterpret_cast<Monero::MultisigState*>(multisigState_ptr); + return multisigState->isReady; +} +// uint32_t threshold; +uint32_t MONERO_MultisigState_threshold(void* multisigState_ptr) { + Monero::MultisigState *multisigState = reinterpret_cast<Monero::MultisigState*>(multisigState_ptr); + return multisigState->threshold; +} +// uint32_t total; +uint32_t MONERO_MultisigState_total(void* multisigState_ptr) { + Monero::MultisigState *multisigState = reinterpret_cast<Monero::MultisigState*>(multisigState_ptr); + return multisigState->total; +} +// DeviceProgress + + +// virtual double progress() const { return m_progress; } +bool MONERO_DeviceProgress_progress(void* deviceProgress_ptr) { + Monero::DeviceProgress *deviceProgress = reinterpret_cast<Monero::DeviceProgress*>(deviceProgress_ptr); + return deviceProgress->progress(); +} +// virtual bool indeterminate() const { return m_indeterminate; } +bool MONERO_DeviceProgress_indeterminate(void* deviceProgress_ptr) { + Monero::DeviceProgress *deviceProgress = reinterpret_cast<Monero::DeviceProgress*>(deviceProgress_ptr); + return deviceProgress->indeterminate(); +} + +// Wallet const char* MONERO_Wallet_seed(void* wallet_ptr) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); @@ -200,6 +708,20 @@ const char* MONERO_Wallet_seed(void* wallet_ptr) { return buffer; } +const char* MONERO_Wallet_getSeedLanguage(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + std::string str = wallet->getSeedLanguage(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} + +void MONERO_Wallet_setSeedLanguage(void* wallet_ptr, const char* arg) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->setSeedLanguage(std::string(arg)); +} + int MONERO_Wallet_status(void* wallet_ptr) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return wallet->status(); @@ -214,6 +736,31 @@ const char* MONERO_Wallet_errorString(void* wallet_ptr) { return buffer; } + +bool MONERO_Wallet_setPassword(void* wallet_ptr, const char* password) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->setPassword(std::string(password)); +} + +const char* MONERO_Wallet_getPassword(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + std::string str = wallet->getPassword(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} + +bool MONERO_Wallet_setDevicePin(void* wallet_ptr, const char* pin) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->setDevicePin(std::string(pin)); +} + +bool MONERO_Wallet_setDevicePassphrase(void* wallet_ptr, const char* passphrase) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->setDevicePassphrase(std::string(passphrase)); +} + const char* MONERO_Wallet_address(void* wallet_ptr, uint64_t accountIndex, uint64_t addressIndex) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); std::string str = wallet->address(accountIndex, addressIndex); @@ -223,6 +770,31 @@ const char* MONERO_Wallet_address(void* wallet_ptr, uint64_t accountIndex, uint6 return buffer; } +const char* MONERO_Wallet_path(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + std::string str = wallet->path(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +int MONERO_Wallet_nettype(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->nettype(); +} +uint8_t MONERO_Wallet_useForkRules(void* wallet_ptr, uint8_t version, int64_t early_blocks) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->useForkRules(version, early_blocks); +} +const char* MONERO_Wallet_integratedAddress(void* wallet_ptr, const char* payment_id) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + std::string str = wallet->integratedAddress(std::string(payment_id)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} + const char* MONERO_Wallet_secretViewKey(void* wallet_ptr) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); std::string str = wallet->secretViewKey(); @@ -258,6 +830,14 @@ const char* MONERO_Wallet_publicSpendKey(void* wallet_ptr) { memcpy(buffer, str.c_str(), size + 1); return buffer; } +const char* MONERO_Wallet_publicMultisigSignerKey(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + std::string str = wallet->publicMultisigSignerKey(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} void MONERO_Wallet_stop(void* wallet_ptr) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); @@ -268,12 +848,32 @@ bool MONERO_Wallet_store(void* wallet_ptr, const char* path) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return wallet->store(std::string(path)); } +bool MONERO_Wallet_filename(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + std::string str = wallet->filename(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +bool MONERO_Wallet_keysFilename(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + std::string str = wallet->keysFilename(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} // virtual bool init(const std::string &daemon_address, uint64_t upper_transaction_size_limit = 0, const std::string &daemon_username = "", const std::string &daemon_password = "", bool use_ssl = false, bool lightWallet = false, const std::string &proxy_address = "") = 0; bool MONERO_Wallet_init(void* wallet_ptr, const char* daemon_address, uint64_t upper_transaction_size_limit, const char* daemon_username, const char* daemon_password, bool use_ssl, bool lightWallet, const char* proxy_address) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return wallet->init(std::string(daemon_address), upper_transaction_size_limit, std::string(daemon_username), std::string(daemon_password), use_ssl, lightWallet, std::string(proxy_address)); } +bool MONERO_Wallet_createWatchOnly(void* wallet_ptr, const char* path, const char* password, const char* language) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->createWatchOnly(std::string(path), std::string(password), std::string(language)); +} void MONERO_Wallet_setRefreshFromBlockHeight(void* wallet_ptr, uint64_t refresh_from_block_height) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); @@ -284,6 +884,20 @@ uint64_t MONERO_Wallet_getRefreshFromBlockHeight(void* wallet_ptr) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return wallet->getRefreshFromBlockHeight(); } + +void MONERO_Wallet_setRecoveringFromSeed(void* wallet_ptr, bool recoveringFromSeed) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->setRecoveringFromSeed(recoveringFromSeed); +} +void MONERO_Wallet_setRecoveringFromDevice(void* wallet_ptr, bool recoveringFromDevice) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->setRecoveringFromDevice(recoveringFromDevice); +} +void MONERO_Wallet_setSubaddressLookahead(void* wallet_ptr, uint32_t major, uint32_t minor) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->setSubaddressLookahead(major, minor); +} + bool MONERO_Wallet_connectToDaemon(void* wallet_ptr) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return wallet->connectToDaemon(); @@ -292,6 +906,14 @@ int MONERO_Wallet_connected(void* wallet_ptr) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return wallet->connected(); } +void MONERO_Wallet_setTrustedDaemon(void* wallet_ptr, bool arg) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->setTrustedDaemon(arg); +} +bool MONERO_Wallet_trustedDaemon(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->trustedDaemon(); +} bool MONERO_Wallet_setProxy(void* wallet_ptr, const char* address) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return wallet->setProxy(std::string(address)); @@ -340,18 +962,63 @@ bool MONERO_Wallet_synchronized(void* wallet_ptr) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return wallet->synchronized(); } + const char* MONERO_Wallet_displayAmount(uint64_t amount) { - // Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); std::string str = Monero::Wallet::displayAmount(amount); const std::string::size_type size = str.size(); char *buffer = new char[size + 1]; //we need extra char for NUL memcpy(buffer, str.c_str(), size + 1); return buffer; } + +// static uint64_t amountFromString(const std::string &amount); +uint64_t MONERO_Wallet_amountFromString(const char* amount) { + return Monero::Wallet::amountFromString(amount); +} +// static uint64_t amountFromDouble(double amount); +uint64_t MONERO_Wallet_amountFromDouble(double amount) { + return Monero::Wallet::amountFromDouble(amount); +} +// static std::string genPaymentId(); +const char* MONERO_Wallet_genPaymentId() { + std::string str = Monero::Wallet::genPaymentId(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// static bool paymentIdValid(const std::string &paiment_id); +bool MONERO_Wallet_paymentIdValid(const char* paiment_id) { + return Monero::Wallet::paymentIdValid(std::string(paiment_id)); +} bool MONERO_Wallet_addressValid(const char* str, int nettype) { // Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return Monero::Wallet::addressValid(std::string(str), nettype); } + +bool MONERO_Wallet_keyValid(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype) { + std::string error; + return Monero::Wallet::keyValid(std::string(secret_key_string), std::string(address_string), isViewKey, nettype, error); +} +const char* MONERO_Wallet_keyValid_error(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype) { + std::string str; + Monero::Wallet::keyValid(std::string(secret_key_string), std::string(address_string), isViewKey, nettype, str); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +const char* MONERO_Wallet_paymentIdFromAddress(const char* strarg, int nettype) { + std::string str = Monero::Wallet::paymentIdFromAddress(std::string(strarg), nettype); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +uint64_t MONERO_Wallet_maximumAllowedAmount() { + return Monero::Wallet::maximumAllowedAmount(); +} + void MONERO_Wallet_init3(void* wallet_ptr, const char* argv0, const char* default_log_base_name, const char* log_path, bool console) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return wallet->init(argv0, default_log_base_name, log_path, console); @@ -417,6 +1084,14 @@ void MONERO_Wallet_setSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, u Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return wallet->setSubaddressLabel(accountIndex, addressIndex, std::string(label)); } +const char* MONERO_Wallet_getMultisigInfo(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + std::string str = wallet->getMultisigInfo(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} void* MONERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id, uint64_t amount, uint32_t mixin_count, int pendingTransactionPriority, @@ -427,6 +1102,10 @@ void* MONERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, co Monero::PendingTransaction::Priority_Low, subaddr_account /*, subaddr_indices */); } +void* MONERO_Wallet_loadUnsignedTx(void* wallet_ptr, const char* fileName) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->loadUnsignedTx(std::string(fileName)); +} bool MONERO_Wallet_submitTransaction(void* wallet_ptr, const char* fileName) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return wallet->submitTransaction(std::string(fileName)); @@ -449,9 +1128,80 @@ bool MONERO_Wallet_importOutputs(void* wallet_ptr, const char* filename) { } void* MONERO_Wallet_history(void* wallet_ptr) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); - return reinterpret_cast<void*>(wallet->history()); + return wallet->history(); +} +void* MONERO_Wallet_addressBook(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->addressBook(); +} +// virtual Coins * coins() = 0; +void* MONERO_Wallet_coins(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->coins(); +} +// virtual Subaddress * subaddress() = 0; +void* MONERO_Wallet_subaddress(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->subaddress(); +} +// virtual SubaddressAccount * subaddressAccount() = 0; +void* MONERO_Wallet_subaddressAccount(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->subaddressAccount(); +} +// virtual uint32_t defaultMixin() const = 0; +uint32_t MONERO_Wallet_defaultMixin(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->defaultMixin(); +} +// virtual void setDefaultMixin(uint32_t arg) = 0; +void MONERO_Wallet_setTefaultMixin(void* wallet_ptr, uint32_t arg) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->setDefaultMixin(arg); +} +// virtual bool setCacheAttribute(const std::string &key, const std::string &val) = 0; +bool MONERO_Wallet_setCacheAttribute(void* wallet_ptr, const char* key, const char* val) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->setCacheAttribute(std::string(key), std::string(val)); +} +// virtual std::string getCacheAttribute(const std::string &key) const = 0; +const char* MONERO_Wallet_getCacheAttribute(void* wallet_ptr, const char* key) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + std::string str = wallet->getCacheAttribute(std::string(key)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// virtual bool setUserNote(const std::string &txid, const std::string ¬e) = 0; +bool MONERO_Wallet_setUserNote(void* wallet_ptr, const char* txid, const char* note) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->setUserNote(std::string(txid), std::string(note)); +} +// virtual std::string getUserNote(const std::string &txid) const = 0; +const char* MONERO_Wallet_getUserNote(void* wallet_ptr, const char* txid) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + std::string str = wallet->getUserNote(std::string(txid)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; } -// virtual void setOffline(bool offline) = 0; + +const char* MONERO_Wallet_getTxKey(void* wallet_ptr, const char* txid) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + std::string str = wallet->getTxKey(std::string(txid)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} + +bool MONERO_Wallet_rescanSpent(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->rescanSpent(); +} + void MONERO_Wallet_setOffline(void* wallet_ptr, bool offline) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return wallet->setOffline(offline); @@ -462,6 +1212,60 @@ bool MONERO_Wallet_isOffline(void* wallet_ptr) { return wallet->isOffline(); } +void MONERO_Wallet_segregatePreForkOutputs(void* wallet_ptr, bool segregate) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->segregatePreForkOutputs(segregate); +} +// virtual void segregationHeight(uint64_t height) = 0; +void MONERO_Wallet_segregationHeight(void* wallet_ptr, uint64_t height) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->segregationHeight(height); +} +// virtual void keyReuseMitigation2(bool mitigation) = 0; +void MONERO_Wallet_keyReuseMitigation2(void* wallet_ptr, bool mitigation) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->keyReuseMitigation2(mitigation); +} +// virtual bool lightWalletLogin(bool &isNewWallet) const = 0; +// virtual bool lightWalletImportWalletRequest(std::string &payment_id, uint64_t &fee, bool &new_request, bool &request_fulfilled, std::string &payment_address, std::string &status) = 0; +// virtual bool lockKeysFile() = 0; +bool MONERO_Wallet_lockKeysFile(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->lockKeysFile(); +} +// virtual bool unlockKeysFile() = 0; +bool MONERO_Wallet_unlockKeysFile(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->unlockKeysFile(); +} +// virtual bool isKeysFileLocked() = 0; +bool MONERO_Wallet_isKeysFileLocked(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->isKeysFileLocked(); +} +// virtual Device getDeviceType() const = 0; +int MONERO_Wallet_getDeviceType(void* wallet_ptr) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->getDeviceType(); +} +// virtual uint64_t coldKeyImageSync(uint64_t &spent, uint64_t &unspent) = 0; +uint64_t MONERO_Wallet_coldKeyImageSync(void* wallet_ptr, uint64_t spent, uint64_t unspent) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + return wallet->coldKeyImageSync(spent, unspent); +} +// virtual void deviceShowAddress(uint32_t accountIndex, uint32_t addressIndex, const std::string &paymentId) = 0; +const char* MONERO_Wallet_deviceShowAddress(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex) { + Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); + std::string str = ""; + wallet->deviceShowAddress(accountIndex, addressIndex, str); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} +// virtual bool reconnectDevice() = 0; +const char* MONERO_Wallet_reconnectDevice(void* wallet_ptr); + uint64_t MONERO_Wallet_getBytesReceived(void* wallet_ptr) { Monero::Wallet *wallet = reinterpret_cast<Monero::Wallet*>(wallet_ptr); return wallet->getBytesReceived(); @@ -515,6 +1319,21 @@ bool MONERO_WalletManager_closeWallet(void* wallet_ptr, bool store) { bool MONERO_WalletManager_walletExists(const char* path) { return Monero::WalletManagerFactory::getWalletManager()->walletExists(std::string(path)); } + +// virtual bool verifyWalletPassword(const std::string &keys_file_name, const std::string &password, bool no_spend_key, uint64_t kdf_rounds = 1) const = 0; +bool MONERO_WalletManager_verifyWalletPassword(const char* keys_file_name, const char* password, bool no_spend_key, uint64_t kdf_rounds) { + return Monero::WalletManagerFactory::getWalletManager()->verifyWalletPassword(std::string(keys_file_name), std::string(password), no_spend_key, kdf_rounds); +} +// virtual bool queryWalletDevice(Wallet::Device& device_type, const std::string &keys_file_name, const std::string &password, uint64_t kdf_rounds = 1) const = 0; +// bool MONERO_WalletManager_queryWalletDevice(int device_type, const char* keys_file_name, const char* password, uint64_t kdf_rounds) { +// return Monero::WalletManagerFactory::getWalletManager()->queryWalletDevice(device_type, std::string(keys_file_name), std::string(password), kdf_rounds); +//} +// virtual std::vector<std::string> findWallets(const std::string &path) = 0; +const char* MONERO_WalletManager_findWallets(const char* path, const char* separator) { + return vectorToString(Monero::WalletManagerFactory::getWalletManager()->findWallets(std::string(path)), std::string(separator)); +} + + const char* MONERO_WalletManager_errorString() { std::string str = Monero::WalletManagerFactory::getWalletManager()->errorString(); const std::string::size_type size = str.size(); @@ -531,6 +1350,49 @@ bool MONERO_WalletManager_setProxy(const char* address) { return Monero::WalletManagerFactory::getWalletManager()->setProxy(std::string(address)); } + +// virtual bool connected(uint32_t *version = NULL) = 0; +// virtual uint64_t blockchainHeight() = 0; +uint64_t MONERO_WalletManager_blockchainHeight() { + return Monero::WalletManagerFactory::getWalletManager()->blockchainHeight(); +} +// virtual uint64_t blockchainTargetHeight() = 0; +uint64_t MONERO_WalletManager_blockchainTargetHeight() { + return Monero::WalletManagerFactory::getWalletManager()->blockchainTargetHeight(); +} +// virtual uint64_t networkDifficulty() = 0; +uint64_t MONERO_WalletManager_networkDifficulty() { + return Monero::WalletManagerFactory::getWalletManager()->networkDifficulty(); +} +// virtual double miningHashRate() = 0; +double MONERO_WalletManager_miningHashRate() { + return Monero::WalletManagerFactory::getWalletManager()->miningHashRate(); +} +// virtual uint64_t blockTarget() = 0; +uint64_t MONERO_WalletManager_blockTarget() { + return Monero::WalletManagerFactory::getWalletManager()->blockTarget(); +} +// virtual bool isMining() = 0; +bool MONERO_WalletManager_isMining() { + return Monero::WalletManagerFactory::getWalletManager()->isMining(); +} +// virtual bool startMining(const std::string &address, uint32_t threads = 1, bool background_mining = false, bool ignore_battery = true) = 0; +bool MONERO_WalletManager_startMining(const char* address, uint32_t threads, bool backgroundMining, bool ignoreBattery) { + return Monero::WalletManagerFactory::getWalletManager()->startMining(std::string(address), threads, backgroundMining, ignoreBattery); +} +// virtual bool stopMining() = 0; +bool MONERO_WalletManager_stopMining(const char* address) { + return Monero::WalletManagerFactory::getWalletManager()->stopMining(); +} +// virtual std::string resolveOpenAlias(const std::string &address, bool &dnssec_valid) const = 0; +const char* MONERO_WalletManager_resolveOpenAlias(const char* address, bool dnssec_valid) { + std::string str = Monero::WalletManagerFactory::getWalletManager()->resolveOpenAlias(std::string(address), dnssec_valid); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; +} + // WalletManagerFactory void MONERO_WalletManagerFactory_setLogLevel(int level) { diff --git a/libbridge/src/main/cpp/wallet2_api_c.h b/libbridge/src/main/cpp/wallet2_api_c.h index 234ab79..4f34e7d 100644 --- a/libbridge/src/main/cpp/wallet2_api_c.h +++ b/libbridge/src/main/cpp/wallet2_api_c.h @@ -16,13 +16,15 @@ extern "C" { #endif -int NetworkTypeMAINNET = 0; // 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); @@ -45,15 +47,23 @@ int NetworkTypeMAINNET = 0; // { // 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; @@ -88,29 +98,43 @@ const char* MONERO_PendingTransaction_signersKeys(void* pendingTx_ptr, const cha // { // 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; -// int MONERO_UnsignedTransaction_status(void* unsignedTx_ptr); +int MONERO_UnsignedTransaction_status(void* unsignedTx_ptr); // virtual std::string errorString() const = 0; -// const char* MONERO_UnsignedTransaction_errorString(void* unsignedTx_ptr); +const char* MONERO_UnsignedTransaction_errorString(void* unsignedTx_ptr); // virtual std::vector<uint64_t> amount() const = 0; +const char* MONERO_UnsignedTransaction_amount(void* unsignedTx_ptr, const char* separator); // virtual std::vector<uint64_t> fee() const = 0; +const char* MONERO_UnsignedTransaction_fee(void* unsignedTx_ptr, const char* separator); // virtual std::vector<uint64_t> mixin() const = 0; +const char* MONERO_UnsignedTransaction_mixin(void* unsignedTx_ptr, const char* separator); // virtual std::string confirmationMessage() const = 0; +const char* MONERO_UnsignedTransaction_confirmationMessage(void* unsignedTx_ptr); // virtual std::vector<std::string> paymentId() const = 0; +const char* MONERO_UnsignedTransaction_paymentId(void* unsignedTx_ptr, const char* separator); // virtual std::vector<std::string> recipientAddress() const = 0; +const char* MONERO_UnsignedTransaction_recipientAddress(void* unsignedTx_ptr, const char* separator); // virtual uint64_t minMixinCount() const = 0; +uint64_t MONERO_UnsignedTransaction_minMixinCount(void* unsignedTx_ptr); // virtual uint64_t txCount() const = 0; +uint64_t MONERO_UnsignedTransaction_txCount(void* unsignedTx_ptr); // virtual bool sign(const std::string &signedFileName) = 0; +bool MONERO_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); @@ -135,6 +159,7 @@ uint64_t MONERO_TransactionInfo_blockHeight(void* txInfo_ptr); // virtual std::string description() const = 0; const char* MONERO_TransactionInfo_description(void* txInfo_ptr); // virtual std::set<uint32_t> subaddrIndex() const = 0; +const char* MONERO_TransactionInfo_subaddrIndex(void* txInfo_ptr, const char* separator); // virtual uint32_t subaddrAccount() const = 0; uint32_t MONERO_TransactionInfo_subaddrAccount(void* txInfo_ptr); // virtual std::string label() const = 0; @@ -150,6 +175,9 @@ uint64_t MONERO_TransactionInfo_timestamp(void* txInfo_ptr); // virtual std::string paymentId() const = 0; const char* MONERO_TransactionInfo_paymentId(void* txInfo_ptr); // virtual const std::vector<Transfer> & transfers() const = 0; +int MONERO_TransactionInfo_transfers_count(void* txInfo_ptr); +uint64_t MONERO_TransactionInfo_transfers_amount(void* txInfo_ptr, int index); +const char* MONERO_TransactionInfo_transfers_address(void* txInfo_ptr, int address); // }; // struct TransactionHistory // { @@ -159,7 +187,10 @@ int MONERO_TransactionHistory_count(void* txHistory_ptr); // virtual TransactionInfo * transaction(int index) const = 0; void* MONERO_TransactionHistory_transaction(void* txHistory_ptr, int index); // virtual TransactionInfo * transaction(const std::string &id) const = 0; +void* MONERO_TransactionHistory_transactionById(void* txHistory_ptr, const char* id); // virtual std::vector<TransactionInfo*> getAll() const = 0; +size_t MONERO_TransactionHistory_getAll_size(void* txHistory_ptr); +void* MONERO_TransactionHistory_getAll_single(void* txHistory_ptr, int id); // virtual void refresh() = 0; void MONERO_TransactionHistory_refresh(void* txHistory_ptr); // virtual void setTxNote(const std::string &txid, const std::string ¬e) = 0; @@ -180,63 +211,107 @@ void MONERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, // std::string m_description; // public: // std::string extra; +const char* MONERO_AddressBookRow_extra(void* addressBookRow_ptr); // std::string getAddress() const {return m_address;} +const char* MONERO_AddressBookRow_getAddress(void* addressBookRow_ptr); // std::string getDescription() const {return m_description;} +const char* MONERO_AddressBookRow_getDescription(void* addressBookRow_ptr); // std::string getPaymentId() const {return m_paymentId;} +const char* MONERO_AddressBookRow_getPaymentId(void* addressBookRow_ptr); // std::size_t getRowId() const {return m_rowId;} +size_t MONERO_AddressBookRow_getRowId(void* addressBookRow_ptr); // }; // struct AddressBook // { // enum ErrorCode { // Status_Ok, +const int AddressBookErrorCodeStatus_Ok = 0; // General_Error, +const int AddressBookErrorCodeGeneral_Error = 1; // Invalid_Address, +const int AddressBookErrorCodeInvalid_Address = 2; // Invalid_Payment_Id +const int AddressBookErrorCodeInvalidPaymentId = 3; // }; // virtual ~AddressBook() = 0; // virtual std::vector<AddressBookRow*> getAll() const = 0; +int MONERO_AddressBook_getAll_size(void* addressBook_ptr); +void* MONERO_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; +bool MONERO_AddressBook_addRow(void* addressBook_ptr, const char* dst_addr , const char* payment_id, const char* description); // virtual bool deleteRow(std::size_t rowId) = 0; +bool MONERO_AddressBook_deleteRow(void* addressBook_ptr, size_t rowId); // virtual bool setDescription(std::size_t index, const std::string &description) = 0; +bool MONERO_AddressBook_setDescription(void* addressBook_ptr, size_t rowId, const char* description); // virtual void refresh() = 0; +void MONERO_AddressBook_refresh(void* addressBook_ptr); // virtual std::string errorString() const = 0; +const char* MONERO_AddressBook_errorString(void* addressBook_ptr); // virtual int errorCode() const = 0; +int MONERO_AddressBook_errorCode(void* addressBook_ptr); // virtual int lookupPaymentID(const std::string &payment_id) const = 0; +int MONERO_AddressBook_lookupPaymentID(void* addressBook_ptr, const char* payment_id); // }; // struct CoinsInfo // { // virtual ~CoinsInfo() = 0; // virtual uint64_t blockHeight() const = 0; +uint64_t MONERO_CoinsInfo_blockHeight(void* coinsInfo_ptr); // virtual std::string hash() const = 0; +const char* MONERO_CoinsInfo_hash(void* coinsInfo_ptr); // virtual size_t internalOutputIndex() const = 0; +size_t MONERO_CoinsInfo_internalOutputIndex(void* coinsInfo_ptr); // virtual uint64_t globalOutputIndex() const = 0; +uint64_t MONERO_CoinsInfo_globalOutputIndex(void* coinsInfo_ptr); // virtual bool spent() const = 0; +bool MONERO_CoinsInfo_spent(void* coinsInfo_ptr); // virtual bool frozen() const = 0; +bool MONERO_CoinsInfo_frozen(void* coinsInfo_ptr); // virtual uint64_t spentHeight() const = 0; +uint64_t MONERO_CoinsInfo_spentHeight(void* coinsInfo_ptr); // virtual uint64_t amount() const = 0; +uint64_t MONERO_CoinsInfo_amount(void* coinsInfo_ptr); // virtual bool rct() const = 0; +bool MONERO_CoinsInfo_rct(void* coinsInfo_ptr); // virtual bool keyImageKnown() const = 0; +bool MONERO_CoinsInfo_keyImageKnown(void* coinsInfo_ptr); // virtual size_t pkIndex() const = 0; +size_t MONERO_CoinsInfo_pkIndex(void* coinsInfo_ptr); // virtual uint32_t subaddrIndex() const = 0; +uint32_t MONERO_CoinsInfo_subaddrIndex(void* coinsInfo_ptr); // virtual uint32_t subaddrAccount() const = 0; +uint32_t MONERO_CoinsInfo_subaddrAccount(void* coinsInfo_ptr); // virtual std::string address() const = 0; +const char* MONERO_CoinsInfo_address(void* coinsInfo_ptr); // virtual std::string addressLabel() const = 0; +const char* MONERO_CoinsInfo_addressLabel(void* coinsInfo_ptr); // virtual std::string keyImage() const = 0; +const char* MONERO_CoinsInfo_keyImage(void* coinsInfo_ptr); // virtual uint64_t unlockTime() const = 0; +uint64_t MONERO_CoinsInfo_unlockTime(void* coinsInfo_ptr); // virtual bool unlocked() const = 0; +bool MONERO_CoinsInfo_unlocked(void* coinsInfo_ptr); // virtual std::string pubKey() const = 0; +const char* MONERO_CoinsInfo_pubKey(void* coinsInfo_ptr); // virtual bool coinbase() const = 0; +bool MONERO_CoinsInfo_coinbase(void* coinsInfo_ptr); // }; // struct Coins // { // virtual ~Coins() = 0; // virtual int count() const = 0; +int MONERO_Coins_count(void* coins_ptr); // virtual CoinsInfo * coin(int index) const = 0; +void* MONERO_Coins_coin(void* coins_ptr, int index); // virtual std::vector<CoinsInfo*> getAll() const = 0; // virtual void refresh() = 0; +void MONERO_Coins_refresh(void* coins_ptr); // virtual void setFrozen(int index) = 0; +void MONERO_Coins_setFrozen(void* coins_ptr, int index); // virtual void thaw(int index) = 0; +void MONERO_Coins_thaw(void* coins_ptr, int index); // virtual bool isTransferUnlocked(uint64_t unlockTime, uint64_t blockHeight) = 0; +bool MONERO_Coins_isTransferUnlocked(void* coins_ptr, uint64_t unlockTime, uint64_t blockHeight); // }; // struct SubaddressRow { // public: @@ -251,18 +326,27 @@ void MONERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, // std::string m_label; // public: // std::string extra; +const char* MONERO_SubaddressRow_extra(void* subaddressRow_ptr); // std::string getAddress() const {return m_address;} +const char* MONERO_SubaddressRow_getAddress(void* subaddressRow_ptr); // std::string getLabel() const {return m_label;} +const char* MONERO_SubaddressRow_getLabel(void* subaddressRow_ptr); // std::size_t getRowId() const {return m_rowId;} +size_t MONERO_SubaddressRow_getRowId(void* subaddressRow_ptr); // }; // struct Subaddress // { // virtual ~Subaddress() = 0; // virtual std::vector<SubaddressRow*> getAll() const = 0; +int MONERO_Subaddress_getAll_size(void* subaddress_ptr); +void* MONERO_Subaddress_getAll_byIndex(void* subaddress_ptr, int index); // virtual void addRow(uint32_t accountIndex, const std::string &label) = 0; +void MONERO_Subaddress_addRow(void* subaddress_ptr, uint32_t accountIndex, const char* label); // virtual void setLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0; +void MONERO_Subaddress_setLabel(void* subaddress_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label); // virtual void refresh(uint32_t accountIndex) = 0; +void MONERO_Subaddress_refresh(void* subaddress_ptr, uint32_t accountIndex); // }; // struct SubaddressAccountRow { @@ -282,29 +366,44 @@ void MONERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, // std::string m_unlockedBalance; // public: // std::string extra; +const char* MONERO_SubaddressAccountRow_extra(void* subaddressAccountRow_ptr); // std::string getAddress() const {return m_address;} +const char* MONERO_SubaddressAccountRow_getAddress(void* subaddressAccountRow_ptr); // std::string getLabel() const {return m_label;} +const char* MONERO_SubaddressAccountRow_getLabel(void* subaddressAccountRow_ptr); // std::string getBalance() const {return m_balance;} +const char* MONERO_SubaddressAccountRow_getBalance(void* subaddressAccountRow_ptr); // std::string getUnlockedBalance() const {return m_unlockedBalance;} +const char* MONERO_SubaddressAccountRow_getUnlockedBalance(void* subaddressAccountRow_ptr); // std::size_t getRowId() const {return m_rowId;} +size_t MONERO_SubaddressAccountRow_getRowId(void* subaddressAccountRow_ptr); // }; // struct SubaddressAccount // { // virtual ~SubaddressAccount() = 0; // virtual std::vector<SubaddressAccountRow*> getAll() const = 0; +int MONERO_SubaddressAccount_getAll_size(void* subaddressAccount_ptr); +void* MONERO_SubaddressAccount_getAll_byIndex(void* subaddressAccount_ptr, int index); // virtual void addRow(const std::string &label) = 0; +void MONERO_SubaddressAccount_addRow(void* subaddressAccount_ptr, const char* label); // virtual void setLabel(uint32_t accountIndex, const std::string &label) = 0; +void MONERO_SubaddressAccount_setLabel(void* subaddressAccount_ptr, uint32_t accountIndex, const char* label); // virtual void refresh() = 0; +void MONERO_SubaddressAccount_refresh(void* subaddressAccount_ptr); // }; // struct MultisigState { // MultisigState() : isMultisig(false), isReady(false), threshold(0), total(0) {} // bool isMultisig; +bool MONERO_MultisigState_isMultisig(void* multisigState_ptr); // bool isReady; +bool MONERO_MultisigState_isReady(void* multisigState_ptr); // uint32_t threshold; +uint32_t MONERO_MultisigState_threshold(void* multisigState_ptr); // uint32_t total; +uint32_t MONERO_MultisigState_total(void* multisigState_ptr); // }; @@ -313,7 +412,9 @@ void MONERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, // DeviceProgress(double progress, bool indeterminate=false): m_progress(progress), m_indeterminate(indeterminate) {} // virtual double progress() const { return m_progress; } +bool MONERO_DeviceProgress_progress(void* deviceProgress_ptr); // virtual bool indeterminate() const { return m_indeterminate; } +bool MONERO_DeviceProgress_indeterminate(void* deviceProgress_ptr); // protected: // double m_progress; @@ -346,47 +447,63 @@ void MONERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, // { // 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; // }; -int ConnectionStatus_Disconnected = 0; -int ConnectionStatus_Connected = 1; -int ConnectionStatus_WrongVersion = 2; // enum ConnectionStatus { // ConnectionStatus_Disconnected, +const int WalletConnectionStatus_Disconnected = 0; // ConnectionStatus_Connected, +const int WalletConnectionStatus_Connected = 1; // ConnectionStatus_WrongVersion +const int WalletConnectionStatus_WrongVersion = 2; // }; // virtual ~Wallet() = 0; // virtual std::string seed(const std::string& seed_offset = "") const = 0; const char* MONERO_Wallet_seed(void* wallet_ptr); // virtual std::string getSeedLanguage() const = 0; +const char* MONERO_Wallet_getSeedLanguage(void* wallet_ptr); // virtual void setSeedLanguage(const std::string &arg) = 0; +void MONERO_Wallet_setSeedLanguage(void* wallet_ptr, const char* arg); // virtual int status() const = 0; int MONERO_Wallet_status(void* wallet_ptr); // virtual std::string errorString() const = 0; const char* MONERO_Wallet_errorString(void* wallet_ptr); // virtual void statusWithErrorString(int& status, std::string& errorString) const = 0; // virtual bool setPassword(const std::string &password) = 0; +bool MONERO_Wallet_setPassword(void* wallet_ptr, const char* password); // virtual const std::string& getPassword() const = 0; +const char* MONERO_Wallet_getPassword(void* wallet_ptr); // virtual bool setDevicePin(const std::string &pin) { (void)pin; return false; }; +bool MONERO_Wallet_setDevicePin(void* wallet_ptr, const char* pin); // virtual bool setDevicePassphrase(const std::string &passphrase) { (void)passphrase; return false; }; +bool MONERO_Wallet_setDevicePassphrase(void* wallet_ptr, const char* passphrase); // virtual std::string address(uint32_t accountIndex = 0, uint32_t addressIndex = 0) const = 0; const char* MONERO_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; +const char* MONERO_Wallet_path(void* wallet_ptr); // virtual NetworkType nettype() const = 0; +int MONERO_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; +uint8_t MONERO_Wallet_useForkRules(void* wallet_ptr, uint8_t version, int64_t early_blocks); // virtual std::string integratedAddress(const std::string &payment_id) const = 0; +const char* MONERO_Wallet_integratedAddress(void* wallet_ptr, const char* payment_id); // virtual std::string secretViewKey() const = 0; const char* MONERO_Wallet_secretViewKey(void* wallet_ptr); // virtual std::string publicViewKey() const = 0; @@ -396,28 +513,37 @@ const char* MONERO_Wallet_secretSpendKey(void* wallet_ptr); // virtual std::string publicSpendKey() const = 0; const char* MONERO_Wallet_publicSpendKey(void* wallet_ptr); // virtual std::string publicMultisigSignerKey() const = 0; +const char* MONERO_Wallet_publicMultisigSignerKey(void* wallet_ptr); // virtual void stop() = 0; void MONERO_Wallet_stop(void* wallet_ptr); // virtual bool store(const std::string &path) = 0; bool MONERO_Wallet_store(void* wallet_ptr, const char* path); // virtual std::string filename() const = 0; +bool MONERO_Wallet_filename(void* wallet_ptr); // virtual std::string keysFilename() const = 0; +bool MONERO_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; bool MONERO_Wallet_init(void* wallet_ptr, const char* daemon_address, uint64_t upper_transaction_size_limit, const char* daemon_username, const char* daemon_password, bool use_ssl, bool lightWallet, const char* proxy_address); // virtual bool createWatchOnly(const std::string &path, const std::string &password, const std::string &language) const = 0; +bool MONERO_Wallet_createWatchOnly(void* wallet_ptr, const char* path, const char* password, const char* language); // virtual void setRefreshFromBlockHeight(uint64_t refresh_from_block_height) = 0; void MONERO_Wallet_setRefreshFromBlockHeight(void* wallet_ptr, uint64_t refresh_from_block_height); // virtual uint64_t getRefreshFromBlockHeight() const = 0; uint64_t MONERO_Wallet_getRefreshFromBlockHeight(void* wallet_ptr); // virtual void setRecoveringFromSeed(bool recoveringFromSeed) = 0; +void MONERO_Wallet_setRecoveringFromSeed(void* wallet_ptr, bool recoveringFromSeed); // virtual void setRecoveringFromDevice(bool recoveringFromDevice) = 0; +void MONERO_Wallet_setRecoveringFromDevice(void* wallet_ptr, bool recoveringFromDevice); // virtual void setSubaddressLookahead(uint32_t major, uint32_t minor) = 0; +void MONERO_Wallet_setSubaddressLookahead(void* wallet_ptr, uint32_t major, uint32_t minor); // virtual bool connectToDaemon() = 0; bool MONERO_Wallet_connectToDaemon(void* wallet_ptr); // virtual ConnectionStatus connected() const = 0; int MONERO_Wallet_connected(void* wallet_ptr); // virtual void setTrustedDaemon(bool arg) = 0; +void MONERO_Wallet_setTrustedDaemon(void* wallet_ptr, bool arg); // virtual bool trustedDaemon() const = 0; +bool MONERO_Wallet_trustedDaemon(void* wallet_ptr); // virtual bool setProxy(const std::string &address) = 0; bool MONERO_Wallet_setProxy(void* wallet_ptr, const char* address); // virtual uint64_t balance(uint32_t accountIndex = 0) const = 0; @@ -455,26 +581,34 @@ bool MONERO_Wallet_synchronized(void* wallet_ptr); // static std::string displayAmount(uint64_t amount); const char* MONERO_Wallet_displayAmount(uint64_t amount); // static uint64_t amountFromString(const std::string &amount); +uint64_t MONERO_Wallet_amountFromString(const char* amount); // static uint64_t amountFromDouble(double amount); +uint64_t MONERO_Wallet_amountFromDouble(double amount); // static std::string genPaymentId(); +const char* MONERO_Wallet_genPaymentId(); // static bool paymentIdValid(const std::string &paiment_id); +bool MONERO_Wallet_paymentIdValid(const char* paiment_id); // static bool addressValid(const std::string &str, NetworkType nettype); bool MONERO_Wallet_addressValid(const char* str, int nettype); // static bool addressValid(const std::string &str, bool testnet) // deprecated // { // return addressValid(str, testnet ? TESTNET : MAINNET); // } +bool MONERO_Wallet_keyValid(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype); +const char* MONERO_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); +const char* MONERO_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(); +uint64_t MONERO_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); void MONERO_Wallet_init3(void* wallet_ptr, const char* argv0, const char* default_log_base_name, const char* log_path, bool console); @@ -512,6 +646,7 @@ const char* MONERO_Wallet_getSubaddressLabel(void* wallet_ptr, uint32_t accountI void MONERO_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; +const char* MONERO_Wallet_getMultisigInfo(void* wallet_ptr); // virtual std::string makeMultisig(const std::vector<std::string>& info, uint32_t threshold) = 0; // virtual std::string exchangeMultisigKeys(const std::vector<std::string> &info, const bool force_update_use_with_caution) = 0; // virtual bool exportMultisigImages(std::string& images) = 0; @@ -534,6 +669,7 @@ void* MONERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, co uint32_t subaddr_account); // std::nullopt // virtual PendingTransaction * createSweepUnmixableTransaction() = 0; // virtual UnsignedTransaction * loadUnsignedTx(const std::string &unsigned_filename) = 0; +void* MONERO_Wallet_loadUnsignedTx(void* wallet_ptr, const char* unsigned_filename); // virtual bool submitTransaction(const std::string &fileName) = 0; bool MONERO_Wallet_submitTransaction(void* wallet_ptr, const char* fileName); // virtual void disposeTransaction(PendingTransaction * t) = 0; @@ -551,17 +687,28 @@ bool MONERO_Wallet_importOutputs(void* wallet_ptr, const char* filename); // virtual TransactionHistory * history() = 0; void* MONERO_Wallet_history(void* wallet_ptr); // virtual AddressBook * addressBook() = 0; +void* MONERO_Wallet_addressBook(void* wallet_ptr); // virtual Coins * coins() = 0; +void* MONERO_Wallet_coins(void* wallet_ptr); // virtual Subaddress * subaddress() = 0; +void* MONERO_Wallet_subaddress(void* wallet_ptr); // virtual SubaddressAccount * subaddressAccount() = 0; +void* MONERO_Wallet_subaddressAccount(void* wallet_ptr); // virtual void setListener(WalletListener *) = 0; // virtual uint32_t defaultMixin() const = 0; +uint32_t MONERO_Wallet_defaultMixin(void* wallet_ptr); // virtual void setDefaultMixin(uint32_t arg) = 0; +void MONERO_Wallet_setTefaultMixin(void* wallet_ptr, uint32_t arg); // virtual bool setCacheAttribute(const std::string &key, const std::string &val) = 0; +bool MONERO_Wallet_setCacheAttribute(void* wallet_ptr, const char* key, const char* val); // virtual std::string getCacheAttribute(const std::string &key) const = 0; +const char* MONERO_Wallet_getCacheAttribute(void* wallet_ptr, const char* key); // virtual bool setUserNote(const std::string &txid, const std::string ¬e) = 0; +bool MONERO_Wallet_setUserNote(void* wallet_ptr, const char* txid, const char* note); // virtual std::string getUserNote(const std::string &txid) const = 0; +const char* MONERO_Wallet_getUserNote(void* wallet_ptr, const char* txid); // virtual std::string getTxKey(const std::string &txid) const = 0; +const char* MONERO_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; @@ -577,6 +724,7 @@ void* MONERO_Wallet_history(void* wallet_ptr); // 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; +bool MONERO_Wallet_rescanSpent(void* wallet_ptr); // virtual void setOffline(bool offline) = 0; void MONERO_Wallet_setOffline(void* wallet_ptr, bool offline); // virtual bool isOffline() const = 0; @@ -588,17 +736,27 @@ bool MONERO_Wallet_isOffline(void* wallet_ptr); // virtual bool getRings(const std::string &txid, std::vector<std::pair<std::string, std::vector<uint64_t>>> &rings) const = 0; // virtual bool setRing(const std::string &key_image, const std::vector<uint64_t> &ring, bool relative) = 0; // virtual void segregatePreForkOutputs(bool segregate) = 0; +void MONERO_Wallet_segregatePreForkOutputs(void* wallet_ptr, bool segregate); // virtual void segregationHeight(uint64_t height) = 0; +void MONERO_Wallet_segregationHeight(void* wallet_ptr, uint64_t height); // virtual void keyReuseMitigation2(bool mitigation) = 0; +void MONERO_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; +bool MONERO_Wallet_lockKeysFile(void* wallet_ptr); // virtual bool unlockKeysFile() = 0; +bool MONERO_Wallet_unlockKeysFile(void* wallet_ptr); // virtual bool isKeysFileLocked() = 0; +bool MONERO_Wallet_isKeysFileLocked(void* wallet_ptr); // virtual Device getDeviceType() const = 0; +int MONERO_Wallet_getDeviceType(void* wallet_ptr); // virtual uint64_t coldKeyImageSync(uint64_t &spent, uint64_t &unspent) = 0; +uint64_t MONERO_Wallet_coldKeyImageSync(void* wallet_ptr, uint64_t spent, uint64_t unspent); // virtual void deviceShowAddress(uint32_t accountIndex, uint32_t addressIndex, const std::string &paymentId) = 0; +const char* MONERO_Wallet_deviceShowAddress(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex); // virtual bool reconnectDevice() = 0; +const char* MONERO_Wallet_reconnectDevice(void* wallet_ptr); // virtual uint64_t getBytesReceived() = 0; uint64_t MONERO_Wallet_getBytesReceived(void* wallet_ptr); // virtual uint64_t getBytesSent() = 0; @@ -683,22 +841,34 @@ bool MONERO_WalletManager_closeWallet(void* wallet_ptr, bool store); // virtual bool walletExists(const std::string &path) = 0; bool MONERO_WalletManager_walletExists(const char* path); // virtual bool verifyWalletPassword(const std::string &keys_file_name, const std::string &password, bool no_spend_key, uint64_t kdf_rounds = 1) const = 0; +bool MONERO_WalletManager_verifyWalletPassword(const char* keys_file_name, const char* password, bool no_spend_key, uint64_t kdf_rounds); // virtual bool queryWalletDevice(Wallet::Device& device_type, const std::string &keys_file_name, const std::string &password, uint64_t kdf_rounds = 1) const = 0; +// bool MONERO_WalletManager_queryWalletDevice(int device_type, const char* keys_file_name, const char* password, uint64_t kdf_rounds); // virtual std::vector<std::string> findWallets(const std::string &path) = 0; +const char* MONERO_WalletManager_findWallets(const char* path, const char* separator); // virtual std::string errorString() const = 0; const char* MONERO_WalletManager_errorString(); // virtual void setDaemonAddress(const std::string &address) = 0; void MONERO_WalletManager_setDaemonAddress(const char* address); // virtual bool connected(uint32_t *version = NULL) = 0; // virtual uint64_t blockchainHeight() = 0; +uint64_t MONERO_WalletManager_blockchainHeight(); // virtual uint64_t blockchainTargetHeight() = 0; +uint64_t MONERO_WalletManager_blockchainTargetHeight(); // virtual uint64_t networkDifficulty() = 0; +uint64_t MONERO_WalletManager_networkDifficulty(); // virtual double miningHashRate() = 0; +double MONERO_WalletManager_miningHashRate(); // virtual uint64_t blockTarget() = 0; +uint64_t MONERO_WalletManager_blockTarget(); // virtual bool isMining() = 0; +bool MONERO_WalletManager_isMining(); // virtual bool startMining(const std::string &address, uint32_t threads = 1, bool background_mining = false, bool ignore_battery = true) = 0; +bool MONERO_WalletManager_startMining(const char* address, uint32_t threads, bool backgroundMining, bool ignoreBattery); // virtual bool stopMining() = 0; +bool MONERO_WalletManager_stopMining(const char* address); // virtual std::string resolveOpenAlias(const std::string &address, bool &dnssec_valid) const = 0; +const char* MONERO_WalletManager_resolveOpenAlias(const char* address, bool dnssec_valid); // static std::tuple<bool, std::string, std::string, std::string, std::string> checkUpdates( // const std::string &software, // std::string subdir, @@ -733,6 +903,7 @@ int LogLevel_Max = 4; // static void setLogLevel(int level); void MONERO_WalletManagerFactory_setLogLevel(int level); // static void setLogCategories(const std::string &categories); +void MONERO_WalletManagerFactory_setLogCategories(const char* categories); // }; // } |