Electroneum
Loading...
Searching...
No Matches
main.cpp File Reference
#include "gtest/gtest.h"
#include "wallet/api/wallet2_api.h"
#include "wallet/wallet2.h"
#include "include_base_utils.h"
#include "common/util.h"
#include <boost/chrono/chrono.hpp>
#include <boost/filesystem.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/asio.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/thread/condition_variable.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/thread.hpp>
#include <iostream>
#include <vector>
#include <atomic>
#include <functional>
Include dependency graph for main.cpp:

Go to the source code of this file.

Classes

struct  Utils
struct  WalletManagerTest
struct  WalletManagerMainnetTest
struct  WalletTest1
struct  WalletTest2
struct  MyWalletListener

Namespaces

namespace  Consts

Functions

 TEST_F (WalletManagerTest, WalletManagerCreatesWallet)
 TEST_F (WalletManagerTest, WalletManagerOpensWallet)
 TEST_F (WalletManagerTest, WalletMaxAmountAsString)
 TEST_F (WalletManagerTest, WalletAmountFromString)
void open_wallet_helper (Electroneum::WalletManager *wmgr, Electroneum::Wallet **wallet, const std::string &pass, boost::mutex *mutex)
 TEST_F (WalletManagerTest, WalletManagerOpensWalletWithPasswordAndReopen)
 TEST_F (WalletManagerTest, WalletManagerStoresWallet)
 TEST_F (WalletManagerTest, WalletManagerMovesWallet)
 TEST_F (WalletManagerTest, WalletManagerChangesPassword)
 TEST_F (WalletManagerTest, WalletManagerRecoversWallet)
 TEST_F (WalletManagerTest, WalletManagerStoresWallet1)
 TEST_F (WalletManagerTest, WalletManagerStoresWallet2)
 TEST_F (WalletManagerTest, WalletManagerStoresWallet3)
 TEST_F (WalletManagerTest, WalletManagerStoresWallet4)
 TEST_F (WalletManagerTest, WalletManagerFindsWallet)
 TEST_F (WalletTest1, WalletGeneratesPaymentId)
 TEST_F (WalletTest1, WalletGeneratesIntegratedAddress)
 TEST_F (WalletTest1, WalletShowsBalance)
 TEST_F (WalletTest1, WalletReturnsCurrentBlockHeight)
 TEST_F (WalletTest1, WalletReturnsDaemonBlockHeight)
 TEST_F (WalletTest1, WalletRefresh)
 TEST_F (WalletTest1, WalletConvertsToString)
 TEST_F (WalletTest1, WalletTransaction)
 TEST_F (WalletTest1, WalletTransactionWithMixin)
 TEST_F (WalletTest1, WalletTransactionWithPriority)
 TEST_F (WalletTest1, WalletHistory)
 TEST_F (WalletTest1, WalletTransactionAndHistory)
 TEST_F (WalletTest1, WalletTransactionWithPaymentId)
 TEST_F (WalletTest2, WalletCallBackRefreshedSync)
 TEST_F (WalletTest2, WalletCallBackRefreshedAsync)
 TEST_F (WalletTest2, WalletCallbackSent)
 TEST_F (WalletTest2, WalletCallbackReceived)
 TEST_F (WalletTest2, WalletCallbackNewBlock)
 TEST_F (WalletManagerMainnetTest, CreateOpenAndRefreshWalletMainNetSync)
 TEST_F (WalletManagerMainnetTest, CreateAndRefreshWalletMainNetAsync)
 TEST_F (WalletManagerMainnetTest, OpenAndRefreshWalletMainNetAsync)
 TEST_F (WalletManagerMainnetTest, RecoverAndRefreshWalletMainNetAsync)
int main (int argc, char **argv)

Variables

const char * Consts::WALLET_NAME = "testwallet"
const char * Consts::WALLET_NAME_MAINNET = "testwallet_mainnet"
const char * Consts::WALLET_NAME_COPY = "testwallet_copy"
const char * Consts::WALLET_NAME_WITH_DIR = "walletdir/testwallet_test"
const char * Consts::WALLET_NAME_WITH_DIR_NON_WRITABLE = "/var/walletdir/testwallet_test"
const char * Consts::WALLET_PASS = "password"
const char * Consts::WALLET_PASS2 = "password22"
const char * Consts::WALLET_LANG = "English"
std::string Consts::WALLETS_ROOT_DIR = "/var/electroneum/testnet_pvt"
std::string Consts::TESTNET_WALLET1_NAME
std::string Consts::TESTNET_WALLET2_NAME
std::string Consts::TESTNET_WALLET3_NAME
std::string Consts::TESTNET_WALLET4_NAME
std::string Consts::TESTNET_WALLET5_NAME
std::string Consts::TESTNET_WALLET6_NAME
const char * Consts::TESTNET_WALLET_PASS = ""
std::string Consts::CURRENT_SRC_WALLET
std::string Consts::CURRENT_DST_WALLET
const uint64_t Consts::AMOUNT_10ETN = 10000000000000L
const uint64_t Consts::AMOUNT_5ETN = 5000000000000L
const uint64_t Consts::AMOUNT_1ETN = 1000000000000L
const std::string Consts::PAYMENT_ID_EMPTY = ""
std::string Consts::TESTNET_DAEMON_ADDRESS = "localhost:36968"
std::string Consts::MAINNET_DAEMON_ADDRESS = "localhost:26968"

Function Documentation

◆ main()

int main ( int argc,
char ** argv )

Definition at line 1141 of file main.cpp.

1142{
1143 TRY_ENTRY();
1144
1145 tools::on_startup();
1146 // we can override default values for "TESTNET_DAEMON_ADDRESS" and "WALLETS_ROOT_DIR"
1147
1148 const char * testnet_daemon_addr = std::getenv("TESTNET_DAEMON_ADDRESS");
1149 if (testnet_daemon_addr) {
1150 TESTNET_DAEMON_ADDRESS = testnet_daemon_addr;
1151 }
1152
1153 const char * mainnet_daemon_addr = std::getenv("MAINNET_DAEMON_ADDRESS");
1154 if (mainnet_daemon_addr) {
1155 MAINNET_DAEMON_ADDRESS = mainnet_daemon_addr;
1156 }
1157
1158
1159
1160 const char * wallets_root_dir = std::getenv("WALLETS_ROOT_DIR");
1161 if (wallets_root_dir) {
1162 WALLETS_ROOT_DIR = wallets_root_dir;
1163 }
1164
1165
1166 TESTNET_WALLET1_NAME = WALLETS_ROOT_DIR + "/wallet_01.bin";
1167 TESTNET_WALLET2_NAME = WALLETS_ROOT_DIR + "/wallet_02.bin";
1168 TESTNET_WALLET3_NAME = WALLETS_ROOT_DIR + "/wallet_03.bin";
1169 TESTNET_WALLET4_NAME = WALLETS_ROOT_DIR + "/wallet_04.bin";
1170 TESTNET_WALLET5_NAME = WALLETS_ROOT_DIR + "/wallet_05.bin";
1171 TESTNET_WALLET6_NAME = WALLETS_ROOT_DIR + "/wallet_06.bin";
1172
1173 CURRENT_SRC_WALLET = TESTNET_WALLET5_NAME;
1174 CURRENT_DST_WALLET = TESTNET_WALLET1_NAME;
1175
1176 ::testing::InitGoogleTest(&argc, argv);
1177 Electroneum::WalletManagerFactory::setLogLevel(Electroneum::WalletManagerFactory::LogLevel_Max);
1178 return RUN_ALL_TESTS();
1179 CATCH_ENTRY_L0("main", 1);
1180}
RUN_ALL_TESTS
int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_
Definition gtest.h:2232
CATCH_ENTRY_L0
#define CATCH_ENTRY_L0(lacation, return_val)
Definition misc_log_ex.h:165
TRY_ENTRY
#define TRY_ENTRY()
Definition misc_log_ex.h:151
Consts::TESTNET_WALLET2_NAME
std::string TESTNET_WALLET2_NAME
Definition main.cpp:74
Consts::TESTNET_WALLET3_NAME
std::string TESTNET_WALLET3_NAME
Definition main.cpp:75
Consts::MAINNET_DAEMON_ADDRESS
std::string MAINNET_DAEMON_ADDRESS
Definition main.cpp:92
Consts::TESTNET_WALLET1_NAME
std::string TESTNET_WALLET1_NAME
Definition main.cpp:73
Consts::CURRENT_DST_WALLET
std::string CURRENT_DST_WALLET
Definition main.cpp:83
Consts::WALLETS_ROOT_DIR
std::string WALLETS_ROOT_DIR
Definition main.cpp:72
Consts::TESTNET_DAEMON_ADDRESS
std::string TESTNET_DAEMON_ADDRESS
Definition main.cpp:91
Consts::TESTNET_WALLET5_NAME
std::string TESTNET_WALLET5_NAME
Definition main.cpp:77
Consts::TESTNET_WALLET6_NAME
std::string TESTNET_WALLET6_NAME
Definition main.cpp:78
Consts::TESTNET_WALLET4_NAME
std::string TESTNET_WALLET4_NAME
Definition main.cpp:76
Consts::CURRENT_SRC_WALLET
std::string CURRENT_SRC_WALLET
Definition main.cpp:82
testing::InitGoogleTest
GTEST_API_ void InitGoogleTest(int *argc, char **argv)
tools::on_startup
bool on_startup()
Definition util.cpp:778
Here is the call graph for this function:

