Merge pull request #1152
8b20cbf
libwallet_api: do not use fast-refresh on recovery (Ilya Kitaev)10fe626
libwallet_api: fast-refresh in case of opening non-synced wallet (Ilya Kitaev)0019e31
libwallet_api: fix unhandled exception on address check (Ilya Kitaev)1f73f80
libwallet_api: fast-refresh for new wallet (Ilya Kitaev)4789347
libwallet_api: test for create/init wallet on mainnet (Ilya Kitaev)
This commit is contained in:
commit
db90a16f03
|
@ -56,18 +56,22 @@ bool isAddressLocal(const std::string &address)
|
|||
LOG_PRINT_L1("Failed to determine whether daemon is local, assuming not");
|
||||
return false;
|
||||
}
|
||||
|
||||
// resolve to IP
|
||||
boost::asio::io_service io_service;
|
||||
boost::asio::ip::tcp::resolver resolver(io_service);
|
||||
boost::asio::ip::tcp::resolver::query query(u_c.host, "");
|
||||
boost::asio::ip::tcp::resolver::iterator i = resolver.resolve(query);
|
||||
while (i != boost::asio::ip::tcp::resolver::iterator())
|
||||
{
|
||||
const boost::asio::ip::tcp::endpoint &ep = *i;
|
||||
if (ep.address().is_loopback())
|
||||
return true;
|
||||
++i;
|
||||
// resolver::resolve can throw an exception
|
||||
try {
|
||||
// resolve to IP
|
||||
boost::asio::io_service io_service;
|
||||
boost::asio::ip::tcp::resolver resolver(io_service);
|
||||
boost::asio::ip::tcp::resolver::query query(u_c.host, "");
|
||||
boost::asio::ip::tcp::resolver::iterator i = resolver.resolve(query);
|
||||
while (i != boost::asio::ip::tcp::resolver::iterator())
|
||||
{
|
||||
const boost::asio::ip::tcp::endpoint &ep = *i;
|
||||
if (ep.address().is_loopback())
|
||||
return true;
|
||||
++i;
|
||||
}
|
||||
} catch (const boost::system::system_error &e) {
|
||||
LOG_ERROR("Failed to resolve " << address << ", :" << e.what());
|
||||
}
|
||||
|
||||
return false;
|
||||
|
|
|
@ -167,7 +167,7 @@ uint64_t Wallet::maximumAllowedAmount()
|
|||
///////////////////////// WalletImpl implementation ////////////////////////
|
||||
WalletImpl::WalletImpl(bool testnet)
|
||||
:m_wallet(nullptr), m_status(Wallet::Status_Ok), m_trustedDaemon(false),
|
||||
m_wallet2Callback(nullptr)
|
||||
m_wallet2Callback(nullptr), m_recoveringFromSeed(false)
|
||||
{
|
||||
m_wallet = new tools::wallet2(testnet);
|
||||
m_history = new TransactionHistoryImpl(this);
|
||||
|
@ -176,6 +176,7 @@ WalletImpl::WalletImpl(bool testnet)
|
|||
m_refreshThreadDone = false;
|
||||
m_refreshEnabled = false;
|
||||
|
||||
|
||||
m_refreshIntervalMillis = DEFAULT_REFRESH_INTERVAL_MILLIS;
|
||||
|
||||
m_refreshThread = boost::thread([this] () {
|
||||
|
@ -196,7 +197,7 @@ bool WalletImpl::create(const std::string &path, const std::string &password, co
|
|||
{
|
||||
|
||||
clearStatus();
|
||||
|
||||
m_recoveringFromSeed = false;
|
||||
bool keys_file_exists;
|
||||
bool wallet_file_exists;
|
||||
tools::wallet2::wallet_exists(path, keys_file_exists, wallet_file_exists);
|
||||
|
@ -233,6 +234,7 @@ bool WalletImpl::create(const std::string &path, const std::string &password, co
|
|||
bool WalletImpl::open(const std::string &path, const std::string &password)
|
||||
{
|
||||
clearStatus();
|
||||
m_recoveringFromSeed = false;
|
||||
try {
|
||||
// TODO: handle "deprecated"
|
||||
m_wallet->load(path, password);
|
||||
|
@ -257,6 +259,7 @@ bool WalletImpl::recover(const std::string &path, const std::string &seed)
|
|||
return false;
|
||||
}
|
||||
|
||||
m_recoveringFromSeed = true;
|
||||
crypto::secret_key recovery_key;
|
||||
std::string old_language;
|
||||
if (!crypto::ElectrumWords::words_to_bytes(seed, recovery_key, old_language)) {
|
||||
|
@ -269,6 +272,7 @@ bool WalletImpl::recover(const std::string &path, const std::string &seed)
|
|||
m_wallet->set_seed_language(old_language);
|
||||
m_wallet->generate(path, "", recovery_key, true, false);
|
||||
// TODO: wallet->init(daemon_address);
|
||||
|
||||
} catch (const std::exception &e) {
|
||||
m_status = Status_Error;
|
||||
m_errorString = e.what();
|
||||
|
@ -385,11 +389,7 @@ string WalletImpl::keysFilename() const
|
|||
bool WalletImpl::init(const std::string &daemon_address, uint64_t upper_transaction_size_limit)
|
||||
{
|
||||
clearStatus();
|
||||
|
||||
m_wallet->init(daemon_address, upper_transaction_size_limit);
|
||||
if (Utils::isAddressLocal(daemon_address)) {
|
||||
this->setTrustedDaemon(true);
|
||||
}
|
||||
doInit(daemon_address, upper_transaction_size_limit);
|
||||
bool result = this->refresh();
|
||||
// enabling background refresh thread
|
||||
startRefresh();
|
||||
|
@ -400,10 +400,7 @@ bool WalletImpl::init(const std::string &daemon_address, uint64_t upper_transact
|
|||
void WalletImpl::initAsync(const string &daemon_address, uint64_t upper_transaction_size_limit)
|
||||
{
|
||||
clearStatus();
|
||||
m_wallet->init(daemon_address, upper_transaction_size_limit);
|
||||
if (Utils::isAddressLocal(daemon_address)) {
|
||||
this->setTrustedDaemon(true);
|
||||
}
|
||||
doInit(daemon_address, upper_transaction_size_limit);
|
||||
startRefresh();
|
||||
}
|
||||
|
||||
|
@ -748,4 +745,27 @@ void WalletImpl::pauseRefresh()
|
|||
}
|
||||
|
||||
|
||||
bool WalletImpl::isNewWallet() const
|
||||
{
|
||||
// in case wallet created without daemon connection, closed and opened again,
|
||||
// it's the same case as if it created from scratch, i.e. we need "fast sync"
|
||||
// with the daemon (pull hashes instead of pull blocks)
|
||||
return !(blockChainHeight() > 1 || m_recoveringFromSeed);
|
||||
}
|
||||
|
||||
void WalletImpl::doInit(const string &daemon_address, uint64_t upper_transaction_size_limit)
|
||||
{
|
||||
m_wallet->init(daemon_address, upper_transaction_size_limit);
|
||||
|
||||
// in case new wallet, this will force fast-refresh (pulling hashes instead of blocks)
|
||||
if (isNewWallet()) {
|
||||
m_wallet->set_refresh_from_block_height(daemonBlockChainHeight());
|
||||
}
|
||||
|
||||
if (Utils::isAddressLocal(daemon_address)) {
|
||||
this->setTrustedDaemon(true);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
|
|
@ -101,6 +101,8 @@ private:
|
|||
void startRefresh();
|
||||
void stopRefresh();
|
||||
void pauseRefresh();
|
||||
bool isNewWallet() const;
|
||||
void doInit(const std::string &daemon_address, uint64_t upper_transaction_size_limit);
|
||||
|
||||
private:
|
||||
friend class PendingTransactionImpl;
|
||||
|
@ -126,7 +128,10 @@ private:
|
|||
boost::mutex m_refreshMutex2;
|
||||
boost::condition_variable m_refreshCV;
|
||||
boost::thread m_refreshThread;
|
||||
|
||||
// flag indicating wallet is recovering from seed
|
||||
// so it shouldn't be considered as new and pull blocks (slow-refresh)
|
||||
// instead of pulling hashes (fast-refresh)
|
||||
bool m_recoveringFromSeed;
|
||||
};
|
||||
|
||||
|
||||
|
|
|
@ -58,6 +58,7 @@ namespace Consts
|
|||
// TODO: get rid of hardcoded paths
|
||||
|
||||
const char * WALLET_NAME = "testwallet";
|
||||
const char * WALLET_NAME_MAINNET = "testwallet_mainnet";
|
||||
const char * WALLET_NAME_COPY = "testwallet_copy";
|
||||
const char * WALLET_NAME_WITH_DIR = "walletdir/testwallet_test";
|
||||
const char * WALLET_NAME_WITH_DIR_NON_WRITABLE = "/var/walletdir/testwallet_test";
|
||||
|
@ -85,6 +86,7 @@ const uint64_t AMOUNT_1XMR = 1000000000000L;
|
|||
const std::string PAYMENT_ID_EMPTY = "";
|
||||
|
||||
std::string TESTNET_DAEMON_ADDRESS = "localhost:38081";
|
||||
std::string MAINNET_DAEMON_ADDRESS = "localhost:18081";
|
||||
|
||||
|
||||
}
|
||||
|
@ -157,6 +159,25 @@ struct WalletManagerTest : public testing::Test
|
|||
|
||||
};
|
||||
|
||||
struct WalletManagerMainnetTest : public testing::Test
|
||||
{
|
||||
Bitmonero::WalletManager * wmgr;
|
||||
|
||||
|
||||
WalletManagerMainnetTest()
|
||||
{
|
||||
std::cout << __FUNCTION__ << std::endl;
|
||||
wmgr = Bitmonero::WalletManagerFactory::getWalletManager();
|
||||
Utils::deleteWallet(WALLET_NAME_MAINNET);
|
||||
}
|
||||
|
||||
|
||||
~WalletManagerMainnetTest()
|
||||
{
|
||||
std::cout << __FUNCTION__ << std::endl;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
struct WalletTest1 : public testing::Test
|
||||
{
|
||||
|
@ -809,8 +830,12 @@ struct MyWalletListener : public Bitmonero::WalletListener
|
|||
|
||||
virtual void newBlock(uint64_t height)
|
||||
{
|
||||
std::cout << "wallet: " << wallet->address()
|
||||
<<", new block received, blockHeight: " << height << std::endl;
|
||||
// std::cout << "wallet: " << wallet->address()
|
||||
// <<", new block received, blockHeight: " << height << std::endl;
|
||||
static int bc_height = wallet->daemonBlockChainHeight();
|
||||
std::cout << height
|
||||
<< " / " << bc_height/* 0*/
|
||||
<< std::endl;
|
||||
newblock_triggered = true;
|
||||
cv_newblock.notify_one();
|
||||
}
|
||||
|
@ -871,6 +896,7 @@ TEST_F(WalletTest2, WalletCallBackRefreshedAsync)
|
|||
|
||||
|
||||
|
||||
|
||||
TEST_F(WalletTest2, WalletCallbackSent)
|
||||
{
|
||||
|
||||
|
@ -924,7 +950,7 @@ TEST_F(WalletTest2, WalletCallbackReceived)
|
|||
ASSERT_TRUE(wallet_dst->refresh());
|
||||
uint64_t balance = wallet_dst->balance();
|
||||
std::cout << "** Balance dst1: " << wallet_dst->displayAmount(wallet_dst->balance()) << std::endl;
|
||||
MyWalletListener * wallet_dst_listener = new MyWalletListener(wallet_dst);
|
||||
std::unique_ptr<MyWalletListener> wallet_dst_listener (new MyWalletListener(wallet_dst));
|
||||
|
||||
uint64_t amount = AMOUNT_1XMR * 5;
|
||||
std::cout << "** Sending " << Bitmonero::Wallet::displayAmount(amount) << " to " << wallet_dst->address();
|
||||
|
@ -968,7 +994,7 @@ TEST_F(WalletTest2, WalletCallbackNewBlock)
|
|||
std::cout << "** Block height: " << bc1 << std::endl;
|
||||
|
||||
|
||||
MyWalletListener * wallet_listener = new MyWalletListener(wallet_src);
|
||||
std::unique_ptr<MyWalletListener> wallet_listener (new MyWalletListener(wallet_src));
|
||||
|
||||
// wait max 4 min for new block
|
||||
std::chrono::seconds wait_for = std::chrono::seconds(60*4);
|
||||
|
@ -984,17 +1010,129 @@ TEST_F(WalletTest2, WalletCallbackNewBlock)
|
|||
|
||||
}
|
||||
|
||||
TEST_F(WalletManagerMainnetTest, CreateOpenAndRefreshWalletMainNetSync)
|
||||
{
|
||||
|
||||
Bitmonero::Wallet * wallet = wmgr->createWallet(WALLET_NAME_MAINNET, "", WALLET_LANG);
|
||||
std::unique_ptr<MyWalletListener> wallet_listener (new MyWalletListener(wallet));
|
||||
wallet->init(MAINNET_DAEMON_ADDRESS, 0);
|
||||
std::cerr << "TEST: waiting on refresh lock...\n";
|
||||
//wallet_listener->cv_refresh.wait_for(lock, wait_for);
|
||||
std::cerr << "TEST: refresh lock acquired...\n";
|
||||
ASSERT_TRUE(wallet_listener->refresh_triggered);
|
||||
ASSERT_TRUE(wallet->connected());
|
||||
ASSERT_TRUE(wallet->blockChainHeight() == wallet->daemonBlockChainHeight());
|
||||
std::cerr << "TEST: closing wallet...\n";
|
||||
wmgr->closeWallet(wallet);
|
||||
}
|
||||
|
||||
|
||||
TEST_F(WalletManagerMainnetTest, CreateAndRefreshWalletMainNetAsync)
|
||||
{
|
||||
// supposing 120 seconds should be enough for fast refresh
|
||||
int SECONDS_TO_REFRESH = 120;
|
||||
|
||||
Bitmonero::Wallet * wallet = wmgr->createWallet(WALLET_NAME_MAINNET, "", WALLET_LANG);
|
||||
std::unique_ptr<MyWalletListener> wallet_listener (new MyWalletListener(wallet));
|
||||
|
||||
std::chrono::seconds wait_for = std::chrono::seconds(SECONDS_TO_REFRESH);
|
||||
std::unique_lock<std::mutex> lock (wallet_listener->mutex);
|
||||
wallet->initAsync(MAINNET_DAEMON_ADDRESS, 0);
|
||||
// wallet->init(MAINNET_DAEMON_ADDRESS, 0);
|
||||
std::cerr << "TEST: waiting on refresh lock...\n";
|
||||
wallet_listener->cv_refresh.wait_for(lock, wait_for);
|
||||
std::cerr << "TEST: refresh lock acquired...\n";
|
||||
ASSERT_TRUE(wallet->status() == Bitmonero::Wallet::Status_Ok);
|
||||
ASSERT_TRUE(wallet_listener->refresh_triggered);
|
||||
ASSERT_TRUE(wallet->connected());
|
||||
ASSERT_TRUE(wallet->blockChainHeight() == wallet->daemonBlockChainHeight());
|
||||
std::cerr << "TEST: closing wallet...\n";
|
||||
wmgr->closeWallet(wallet);
|
||||
}
|
||||
|
||||
TEST_F(WalletManagerMainnetTest, OpenAndRefreshWalletMainNetAsync)
|
||||
{
|
||||
|
||||
// supposing 120 seconds should be enough for fast refresh
|
||||
int SECONDS_TO_REFRESH = 120;
|
||||
Bitmonero::Wallet * wallet = wmgr->createWallet(WALLET_NAME_MAINNET, "", WALLET_LANG);
|
||||
wmgr->closeWallet(wallet);
|
||||
wallet = wmgr->openWallet(WALLET_NAME_MAINNET, "");
|
||||
|
||||
std::unique_ptr<MyWalletListener> wallet_listener (new MyWalletListener(wallet));
|
||||
|
||||
std::chrono::seconds wait_for = std::chrono::seconds(SECONDS_TO_REFRESH);
|
||||
std::unique_lock<std::mutex> lock (wallet_listener->mutex);
|
||||
wallet->initAsync(MAINNET_DAEMON_ADDRESS, 0);
|
||||
// wallet->init(MAINNET_DAEMON_ADDRESS, 0);
|
||||
std::cerr << "TEST: waiting on refresh lock...\n";
|
||||
wallet_listener->cv_refresh.wait_for(lock, wait_for);
|
||||
std::cerr << "TEST: refresh lock acquired...\n";
|
||||
ASSERT_TRUE(wallet->status() == Bitmonero::Wallet::Status_Ok);
|
||||
ASSERT_TRUE(wallet_listener->refresh_triggered);
|
||||
ASSERT_TRUE(wallet->connected());
|
||||
ASSERT_TRUE(wallet->blockChainHeight() == wallet->daemonBlockChainHeight());
|
||||
std::cerr << "TEST: closing wallet...\n";
|
||||
wmgr->closeWallet(wallet);
|
||||
|
||||
}
|
||||
|
||||
TEST_F(WalletManagerMainnetTest, RecoverAndRefreshWalletMainNetAsync)
|
||||
{
|
||||
|
||||
// supposing 120 seconds should be enough for fast refresh
|
||||
int SECONDS_TO_REFRESH = 120;
|
||||
Bitmonero::Wallet * wallet = wmgr->createWallet(WALLET_NAME_MAINNET, "", WALLET_LANG);
|
||||
std::string seed = wallet->seed();
|
||||
std::string address = wallet->address();
|
||||
wmgr->closeWallet(wallet);
|
||||
|
||||
// deleting wallet files
|
||||
Utils::deleteWallet(WALLET_NAME_MAINNET);
|
||||
// ..and recovering wallet from seed
|
||||
|
||||
wallet = wmgr->recoveryWallet(WALLET_NAME_MAINNET, seed);
|
||||
ASSERT_TRUE(wallet->status() == Bitmonero::Wallet::Status_Ok);
|
||||
ASSERT_TRUE(wallet->address() == address);
|
||||
std::unique_ptr<MyWalletListener> wallet_listener (new MyWalletListener(wallet));
|
||||
std::chrono::seconds wait_for = std::chrono::seconds(SECONDS_TO_REFRESH);
|
||||
std::unique_lock<std::mutex> lock (wallet_listener->mutex);
|
||||
wallet->initAsync(MAINNET_DAEMON_ADDRESS, 0);
|
||||
// wallet->init(MAINNET_DAEMON_ADDRESS, 0);
|
||||
std::cerr << "TEST: waiting on refresh lock...\n";
|
||||
|
||||
// here we wait for 120 seconds and test if wallet doesn't syncrnonize blockchain completely,
|
||||
// as it needs much more than 120 seconds for mainnet
|
||||
|
||||
wallet_listener->cv_refresh.wait_for(lock, wait_for);
|
||||
ASSERT_TRUE(wallet->status() == Bitmonero::Wallet::Status_Ok);
|
||||
ASSERT_FALSE(wallet_listener->refresh_triggered);
|
||||
ASSERT_TRUE(wallet->connected());
|
||||
ASSERT_FALSE(wallet->blockChainHeight() == wallet->daemonBlockChainHeight());
|
||||
std::cerr << "TEST: closing wallet...\n";
|
||||
wmgr->closeWallet(wallet);
|
||||
std::cerr << "TEST: wallet closed\n";
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
// we can override default values for "TESTNET_DAEMON_ADDRESS" and "WALLETS_ROOT_DIR"
|
||||
|
||||
const char * monero_daemon_addr = std::getenv("TESTNET_DAEMON_ADDRESS");
|
||||
if (monero_daemon_addr) {
|
||||
TESTNET_DAEMON_ADDRESS = monero_daemon_addr;
|
||||
const char * testnet_daemon_addr = std::getenv("TESTNET_DAEMON_ADDRESS");
|
||||
if (testnet_daemon_addr) {
|
||||
TESTNET_DAEMON_ADDRESS = testnet_daemon_addr;
|
||||
}
|
||||
|
||||
const char * mainnet_daemon_addr = std::getenv("MAINNET_DAEMON_ADDRESS");
|
||||
if (mainnet_daemon_addr) {
|
||||
MAINNET_DAEMON_ADDRESS = mainnet_daemon_addr;
|
||||
}
|
||||
|
||||
|
||||
|
||||
const char * wallets_root_dir = std::getenv("WALLETS_ROOT_DIR");
|
||||
if (wallets_root_dir) {
|
||||
WALLETS_ROOT_DIR = wallets_root_dir;
|
||||
|
|
Loading…
Reference in New Issue