2015-12-31 06:39:56 +00:00
|
|
|
// Copyright (c) 2014-2016, The Monero Project
|
2014-07-23 13:03:52 +00:00
|
|
|
//
|
|
|
|
// All rights reserved.
|
|
|
|
//
|
|
|
|
// Redistribution and use in source and binary forms, with or without modification, are
|
|
|
|
// permitted provided that the following conditions are met:
|
|
|
|
//
|
|
|
|
// 1. Redistributions of source code must retain the above copyright notice, this list of
|
|
|
|
// conditions and the following disclaimer.
|
|
|
|
//
|
|
|
|
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
|
|
|
// of conditions and the following disclaimer in the documentation and/or other
|
|
|
|
// materials provided with the distribution.
|
|
|
|
//
|
|
|
|
// 3. Neither the name of the copyright holder nor the names of its contributors may be
|
|
|
|
// used to endorse or promote products derived from this software without specific
|
|
|
|
// prior written permission.
|
|
|
|
//
|
|
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
|
|
|
|
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
|
|
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
|
|
|
|
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
|
|
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
|
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
|
|
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
|
|
|
|
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
//
|
|
|
|
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
|
2014-03-03 22:07:58 +00:00
|
|
|
|
2014-09-27 12:50:15 +00:00
|
|
|
/*!
|
|
|
|
* \file simplewallet.h
|
|
|
|
*
|
|
|
|
* \brief Header file that declares simple_wallet class.
|
|
|
|
*/
|
2014-03-03 22:07:58 +00:00
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include <memory>
|
|
|
|
|
2016-11-09 03:55:41 +00:00
|
|
|
#include <boost/optional/optional.hpp>
|
2014-03-03 22:07:58 +00:00
|
|
|
#include <boost/program_options/variables_map.hpp>
|
|
|
|
|
|
|
|
#include "cryptonote_core/account.h"
|
|
|
|
#include "cryptonote_core/cryptonote_basic_impl.h"
|
|
|
|
#include "wallet/wallet2.h"
|
|
|
|
#include "console_handler.h"
|
2016-11-09 03:55:41 +00:00
|
|
|
#include "wallet/password_container.h"
|
2014-06-04 22:59:47 +00:00
|
|
|
#include "crypto/crypto.h" // for definition of crypto::secret_key
|
2014-03-03 22:07:58 +00:00
|
|
|
|
2014-09-27 12:50:15 +00:00
|
|
|
/*!
|
|
|
|
* \namespace cryptonote
|
|
|
|
* \brief Holds cryptonote related classes and helpers.
|
|
|
|
*/
|
2014-03-03 22:07:58 +00:00
|
|
|
namespace cryptonote
|
|
|
|
{
|
2014-09-27 12:50:15 +00:00
|
|
|
/*!
|
|
|
|
* \brief Manages wallet operations. This is the most abstracted wallet class.
|
|
|
|
*/
|
2014-04-02 16:00:17 +00:00
|
|
|
class simple_wallet : public tools::i_wallet2_callback
|
2014-03-03 22:07:58 +00:00
|
|
|
{
|
2015-07-14 19:28:25 +00:00
|
|
|
public:
|
|
|
|
static const char *tr(const char *str) { return i18n_translate(str, "cryptonote::simple_wallet"); }
|
|
|
|
|
2014-03-03 22:07:58 +00:00
|
|
|
public:
|
|
|
|
typedef std::vector<std::string> command_type;
|
|
|
|
|
|
|
|
simple_wallet();
|
|
|
|
bool init(const boost::program_options::variables_map& vm);
|
|
|
|
bool deinit();
|
|
|
|
bool run();
|
2014-03-20 11:46:11 +00:00
|
|
|
void stop();
|
2015-11-29 13:02:01 +00:00
|
|
|
void interrupt();
|
2014-03-03 22:07:58 +00:00
|
|
|
|
|
|
|
//wallet *create_wallet();
|
|
|
|
bool process_command(const std::vector<std::string> &args);
|
|
|
|
std::string get_commands_str();
|
|
|
|
private:
|
2015-11-22 19:03:10 +00:00
|
|
|
bool handle_command_line(const boost::program_options::variables_map& vm);
|
2014-03-03 22:07:58 +00:00
|
|
|
|
|
|
|
bool run_console_handler();
|
|
|
|
|
2016-08-07 12:06:40 +00:00
|
|
|
void wallet_idle_thread();
|
2015-11-28 12:38:58 +00:00
|
|
|
|
2016-11-09 03:55:41 +00:00
|
|
|
bool new_wallet(const boost::program_options::variables_map& vm, const crypto::secret_key& recovery_key,
|
|
|
|
bool recover, bool two_random, const std::string &old_language);
|
|
|
|
bool new_wallet(const boost::program_options::variables_map& vm, const cryptonote::account_public_address& address,
|
|
|
|
const boost::optional<crypto::secret_key>& spendkey, const crypto::secret_key& viewkey);
|
|
|
|
bool open_wallet(const boost::program_options::variables_map& vm);
|
2014-03-03 22:07:58 +00:00
|
|
|
bool close_wallet();
|
|
|
|
|
2014-08-05 06:53:30 +00:00
|
|
|
bool viewkey(const std::vector<std::string> &args = std::vector<std::string>());
|
2015-05-20 00:08:37 +00:00
|
|
|
bool spendkey(const std::vector<std::string> &args = std::vector<std::string>());
|
2014-08-01 13:40:18 +00:00
|
|
|
bool seed(const std::vector<std::string> &args = std::vector<std::string>());
|
2014-12-06 14:58:33 +00:00
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief Sets seed language.
|
|
|
|
*
|
|
|
|
* interactive
|
|
|
|
* - prompts for password so wallet can be rewritten
|
|
|
|
* - calls get_mnemonic_language() which prompts for language
|
|
|
|
*
|
|
|
|
* \return success status
|
|
|
|
*/
|
|
|
|
bool seed_set_language(const std::vector<std::string> &args = std::vector<std::string>());
|
2015-07-18 21:03:35 +00:00
|
|
|
bool set_always_confirm_transfers(const std::vector<std::string> &args = std::vector<std::string>());
|
2015-11-22 12:26:27 +00:00
|
|
|
bool set_store_tx_info(const std::vector<std::string> &args = std::vector<std::string>());
|
2015-10-30 21:16:51 +00:00
|
|
|
bool set_default_mixin(const std::vector<std::string> &args = std::vector<std::string>());
|
2015-11-28 12:38:58 +00:00
|
|
|
bool set_auto_refresh(const std::vector<std::string> &args = std::vector<std::string>());
|
2015-12-05 21:44:25 +00:00
|
|
|
bool set_refresh_type(const std::vector<std::string> &args = std::vector<std::string>());
|
2016-10-01 16:03:53 +00:00
|
|
|
bool set_confirm_missing_payment_id(const std::vector<std::string> &args = std::vector<std::string>());
|
2014-03-20 11:46:11 +00:00
|
|
|
bool help(const std::vector<std::string> &args = std::vector<std::string>());
|
2014-03-03 22:07:58 +00:00
|
|
|
bool start_mining(const std::vector<std::string> &args);
|
|
|
|
bool stop_mining(const std::vector<std::string> &args);
|
2014-05-15 22:21:43 +00:00
|
|
|
bool save_bc(const std::vector<std::string>& args);
|
2014-03-03 22:07:58 +00:00
|
|
|
bool refresh(const std::vector<std::string> &args);
|
2016-04-20 23:11:11 +00:00
|
|
|
bool show_balance_unlocked();
|
2014-03-20 11:46:11 +00:00
|
|
|
bool show_balance(const std::vector<std::string> &args = std::vector<std::string>());
|
2014-03-03 22:07:58 +00:00
|
|
|
bool show_incoming_transfers(const std::vector<std::string> &args);
|
2014-05-03 16:19:43 +00:00
|
|
|
bool show_payments(const std::vector<std::string> &args);
|
2014-03-03 22:07:58 +00:00
|
|
|
bool show_blockchain_height(const std::vector<std::string> &args);
|
2016-06-15 22:37:13 +00:00
|
|
|
bool transfer_main(int transfer_type, const std::vector<std::string> &args);
|
2014-03-03 22:07:58 +00:00
|
|
|
bool transfer(const std::vector<std::string> &args);
|
2015-07-19 22:47:13 +00:00
|
|
|
bool transfer_new(const std::vector<std::string> &args);
|
2016-09-28 13:20:37 +00:00
|
|
|
bool locked_transfer(const std::vector<std::string> &args);
|
2016-04-19 20:20:27 +00:00
|
|
|
bool sweep_all(const std::vector<std::string> &args);
|
2016-03-26 21:15:47 +00:00
|
|
|
bool sweep_unmixable(const std::vector<std::string> &args);
|
2016-09-26 22:11:10 +00:00
|
|
|
bool sign_transfer(const std::vector<std::string> &args);
|
|
|
|
bool submit_transfer(const std::vector<std::string> &args);
|
2014-06-16 00:36:44 +00:00
|
|
|
std::vector<std::vector<cryptonote::tx_destination_entry>> split_amounts(
|
|
|
|
std::vector<cryptonote::tx_destination_entry> dsts, size_t num_splits
|
2014-06-15 21:20:16 +00:00
|
|
|
);
|
2014-04-02 16:00:17 +00:00
|
|
|
bool print_address(const std::vector<std::string> &args = std::vector<std::string>());
|
2015-06-11 08:44:13 +00:00
|
|
|
bool print_integrated_address(const std::vector<std::string> &args = std::vector<std::string>());
|
2014-03-03 22:07:58 +00:00
|
|
|
bool save(const std::vector<std::string> &args);
|
2015-05-31 14:34:55 +00:00
|
|
|
bool save_watch_only(const std::vector<std::string> &args);
|
2014-12-06 14:58:33 +00:00
|
|
|
bool set_variable(const std::vector<std::string> &args);
|
2015-08-11 14:14:44 +00:00
|
|
|
bool rescan_spent(const std::vector<std::string> &args);
|
2014-03-03 22:07:58 +00:00
|
|
|
bool set_log(const std::vector<std::string> &args);
|
2015-08-19 19:59:44 +00:00
|
|
|
bool get_tx_key(const std::vector<std::string> &args);
|
2015-10-11 23:13:05 +00:00
|
|
|
bool check_tx_key(const std::vector<std::string> &args);
|
2015-11-15 21:59:40 +00:00
|
|
|
bool show_transfers(const std::vector<std::string> &args);
|
2015-12-30 12:58:15 +00:00
|
|
|
bool rescan_blockchain(const std::vector<std::string> &args);
|
|
|
|
bool refresh_main(uint64_t start_height, bool reset = false);
|
2016-04-20 17:19:42 +00:00
|
|
|
bool set_tx_note(const std::vector<std::string> &args);
|
|
|
|
bool get_tx_note(const std::vector<std::string> &args);
|
2016-06-20 18:11:10 +00:00
|
|
|
bool status(const std::vector<std::string> &args);
|
2016-09-16 10:50:52 +00:00
|
|
|
bool set_default_priority(const std::vector<std::string> &args);
|
2016-04-23 20:46:48 +00:00
|
|
|
bool sign(const std::vector<std::string> &args);
|
|
|
|
bool verify(const std::vector<std::string> &args);
|
2016-07-15 11:11:55 +00:00
|
|
|
bool export_key_images(const std::vector<std::string> &args);
|
|
|
|
bool import_key_images(const std::vector<std::string> &args);
|
2016-10-30 19:37:09 +00:00
|
|
|
bool export_outputs(const std::vector<std::string> &args);
|
|
|
|
bool import_outputs(const std::vector<std::string> &args);
|
2014-03-03 22:07:58 +00:00
|
|
|
|
2014-03-20 11:46:11 +00:00
|
|
|
uint64_t get_daemon_blockchain_height(std::string& err);
|
2016-07-10 15:49:40 +00:00
|
|
|
bool try_connect_to_daemon(bool silent = false);
|
2014-05-03 16:19:43 +00:00
|
|
|
bool ask_wallet_create_if_needed();
|
2016-10-30 10:49:22 +00:00
|
|
|
bool accept_loaded_tx(const std::function<size_t()> get_num_txes, const std::function<const tools::wallet2::tx_construction_data&(size_t)> &get_tx);
|
2016-09-26 22:11:10 +00:00
|
|
|
bool accept_loaded_tx(const tools::wallet2::unsigned_tx_set &txs);
|
2016-10-30 10:49:22 +00:00
|
|
|
bool accept_loaded_tx(const tools::wallet2::signed_tx_set &txs);
|
2016-04-19 20:20:27 +00:00
|
|
|
bool get_address_from_str(const std::string &str, cryptonote::account_public_address &address, bool &has_payment_id, crypto::hash8 &payment_id);
|
2015-11-29 13:02:01 +00:00
|
|
|
|
2014-10-19 09:09:45 +00:00
|
|
|
/*!
|
|
|
|
* \brief Prints the seed with a nice message
|
|
|
|
* \param seed seed to print
|
|
|
|
*/
|
|
|
|
void print_seed(std::string seed);
|
2014-09-27 12:50:15 +00:00
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief Gets the word seed language from the user.
|
|
|
|
*
|
|
|
|
* User is asked to choose from a list of supported languages.
|
|
|
|
*
|
|
|
|
* \return The chosen language.
|
|
|
|
*/
|
2014-09-25 12:34:30 +00:00
|
|
|
std::string get_mnemonic_language();
|
2014-03-03 22:07:58 +00:00
|
|
|
|
2014-04-02 16:00:17 +00:00
|
|
|
//----------------- i_wallet2_callback ---------------------
|
|
|
|
virtual void on_new_block(uint64_t height, const cryptonote::block& block);
|
2016-06-15 22:37:13 +00:00
|
|
|
virtual void on_money_received(uint64_t height, const cryptonote::transaction& tx, uint64_t amount);
|
|
|
|
virtual void on_money_spent(uint64_t height, const cryptonote::transaction& in_tx, uint64_t amount, const cryptonote::transaction& spend_tx);
|
2014-05-03 16:19:43 +00:00
|
|
|
virtual void on_skip_transaction(uint64_t height, const cryptonote::transaction& tx);
|
2014-04-02 16:00:17 +00:00
|
|
|
//----------------------------------------------------------
|
|
|
|
|
|
|
|
friend class refresh_progress_reporter_t;
|
|
|
|
|
|
|
|
class refresh_progress_reporter_t
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
refresh_progress_reporter_t(cryptonote::simple_wallet& simple_wallet)
|
|
|
|
: m_simple_wallet(simple_wallet)
|
|
|
|
, m_blockchain_height(0)
|
|
|
|
, m_blockchain_height_update_time()
|
|
|
|
, m_print_time()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void update(uint64_t height, bool force = false)
|
|
|
|
{
|
|
|
|
auto current_time = std::chrono::system_clock::now();
|
2016-01-29 15:09:17 +00:00
|
|
|
const auto node_update_threshold = std::chrono::seconds(DIFFICULTY_TARGET_V1 / 2); // use min of V1/V2
|
|
|
|
if (node_update_threshold < current_time - m_blockchain_height_update_time || m_blockchain_height <= height)
|
2014-04-02 16:00:17 +00:00
|
|
|
{
|
|
|
|
update_blockchain_height();
|
|
|
|
m_blockchain_height = (std::max)(m_blockchain_height, height);
|
|
|
|
}
|
|
|
|
|
2015-11-21 11:52:35 +00:00
|
|
|
if (std::chrono::milliseconds(20) < current_time - m_print_time || force)
|
2014-04-02 16:00:17 +00:00
|
|
|
{
|
2015-11-21 11:52:35 +00:00
|
|
|
std::cout << QT_TRANSLATE_NOOP("cryptonote::simple_wallet", "Height ") << height << " / " << m_blockchain_height << '\r' << std::flush;
|
2014-04-02 16:00:17 +00:00
|
|
|
m_print_time = current_time;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
void update_blockchain_height()
|
|
|
|
{
|
|
|
|
std::string err;
|
|
|
|
uint64_t blockchain_height = m_simple_wallet.get_daemon_blockchain_height(err);
|
|
|
|
if (err.empty())
|
|
|
|
{
|
|
|
|
m_blockchain_height = blockchain_height;
|
|
|
|
m_blockchain_height_update_time = std::chrono::system_clock::now();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
LOG_ERROR("Failed to get current blockchain height: " << err);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
cryptonote::simple_wallet& m_simple_wallet;
|
|
|
|
uint64_t m_blockchain_height;
|
|
|
|
std::chrono::system_clock::time_point m_blockchain_height_update_time;
|
|
|
|
std::chrono::system_clock::time_point m_print_time;
|
|
|
|
};
|
|
|
|
|
|
|
|
private:
|
2014-03-03 22:07:58 +00:00
|
|
|
std::string m_wallet_file;
|
|
|
|
std::string m_generate_new;
|
2015-06-20 11:31:53 +00:00
|
|
|
std::string m_generate_from_view_key;
|
2016-02-22 22:10:55 +00:00
|
|
|
std::string m_generate_from_keys;
|
wallet: add a --generate-from-json flag
It takes a filename containing JSON data to generate a wallet.
The following fields are valid:
version: integer, should be 1
filename: string, path/filename for the newly created wallet
scan_from_height: 64 bit unsigned integer, optional
password: string, optional
viewkey: string, hex representation
spendkey: string, hex representation
seed: string, optional, list of words separated by spaces
Either seed or private keys should be given. If using private
keys, the spend key may be omitted (the wallet will not be
able to spend, but will see incoming transactions).
If scan_from_height is given, blocks below this height will not
be checked for transactions as an optimization.
2016-03-25 00:48:11 +00:00
|
|
|
std::string m_generate_from_json;
|
2014-03-03 22:07:58 +00:00
|
|
|
std::string m_import_path;
|
|
|
|
|
2014-06-04 22:59:47 +00:00
|
|
|
std::string m_electrum_seed; // electrum-style seed parameter
|
|
|
|
|
|
|
|
crypto::secret_key m_recovery_key; // recovery key (used as random for wallet gen)
|
2014-06-08 22:59:02 +00:00
|
|
|
bool m_restore_deterministic_wallet; // recover flag
|
2014-06-09 00:04:32 +00:00
|
|
|
bool m_non_deterministic; // old 2-random generation
|
2015-10-11 18:45:59 +00:00
|
|
|
bool m_trusted_daemon;
|
2016-07-10 15:49:40 +00:00
|
|
|
bool m_allow_mismatched_daemon_version;
|
2016-08-09 23:54:20 +00:00
|
|
|
bool m_restoring; // are we restoring, by whatever method?
|
2016-04-15 18:10:20 +00:00
|
|
|
uint64_t m_restore_height; // optional
|
2014-06-04 22:59:47 +00:00
|
|
|
|
2014-03-03 22:07:58 +00:00
|
|
|
epee::console_handlers_binder m_cmd_binder;
|
|
|
|
|
2014-03-20 11:46:11 +00:00
|
|
|
std::unique_ptr<tools::wallet2> m_wallet;
|
2014-05-25 17:06:40 +00:00
|
|
|
epee::net_utils::http::http_simple_client m_http_client;
|
2014-04-02 16:00:17 +00:00
|
|
|
refresh_progress_reporter_t m_refresh_progress_reporter;
|
2015-11-28 12:38:58 +00:00
|
|
|
|
2016-08-07 12:06:40 +00:00
|
|
|
std::atomic<bool> m_idle_run;
|
|
|
|
boost::thread m_idle_thread;
|
|
|
|
boost::mutex m_idle_mutex;
|
|
|
|
boost::condition_variable m_idle_cond;
|
|
|
|
|
|
|
|
std::atomic<bool> m_auto_refresh_enabled;
|
2015-11-28 12:38:58 +00:00
|
|
|
bool m_auto_refresh_refreshing;
|
2015-11-29 13:02:01 +00:00
|
|
|
std::atomic<bool> m_in_manual_refresh;
|
2014-03-03 22:07:58 +00:00
|
|
|
};
|
|
|
|
}
|