◆ open_wallet_helper()

void open_wallet_helper ( Electroneum::WalletManager * wmgr,
Electroneum::Wallet ** wallet,
const std::string & pass,
boost::mutex * mutex )

Definition at line 260 of file main.cpp.

261{
262 if (mutex)
263 mutex->lock();
264 LOG_PRINT_L3("opening wallet in thread: " << boost::this_thread::get_id());
265 *wallet = wmgr->openWallet(WALLET_NAME, pass, Electroneum::NetworkType::TESTNET);
266 LOG_PRINT_L3("wallet address: " << (*wallet)->mainAddress());
267 LOG_PRINT_L3("wallet status: " << (*wallet)->status());
268 LOG_PRINT_L3("closing wallet in thread: " << boost::this_thread::get_id());
269 if (mutex)
270 mutex->unlock();
271}
LOG_PRINT_L3
#define LOG_PRINT_L3(x)
Definition misc_log_ex.h:102
Consts::WALLET_NAME
const char * WALLET_NAME
Definition main.cpp:63
Electroneum::WalletManager::openWallet
virtual Wallet * openWallet(const std::string &path, const std::string &password, NetworkType nettype, uint64_t kdf_rounds=1, WalletListener *listener=nullptr)=0
Opens existing wallet.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ TEST_F() [1/36]

TEST_F ( WalletManagerMainnetTest ,
CreateAndRefreshWalletMainNetAsync  )

Definition at line 1051 of file main.cpp.

1052{
1053 // supposing 120 seconds should be enough for fast refresh
1054 int SECONDS_TO_REFRESH = 120;
1055
1056 Electroneum::Wallet * wallet = wmgr->createWallet(WALLET_NAME_MAINNET, "", WALLET_LANG, Electroneum::NetworkType::MAINNET);
1057 std::unique_ptr<MyWalletListener> wallet_listener (new MyWalletListener(wallet));
1058
1059 boost::chrono::seconds wait_for = boost::chrono::seconds(SECONDS_TO_REFRESH);
1060 boost::unique_lock<boost::mutex> lock (wallet_listener->mutex);
1061 wallet->init(MAINNET_DAEMON_ADDRESS, 0);
1062 wallet->startRefresh();
1063 std::cerr << "TEST: waiting on refresh lock...\n";
1064 wallet_listener->cv_refresh.wait_for(lock, wait_for);
1065 std::cerr << "TEST: refresh lock acquired...\n";
1066 ASSERT_TRUE(wallet->status() == Electroneum::Wallet::Status_Ok);
1067 ASSERT_TRUE(wallet_listener->refresh_triggered);
1068 ASSERT_TRUE(wallet->connected());
1069 ASSERT_TRUE(wallet->blockChainHeight() == wallet->daemonBlockChainHeight());
1070 std::cerr << "TEST: closing wallet...\n";
1071 wmgr->closeWallet(wallet);
1072}
ASSERT_TRUE
#define ASSERT_TRUE(condition)
Definition gtest.h:1865
Consts::WALLET_LANG
const char * WALLET_LANG
Definition main.cpp:70
Consts::WALLET_NAME_MAINNET
const char * WALLET_NAME_MAINNET
Definition main.cpp:64
Electroneum::Wallet
Interface for wallet operations. TODO: check if /include/IWallet.h is still actual.
Definition wallet2_api.h:431
Electroneum::Wallet::init
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)=0
init - initializes wallet with daemon connection params. if daemon_address is local address,...
Electroneum::Wallet::status
virtual int status() const =0
returns wallet status (Status_Ok | Status_Error)
Electroneum::Wallet::connected
virtual ConnectionStatus connected() const =0
connected - checks if the wallet connected to the daemon
Electroneum::Wallet::startRefresh
virtual void startRefresh()=0
StartRefresh - Start/resume refresh thread (refresh every 10 seconds).
Electroneum::Wallet::daemonBlockChainHeight
virtual uint64_t daemonBlockChainHeight() const =0
daemonBlockChainHeight - returns daemon blockchain height
Electroneum::Wallet::blockChainHeight
virtual uint64_t blockChainHeight() const =0
blockChainHeight - returns current blockchain height
Here is the call graph for this function:

◆ TEST_F() [2/36]

TEST_F ( WalletManagerMainnetTest ,
CreateOpenAndRefreshWalletMainNetSync  )

Definition at line 1034 of file main.cpp.

1035{
1036
1037 Electroneum::Wallet * wallet = wmgr->createWallet(WALLET_NAME_MAINNET, "", WALLET_LANG, Electroneum::NetworkType::MAINNET);
1038 std::unique_ptr<MyWalletListener> wallet_listener (new MyWalletListener(wallet));
1039 wallet->init(MAINNET_DAEMON_ADDRESS, 0);
1040 std::cerr << "TEST: waiting on refresh lock...\n";
1041 //wallet_listener->cv_refresh.wait_for(lock, wait_for);
1042 std::cerr << "TEST: refresh lock acquired...\n";
1043 ASSERT_TRUE(wallet_listener->refresh_triggered);
1044 ASSERT_TRUE(wallet->connected());
1045 ASSERT_TRUE(wallet->blockChainHeight() == wallet->daemonBlockChainHeight());
1046 std::cerr << "TEST: closing wallet...\n";
1047 wmgr->closeWallet(wallet);
1048}
Here is the call graph for this function:

◆ TEST_F() [3/36]

TEST_F ( WalletManagerMainnetTest ,
OpenAndRefreshWalletMainNetAsync  )

Definition at line 1074 of file main.cpp.

1075{
1076
1077 // supposing 120 seconds should be enough for fast refresh
1078 int SECONDS_TO_REFRESH = 120;
1079 Electroneum::Wallet * wallet = wmgr->createWallet(WALLET_NAME_MAINNET, "", WALLET_LANG, Electroneum::NetworkType::MAINNET);
1080 wmgr->closeWallet(wallet);
1081 wallet = wmgr->openWallet(WALLET_NAME_MAINNET, "", Electroneum::NetworkType::MAINNET);
1082
1083 std::unique_ptr<MyWalletListener> wallet_listener (new MyWalletListener(wallet));
1084
1085 boost::chrono::seconds wait_for = boost::chrono::seconds(SECONDS_TO_REFRESH);
1086 boost::unique_lock<boost::mutex> lock (wallet_listener->mutex);
1087 wallet->init(MAINNET_DAEMON_ADDRESS, 0);
1088 wallet->startRefresh();
1089 std::cerr << "TEST: waiting on refresh lock...\n";
1090 wallet_listener->cv_refresh.wait_for(lock, wait_for);
1091 std::cerr << "TEST: refresh lock acquired...\n";
1092 ASSERT_TRUE(wallet->status() == Electroneum::Wallet::Status_Ok);
1093 ASSERT_TRUE(wallet_listener->refresh_triggered);
1094 ASSERT_TRUE(wallet->connected());
1095 ASSERT_TRUE(wallet->blockChainHeight() == wallet->daemonBlockChainHeight());
1096 std::cerr << "TEST: closing wallet...\n";
1097 wmgr->closeWallet(wallet);
1098
1099}
Here is the call graph for this function:

