From 235107fe5dc1caa8e17e396e9bf5cfdf89deb6fd Mon Sep 17 00:00:00 2001 From: Some Random Crypto Guy Date: Tue, 18 Mar 2025 10:31:55 +0000 Subject: [PATCH] updated build to include correct source files upstream; renamed codebase to use SALVIUM_ --- patches/salvium/0008-coin-control.patch | 30 +- salvium_libwallet2_api_c/CMakeLists.txt | 7 + .../salvium_libwallet2_api_c.exp | 308 +++++++++ .../src/main/cpp/salvium_checksum.h | 6 + .../src/main/cpp/wallet2_api_c.cpp | 654 +++++++++--------- .../src/main/cpp/wallet2_api_c.h | 620 ++++++++--------- 6 files changed, 973 insertions(+), 652 deletions(-) create mode 100644 salvium_libwallet2_api_c/salvium_libwallet2_api_c.exp create mode 100644 salvium_libwallet2_api_c/src/main/cpp/salvium_checksum.h diff --git a/patches/salvium/0008-coin-control.patch b/patches/salvium/0008-coin-control.patch index 3d3e396..a0fd8e1 100644 --- a/patches/salvium/0008-coin-control.patch +++ b/patches/salvium/0008-coin-control.patch @@ -550,7 +550,7 @@ index 4b0a26a6b..644cf503b 100644 // - confirmed_transfer_details) -PendingTransaction *WalletImpl::createTransactionMultDest(const Monero::transaction_type &tx_type, const std::vector &dst_addr, const string &payment_id, optional> amount, uint32_t mixin_count, const std::string &asset_type, const bool is_return, PendingTransaction::Priority priority, uint32_t subaddr_account, std::set subaddr_indices) -+PendingTransaction *WalletImpl::createTransactionMultDest(const Monero::transaction_type &tx_type, const std::vector &dst_addr, const string &payment_id, optional> amount, uint32_t mixin_count, const std::string &asset_type, const bool is_return, PendingTransaction::Priority priority, uint32_t subaddr_account, std::set subaddr_indices), const std::set &preferred_inputs) ++PendingTransaction *WalletImpl::createTransactionMultDest(const Monero::transaction_type &tx_type, const std::vector &dst_addr, const string &payment_id, optional> amount, uint32_t mixin_count, const std::string &asset_type, const bool is_return, PendingTransaction::Priority priority, uint32_t subaddr_account, std::set subaddr_indices, const std::set &preferred_inputs) { clearStatus(); @@ -749,20 +749,7 @@ index 4b0a26a6b..644cf503b 100644 setStatusError(writer.str()); } catch (const tools::error::tx_not_possible& e) { std::ostringstream writer; -@@ -2222,10 +2304,10 @@ PendingTransaction *WalletImpl::createTransactionMultDest(const Monero::transact - } - - PendingTransaction *WalletImpl::createTransaction(const string &dst_addr, const string &payment_id, optional amount, uint32_t mixin_count, -- const std::string &asset_type, const bool is_return, PendingTransaction::Priority priority, uint32_t subaddr_account, std::set subaddr_indices) -+ const std::string &asset_type, const bool is_return, PendingTransaction::Priority priority, uint32_t subaddr_account, std::set subaddr_indices, const std::set &preferred_inputs) - - { -- return createTransactionMultDest(Monero::transaction_type::TRANSFER, std::vector {dst_addr}, payment_id, amount ? (std::vector {*amount}) : (optional>()), mixin_count, asset_type, is_return, priority, subaddr_account, subaddr_indices); -+ return createTransactionMultDest(Monero::transaction_type::TRANSFER, std::vector {dst_addr}, payment_id, amount ? (std::vector {*amount}) : (optional>()), mixin_count, asset_type, is_return, priority, subaddr_account, subaddr_indices, preferred_inputs); - } - - PendingTransaction *WalletImpl::createSweepUnmixableTransaction() -@@ -2278,6 +2360,16 @@ PendingTransaction *WalletImpl::createSweepUnmixableTransaction() +@@ -2179,6 +2261,16 @@ PendingTransaction *WalletImpl::createTransactionMultDest(const Monero::transact print_money(e.tx_amount() + e.fee()) % print_money(e.tx_amount()) % print_money(e.fee()); @@ -779,6 +766,19 @@ index 4b0a26a6b..644cf503b 100644 setStatusError(writer.str()); } catch (const tools::error::not_enough_outs_to_mix& e) { std::ostringstream writer; +@@ -2222,10 +2304,10 @@ PendingTransaction *WalletImpl::createTransactionMultDest(const Monero::transact + } + + PendingTransaction *WalletImpl::createTransaction(const string &dst_addr, const string &payment_id, optional amount, uint32_t mixin_count, +- const std::string &asset_type, const bool is_return, PendingTransaction::Priority priority, uint32_t subaddr_account, std::set subaddr_indices) ++ const std::string &asset_type, const bool is_return, PendingTransaction::Priority priority, uint32_t subaddr_account, std::set subaddr_indices, const std::set &preferred_inputs) + + { +- return createTransactionMultDest(Monero::transaction_type::TRANSFER, std::vector {dst_addr}, payment_id, amount ? (std::vector {*amount}) : (optional>()), mixin_count, asset_type, is_return, priority, subaddr_account, subaddr_indices); ++ return createTransactionMultDest(Monero::transaction_type::TRANSFER, std::vector {dst_addr}, payment_id, amount ? (std::vector {*amount}) : (optional>()), mixin_count, asset_type, is_return, priority, subaddr_account, subaddr_indices, preferred_inputs); + } + + PendingTransaction *WalletImpl::createSweepUnmixableTransaction() @@ -2350,6 +2442,11 @@ AddressBook *WalletImpl::addressBook() return m_addressBook.get(); } diff --git a/salvium_libwallet2_api_c/CMakeLists.txt b/salvium_libwallet2_api_c/CMakeLists.txt index 876d2d4..afc2bf4 100644 --- a/salvium_libwallet2_api_c/CMakeLists.txt +++ b/salvium_libwallet2_api_c/CMakeLists.txt @@ -103,6 +103,9 @@ elseif(${MONERO_FLAVOR} STREQUAL "wownero") target_compile_definitions(wallet2_api_c PRIVATE FLAVOR_WOWNERO) elseif(${MONERO_FLAVOR} STREQUAL "zano") target_compile_definitions(wallet2_api_c PRIVATE FLAVOR_ZANO) +elseif(${MONERO_FLAVOR} STREQUAL "salvium") + target_compile_definitions(wallet2_api_c PRIVATE FLAVOR_SALVIUM) + set(BCUR_ENABLED bc-ur) endif() if(NOT ${HOST_ABI} STREQUAL "x86_64-apple-darwin11" AND NOT ${HOST_ABI} STREQUAL "aarch64-apple-darwin11" AND NOT ${HOST_ABI} STREQUAL "aarch64-apple-darwin" AND NOT ${HOST_ABI} STREQUAL "x86_64-apple-darwin" AND NOT ${HOST_ABI} STREQUAL "host-apple-darwin" AND NOT ${HOST_ABI} STREQUAL "x86_64-host-apple-darwin" AND NOT ${HOST_ABI} STREQUAL "aarch64-host-apple-darwin" AND NOT ${HOST_ABI} STREQUAL "host-apple-ios" AND NOT ${HOST_ABI} STREQUAL "aarch64-apple-ios" AND NOT ${HOST_ABI} STREQUAL "aarch64-apple-iossimulator" AND NOT ${HOST_ABI} STREQUAL "x86_64-apple-iossimulator") @@ -123,6 +126,8 @@ if(${HOST_ABI} STREQUAL "x86_64-apple-darwin11" OR ${HOST_ABI} STREQUAL "aarch64 set(EXPORTED_SYMBOLS_FILE ${CMAKE_CURRENT_SOURCE_DIR}/wownero_libwallet2_api_c.exp) elseif(${MONERO_FLAVOR} STREQUAL "zano") set(EXPORTED_SYMBOLS_FILE ${CMAKE_CURRENT_SOURCE_DIR}/zano_libwallet2_api_c.exp) + elseif(${MONERO_FLAVOR} STREQUAL "salvium") + set(EXPORTED_SYMBOLS_FILE ${CMAKE_CURRENT_SOURCE_DIR}/salvium_libwallet2_api_c.exp) endif() set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -exported_symbols_list ${EXPORTED_SYMBOLS_FILE}") @@ -147,6 +152,8 @@ elseif(${MONERO_FLAVOR} STREQUAL "zano") ${Boost_LIBRARIES} ${OpenSSL_LIBRARIES}) +elseif(${MONERO_FLAVOR} STREQUAL "salvium") + set(WALLET_TARGETS wallet_api ${wallet_api_LIB_DEPENDS}) # wallet_api_LIB_DEPENDS endif() if(${MONERO_FLAVOR} STREQUAL "wownero") diff --git a/salvium_libwallet2_api_c/salvium_libwallet2_api_c.exp b/salvium_libwallet2_api_c/salvium_libwallet2_api_c.exp new file mode 100644 index 0000000..3e0f5b3 --- /dev/null +++ b/salvium_libwallet2_api_c/salvium_libwallet2_api_c.exp @@ -0,0 +1,308 @@ +_SALVIUM_PendingTransaction_status +_SALVIUM_PendingTransaction_errorString +_SALVIUM_PendingTransaction_commit +_SALVIUM_PendingTransaction_commitUR +_SALVIUM_PendingTransaction_amount +_SALVIUM_PendingTransaction_dust +_SALVIUM_PendingTransaction_fee +_SALVIUM_PendingTransaction_txid +_SALVIUM_PendingTransaction_txCount +_SALVIUM_PendingTransaction_subaddrAccount +_SALVIUM_PendingTransaction_subaddrIndices +_SALVIUM_PendingTransaction_multisigSignData +_SALVIUM_PendingTransaction_signMultisigTx +_SALVIUM_PendingTransaction_signersKeys +_SALVIUM_PendingTransaction_hex +_SALVIUM_UnsignedTransaction_status +_SALVIUM_UnsignedTransaction_errorString +_SALVIUM_UnsignedTransaction_amount +_SALVIUM_UnsignedTransaction_fee +_SALVIUM_UnsignedTransaction_mixin +_SALVIUM_UnsignedTransaction_confirmationMessage +_SALVIUM_UnsignedTransaction_paymentId +_SALVIUM_UnsignedTransaction_recipientAddress +_SALVIUM_UnsignedTransaction_minMixinCount +_SALVIUM_UnsignedTransaction_txCount +_SALVIUM_UnsignedTransaction_sign +_SALVIUM_UnsignedTransaction_signUR +_SALVIUM_TransactionInfo_direction +_SALVIUM_TransactionInfo_isPending +_SALVIUM_TransactionInfo_isFailed +_SALVIUM_TransactionInfo_isCoinbase +_SALVIUM_TransactionInfo_amount +_SALVIUM_TransactionInfo_fee +_SALVIUM_TransactionInfo_blockHeight +_SALVIUM_TransactionInfo_description +_SALVIUM_TransactionInfo_subaddrIndex +_SALVIUM_TransactionInfo_subaddrAccount +_SALVIUM_TransactionInfo_label +_SALVIUM_TransactionInfo_confirmations +_SALVIUM_TransactionInfo_unlockTime +_SALVIUM_TransactionInfo_hash +_SALVIUM_TransactionInfo_timestamp +_SALVIUM_TransactionInfo_paymentId +_SALVIUM_TransactionInfo_transfers_count +_SALVIUM_TransactionInfo_transfers_amount +_SALVIUM_TransactionInfo_transfers_address +_SALVIUM_TransactionHistory_count +_SALVIUM_TransactionHistory_transaction +_SALVIUM_TransactionHistory_transactionById +_SALVIUM_TransactionHistory_refresh +_SALVIUM_TransactionHistory_setTxNote +_SALVIUM_AddressBookRow_extra +_SALVIUM_AddressBookRow_getAddress +_SALVIUM_AddressBookRow_getDescription +_SALVIUM_AddressBookRow_getPaymentId +_SALVIUM_AddressBookRow_getRowId +_SALVIUM_AddressBook_getAll_size +_SALVIUM_AddressBook_getAll_byIndex +_SALVIUM_AddressBook_addRow +_SALVIUM_AddressBook_deleteRow +_SALVIUM_AddressBook_setDescription +_SALVIUM_AddressBook_refresh +_SALVIUM_AddressBook_errorString +_SALVIUM_AddressBook_errorCode +_SALVIUM_AddressBook_lookupPaymentID +_SALVIUM_CoinsInfo_blockHeight +_SALVIUM_CoinsInfo_hash +_SALVIUM_CoinsInfo_internalOutputIndex +_SALVIUM_CoinsInfo_globalOutputIndex +_SALVIUM_CoinsInfo_spent +_SALVIUM_CoinsInfo_frozen +_SALVIUM_CoinsInfo_spentHeight +_SALVIUM_CoinsInfo_amount +_SALVIUM_CoinsInfo_rct +_SALVIUM_CoinsInfo_keyImageKnown +_SALVIUM_CoinsInfo_pkIndex +_SALVIUM_CoinsInfo_subaddrIndex +_SALVIUM_CoinsInfo_subaddrAccount +_SALVIUM_CoinsInfo_address +_SALVIUM_CoinsInfo_addressLabel +_SALVIUM_CoinsInfo_keyImage +_SALVIUM_CoinsInfo_unlockTime +_SALVIUM_CoinsInfo_unlocked +_SALVIUM_CoinsInfo_pubKey +_SALVIUM_CoinsInfo_coinbase +_SALVIUM_CoinsInfo_description +_SALVIUM_Coins_count +_SALVIUM_Coins_coin +_SALVIUM_Coins_getAll_size +_SALVIUM_Coins_getAll_byIndex +_SALVIUM_Coins_refresh +_SALVIUM_Coins_setFrozenByPublicKey +_SALVIUM_Coins_setFrozen +_SALVIUM_Coins_thaw +_SALVIUM_Coins_thawByPublicKey +_SALVIUM_Coins_isTransferUnlocked +_SALVIUM_Coins_setDescription +_SALVIUM_SubaddressRow_extra +_SALVIUM_SubaddressRow_getAddress +_SALVIUM_SubaddressRow_getLabel +_SALVIUM_SubaddressRow_getRowId +_SALVIUM_Subaddress_getAll_size +_SALVIUM_Subaddress_getAll_byIndex +_SALVIUM_Subaddress_addRow +_SALVIUM_Subaddress_setLabel +_SALVIUM_Subaddress_refresh +_SALVIUM_SubaddressAccountRow_extra +_SALVIUM_SubaddressAccountRow_getAddress +_SALVIUM_SubaddressAccountRow_getLabel +_SALVIUM_SubaddressAccountRow_getBalance +_SALVIUM_SubaddressAccountRow_getUnlockedBalance +_SALVIUM_SubaddressAccountRow_getRowId +_SALVIUM_SubaddressAccount_getAll_size +_SALVIUM_SubaddressAccount_getAll_byIndex +_SALVIUM_SubaddressAccount_addRow +_SALVIUM_SubaddressAccount_setLabel +_SALVIUM_SubaddressAccount_refresh +_SALVIUM_MultisigState_isMultisig +_SALVIUM_MultisigState_isReady +_SALVIUM_MultisigState_threshold +_SALVIUM_MultisigState_total +_SALVIUM_DeviceProgress_progress +_SALVIUM_DeviceProgress_indeterminate +_SALVIUM_Wallet_seed +_SALVIUM_Wallet_getSeedLanguage +_SALVIUM_Wallet_setSeedLanguage +_SALVIUM_Wallet_status +_SALVIUM_Wallet_errorString +_SALVIUM_Wallet_setPassword +_SALVIUM_Wallet_getPassword +_SALVIUM_Wallet_setDevicePin +_SALVIUM_Wallet_setDevicePassphrase +_SALVIUM_Wallet_address +_SALVIUM_Wallet_path +_SALVIUM_Wallet_nettype +_SALVIUM_Wallet_useForkRules +_SALVIUM_Wallet_integratedAddress +_SALVIUM_Wallet_secretViewKey +_SALVIUM_Wallet_publicViewKey +_SALVIUM_Wallet_secretSpendKey +_SALVIUM_Wallet_publicSpendKey +_SALVIUM_Wallet_publicMultisigSignerKey +_SALVIUM_Wallet_stop +_SALVIUM_Wallet_store +_SALVIUM_Wallet_filename +_SALVIUM_Wallet_keysFilename +_SALVIUM_Wallet_init +_SALVIUM_Wallet_createWatchOnly +_SALVIUM_Wallet_setRefreshFromBlockHeight +_SALVIUM_Wallet_getRefreshFromBlockHeight +_SALVIUM_Wallet_setRecoveringFromSeed +_SALVIUM_Wallet_setRecoveringFromDevice +_SALVIUM_Wallet_setSubaddressLookahead +_SALVIUM_Wallet_connectToDaemon +_SALVIUM_Wallet_connected +_SALVIUM_Wallet_setTrustedDaemon +_SALVIUM_Wallet_trustedDaemon +_SALVIUM_Wallet_setProxy +_SALVIUM_Wallet_balance +_SALVIUM_Wallet_unlockedBalance +_SALVIUM_Wallet_viewOnlyBalance +_SALVIUM_Wallet_watchOnly +_SALVIUM_Wallet_isDeterministic +_SALVIUM_Wallet_blockChainHeight +_SALVIUM_Wallet_approximateBlockChainHeight +_SALVIUM_Wallet_estimateBlockChainHeight +_SALVIUM_Wallet_daemonBlockChainHeight +_SALVIUM_Wallet_daemonBlockChainTargetHeight +_SALVIUM_Wallet_synchronized +_SALVIUM_Wallet_displayAmount +_SALVIUM_Wallet_amountFromString +_SALVIUM_Wallet_amountFromDouble +_SALVIUM_Wallet_genPaymentId +_SALVIUM_Wallet_paymentIdValid +_SALVIUM_Wallet_addressValid +_SALVIUM_Wallet_keyValid +_SALVIUM_Wallet_keyValid_error +_SALVIUM_Wallet_paymentIdFromAddress +_SALVIUM_Wallet_maximumAllowedAmount +_SALVIUM_Wallet_init3 +_SALVIUM_Wallet_getPolyseed +_SALVIUM_Wallet_createPolyseed +_SALVIUM_Wallet_startRefresh +_SALVIUM_Wallet_pauseRefresh +_SALVIUM_Wallet_refresh +_SALVIUM_Wallet_refreshAsync +_SALVIUM_Wallet_rescanBlockchain +_SALVIUM_Wallet_rescanBlockchainAsync +_SALVIUM_Wallet_setAutoRefreshInterval +_SALVIUM_Wallet_autoRefreshInterval +_SALVIUM_Wallet_addSubaddressAccount +_SALVIUM_Wallet_numSubaddressAccounts +_SALVIUM_Wallet_numSubaddresses +_SALVIUM_Wallet_addSubaddress +_SALVIUM_Wallet_getSubaddressLabel +_SALVIUM_Wallet_setSubaddressLabel +_SALVIUM_Wallet_multisig +_SALVIUM_Wallet_getMultisigInfo +_SALVIUM_Wallet_makeMultisig +_SALVIUM_Wallet_exchangeMultisigKeys +_SALVIUM_Wallet_exportMultisigImages +_SALVIUM_Wallet_importMultisigImages +_SALVIUM_Wallet_hasMultisigPartialKeyImages +_SALVIUM_Wallet_restoreMultisigTransaction +_SALVIUM_Wallet_createTransactionMultDest +_SALVIUM_Wallet_createTransaction +_SALVIUM_Wallet_loadUnsignedTx +_SALVIUM_Wallet_loadUnsignedTxUR +_SALVIUM_Wallet_submitTransaction +_SALVIUM_Wallet_submitTransactionUR +_SALVIUM_Wallet_hasUnknownKeyImages +_SALVIUM_Wallet_exportKeyImages +_SALVIUM_Wallet_exportKeyImagesUR +_SALVIUM_Wallet_importKeyImages +_SALVIUM_Wallet_importKeyImagesUR +_SALVIUM_Wallet_exportOutputs +_SALVIUM_Wallet_exportOutputsUR +_SALVIUM_Wallet_importOutputs +_SALVIUM_Wallet_importOutputsUR +_SALVIUM_Wallet_setupBackgroundSync +_SALVIUM_Wallet_getBackgroundSyncType +_SALVIUM_Wallet_startBackgroundSync +_SALVIUM_Wallet_stopBackgroundSync +_SALVIUM_Wallet_isBackgroundSyncing +_SALVIUM_Wallet_isBackgroundWallet +_SALVIUM_Wallet_history +_SALVIUM_Wallet_addressBook +_SALVIUM_Wallet_coins +_SALVIUM_Wallet_subaddress +_SALVIUM_Wallet_subaddressAccount +_SALVIUM_Wallet_defaultMixin +_SALVIUM_Wallet_setDefaultMixin +_SALVIUM_Wallet_setCacheAttribute +_SALVIUM_Wallet_getCacheAttribute +_SALVIUM_Wallet_setUserNote +_SALVIUM_Wallet_getUserNote +_SALVIUM_Wallet_getTxKey +_SALVIUM_Wallet_signMessage +_SALVIUM_Wallet_verifySignedMessage +_SALVIUM_Wallet_rescanSpent +_SALVIUM_Wallet_setOffline +_SALVIUM_Wallet_isOffline +_SALVIUM_Wallet_segregatePreForkOutputs +_SALVIUM_Wallet_segregationHeight +_SALVIUM_Wallet_keyReuseMitigation2 +_SALVIUM_Wallet_lockKeysFile +_SALVIUM_Wallet_unlockKeysFile +_SALVIUM_Wallet_isKeysFileLocked +_SALVIUM_Wallet_getDeviceType +_SALVIUM_Wallet_coldKeyImageSync +_SALVIUM_Wallet_deviceShowAddress +_SALVIUM_Wallet_reconnectDevice +_SALVIUM_Wallet_getBytesReceived +_SALVIUM_Wallet_getBytesSent +_SALVIUM_Wallet_getStateIsConnected +_SALVIUM_Wallet_getSendToDevice +_SALVIUM_Wallet_getSendToDeviceLength +_SALVIUM_Wallet_getReceivedFromDevice +_SALVIUM_Wallet_getReceivedFromDeviceLength +_SALVIUM_Wallet_getWaitsForDeviceSend +_SALVIUM_Wallet_getWaitsForDeviceReceive +_SALVIUM_Wallet_setDeviceReceivedData +_SALVIUM_Wallet_setDeviceSendData +_SALVIUM_WalletManager_createWallet +_SALVIUM_WalletManager_openWallet +_SALVIUM_WalletManager_recoveryWallet +_SALVIUM_WalletManager_createWalletFromKeys +_SALVIUM_WalletManager_createDeterministicWalletFromSpendKey +_SALVIUM_WalletManager_createWalletFromDevice +_SALVIUM_WalletManager_createWalletFromPolyseed +_SALVIUM_WalletManager_closeWallet +_SALVIUM_WalletManager_walletExists +_SALVIUM_WalletManager_verifyWalletPassword +_SALVIUM_WalletManager_queryWalletDevice +_SALVIUM_WalletManager_findWallets +_SALVIUM_WalletManager_errorString +_SALVIUM_WalletManager_setDaemonAddress +_SALVIUM_WalletManager_blockchainHeight +_SALVIUM_WalletManager_blockchainTargetHeight +_SALVIUM_WalletManager_networkDifficulty +_SALVIUM_WalletManager_miningHashRate +_SALVIUM_WalletManager_blockTarget +_SALVIUM_WalletManager_isMining +_SALVIUM_WalletManager_startMining +_SALVIUM_WalletManager_stopMining +_SALVIUM_WalletManager_resolveOpenAlias +_SALVIUM_WalletManager_setProxy +_SALVIUM_WalletManagerFactory_getWalletManager +_SALVIUM_WalletManagerFactory_setLogLevel +_SALVIUM_WalletManagerFactory_setLogCategories +_SALVIUM_DEBUG_test0 +_SALVIUM_DEBUG_test1 +_SALVIUM_DEBUG_test2 +_SALVIUM_DEBUG_test3 +_SALVIUM_DEBUG_test4 +_SALVIUM_DEBUG_test5 +_SALVIUM_DEBUG_test5_std +_SALVIUM_DEBUG_isPointerNull +_SALVIUM_cw_getWalletListener +_SALVIUM_cw_WalletListener_resetNeedToRefresh +_SALVIUM_cw_WalletListener_isNeedToRefresh +_SALVIUM_cw_WalletListener_isNewTransactionExist +_SALVIUM_cw_WalletListener_resetIsNewTransactionExist +_SALVIUM_cw_WalletListener_height +_SALVIUM_free +_SALVIUM_checksum_wallet2_api_c_h +_SALVIUM_checksum_wallet2_api_c_cpp +_SALVIUM_checksum_wallet2_api_c_exp diff --git a/salvium_libwallet2_api_c/src/main/cpp/salvium_checksum.h b/salvium_libwallet2_api_c/src/main/cpp/salvium_checksum.h new file mode 100644 index 0000000..e4994fb --- /dev/null +++ b/salvium_libwallet2_api_c/src/main/cpp/salvium_checksum.h @@ -0,0 +1,6 @@ +#ifndef SALVIUMC_CHECKSUMS +#define SALVIUMC_CHECKSUMS +const char * SALVIUM_wallet2_api_c_h_sha256 = "9e80c4b59a0509aa02fbf01e8df2881b89f82225d1765bfa7856cbdbaf7af116"; +const char * SALVIUM_wallet2_api_c_cpp_sha256 = "d229507db508e574bd2badf4819a38dbead8c16a84311ad32c22c887a6003439-0232839913b13cf0ab0bb7ad25fff0c05f37d2fe"; +const char * SALVIUM_wallet2_api_c_exp_sha256 = "d0f95f1f3bc49f1f59fe4eb0b61826128d7d3bb75405d5a01a252d02db03097d"; +#endif diff --git a/salvium_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp b/salvium_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp index 19192cf..d8dbbcc 100644 --- a/salvium_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp +++ b/salvium_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp @@ -4,8 +4,8 @@ #include "helpers.hpp" #include #include -#include "../../../../monero/src/wallet/api/wallet2_api.h" -#include "monero_checksum.h" +#include "../../../../salvium/src/wallet/api/wallet2_api.h" +#include "salvium_checksum.h" #ifdef __cplusplus extern "C" @@ -23,13 +23,13 @@ extern "C" // a if statement - which in general I consider an anti-patter in just wrappers // // _____________ void* because C++ wallet->createTransaction returns a pointer to Monero::PendingTransaction, which we don't want to have exposed in C land -// / _____________ MONERO prefix just means that this function is using monero codebase, to not cause any symbols collision when using more than one libwallet2_api_c.so in a single program. +// / _____________ SALVIUM prefix just means that this function is using salvium codebase, to not cause any symbols collision when using more than one libwallet2_api_c.so in a single program. // | / _____________ Wallet is one of the classes in Monero namespace in the upstream codebase (see the include line above) // | | / _____________ aaand it is calling createTransaction function. // | | | / _________________________________________________________________________________ // | | | | / \ All of these parameters can be found in the upstream // | | | | | _____________/ function definition, if something was more complex - -// void* MONERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id, / like std::set I've used splitString functions and introduced a new +// void* SALVIUM_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id, / like std::set I've used splitString functions and introduced a new // uint64_t amount, uint32_t mixin_count, / parameter - separator, as it is the simplest way to get vector onto // int pendingTransactionPriority, / C side from more advanced world. // uint32_t subaddr_account, / @@ -49,7 +49,7 @@ extern "C" // // // One case which is not covered here is when we have to return a string -// const char* MONERO_PendingTransaction_errorString(void* pendingTx_ptr) { +// const char* SALVIUM_PendingTransaction_errorString(void* pendingTx_ptr) { // Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); // std::string str = pendingTx->errorString(); <------------- get the actual string from the upstream codebase // const std::string::size_type size = str.size(); ------------------------------\ @@ -62,13 +62,13 @@ extern "C" // PendingTransaction -int MONERO_PendingTransaction_status(void* pendingTx_ptr) { +int SALVIUM_PendingTransaction_status(void* pendingTx_ptr) { DEBUG_START() Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); return pendingTx->status(); DEBUG_END() } -const char* MONERO_PendingTransaction_errorString(void* pendingTx_ptr) { +const char* SALVIUM_PendingTransaction_errorString(void* pendingTx_ptr) { DEBUG_START() Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); std::string str = pendingTx->errorString(); @@ -78,13 +78,13 @@ const char* MONERO_PendingTransaction_errorString(void* pendingTx_ptr) { return buffer; DEBUG_END() } -bool MONERO_PendingTransaction_commit(void* pendingTx_ptr, const char* filename, bool overwrite) { +bool SALVIUM_PendingTransaction_commit(void* pendingTx_ptr, const char* filename, bool overwrite) { DEBUG_START() Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); return pendingTx->commit(std::string(filename), overwrite); DEBUG_END() } -const char* MONERO_PendingTransaction_commitUR(void* pendingTx_ptr, int max_fragment_length) { +const char* SALVIUM_PendingTransaction_commitUR(void* pendingTx_ptr, int max_fragment_length) { DEBUG_START() Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); std::string str = pendingTx->commitUR(max_fragment_length); @@ -94,52 +94,52 @@ const char* MONERO_PendingTransaction_commitUR(void* pendingTx_ptr, int max_frag return buffer; DEBUG_END() } -uint64_t MONERO_PendingTransaction_amount(void* pendingTx_ptr) { +uint64_t SALVIUM_PendingTransaction_amount(void* pendingTx_ptr) { DEBUG_START() Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); return pendingTx->amount(); DEBUG_END() } -uint64_t MONERO_PendingTransaction_dust(void* pendingTx_ptr) { +uint64_t SALVIUM_PendingTransaction_dust(void* pendingTx_ptr) { DEBUG_START() Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); return pendingTx->dust(); DEBUG_END() } -uint64_t MONERO_PendingTransaction_fee(void* pendingTx_ptr) { +uint64_t SALVIUM_PendingTransaction_fee(void* pendingTx_ptr) { DEBUG_START() Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); return pendingTx->fee(); DEBUG_END() } -const char* MONERO_PendingTransaction_txid(void* pendingTx_ptr, const char* separator) { +const char* SALVIUM_PendingTransaction_txid(void* pendingTx_ptr, const char* separator) { DEBUG_START() Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); std::vector txid = pendingTx->txid(); return vectorToString(txid, std::string(separator)); DEBUG_END() } -uint64_t MONERO_PendingTransaction_txCount(void* pendingTx_ptr) { +uint64_t SALVIUM_PendingTransaction_txCount(void* pendingTx_ptr) { DEBUG_START() Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); return pendingTx->txCount(); DEBUG_END() } -const char* MONERO_PendingTransaction_subaddrAccount(void* pendingTx_ptr, const char* separator) { +const char* SALVIUM_PendingTransaction_subaddrAccount(void* pendingTx_ptr, const char* separator) { DEBUG_START() Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); std::vector subaddrAccount = pendingTx->subaddrAccount(); return vectorToString(subaddrAccount, std::string(separator)); DEBUG_END() } -const char* MONERO_PendingTransaction_subaddrIndices(void* pendingTx_ptr, const char* separator) { +const char* SALVIUM_PendingTransaction_subaddrIndices(void* pendingTx_ptr, const char* separator) { DEBUG_START() Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); std::vector> subaddrIndices = pendingTx->subaddrIndices(); return vectorToString(subaddrIndices, std::string(separator)); DEBUG_END() } -const char* MONERO_PendingTransaction_multisigSignData(void* pendingTx_ptr) { +const char* SALVIUM_PendingTransaction_multisigSignData(void* pendingTx_ptr) { DEBUG_START() Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); std::string str = pendingTx->multisigSignData(); @@ -149,13 +149,13 @@ const char* MONERO_PendingTransaction_multisigSignData(void* pendingTx_ptr) { return buffer; DEBUG_END() } -void MONERO_PendingTransaction_signMultisigTx(void* pendingTx_ptr) { +void SALVIUM_PendingTransaction_signMultisigTx(void* pendingTx_ptr) { DEBUG_START() Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); return pendingTx->signMultisigTx(); DEBUG_END() } -const char* MONERO_PendingTransaction_signersKeys(void* pendingTx_ptr, const char* separator) { +const char* SALVIUM_PendingTransaction_signersKeys(void* pendingTx_ptr, const char* separator) { DEBUG_START() Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); std::vector txid = pendingTx->signersKeys(); @@ -163,7 +163,7 @@ const char* MONERO_PendingTransaction_signersKeys(void* pendingTx_ptr, const cha DEBUG_END() } -const char* MONERO_PendingTransaction_hex(void* pendingTx_ptr, const char* separator) { +const char* SALVIUM_PendingTransaction_hex(void* pendingTx_ptr, const char* separator) { DEBUG_START() Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); std::vector txid = pendingTx->hex(); @@ -171,7 +171,7 @@ const char* MONERO_PendingTransaction_hex(void* pendingTx_ptr, const char* separ DEBUG_END() } -const char* MONERO_PendingTransaction_txKey(void* pendingTx_ptr, const char* separator) { +const char* SALVIUM_PendingTransaction_txKey(void* pendingTx_ptr, const char* separator) { DEBUG_START() Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); std::vector txid = pendingTx->txKey(); @@ -181,13 +181,13 @@ const char* MONERO_PendingTransaction_txKey(void* pendingTx_ptr, const char* sep // UnsignedTransaction -int MONERO_UnsignedTransaction_status(void* unsignedTx_ptr) { +int SALVIUM_UnsignedTransaction_status(void* unsignedTx_ptr) { DEBUG_START() Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); return unsignedTx->status(); DEBUG_END() } -const char* MONERO_UnsignedTransaction_errorString(void* unsignedTx_ptr) { +const char* SALVIUM_UnsignedTransaction_errorString(void* unsignedTx_ptr) { DEBUG_START() Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); std::string str = unsignedTx->errorString(); @@ -197,25 +197,25 @@ const char* MONERO_UnsignedTransaction_errorString(void* unsignedTx_ptr) { return buffer; DEBUG_END() } -const char* MONERO_UnsignedTransaction_amount(void* unsignedTx_ptr, const char* separator) { +const char* SALVIUM_UnsignedTransaction_amount(void* unsignedTx_ptr, const char* separator) { DEBUG_START() Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); return vectorToString(unsignedTx->amount(), std::string(separator)); DEBUG_END() } -const char* MONERO_UnsignedTransaction_fee(void* unsignedTx_ptr, const char* separator) { +const char* SALVIUM_UnsignedTransaction_fee(void* unsignedTx_ptr, const char* separator) { DEBUG_START() Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); return vectorToString(unsignedTx->fee(), std::string(separator)); DEBUG_END() } -const char* MONERO_UnsignedTransaction_mixin(void* unsignedTx_ptr, const char* separator) { +const char* SALVIUM_UnsignedTransaction_mixin(void* unsignedTx_ptr, const char* separator) { DEBUG_START() Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); return vectorToString(unsignedTx->mixin(), std::string(separator)); DEBUG_END() } -const char* MONERO_UnsignedTransaction_confirmationMessage(void* unsignedTx_ptr) { +const char* SALVIUM_UnsignedTransaction_confirmationMessage(void* unsignedTx_ptr) { DEBUG_START() Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); std::string str = unsignedTx->confirmationMessage(); @@ -225,37 +225,37 @@ const char* MONERO_UnsignedTransaction_confirmationMessage(void* unsignedTx_ptr) return buffer; DEBUG_END() } -const char* MONERO_UnsignedTransaction_paymentId(void* unsignedTx_ptr, const char* separator) { +const char* SALVIUM_UnsignedTransaction_paymentId(void* unsignedTx_ptr, const char* separator) { DEBUG_START() Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); return vectorToString(unsignedTx->paymentId(), std::string(separator)); DEBUG_END() } -const char* MONERO_UnsignedTransaction_recipientAddress(void* unsignedTx_ptr, const char* separator) { +const char* SALVIUM_UnsignedTransaction_recipientAddress(void* unsignedTx_ptr, const char* separator) { DEBUG_START() Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); return vectorToString(unsignedTx->recipientAddress(), std::string(separator)); DEBUG_END() } -uint64_t MONERO_UnsignedTransaction_minMixinCount(void* unsignedTx_ptr) { +uint64_t SALVIUM_UnsignedTransaction_minMixinCount(void* unsignedTx_ptr) { DEBUG_START() Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); return unsignedTx->minMixinCount(); DEBUG_END() } -uint64_t MONERO_UnsignedTransaction_txCount(void* unsignedTx_ptr) { +uint64_t SALVIUM_UnsignedTransaction_txCount(void* unsignedTx_ptr) { DEBUG_START() Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); return unsignedTx->txCount(); DEBUG_END() } -bool MONERO_UnsignedTransaction_sign(void* unsignedTx_ptr, const char* signedFileName) { +bool SALVIUM_UnsignedTransaction_sign(void* unsignedTx_ptr, const char* signedFileName) { DEBUG_START() Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); return unsignedTx->sign(std::string(signedFileName)); DEBUG_END() } -const char* MONERO_UnsignedTransaction_signUR(void* unsignedTx_ptr, int max_fragment_length) { +const char* SALVIUM_UnsignedTransaction_signUR(void* unsignedTx_ptr, int max_fragment_length) { DEBUG_START() Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); std::string str = unsignedTx->signUR(max_fragment_length); @@ -266,49 +266,49 @@ const char* MONERO_UnsignedTransaction_signUR(void* unsignedTx_ptr, int max_frag DEBUG_END() } // TransactionInfo -int MONERO_TransactionInfo_direction(void* txInfo_ptr) { +int SALVIUM_TransactionInfo_direction(void* txInfo_ptr) { DEBUG_START() Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); return txInfo->direction(); DEBUG_END() } -bool MONERO_TransactionInfo_isPending(void* txInfo_ptr) { +bool SALVIUM_TransactionInfo_isPending(void* txInfo_ptr) { DEBUG_START() Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); return txInfo->isPending(); DEBUG_END() } -bool MONERO_TransactionInfo_isFailed(void* txInfo_ptr) { +bool SALVIUM_TransactionInfo_isFailed(void* txInfo_ptr) { DEBUG_START() Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); return txInfo->isFailed(); DEBUG_END() } -bool MONERO_TransactionInfo_isCoinbase(void* txInfo_ptr) { +bool SALVIUM_TransactionInfo_isCoinbase(void* txInfo_ptr) { DEBUG_START() Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); return txInfo->isCoinbase(); DEBUG_END() } -uint64_t MONERO_TransactionInfo_amount(void* txInfo_ptr) { +uint64_t SALVIUM_TransactionInfo_amount(void* txInfo_ptr) { DEBUG_START() Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); return txInfo->amount(); DEBUG_END() } -uint64_t MONERO_TransactionInfo_fee(void* txInfo_ptr) { +uint64_t SALVIUM_TransactionInfo_fee(void* txInfo_ptr) { DEBUG_START() Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); return txInfo->fee(); DEBUG_END() } -uint64_t MONERO_TransactionInfo_blockHeight(void* txInfo_ptr) { +uint64_t SALVIUM_TransactionInfo_blockHeight(void* txInfo_ptr) { DEBUG_START() Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); return txInfo->blockHeight(); DEBUG_END() } -const char* MONERO_TransactionInfo_description(void* txInfo_ptr) { +const char* SALVIUM_TransactionInfo_description(void* txInfo_ptr) { DEBUG_START() Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); std::string str = txInfo->description(); @@ -318,20 +318,20 @@ const char* MONERO_TransactionInfo_description(void* txInfo_ptr) { return buffer; DEBUG_END() } -const char* MONERO_TransactionInfo_subaddrIndex(void* txInfo_ptr, const char* separator) { +const char* SALVIUM_TransactionInfo_subaddrIndex(void* txInfo_ptr, const char* separator) { DEBUG_START() Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); std::set subaddrIndex = txInfo->subaddrIndex(); return vectorToString(subaddrIndex, std::string(separator)); DEBUG_END() } -uint32_t MONERO_TransactionInfo_subaddrAccount(void* txInfo_ptr) { +uint32_t SALVIUM_TransactionInfo_subaddrAccount(void* txInfo_ptr) { DEBUG_START() Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); return txInfo->subaddrAccount(); DEBUG_END() } -const char* MONERO_TransactionInfo_label(void* txInfo_ptr) { +const char* SALVIUM_TransactionInfo_label(void* txInfo_ptr) { DEBUG_START() Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); std::string str = txInfo->label(); @@ -341,19 +341,19 @@ const char* MONERO_TransactionInfo_label(void* txInfo_ptr) { return buffer; DEBUG_END() } -uint64_t MONERO_TransactionInfo_confirmations(void* txInfo_ptr) { +uint64_t SALVIUM_TransactionInfo_confirmations(void* txInfo_ptr) { DEBUG_START() Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); return txInfo->confirmations(); DEBUG_END() } -uint64_t MONERO_TransactionInfo_unlockTime(void* txInfo_ptr) { +uint64_t SALVIUM_TransactionInfo_unlockTime(void* txInfo_ptr) { DEBUG_START() Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); return txInfo->unlockTime(); DEBUG_END() } -const char* MONERO_TransactionInfo_hash(void* txInfo_ptr) { +const char* SALVIUM_TransactionInfo_hash(void* txInfo_ptr) { DEBUG_START() Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); std::string str = txInfo->hash(); @@ -363,13 +363,13 @@ const char* MONERO_TransactionInfo_hash(void* txInfo_ptr) { return buffer; DEBUG_END() } -uint64_t MONERO_TransactionInfo_timestamp(void* txInfo_ptr) { +uint64_t SALVIUM_TransactionInfo_timestamp(void* txInfo_ptr) { DEBUG_START() Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); return txInfo->timestamp(); DEBUG_END() } -const char* MONERO_TransactionInfo_paymentId(void* txInfo_ptr) { +const char* SALVIUM_TransactionInfo_paymentId(void* txInfo_ptr) { DEBUG_START() Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); std::string str = txInfo->paymentId(); @@ -380,21 +380,21 @@ const char* MONERO_TransactionInfo_paymentId(void* txInfo_ptr) { DEBUG_END() } -int MONERO_TransactionInfo_transfers_count(void* txInfo_ptr) { +int SALVIUM_TransactionInfo_transfers_count(void* txInfo_ptr) { DEBUG_START() Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); return txInfo->transfers().size(); DEBUG_END() } -uint64_t MONERO_TransactionInfo_transfers_amount(void* txInfo_ptr, int index) { +uint64_t SALVIUM_TransactionInfo_transfers_amount(void* txInfo_ptr, int index) { DEBUG_START() Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); return txInfo->transfers()[index].amount; DEBUG_END() } -const char* MONERO_TransactionInfo_transfers_address(void* txInfo_ptr, int index) { +const char* SALVIUM_TransactionInfo_transfers_address(void* txInfo_ptr, int index) { DEBUG_START() Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); std::string str = txInfo->transfers()[index].address; @@ -409,32 +409,32 @@ const char* MONERO_TransactionInfo_transfers_address(void* txInfo_ptr, int index // TransactionHistory -int MONERO_TransactionHistory_count(void* txHistory_ptr) { +int SALVIUM_TransactionHistory_count(void* txHistory_ptr) { DEBUG_START() Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); return txHistory->count(); DEBUG_END() } -void* MONERO_TransactionHistory_transaction(void* txHistory_ptr, int index) { +void* SALVIUM_TransactionHistory_transaction(void* txHistory_ptr, int index) { DEBUG_START() Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); return reinterpret_cast(txHistory->transaction(index)); DEBUG_END() } -void* MONERO_TransactionHistory_transactionById(void* txHistory_ptr, const char* id) { +void* SALVIUM_TransactionHistory_transactionById(void* txHistory_ptr, const char* id) { DEBUG_START() Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); return reinterpret_cast(txHistory->transaction(std::string(id))); DEBUG_END() } -void MONERO_TransactionHistory_refresh(void* txHistory_ptr) { +void SALVIUM_TransactionHistory_refresh(void* txHistory_ptr) { DEBUG_START() Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); return txHistory->refresh(); DEBUG_END() } -void MONERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, const char* note) { +void SALVIUM_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, const char* note) { DEBUG_START() Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); return txHistory->setTxNote(std::string(txid), std::string(note)); @@ -444,7 +444,7 @@ void MONERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, // AddressBokRow // std::string extra; -const char* MONERO_AddressBookRow_extra(void* addressBookRow_ptr) { +const char* SALVIUM_AddressBookRow_extra(void* addressBookRow_ptr) { DEBUG_START() Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); std::string str = addressBookRow->extra; @@ -455,7 +455,7 @@ const char* MONERO_AddressBookRow_extra(void* addressBookRow_ptr) { DEBUG_END() } // std::string getAddress() const {return m_address;} -const char* MONERO_AddressBookRow_getAddress(void* addressBookRow_ptr) { +const char* SALVIUM_AddressBookRow_getAddress(void* addressBookRow_ptr) { DEBUG_START() Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); std::string str = addressBookRow->getAddress(); @@ -466,7 +466,7 @@ const char* MONERO_AddressBookRow_getAddress(void* addressBookRow_ptr) { DEBUG_END() } // std::string getDescription() const {return m_description;} -const char* MONERO_AddressBookRow_getDescription(void* addressBookRow_ptr) { +const char* SALVIUM_AddressBookRow_getDescription(void* addressBookRow_ptr) { DEBUG_START() Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); std::string str = addressBookRow->getDescription(); @@ -477,7 +477,7 @@ const char* MONERO_AddressBookRow_getDescription(void* addressBookRow_ptr) { DEBUG_END() } // std::string getPaymentId() const {return m_paymentId;} -const char* MONERO_AddressBookRow_getPaymentId(void* addressBookRow_ptr) { +const char* SALVIUM_AddressBookRow_getPaymentId(void* addressBookRow_ptr) { DEBUG_START() Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); std::string str = addressBookRow->getPaymentId(); @@ -488,7 +488,7 @@ const char* MONERO_AddressBookRow_getPaymentId(void* addressBookRow_ptr) { DEBUG_END() } // std::size_t getRowId() const {return m_rowId;} -size_t MONERO_AddressBookRow_getRowId(void* addressBookRow_ptr) { +size_t SALVIUM_AddressBookRow_getRowId(void* addressBookRow_ptr) { DEBUG_START() Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); return addressBookRow->getRowId(); @@ -497,48 +497,48 @@ size_t MONERO_AddressBookRow_getRowId(void* addressBookRow_ptr) { // AddressBook // virtual std::vector getAll() const = 0; -int MONERO_AddressBook_getAll_size(void* addressBook_ptr) { +int SALVIUM_AddressBook_getAll_size(void* addressBook_ptr) { DEBUG_START() Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); return addressBook->getAll().size(); DEBUG_END() } -void* MONERO_AddressBook_getAll_byIndex(void* addressBook_ptr, int index) { +void* SALVIUM_AddressBook_getAll_byIndex(void* addressBook_ptr, int index) { DEBUG_START() Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); return addressBook->getAll()[index]; DEBUG_END() } // 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) { +bool SALVIUM_AddressBook_addRow(void* addressBook_ptr, const char* dst_addr , const char* payment_id, const char* description) { DEBUG_START() Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); return addressBook->addRow(std::string(dst_addr), std::string(payment_id), std::string(description)); DEBUG_END() } // virtual bool deleteRow(std::size_t rowId) = 0; -bool MONERO_AddressBook_deleteRow(void* addressBook_ptr, size_t rowId) { +bool SALVIUM_AddressBook_deleteRow(void* addressBook_ptr, size_t rowId) { DEBUG_START() Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); return addressBook->deleteRow(rowId); DEBUG_END() } // 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) { +bool SALVIUM_AddressBook_setDescription(void* addressBook_ptr, size_t rowId, const char* description) { DEBUG_START() Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); return addressBook->setDescription(rowId, std::string(description)); DEBUG_END() } // virtual void refresh() = 0; -void MONERO_AddressBook_refresh(void* addressBook_ptr) { +void SALVIUM_AddressBook_refresh(void* addressBook_ptr) { DEBUG_START() Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); return addressBook->refresh(); DEBUG_END() } // virtual std::string errorString() const = 0; -const char* MONERO_AddressBook_errorString(void* addressBook_ptr) { +const char* SALVIUM_AddressBook_errorString(void* addressBook_ptr) { DEBUG_START() Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); std::string str = addressBook->errorString(); @@ -549,14 +549,14 @@ const char* MONERO_AddressBook_errorString(void* addressBook_ptr) { DEBUG_END() } // virtual int errorCode() const = 0; -int MONERO_AddressBook_errorCode(void* addressBook_ptr) { +int SALVIUM_AddressBook_errorCode(void* addressBook_ptr) { DEBUG_START() Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); return addressBook->errorCode(); DEBUG_END() } // virtual int lookupPaymentID(const std::string &payment_id) const = 0; -int MONERO_AddressBook_lookupPaymentID(void* addressBook_ptr, const char* payment_id) { +int SALVIUM_AddressBook_lookupPaymentID(void* addressBook_ptr, const char* payment_id) { DEBUG_START() Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); return addressBook->lookupPaymentID(std::string(payment_id)); @@ -564,14 +564,14 @@ int MONERO_AddressBook_lookupPaymentID(void* addressBook_ptr, const char* paymen } // CoinsInfo -uint64_t MONERO_CoinsInfo_blockHeight(void* coinsInfo_ptr) { +uint64_t SALVIUM_CoinsInfo_blockHeight(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); return coinsInfo->blockHeight(); DEBUG_END() } // virtual std::string hash() const = 0; -const char* MONERO_CoinsInfo_hash(void* coinsInfo_ptr) { +const char* SALVIUM_CoinsInfo_hash(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); std::string str = coinsInfo->hash(); @@ -582,84 +582,84 @@ const char* MONERO_CoinsInfo_hash(void* coinsInfo_ptr) { DEBUG_END() } // virtual size_t internalOutputIndex() const = 0; -size_t MONERO_CoinsInfo_internalOutputIndex(void* coinsInfo_ptr) { +size_t SALVIUM_CoinsInfo_internalOutputIndex(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); return coinsInfo->internalOutputIndex(); DEBUG_END() } // virtual uint64_t globalOutputIndex() const = 0; -uint64_t MONERO_CoinsInfo_globalOutputIndex(void* coinsInfo_ptr) { +uint64_t SALVIUM_CoinsInfo_globalOutputIndex(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); return coinsInfo->globalOutputIndex(); DEBUG_END() } // virtual bool spent() const = 0; -bool MONERO_CoinsInfo_spent(void* coinsInfo_ptr) { +bool SALVIUM_CoinsInfo_spent(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); return coinsInfo->spent(); DEBUG_END() } // virtual bool frozen() const = 0; -bool MONERO_CoinsInfo_frozen(void* coinsInfo_ptr) { +bool SALVIUM_CoinsInfo_frozen(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); return coinsInfo->frozen(); DEBUG_END() } // virtual uint64_t spentHeight() const = 0; -uint64_t MONERO_CoinsInfo_spentHeight(void* coinsInfo_ptr) { +uint64_t SALVIUM_CoinsInfo_spentHeight(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); return coinsInfo->spentHeight(); DEBUG_END() } // virtual uint64_t amount() const = 0; -uint64_t MONERO_CoinsInfo_amount(void* coinsInfo_ptr) { +uint64_t SALVIUM_CoinsInfo_amount(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); return coinsInfo->amount(); DEBUG_END() } // virtual bool rct() const = 0; -bool MONERO_CoinsInfo_rct(void* coinsInfo_ptr) { +bool SALVIUM_CoinsInfo_rct(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); return coinsInfo->rct(); DEBUG_END() } // virtual bool keyImageKnown() const = 0; -bool MONERO_CoinsInfo_keyImageKnown(void* coinsInfo_ptr) { +bool SALVIUM_CoinsInfo_keyImageKnown(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); return coinsInfo->keyImageKnown(); DEBUG_END() } // virtual size_t pkIndex() const = 0; -size_t MONERO_CoinsInfo_pkIndex(void* coinsInfo_ptr) { +size_t SALVIUM_CoinsInfo_pkIndex(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); return coinsInfo->pkIndex(); DEBUG_END() } // virtual uint32_t subaddrIndex() const = 0; -uint32_t MONERO_CoinsInfo_subaddrIndex(void* coinsInfo_ptr) { +uint32_t SALVIUM_CoinsInfo_subaddrIndex(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); return coinsInfo->subaddrIndex(); DEBUG_END() } // virtual uint32_t subaddrAccount() const = 0; -uint32_t MONERO_CoinsInfo_subaddrAccount(void* coinsInfo_ptr) { +uint32_t SALVIUM_CoinsInfo_subaddrAccount(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); return coinsInfo->subaddrAccount(); DEBUG_END() } // virtual std::string address() const = 0; -const char* MONERO_CoinsInfo_address(void* coinsInfo_ptr) { +const char* SALVIUM_CoinsInfo_address(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); std::string str = coinsInfo->address(); @@ -670,7 +670,7 @@ const char* MONERO_CoinsInfo_address(void* coinsInfo_ptr) { DEBUG_END() } // virtual std::string addressLabel() const = 0; -const char* MONERO_CoinsInfo_addressLabel(void* coinsInfo_ptr) { +const char* SALVIUM_CoinsInfo_addressLabel(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); std::string str = coinsInfo->addressLabel(); @@ -681,7 +681,7 @@ const char* MONERO_CoinsInfo_addressLabel(void* coinsInfo_ptr) { DEBUG_END() } // virtual std::string keyImage() const = 0; -const char* MONERO_CoinsInfo_keyImage(void* coinsInfo_ptr) { +const char* SALVIUM_CoinsInfo_keyImage(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); std::string str = coinsInfo->keyImage(); @@ -692,21 +692,21 @@ const char* MONERO_CoinsInfo_keyImage(void* coinsInfo_ptr) { DEBUG_END() } // virtual uint64_t unlockTime() const = 0; -uint64_t MONERO_CoinsInfo_unlockTime(void* coinsInfo_ptr) { +uint64_t SALVIUM_CoinsInfo_unlockTime(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); return coinsInfo->unlockTime(); DEBUG_END() } // virtual bool unlocked() const = 0; -bool MONERO_CoinsInfo_unlocked(void* coinsInfo_ptr) { +bool SALVIUM_CoinsInfo_unlocked(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); return coinsInfo->unlocked(); DEBUG_END() } // virtual std::string pubKey() const = 0; -const char* MONERO_CoinsInfo_pubKey(void* coinsInfo_ptr) { +const char* SALVIUM_CoinsInfo_pubKey(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); std::string str = coinsInfo->pubKey(); @@ -717,14 +717,14 @@ const char* MONERO_CoinsInfo_pubKey(void* coinsInfo_ptr) { DEBUG_END() } // virtual bool coinbase() const = 0; -bool MONERO_CoinsInfo_coinbase(void* coinsInfo_ptr) { +bool SALVIUM_CoinsInfo_coinbase(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); return coinsInfo->coinbase(); DEBUG_END() } // virtual std::string description() const = 0; -const char* MONERO_CoinsInfo_description(void* coinsInfo_ptr) { +const char* SALVIUM_CoinsInfo_description(void* coinsInfo_ptr) { DEBUG_START() Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); std::string str = coinsInfo->description(); @@ -740,27 +740,27 @@ const char* MONERO_CoinsInfo_description(void* coinsInfo_ptr) { // virtual ~Coins() = 0; // virtual int count() const = 0; -int MONERO_Coins_count(void* coins_ptr) { +int SALVIUM_Coins_count(void* coins_ptr) { DEBUG_START() Monero::Coins *coins = reinterpret_cast(coins_ptr); return coins->count(); DEBUG_END() } // virtual CoinsInfo * coin(int index) const = 0; -void* MONERO_Coins_coin(void* coins_ptr, int index) { +void* SALVIUM_Coins_coin(void* coins_ptr, int index) { DEBUG_START() Monero::Coins *coins = reinterpret_cast(coins_ptr); return coins->coin(index); DEBUG_END() } -int MONERO_Coins_getAll_size(void* coins_ptr) { +int SALVIUM_Coins_getAll_size(void* coins_ptr) { DEBUG_START() Monero::Coins *coins = reinterpret_cast(coins_ptr); return coins->getAll().size(); DEBUG_END() } -void* MONERO_Coins_getAll_byIndex(void* coins_ptr, int index) { +void* SALVIUM_Coins_getAll_byIndex(void* coins_ptr, int index) { DEBUG_START() Monero::Coins *coins = reinterpret_cast(coins_ptr); return coins->getAll()[index]; @@ -769,49 +769,49 @@ void* MONERO_Coins_getAll_byIndex(void* coins_ptr, int index) { // virtual std::vector getAll() const = 0; // virtual void refresh() = 0; -void MONERO_Coins_refresh(void* coins_ptr) { +void SALVIUM_Coins_refresh(void* coins_ptr) { DEBUG_START() Monero::Coins *coins = reinterpret_cast(coins_ptr); return coins->refresh(); DEBUG_END() } // virtual void setFrozen(std::string public_key) = 0; -void MONERO_Coins_setFrozenByPublicKey(void* coins_ptr, const char* public_key) { +void SALVIUM_Coins_setFrozenByPublicKey(void* coins_ptr, const char* public_key) { DEBUG_START() Monero::Coins *coins = reinterpret_cast(coins_ptr); return coins->setFrozen(std::string(public_key)); DEBUG_END() } // virtual void setFrozen(int index) = 0; -void MONERO_Coins_setFrozen(void* coins_ptr, int index) { +void SALVIUM_Coins_setFrozen(void* coins_ptr, int index) { DEBUG_START() Monero::Coins *coins = reinterpret_cast(coins_ptr); return coins->setFrozen(index); DEBUG_END() } // virtual void thaw(int index) = 0; -void MONERO_Coins_thaw(void* coins_ptr, int index) { +void SALVIUM_Coins_thaw(void* coins_ptr, int index) { DEBUG_START() Monero::Coins *coins = reinterpret_cast(coins_ptr); return coins->thaw(index); DEBUG_END() } // virtual void thaw(std::string public_key) = 0; -void MONERO_Coins_thawByPublicKey(void* coins_ptr, const char* public_key) { +void SALVIUM_Coins_thawByPublicKey(void* coins_ptr, const char* public_key) { DEBUG_START() Monero::Coins *coins = reinterpret_cast(coins_ptr); return coins->thaw(std::string(public_key)); DEBUG_END() } // virtual bool isTransferUnlocked(uint64_t unlockTime, uint64_t blockHeight) = 0; -bool MONERO_Coins_isTransferUnlocked(void* coins_ptr, uint64_t unlockTime, uint64_t blockHeight) { +bool SALVIUM_Coins_isTransferUnlocked(void* coins_ptr, uint64_t unlockTime, uint64_t blockHeight) { DEBUG_START() Monero::Coins *coins = reinterpret_cast(coins_ptr); return coins->isTransferUnlocked(unlockTime, blockHeight); DEBUG_END() } // virtual void setDescription(const std::string &public_key, const std::string &description) = 0; -void MONERO_Coins_setDescription(void* coins_ptr, const char* public_key, const char* description) { +void SALVIUM_Coins_setDescription(void* coins_ptr, const char* public_key, const char* description) { DEBUG_START() Monero::Coins *coins = reinterpret_cast(coins_ptr); return coins->setDescription(std::string(public_key), std::string(description)); @@ -821,7 +821,7 @@ void MONERO_Coins_setDescription(void* coins_ptr, const char* public_key, const // SubaddressRow // std::string extra; -const char* MONERO_SubaddressRow_extra(void* subaddressRow_ptr) { +const char* SALVIUM_SubaddressRow_extra(void* subaddressRow_ptr) { DEBUG_START() Monero::SubaddressRow *subaddressRow = reinterpret_cast(subaddressRow_ptr); std::string str = subaddressRow->extra; @@ -832,7 +832,7 @@ const char* MONERO_SubaddressRow_extra(void* subaddressRow_ptr) { DEBUG_END() } // std::string getAddress() const {return m_address;} -const char* MONERO_SubaddressRow_getAddress(void* subaddressRow_ptr) { +const char* SALVIUM_SubaddressRow_getAddress(void* subaddressRow_ptr) { DEBUG_START() Monero::SubaddressRow *subaddressRow = reinterpret_cast(subaddressRow_ptr); std::string str = subaddressRow->getAddress(); @@ -843,7 +843,7 @@ const char* MONERO_SubaddressRow_getAddress(void* subaddressRow_ptr) { DEBUG_END() } // std::string getLabel() const {return m_label;} -const char* MONERO_SubaddressRow_getLabel(void* subaddressRow_ptr) { +const char* SALVIUM_SubaddressRow_getLabel(void* subaddressRow_ptr) { DEBUG_START() Monero::SubaddressRow *subaddressRow = reinterpret_cast(subaddressRow_ptr); std::string str = subaddressRow->getLabel(); @@ -854,7 +854,7 @@ const char* MONERO_SubaddressRow_getLabel(void* subaddressRow_ptr) { DEBUG_END() } // std::size_t getRowId() const {return m_rowId;} -size_t MONERO_SubaddressRow_getRowId(void* subaddressRow_ptr) { +size_t SALVIUM_SubaddressRow_getRowId(void* subaddressRow_ptr) { DEBUG_START() Monero::SubaddressRow *subaddressRow = reinterpret_cast(subaddressRow_ptr); return subaddressRow->getRowId(); @@ -863,34 +863,34 @@ size_t MONERO_SubaddressRow_getRowId(void* subaddressRow_ptr) { // Subaddress -int MONERO_Subaddress_getAll_size(void* subaddress_ptr) { +int SALVIUM_Subaddress_getAll_size(void* subaddress_ptr) { DEBUG_START() Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); return subaddress->getAll().size(); DEBUG_END() } -void* MONERO_Subaddress_getAll_byIndex(void* subaddress_ptr, int index) { +void* SALVIUM_Subaddress_getAll_byIndex(void* subaddress_ptr, int index) { DEBUG_START() Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); return subaddress->getAll()[index]; DEBUG_END() } // virtual void addRow(uint32_t accountIndex, const std::string &label) = 0; -void MONERO_Subaddress_addRow(void* subaddress_ptr, uint32_t accountIndex, const char* label) { +void SALVIUM_Subaddress_addRow(void* subaddress_ptr, uint32_t accountIndex, const char* label) { DEBUG_START() Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); return subaddress->addRow(accountIndex, std::string(label)); DEBUG_END() } // 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) { +void SALVIUM_Subaddress_setLabel(void* subaddress_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label) { DEBUG_START() Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); return subaddress->setLabel(accountIndex, addressIndex, std::string(label)); DEBUG_END() } // virtual void refresh(uint32_t accountIndex) = 0; -void MONERO_Subaddress_refresh(void* subaddress_ptr, uint32_t accountIndex) { +void SALVIUM_Subaddress_refresh(void* subaddress_ptr, uint32_t accountIndex) { DEBUG_START() Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); return subaddress->refresh(accountIndex); @@ -900,7 +900,7 @@ void MONERO_Subaddress_refresh(void* subaddress_ptr, uint32_t accountIndex) { // SubaddressAccountRow // std::string extra; -const char* MONERO_SubaddressAccountRow_extra(void* subaddressAccountRow_ptr) { +const char* SALVIUM_SubaddressAccountRow_extra(void* subaddressAccountRow_ptr) { DEBUG_START() Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); std::string str = subaddressAccountRow->extra; @@ -911,7 +911,7 @@ const char* MONERO_SubaddressAccountRow_extra(void* subaddressAccountRow_ptr) { DEBUG_END() } // std::string getAddress() const {return m_address;} -const char* MONERO_SubaddressAccountRow_getAddress(void* subaddressAccountRow_ptr) { +const char* SALVIUM_SubaddressAccountRow_getAddress(void* subaddressAccountRow_ptr) { DEBUG_START() Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); std::string str = subaddressAccountRow->getAddress(); @@ -922,7 +922,7 @@ const char* MONERO_SubaddressAccountRow_getAddress(void* subaddressAccountRow_pt DEBUG_END() } // std::string getLabel() const {return m_label;} -const char* MONERO_SubaddressAccountRow_getLabel(void* subaddressAccountRow_ptr) { +const char* SALVIUM_SubaddressAccountRow_getLabel(void* subaddressAccountRow_ptr) { DEBUG_START() Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); std::string str = subaddressAccountRow->getLabel(); @@ -933,7 +933,7 @@ const char* MONERO_SubaddressAccountRow_getLabel(void* subaddressAccountRow_ptr) DEBUG_END() } // std::string getBalance() const {return m_balance;} -const char* MONERO_SubaddressAccountRow_getBalance(void* subaddressAccountRow_ptr) { +const char* SALVIUM_SubaddressAccountRow_getBalance(void* subaddressAccountRow_ptr) { DEBUG_START() Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); std::string str = subaddressAccountRow->getBalance(); @@ -944,7 +944,7 @@ const char* MONERO_SubaddressAccountRow_getBalance(void* subaddressAccountRow_pt DEBUG_END() } // std::string getUnlockedBalance() const {return m_unlockedBalance;} -const char* MONERO_SubaddressAccountRow_getUnlockedBalance(void* subaddressAccountRow_ptr) { +const char* SALVIUM_SubaddressAccountRow_getUnlockedBalance(void* subaddressAccountRow_ptr) { DEBUG_START() Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); std::string str = subaddressAccountRow->getUnlockedBalance(); @@ -955,7 +955,7 @@ const char* MONERO_SubaddressAccountRow_getUnlockedBalance(void* subaddressAccou DEBUG_END() } // std::size_t getRowId() const {return m_rowId;} -size_t MONERO_SubaddressAccountRow_getRowId(void* subaddressAccountRow_ptr) { +size_t SALVIUM_SubaddressAccountRow_getRowId(void* subaddressAccountRow_ptr) { DEBUG_START() Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); return subaddressAccountRow->getRowId(); @@ -966,34 +966,34 @@ size_t MONERO_SubaddressAccountRow_getRowId(void* subaddressAccountRow_ptr) { // { // virtual ~SubaddressAccount() = 0; // virtual std::vector getAll() const = 0; -int MONERO_SubaddressAccount_getAll_size(void* subaddressAccount_ptr) { +int SALVIUM_SubaddressAccount_getAll_size(void* subaddressAccount_ptr) { DEBUG_START() Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); return subaddress->getAll().size(); DEBUG_END() } -void* MONERO_SubaddressAccount_getAll_byIndex(void* subaddressAccount_ptr, int index) { +void* SALVIUM_SubaddressAccount_getAll_byIndex(void* subaddressAccount_ptr, int index) { DEBUG_START() Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); return subaddress->getAll()[index]; DEBUG_END() } // virtual void addRow(const std::string &label) = 0; -void MONERO_SubaddressAccount_addRow(void* subaddressAccount_ptr, const char* label) { +void SALVIUM_SubaddressAccount_addRow(void* subaddressAccount_ptr, const char* label) { DEBUG_START() Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); return subaddress->addRow(std::string(label)); DEBUG_END() } // virtual void setLabel(uint32_t accountIndex, const std::string &label) = 0; -void MONERO_SubaddressAccount_setLabel(void* subaddressAccount_ptr, uint32_t accountIndex, const char* label) { +void SALVIUM_SubaddressAccount_setLabel(void* subaddressAccount_ptr, uint32_t accountIndex, const char* label) { DEBUG_START() Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); return subaddress->setLabel(accountIndex, std::string(label)); DEBUG_END() } // virtual void refresh() = 0; -void MONERO_SubaddressAccount_refresh(void* subaddressAccount_ptr) { +void SALVIUM_SubaddressAccount_refresh(void* subaddressAccount_ptr) { DEBUG_START() Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); return subaddress->refresh(); @@ -1003,28 +1003,28 @@ void MONERO_SubaddressAccount_refresh(void* subaddressAccount_ptr) { // MultisigState // bool isMultisig; -bool MONERO_MultisigState_isMultisig(void* multisigState_ptr) { +bool SALVIUM_MultisigState_isMultisig(void* multisigState_ptr) { DEBUG_START() Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); return multisigState->isMultisig; DEBUG_END() } // bool isReady; -bool MONERO_MultisigState_isReady(void* multisigState_ptr) { +bool SALVIUM_MultisigState_isReady(void* multisigState_ptr) { DEBUG_START() Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); return multisigState->isReady; DEBUG_END() } // uint32_t threshold; -uint32_t MONERO_MultisigState_threshold(void* multisigState_ptr) { +uint32_t SALVIUM_MultisigState_threshold(void* multisigState_ptr) { DEBUG_START() Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); return multisigState->threshold; DEBUG_END() } // uint32_t total; -uint32_t MONERO_MultisigState_total(void* multisigState_ptr) { +uint32_t SALVIUM_MultisigState_total(void* multisigState_ptr) { DEBUG_START() Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); return multisigState->total; @@ -1035,14 +1035,14 @@ uint32_t MONERO_MultisigState_total(void* multisigState_ptr) { // virtual double progress() const { return m_progress; } -bool MONERO_DeviceProgress_progress(void* deviceProgress_ptr) { +bool SALVIUM_DeviceProgress_progress(void* deviceProgress_ptr) { DEBUG_START() Monero::DeviceProgress *deviceProgress = reinterpret_cast(deviceProgress_ptr); return deviceProgress->progress(); DEBUG_END() } // virtual bool indeterminate() const { return m_indeterminate; } -bool MONERO_DeviceProgress_indeterminate(void* deviceProgress_ptr) { +bool SALVIUM_DeviceProgress_indeterminate(void* deviceProgress_ptr) { DEBUG_START() Monero::DeviceProgress *deviceProgress = reinterpret_cast(deviceProgress_ptr); return deviceProgress->indeterminate(); @@ -1051,7 +1051,7 @@ bool MONERO_DeviceProgress_indeterminate(void* deviceProgress_ptr) { // Wallet -const char* MONERO_Wallet_seed(void* wallet_ptr, const char* seed_offset) { +const char* SALVIUM_Wallet_seed(void* wallet_ptr, const char* seed_offset) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->seed(std::string(seed_offset)); @@ -1062,7 +1062,7 @@ const char* MONERO_Wallet_seed(void* wallet_ptr, const char* seed_offset) { DEBUG_END() } -const char* MONERO_Wallet_getSeedLanguage(void* wallet_ptr) { +const char* SALVIUM_Wallet_getSeedLanguage(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->getSeedLanguage(); @@ -1073,21 +1073,21 @@ const char* MONERO_Wallet_getSeedLanguage(void* wallet_ptr) { DEBUG_END() } -void MONERO_Wallet_setSeedLanguage(void* wallet_ptr, const char* arg) { +void SALVIUM_Wallet_setSeedLanguage(void* wallet_ptr, const char* arg) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->setSeedLanguage(std::string(arg)); DEBUG_END() } -int MONERO_Wallet_status(void* wallet_ptr) { +int SALVIUM_Wallet_status(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->status(); DEBUG_END() } -const char* MONERO_Wallet_errorString(void* wallet_ptr) { +const char* SALVIUM_Wallet_errorString(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->errorString(); @@ -1099,14 +1099,14 @@ const char* MONERO_Wallet_errorString(void* wallet_ptr) { } -bool MONERO_Wallet_setPassword(void* wallet_ptr, const char* password) { +bool SALVIUM_Wallet_setPassword(void* wallet_ptr, const char* password) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->setPassword(std::string(password)); DEBUG_END() } -const char* MONERO_Wallet_getPassword(void* wallet_ptr) { +const char* SALVIUM_Wallet_getPassword(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->getPassword(); @@ -1117,21 +1117,21 @@ const char* MONERO_Wallet_getPassword(void* wallet_ptr) { DEBUG_END() } -bool MONERO_Wallet_setDevicePin(void* wallet_ptr, const char* pin) { +bool SALVIUM_Wallet_setDevicePin(void* wallet_ptr, const char* pin) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->setDevicePin(std::string(pin)); DEBUG_END() } -bool MONERO_Wallet_setDevicePassphrase(void* wallet_ptr, const char* passphrase) { +bool SALVIUM_Wallet_setDevicePassphrase(void* wallet_ptr, const char* passphrase) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->setDevicePassphrase(std::string(passphrase)); DEBUG_END() } -const char* MONERO_Wallet_address(void* wallet_ptr, uint64_t accountIndex, uint64_t addressIndex) { +const char* SALVIUM_Wallet_address(void* wallet_ptr, uint64_t accountIndex, uint64_t addressIndex) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->address(accountIndex, addressIndex); @@ -1142,7 +1142,7 @@ const char* MONERO_Wallet_address(void* wallet_ptr, uint64_t accountIndex, uint6 DEBUG_END() } -const char* MONERO_Wallet_path(void* wallet_ptr) { +const char* SALVIUM_Wallet_path(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->path(); @@ -1152,19 +1152,19 @@ const char* MONERO_Wallet_path(void* wallet_ptr) { return buffer; DEBUG_END() } -int MONERO_Wallet_nettype(void* wallet_ptr) { +int SALVIUM_Wallet_nettype(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->nettype(); DEBUG_END() } -uint8_t MONERO_Wallet_useForkRules(void* wallet_ptr, uint8_t version, int64_t early_blocks) { +uint8_t SALVIUM_Wallet_useForkRules(void* wallet_ptr, uint8_t version, int64_t early_blocks) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->useForkRules(version, early_blocks); DEBUG_END() } -const char* MONERO_Wallet_integratedAddress(void* wallet_ptr, const char* payment_id) { +const char* SALVIUM_Wallet_integratedAddress(void* wallet_ptr, const char* payment_id) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->integratedAddress(std::string(payment_id)); @@ -1175,7 +1175,7 @@ const char* MONERO_Wallet_integratedAddress(void* wallet_ptr, const char* paymen DEBUG_END() } -const char* MONERO_Wallet_secretViewKey(void* wallet_ptr) { +const char* SALVIUM_Wallet_secretViewKey(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->secretViewKey(); @@ -1186,7 +1186,7 @@ const char* MONERO_Wallet_secretViewKey(void* wallet_ptr) { DEBUG_END() } -const char* MONERO_Wallet_publicViewKey(void* wallet_ptr) { +const char* SALVIUM_Wallet_publicViewKey(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->publicViewKey(); @@ -1197,7 +1197,7 @@ const char* MONERO_Wallet_publicViewKey(void* wallet_ptr) { DEBUG_END() } -const char* MONERO_Wallet_secretSpendKey(void* wallet_ptr) { +const char* SALVIUM_Wallet_secretSpendKey(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->secretSpendKey(); @@ -1208,7 +1208,7 @@ const char* MONERO_Wallet_secretSpendKey(void* wallet_ptr) { DEBUG_END() } -const char* MONERO_Wallet_publicSpendKey(void* wallet_ptr) { +const char* SALVIUM_Wallet_publicSpendKey(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->publicSpendKey(); @@ -1218,7 +1218,7 @@ const char* MONERO_Wallet_publicSpendKey(void* wallet_ptr) { return buffer; DEBUG_END() } -const char* MONERO_Wallet_publicMultisigSignerKey(void* wallet_ptr) { +const char* SALVIUM_Wallet_publicMultisigSignerKey(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->publicMultisigSignerKey(); @@ -1229,20 +1229,20 @@ const char* MONERO_Wallet_publicMultisigSignerKey(void* wallet_ptr) { DEBUG_END() } -void MONERO_Wallet_stop(void* wallet_ptr) { +void SALVIUM_Wallet_stop(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->stop(); DEBUG_END() } -bool MONERO_Wallet_store(void* wallet_ptr, const char* path) { +bool SALVIUM_Wallet_store(void* wallet_ptr, const char* path) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->store(std::string(path)); DEBUG_END() } -const char* MONERO_Wallet_filename(void* wallet_ptr) { +const char* SALVIUM_Wallet_filename(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->filename(); @@ -1252,7 +1252,7 @@ const char* MONERO_Wallet_filename(void* wallet_ptr) { return buffer; DEBUG_END() } -const char* MONERO_Wallet_keysFilename(void* wallet_ptr) { +const char* SALVIUM_Wallet_keysFilename(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->keysFilename(); @@ -1264,98 +1264,98 @@ const char* 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) { +bool SALVIUM_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) { DEBUG_START() 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)); DEBUG_END() } -bool MONERO_Wallet_createWatchOnly(void* wallet_ptr, const char* path, const char* password, const char* language) { +bool SALVIUM_Wallet_createWatchOnly(void* wallet_ptr, const char* path, const char* password, const char* language) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->createWatchOnly(std::string(path), std::string(password), std::string(language)); DEBUG_END() } -void MONERO_Wallet_setRefreshFromBlockHeight(void* wallet_ptr, uint64_t refresh_from_block_height) { +void SALVIUM_Wallet_setRefreshFromBlockHeight(void* wallet_ptr, uint64_t refresh_from_block_height) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->setRefreshFromBlockHeight(refresh_from_block_height); DEBUG_END() } -uint64_t MONERO_Wallet_getRefreshFromBlockHeight(void* wallet_ptr) { +uint64_t SALVIUM_Wallet_getRefreshFromBlockHeight(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->getRefreshFromBlockHeight(); DEBUG_END() } -void MONERO_Wallet_setRecoveringFromSeed(void* wallet_ptr, bool recoveringFromSeed) { +void SALVIUM_Wallet_setRecoveringFromSeed(void* wallet_ptr, bool recoveringFromSeed) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->setRecoveringFromSeed(recoveringFromSeed); DEBUG_END() } -void MONERO_Wallet_setRecoveringFromDevice(void* wallet_ptr, bool recoveringFromDevice) { +void SALVIUM_Wallet_setRecoveringFromDevice(void* wallet_ptr, bool recoveringFromDevice) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->setRecoveringFromDevice(recoveringFromDevice); DEBUG_END() } -void MONERO_Wallet_setSubaddressLookahead(void* wallet_ptr, uint32_t major, uint32_t minor) { +void SALVIUM_Wallet_setSubaddressLookahead(void* wallet_ptr, uint32_t major, uint32_t minor) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->setSubaddressLookahead(major, minor); DEBUG_END() } -bool MONERO_Wallet_connectToDaemon(void* wallet_ptr) { +bool SALVIUM_Wallet_connectToDaemon(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->connectToDaemon(); DEBUG_END() } -int MONERO_Wallet_connected(void* wallet_ptr) { +int SALVIUM_Wallet_connected(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->connected(); DEBUG_END() } -void MONERO_Wallet_setTrustedDaemon(void* wallet_ptr, bool arg) { +void SALVIUM_Wallet_setTrustedDaemon(void* wallet_ptr, bool arg) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->setTrustedDaemon(arg); DEBUG_END() } -bool MONERO_Wallet_trustedDaemon(void* wallet_ptr) { +bool SALVIUM_Wallet_trustedDaemon(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->trustedDaemon(); DEBUG_END() } -bool MONERO_Wallet_setProxy(void* wallet_ptr, const char* address) { +bool SALVIUM_Wallet_setProxy(void* wallet_ptr, const char* address) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->setProxy(std::string(address)); DEBUG_END() } -uint64_t MONERO_Wallet_balance(void* wallet_ptr, uint32_t accountIndex) { +uint64_t SALVIUM_Wallet_balance(void* wallet_ptr, uint32_t accountIndex) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->balance(accountIndex); DEBUG_END() } -uint64_t MONERO_Wallet_unlockedBalance(void* wallet_ptr, uint32_t accountIndex) { +uint64_t SALVIUM_Wallet_unlockedBalance(void* wallet_ptr, uint32_t accountIndex) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->unlockedBalance(accountIndex); DEBUG_END() } -uint64_t MONERO_Wallet_viewOnlyBalance(void* wallet_ptr, uint32_t accountIndex) { +uint64_t SALVIUM_Wallet_viewOnlyBalance(void* wallet_ptr, uint32_t accountIndex) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->viewOnlyBalance(accountIndex); @@ -1363,57 +1363,57 @@ uint64_t MONERO_Wallet_viewOnlyBalance(void* wallet_ptr, uint32_t accountIndex) } // TODO -bool MONERO_Wallet_watchOnly(void* wallet_ptr) { +bool SALVIUM_Wallet_watchOnly(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->watchOnly(); DEBUG_END() } -bool MONERO_Wallet_isDeterministic(void* wallet_ptr) { +bool SALVIUM_Wallet_isDeterministic(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->isDeterministic(); DEBUG_END() } -uint64_t MONERO_Wallet_blockChainHeight(void* wallet_ptr) { +uint64_t SALVIUM_Wallet_blockChainHeight(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->blockChainHeight(); DEBUG_END() } -uint64_t MONERO_Wallet_approximateBlockChainHeight(void* wallet_ptr) { +uint64_t SALVIUM_Wallet_approximateBlockChainHeight(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->approximateBlockChainHeight(); DEBUG_END() } -uint64_t MONERO_Wallet_estimateBlockChainHeight(void* wallet_ptr) { +uint64_t SALVIUM_Wallet_estimateBlockChainHeight(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->estimateBlockChainHeight(); DEBUG_END() } -uint64_t MONERO_Wallet_daemonBlockChainHeight(void* wallet_ptr) { +uint64_t SALVIUM_Wallet_daemonBlockChainHeight(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->daemonBlockChainHeight(); DEBUG_END() } -uint64_t MONERO_Wallet_daemonBlockChainTargetHeight(void* wallet_ptr) { +uint64_t SALVIUM_Wallet_daemonBlockChainTargetHeight(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->daemonBlockChainTargetHeight(); DEBUG_END() } -bool MONERO_Wallet_synchronized(void* wallet_ptr) { +bool SALVIUM_Wallet_synchronized(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->synchronized(); DEBUG_END() } -const char* MONERO_Wallet_displayAmount(uint64_t amount) { +const char* SALVIUM_Wallet_displayAmount(uint64_t amount) { DEBUG_START() std::string str = Monero::Wallet::displayAmount(amount); const std::string::size_type size = str.size(); @@ -1424,19 +1424,19 @@ const char* MONERO_Wallet_displayAmount(uint64_t amount) { } // static uint64_t amountFromString(const std::string &amount); -uint64_t MONERO_Wallet_amountFromString(const char* amount) { +uint64_t SALVIUM_Wallet_amountFromString(const char* amount) { DEBUG_START() return Monero::Wallet::amountFromString(amount); DEBUG_END() } // static uint64_t amountFromDouble(double amount); -uint64_t MONERO_Wallet_amountFromDouble(double amount) { +uint64_t SALVIUM_Wallet_amountFromDouble(double amount) { DEBUG_START() return Monero::Wallet::amountFromDouble(amount); DEBUG_END() } // static std::string genPaymentId(); -const char* MONERO_Wallet_genPaymentId() { +const char* SALVIUM_Wallet_genPaymentId() { DEBUG_START() std::string str = Monero::Wallet::genPaymentId(); const std::string::size_type size = str.size(); @@ -1446,25 +1446,25 @@ const char* MONERO_Wallet_genPaymentId() { DEBUG_END() } // static bool paymentIdValid(const std::string &paiment_id); -bool MONERO_Wallet_paymentIdValid(const char* paiment_id) { +bool SALVIUM_Wallet_paymentIdValid(const char* paiment_id) { DEBUG_START() return Monero::Wallet::paymentIdValid(std::string(paiment_id)); DEBUG_END() } -bool MONERO_Wallet_addressValid(const char* str, int nettype) { +bool SALVIUM_Wallet_addressValid(const char* str, int nettype) { DEBUG_START() // Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return Monero::Wallet::addressValid(std::string(str), nettype); DEBUG_END() } -bool MONERO_Wallet_keyValid(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype) { +bool SALVIUM_Wallet_keyValid(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype) { DEBUG_START() std::string error; return Monero::Wallet::keyValid(std::string(secret_key_string), std::string(address_string), isViewKey, nettype, error); DEBUG_END() } -const char* MONERO_Wallet_keyValid_error(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype) { +const char* SALVIUM_Wallet_keyValid_error(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype) { DEBUG_START() std::string str; Monero::Wallet::keyValid(std::string(secret_key_string), std::string(address_string), isViewKey, nettype, str); @@ -1475,7 +1475,7 @@ const char* MONERO_Wallet_keyValid_error(const char* secret_key_string, const ch DEBUG_END() } -const char* MONERO_Wallet_paymentIdFromAddress(const char* strarg, int nettype) { +const char* SALVIUM_Wallet_paymentIdFromAddress(const char* strarg, int nettype) { DEBUG_START() std::string str = Monero::Wallet::paymentIdFromAddress(std::string(strarg), nettype); const std::string::size_type size = str.size(); @@ -1484,19 +1484,19 @@ const char* MONERO_Wallet_paymentIdFromAddress(const char* strarg, int nettype) return buffer; DEBUG_END() } -uint64_t MONERO_Wallet_maximumAllowedAmount() { +uint64_t SALVIUM_Wallet_maximumAllowedAmount() { DEBUG_START() return Monero::Wallet::maximumAllowedAmount(); DEBUG_END() } -void MONERO_Wallet_init3(void* wallet_ptr, const char* argv0, const char* default_log_base_name, const char* log_path, bool console) { +void SALVIUM_Wallet_init3(void* wallet_ptr, const char* argv0, const char* default_log_base_name, const char* log_path, bool console) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->init(argv0, default_log_base_name, log_path, console); DEBUG_END() } -const char* MONERO_Wallet_getPolyseed(void* wallet_ptr, const char* passphrase) { +const char* SALVIUM_Wallet_getPolyseed(void* wallet_ptr, const char* passphrase) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string seed = ""; @@ -1510,12 +1510,12 @@ const char* MONERO_Wallet_getPolyseed(void* wallet_ptr, const char* passphrase) DEBUG_END() } // static bool createPolyseed(std::string &seed_words, std::string &err, const std::string &language = "English"); -const char* MONERO_Wallet_createPolyseed(const char* language) { +const char* SALVIUM_Wallet_createPolyseed(const char* language) { DEBUG_START() std::string seed_words = ""; std::string err; Monero::Wallet::createPolyseed(seed_words, err, std::string(language)); - std::cout << "MONERO_Wallet_createPolyseed(language: " << language << "):" << std::endl; + std::cout << "SALVIUM_Wallet_createPolyseed(language: " << language << "):" << std::endl; std::cout << " err: " << err << std::endl; std::string str = seed_words; const std::string::size_type size = str.size(); @@ -1525,79 +1525,79 @@ const char* MONERO_Wallet_createPolyseed(const char* language) { DEBUG_END() } -void MONERO_Wallet_startRefresh(void* wallet_ptr) { +void SALVIUM_Wallet_startRefresh(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->startRefresh(); DEBUG_END() } -void MONERO_Wallet_pauseRefresh(void* wallet_ptr) { +void SALVIUM_Wallet_pauseRefresh(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->pauseRefresh(); DEBUG_END() } -bool MONERO_Wallet_refresh(void* wallet_ptr) { +bool SALVIUM_Wallet_refresh(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->refresh(); DEBUG_END() } -void MONERO_Wallet_refreshAsync(void* wallet_ptr) { +void SALVIUM_Wallet_refreshAsync(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->refreshAsync(); DEBUG_END() } -bool MONERO_Wallet_rescanBlockchain(void* wallet_ptr) { +bool SALVIUM_Wallet_rescanBlockchain(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->rescanBlockchain(); DEBUG_END() } -void MONERO_Wallet_rescanBlockchainAsync(void* wallet_ptr) { +void SALVIUM_Wallet_rescanBlockchainAsync(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->rescanBlockchainAsync(); DEBUG_END() } -void MONERO_Wallet_setAutoRefreshInterval(void* wallet_ptr, int millis) { +void SALVIUM_Wallet_setAutoRefreshInterval(void* wallet_ptr, int millis) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->setAutoRefreshInterval(millis); DEBUG_END() } -int MONERO_Wallet_autoRefreshInterval(void* wallet_ptr) { +int SALVIUM_Wallet_autoRefreshInterval(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->autoRefreshInterval(); DEBUG_END() } -void MONERO_Wallet_addSubaddressAccount(void* wallet_ptr, const char* label) { +void SALVIUM_Wallet_addSubaddressAccount(void* wallet_ptr, const char* label) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->addSubaddressAccount(std::string(label)); DEBUG_END() } -size_t MONERO_Wallet_numSubaddressAccounts(void* wallet_ptr) { +size_t SALVIUM_Wallet_numSubaddressAccounts(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->numSubaddressAccounts(); DEBUG_END() } -size_t MONERO_Wallet_numSubaddresses(void* wallet_ptr, uint32_t accountIndex) { +size_t SALVIUM_Wallet_numSubaddresses(void* wallet_ptr, uint32_t accountIndex) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->numSubaddresses(accountIndex); DEBUG_END() } -void MONERO_Wallet_addSubaddress(void* wallet_ptr, uint32_t accountIndex, const char* label) { +void SALVIUM_Wallet_addSubaddress(void* wallet_ptr, uint32_t accountIndex, const char* label) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->addSubaddress(accountIndex, std::string(label)); DEBUG_END() } -const char* MONERO_Wallet_getSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex) { +const char* SALVIUM_Wallet_getSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->getSubaddressLabel(accountIndex, addressIndex); @@ -1608,14 +1608,14 @@ const char* MONERO_Wallet_getSubaddressLabel(void* wallet_ptr, uint32_t accountI DEBUG_END() } -void MONERO_Wallet_setSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label) { +void SALVIUM_Wallet_setSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->setSubaddressLabel(accountIndex, addressIndex, std::string(label)); DEBUG_END() } -void* MONERO_Wallet_multisig(void* wallet_ptr) { +void* SALVIUM_Wallet_multisig(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); Monero::MultisigState *mstate_ptr = new Monero::MultisigState(wallet->multisig()); @@ -1623,7 +1623,7 @@ void* MONERO_Wallet_multisig(void* wallet_ptr) { DEBUG_END() } -const char* MONERO_Wallet_getMultisigInfo(void* wallet_ptr) { +const char* SALVIUM_Wallet_getMultisigInfo(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->getMultisigInfo(); @@ -1634,7 +1634,7 @@ const char* MONERO_Wallet_getMultisigInfo(void* wallet_ptr) { DEBUG_END() } -const char* MONERO_Wallet_makeMultisig(void* wallet_ptr, const char* info, const char* info_separator, uint32_t threshold) { +const char* SALVIUM_Wallet_makeMultisig(void* wallet_ptr, const char* info, const char* info_separator, uint32_t threshold) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->makeMultisig(splitStringVector(std::string(info), std::string(info_separator)), threshold); @@ -1645,7 +1645,7 @@ const char* MONERO_Wallet_makeMultisig(void* wallet_ptr, const char* info, const DEBUG_END() } -const char* MONERO_Wallet_exchangeMultisigKeys(void* wallet_ptr, const char* info, const char* info_separator, bool force_update_use_with_caution) { +const char* SALVIUM_Wallet_exchangeMultisigKeys(void* wallet_ptr, const char* info, const char* info_separator, bool force_update_use_with_caution) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->exchangeMultisigKeys(splitStringVector(std::string(info), std::string(info_separator)), force_update_use_with_caution); @@ -1656,7 +1656,7 @@ const char* MONERO_Wallet_exchangeMultisigKeys(void* wallet_ptr, const char* inf DEBUG_END() } -const char* MONERO_Wallet_exportMultisigImages(void* wallet_ptr, const char* separator) { +const char* SALVIUM_Wallet_exportMultisigImages(void* wallet_ptr, const char* separator) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str; @@ -1668,21 +1668,21 @@ const char* MONERO_Wallet_exportMultisigImages(void* wallet_ptr, const char* sep DEBUG_END() } -size_t MONERO_Wallet_importMultisigImages(void* wallet_ptr, const char* info, const char* info_separator) { +size_t SALVIUM_Wallet_importMultisigImages(void* wallet_ptr, const char* info, const char* info_separator) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->importMultisigImages(splitStringVector(std::string(info), std::string(info_separator))); DEBUG_END() } -size_t MONERO_Wallet_hasMultisigPartialKeyImages(void* wallet_ptr) { +size_t SALVIUM_Wallet_hasMultisigPartialKeyImages(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->hasMultisigPartialKeyImages(); DEBUG_END() } -void* MONERO_Wallet_restoreMultisigTransaction(void* wallet_ptr, const char* signData) { +void* SALVIUM_Wallet_restoreMultisigTransaction(void* wallet_ptr, const char* signData) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return reinterpret_cast(wallet->restoreMultisigTransaction(std::string(signData))); @@ -1700,7 +1700,7 @@ Monero::PendingTransaction::Priority PendingTransaction_Priority_fromInt(int val } } -void* MONERO_Wallet_createTransactionMultDest(void* wallet_ptr, const char* dst_addr_list, const char* dst_addr_list_separator, const char* payment_id, +void* SALVIUM_Wallet_createTransactionMultDest(void* wallet_ptr, const char* dst_addr_list, const char* dst_addr_list_separator, const char* payment_id, bool amount_sweep_all, const char* amount_list, const char* amount_list_separator, uint32_t mixin_count, int pendingTransactionPriority, uint32_t subaddr_account, @@ -1727,7 +1727,7 @@ void* MONERO_Wallet_createTransactionMultDest(void* wallet_ptr, const char* dst_ DEBUG_END() } -void* MONERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id, +void* SALVIUM_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, @@ -1747,45 +1747,45 @@ void* MONERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, co DEBUG_END() } -void* MONERO_Wallet_loadUnsignedTx(void* wallet_ptr, const char* fileName) { +void* SALVIUM_Wallet_loadUnsignedTx(void* wallet_ptr, const char* fileName) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->loadUnsignedTx(std::string(fileName)); DEBUG_END() } -void* MONERO_Wallet_loadUnsignedTxUR(void* wallet_ptr, const char* input) { +void* SALVIUM_Wallet_loadUnsignedTxUR(void* wallet_ptr, const char* input) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->loadUnsignedTxUR(std::string(input)); DEBUG_END() } -bool MONERO_Wallet_submitTransaction(void* wallet_ptr, const char* fileName) { +bool SALVIUM_Wallet_submitTransaction(void* wallet_ptr, const char* fileName) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->submitTransaction(std::string(fileName)); DEBUG_END() } -bool MONERO_Wallet_submitTransactionUR(void* wallet_ptr, const char* input) { +bool SALVIUM_Wallet_submitTransactionUR(void* wallet_ptr, const char* input) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->submitTransactionUR(std::string(input)); DEBUG_END() } -bool MONERO_Wallet_hasUnknownKeyImages(void* wallet_ptr) { +bool SALVIUM_Wallet_hasUnknownKeyImages(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->hasUnknownKeyImages(); DEBUG_END() } -bool MONERO_Wallet_exportKeyImages(void* wallet_ptr, const char* filename, bool all) { +bool SALVIUM_Wallet_exportKeyImages(void* wallet_ptr, const char* filename, bool all) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->exportKeyImages(std::string(filename), all); DEBUG_END() } -const char* MONERO_Wallet_exportKeyImagesUR(void* wallet_ptr, size_t max_fragment_length, bool all) { +const char* SALVIUM_Wallet_exportKeyImagesUR(void* wallet_ptr, size_t max_fragment_length, bool all) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->exportKeyImagesUR(max_fragment_length, all); @@ -1795,25 +1795,25 @@ const char* MONERO_Wallet_exportKeyImagesUR(void* wallet_ptr, size_t max_fragmen return buffer; DEBUG_END() } -bool MONERO_Wallet_importKeyImages(void* wallet_ptr, const char* filename) { +bool SALVIUM_Wallet_importKeyImages(void* wallet_ptr, const char* filename) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->importKeyImages(std::string(filename)); DEBUG_END() } -bool MONERO_Wallet_importKeyImagesUR(void* wallet_ptr, const char* input) { +bool SALVIUM_Wallet_importKeyImagesUR(void* wallet_ptr, const char* input) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->importKeyImagesUR(std::string(input)); DEBUG_END() } -bool MONERO_Wallet_exportOutputs(void* wallet_ptr, const char* filename, bool all) { +bool SALVIUM_Wallet_exportOutputs(void* wallet_ptr, const char* filename, bool all) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->exportOutputs(std::string(filename), all); DEBUG_END() } -const char* MONERO_Wallet_exportOutputsUR(void* wallet_ptr, size_t max_fragment_length, bool all) { +const char* SALVIUM_Wallet_exportOutputsUR(void* wallet_ptr, size_t max_fragment_length, bool all) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->exportOutputsUR(max_fragment_length, all); @@ -1823,116 +1823,116 @@ const char* MONERO_Wallet_exportOutputsUR(void* wallet_ptr, size_t max_fragment_ return buffer; DEBUG_END() } -bool MONERO_Wallet_importOutputs(void* wallet_ptr, const char* filename) { +bool SALVIUM_Wallet_importOutputs(void* wallet_ptr, const char* filename) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->importOutputs(std::string(filename)); DEBUG_END() } -bool MONERO_Wallet_importOutputsUR(void* wallet_ptr, const char* input) { +bool SALVIUM_Wallet_importOutputsUR(void* wallet_ptr, const char* input) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->importOutputsUR(std::string(input)); DEBUG_END() } // virtual bool setupBackgroundSync(const BackgroundSyncType background_sync_type, const std::string &wallet_password, const optional &background_cache_password) = 0; -bool MONERO_Wallet_setupBackgroundSync(void* wallet_ptr, int background_sync_type, const char* wallet_password, const char* background_cache_password) { +bool SALVIUM_Wallet_setupBackgroundSync(void* wallet_ptr, int background_sync_type, const char* wallet_password, const char* background_cache_password) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->setupBackgroundSync(Monero::Wallet::BackgroundSyncType::BackgroundSync_CustomPassword, std::string(wallet_password), std::string(background_cache_password)); DEBUG_END() } // virtual BackgroundSyncType getBackgroundSyncType() const = 0; -int MONERO_Wallet_getBackgroundSyncType(void* wallet_ptr) { +int SALVIUM_Wallet_getBackgroundSyncType(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->getBackgroundSyncType(); DEBUG_END() } // virtual bool startBackgroundSync() = 0; -bool MONERO_Wallet_startBackgroundSync(void* wallet_ptr) { +bool SALVIUM_Wallet_startBackgroundSync(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->startBackgroundSync(); DEBUG_END() } // virtual bool stopBackgroundSync(const std::string &wallet_password) = 0; -bool MONERO_Wallet_stopBackgroundSync(void* wallet_ptr, const char* wallet_password) { +bool SALVIUM_Wallet_stopBackgroundSync(void* wallet_ptr, const char* wallet_password) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->stopBackgroundSync(std::string(wallet_password)); DEBUG_END() } // virtual bool isBackgroundSyncing() const = 0; -bool MONERO_Wallet_isBackgroundSyncing(void* wallet_ptr) { +bool SALVIUM_Wallet_isBackgroundSyncing(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->hasUnknownKeyImages(); DEBUG_END() } // virtual bool isBackgroundWallet() const = 0; -bool MONERO_Wallet_isBackgroundWallet(void* wallet_ptr) { +bool SALVIUM_Wallet_isBackgroundWallet(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->isBackgroundWallet(); DEBUG_END() } -void* MONERO_Wallet_history(void* wallet_ptr) { +void* SALVIUM_Wallet_history(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->history(); DEBUG_END() } -void* MONERO_Wallet_addressBook(void* wallet_ptr) { +void* SALVIUM_Wallet_addressBook(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->addressBook(); DEBUG_END() } // virtual Coins * coins() = 0; -void* MONERO_Wallet_coins(void* wallet_ptr) { +void* SALVIUM_Wallet_coins(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->coins(); DEBUG_END() } // virtual Subaddress * subaddress() = 0; -void* MONERO_Wallet_subaddress(void* wallet_ptr) { +void* SALVIUM_Wallet_subaddress(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->subaddress(); DEBUG_END() } // virtual SubaddressAccount * subaddressAccount() = 0; -void* MONERO_Wallet_subaddressAccount(void* wallet_ptr) { +void* SALVIUM_Wallet_subaddressAccount(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->subaddressAccount(); DEBUG_END() } // virtual uint32_t defaultMixin() const = 0; -uint32_t MONERO_Wallet_defaultMixin(void* wallet_ptr) { +uint32_t SALVIUM_Wallet_defaultMixin(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->defaultMixin(); DEBUG_END() } // virtual void setDefaultMixin(uint32_t arg) = 0; -void MONERO_Wallet_setDefaultMixin(void* wallet_ptr, uint32_t arg) { +void SALVIUM_Wallet_setDefaultMixin(void* wallet_ptr, uint32_t arg) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->setDefaultMixin(arg); DEBUG_END() } // 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) { +bool SALVIUM_Wallet_setCacheAttribute(void* wallet_ptr, const char* key, const char* val) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->setCacheAttribute(std::string(key), std::string(val)); DEBUG_END() } // virtual std::string getCacheAttribute(const std::string &key) const = 0; -const char* MONERO_Wallet_getCacheAttribute(void* wallet_ptr, const char* key) { +const char* SALVIUM_Wallet_getCacheAttribute(void* wallet_ptr, const char* key) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->getCacheAttribute(std::string(key)); @@ -1943,14 +1943,14 @@ const char* MONERO_Wallet_getCacheAttribute(void* wallet_ptr, const char* key) { DEBUG_END() } // 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) { +bool SALVIUM_Wallet_setUserNote(void* wallet_ptr, const char* txid, const char* note) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->setUserNote(std::string(txid), std::string(note)); DEBUG_END() } // virtual std::string getUserNote(const std::string &txid) const = 0; -const char* MONERO_Wallet_getUserNote(void* wallet_ptr, const char* txid) { +const char* SALVIUM_Wallet_getUserNote(void* wallet_ptr, const char* txid) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->getUserNote(std::string(txid)); @@ -1961,7 +1961,7 @@ const char* MONERO_Wallet_getUserNote(void* wallet_ptr, const char* txid) { DEBUG_END() } -const char* MONERO_Wallet_getTxKey(void* wallet_ptr, const char* txid) { +const char* SALVIUM_Wallet_getTxKey(void* wallet_ptr, const char* txid) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->getTxKey(std::string(txid)); @@ -1972,7 +1972,7 @@ const char* MONERO_Wallet_getTxKey(void* wallet_ptr, const char* txid) { DEBUG_END() } -const char* MONERO_Wallet_signMessage(void* wallet_ptr, const char* message, const char* address) { +const char* SALVIUM_Wallet_signMessage(void* wallet_ptr, const char* message, const char* address) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = wallet->signMessage(std::string(message), std::string(address)); @@ -1983,7 +1983,7 @@ const char* MONERO_Wallet_signMessage(void* wallet_ptr, const char* message, con DEBUG_END() } -bool MONERO_Wallet_verifySignedMessage(void* wallet_ptr, const char* message, const char* address, const char* signature) { +bool SALVIUM_Wallet_verifySignedMessage(void* wallet_ptr, const char* message, const char* address, const char* signature) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); bool v = wallet->verifySignedMessage(std::string(message), std::string(address), std::string(signature)); @@ -1991,42 +1991,42 @@ bool MONERO_Wallet_verifySignedMessage(void* wallet_ptr, const char* message, co DEBUG_END() } -bool MONERO_Wallet_rescanSpent(void* wallet_ptr) { +bool SALVIUM_Wallet_rescanSpent(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->rescanSpent(); DEBUG_END() } -void MONERO_Wallet_setOffline(void* wallet_ptr, bool offline) { +void SALVIUM_Wallet_setOffline(void* wallet_ptr, bool offline) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->setOffline(offline); DEBUG_END() } // virtual bool isOffline() const = 0; -bool MONERO_Wallet_isOffline(void* wallet_ptr) { +bool SALVIUM_Wallet_isOffline(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->isOffline(); DEBUG_END() } -void MONERO_Wallet_segregatePreForkOutputs(void* wallet_ptr, bool segregate) { +void SALVIUM_Wallet_segregatePreForkOutputs(void* wallet_ptr, bool segregate) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->segregatePreForkOutputs(segregate); DEBUG_END() } // virtual void segregationHeight(uint64_t height) = 0; -void MONERO_Wallet_segregationHeight(void* wallet_ptr, uint64_t height) { +void SALVIUM_Wallet_segregationHeight(void* wallet_ptr, uint64_t height) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->segregationHeight(height); DEBUG_END() } // virtual void keyReuseMitigation2(bool mitigation) = 0; -void MONERO_Wallet_keyReuseMitigation2(void* wallet_ptr, bool mitigation) { +void SALVIUM_Wallet_keyReuseMitigation2(void* wallet_ptr, bool mitigation) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->keyReuseMitigation2(mitigation); @@ -2035,42 +2035,42 @@ 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) { +bool SALVIUM_Wallet_lockKeysFile(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->lockKeysFile(); DEBUG_END() } // virtual bool unlockKeysFile() = 0; -bool MONERO_Wallet_unlockKeysFile(void* wallet_ptr) { +bool SALVIUM_Wallet_unlockKeysFile(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->unlockKeysFile(); DEBUG_END() } // virtual bool isKeysFileLocked() = 0; -bool MONERO_Wallet_isKeysFileLocked(void* wallet_ptr) { +bool SALVIUM_Wallet_isKeysFileLocked(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->isKeysFileLocked(); DEBUG_END() } // virtual Device getDeviceType() const = 0; -int MONERO_Wallet_getDeviceType(void* wallet_ptr) { +int SALVIUM_Wallet_getDeviceType(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->getDeviceType(); DEBUG_END() } // 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) { +uint64_t SALVIUM_Wallet_coldKeyImageSync(void* wallet_ptr, uint64_t spent, uint64_t unspent) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->coldKeyImageSync(spent, unspent); DEBUG_END() } // 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) { +const char* SALVIUM_Wallet_deviceShowAddress(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); std::string str = ""; @@ -2082,86 +2082,86 @@ const char* MONERO_Wallet_deviceShowAddress(void* wallet_ptr, uint32_t accountIn DEBUG_END() } // virtual bool reconnectDevice() = 0; -bool MONERO_Wallet_reconnectDevice(void* wallet_ptr) { +bool SALVIUM_Wallet_reconnectDevice(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->reconnectDevice(); DEBUG_END() }; -uint64_t MONERO_Wallet_getBytesReceived(void* wallet_ptr) { +uint64_t SALVIUM_Wallet_getBytesReceived(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->getBytesReceived(); DEBUG_END() } -uint64_t MONERO_Wallet_getBytesSent(void* wallet_ptr) { +uint64_t SALVIUM_Wallet_getBytesSent(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->getBytesSent(); DEBUG_END() } -bool MONERO_Wallet_getStateIsConnected(void* wallet_ptr) { +bool SALVIUM_Wallet_getStateIsConnected(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->getStateIsConnected(); DEBUG_END() } -unsigned char* MONERO_Wallet_getSendToDevice(void* wallet_ptr) { +unsigned char* SALVIUM_Wallet_getSendToDevice(void* wallet_ptr) { Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->getSendToDevice(); } -size_t MONERO_Wallet_getSendToDeviceLength(void* wallet_ptr) { +size_t SALVIUM_Wallet_getSendToDeviceLength(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->getSendToDeviceLength(); DEBUG_END() } -unsigned char* MONERO_Wallet_getReceivedFromDevice(void* wallet_ptr) { +unsigned char* SALVIUM_Wallet_getReceivedFromDevice(void* wallet_ptr) { Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->getReceivedFromDevice(); } -size_t MONERO_Wallet_getReceivedFromDeviceLength(void* wallet_ptr) { +size_t SALVIUM_Wallet_getReceivedFromDeviceLength(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->getReceivedFromDeviceLength(); DEBUG_END() } -bool MONERO_Wallet_getWaitsForDeviceSend(void* wallet_ptr) { +bool SALVIUM_Wallet_getWaitsForDeviceSend(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->getWaitsForDeviceSend(); DEBUG_END() } -bool MONERO_Wallet_getWaitsForDeviceReceive(void* wallet_ptr) { +bool SALVIUM_Wallet_getWaitsForDeviceReceive(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->getWaitsForDeviceReceive(); DEBUG_END() } -void MONERO_Wallet_setDeviceReceivedData(void* wallet_ptr, unsigned char* data, size_t len) { +void SALVIUM_Wallet_setDeviceReceivedData(void* wallet_ptr, unsigned char* data, size_t len) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->setDeviceReceivedData(data, len); DEBUG_END() } -void MONERO_Wallet_setDeviceSendData(void* wallet_ptr, unsigned char* data, size_t len) { +void SALVIUM_Wallet_setDeviceSendData(void* wallet_ptr, unsigned char* data, size_t len) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return wallet->setDeviceSendData(data, len); DEBUG_END() } -void* MONERO_WalletManager_createWallet(void* wm_ptr, const char* path, const char* password, const char* language, int networkType) { +void* SALVIUM_WalletManager_createWallet(void* wm_ptr, const char* path, const char* password, const char* language, int networkType) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); Monero::Wallet *wallet = wm->createWallet( @@ -2173,7 +2173,7 @@ void* MONERO_WalletManager_createWallet(void* wm_ptr, const char* path, const ch DEBUG_END() } -void* MONERO_WalletManager_openWallet(void* wm_ptr, const char* path, const char* password, int networkType) { +void* SALVIUM_WalletManager_openWallet(void* wm_ptr, const char* path, const char* password, int networkType) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); Monero::Wallet *wallet = wm->openWallet( @@ -2183,7 +2183,7 @@ void* MONERO_WalletManager_openWallet(void* wm_ptr, const char* path, const char return reinterpret_cast(wallet); DEBUG_END() } -void* MONERO_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) { +void* SALVIUM_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) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); // (const std::string &path, const std::string &password, const std::string &mnemonic, @@ -2209,7 +2209,7 @@ void* MONERO_WalletManager_recoveryWallet(void* wm_ptr, const char* path, const // const std::string &viewKeyString, // const std::string &spendKeyString = "", // uint64_t kdf_rounds = 1) = 0; -void* MONERO_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) { +void* SALVIUM_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) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); Monero::Wallet *wallet = wm->createWalletFromKeys( @@ -2225,7 +2225,7 @@ void* MONERO_WalletManager_createWalletFromKeys(void* wm_ptr, const char* path, DEBUG_END() } -void* MONERO_WalletManager_createWalletFromDevice(void* wm_ptr, const char* path, const char* password, int nettype, const char* deviceName, uint64_t restoreHeight, const char* subaddressLookahead, const char* viewKeyString, const char* spendKeyString, uint64_t kdf_rounds) { +void* SALVIUM_WalletManager_createWalletFromDevice(void* wm_ptr, const char* path, const char* password, int nettype, const char* deviceName, uint64_t restoreHeight, const char* subaddressLookahead, const char* viewKeyString, const char* spendKeyString, uint64_t kdf_rounds) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); Monero::Wallet *wallet = wm->createWalletFromDevice(std::string(path), @@ -2239,7 +2239,7 @@ void* MONERO_WalletManager_createWalletFromDevice(void* wm_ptr, const char* path DEBUG_END() } -void* MONERO_WalletManager_createDeterministicWalletFromSpendKey(void* wm_ptr, const char* path, const char* password, +void* SALVIUM_WalletManager_createDeterministicWalletFromSpendKey(void* wm_ptr, const char* path, const char* password, const char* language, int nettype, uint64_t restoreHeight, const char* spendKeyString, uint64_t kdf_rounds) { DEBUG_START() @@ -2257,7 +2257,7 @@ void* MONERO_WalletManager_createDeterministicWalletFromSpendKey(void* wm_ptr, c DEBUG_END() } -void* MONERO_WalletManager_createWalletFromPolyseed(void* wm_ptr, const char* path, const char* password, +void* SALVIUM_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) { DEBUG_START() @@ -2274,7 +2274,7 @@ void* MONERO_WalletManager_createWalletFromPolyseed(void* wm_ptr, const char* pa } -bool MONERO_WalletManager_closeWallet(void* wm_ptr, void* wallet_ptr, bool store) { +bool SALVIUM_WalletManager_closeWallet(void* wm_ptr, void* wallet_ptr, bool store) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); @@ -2282,7 +2282,7 @@ bool MONERO_WalletManager_closeWallet(void* wm_ptr, void* wallet_ptr, bool store DEBUG_END() } -bool MONERO_WalletManager_walletExists(void* wm_ptr, const char* path) { +bool SALVIUM_WalletManager_walletExists(void* wm_ptr, const char* path) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); return wm->walletExists(std::string(path)); @@ -2290,7 +2290,7 @@ bool MONERO_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; -bool MONERO_WalletManager_verifyWalletPassword(void* wm_ptr, const char* keys_file_name, const char* password, bool no_spend_key, uint64_t kdf_rounds) { +bool SALVIUM_WalletManager_verifyWalletPassword(void* wm_ptr, const char* keys_file_name, const char* password, bool no_spend_key, uint64_t kdf_rounds) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); return wm->verifyWalletPassword(std::string(keys_file_name), std::string(password), no_spend_key, kdf_rounds); @@ -2298,7 +2298,7 @@ bool MONERO_WalletManager_verifyWalletPassword(void* wm_ptr, const char* keys_fi } // virtual bool queryWalletDevice(Wallet::Device& device_type, const std::string &keys_file_name, const std::string &password, uint64_t kdf_rounds = 1) const = 0; -int MONERO_WalletManager_queryWalletDevice(void* wm_ptr, const char* keys_file_name, const char* password, uint64_t kdf_rounds) { +int SALVIUM_WalletManager_queryWalletDevice(void* wm_ptr, const char* keys_file_name, const char* password, uint64_t kdf_rounds) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); Monero::Wallet::Device device_type; @@ -2308,7 +2308,7 @@ int MONERO_WalletManager_queryWalletDevice(void* wm_ptr, const char* keys_file_n } // virtual std::vector findWallets(const std::string &path) = 0; -const char* MONERO_WalletManager_findWallets(void* wm_ptr, const char* path, const char* separator) { +const char* SALVIUM_WalletManager_findWallets(void* wm_ptr, const char* path, const char* separator) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); return vectorToString(wm->findWallets(std::string(path)), std::string(separator)); @@ -2316,7 +2316,7 @@ const char* MONERO_WalletManager_findWallets(void* wm_ptr, const char* path, con } -const char* MONERO_WalletManager_errorString(void* wm_ptr) { +const char* SALVIUM_WalletManager_errorString(void* wm_ptr) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); std::string str = wm->errorString(); @@ -2327,14 +2327,14 @@ const char* MONERO_WalletManager_errorString(void* wm_ptr) { DEBUG_END() } -void MONERO_WalletManager_setDaemonAddress(void* wm_ptr, const char* address) { +void SALVIUM_WalletManager_setDaemonAddress(void* wm_ptr, const char* address) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); return wm->setDaemonAddress(std::string(address)); DEBUG_END() } -bool MONERO_WalletManager_setProxy(void* wm_ptr, const char* address) { +bool SALVIUM_WalletManager_setProxy(void* wm_ptr, const char* address) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); return wm->setProxy(std::string(address)); @@ -2344,63 +2344,63 @@ bool MONERO_WalletManager_setProxy(void* wm_ptr, const char* address) { // virtual bool connected(uint32_t *version = NULL) = 0; // virtual uint64_t blockchainHeight() = 0; -uint64_t MONERO_WalletManager_blockchainHeight(void* wm_ptr) { +uint64_t SALVIUM_WalletManager_blockchainHeight(void* wm_ptr) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); return wm->blockchainHeight(); DEBUG_END() } // virtual uint64_t blockchainTargetHeight() = 0; -uint64_t MONERO_WalletManager_blockchainTargetHeight(void* wm_ptr) { +uint64_t SALVIUM_WalletManager_blockchainTargetHeight(void* wm_ptr) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); return wm->blockchainTargetHeight(); DEBUG_END() } // virtual uint64_t networkDifficulty() = 0; -uint64_t MONERO_WalletManager_networkDifficulty(void* wm_ptr) { +uint64_t SALVIUM_WalletManager_networkDifficulty(void* wm_ptr) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); return wm->networkDifficulty(); DEBUG_END() } // virtual double miningHashRate() = 0; -double MONERO_WalletManager_miningHashRate(void* wm_ptr) { +double SALVIUM_WalletManager_miningHashRate(void* wm_ptr) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); return wm->miningHashRate(); DEBUG_END() } // virtual uint64_t blockTarget() = 0; -uint64_t MONERO_WalletManager_blockTarget(void* wm_ptr) { +uint64_t SALVIUM_WalletManager_blockTarget(void* wm_ptr) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); return wm->blockTarget(); DEBUG_END() } // virtual bool isMining() = 0; -bool MONERO_WalletManager_isMining(void* wm_ptr) { +bool SALVIUM_WalletManager_isMining(void* wm_ptr) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); return wm->isMining(); DEBUG_END() } // virtual bool startMining(const std::string &address, uint32_t threads = 1, bool background_mining = false, bool ignore_battery = true) = 0; -bool MONERO_WalletManager_startMining(void* wm_ptr, const char* address, uint32_t threads, bool backgroundMining, bool ignoreBattery) { +bool SALVIUM_WalletManager_startMining(void* wm_ptr, const char* address, uint32_t threads, bool backgroundMining, bool ignoreBattery) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); return wm->startMining(std::string(address), threads, backgroundMining, ignoreBattery); DEBUG_END() } // virtual bool stopMining() = 0; -bool MONERO_WalletManager_stopMining(void* wm_ptr, const char* address) { +bool SALVIUM_WalletManager_stopMining(void* wm_ptr, const char* address) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); return wm->stopMining(); DEBUG_END() } // virtual std::string resolveOpenAlias(const std::string &address, bool &dnssec_valid) const = 0; -const char* MONERO_WalletManager_resolveOpenAlias(void* wm_ptr, const char* address, bool dnssec_valid) { +const char* SALVIUM_WalletManager_resolveOpenAlias(void* wm_ptr, const char* address, bool dnssec_valid) { DEBUG_START() Monero::WalletManager *wm = reinterpret_cast(wm_ptr); std::string str = wm->resolveOpenAlias(std::string(address), dnssec_valid); @@ -2413,20 +2413,20 @@ const char* MONERO_WalletManager_resolveOpenAlias(void* wm_ptr, const char* addr // WalletManagerFactory -void* MONERO_WalletManagerFactory_getWalletManager() { +void* SALVIUM_WalletManagerFactory_getWalletManager() { DEBUG_START() Monero::WalletManager *wm = Monero::WalletManagerFactory::getWalletManager(); return reinterpret_cast(wm); DEBUG_END() } -void MONERO_WalletManagerFactory_setLogLevel(int level) { +void SALVIUM_WalletManagerFactory_setLogLevel(int level) { DEBUG_START() return Monero::WalletManagerFactory::setLogLevel(level); DEBUG_END() } -void MONERO_WalletManagerFactory_setLogCategories(const char* categories) { +void SALVIUM_WalletManagerFactory_setLogCategories(const char* categories) { DEBUG_START() return Monero::WalletManagerFactory::setLogCategories(std::string(categories)); DEBUG_END() @@ -2442,39 +2442,39 @@ void MONERO_WalletManagerFactory_setLogCategories(const char* categories) { // 4) void* // 5) const char* -void MONERO_DEBUG_test0() { +void SALVIUM_DEBUG_test0() { return; } -bool MONERO_DEBUG_test1(bool x) { +bool SALVIUM_DEBUG_test1(bool x) { return x; } -int MONERO_DEBUG_test2(int x) { +int SALVIUM_DEBUG_test2(int x) { return x; } -uint64_t MONERO_DEBUG_test3(uint64_t x) { +uint64_t SALVIUM_DEBUG_test3(uint64_t x) { return x; } -void* MONERO_DEBUG_test4(uint64_t x) { +void* SALVIUM_DEBUG_test4(uint64_t x) { int *y = new int(x); return reinterpret_cast(y); } -const char* MONERO_DEBUG_test5() { +const char* SALVIUM_DEBUG_test5() { const char *text = "This is a const char* text"; return text; } -const char* MONERO_DEBUG_test5_std() { +const char* SALVIUM_DEBUG_test5_std() { std::string text("This is a std::string text"); const char *text2 = "This is a text"; return text2; } -bool MONERO_DEBUG_isPointerNull(void* wallet_ptr) { +bool SALVIUM_DEBUG_isPointerNull(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); return (wallet != NULL); @@ -2486,14 +2486,14 @@ bool MONERO_DEBUG_isPointerNull(void* wallet_ptr) { // callback to dart should be possible..? I mean why not? But I need to // wait for other implementation (Go preferably) to see if this approach // will work as expected. -struct MONERO_cw_WalletListener; -struct MONERO_cw_WalletListener : Monero::WalletListener +struct SALVIUM_cw_WalletListener; +struct SALVIUM_cw_WalletListener : Monero::WalletListener { uint64_t m_height; bool m_need_to_refresh; bool m_new_transaction; - MONERO_cw_WalletListener() + SALVIUM_cw_WalletListener() { m_height = 0; m_need_to_refresh = false; @@ -2557,62 +2557,62 @@ struct MONERO_cw_WalletListener : Monero::WalletListener } }; -void* MONERO_cw_getWalletListener(void* wallet_ptr) { +void* SALVIUM_cw_getWalletListener(void* wallet_ptr) { DEBUG_START() Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - MONERO_cw_WalletListener *listener = new MONERO_cw_WalletListener(); + SALVIUM_cw_WalletListener *listener = new SALVIUM_cw_WalletListener(); wallet->setListener(listener); return reinterpret_cast(listener); DEBUG_END() } -void MONERO_cw_WalletListener_resetNeedToRefresh(void* cw_walletListener_ptr) { +void SALVIUM_cw_WalletListener_resetNeedToRefresh(void* cw_walletListener_ptr) { DEBUG_START() - MONERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); + SALVIUM_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); listener->cw_resetNeedToRefresh(); DEBUG_END() } -bool MONERO_cw_WalletListener_isNeedToRefresh(void* cw_walletListener_ptr) { +bool SALVIUM_cw_WalletListener_isNeedToRefresh(void* cw_walletListener_ptr) { DEBUG_START() - MONERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); + SALVIUM_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); return listener->cw_isNeedToRefresh(); DEBUG_END() }; -bool MONERO_cw_WalletListener_isNewTransactionExist(void* cw_walletListener_ptr) { +bool SALVIUM_cw_WalletListener_isNewTransactionExist(void* cw_walletListener_ptr) { DEBUG_START() - MONERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); + SALVIUM_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); return listener->cw_isNeedToRefresh(); DEBUG_END() }; -void MONERO_cw_WalletListener_resetIsNewTransactionExist(void* cw_walletListener_ptr) { +void SALVIUM_cw_WalletListener_resetIsNewTransactionExist(void* cw_walletListener_ptr) { DEBUG_START() - MONERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); + SALVIUM_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); listener->cw_isNeedToRefresh(); DEBUG_END() }; -uint64_t MONERO_cw_WalletListener_height(void* cw_walletListener_ptr) { +uint64_t SALVIUM_cw_WalletListener_height(void* cw_walletListener_ptr) { DEBUG_START() - MONERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); + SALVIUM_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); return listener->cw_isNeedToRefresh(); DEBUG_END() }; -const char* MONERO_checksum_wallet2_api_c_h() { - return MONERO_wallet2_api_c_h_sha256; +const char* SALVIUM_checksum_wallet2_api_c_h() { + return SALVIUM_wallet2_api_c_h_sha256; } -const char* MONERO_checksum_wallet2_api_c_cpp() { - return MONERO_wallet2_api_c_cpp_sha256; +const char* SALVIUM_checksum_wallet2_api_c_cpp() { + return SALVIUM_wallet2_api_c_cpp_sha256; } -const char* MONERO_checksum_wallet2_api_c_exp() { - return MONERO_wallet2_api_c_exp_sha256; +const char* SALVIUM_checksum_wallet2_api_c_exp() { + return SALVIUM_wallet2_api_c_exp_sha256; } // i hate windows -void MONERO_free(void* ptr) { +void SALVIUM_free(void* ptr) { free(ptr); } diff --git a/salvium_libwallet2_api_c/src/main/cpp/wallet2_api_c.h b/salvium_libwallet2_api_c/src/main/cpp/wallet2_api_c.h index 17c647c..fd8a5ef 100644 --- a/salvium_libwallet2_api_c/src/main/cpp/wallet2_api_c.h +++ b/salvium_libwallet2_api_c/src/main/cpp/wallet2_api_c.h @@ -10,7 +10,7 @@ #include #include #include -#include "monero_checksum.h" +#include "salvium_checksum.h" #ifdef __cplusplus extern "C" @@ -73,36 +73,36 @@ const int Priority_Last = 4; // }; // virtual ~PendingTransaction() = 0; // virtual int status() const = 0; -extern ADDAPI int MONERO_PendingTransaction_status(void* pendingTx_ptr); +extern ADDAPI int SALVIUM_PendingTransaction_status(void* pendingTx_ptr); // virtual std::string errorString() const = 0; -extern ADDAPI const char* MONERO_PendingTransaction_errorString(void* pendingTx_ptr); +extern ADDAPI const char* SALVIUM_PendingTransaction_errorString(void* pendingTx_ptr); // virtual bool commit(const std::string &filename = "", bool overwrite = false) = 0; -extern ADDAPI bool MONERO_PendingTransaction_commit(void* pendingTx_ptr, const char* filename, bool overwrite); -extern ADDAPI const char* MONERO_PendingTransaction_commitUR(void* pendingTx_ptr, int max_fragment_length); +extern ADDAPI bool SALVIUM_PendingTransaction_commit(void* pendingTx_ptr, const char* filename, bool overwrite); +extern ADDAPI const char* SALVIUM_PendingTransaction_commitUR(void* pendingTx_ptr, int max_fragment_length); // virtual uint64_t amount() const = 0; -extern ADDAPI uint64_t MONERO_PendingTransaction_amount(void* pendingTx_ptr); +extern ADDAPI uint64_t SALVIUM_PendingTransaction_amount(void* pendingTx_ptr); // virtual uint64_t dust() const = 0; -extern ADDAPI uint64_t MONERO_PendingTransaction_dust(void* pendingTx_ptr); +extern ADDAPI uint64_t SALVIUM_PendingTransaction_dust(void* pendingTx_ptr); // virtual uint64_t fee() const = 0; -extern ADDAPI uint64_t MONERO_PendingTransaction_fee(void* pendingTx_ptr); +extern ADDAPI uint64_t SALVIUM_PendingTransaction_fee(void* pendingTx_ptr); // virtual std::vector txid() const = 0; -extern ADDAPI const char* MONERO_PendingTransaction_txid(void* pendingTx_ptr, const char* separator); +extern ADDAPI const char* SALVIUM_PendingTransaction_txid(void* pendingTx_ptr, const char* separator); // virtual uint64_t txCount() const = 0; -extern ADDAPI uint64_t MONERO_PendingTransaction_txCount(void* pendingTx_ptr); +extern ADDAPI uint64_t SALVIUM_PendingTransaction_txCount(void* pendingTx_ptr); // virtual std::vector subaddrAccount() const = 0; -extern ADDAPI const char* MONERO_PendingTransaction_subaddrAccount(void* pendingTx_ptr, const char* separator); +extern ADDAPI const char* SALVIUM_PendingTransaction_subaddrAccount(void* pendingTx_ptr, const char* separator); // virtual std::vector> subaddrIndices() const = 0; -extern ADDAPI const char* MONERO_PendingTransaction_subaddrIndices(void* pendingTx_ptr, const char* separator); +extern ADDAPI const char* SALVIUM_PendingTransaction_subaddrIndices(void* pendingTx_ptr, const char* separator); // virtual std::string multisigSignData() = 0; -extern ADDAPI const char* MONERO_PendingTransaction_multisigSignData(void* pendingTx_ptr); +extern ADDAPI const char* SALVIUM_PendingTransaction_multisigSignData(void* pendingTx_ptr); // virtual void signMultisigTx() = 0; -extern ADDAPI void MONERO_PendingTransaction_signMultisigTx(void* pendingTx_ptr); +extern ADDAPI void SALVIUM_PendingTransaction_signMultisigTx(void* pendingTx_ptr); // virtual std::vector signersKeys() const = 0; -extern ADDAPI const char* MONERO_PendingTransaction_signersKeys(void* pendingTx_ptr, const char* separator); +extern ADDAPI const char* SALVIUM_PendingTransaction_signersKeys(void* pendingTx_ptr, const char* separator); // virtual std::vector hex() const = 0; -extern ADDAPI const char* MONERO_PendingTransaction_hex(void* pendingTx_ptr, const char* separator); +extern ADDAPI const char* SALVIUM_PendingTransaction_hex(void* pendingTx_ptr, const char* separator); // virtual std::vector txKey() const = 0; -// extern ADDAPI const char* MONERO_PendingTransaction_txHex(void* pendingTx_ptr, const char* separator); +// extern ADDAPI const char* SALVIUM_PendingTransaction_txHex(void* pendingTx_ptr, const char* separator); // }; // struct UnsignedTransaction @@ -117,28 +117,28 @@ const int UnsignedTransactionStatus_Critical = 2; // }; // virtual ~UnsignedTransaction() = 0; // virtual int status() const = 0; -extern ADDAPI int MONERO_UnsignedTransaction_status(void* unsignedTx_ptr); +extern ADDAPI int SALVIUM_UnsignedTransaction_status(void* unsignedTx_ptr); // virtual std::string errorString() const = 0; -extern ADDAPI const char* MONERO_UnsignedTransaction_errorString(void* unsignedTx_ptr); +extern ADDAPI const char* SALVIUM_UnsignedTransaction_errorString(void* unsignedTx_ptr); // virtual std::vector amount() const = 0; -extern ADDAPI const char* MONERO_UnsignedTransaction_amount(void* unsignedTx_ptr, const char* separator); +extern ADDAPI const char* SALVIUM_UnsignedTransaction_amount(void* unsignedTx_ptr, const char* separator); // virtual std::vector fee() const = 0; -extern ADDAPI const char* MONERO_UnsignedTransaction_fee(void* unsignedTx_ptr, const char* separator); +extern ADDAPI const char* SALVIUM_UnsignedTransaction_fee(void* unsignedTx_ptr, const char* separator); // virtual std::vector mixin() const = 0; -extern ADDAPI const char* MONERO_UnsignedTransaction_mixin(void* unsignedTx_ptr, const char* separator); +extern ADDAPI const char* SALVIUM_UnsignedTransaction_mixin(void* unsignedTx_ptr, const char* separator); // virtual std::string confirmationMessage() const = 0; -extern ADDAPI const char* MONERO_UnsignedTransaction_confirmationMessage(void* unsignedTx_ptr); +extern ADDAPI const char* SALVIUM_UnsignedTransaction_confirmationMessage(void* unsignedTx_ptr); // virtual std::vector paymentId() const = 0; -extern ADDAPI const char* MONERO_UnsignedTransaction_paymentId(void* unsignedTx_ptr, const char* separator); +extern ADDAPI const char* SALVIUM_UnsignedTransaction_paymentId(void* unsignedTx_ptr, const char* separator); // virtual std::vector recipientAddress() const = 0; -extern ADDAPI const char* MONERO_UnsignedTransaction_recipientAddress(void* unsignedTx_ptr, const char* separator); +extern ADDAPI const char* SALVIUM_UnsignedTransaction_recipientAddress(void* unsignedTx_ptr, const char* separator); // virtual uint64_t minMixinCount() const = 0; -extern ADDAPI uint64_t MONERO_UnsignedTransaction_minMixinCount(void* unsignedTx_ptr); +extern ADDAPI uint64_t SALVIUM_UnsignedTransaction_minMixinCount(void* unsignedTx_ptr); // virtual uint64_t txCount() const = 0; -extern ADDAPI uint64_t MONERO_UnsignedTransaction_txCount(void* unsignedTx_ptr); +extern ADDAPI uint64_t SALVIUM_UnsignedTransaction_txCount(void* unsignedTx_ptr); // virtual bool sign(const std::string &signedFileName) = 0; -extern ADDAPI bool MONERO_UnsignedTransaction_sign(void* unsignedTx_ptr, const char* signedFileName); -extern ADDAPI const char* MONERO_UnsignedTransaction_signUR(void* unsignedTx_ptr, int max_fragment_length); +extern ADDAPI bool SALVIUM_UnsignedTransaction_sign(void* unsignedTx_ptr, const char* signedFileName); +extern ADDAPI const char* SALVIUM_UnsignedTransaction_signUR(void* unsignedTx_ptr, int max_fragment_length); // }; // struct TransactionInfo // { @@ -155,56 +155,56 @@ const int TransactionInfoDirection_Out = 1; // }; // virtual ~TransactionInfo() = 0; // virtual int direction() const = 0; -extern ADDAPI int MONERO_TransactionInfo_direction(void* txInfo_ptr); +extern ADDAPI int SALVIUM_TransactionInfo_direction(void* txInfo_ptr); // virtual bool isPending() const = 0; -extern ADDAPI bool MONERO_TransactionInfo_isPending(void* txInfo_ptr); +extern ADDAPI bool SALVIUM_TransactionInfo_isPending(void* txInfo_ptr); // virtual bool isFailed() const = 0; -extern ADDAPI bool MONERO_TransactionInfo_isFailed(void* txInfo_ptr); +extern ADDAPI bool SALVIUM_TransactionInfo_isFailed(void* txInfo_ptr); // virtual bool isCoinbase() const = 0; -extern ADDAPI bool MONERO_TransactionInfo_isCoinbase(void* txInfo_ptr); +extern ADDAPI bool SALVIUM_TransactionInfo_isCoinbase(void* txInfo_ptr); // virtual uint64_t amount() const = 0; -extern ADDAPI uint64_t MONERO_TransactionInfo_amount(void* txInfo_ptr); +extern ADDAPI uint64_t SALVIUM_TransactionInfo_amount(void* txInfo_ptr); // virtual uint64_t fee() const = 0; -extern ADDAPI uint64_t MONERO_TransactionInfo_fee(void* txInfo_ptr); +extern ADDAPI uint64_t SALVIUM_TransactionInfo_fee(void* txInfo_ptr); // virtual uint64_t blockHeight() const = 0; -extern ADDAPI uint64_t MONERO_TransactionInfo_blockHeight(void* txInfo_ptr); +extern ADDAPI uint64_t SALVIUM_TransactionInfo_blockHeight(void* txInfo_ptr); // virtual std::string description() const = 0; -extern ADDAPI const char* MONERO_TransactionInfo_description(void* txInfo_ptr); +extern ADDAPI const char* SALVIUM_TransactionInfo_description(void* txInfo_ptr); // virtual std::set subaddrIndex() const = 0; -extern ADDAPI const char* MONERO_TransactionInfo_subaddrIndex(void* txInfo_ptr, const char* separator); +extern ADDAPI const char* SALVIUM_TransactionInfo_subaddrIndex(void* txInfo_ptr, const char* separator); // virtual uint32_t subaddrAccount() const = 0; -extern ADDAPI uint32_t MONERO_TransactionInfo_subaddrAccount(void* txInfo_ptr); +extern ADDAPI uint32_t SALVIUM_TransactionInfo_subaddrAccount(void* txInfo_ptr); // virtual std::string label() const = 0; -extern ADDAPI const char* MONERO_TransactionInfo_label(void* txInfo_ptr); +extern ADDAPI const char* SALVIUM_TransactionInfo_label(void* txInfo_ptr); // virtual uint64_t confirmations() const = 0; -extern ADDAPI uint64_t MONERO_TransactionInfo_confirmations(void* txInfo_ptr); +extern ADDAPI uint64_t SALVIUM_TransactionInfo_confirmations(void* txInfo_ptr); // virtual uint64_t unlockTime() const = 0; -extern ADDAPI uint64_t MONERO_TransactionInfo_unlockTime(void* txInfo_ptr); +extern ADDAPI uint64_t SALVIUM_TransactionInfo_unlockTime(void* txInfo_ptr); // virtual std::string hash() const = 0; -extern ADDAPI const char* MONERO_TransactionInfo_hash(void* txInfo_ptr); +extern ADDAPI const char* SALVIUM_TransactionInfo_hash(void* txInfo_ptr); // virtual std::time_t timestamp() const = 0; -extern ADDAPI uint64_t MONERO_TransactionInfo_timestamp(void* txInfo_ptr); +extern ADDAPI uint64_t SALVIUM_TransactionInfo_timestamp(void* txInfo_ptr); // virtual std::string paymentId() const = 0; -extern ADDAPI const char* MONERO_TransactionInfo_paymentId(void* txInfo_ptr); +extern ADDAPI const char* SALVIUM_TransactionInfo_paymentId(void* txInfo_ptr); // virtual const std::vector & transfers() const = 0; -extern ADDAPI int MONERO_TransactionInfo_transfers_count(void* txInfo_ptr); -extern ADDAPI uint64_t MONERO_TransactionInfo_transfers_amount(void* txInfo_ptr, int index); -extern ADDAPI const char* MONERO_TransactionInfo_transfers_address(void* txInfo_ptr, int address); +extern ADDAPI int SALVIUM_TransactionInfo_transfers_count(void* txInfo_ptr); +extern ADDAPI uint64_t SALVIUM_TransactionInfo_transfers_amount(void* txInfo_ptr, int index); +extern ADDAPI const char* SALVIUM_TransactionInfo_transfers_address(void* txInfo_ptr, int address); // }; // struct TransactionHistory // { // virtual ~TransactionHistory() = 0; // virtual int count() const = 0; -extern ADDAPI int MONERO_TransactionHistory_count(void* txHistory_ptr); +extern ADDAPI int SALVIUM_TransactionHistory_count(void* txHistory_ptr); // virtual TransactionInfo * transaction(int index) const = 0; -extern ADDAPI void* MONERO_TransactionHistory_transaction(void* txHistory_ptr, int index); +extern ADDAPI void* SALVIUM_TransactionHistory_transaction(void* txHistory_ptr, int index); // virtual TransactionInfo * transaction(const std::string &id) const = 0; -extern ADDAPI void* MONERO_TransactionHistory_transactionById(void* txHistory_ptr, const char* id); +extern ADDAPI void* SALVIUM_TransactionHistory_transactionById(void* txHistory_ptr, const char* id); // virtual std::vector getAll() const = 0; // virtual void refresh() = 0; -extern ADDAPI void MONERO_TransactionHistory_refresh(void* txHistory_ptr); +extern ADDAPI void SALVIUM_TransactionHistory_refresh(void* txHistory_ptr); // virtual void setTxNote(const std::string &txid, const std::string ¬e) = 0; -extern ADDAPI void MONERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, const char* note); +extern ADDAPI void SALVIUM_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, const char* note); // }; // struct AddressBookRow { // public: @@ -221,15 +221,15 @@ extern ADDAPI void MONERO_TransactionHistory_setTxNote(void* txHistory_ptr, cons // std::string m_description; // public: // std::string extra; -extern ADDAPI const char* MONERO_AddressBookRow_extra(void* addressBookRow_ptr); +extern ADDAPI const char* SALVIUM_AddressBookRow_extra(void* addressBookRow_ptr); // std::string getAddress() const {return m_address;} -extern ADDAPI const char* MONERO_AddressBookRow_getAddress(void* addressBookRow_ptr); +extern ADDAPI const char* SALVIUM_AddressBookRow_getAddress(void* addressBookRow_ptr); // std::string getDescription() const {return m_description;} -extern ADDAPI const char* MONERO_AddressBookRow_getDescription(void* addressBookRow_ptr); +extern ADDAPI const char* SALVIUM_AddressBookRow_getDescription(void* addressBookRow_ptr); // std::string getPaymentId() const {return m_paymentId;} -extern ADDAPI const char* MONERO_AddressBookRow_getPaymentId(void* addressBookRow_ptr); +extern ADDAPI const char* SALVIUM_AddressBookRow_getPaymentId(void* addressBookRow_ptr); // std::size_t getRowId() const {return m_rowId;} -extern ADDAPI size_t MONERO_AddressBookRow_getRowId(void* addressBookRow_ptr); +extern ADDAPI size_t SALVIUM_AddressBookRow_getRowId(void* addressBookRow_ptr); // }; // struct AddressBook // { @@ -245,93 +245,93 @@ const int AddressBookErrorCodeInvalidPaymentId = 3; // }; // virtual ~AddressBook() = 0; // virtual std::vector getAll() const = 0; -extern ADDAPI int MONERO_AddressBook_getAll_size(void* addressBook_ptr); -extern ADDAPI void* MONERO_AddressBook_getAll_byIndex(void* addressBook_ptr, int index); +extern ADDAPI int SALVIUM_AddressBook_getAll_size(void* addressBook_ptr); +extern ADDAPI void* SALVIUM_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 MONERO_AddressBook_addRow(void* addressBook_ptr, const char* dst_addr , const char* payment_id, const char* description); +extern ADDAPI bool SALVIUM_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 MONERO_AddressBook_deleteRow(void* addressBook_ptr, size_t rowId); +extern ADDAPI bool SALVIUM_AddressBook_deleteRow(void* addressBook_ptr, size_t rowId); // virtual bool setDescription(std::size_t index, const std::string &description) = 0; -extern ADDAPI bool MONERO_AddressBook_setDescription(void* addressBook_ptr, size_t rowId, const char* description); +extern ADDAPI bool SALVIUM_AddressBook_setDescription(void* addressBook_ptr, size_t rowId, const char* description); // virtual void refresh() = 0; -extern ADDAPI void MONERO_AddressBook_refresh(void* addressBook_ptr); +extern ADDAPI void SALVIUM_AddressBook_refresh(void* addressBook_ptr); // virtual std::string errorString() const = 0; -extern ADDAPI const char* MONERO_AddressBook_errorString(void* addressBook_ptr); +extern ADDAPI const char* SALVIUM_AddressBook_errorString(void* addressBook_ptr); // virtual int errorCode() const = 0; -extern ADDAPI int MONERO_AddressBook_errorCode(void* addressBook_ptr); +extern ADDAPI int SALVIUM_AddressBook_errorCode(void* addressBook_ptr); // virtual int lookupPaymentID(const std::string &payment_id) const = 0; -extern ADDAPI int MONERO_AddressBook_lookupPaymentID(void* addressBook_ptr, const char* payment_id); +extern ADDAPI int SALVIUM_AddressBook_lookupPaymentID(void* addressBook_ptr, const char* payment_id); // }; // struct CoinsInfo // { // virtual ~CoinsInfo() = 0; // virtual uint64_t blockHeight() const = 0; -extern ADDAPI uint64_t MONERO_CoinsInfo_blockHeight(void* coinsInfo_ptr); +extern ADDAPI uint64_t SALVIUM_CoinsInfo_blockHeight(void* coinsInfo_ptr); // virtual std::string hash() const = 0; -extern ADDAPI const char* MONERO_CoinsInfo_hash(void* coinsInfo_ptr); +extern ADDAPI const char* SALVIUM_CoinsInfo_hash(void* coinsInfo_ptr); // virtual size_t internalOutputIndex() const = 0; -extern ADDAPI size_t MONERO_CoinsInfo_internalOutputIndex(void* coinsInfo_ptr); +extern ADDAPI size_t SALVIUM_CoinsInfo_internalOutputIndex(void* coinsInfo_ptr); // virtual uint64_t globalOutputIndex() const = 0; -extern ADDAPI uint64_t MONERO_CoinsInfo_globalOutputIndex(void* coinsInfo_ptr); +extern ADDAPI uint64_t SALVIUM_CoinsInfo_globalOutputIndex(void* coinsInfo_ptr); // virtual bool spent() const = 0; -extern ADDAPI bool MONERO_CoinsInfo_spent(void* coinsInfo_ptr); +extern ADDAPI bool SALVIUM_CoinsInfo_spent(void* coinsInfo_ptr); // virtual bool frozen() const = 0; -extern ADDAPI bool MONERO_CoinsInfo_frozen(void* coinsInfo_ptr); +extern ADDAPI bool SALVIUM_CoinsInfo_frozen(void* coinsInfo_ptr); // virtual uint64_t spentHeight() const = 0; -extern ADDAPI uint64_t MONERO_CoinsInfo_spentHeight(void* coinsInfo_ptr); +extern ADDAPI uint64_t SALVIUM_CoinsInfo_spentHeight(void* coinsInfo_ptr); // virtual uint64_t amount() const = 0; -extern ADDAPI uint64_t MONERO_CoinsInfo_amount(void* coinsInfo_ptr); +extern ADDAPI uint64_t SALVIUM_CoinsInfo_amount(void* coinsInfo_ptr); // virtual bool rct() const = 0; -extern ADDAPI bool MONERO_CoinsInfo_rct(void* coinsInfo_ptr); +extern ADDAPI bool SALVIUM_CoinsInfo_rct(void* coinsInfo_ptr); // virtual bool keyImageKnown() const = 0; -extern ADDAPI bool MONERO_CoinsInfo_keyImageKnown(void* coinsInfo_ptr); +extern ADDAPI bool SALVIUM_CoinsInfo_keyImageKnown(void* coinsInfo_ptr); // virtual size_t pkIndex() const = 0; -extern ADDAPI size_t MONERO_CoinsInfo_pkIndex(void* coinsInfo_ptr); +extern ADDAPI size_t SALVIUM_CoinsInfo_pkIndex(void* coinsInfo_ptr); // virtual uint32_t subaddrIndex() const = 0; -extern ADDAPI uint32_t MONERO_CoinsInfo_subaddrIndex(void* coinsInfo_ptr); +extern ADDAPI uint32_t SALVIUM_CoinsInfo_subaddrIndex(void* coinsInfo_ptr); // virtual uint32_t subaddrAccount() const = 0; -extern ADDAPI uint32_t MONERO_CoinsInfo_subaddrAccount(void* coinsInfo_ptr); +extern ADDAPI uint32_t SALVIUM_CoinsInfo_subaddrAccount(void* coinsInfo_ptr); // virtual std::string address() const = 0; -extern ADDAPI const char* MONERO_CoinsInfo_address(void* coinsInfo_ptr); +extern ADDAPI const char* SALVIUM_CoinsInfo_address(void* coinsInfo_ptr); // virtual std::string addressLabel() const = 0; -extern ADDAPI const char* MONERO_CoinsInfo_addressLabel(void* coinsInfo_ptr); +extern ADDAPI const char* SALVIUM_CoinsInfo_addressLabel(void* coinsInfo_ptr); // virtual std::string keyImage() const = 0; -extern ADDAPI const char* MONERO_CoinsInfo_keyImage(void* coinsInfo_ptr); +extern ADDAPI const char* SALVIUM_CoinsInfo_keyImage(void* coinsInfo_ptr); // virtual uint64_t unlockTime() const = 0; -extern ADDAPI uint64_t MONERO_CoinsInfo_unlockTime(void* coinsInfo_ptr); +extern ADDAPI uint64_t SALVIUM_CoinsInfo_unlockTime(void* coinsInfo_ptr); // virtual bool unlocked() const = 0; -extern ADDAPI bool MONERO_CoinsInfo_unlocked(void* coinsInfo_ptr); +extern ADDAPI bool SALVIUM_CoinsInfo_unlocked(void* coinsInfo_ptr); // virtual std::string pubKey() const = 0; -extern ADDAPI const char* MONERO_CoinsInfo_pubKey(void* coinsInfo_ptr); +extern ADDAPI const char* SALVIUM_CoinsInfo_pubKey(void* coinsInfo_ptr); // virtual bool coinbase() const = 0; -extern ADDAPI bool MONERO_CoinsInfo_coinbase(void* coinsInfo_ptr); +extern ADDAPI bool SALVIUM_CoinsInfo_coinbase(void* coinsInfo_ptr); // virtual std::string description() const = 0; -extern ADDAPI const char* MONERO_CoinsInfo_description(void* coinsInfo_ptr); +extern ADDAPI const char* SALVIUM_CoinsInfo_description(void* coinsInfo_ptr); // }; // struct Coins // { // virtual ~Coins() = 0; // virtual int count() const = 0; -extern ADDAPI int MONERO_Coins_count(void* coins_ptr); +extern ADDAPI int SALVIUM_Coins_count(void* coins_ptr); // virtual CoinsInfo * coin(int index) const = 0; -extern ADDAPI void* MONERO_Coins_coin(void* coins_ptr, int index); +extern ADDAPI void* SALVIUM_Coins_coin(void* coins_ptr, int index); // virtual std::vector getAll() const = 0; -extern ADDAPI int MONERO_Coins_getAll_size(void* coins_ptr); -extern ADDAPI void* MONERO_Coins_getAll_byIndex(void* coins_ptr, int index); +extern ADDAPI int SALVIUM_Coins_getAll_size(void* coins_ptr); +extern ADDAPI void* SALVIUM_Coins_getAll_byIndex(void* coins_ptr, int index); // virtual void refresh() = 0; -extern ADDAPI void MONERO_Coins_refresh(void* coins_ptr); +extern ADDAPI void SALVIUM_Coins_refresh(void* coins_ptr); // virtual void setFrozen(std::string public_key) = 0; -extern ADDAPI void MONERO_Coins_setFrozenByPublicKey(void* coins_ptr, const char* public_key); +extern ADDAPI void SALVIUM_Coins_setFrozenByPublicKey(void* coins_ptr, const char* public_key); // virtual void setFrozen(int index) = 0; -extern ADDAPI void MONERO_Coins_setFrozen(void* coins_ptr, int index); +extern ADDAPI void SALVIUM_Coins_setFrozen(void* coins_ptr, int index); // virtual void thaw(int index) = 0; -extern ADDAPI void MONERO_Coins_thaw(void* coins_ptr, int index); +extern ADDAPI void SALVIUM_Coins_thaw(void* coins_ptr, int index); // virtual void thaw(std::string public_key) = 0; -extern ADDAPI void MONERO_Coins_thawByPublicKey(void* coins_ptr, const char* public_key); +extern ADDAPI void SALVIUM_Coins_thawByPublicKey(void* coins_ptr, const char* public_key); // virtual bool isTransferUnlocked(uint64_t unlockTime, uint64_t blockHeight) = 0; -extern ADDAPI bool MONERO_Coins_isTransferUnlocked(void* coins_ptr, uint64_t unlockTime, uint64_t blockHeight); +extern ADDAPI bool SALVIUM_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 MONERO_Coins_setDescription(void* coins_ptr, const char* public_key, const char* description); +extern ADDAPI void SALVIUM_Coins_setDescription(void* coins_ptr, const char* public_key, const char* description); // }; // struct SubaddressRow { // public: @@ -346,27 +346,27 @@ extern ADDAPI void MONERO_Coins_setDescription(void* coins_ptr, const char* publ // std::string m_label; // public: // std::string extra; -extern ADDAPI const char* MONERO_SubaddressRow_extra(void* subaddressRow_ptr); +extern ADDAPI const char* SALVIUM_SubaddressRow_extra(void* subaddressRow_ptr); // std::string getAddress() const {return m_address;} -extern ADDAPI const char* MONERO_SubaddressRow_getAddress(void* subaddressRow_ptr); +extern ADDAPI const char* SALVIUM_SubaddressRow_getAddress(void* subaddressRow_ptr); // std::string getLabel() const {return m_label;} -extern ADDAPI const char* MONERO_SubaddressRow_getLabel(void* subaddressRow_ptr); +extern ADDAPI const char* SALVIUM_SubaddressRow_getLabel(void* subaddressRow_ptr); // std::size_t getRowId() const {return m_rowId;} -extern ADDAPI size_t MONERO_SubaddressRow_getRowId(void* subaddressRow_ptr); +extern ADDAPI size_t SALVIUM_SubaddressRow_getRowId(void* subaddressRow_ptr); // }; // struct Subaddress // { // virtual ~Subaddress() = 0; // virtual std::vector getAll() const = 0; -extern ADDAPI int MONERO_Subaddress_getAll_size(void* subaddress_ptr); -extern ADDAPI void* MONERO_Subaddress_getAll_byIndex(void* subaddress_ptr, int index); +extern ADDAPI int SALVIUM_Subaddress_getAll_size(void* subaddress_ptr); +extern ADDAPI void* SALVIUM_Subaddress_getAll_byIndex(void* subaddress_ptr, int index); // virtual void addRow(uint32_t accountIndex, const std::string &label) = 0; -extern ADDAPI void MONERO_Subaddress_addRow(void* subaddress_ptr, uint32_t accountIndex, const char* label); +extern ADDAPI void SALVIUM_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 MONERO_Subaddress_setLabel(void* subaddress_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label); +extern ADDAPI void SALVIUM_Subaddress_setLabel(void* subaddress_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label); // virtual void refresh(uint32_t accountIndex) = 0; -extern ADDAPI void MONERO_Subaddress_refresh(void* subaddress_ptr, uint32_t accountIndex); +extern ADDAPI void SALVIUM_Subaddress_refresh(void* subaddress_ptr, uint32_t accountIndex); // }; // struct SubaddressAccountRow { @@ -386,44 +386,44 @@ extern ADDAPI void MONERO_Subaddress_refresh(void* subaddress_ptr, uint32_t acco // std::string m_unlockedBalance; // public: // std::string extra; -extern ADDAPI const char* MONERO_SubaddressAccountRow_extra(void* subaddressAccountRow_ptr); +extern ADDAPI const char* SALVIUM_SubaddressAccountRow_extra(void* subaddressAccountRow_ptr); // std::string getAddress() const {return m_address;} -extern ADDAPI const char* MONERO_SubaddressAccountRow_getAddress(void* subaddressAccountRow_ptr); +extern ADDAPI const char* SALVIUM_SubaddressAccountRow_getAddress(void* subaddressAccountRow_ptr); // std::string getLabel() const {return m_label;} -extern ADDAPI const char* MONERO_SubaddressAccountRow_getLabel(void* subaddressAccountRow_ptr); +extern ADDAPI const char* SALVIUM_SubaddressAccountRow_getLabel(void* subaddressAccountRow_ptr); // std::string getBalance() const {return m_balance;} -extern ADDAPI const char* MONERO_SubaddressAccountRow_getBalance(void* subaddressAccountRow_ptr); +extern ADDAPI const char* SALVIUM_SubaddressAccountRow_getBalance(void* subaddressAccountRow_ptr); // std::string getUnlockedBalance() const {return m_unlockedBalance;} -extern ADDAPI const char* MONERO_SubaddressAccountRow_getUnlockedBalance(void* subaddressAccountRow_ptr); +extern ADDAPI const char* SALVIUM_SubaddressAccountRow_getUnlockedBalance(void* subaddressAccountRow_ptr); // std::size_t getRowId() const {return m_rowId;} -extern ADDAPI size_t MONERO_SubaddressAccountRow_getRowId(void* subaddressAccountRow_ptr); +extern ADDAPI size_t SALVIUM_SubaddressAccountRow_getRowId(void* subaddressAccountRow_ptr); // }; // struct SubaddressAccount // { // virtual ~SubaddressAccount() = 0; // virtual std::vector getAll() const = 0; -extern ADDAPI int MONERO_SubaddressAccount_getAll_size(void* subaddressAccount_ptr); -extern ADDAPI void* MONERO_SubaddressAccount_getAll_byIndex(void* subaddressAccount_ptr, int index); +extern ADDAPI int SALVIUM_SubaddressAccount_getAll_size(void* subaddressAccount_ptr); +extern ADDAPI void* SALVIUM_SubaddressAccount_getAll_byIndex(void* subaddressAccount_ptr, int index); // virtual void addRow(const std::string &label) = 0; -extern ADDAPI void MONERO_SubaddressAccount_addRow(void* subaddressAccount_ptr, const char* label); +extern ADDAPI void SALVIUM_SubaddressAccount_addRow(void* subaddressAccount_ptr, const char* label); // virtual void setLabel(uint32_t accountIndex, const std::string &label) = 0; -extern ADDAPI void MONERO_SubaddressAccount_setLabel(void* subaddressAccount_ptr, uint32_t accountIndex, const char* label); +extern ADDAPI void SALVIUM_SubaddressAccount_setLabel(void* subaddressAccount_ptr, uint32_t accountIndex, const char* label); // virtual void refresh() = 0; -extern ADDAPI void MONERO_SubaddressAccount_refresh(void* subaddressAccount_ptr); +extern ADDAPI void SALVIUM_SubaddressAccount_refresh(void* subaddressAccount_ptr); // }; // struct MultisigState { // MultisigState() : isMultisig(false), isReady(false), threshold(0), total(0) {} // bool isMultisig; -extern ADDAPI bool MONERO_MultisigState_isMultisig(void* multisigState_ptr); +extern ADDAPI bool SALVIUM_MultisigState_isMultisig(void* multisigState_ptr); // bool isReady; -extern ADDAPI bool MONERO_MultisigState_isReady(void* multisigState_ptr); +extern ADDAPI bool SALVIUM_MultisigState_isReady(void* multisigState_ptr); // uint32_t threshold; -extern ADDAPI uint32_t MONERO_MultisigState_threshold(void* multisigState_ptr); +extern ADDAPI uint32_t SALVIUM_MultisigState_threshold(void* multisigState_ptr); // uint32_t total; -extern ADDAPI uint32_t MONERO_MultisigState_total(void* multisigState_ptr); +extern ADDAPI uint32_t SALVIUM_MultisigState_total(void* multisigState_ptr); // }; @@ -432,9 +432,9 @@ extern ADDAPI uint32_t MONERO_MultisigState_total(void* multisigState_ptr); // DeviceProgress(double progress, bool indeterminate=false): m_progress(progress), m_indeterminate(indeterminate) {} // virtual double progress() const { return m_progress; } -extern ADDAPI bool MONERO_DeviceProgress_progress(void* deviceProgress_ptr); +extern ADDAPI bool SALVIUM_DeviceProgress_progress(void* deviceProgress_ptr); // virtual bool indeterminate() const { return m_indeterminate; } -extern ADDAPI bool MONERO_DeviceProgress_indeterminate(void* deviceProgress_ptr); +extern ADDAPI bool SALVIUM_DeviceProgress_indeterminate(void* deviceProgress_ptr); // protected: // double m_progress; @@ -499,83 +499,83 @@ const int BackgroundSync_CustomPassword = 2; // }; // virtual ~Wallet() = 0; // virtual std::string seed(const std::string& seed_offset = "") const = 0; -extern ADDAPI const char* MONERO_Wallet_seed(void* wallet_ptr, const char* seed_offset); +extern ADDAPI const char* SALVIUM_Wallet_seed(void* wallet_ptr, const char* seed_offset); // virtual std::string getSeedLanguage() const = 0; -extern ADDAPI const char* MONERO_Wallet_getSeedLanguage(void* wallet_ptr); +extern ADDAPI const char* SALVIUM_Wallet_getSeedLanguage(void* wallet_ptr); // virtual void setSeedLanguage(const std::string &arg) = 0; -extern ADDAPI void MONERO_Wallet_setSeedLanguage(void* wallet_ptr, const char* arg); +extern ADDAPI void SALVIUM_Wallet_setSeedLanguage(void* wallet_ptr, const char* arg); // virtual int status() const = 0; -extern ADDAPI int MONERO_Wallet_status(void* wallet_ptr); +extern ADDAPI int SALVIUM_Wallet_status(void* wallet_ptr); // virtual std::string errorString() const = 0; -extern ADDAPI const char* MONERO_Wallet_errorString(void* wallet_ptr); +extern ADDAPI const char* SALVIUM_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 MONERO_Wallet_setPassword(void* wallet_ptr, const char* password); +extern ADDAPI bool SALVIUM_Wallet_setPassword(void* wallet_ptr, const char* password); // virtual const std::string& getPassword() const = 0; -extern ADDAPI const char* MONERO_Wallet_getPassword(void* wallet_ptr); +extern ADDAPI const char* SALVIUM_Wallet_getPassword(void* wallet_ptr); // virtual bool setDevicePin(const std::string &pin) { (void)pin; return false; }; -extern ADDAPI bool MONERO_Wallet_setDevicePin(void* wallet_ptr, const char* pin); +extern ADDAPI bool SALVIUM_Wallet_setDevicePin(void* wallet_ptr, const char* pin); // virtual bool setDevicePassphrase(const std::string &passphrase) { (void)passphrase; return false; }; -extern ADDAPI bool MONERO_Wallet_setDevicePassphrase(void* wallet_ptr, const char* passphrase); +extern ADDAPI bool SALVIUM_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* MONERO_Wallet_address(void* wallet_ptr, uint64_t accountIndex, uint64_t addressIndex); +extern ADDAPI const char* SALVIUM_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* MONERO_Wallet_path(void* wallet_ptr); +extern ADDAPI const char* SALVIUM_Wallet_path(void* wallet_ptr); // virtual NetworkType nettype() const = 0; -extern ADDAPI int MONERO_Wallet_nettype(void* wallet_ptr); +extern ADDAPI int SALVIUM_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 MONERO_Wallet_useForkRules(void* wallet_ptr, uint8_t version, int64_t early_blocks); +extern ADDAPI uint8_t SALVIUM_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* MONERO_Wallet_integratedAddress(void* wallet_ptr, const char* payment_id); +extern ADDAPI const char* SALVIUM_Wallet_integratedAddress(void* wallet_ptr, const char* payment_id); // virtual std::string secretViewKey() const = 0; -extern ADDAPI const char* MONERO_Wallet_secretViewKey(void* wallet_ptr); +extern ADDAPI const char* SALVIUM_Wallet_secretViewKey(void* wallet_ptr); // virtual std::string publicViewKey() const = 0; -extern ADDAPI const char* MONERO_Wallet_publicViewKey(void* wallet_ptr); +extern ADDAPI const char* SALVIUM_Wallet_publicViewKey(void* wallet_ptr); // virtual std::string secretSpendKey() const = 0; -extern ADDAPI const char* MONERO_Wallet_secretSpendKey(void* wallet_ptr); +extern ADDAPI const char* SALVIUM_Wallet_secretSpendKey(void* wallet_ptr); // virtual std::string publicSpendKey() const = 0; -extern ADDAPI const char* MONERO_Wallet_publicSpendKey(void* wallet_ptr); +extern ADDAPI const char* SALVIUM_Wallet_publicSpendKey(void* wallet_ptr); // virtual std::string publicMultisigSignerKey() const = 0; -extern ADDAPI const char* MONERO_Wallet_publicMultisigSignerKey(void* wallet_ptr); +extern ADDAPI const char* SALVIUM_Wallet_publicMultisigSignerKey(void* wallet_ptr); // virtual void stop() = 0; -extern ADDAPI void MONERO_Wallet_stop(void* wallet_ptr); +extern ADDAPI void SALVIUM_Wallet_stop(void* wallet_ptr); // virtual bool store(const std::string &path) = 0; -extern ADDAPI bool MONERO_Wallet_store(void* wallet_ptr, const char* path); +extern ADDAPI bool SALVIUM_Wallet_store(void* wallet_ptr, const char* path); // virtual std::string filename() const = 0; -extern ADDAPI const char* MONERO_Wallet_filename(void* wallet_ptr); +extern ADDAPI const char* SALVIUM_Wallet_filename(void* wallet_ptr); // virtual std::string keysFilename() const = 0; -extern ADDAPI const char* MONERO_Wallet_keysFilename(void* wallet_ptr); +extern ADDAPI const char* SALVIUM_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 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); +extern ADDAPI bool SALVIUM_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 MONERO_Wallet_createWatchOnly(void* wallet_ptr, const char* path, const char* password, const char* language); +extern ADDAPI bool SALVIUM_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 MONERO_Wallet_setRefreshFromBlockHeight(void* wallet_ptr, uint64_t refresh_from_block_height); +extern ADDAPI void SALVIUM_Wallet_setRefreshFromBlockHeight(void* wallet_ptr, uint64_t refresh_from_block_height); // virtual uint64_t getRefreshFromBlockHeight() const = 0; -extern ADDAPI uint64_t MONERO_Wallet_getRefreshFromBlockHeight(void* wallet_ptr); +extern ADDAPI uint64_t SALVIUM_Wallet_getRefreshFromBlockHeight(void* wallet_ptr); // virtual void setRecoveringFromSeed(bool recoveringFromSeed) = 0; -extern ADDAPI void MONERO_Wallet_setRecoveringFromSeed(void* wallet_ptr, bool recoveringFromSeed); +extern ADDAPI void SALVIUM_Wallet_setRecoveringFromSeed(void* wallet_ptr, bool recoveringFromSeed); // virtual void setRecoveringFromDevice(bool recoveringFromDevice) = 0; -extern ADDAPI void MONERO_Wallet_setRecoveringFromDevice(void* wallet_ptr, bool recoveringFromDevice); +extern ADDAPI void SALVIUM_Wallet_setRecoveringFromDevice(void* wallet_ptr, bool recoveringFromDevice); // virtual void setSubaddressLookahead(uint32_t major, uint32_t minor) = 0; -extern ADDAPI void MONERO_Wallet_setSubaddressLookahead(void* wallet_ptr, uint32_t major, uint32_t minor); +extern ADDAPI void SALVIUM_Wallet_setSubaddressLookahead(void* wallet_ptr, uint32_t major, uint32_t minor); // virtual bool connectToDaemon() = 0; -extern ADDAPI bool MONERO_Wallet_connectToDaemon(void* wallet_ptr); +extern ADDAPI bool SALVIUM_Wallet_connectToDaemon(void* wallet_ptr); // virtual ConnectionStatus connected() const = 0; -extern ADDAPI int MONERO_Wallet_connected(void* wallet_ptr); +extern ADDAPI int SALVIUM_Wallet_connected(void* wallet_ptr); // virtual void setTrustedDaemon(bool arg) = 0; -extern ADDAPI void MONERO_Wallet_setTrustedDaemon(void* wallet_ptr, bool arg); +extern ADDAPI void SALVIUM_Wallet_setTrustedDaemon(void* wallet_ptr, bool arg); // virtual bool trustedDaemon() const = 0; -extern ADDAPI bool MONERO_Wallet_trustedDaemon(void* wallet_ptr); +extern ADDAPI bool SALVIUM_Wallet_trustedDaemon(void* wallet_ptr); // virtual bool setProxy(const std::string &address) = 0; -extern ADDAPI bool MONERO_Wallet_setProxy(void* wallet_ptr, const char* address); +extern ADDAPI bool SALVIUM_Wallet_setProxy(void* wallet_ptr, const char* address); // virtual uint64_t balance(uint32_t accountIndex = 0) const = 0; -extern ADDAPI uint64_t MONERO_Wallet_balance(void* wallet_ptr, uint32_t accountIndex); +extern ADDAPI uint64_t SALVIUM_Wallet_balance(void* wallet_ptr, uint32_t accountIndex); // uint64_t balanceAll() const { // uint64_t result = 0; // for (uint32_t i = 0; i < numSubaddressAccounts(); ++i) @@ -583,7 +583,7 @@ extern ADDAPI uint64_t MONERO_Wallet_balance(void* wallet_ptr, uint32_t accountI // return result; // } // virtual uint64_t unlockedBalance(uint32_t accountIndex = 0) const = 0; -extern ADDAPI uint64_t MONERO_Wallet_unlockedBalance(void* wallet_ptr, uint32_t accountIndex); +extern ADDAPI uint64_t SALVIUM_Wallet_unlockedBalance(void* wallet_ptr, uint32_t accountIndex); // uint64_t unlockedBalanceAll() const { // uint64_t result = 0; // for (uint32_t i = 0; i < numSubaddressAccounts(); ++i) @@ -592,114 +592,114 @@ extern ADDAPI uint64_t MONERO_Wallet_unlockedBalance(void* wallet_ptr, uint32_t // } // virtual bool watchOnly() const = 0; // virtual uint64_t viewOnlyBalance(uint32_t accountIndex, const std::vector &key_images = {}) const = 0; -extern ADDAPI uint64_t MONERO_Wallet_viewOnlyBalance(void* wallet_ptr, uint32_t accountIndex); -extern ADDAPI bool MONERO_Wallet_watchOnly(void* wallet_ptr); +extern ADDAPI uint64_t SALVIUM_Wallet_viewOnlyBalance(void* wallet_ptr, uint32_t accountIndex); +extern ADDAPI bool SALVIUM_Wallet_watchOnly(void* wallet_ptr); // virtual bool isDeterministic() const = 0; -extern ADDAPI bool MONERO_Wallet_isDeterministic(void* wallet_ptr); +extern ADDAPI bool SALVIUM_Wallet_isDeterministic(void* wallet_ptr); // virtual uint64_t blockChainHeight() const = 0; -extern ADDAPI uint64_t MONERO_Wallet_blockChainHeight(void* wallet_ptr); +extern ADDAPI uint64_t SALVIUM_Wallet_blockChainHeight(void* wallet_ptr); // virtual uint64_t approximateBlockChainHeight() const = 0; -extern ADDAPI uint64_t MONERO_Wallet_approximateBlockChainHeight(void* wallet_ptr); +extern ADDAPI uint64_t SALVIUM_Wallet_approximateBlockChainHeight(void* wallet_ptr); // virtual uint64_t estimateBlockChainHeight() const = 0; -extern ADDAPI uint64_t MONERO_Wallet_estimateBlockChainHeight(void* wallet_ptr); +extern ADDAPI uint64_t SALVIUM_Wallet_estimateBlockChainHeight(void* wallet_ptr); // virtual uint64_t daemonBlockChainHeight() const = 0; -extern ADDAPI uint64_t MONERO_Wallet_daemonBlockChainHeight(void* wallet_ptr); +extern ADDAPI uint64_t SALVIUM_Wallet_daemonBlockChainHeight(void* wallet_ptr); // virtual uint64_t daemonBlockChainTargetHeight() const = 0; -extern ADDAPI uint64_t MONERO_Wallet_daemonBlockChainTargetHeight(void* wallet_ptr); +extern ADDAPI uint64_t SALVIUM_Wallet_daemonBlockChainTargetHeight(void* wallet_ptr); // virtual bool synchronized() const = 0; -extern ADDAPI bool MONERO_Wallet_synchronized(void* wallet_ptr); +extern ADDAPI bool SALVIUM_Wallet_synchronized(void* wallet_ptr); // static std::string displayAmount(uint64_t amount); -extern ADDAPI const char* MONERO_Wallet_displayAmount(uint64_t amount); +extern ADDAPI const char* SALVIUM_Wallet_displayAmount(uint64_t amount); // static uint64_t amountFromString(const std::string &amount); -extern ADDAPI uint64_t MONERO_Wallet_amountFromString(const char* amount); +extern ADDAPI uint64_t SALVIUM_Wallet_amountFromString(const char* amount); // static uint64_t amountFromDouble(double amount); -extern ADDAPI uint64_t MONERO_Wallet_amountFromDouble(double amount); +extern ADDAPI uint64_t SALVIUM_Wallet_amountFromDouble(double amount); // static std::string genPaymentId(); -extern ADDAPI const char* MONERO_Wallet_genPaymentId(); +extern ADDAPI const char* SALVIUM_Wallet_genPaymentId(); // static bool paymentIdValid(const std::string &paiment_id); -extern ADDAPI bool MONERO_Wallet_paymentIdValid(const char* paiment_id); +extern ADDAPI bool SALVIUM_Wallet_paymentIdValid(const char* paiment_id); // static bool addressValid(const std::string &str, NetworkType nettype); -extern ADDAPI bool MONERO_Wallet_addressValid(const char* str, int nettype); +extern ADDAPI bool SALVIUM_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 MONERO_Wallet_keyValid(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype); -extern ADDAPI const char* MONERO_Wallet_keyValid_error(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype); +extern ADDAPI bool SALVIUM_Wallet_keyValid(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype); +extern ADDAPI const char* SALVIUM_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* MONERO_Wallet_paymentIdFromAddress(const char* strarg, int nettype); +extern ADDAPI const char* SALVIUM_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 MONERO_Wallet_maximumAllowedAmount(); +extern ADDAPI uint64_t SALVIUM_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 MONERO_Wallet_init3(void* wallet_ptr, const char* argv0, const char* default_log_base_name, const char* log_path, bool console); +extern ADDAPI void SALVIUM_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* MONERO_Wallet_getPolyseed(void* wallet_ptr, const char* passphrase); +extern ADDAPI const char* SALVIUM_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* MONERO_Wallet_createPolyseed(const char* language); -extern ADDAPI void MONERO_Wallet_startRefresh(void* wallet_ptr); +extern ADDAPI const char* SALVIUM_Wallet_createPolyseed(const char* language); +extern ADDAPI void SALVIUM_Wallet_startRefresh(void* wallet_ptr); // virtual void pauseRefresh() = 0; -extern ADDAPI void MONERO_Wallet_pauseRefresh(void* wallet_ptr); +extern ADDAPI void SALVIUM_Wallet_pauseRefresh(void* wallet_ptr); // virtual bool refresh() = 0; -extern ADDAPI bool MONERO_Wallet_refresh(void* wallet_ptr); +extern ADDAPI bool SALVIUM_Wallet_refresh(void* wallet_ptr); // virtual void refreshAsync() = 0; -extern ADDAPI void MONERO_Wallet_refreshAsync(void* wallet_ptr); +extern ADDAPI void SALVIUM_Wallet_refreshAsync(void* wallet_ptr); // virtual bool rescanBlockchain() = 0; -extern ADDAPI bool MONERO_Wallet_rescanBlockchain(void* wallet_ptr); +extern ADDAPI bool SALVIUM_Wallet_rescanBlockchain(void* wallet_ptr); // virtual void rescanBlockchainAsync() = 0; -extern ADDAPI void MONERO_Wallet_rescanBlockchainAsync(void* wallet_ptr); +extern ADDAPI void SALVIUM_Wallet_rescanBlockchainAsync(void* wallet_ptr); // virtual void setAutoRefreshInterval(int millis) = 0; -extern ADDAPI void MONERO_Wallet_setAutoRefreshInterval(void* wallet_ptr, int millis); +extern ADDAPI void SALVIUM_Wallet_setAutoRefreshInterval(void* wallet_ptr, int millis); // virtual int autoRefreshInterval() const = 0; -extern ADDAPI int MONERO_Wallet_autoRefreshInterval(void* wallet_ptr); +extern ADDAPI int SALVIUM_Wallet_autoRefreshInterval(void* wallet_ptr); // virtual void addSubaddressAccount(const std::string& label) = 0; -extern ADDAPI void MONERO_Wallet_addSubaddressAccount(void* wallet_ptr, const char* label); +extern ADDAPI void SALVIUM_Wallet_addSubaddressAccount(void* wallet_ptr, const char* label); // virtual size_t numSubaddressAccounts() const = 0; -extern ADDAPI size_t MONERO_Wallet_numSubaddressAccounts(void* wallet_ptr); +extern ADDAPI size_t SALVIUM_Wallet_numSubaddressAccounts(void* wallet_ptr); // virtual size_t numSubaddresses(uint32_t accountIndex) const = 0; -extern ADDAPI size_t MONERO_Wallet_numSubaddresses(void* wallet_ptr, uint32_t accountIndex); +extern ADDAPI size_t SALVIUM_Wallet_numSubaddresses(void* wallet_ptr, uint32_t accountIndex); // virtual void addSubaddress(uint32_t accountIndex, const std::string& label) = 0; -extern ADDAPI void MONERO_Wallet_addSubaddress(void* wallet_ptr, uint32_t accountIndex, const char* label); +extern ADDAPI void SALVIUM_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* MONERO_Wallet_getSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex); +extern ADDAPI const char* SALVIUM_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 MONERO_Wallet_setSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label); +extern ADDAPI void SALVIUM_Wallet_setSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label); // virtual MultisigState multisig() const = 0; -extern ADDAPI void* MONERO_Wallet_multisig(void* wallet_ptr); +extern ADDAPI void* SALVIUM_Wallet_multisig(void* wallet_ptr); // virtual std::string getMultisigInfo() const = 0; -extern ADDAPI const char* MONERO_Wallet_getMultisigInfo(void* wallet_ptr); +extern ADDAPI const char* SALVIUM_Wallet_getMultisigInfo(void* wallet_ptr); // virtual std::string makeMultisig(const std::vector& info, uint32_t threshold) = 0; -extern ADDAPI const char* MONERO_Wallet_makeMultisig(void* wallet_ptr, const char* info, const char* info_separator, uint32_t threshold); +extern ADDAPI const char* SALVIUM_Wallet_makeMultisig(void* wallet_ptr, const char* info, const char* info_separator, uint32_t threshold); // virtual std::string exchangeMultisigKeys(const std::vector &info, const bool force_update_use_with_caution) = 0; -extern ADDAPI const char* MONERO_Wallet_exchangeMultisigKeys(void* wallet_ptr, const char* info, const char* info_separator, bool force_update_use_with_caution); +extern ADDAPI const char* SALVIUM_Wallet_exchangeMultisigKeys(void* wallet_ptr, const char* info, const char* info_separator, bool force_update_use_with_caution); // virtual bool exportMultisigImages(std::string& images) = 0; -extern ADDAPI const char* MONERO_Wallet_exportMultisigImages(void* wallet_ptr, const char* separator); +extern ADDAPI const char* SALVIUM_Wallet_exportMultisigImages(void* wallet_ptr, const char* separator); // virtual size_t importMultisigImages(const std::vector& images) = 0; -extern ADDAPI size_t MONERO_Wallet_importMultisigImages(void* wallet_ptr, const char* info, const char* info_separator); +extern ADDAPI size_t SALVIUM_Wallet_importMultisigImages(void* wallet_ptr, const char* info, const char* info_separator); // virtual bool hasMultisigPartialKeyImages() const = 0; -extern ADDAPI size_t MONERO_Wallet_hasMultisigPartialKeyImages(void* wallet_ptr); +extern ADDAPI size_t SALVIUM_Wallet_hasMultisigPartialKeyImages(void* wallet_ptr); // virtual PendingTransaction* restoreMultisigTransaction(const std::string& signData) = 0; -extern ADDAPI void* MONERO_Wallet_restoreMultisigTransaction(void* wallet_ptr, const char* signData); +extern ADDAPI void* SALVIUM_Wallet_restoreMultisigTransaction(void* wallet_ptr, const char* signData); // 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; -extern ADDAPI void* MONERO_Wallet_createTransactionMultDest(void* wallet_ptr, const char* dst_addr_list, const char* dst_addr_list_separator, const char* payment_id, +extern ADDAPI void* SALVIUM_Wallet_createTransactionMultDest(void* wallet_ptr, const char* dst_addr_list, const char* dst_addr_list_separator, const char* payment_id, bool amount_sweep_all, const char* amount_list, const char* amount_list_separator, uint32_t mixin_count, int pendingTransactionPriority, uint32_t subaddr_account, @@ -710,73 +710,73 @@ extern ADDAPI void* MONERO_Wallet_createTransactionMultDest(void* wallet_ptr, co // uint32_t subaddr_account = 0, // std::set subaddr_indices = {}, // const std::set &preferred_inputs = {) = 0; -extern ADDAPI void* MONERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id, +extern ADDAPI void* SALVIUM_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* MONERO_Wallet_loadUnsignedTx(void* wallet_ptr, const char* unsigned_filename); -extern ADDAPI void* MONERO_Wallet_loadUnsignedTxUR(void* wallet_ptr, const char* input); +extern ADDAPI void* SALVIUM_Wallet_loadUnsignedTx(void* wallet_ptr, const char* unsigned_filename); +extern ADDAPI void* SALVIUM_Wallet_loadUnsignedTxUR(void* wallet_ptr, const char* input); // virtual bool submitTransaction(const std::string &fileName) = 0; -extern ADDAPI bool MONERO_Wallet_submitTransaction(void* wallet_ptr, const char* fileName); -extern ADDAPI bool MONERO_Wallet_submitTransactionUR(void* wallet_ptr, const char* input); +extern ADDAPI bool SALVIUM_Wallet_submitTransaction(void* wallet_ptr, const char* fileName); +extern ADDAPI bool SALVIUM_Wallet_submitTransactionUR(void* wallet_ptr, const char* input); // 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 MONERO_Wallet_hasUnknownKeyImages(void* wallet_ptr); +extern ADDAPI bool SALVIUM_Wallet_hasUnknownKeyImages(void* wallet_ptr); // virtual bool exportKeyImages(const std::string &filename, bool all = false) = 0; -extern ADDAPI bool MONERO_Wallet_exportKeyImages(void* wallet_ptr, const char* filename, bool all); -extern ADDAPI const char* MONERO_Wallet_exportKeyImagesUR(void* wallet_ptr, size_t max_fragment_length, bool all) ; +extern ADDAPI bool SALVIUM_Wallet_exportKeyImages(void* wallet_ptr, const char* filename, bool all); +extern ADDAPI const char* SALVIUM_Wallet_exportKeyImagesUR(void* wallet_ptr, size_t max_fragment_length, bool all) ; // virtual bool importKeyImages(const std::string &filename) = 0; -extern ADDAPI bool MONERO_Wallet_importKeyImages(void* wallet_ptr, const char* filename); -extern ADDAPI bool MONERO_Wallet_importKeyImagesUR(void* wallet_ptr, const char* input); +extern ADDAPI bool SALVIUM_Wallet_importKeyImages(void* wallet_ptr, const char* filename); +extern ADDAPI bool SALVIUM_Wallet_importKeyImagesUR(void* wallet_ptr, const char* input); // virtual bool exportOutputs(const std::string &filename, bool all = false) = 0; -extern ADDAPI bool MONERO_Wallet_exportOutputs(void* wallet_ptr, const char* filename, bool all); -extern ADDAPI const char* MONERO_Wallet_exportOutputsUR(void* wallet_ptr, size_t max_fragment_length, bool all); +extern ADDAPI bool SALVIUM_Wallet_exportOutputs(void* wallet_ptr, const char* filename, bool all); +extern ADDAPI const char* SALVIUM_Wallet_exportOutputsUR(void* wallet_ptr, size_t max_fragment_length, bool all); // virtual bool importOutputs(const std::string &filename) = 0; -extern ADDAPI bool MONERO_Wallet_importOutputs(void* wallet_ptr, const char* filename); -extern ADDAPI bool MONERO_Wallet_importOutputsUR(void* wallet_ptr, const char* input); +extern ADDAPI bool SALVIUM_Wallet_importOutputs(void* wallet_ptr, const char* filename); +extern ADDAPI bool SALVIUM_Wallet_importOutputsUR(void* wallet_ptr, const char* input); // 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 MONERO_Wallet_setupBackgroundSync(void* wallet_ptr, int background_sync_type, const char* wallet_password, const char* background_cache_password); +extern ADDAPI bool SALVIUM_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 MONERO_Wallet_getBackgroundSyncType(void* wallet_ptr); +extern ADDAPI int SALVIUM_Wallet_getBackgroundSyncType(void* wallet_ptr); // virtual bool startBackgroundSync() = 0; -extern ADDAPI bool MONERO_Wallet_startBackgroundSync(void* wallet_ptr); +extern ADDAPI bool SALVIUM_Wallet_startBackgroundSync(void* wallet_ptr); // virtual bool stopBackgroundSync(const std::string &wallet_password) = 0; -extern ADDAPI bool MONERO_Wallet_stopBackgroundSync(void* wallet_ptr, const char* wallet_password); +extern ADDAPI bool SALVIUM_Wallet_stopBackgroundSync(void* wallet_ptr, const char* wallet_password); // virtual bool isBackgroundSyncing() const = 0; -extern ADDAPI bool MONERO_Wallet_isBackgroundSyncing(void* wallet_ptr); +extern ADDAPI bool SALVIUM_Wallet_isBackgroundSyncing(void* wallet_ptr); // virtual bool isBackgroundWallet() const = 0; -extern ADDAPI bool MONERO_Wallet_isBackgroundWallet(void* wallet_ptr); +extern ADDAPI bool SALVIUM_Wallet_isBackgroundWallet(void* wallet_ptr); // virtual TransactionHistory * history() = 0; -extern ADDAPI void* MONERO_Wallet_history(void* wallet_ptr); +extern ADDAPI void* SALVIUM_Wallet_history(void* wallet_ptr); // virtual AddressBook * addressBook() = 0; -extern ADDAPI void* MONERO_Wallet_addressBook(void* wallet_ptr); +extern ADDAPI void* SALVIUM_Wallet_addressBook(void* wallet_ptr); // virtual Coins * coins() = 0; -extern ADDAPI void* MONERO_Wallet_coins(void* wallet_ptr); +extern ADDAPI void* SALVIUM_Wallet_coins(void* wallet_ptr); // virtual Subaddress * subaddress() = 0; -extern ADDAPI void* MONERO_Wallet_subaddress(void* wallet_ptr); +extern ADDAPI void* SALVIUM_Wallet_subaddress(void* wallet_ptr); // virtual SubaddressAccount * subaddressAccount() = 0; -extern ADDAPI void* MONERO_Wallet_subaddressAccount(void* wallet_ptr); +extern ADDAPI void* SALVIUM_Wallet_subaddressAccount(void* wallet_ptr); // virtual void setListener(WalletListener *) = 0; // virtual uint32_t defaultMixin() const = 0; -extern ADDAPI uint32_t MONERO_Wallet_defaultMixin(void* wallet_ptr); +extern ADDAPI uint32_t SALVIUM_Wallet_defaultMixin(void* wallet_ptr); // virtual void setDefaultMixin(uint32_t arg) = 0; -extern ADDAPI void MONERO_Wallet_setDefaultMixin(void* wallet_ptr, uint32_t arg); +extern ADDAPI void SALVIUM_Wallet_setDefaultMixin(void* wallet_ptr, uint32_t arg); // virtual bool setCacheAttribute(const std::string &key, const std::string &val) = 0; -extern ADDAPI bool MONERO_Wallet_setCacheAttribute(void* wallet_ptr, const char* key, const char* val); +extern ADDAPI bool SALVIUM_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* MONERO_Wallet_getCacheAttribute(void* wallet_ptr, const char* key); +extern ADDAPI const char* SALVIUM_Wallet_getCacheAttribute(void* wallet_ptr, const char* key); // virtual bool setUserNote(const std::string &txid, const std::string ¬e) = 0; -extern ADDAPI bool MONERO_Wallet_setUserNote(void* wallet_ptr, const char* txid, const char* note); +extern ADDAPI bool SALVIUM_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* MONERO_Wallet_getUserNote(void* wallet_ptr, const char* txid); +extern ADDAPI const char* SALVIUM_Wallet_getUserNote(void* wallet_ptr, const char* txid); // virtual std::string getTxKey(const std::string &txid) const = 0; -extern ADDAPI const char* MONERO_Wallet_getTxKey(void* wallet_ptr, const char* txid); +extern ADDAPI const char* SALVIUM_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; @@ -785,20 +785,20 @@ extern ADDAPI const char* MONERO_Wallet_getTxKey(void* wallet_ptr, const char* t // 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* MONERO_Wallet_signMessage(void* wallet_ptr, const char* message, const char* address); +extern ADDAPI const char* SALVIUM_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 MONERO_Wallet_verifySignedMessage(void* wallet_ptr, const char* message, const char* address, const char* signature); +extern ADDAPI bool SALVIUM_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 MONERO_Wallet_rescanSpent(void* wallet_ptr); +extern ADDAPI bool SALVIUM_Wallet_rescanSpent(void* wallet_ptr); // virtual void setOffline(bool offline) = 0; -extern ADDAPI void MONERO_Wallet_setOffline(void* wallet_ptr, bool offline); +extern ADDAPI void SALVIUM_Wallet_setOffline(void* wallet_ptr, bool offline); // virtual bool isOffline() const = 0; -extern ADDAPI bool MONERO_Wallet_isOffline(void* wallet_ptr); +extern ADDAPI bool SALVIUM_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; @@ -806,53 +806,53 @@ extern ADDAPI bool MONERO_Wallet_isOffline(void* wallet_ptr); // 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 MONERO_Wallet_segregatePreForkOutputs(void* wallet_ptr, bool segregate); +extern ADDAPI void SALVIUM_Wallet_segregatePreForkOutputs(void* wallet_ptr, bool segregate); // virtual void segregationHeight(uint64_t height) = 0; -extern ADDAPI void MONERO_Wallet_segregationHeight(void* wallet_ptr, uint64_t height); +extern ADDAPI void SALVIUM_Wallet_segregationHeight(void* wallet_ptr, uint64_t height); // virtual void keyReuseMitigation2(bool mitigation) = 0; -extern ADDAPI void MONERO_Wallet_keyReuseMitigation2(void* wallet_ptr, bool mitigation); +extern ADDAPI void SALVIUM_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 MONERO_Wallet_lockKeysFile(void* wallet_ptr); +extern ADDAPI bool SALVIUM_Wallet_lockKeysFile(void* wallet_ptr); // virtual bool unlockKeysFile() = 0; -extern ADDAPI bool MONERO_Wallet_unlockKeysFile(void* wallet_ptr); +extern ADDAPI bool SALVIUM_Wallet_unlockKeysFile(void* wallet_ptr); // virtual bool isKeysFileLocked() = 0; -extern ADDAPI bool MONERO_Wallet_isKeysFileLocked(void* wallet_ptr); +extern ADDAPI bool SALVIUM_Wallet_isKeysFileLocked(void* wallet_ptr); // virtual Device getDeviceType() const = 0; -extern ADDAPI int MONERO_Wallet_getDeviceType(void* wallet_ptr); +extern ADDAPI int SALVIUM_Wallet_getDeviceType(void* wallet_ptr); // virtual uint64_t coldKeyImageSync(uint64_t &spent, uint64_t &unspent) = 0; -extern ADDAPI uint64_t MONERO_Wallet_coldKeyImageSync(void* wallet_ptr, uint64_t spent, uint64_t unspent); +extern ADDAPI uint64_t SALVIUM_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* MONERO_Wallet_deviceShowAddress(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex); +extern ADDAPI const char* SALVIUM_Wallet_deviceShowAddress(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex); // virtual bool reconnectDevice() = 0; -extern ADDAPI bool MONERO_Wallet_reconnectDevice(void* wallet_ptr); +extern ADDAPI bool SALVIUM_Wallet_reconnectDevice(void* wallet_ptr); // virtual uint64_t getBytesReceived() = 0; -extern ADDAPI uint64_t MONERO_Wallet_getBytesReceived(void* wallet_ptr); +extern ADDAPI uint64_t SALVIUM_Wallet_getBytesReceived(void* wallet_ptr); // virtual uint64_t getBytesSent() = 0; -extern ADDAPI uint64_t MONERO_Wallet_getBytesSent(void* wallet_ptr); +extern ADDAPI uint64_t SALVIUM_Wallet_getBytesSent(void* wallet_ptr); // HIDAPI_DUMMY -extern ADDAPI bool MONERO_Wallet_getStateIsConnected(void* wallet_ptr); -extern ADDAPI unsigned char* MONERO_Wallet_getSendToDevice(void* wallet_ptr); -extern ADDAPI size_t MONERO_Wallet_getSendToDeviceLength(void* wallet_ptr); -extern ADDAPI unsigned char* MONERO_Wallet_getReceivedFromDevice(void* wallet_ptr); -extern ADDAPI size_t MONERO_Wallet_getReceivedFromDeviceLength(void* wallet_ptr); -extern ADDAPI bool MONERO_Wallet_getWaitsForDeviceSend(void* wallet_ptr); -extern ADDAPI bool MONERO_Wallet_getWaitsForDeviceReceive(void* wallet_ptr); -extern ADDAPI void MONERO_Wallet_setDeviceReceivedData(void* wallet_ptr, unsigned char* data, size_t len); -extern ADDAPI void MONERO_Wallet_setDeviceSendData(void* wallet_ptr, unsigned char* data, size_t len); +extern ADDAPI bool SALVIUM_Wallet_getStateIsConnected(void* wallet_ptr); +extern ADDAPI unsigned char* SALVIUM_Wallet_getSendToDevice(void* wallet_ptr); +extern ADDAPI size_t SALVIUM_Wallet_getSendToDeviceLength(void* wallet_ptr); +extern ADDAPI unsigned char* SALVIUM_Wallet_getReceivedFromDevice(void* wallet_ptr); +extern ADDAPI size_t SALVIUM_Wallet_getReceivedFromDeviceLength(void* wallet_ptr); +extern ADDAPI bool SALVIUM_Wallet_getWaitsForDeviceSend(void* wallet_ptr); +extern ADDAPI bool SALVIUM_Wallet_getWaitsForDeviceReceive(void* wallet_ptr); +extern ADDAPI void SALVIUM_Wallet_setDeviceReceivedData(void* wallet_ptr, unsigned char* data, size_t len); +extern ADDAPI void SALVIUM_Wallet_setDeviceSendData(void* wallet_ptr, unsigned char* data, size_t len); // }; // 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* MONERO_WalletManager_createWallet(void* wm_ptr, const char* path, const char* password, const char* language, int networkType); +extern ADDAPI void* SALVIUM_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* MONERO_WalletManager_openWallet(void* wm_ptr, const char* path, const char* password, int networkType); +extern ADDAPI void* SALVIUM_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); @@ -860,7 +860,7 @@ extern ADDAPI void* MONERO_WalletManager_openWallet(void* wm_ptr, const char* pa // 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* MONERO_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); +extern ADDAPI void* SALVIUM_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 // { @@ -880,7 +880,7 @@ extern ADDAPI void* MONERO_WalletManager_recoveryWallet(void* wm_ptr, const char // const std::string &viewKeyString, // const std::string &spendKeyString = "", // uint64_t kdf_rounds = 1) = 0; -extern ADDAPI void* MONERO_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); +extern ADDAPI void* SALVIUM_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, @@ -916,7 +916,7 @@ extern ADDAPI void* MONERO_WalletManager_createWalletFromKeys(void* wm_ptr, cons // uint64_t restoreHeight, // const std::string &spendKeyString, // uint64_t kdf_rounds = 1) = 0; -extern ADDAPI void* MONERO_WalletManager_createDeterministicWalletFromSpendKey(void* wm_ptr, const char* path, const char* password, +extern ADDAPI void* SALVIUM_WalletManager_createDeterministicWalletFromSpendKey(void* wm_ptr, const char* path, const char* password, const char* language, int nettype, uint64_t restoreHeight, const char* spendKeyString, uint64_t kdf_rounds); // virtual Wallet * createWalletFromDevice(const std::string &path, @@ -927,7 +927,7 @@ extern ADDAPI void* MONERO_WalletManager_createDeterministicWalletFromSpendKey(v // const std::string &subaddressLookahead = "", // uint64_t kdf_rounds = 1, // WalletListener * listener = nullptr) = 0; -extern ADDAPI void* MONERO_WalletManager_createWalletFromDevice(void* wm_ptr, const char* path, const char* password, int nettype, const char* deviceName, uint64_t restoreHeight, const char* subaddressLookahead, const char* viewKeyString, const char* spendKeyString, uint64_t kdf_rounds); +extern ADDAPI void* SALVIUM_WalletManager_createWalletFromDevice(void* wm_ptr, const char* path, const char* password, int nettype, const char* deviceName, uint64_t restoreHeight, const char* subaddressLookahead, const char* viewKeyString, const char* spendKeyString, uint64_t kdf_rounds); // virtual Wallet * createWalletFromPolyseed(const std::string &path, // const std::string &password, // NetworkType nettype, @@ -936,49 +936,49 @@ extern ADDAPI void* MONERO_WalletManager_createWalletFromDevice(void* wm_ptr, co // bool newWallet = true, // uint64_t restore_height = 0, // uint64_t kdf_rounds = 1) = 0; -extern ADDAPI void* MONERO_WalletManager_createWalletFromPolyseed(void* wm_ptr, const char* path, const char* password, +extern ADDAPI void* SALVIUM_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 MONERO_WalletManager_closeWallet(void* wm_ptr, void* wallet_ptr, bool store); +extern ADDAPI bool SALVIUM_WalletManager_closeWallet(void* wm_ptr, void* wallet_ptr, bool store); // virtual bool walletExists(const std::string &path) = 0; -extern ADDAPI bool MONERO_WalletManager_walletExists(void* wm_ptr, const char* path); +extern ADDAPI bool SALVIUM_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 MONERO_WalletManager_verifyWalletPassword(void* wm_ptr, const char* keys_file_name, const char* password, bool no_spend_key, uint64_t kdf_rounds); +extern ADDAPI bool SALVIUM_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 int MONERO_WalletManager_queryWalletDevice(void* wm_ptr, const char* keys_file_name, const char* password, uint64_t kdf_rounds); +extern ADDAPI int SALVIUM_WalletManager_queryWalletDevice(void* wm_ptr, 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* MONERO_WalletManager_findWallets(void* wm_ptr, const char* path, const char* separator); +extern ADDAPI const char* SALVIUM_WalletManager_findWallets(void* wm_ptr, const char* path, const char* separator); // virtual std::string errorString() const = 0; -extern ADDAPI const char* MONERO_WalletManager_errorString(void* wm_ptr); +extern ADDAPI const char* SALVIUM_WalletManager_errorString(void* wm_ptr); // virtual void setDaemonAddress(const std::string &address) = 0; -extern ADDAPI void MONERO_WalletManager_setDaemonAddress(void* wm_ptr, const char* address); +extern ADDAPI void SALVIUM_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 MONERO_WalletManager_blockchainHeight(void* wm_ptr); +extern ADDAPI uint64_t SALVIUM_WalletManager_blockchainHeight(void* wm_ptr); // virtual uint64_t blockchainTargetHeight() = 0; -extern ADDAPI uint64_t MONERO_WalletManager_blockchainTargetHeight(void* wm_ptr); +extern ADDAPI uint64_t SALVIUM_WalletManager_blockchainTargetHeight(void* wm_ptr); // virtual uint64_t networkDifficulty() = 0; -extern ADDAPI uint64_t MONERO_WalletManager_networkDifficulty(void* wm_ptr); +extern ADDAPI uint64_t SALVIUM_WalletManager_networkDifficulty(void* wm_ptr); // virtual double miningHashRate() = 0; -extern ADDAPI double MONERO_WalletManager_miningHashRate(void* wm_ptr); +extern ADDAPI double SALVIUM_WalletManager_miningHashRate(void* wm_ptr); // virtual uint64_t blockTarget() = 0; -extern ADDAPI uint64_t MONERO_WalletManager_blockTarget(void* wm_ptr); +extern ADDAPI uint64_t SALVIUM_WalletManager_blockTarget(void* wm_ptr); // virtual bool isMining() = 0; -extern ADDAPI bool MONERO_WalletManager_isMining(void* wm_ptr); +extern ADDAPI bool SALVIUM_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 MONERO_WalletManager_startMining(void* wm_ptr, const char* address, uint32_t threads, bool backgroundMining, bool ignoreBattery); +extern ADDAPI bool SALVIUM_WalletManager_startMining(void* wm_ptr, const char* address, uint32_t threads, bool backgroundMining, bool ignoreBattery); // virtual bool stopMining() = 0; -extern ADDAPI bool MONERO_WalletManager_stopMining(void* wm_ptr, const char* address); +extern ADDAPI bool SALVIUM_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* MONERO_WalletManager_resolveOpenAlias(void* wm_ptr, const char* address, bool dnssec_valid); +extern ADDAPI const char* SALVIUM_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 MONERO_WalletManager_setProxy(void* wm_ptr, const char* address); +extern ADDAPI bool SALVIUM_WalletManager_setProxy(void* wm_ptr, const char* address); // }; int LogLevel_Silent = -1; @@ -1003,37 +1003,37 @@ int LogLevel_Max = 4; // LogLevel_Max = LogLevel_4 // }; // static WalletManager * getWalletManager(); -extern ADDAPI void* MONERO_WalletManagerFactory_getWalletManager(); +extern ADDAPI void* SALVIUM_WalletManagerFactory_getWalletManager(); // static void setLogLevel(int level); -extern ADDAPI void MONERO_WalletManagerFactory_setLogLevel(int level); +extern ADDAPI void SALVIUM_WalletManagerFactory_setLogLevel(int level); // static void setLogCategories(const std::string &categories); -extern ADDAPI void MONERO_WalletManagerFactory_setLogCategories(const char* categories); +extern ADDAPI void SALVIUM_WalletManagerFactory_setLogCategories(const char* categories); // }; // } -extern ADDAPI void MONERO_DEBUG_test0(); -extern ADDAPI bool MONERO_DEBUG_test1(bool x); -extern ADDAPI int MONERO_DEBUG_test2(int x); -extern ADDAPI uint64_t MONERO_DEBUG_test3(uint64_t x); -extern ADDAPI void* MONERO_DEBUG_test4(uint64_t x); -extern ADDAPI const char* MONERO_DEBUG_test5(); -extern ADDAPI const char* MONERO_DEBUG_test5_std(); -extern ADDAPI bool MONERO_DEBUG_isPointerNull(void* wallet_ptr); +extern ADDAPI void SALVIUM_DEBUG_test0(); +extern ADDAPI bool SALVIUM_DEBUG_test1(bool x); +extern ADDAPI int SALVIUM_DEBUG_test2(int x); +extern ADDAPI uint64_t SALVIUM_DEBUG_test3(uint64_t x); +extern ADDAPI void* SALVIUM_DEBUG_test4(uint64_t x); +extern ADDAPI const char* SALVIUM_DEBUG_test5(); +extern ADDAPI const char* SALVIUM_DEBUG_test5_std(); +extern ADDAPI bool SALVIUM_DEBUG_isPointerNull(void* wallet_ptr); // cake world -extern ADDAPI void* MONERO_cw_getWalletListener(void* wallet_ptr); -extern ADDAPI void MONERO_cw_WalletListener_resetNeedToRefresh(void* cw_walletListener_ptr); -extern ADDAPI bool MONERO_cw_WalletListener_isNeedToRefresh(void* cw_walletListener_ptr); -extern ADDAPI bool MONERO_cw_WalletListener_isNewTransactionExist(void* cw_walletListener_ptr); -extern ADDAPI void MONERO_cw_WalletListener_resetIsNewTransactionExist(void* cw_walletListener_ptr); -extern ADDAPI uint64_t MONERO_cw_WalletListener_height(void* cw_walletListener_ptr); +extern ADDAPI void* SALVIUM_cw_getWalletListener(void* wallet_ptr); +extern ADDAPI void SALVIUM_cw_WalletListener_resetNeedToRefresh(void* cw_walletListener_ptr); +extern ADDAPI bool SALVIUM_cw_WalletListener_isNeedToRefresh(void* cw_walletListener_ptr); +extern ADDAPI bool SALVIUM_cw_WalletListener_isNewTransactionExist(void* cw_walletListener_ptr); +extern ADDAPI void SALVIUM_cw_WalletListener_resetIsNewTransactionExist(void* cw_walletListener_ptr); +extern ADDAPI uint64_t SALVIUM_cw_WalletListener_height(void* cw_walletListener_ptr); -extern ADDAPI void MONERO_free(void* ptr); +extern ADDAPI void SALVIUM_free(void* ptr); -extern ADDAPI const char* MONERO_checksum_wallet2_api_c_h(); -extern ADDAPI const char* MONERO_checksum_wallet2_api_c_cpp(); -extern ADDAPI const char* MONERO_checksum_wallet2_api_c_exp(); +extern ADDAPI const char* SALVIUM_checksum_wallet2_api_c_h(); +extern ADDAPI const char* SALVIUM_checksum_wallet2_api_c_cpp(); +extern ADDAPI const char* SALVIUM_checksum_wallet2_api_c_exp(); #ifdef __cplusplus }