◆ TEST_F() [4/36]

TEST_F ( WalletManagerMainnetTest ,
RecoverAndRefreshWalletMainNetAsync  )

Definition at line 1101 of file main.cpp.

1102{
1103
1104 // supposing 120 seconds should be enough for fast refresh
1105 int SECONDS_TO_REFRESH = 120;
1106 Electroneum::Wallet * wallet = wmgr->createWallet(WALLET_NAME_MAINNET, "", WALLET_LANG, Electroneum::NetworkType::MAINNET);
1107 std::string seed = wallet->seed();
1108 std::string address = wallet->mainAddress();
1109 wmgr->closeWallet(wallet);
1110
1111 // deleting wallet files
1112 Utils::deleteWallet(WALLET_NAME_MAINNET);
1113 // ..and recovering wallet from seed
1114
1115 wallet = wmgr->recoveryWallet(WALLET_NAME_MAINNET, seed, Electroneum::NetworkType::MAINNET);
1116 ASSERT_TRUE(wallet->status() == Electroneum::Wallet::Status_Ok);
1117 ASSERT_TRUE(wallet->mainAddress() == address);
1118 std::unique_ptr<MyWalletListener> wallet_listener (new MyWalletListener(wallet));
1119 boost::chrono::seconds wait_for = boost::chrono::seconds(SECONDS_TO_REFRESH);
1120 boost::unique_lock<boost::mutex> lock (wallet_listener->mutex);
1121 wallet->init(MAINNET_DAEMON_ADDRESS, 0);
1122 wallet->startRefresh();
1123 std::cerr << "TEST: waiting on refresh lock...\n";
1124
1125 // here we wait for 120 seconds and test if wallet doesn't syncrnonize blockchain completely,
1126 // as it needs much more than 120 seconds for mainnet
1127
1128 wallet_listener->cv_refresh.wait_for(lock, wait_for);
1129 ASSERT_TRUE(wallet->status() == Electroneum::Wallet::Status_Ok);
1130 ASSERT_FALSE(wallet_listener->refresh_triggered);
1131 ASSERT_TRUE(wallet->connected());
1132 ASSERT_FALSE(wallet->blockChainHeight() == wallet->daemonBlockChainHeight());
1133 std::cerr << "TEST: closing wallet...\n";
1134 wmgr->closeWallet(wallet);
1135 std::cerr << "TEST: wallet closed\n";
1136
1137}
ASSERT_FALSE
#define ASSERT_FALSE(condition)
Definition gtest.h:1868
Electroneum::Wallet::mainAddress
std::string mainAddress() const
Definition wallet2_api.h:464
Electroneum::Wallet::seed
virtual std::string seed() const =0
Utils::deleteWallet
static void deleteWallet(const std::string &walletname)
Definition main.cpp:103
address
const char * address
Definition multisig.cpp:37
Here is the call graph for this function:

◆ TEST_F() [5/36]

TEST_F ( WalletManagerTest ,
WalletAmountFromString  )

Definition at line 247 of file main.cpp.

248{
249 uint64_t amount = Electroneum::Wallet::amountFromString("18446740");
250 ASSERT_TRUE(amount > 0);
251 amount = Electroneum::Wallet::amountFromString("11000000000000");
252 ASSERT_FALSE(amount > 0);
253 amount = Electroneum::Wallet::amountFromString("0.0");
254 ASSERT_FALSE(amount > 0);
255 amount = Electroneum::Wallet::amountFromString("10.1");
256 ASSERT_TRUE(amount > 0);
257
258}
uint64_t
unsigned __int64 uint64_t
Definition stdint.h:136
Electroneum::Wallet::amountFromString
static uint64_t amountFromString(const std::string &amount)
Definition wallet.cpp:304
Here is the call graph for this function:

◆ TEST_F() [6/36]

TEST_F ( WalletManagerTest ,
WalletManagerChangesPassword  )

Definition at line 356 of file main.cpp.

357{
358 Electroneum::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, Electroneum::NetworkType::MAINNET);
359 std::string seed1 = wallet1->seed();
360 ASSERT_TRUE(wallet1->setPassword(WALLET_PASS2));
361 ASSERT_TRUE(wmgr->closeWallet(wallet1));
362 Electroneum::Wallet * wallet2 = wmgr->openWallet(WALLET_NAME, WALLET_PASS2, Electroneum::NetworkType::MAINNET);
363 ASSERT_TRUE(wallet2->status() == Electroneum::Wallet::Status_Ok);
364 ASSERT_TRUE(wallet2->seed() == seed1);
365 ASSERT_TRUE(wmgr->closeWallet(wallet2));
366 Electroneum::Wallet * wallet3 = wmgr->openWallet(WALLET_NAME, WALLET_PASS, Electroneum::NetworkType::MAINNET);
367 ASSERT_FALSE(wallet3->status() == Electroneum::Wallet::Status_Ok);
368}
Consts::WALLET_PASS2
const char * WALLET_PASS2
Definition main.cpp:69
Consts::WALLET_PASS
const char * WALLET_PASS
Definition main.cpp:68
Electroneum::Wallet::setPassword
virtual bool setPassword(const std::string &password)=0
Here is the call graph for this function:

◆ TEST_F() [7/36]

TEST_F ( WalletManagerTest ,
WalletManagerCreatesWallet  )

Definition at line 209 of file main.cpp.

210{
211
212 Electroneum::Wallet * wallet = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, Electroneum::NetworkType::MAINNET);
213 ASSERT_TRUE(wallet->status() == Electroneum::Wallet::Status_Ok);
214 ASSERT_TRUE(!wallet->seed().empty());
215 std::vector<std::string> words;
216 std::string seed = wallet->seed();
217 boost::split(words, seed, boost::is_any_of(" "), boost::token_compress_on);
218 ASSERT_TRUE(words.size() == 25);
219 std::cout << "** seed: " << wallet->seed() << std::endl;
220 ASSERT_FALSE(wallet->mainAddress().empty());
221 std::cout << "** address: " << wallet->mainAddress() << std::endl;
222 ASSERT_TRUE(wmgr->closeWallet(wallet));
223
224}
Here is the call graph for this function:

◆ TEST_F() [8/36]

TEST_F ( WalletManagerTest ,
WalletManagerFindsWallet  )

Definition at line 470 of file main.cpp.

471{
472 std::vector<std::string> wallets = wmgr->findWallets(WALLETS_ROOT_DIR);
473 ASSERT_FALSE(wallets.empty());
474 std::cout << "Found wallets: " << std::endl;
475 for (auto wallet_path: wallets) {
476 std::cout << wallet_path << std::endl;
477 }
478}

◆ TEST_F() [9/36]

TEST_F ( WalletManagerTest ,
WalletManagerMovesWallet  )

Definition at line 340 of file main.cpp.

341{
342
343 Electroneum::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, Electroneum::NetworkType::MAINNET);
344 std::string WALLET_NAME_MOVED = std::string("/tmp/") + WALLET_NAME + ".moved";
345 std::string seed1 = wallet1->seed();
346 ASSERT_TRUE(wallet1->store(WALLET_NAME_MOVED));
347
348 Electroneum::Wallet * wallet2 = wmgr->openWallet(WALLET_NAME_MOVED, WALLET_PASS, Electroneum::NetworkType::MAINNET);
349 ASSERT_TRUE(wallet2->filename() == WALLET_NAME_MOVED);
350 ASSERT_TRUE(wallet2->keysFilename() == WALLET_NAME_MOVED + ".keys");
351 ASSERT_TRUE(wallet2->status() == Electroneum::Wallet::Status_Ok);
352 ASSERT_TRUE(wallet2->seed() == seed1);
353}
Electroneum::Wallet::keysFilename
virtual std::string keysFilename() const =0
keysFilename - returns keys filename. usually this formed as "wallet_filename".keys
Electroneum::Wallet::store
virtual bool store(const std::string &path)=0
store - stores wallet to file.
Electroneum::Wallet::filename
virtual std::string filename() const =0
filename - returns wallet filename
Here is the call graph for this function:

◆ TEST_F() [10/36]

TEST_F ( WalletManagerTest ,
WalletManagerOpensWallet  )

Definition at line 226 of file main.cpp.

227{
228
229 Electroneum::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, Electroneum::NetworkType::MAINNET);
230 std::string seed1 = wallet1->seed();
231 ASSERT_TRUE(wmgr->closeWallet(wallet1));
232 Electroneum::Wallet * wallet2 = wmgr->openWallet(WALLET_NAME, WALLET_PASS, Electroneum::NetworkType::MAINNET);
233 ASSERT_TRUE(wallet2->status() == Electroneum::Wallet::Status_Ok);
234 ASSERT_TRUE(wallet2->seed() == seed1);
235 std::cout << "** seed: " << wallet2->seed() << std::endl;
236}
Here is the call graph for this function:

◆ TEST_F() [11/36]

TEST_F ( WalletManagerTest ,
WalletManagerOpensWalletWithPasswordAndReopen  )

Definition at line 302 of file main.cpp.

303{
304 // create password protected wallet
305 std::string wallet_pass = "password";
306 std::string wrong_wallet_pass = "1111";
307 Electroneum::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, wallet_pass, WALLET_LANG, Electroneum::NetworkType::TESTNET);
308 std::string seed1 = wallet1->seed();
309 ASSERT_TRUE(wmgr->closeWallet(wallet1));
310
311 Electroneum::Wallet *wallet2 = nullptr;
312 Electroneum::Wallet *wallet3 = nullptr;
313 boost::mutex mutex;
314
315 open_wallet_helper(wmgr, &wallet2, wrong_wallet_pass, nullptr);
316 ASSERT_TRUE(wallet2 != nullptr);
317 ASSERT_TRUE(wallet2->status() != Electroneum::Wallet::Status_Ok);
318 ASSERT_TRUE(wmgr->closeWallet(wallet2));
319
320 open_wallet_helper(wmgr, &wallet3, wallet_pass, nullptr);
321 ASSERT_TRUE(wallet3 != nullptr);
322 ASSERT_TRUE(wallet3->status() == Electroneum::Wallet::Status_Ok);
323 ASSERT_TRUE(wmgr->closeWallet(wallet3));
324}
open_wallet_helper
void open_wallet_helper(Electroneum::WalletManager *wmgr, Electroneum::Wallet **wallet, const std::string &pass, boost::mutex *mutex)
Definition main.cpp:260
Here is the call graph for this function:

◆ TEST_F() [12/36]

TEST_F ( WalletManagerTest ,
WalletManagerRecoversWallet  )

Definition at line 372 of file main.cpp.

373{
374 Electroneum::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, Electroneum::NetworkType::MAINNET);
375 std::string seed1 = wallet1->seed();
376 std::string address1 = wallet1->mainAddress();
377 ASSERT_FALSE(address1.empty());
378 ASSERT_TRUE(wmgr->closeWallet(wallet1));
379 Utils::deleteWallet(WALLET_NAME);
380 Electroneum::Wallet * wallet2 = wmgr->recoveryWallet(WALLET_NAME, seed1, Electroneum::NetworkType::MAINNET);
381 ASSERT_TRUE(wallet2->status() == Electroneum::Wallet::Status_Ok);
382 ASSERT_TRUE(wallet2->seed() == seed1);
383 ASSERT_TRUE(wallet2->mainAddress() == address1);
384 ASSERT_TRUE(wmgr->closeWallet(wallet2));
385}
Here is the call graph for this function:

◆ TEST_F() [13/36]

TEST_F ( WalletManagerTest ,
WalletManagerStoresWallet  )

Definition at line 327 of file main.cpp.

328{
329
330 Electroneum::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, Electroneum::NetworkType::MAINNET);
331 std::string seed1 = wallet1->seed();
332 wallet1->store("");
333 ASSERT_TRUE(wmgr->closeWallet(wallet1));
334 Electroneum::Wallet * wallet2 = wmgr->openWallet(WALLET_NAME, WALLET_PASS, Electroneum::NetworkType::MAINNET);
335 ASSERT_TRUE(wallet2->status() == Electroneum::Wallet::Status_Ok);
336 ASSERT_TRUE(wallet2->seed() == seed1);
337}
Here is the call graph for this function:

◆ TEST_F() [14/36]

TEST_F ( WalletManagerTest ,
WalletManagerStoresWallet1  )

Definition at line 388 of file main.cpp.

389{
390 Electroneum::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, Electroneum::NetworkType::MAINNET);
391 std::string seed1 = wallet1->seed();
392 std::string address1 = wallet1->mainAddress();
393
394 ASSERT_TRUE(wallet1->store(""));
395 ASSERT_TRUE(wallet1->store(WALLET_NAME_COPY));
396 ASSERT_TRUE(wmgr->closeWallet(wallet1));
397 Electroneum::Wallet * wallet2 = wmgr->openWallet(WALLET_NAME_COPY, WALLET_PASS, Electroneum::NetworkType::MAINNET);
398 ASSERT_TRUE(wallet2->status() == Electroneum::Wallet::Status_Ok);
399 ASSERT_TRUE(wallet2->seed() == seed1);
400 ASSERT_TRUE(wallet2->mainAddress() == address1);
401 ASSERT_TRUE(wmgr->closeWallet(wallet2));
402}
Consts::WALLET_NAME_COPY
const char * WALLET_NAME_COPY
Definition main.cpp:65
Here is the call graph for this function:

◆ TEST_F() [15/36]

TEST_F ( WalletManagerTest ,
WalletManagerStoresWallet2  )

Definition at line 405 of file main.cpp.

406{
407 Electroneum::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, Electroneum::NetworkType::MAINNET);
408 std::string seed1 = wallet1->seed();
409 std::string address1 = wallet1->mainAddress();
410
411 ASSERT_TRUE(wallet1->store(WALLET_NAME_WITH_DIR));
412 ASSERT_TRUE(wmgr->closeWallet(wallet1));
413
414 wallet1 = wmgr->openWallet(WALLET_NAME_WITH_DIR, WALLET_PASS, Electroneum::NetworkType::MAINNET);
415 ASSERT_TRUE(wallet1->status() == Electroneum::Wallet::Status_Ok);
416 ASSERT_TRUE(wallet1->seed() == seed1);
417 ASSERT_TRUE(wallet1->mainAddress() == address1);
418 ASSERT_TRUE(wmgr->closeWallet(wallet1));
419}
Consts::WALLET_NAME_WITH_DIR
const char * WALLET_NAME_WITH_DIR
Definition main.cpp:66
Here is the call graph for this function:

◆ TEST_F() [16/36]

TEST_F ( WalletManagerTest ,
WalletManagerStoresWallet3  )

Definition at line 422 of file main.cpp.

423{
424 Electroneum::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, Electroneum::NetworkType::MAINNET);
425 std::string seed1 = wallet1->seed();
426 std::string address1 = wallet1->mainAddress();
427
428 ASSERT_FALSE(wallet1->store(WALLET_NAME_WITH_DIR_NON_WRITABLE));
429 ASSERT_TRUE(wmgr->closeWallet(wallet1));
430
431 wallet1 = wmgr->openWallet(WALLET_NAME_WITH_DIR_NON_WRITABLE, WALLET_PASS, Electroneum::NetworkType::MAINNET);
432 ASSERT_FALSE(wallet1->status() == Electroneum::Wallet::Status_Ok);
433
434 // "close" always returns true;
435 ASSERT_TRUE(wmgr->closeWallet(wallet1));
436
437 wallet1 = wmgr->openWallet(WALLET_NAME, WALLET_PASS, Electroneum::NetworkType::MAINNET);
438 ASSERT_TRUE(wallet1->status() == Electroneum::Wallet::Status_Ok);
439 ASSERT_TRUE(wallet1->seed() == seed1);
440 ASSERT_TRUE(wallet1->mainAddress() == address1);
441 ASSERT_TRUE(wmgr->closeWallet(wallet1));
442
443}
Consts::WALLET_NAME_WITH_DIR_NON_WRITABLE
const char * WALLET_NAME_WITH_DIR_NON_WRITABLE
Definition main.cpp:67
Here is the call graph for this function:

◆ TEST_F() [17/36]

TEST_F ( WalletManagerTest ,
WalletManagerStoresWallet4  )

Definition at line 446 of file main.cpp.

447{
448 Electroneum::Wallet * wallet1 = wmgr->createWallet(WALLET_NAME, WALLET_PASS, WALLET_LANG, Electroneum::NetworkType::MAINNET);
449 std::string seed1 = wallet1->seed();
450 std::string address1 = wallet1->mainAddress();
451
452 ASSERT_TRUE(wallet1->store(""));
453 ASSERT_TRUE(wallet1->status() == Electroneum::Wallet::Status_Ok);
454
455 ASSERT_TRUE(wallet1->store(""));
456 ASSERT_TRUE(wallet1->status() == Electroneum::Wallet::Status_Ok);
457
458 ASSERT_TRUE(wmgr->closeWallet(wallet1));
459
460 wallet1 = wmgr->openWallet(WALLET_NAME, WALLET_PASS, Electroneum::NetworkType::MAINNET);
461 ASSERT_TRUE(wallet1->status() == Electroneum::Wallet::Status_Ok);
462 ASSERT_TRUE(wallet1->seed() == seed1);
463 ASSERT_TRUE(wallet1->mainAddress() == address1);
464 ASSERT_TRUE(wmgr->closeWallet(wallet1));
465}
Here is the call graph for this function:

◆ TEST_F() [18/36]

TEST_F ( WalletManagerTest ,
WalletMaxAmountAsString  )

Definition at line 239 of file main.cpp.

240{
241 LOG_PRINT_L3("max amount: " << Electroneum::Wallet::displayAmount(
242 Electroneum::Wallet::maximumAllowedAmount()));
243
244}
Electroneum::Wallet::displayAmount
static std::string displayAmount(uint64_t amount)
Definition wallet.cpp:299
Electroneum::Wallet::maximumAllowedAmount
static uint64_t maximumAllowedAmount()
Definition wallet.cpp:388
Here is the call graph for this function:

◆ TEST_F() [19/36]

TEST_F ( WalletTest1 ,
WalletConvertsToString  )

Definition at line 554 of file main.cpp.

555{
556 std::string strAmount = Electroneum::Wallet::displayAmount(AMOUNT_5ETN);
557 ASSERT_TRUE(AMOUNT_5ETN == Electroneum::Wallet::amountFromString(strAmount));
558
559 ASSERT_TRUE(AMOUNT_5ETN == Electroneum::Wallet::amountFromDouble(5.0));
560 ASSERT_TRUE(AMOUNT_10ETN == Electroneum::Wallet::amountFromDouble(10.0));
561 ASSERT_TRUE(AMOUNT_1ETN == Electroneum::Wallet::amountFromDouble(1.0));
562
563}
Consts::AMOUNT_5ETN
const uint64_t AMOUNT_5ETN
Definition main.cpp:86
Consts::AMOUNT_10ETN
const uint64_t AMOUNT_10ETN
Definition main.cpp:85
Consts::AMOUNT_1ETN
const uint64_t AMOUNT_1ETN
Definition main.cpp:87
Electroneum::Wallet::amountFromDouble
static uint64_t amountFromDouble(double amount)
Definition wallet.cpp:311
Here is the call graph for this function:

◆ TEST_F() [20/36]

TEST_F ( WalletTest1 ,
WalletGeneratesIntegratedAddress  )

Definition at line 488 of file main.cpp.

489{
490 std::string payment_id = Electroneum::Wallet::genPaymentId();
491
492 Electroneum::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Electroneum::NetworkType::TESTNET);
493 std::string integrated_address = wallet1->integratedAddress(payment_id);
494 ASSERT_TRUE(integrated_address.length() == 106);
495}
Consts::TESTNET_WALLET_PASS
const char * TESTNET_WALLET_PASS
Definition main.cpp:80
Electroneum::Wallet::genPaymentId
static std::string genPaymentId()
Definition wallet.cpp:318
Electroneum::Wallet::integratedAddress
virtual std::string integratedAddress(const std::string &payment_id) const =0
integratedAddress - returns integrated address for current wallet address and given payment_id....
Here is the call graph for this function:

◆ TEST_F() [21/36]

TEST_F ( WalletTest1 ,
WalletGeneratesPaymentId  )

Definition at line 481 of file main.cpp.

482{
483 std::string payment_id = Electroneum::Wallet::genPaymentId();
484 ASSERT_TRUE(payment_id.length() == 16);
485}
Here is the call graph for this function:

◆ TEST_F() [22/36]

TEST_F ( WalletTest1 ,
WalletHistory  )

Definition at line 684 of file main.cpp.

685{
686 Electroneum::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Electroneum::NetworkType::TESTNET);
687 // make sure testnet daemon is running
688 ASSERT_TRUE(wallet1->init(TESTNET_DAEMON_ADDRESS, 0));
689 ASSERT_TRUE(wallet1->refresh());
690 Electroneum::TransactionHistory * history = wallet1->history();
691 history->refresh();
692 ASSERT_TRUE(history->count() > 0);
693
694
695 for (auto t: history->getAll()) {
696 ASSERT_TRUE(t != nullptr);
697 Utils::print_transaction(t);
698 }
699}
Electroneum::TransactionHistory
The TransactionHistory - interface for displaying transaction history.
Definition wallet2_api.h:204
Electroneum::TransactionHistory::count
virtual int count() const =0
Electroneum::TransactionHistory::getAll
virtual std::vector< TransactionInfo * > getAll() const =0
Electroneum::Wallet::history
virtual TransactionHistory * history()=0
Electroneum::Wallet::refresh
virtual bool refresh()=0
refresh - refreshes the wallet, updating transactions from daemon
Utils::print_transaction
static void print_transaction(Electroneum::TransactionInfo *t)
Definition main.cpp:117
Here is the call graph for this function:

◆ TEST_F() [23/36]

TEST_F ( WalletTest1 ,
WalletRefresh  )

Definition at line 542 of file main.cpp.

543{
544
545 std::cout << "Opening wallet: " << CURRENT_SRC_WALLET << std::endl;
546 Electroneum::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Electroneum::NetworkType::TESTNET);
547 // make sure testnet daemon is running
548 std::cout << "connecting to daemon: " << TESTNET_DAEMON_ADDRESS << std::endl;
549 ASSERT_TRUE(wallet1->init(TESTNET_DAEMON_ADDRESS, 0));
550 ASSERT_TRUE(wallet1->refresh());
551 ASSERT_TRUE(wmgr->closeWallet(wallet1));
552}
Here is the call graph for this function:

◆ TEST_F() [24/36]

TEST_F ( WalletTest1 ,
WalletReturnsCurrentBlockHeight  )

Definition at line 516 of file main.cpp.

517{
518 Electroneum::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Electroneum::NetworkType::TESTNET);
519 ASSERT_TRUE(wallet1->blockChainHeight() > 0);
520 wmgr->closeWallet(wallet1);
521}
Here is the call graph for this function:

◆ TEST_F() [25/36]

TEST_F ( WalletTest1 ,
WalletReturnsDaemonBlockHeight  )

Definition at line 524 of file main.cpp.

525{
526 Electroneum::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Electroneum::NetworkType::TESTNET);
527 // wallet not connected to daemon
528 ASSERT_TRUE(wallet1->daemonBlockChainHeight() == 0);
529 ASSERT_TRUE(wallet1->status() != Electroneum::Wallet::Status_Ok);
530 ASSERT_FALSE(wallet1->errorString().empty());
531 wmgr->closeWallet(wallet1);
532
533 wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Electroneum::NetworkType::TESTNET);
534 // wallet connected to daemon
535 wallet1->init(TESTNET_DAEMON_ADDRESS, 0);
536 ASSERT_TRUE(wallet1->daemonBlockChainHeight() > 0);
537 std::cout << "daemonBlockChainHeight: " << wallet1->daemonBlockChainHeight() << std::endl;
538 wmgr->closeWallet(wallet1);
539}
Electroneum::Wallet::errorString
virtual std::string errorString() const =0
in case error status, returns error string
Here is the call graph for this function:

◆ TEST_F() [26/36]

TEST_F ( WalletTest1 ,
WalletShowsBalance  )

Definition at line 498 of file main.cpp.

499{
500 Electroneum::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Electroneum::NetworkType::TESTNET);
501 ASSERT_TRUE(wallet1->balance(0) > 0);
502 ASSERT_TRUE(wallet1->unlockedBalance(0) > 0);
503
504 uint64_t balance1 = wallet1->balance(0);
505 uint64_t unlockedBalance1 = wallet1->unlockedBalance(0);
506 ASSERT_TRUE(wmgr->closeWallet(wallet1));
507 Electroneum::Wallet * wallet2 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Electroneum::NetworkType::TESTNET);
508
509 ASSERT_TRUE(balance1 == wallet2->balance(0));
510 std::cout << "wallet balance: " << wallet2->balance(0) << std::endl;
511 ASSERT_TRUE(unlockedBalance1 == wallet2->unlockedBalance(0));
512 std::cout << "wallet unlocked balance: " << wallet2->unlockedBalance(0) << std::endl;
513 ASSERT_TRUE(wmgr->closeWallet(wallet2));
514}
Electroneum::Wallet::balance
virtual uint64_t balance(uint32_t accountIndex=0, bool public_blockchain=false) const =0
Electroneum::Wallet::unlockedBalance
virtual uint64_t unlockedBalance(uint32_t accountIndex=0, bool public_blockchain=false) const =0
Here is the call graph for this function:

◆ TEST_F() [27/36]

TEST_F ( WalletTest1 ,
WalletTransaction  )

Definition at line 567 of file main.cpp.

569{
570 Electroneum::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Electroneum::NetworkType::TESTNET);
571 // make sure testnet daemon is running
572 ASSERT_TRUE(wallet1->init(TESTNET_DAEMON_ADDRESS, 0));
573 ASSERT_TRUE(wallet1->refresh());
574 uint64_t balance = wallet1->balance(0);
575 ASSERT_TRUE(wallet1->status() == Electroneum::PendingTransaction::Status_Ok);
576
577 std::string recepient_address = Utils::get_wallet_address(CURRENT_DST_WALLET, TESTNET_WALLET_PASS);
578 const int MIXIN_COUNT = 4;
579
580
581 Electroneum::PendingTransaction * transaction = wallet1->createTransaction(recepient_address,
582 PAYMENT_ID_EMPTY,
583 AMOUNT_10ETN,
584 MIXIN_COUNT,
585 Electroneum::PendingTransaction::Priority_Medium,
586 0,
587 std::set<uint32_t>{});
588 ASSERT_TRUE(transaction->status() == Electroneum::PendingTransaction::Status_Ok);
589 wallet1->refresh();
590
591 ASSERT_TRUE(wallet1->balance(0) == balance);
592 ASSERT_TRUE(transaction->amount() == AMOUNT_10ETN);
593 ASSERT_TRUE(transaction->commit());
594 ASSERT_FALSE(wallet1->balance(0) == balance);
595 ASSERT_TRUE(wmgr->closeWallet(wallet1));
596}
Consts::PAYMENT_ID_EMPTY
const std::string PAYMENT_ID_EMPTY
Definition main.cpp:89
Electroneum::PendingTransaction
Transaction-like interface for sending etn.
Definition wallet2_api.h:73
Electroneum::PendingTransaction::status
virtual int status() const =0
Electroneum::PendingTransaction::amount
virtual uint64_t amount() const =0
Electroneum::PendingTransaction::commit
virtual bool commit(const std::string &filename="", bool overwrite=false)=0
Electroneum::Wallet::createTransaction
virtual PendingTransaction * createTransaction(const std::string &dst_addr, const std::string &payment_id, optional< uint64_t > amount, uint32_t mixin_count, PendingTransaction::Priority=PendingTransaction::Priority_Low, uint32_t subaddr_account=0, std::set< uint32_t > subaddr_indices={})=0
createTransaction creates transaction. if dst_addr is an integrated address, payment_id is ignored
Utils::get_wallet_address
static std::string get_wallet_address(const std::string &filename, const std::string &password)
Definition main.cpp:131
Here is the call graph for this function:

◆ TEST_F() [28/36]

TEST_F ( WalletTest1 ,
WalletTransactionAndHistory  )

Definition at line 701 of file main.cpp.

702{
703 return;
704 Electroneum::Wallet * wallet_src = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Electroneum::NetworkType::TESTNET);
705 // make sure testnet daemon is running
706 ASSERT_TRUE(wallet_src->init(TESTNET_DAEMON_ADDRESS, 0));
707 ASSERT_TRUE(wallet_src->refresh());
708 Electroneum::TransactionHistory * history = wallet_src->history();
709 history->refresh();
710 ASSERT_TRUE(history->count() > 0);
711 size_t count1 = history->count();
712
713 std::cout << "**** Transactions before transfer (" << count1 << ")" << std::endl;
714 for (auto t: history->getAll()) {
715 ASSERT_TRUE(t != nullptr);
716 Utils::print_transaction(t);
717 }
718
719 std::string wallet4_addr = Utils::get_wallet_address(CURRENT_DST_WALLET, TESTNET_WALLET_PASS);
720
721
722 Electroneum::PendingTransaction * tx = wallet_src->createTransaction(wallet4_addr,
723 PAYMENT_ID_EMPTY,
724 AMOUNT_10ETN * 5, 1, Electroneum::PendingTransaction::Priority_Medium, 0, std::set<uint32_t>{});
725
726 ASSERT_TRUE(tx->status() == Electroneum::PendingTransaction::Status_Ok);
727 ASSERT_TRUE(tx->commit());
728 history = wallet_src->history();
729 history->refresh();
730 ASSERT_TRUE(count1 != history->count());
731
732 std::cout << "**** Transactions after transfer (" << history->count() << ")" << std::endl;
733 for (auto t: history->getAll()) {
734 ASSERT_TRUE(t != nullptr);
735 Utils::print_transaction(t);
736 }
737}
Here is the call graph for this function:

◆ TEST_F() [29/36]

TEST_F ( WalletTest1 ,
WalletTransactionWithMixin  )

Definition at line 600 of file main.cpp.

601{
602
603 std::vector<int> mixins;
604 // 2,3,4,5,6,7,8,9,10,15,20,25 can we do it like that?
605 mixins.push_back(2); mixins.push_back(3); mixins.push_back(4); mixins.push_back(5); mixins.push_back(6);
606 mixins.push_back(7); mixins.push_back(8); mixins.push_back(9); mixins.push_back(10); mixins.push_back(15);
607 mixins.push_back(20); mixins.push_back(25);
608
609
610 std::string payment_id = "";
611
612 Electroneum::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Electroneum::NetworkType::TESTNET);
613
614
615 // make sure testnet daemon is running
616 ASSERT_TRUE(wallet1->init(TESTNET_DAEMON_ADDRESS, 0));
617 ASSERT_TRUE(wallet1->refresh());
618 uint64_t balance = wallet1->balance(0);
619 ASSERT_TRUE(wallet1->status() == Electroneum::PendingTransaction::Status_Ok);
620
621 std::string recepient_address = Utils::get_wallet_address(CURRENT_DST_WALLET, TESTNET_WALLET_PASS);
622 for (auto mixin : mixins) {
623 std::cerr << "Transaction mixin count: " << mixin << std::endl;
624
625 Electroneum::PendingTransaction * transaction = wallet1->createTransaction(
626 recepient_address, payment_id, AMOUNT_5ETN, mixin, Electroneum::PendingTransaction::Priority_Medium, 0, std::set<uint32_t>{});
627
628 std::cerr << "Transaction status: " << transaction->status() << std::endl;
629 std::cerr << "Transaction fee: " << Electroneum::Wallet::displayAmount(transaction->fee()) << std::endl;
630 std::cerr << "Transaction error: " << transaction->errorString() << std::endl;
631 ASSERT_TRUE(transaction->status() == Electroneum::PendingTransaction::Status_Ok);
632 wallet1->disposeTransaction(transaction);
633 }
634
635 wallet1->refresh();
636
637 ASSERT_TRUE(wallet1->balance(0) == balance);
638 ASSERT_TRUE(wmgr->closeWallet(wallet1));
639}
Electroneum::PendingTransaction::fee
virtual uint64_t fee() const =0
Electroneum::PendingTransaction::errorString
virtual std::string errorString() const =0
Electroneum::Wallet::disposeTransaction
virtual void disposeTransaction(PendingTransaction *t)=0
disposeTransaction - destroys transaction object
Here is the call graph for this function:

◆ TEST_F() [30/36]

TEST_F ( WalletTest1 ,
WalletTransactionWithPaymentId  )

Definition at line 740 of file main.cpp.

741{
742
743 Electroneum::Wallet * wallet_src = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Electroneum::NetworkType::TESTNET);
744 // make sure testnet daemon is running
745 ASSERT_TRUE(wallet_src->init(TESTNET_DAEMON_ADDRESS, 0));
746 ASSERT_TRUE(wallet_src->refresh());
747 Electroneum::TransactionHistory * history = wallet_src->history();
748 history->refresh();
749 ASSERT_TRUE(history->count() > 0);
750 size_t count1 = history->count();
751
752 std::cout << "**** Transactions before transfer (" << count1 << ")" << std::endl;
753 for (auto t: history->getAll()) {
754 ASSERT_TRUE(t != nullptr);
755 Utils::print_transaction(t);
756 }
757
758 std::string wallet4_addr = Utils::get_wallet_address(CURRENT_DST_WALLET, TESTNET_WALLET_PASS);
759
760 std::string payment_id = Electroneum::Wallet::genPaymentId();
761 ASSERT_TRUE(payment_id.length() == 16);
762
763
764 Electroneum::PendingTransaction * tx = wallet_src->createTransaction(wallet4_addr,
765 payment_id,
766 AMOUNT_1ETN, 1, Electroneum::PendingTransaction::Priority_Medium, 0, std::set<uint32_t>{});
767
768 ASSERT_TRUE(tx->status() == Electroneum::PendingTransaction::Status_Ok);
769 ASSERT_TRUE(tx->commit());
770 history = wallet_src->history();
771 history->refresh();
772 ASSERT_TRUE(count1 != history->count());
773
774 bool payment_id_in_history = false;
775
776 std::cout << "**** Transactions after transfer (" << history->count() << ")" << std::endl;
777 for (auto t: history->getAll()) {
778 ASSERT_TRUE(t != nullptr);
779 Utils::print_transaction(t);
780 if (t->paymentId() == payment_id) {
781 payment_id_in_history = true;
782 }
783 }
784
785 ASSERT_TRUE(payment_id_in_history);
786}
Here is the call graph for this function:

◆ TEST_F() [31/36]

TEST_F ( WalletTest1 ,
WalletTransactionWithPriority  )

Definition at line 641 of file main.cpp.

642{
643
644 std::string payment_id = "";
645
646 Electroneum::Wallet * wallet1 = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Electroneum::NetworkType::TESTNET);
647
648 // make sure testnet daemon is running
649 ASSERT_TRUE(wallet1->init(TESTNET_DAEMON_ADDRESS, 0));
650 ASSERT_TRUE(wallet1->refresh());
651 uint64_t balance = wallet1->balance(0);
652 ASSERT_TRUE(wallet1->status() == Electroneum::PendingTransaction::Status_Ok);
653
654 std::string recepient_address = Utils::get_wallet_address(CURRENT_DST_WALLET, TESTNET_WALLET_PASS);
655 uint32_t mixin = 0;
656 uint64_t fee = 0;
657
658 std::vector<Electroneum::PendingTransaction::Priority> priorities = {
659 Electroneum::PendingTransaction::Priority_Low,
660 Electroneum::PendingTransaction::Priority_Medium,
661 Electroneum::PendingTransaction::Priority_High
662 };
663
664 for (auto it = priorities.begin(); it != priorities.end(); ++it) {
665 std::cerr << "Transaction priority: " << *it << std::endl;
666
667 Electroneum::PendingTransaction * transaction = wallet1->createTransaction(
668 recepient_address, payment_id, AMOUNT_5ETN, mixin, *it, 0, std::set<uint32_t>{});
669 std::cerr << "Transaction status: " << transaction->status() << std::endl;
670 std::cerr << "Transaction fee: " << Electroneum::Wallet::displayAmount(transaction->fee()) << std::endl;
671 std::cerr << "Transaction error: " << transaction->errorString() << std::endl;
672 ASSERT_TRUE(transaction->fee() > fee);
673 ASSERT_TRUE(transaction->status() == Electroneum::PendingTransaction::Status_Ok);
674 fee = transaction->fee();
675 wallet1->disposeTransaction(transaction);
676 }
677 wallet1->refresh();
678 ASSERT_TRUE(wallet1->balance(0) == balance);
679 ASSERT_TRUE(wmgr->closeWallet(wallet1));
680}
uint32_t
unsigned int uint32_t
Definition stdint.h:126
Here is the call graph for this function:

◆ TEST_F() [32/36]

TEST_F ( WalletTest2 ,
WalletCallbackNewBlock  )

Definition at line 1007 of file main.cpp.

1008{
1009
1010 Electroneum::Wallet * wallet_src = wmgr->openWallet(TESTNET_WALLET5_NAME, TESTNET_WALLET_PASS, Electroneum::NetworkType::TESTNET);
1011 // make sure testnet daemon is running
1012 ASSERT_TRUE(wallet_src->init(TESTNET_DAEMON_ADDRESS, 0));
1013 ASSERT_TRUE(wallet_src->refresh());
1014 uint64_t bc1 = wallet_src->blockChainHeight();
1015 std::cout << "** Block height: " << bc1 << std::endl;
1016
1017
1018 std::unique_ptr<MyWalletListener> wallet_listener (new MyWalletListener(wallet_src));
1019
1020 // wait max 4 min for new block
1021 boost::chrono::seconds wait_for = boost::chrono::seconds(60*4);
1022 boost::unique_lock<boost::mutex> lock (wallet_listener->mutex);
1023 std::cerr << "TEST: waiting on newblock lock...\n";
1024 wallet_listener->cv_newblock.wait_for(lock, wait_for);
1025 std::cerr << "TEST: newblock lock acquired...\n";
1026 ASSERT_TRUE(wallet_listener->newblock_triggered);
1027 uint64_t bc2 = wallet_src->blockChainHeight();
1028 std::cout << "** Block height: " << bc2 << std::endl;
1029 ASSERT_TRUE(bc2 > bc1);
1030 wmgr->closeWallet(wallet_src);
1031
1032}
Here is the call graph for this function:

◆ TEST_F() [33/36]

TEST_F ( WalletTest2 ,
WalletCallbackReceived  )

Definition at line 960 of file main.cpp.

961{
962
963 Electroneum::Wallet * wallet_src = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Electroneum::NetworkType::TESTNET);
964 // make sure testnet daemon is running
965 ASSERT_TRUE(wallet_src->init(TESTNET_DAEMON_ADDRESS, 0));
966 ASSERT_TRUE(wallet_src->refresh());
967 std::cout << "** Balance src1: " << wallet_src->displayAmount(wallet_src->balance(0)) << std::endl;
968
969 Electroneum::Wallet * wallet_dst = wmgr->openWallet(CURRENT_DST_WALLET, TESTNET_WALLET_PASS, Electroneum::NetworkType::TESTNET);
970 ASSERT_TRUE(wallet_dst->init(TESTNET_DAEMON_ADDRESS, 0));
971 ASSERT_TRUE(wallet_dst->refresh());
972 uint64_t balance = wallet_dst->balance(0);
973 std::cout << "** Balance dst1: " << wallet_dst->displayAmount(wallet_dst->balance(0)) << std::endl;
974 std::unique_ptr<MyWalletListener> wallet_dst_listener (new MyWalletListener(wallet_dst));
975
976 uint64_t amount = AMOUNT_1ETN * 5;
977 std::cout << "** Sending " << Electroneum::Wallet::displayAmount(amount) << " to " << wallet_dst->mainAddress();
978 Electroneum::PendingTransaction * tx = wallet_src->createTransaction(wallet_dst->mainAddress(),
979 PAYMENT_ID_EMPTY,
980 amount, 1, Electroneum::PendingTransaction::Priority_Medium, 0, std::set<uint32_t>{});
981
982 std::cout << "** Committing transaction: " << Electroneum::Wallet::displayAmount(tx->amount())
983 << " with fee: " << Electroneum::Wallet::displayAmount(tx->fee());
984
985 ASSERT_TRUE(tx->status() == Electroneum::PendingTransaction::Status_Ok);
986 ASSERT_TRUE(tx->commit());
987
988 boost::chrono::seconds wait_for = boost::chrono::seconds(60*4);
989 boost::unique_lock<boost::mutex> lock (wallet_dst_listener->mutex);
990 std::cerr << "TEST: waiting on receive lock...\n";
991 wallet_dst_listener->cv_receive.wait_for(lock, wait_for);
992 std::cerr << "TEST: receive lock acquired...\n";
993 ASSERT_TRUE(wallet_dst_listener->receive_triggered);
994 ASSERT_TRUE(wallet_dst_listener->update_triggered);
995
996 std::cout << "** Balance src2: " << wallet_dst->displayAmount(wallet_src->balance(0)) << std::endl;
997 std::cout << "** Balance dst2: " << wallet_dst->displayAmount(wallet_dst->balance(0)) << std::endl;
998
999 ASSERT_TRUE(wallet_dst->balance(0) > balance);
1000
1001 wmgr->closeWallet(wallet_src);
1002 wmgr->closeWallet(wallet_dst);
1003}
Here is the call graph for this function:

◆ TEST_F() [34/36]

TEST_F ( WalletTest2 ,
WalletCallBackRefreshedAsync  )

Definition at line 899 of file main.cpp.

900{
901
902 Electroneum::Wallet * wallet_src = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Electroneum::NetworkType::TESTNET);
903 MyWalletListener * wallet_src_listener = new MyWalletListener(wallet_src);
904
905 boost::chrono::seconds wait_for = boost::chrono::seconds(20);
906 boost::unique_lock<boost::mutex> lock (wallet_src_listener->mutex);
907 wallet_src->init(MAINNET_DAEMON_ADDRESS, 0);
908 wallet_src->startRefresh();
909 std::cerr << "TEST: waiting on refresh lock...\n";
910 wallet_src_listener->cv_refresh.wait_for(lock, wait_for);
911 std::cerr << "TEST: refresh lock acquired...\n";
912 ASSERT_TRUE(wallet_src_listener->refresh_triggered);
913 ASSERT_TRUE(wallet_src->connected());
914 std::cerr << "TEST: closing wallet...\n";
915 wmgr->closeWallet(wallet_src);
916}
MyWalletListener::mutex
boost::mutex mutex
Definition main.cpp:795
MyWalletListener::refresh_triggered
bool refresh_triggered
Definition main.cpp:805
MyWalletListener::cv_refresh
boost::condition_variable cv_refresh
Definition main.cpp:799
Here is the call graph for this function:

◆ TEST_F() [35/36]

TEST_F ( WalletTest2 ,
WalletCallBackRefreshedSync  )

Definition at line 882 of file main.cpp.

883{
884
885 Electroneum::Wallet * wallet_src = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Electroneum::NetworkType::TESTNET);
886 MyWalletListener * wallet_src_listener = new MyWalletListener(wallet_src);
887 ASSERT_TRUE(wallet_src->init(TESTNET_DAEMON_ADDRESS, 0));
888 ASSERT_TRUE(wallet_src_listener->refresh_triggered);
889 ASSERT_TRUE(wallet_src->connected());
890 boost::chrono::seconds wait_for = boost::chrono::seconds(60*3);
891 boost::unique_lock<boost::mutex> lock (wallet_src_listener->mutex);
892 wallet_src_listener->cv_refresh.wait_for(lock, wait_for);
893 wmgr->closeWallet(wallet_src);
894}
Here is the call graph for this function:

◆ TEST_F() [36/36]

TEST_F ( WalletTest2 ,
WalletCallbackSent  )

Definition at line 921 of file main.cpp.

922{
923
924 Electroneum::Wallet * wallet_src = wmgr->openWallet(CURRENT_SRC_WALLET, TESTNET_WALLET_PASS, Electroneum::NetworkType::TESTNET);
925 // make sure testnet daemon is running
926 ASSERT_TRUE(wallet_src->init(TESTNET_DAEMON_ADDRESS, 0));
927 ASSERT_TRUE(wallet_src->refresh());
928 MyWalletListener * wallet_src_listener = new MyWalletListener(wallet_src);
929 uint64_t balance = wallet_src->balance(0);
930 std::cout << "** Balance: " << wallet_src->displayAmount(wallet_src->balance(0)) << std::endl;
931 Electroneum::Wallet * wallet_dst = wmgr->openWallet(CURRENT_DST_WALLET, TESTNET_WALLET_PASS, Electroneum::NetworkType::TESTNET);
932
933 uint64_t amount = AMOUNT_1ETN * 5;
934 std::cout << "** Sending " << Electroneum::Wallet::displayAmount(amount) << " to " << wallet_dst->mainAddress();
935
936
937 Electroneum::PendingTransaction * tx = wallet_src->createTransaction(wallet_dst->mainAddress(),
938 PAYMENT_ID_EMPTY,
939 amount, 1, Electroneum::PendingTransaction::Priority_Medium, 0, std::set<uint32_t>{});
940 std::cout << "** Committing transaction: " << Electroneum::Wallet::displayAmount(tx->amount())
941 << " with fee: " << Electroneum::Wallet::displayAmount(tx->fee());
942
943 ASSERT_TRUE(tx->status() == Electroneum::PendingTransaction::Status_Ok);
944 ASSERT_TRUE(tx->commit());
945
946 boost::chrono::seconds wait_for = boost::chrono::seconds(60*3);
947 boost::unique_lock<boost::mutex> lock (wallet_src_listener->mutex);
948 std::cerr << "TEST: waiting on send lock...\n";
949 wallet_src_listener->cv_send.wait_for(lock, wait_for);
950 std::cerr << "TEST: send lock acquired...\n";
951 ASSERT_TRUE(wallet_src_listener->send_triggered);
952 ASSERT_TRUE(wallet_src_listener->update_triggered);
953 std::cout << "** Balance: " << wallet_src->displayAmount(wallet_src->balance(0)) << std::endl;
954 ASSERT_TRUE(wallet_src->balance(0) < balance);
955 wmgr->closeWallet(wallet_src);
956 wmgr->closeWallet(wallet_dst);
957}
MyWalletListener::update_triggered
bool update_triggered
Definition main.cpp:804
MyWalletListener::cv_send
boost::condition_variable cv_send
Definition main.cpp:796
MyWalletListener::send_triggered
bool send_triggered
Definition main.cpp:801
Here is the call graph for this function: