2017-02-21 19:38:18 +02:00
|
|
|
// Copyright (c) 2014-2017, The Monero Project
|
2014-07-23 16:03:52 +03: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-04 00:07:58 +02:00
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
|
|
#include <memory>
|
2016-11-09 05:55:41 +02:00
|
|
|
|
|
|
|
|
#include <boost/program_options/options_description.hpp>
|
|
|
|
|
#include <boost/program_options/variables_map.hpp>
|
2014-03-04 00:07:58 +02:00
|
|
|
#include <boost/serialization/list.hpp>
|
|
|
|
|
#include <boost/serialization/vector.hpp>
|
|
|
|
|
#include <atomic>
|
2014-04-02 19:00:17 +03:00
|
|
|
|
2014-03-04 00:07:58 +02:00
|
|
|
#include "include_base_utils.h"
|
2017-01-26 17:07:23 +02:00
|
|
|
#include "cryptonote_basic/account.h"
|
|
|
|
|
#include "cryptonote_basic/account_boost_serialization.h"
|
|
|
|
|
#include "cryptonote_basic/cryptonote_basic_impl.h"
|
2014-03-04 00:07:58 +02:00
|
|
|
#include "net/http_client.h"
|
|
|
|
|
#include "storages/http_abstract_invoke.h"
|
|
|
|
|
#include "rpc/core_rpc_server_commands_defs.h"
|
2017-01-26 17:07:23 +02:00
|
|
|
#include "cryptonote_basic/cryptonote_format_utils.h"
|
|
|
|
|
#include "cryptonote_core/cryptonote_tx_utils.h"
|
2014-03-04 00:07:58 +02:00
|
|
|
#include "common/unordered_containers_boost_serialization.h"
|
|
|
|
|
#include "crypto/chacha8.h"
|
|
|
|
|
#include "crypto/hash.h"
|
2016-06-16 01:37:13 +03:00
|
|
|
#include "ringct/rctTypes.h"
|
|
|
|
|
#include "ringct/rctOps.h"
|
2014-03-04 00:07:58 +02:00
|
|
|
|
2014-04-02 19:00:17 +03:00
|
|
|
#include "wallet_errors.h"
|
2017-02-06 00:48:03 +02:00
|
|
|
#include "common/password.h"
|
2017-01-07 21:23:57 +02:00
|
|
|
#include "node_rpc_proxy.h"
|
2014-04-02 19:00:17 +03:00
|
|
|
|
2014-06-17 04:52:06 +03:00
|
|
|
#include <iostream>
|
Change logging to easylogging++
This replaces the epee and data_loggers logging systems with
a single one, and also adds filename:line and explicit severity
levels. Categories may be defined, and logging severity set
by category (or set of categories). epee style 0-4 log level
maps to a sensible severity configuration. Log files now also
rotate when reaching 100 MB.
To select which logs to output, use the MONERO_LOGS environment
variable, with a comma separated list of categories (globs are
supported), with their requested severity level after a colon.
If a log matches more than one such setting, the last one in
the configuration string applies. A few examples:
This one is (mostly) silent, only outputting fatal errors:
MONERO_LOGS=*:FATAL
This one is very verbose:
MONERO_LOGS=*:TRACE
This one is totally silent (logwise):
MONERO_LOGS=""
This one outputs all errors and warnings, except for the
"verify" category, which prints just fatal errors (the verify
category is used for logs about incoming transactions and
blocks, and it is expected that some/many will fail to verify,
hence we don't want the spam):
MONERO_LOGS=*:WARNING,verify:FATAL
Log levels are, in decreasing order of priority:
FATAL, ERROR, WARNING, INFO, DEBUG, TRACE
Subcategories may be added using prefixes and globs. This
example will output net.p2p logs at the TRACE level, but all
other net* logs only at INFO:
MONERO_LOGS=*:ERROR,net*:INFO,net.p2p:TRACE
Logs which are intended for the user (which Monero was using
a lot through epee, but really isn't a nice way to go things)
should use the "global" category. There are a few helper macros
for using this category, eg: MGINFO("this shows up by default")
or MGINFO_RED("this is red"), to try to keep a similar look
and feel for now.
Existing epee log macros still exist, and map to the new log
levels, but since they're used as a "user facing" UI element
as much as a logging system, they often don't map well to log
severities (ie, a log level 0 log may be an error, or may be
something we want the user to see, such as an important info).
In those cases, I tried to use the new macros. In other cases,
I left the existing macros in. When modifying logs, it is
probably best to switch to the new macros with explicit levels.
The --log-level options and set_log commands now also accept
category settings, in addition to the epee style log levels.
2017-01-01 18:34:23 +02:00
|
|
|
|
|
|
|
|
#undef MONERO_DEFAULT_LOG_CATEGORY
|
|
|
|
|
#define MONERO_DEFAULT_LOG_CATEGORY "wallet.wallet2"
|
|
|
|
|
|
2017-01-02 03:43:20 +02:00
|
|
|
class Serialization_portability_wallet_Test;
|
|
|
|
|
|
2014-03-04 00:07:58 +02:00
|
|
|
namespace tools
|
|
|
|
|
{
|
2014-04-02 19:00:17 +03:00
|
|
|
class i_wallet2_callback
|
2014-03-20 13:46:11 +02:00
|
|
|
{
|
2014-04-02 19:00:17 +03:00
|
|
|
public:
|
|
|
|
|
virtual void on_new_block(uint64_t height, const cryptonote::block& block) {}
|
2017-02-27 22:26:17 +02:00
|
|
|
virtual void on_money_received(uint64_t height, const crypto::hash &txid, const cryptonote::transaction& tx, uint64_t amount) {}
|
|
|
|
|
virtual void on_unconfirmed_money_received(uint64_t height, const crypto::hash &txid, const cryptonote::transaction& tx, uint64_t amount) {}
|
|
|
|
|
virtual void on_money_spent(uint64_t height, const crypto::hash &txid, const cryptonote::transaction& in_tx, uint64_t amount, const cryptonote::transaction& spend_tx) {}
|
|
|
|
|
virtual void on_skip_transaction(uint64_t height, const crypto::hash &txid, const cryptonote::transaction& tx) {}
|
2016-05-13 12:59:29 +03:00
|
|
|
virtual ~i_wallet2_callback() {}
|
2014-04-02 19:00:17 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct tx_dust_policy
|
|
|
|
|
{
|
|
|
|
|
uint64_t dust_threshold;
|
|
|
|
|
bool add_to_fee;
|
|
|
|
|
cryptonote::account_public_address addr_for_dust;
|
|
|
|
|
|
|
|
|
|
tx_dust_policy(uint64_t a_dust_threshold = 0, bool an_add_to_fee = true, cryptonote::account_public_address an_addr_for_dust = cryptonote::account_public_address())
|
|
|
|
|
: dust_threshold(a_dust_threshold)
|
|
|
|
|
, add_to_fee(an_add_to_fee)
|
|
|
|
|
, addr_for_dust(an_addr_for_dust)
|
2014-03-20 13:46:11 +02:00
|
|
|
{
|
|
|
|
|
}
|
2014-04-02 19:00:17 +03:00
|
|
|
};
|
2014-03-20 13:46:11 +02:00
|
|
|
|
2014-03-04 00:07:58 +02:00
|
|
|
class wallet2
|
|
|
|
|
{
|
2017-01-02 03:43:20 +02:00
|
|
|
friend class ::Serialization_portability_wallet_Test;
|
2014-03-04 00:07:58 +02:00
|
|
|
public:
|
2017-01-25 07:16:05 +02:00
|
|
|
static constexpr const std::chrono::seconds rpc_timeout = std::chrono::minutes(3) + std::chrono::seconds(30);
|
|
|
|
|
|
2015-11-22 21:03:10 +02:00
|
|
|
enum RefreshType {
|
|
|
|
|
RefreshFull,
|
|
|
|
|
RefreshOptimizeCoinbase,
|
|
|
|
|
RefreshNoCoinbase,
|
2015-12-05 23:44:25 +02:00
|
|
|
RefreshDefault = RefreshOptimizeCoinbase,
|
2015-11-22 21:03:10 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
private:
|
2017-08-26 18:23:54 +03:00
|
|
|
wallet2(const wallet2&) : m_run(true), m_callback(0), m_testnet(false), m_always_confirm_transfers(true), m_print_ring_members(false), m_store_tx_info(true), m_default_mixin(0), m_default_priority(0), m_refresh_type(RefreshOptimizeCoinbase), m_auto_refresh(true), m_refresh_from_block_height(0), m_confirm_missing_payment_id(true), m_ask_password(true), m_min_output_count(0), m_min_output_value(0), m_merge_destinations(false), m_confirm_backlog(true), m_is_initialized(false),m_node_rpc_proxy(m_http_client, m_daemon_rpc_mutex) {}
|
2015-11-22 21:03:10 +02:00
|
|
|
|
|
|
|
|
public:
|
2017-01-25 07:16:05 +02:00
|
|
|
static const char* tr(const char* str);
|
2016-11-09 05:55:41 +02:00
|
|
|
|
|
|
|
|
static bool has_testnet_option(const boost::program_options::variables_map& vm);
|
|
|
|
|
static void init_options(boost::program_options::options_description& desc_params);
|
|
|
|
|
|
2016-12-18 01:07:15 +02:00
|
|
|
//! \return Password retrieved from prompt. Logs error on failure.
|
2017-03-05 16:52:38 +02:00
|
|
|
static boost::optional<password_container> password_prompt(const bool new_password);
|
2016-12-18 01:07:15 +02:00
|
|
|
|
2016-11-09 05:55:41 +02:00
|
|
|
//! Uses stdin and stdout. Returns a wallet2 if no errors.
|
|
|
|
|
static std::unique_ptr<wallet2> make_from_json(const boost::program_options::variables_map& vm, const std::string& json_file);
|
|
|
|
|
|
|
|
|
|
//! Uses stdin and stdout. Returns a wallet2 and password for `wallet_file` if no errors.
|
|
|
|
|
static std::pair<std::unique_ptr<wallet2>, password_container>
|
|
|
|
|
make_from_file(const boost::program_options::variables_map& vm, const std::string& wallet_file);
|
|
|
|
|
|
|
|
|
|
//! Uses stdin and stdout. Returns a wallet2 and password for wallet with no file if no errors.
|
|
|
|
|
static std::pair<std::unique_ptr<wallet2>, password_container> make_new(const boost::program_options::variables_map& vm);
|
|
|
|
|
|
2017-04-03 01:09:36 +03:00
|
|
|
//! Just parses variables.
|
|
|
|
|
static std::unique_ptr<wallet2> make_dummy(const boost::program_options::variables_map& vm);
|
|
|
|
|
|
2017-08-02 01:41:05 +03:00
|
|
|
static bool verify_password(const std::string& keys_file_name, const std::string& password, bool watch_only);
|
|
|
|
|
|
2017-08-26 18:23:54 +03:00
|
|
|
wallet2(bool testnet = false, bool restricted = false) : m_run(true), m_callback(0), m_testnet(testnet), m_always_confirm_transfers(true), m_print_ring_members(false), m_store_tx_info(true), m_default_mixin(0), m_default_priority(0), m_refresh_type(RefreshOptimizeCoinbase), m_auto_refresh(true), m_refresh_from_block_height(0), m_confirm_missing_payment_id(true), m_ask_password(true), m_min_output_count(0), m_min_output_value(0), m_merge_destinations(false), m_confirm_backlog(true), m_is_initialized(false), m_restricted(restricted), is_old_file_format(false), m_node_rpc_proxy(m_http_client, m_daemon_rpc_mutex) {}
|
wallet: try to save large outputs when using an unneeded second input
When a single input is enough to satisfy a transfer, the code would
previously try to add a second input, to match the "canonical" makeup
of a transaction with two inputs and two outputs. This would cause
wallets to slowly merge outputs till all the monero ends up in a
single output, which causes trouble when making two transactions
one after the other, since change is locked for 10 blocks, and an
increasing portion of the remaining balance would end up locked on
each transaction.
There are two new settings (min-output-count and min-output-value)
which can control when to stop adding such unneeded second outputs.
The idea is that small "dust" outputs will still get added, but
larger ones will not.
Enable with, eg:
set min-output-count 10
set min-output-value 30
to avoid using an unneeded second output of 30 monero or more, if
there would be less than 10 such outputs left.
This does not invalidate any other reason why such outputs would
be used (ie, when they're really needed to satisfy a transfer, or
when randomly picked in the normal course of selection). This may
be improved in the future.
2017-03-24 22:58:02 +02:00
|
|
|
|
2014-03-04 00:07:58 +02:00
|
|
|
struct transfer_details
|
|
|
|
|
{
|
|
|
|
|
uint64_t m_block_height;
|
2016-08-06 21:19:25 +03:00
|
|
|
cryptonote::transaction_prefix m_tx;
|
|
|
|
|
crypto::hash m_txid;
|
2014-03-04 00:07:58 +02:00
|
|
|
size_t m_internal_output_index;
|
|
|
|
|
uint64_t m_global_output_index;
|
|
|
|
|
bool m_spent;
|
2016-06-17 01:58:54 +03:00
|
|
|
uint64_t m_spent_height;
|
2014-03-04 00:07:58 +02:00
|
|
|
crypto::key_image m_key_image; //TODO: key_image stored twice :(
|
2016-06-16 01:37:13 +03:00
|
|
|
rct::key m_mask;
|
|
|
|
|
uint64_t m_amount;
|
2016-08-12 20:45:07 +03:00
|
|
|
bool m_rct;
|
2016-11-07 20:50:05 +02:00
|
|
|
bool m_key_image_known;
|
2016-12-09 20:21:21 +02:00
|
|
|
size_t m_pk_index;
|
2014-03-04 00:07:58 +02:00
|
|
|
|
2016-08-12 20:45:07 +03:00
|
|
|
bool is_rct() const { return m_rct; }
|
2016-06-16 01:37:13 +03:00
|
|
|
uint64_t amount() const { return m_amount; }
|
2016-11-07 20:50:05 +02:00
|
|
|
const crypto::public_key &get_public_key() const { return boost::get<const cryptonote::txout_to_key>(m_tx.vout[m_internal_output_index].target).key; }
|
2016-11-15 23:22:04 +02:00
|
|
|
|
|
|
|
|
BEGIN_SERIALIZE_OBJECT()
|
|
|
|
|
FIELD(m_block_height)
|
|
|
|
|
FIELD(m_tx)
|
|
|
|
|
FIELD(m_txid)
|
|
|
|
|
FIELD(m_internal_output_index)
|
|
|
|
|
FIELD(m_global_output_index)
|
|
|
|
|
FIELD(m_spent)
|
|
|
|
|
FIELD(m_spent_height)
|
|
|
|
|
FIELD(m_key_image)
|
|
|
|
|
FIELD(m_mask)
|
|
|
|
|
FIELD(m_amount)
|
|
|
|
|
FIELD(m_rct)
|
|
|
|
|
FIELD(m_key_image_known)
|
2016-12-09 20:21:21 +02:00
|
|
|
FIELD(m_pk_index)
|
2016-11-15 23:22:04 +02:00
|
|
|
END_SERIALIZE()
|
2014-03-04 00:07:58 +02:00
|
|
|
};
|
|
|
|
|
|
2014-05-03 19:19:43 +03:00
|
|
|
struct payment_details
|
|
|
|
|
{
|
|
|
|
|
crypto::hash m_tx_hash;
|
|
|
|
|
uint64_t m_amount;
|
|
|
|
|
uint64_t m_block_height;
|
|
|
|
|
uint64_t m_unlock_time;
|
2016-04-19 23:18:43 +03:00
|
|
|
uint64_t m_timestamp;
|
2014-05-03 19:19:43 +03:00
|
|
|
};
|
|
|
|
|
|
2014-04-02 19:00:17 +03:00
|
|
|
struct unconfirmed_transfer_details
|
2014-03-04 00:07:58 +02:00
|
|
|
{
|
2016-08-06 21:19:25 +03:00
|
|
|
cryptonote::transaction_prefix m_tx;
|
2016-06-16 01:37:13 +03:00
|
|
|
uint64_t m_amount_in;
|
|
|
|
|
uint64_t m_amount_out;
|
2014-04-02 19:00:17 +03:00
|
|
|
uint64_t m_change;
|
2014-05-03 19:19:43 +03:00
|
|
|
time_t m_sent_time;
|
2015-11-22 14:13:59 +02:00
|
|
|
std::vector<cryptonote::tx_destination_entry> m_dests;
|
|
|
|
|
crypto::hash m_payment_id;
|
2016-01-29 21:44:48 +02:00
|
|
|
enum { pending, pending_not_in_pool, failed } m_state;
|
2016-04-19 23:18:43 +03:00
|
|
|
uint64_t m_timestamp;
|
2014-03-04 00:07:58 +02:00
|
|
|
};
|
|
|
|
|
|
2015-11-15 23:59:40 +02:00
|
|
|
struct confirmed_transfer_details
|
|
|
|
|
{
|
|
|
|
|
uint64_t m_amount_in;
|
|
|
|
|
uint64_t m_amount_out;
|
|
|
|
|
uint64_t m_change;
|
|
|
|
|
uint64_t m_block_height;
|
2015-11-22 14:13:59 +02:00
|
|
|
std::vector<cryptonote::tx_destination_entry> m_dests;
|
|
|
|
|
crypto::hash m_payment_id;
|
2016-04-19 23:18:43 +03:00
|
|
|
uint64_t m_timestamp;
|
2017-07-25 18:28:48 +03:00
|
|
|
uint64_t m_unlock_time;
|
2015-11-22 14:13:59 +02:00
|
|
|
|
2017-07-25 18:28:48 +03:00
|
|
|
confirmed_transfer_details(): m_amount_in(0), m_amount_out(0), m_change((uint64_t)-1), m_block_height(0), m_payment_id(cryptonote::null_hash), m_timestamp(0), m_unlock_time(0) {}
|
2015-11-15 23:59:40 +02:00
|
|
|
confirmed_transfer_details(const unconfirmed_transfer_details &utd, uint64_t height):
|
2017-07-25 18:28:48 +03:00
|
|
|
m_amount_in(utd.m_amount_in), m_amount_out(utd.m_amount_out), m_change(utd.m_change), m_block_height(height), m_dests(utd.m_dests), m_payment_id(utd.m_payment_id), m_timestamp(utd.m_timestamp), m_unlock_time(utd.m_tx.unlock_time) {}
|
2015-11-15 23:59:40 +02:00
|
|
|
};
|
|
|
|
|
|
2016-09-27 01:11:10 +03:00
|
|
|
struct tx_construction_data
|
|
|
|
|
{
|
|
|
|
|
std::vector<cryptonote::tx_source_entry> sources;
|
|
|
|
|
cryptonote::tx_destination_entry change_dts;
|
2016-11-23 22:10:34 +02:00
|
|
|
std::vector<cryptonote::tx_destination_entry> splitted_dsts; // split, includes change
|
2016-10-25 23:19:47 +03:00
|
|
|
std::list<size_t> selected_transfers;
|
2016-09-27 01:11:10 +03:00
|
|
|
std::vector<uint8_t> extra;
|
|
|
|
|
uint64_t unlock_time;
|
|
|
|
|
bool use_rct;
|
2016-11-23 22:10:34 +02:00
|
|
|
std::vector<cryptonote::tx_destination_entry> dests; // original setup, does not include change
|
2016-09-27 01:11:10 +03:00
|
|
|
};
|
|
|
|
|
|
2014-04-02 19:00:17 +03:00
|
|
|
typedef std::vector<transfer_details> transfer_container;
|
2014-05-03 19:19:43 +03:00
|
|
|
typedef std::unordered_multimap<crypto::hash, payment_details> payment_container;
|
2014-04-02 19:00:17 +03:00
|
|
|
|
2016-11-23 22:10:34 +02:00
|
|
|
// The convention for destinations is:
|
|
|
|
|
// dests does not include change
|
|
|
|
|
// splitted_dsts (in construction_data) does
|
2014-06-16 03:36:44 +03:00
|
|
|
struct pending_tx
|
|
|
|
|
{
|
|
|
|
|
cryptonote::transaction tx;
|
|
|
|
|
uint64_t dust, fee;
|
2016-04-18 11:20:31 +03:00
|
|
|
bool dust_added_to_fee;
|
2014-06-16 03:36:44 +03:00
|
|
|
cryptonote::tx_destination_entry change_dts;
|
2016-09-27 01:11:10 +03:00
|
|
|
std::list<size_t> selected_transfers;
|
2014-06-16 03:36:44 +03:00
|
|
|
std::string key_images;
|
2015-08-19 22:59:44 +03:00
|
|
|
crypto::secret_key tx_key;
|
2015-11-22 14:13:59 +02:00
|
|
|
std::vector<cryptonote::tx_destination_entry> dests;
|
2016-09-27 01:11:10 +03:00
|
|
|
|
|
|
|
|
tx_construction_data construction_data;
|
|
|
|
|
};
|
|
|
|
|
|
2017-01-08 14:17:09 +02:00
|
|
|
// The term "Unsigned tx" is not really a tx since it's not signed yet.
|
|
|
|
|
// It doesnt have tx hash, key and the integrated address is not separated into addr + payment id.
|
2016-09-27 01:11:10 +03:00
|
|
|
struct unsigned_tx_set
|
|
|
|
|
{
|
|
|
|
|
std::vector<tx_construction_data> txes;
|
2016-11-15 23:22:04 +02:00
|
|
|
wallet2::transfer_container transfers;
|
2016-09-27 01:11:10 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct signed_tx_set
|
|
|
|
|
{
|
|
|
|
|
std::vector<pending_tx> ptx;
|
2016-11-15 23:22:04 +02:00
|
|
|
std::vector<crypto::key_image> key_images;
|
2014-06-16 03:36:44 +03:00
|
|
|
};
|
|
|
|
|
|
2014-03-04 00:07:58 +02:00
|
|
|
struct keys_file_data
|
|
|
|
|
{
|
|
|
|
|
crypto::chacha8_iv iv;
|
|
|
|
|
std::string account_data;
|
|
|
|
|
|
|
|
|
|
BEGIN_SERIALIZE_OBJECT()
|
|
|
|
|
FIELD(iv)
|
|
|
|
|
FIELD(account_data)
|
|
|
|
|
END_SERIALIZE()
|
|
|
|
|
};
|
|
|
|
|
|
2015-08-22 16:21:32 +03:00
|
|
|
struct cache_file_data
|
|
|
|
|
{
|
|
|
|
|
crypto::chacha8_iv iv;
|
|
|
|
|
std::string cache_data;
|
|
|
|
|
|
|
|
|
|
BEGIN_SERIALIZE_OBJECT()
|
|
|
|
|
FIELD(iv)
|
|
|
|
|
FIELD(cache_data)
|
|
|
|
|
END_SERIALIZE()
|
|
|
|
|
};
|
2016-12-12 01:42:46 +02:00
|
|
|
|
|
|
|
|
// GUI Address book
|
|
|
|
|
struct address_book_row
|
|
|
|
|
{
|
|
|
|
|
cryptonote::account_public_address m_address;
|
|
|
|
|
crypto::hash m_payment_id;
|
2016-12-12 22:39:29 +02:00
|
|
|
std::string m_description;
|
2016-12-12 01:42:46 +02:00
|
|
|
};
|
2015-08-22 16:21:32 +03:00
|
|
|
|
2017-01-07 18:06:07 +02:00
|
|
|
typedef std::tuple<uint64_t, crypto::public_key, rct::key> get_outs_entry;
|
|
|
|
|
|
2014-10-18 22:38:21 +03:00
|
|
|
/*!
|
|
|
|
|
* \brief Generates a wallet or restores one.
|
|
|
|
|
* \param wallet_ Name of wallet file
|
|
|
|
|
* \param password Password of wallet file
|
|
|
|
|
* \param recovery_param If it is a restore, the recovery key
|
|
|
|
|
* \param recover Whether it is a restore
|
|
|
|
|
* \param two_random Whether it is a non-deterministic wallet
|
|
|
|
|
* \return The secret key of the generated wallet
|
|
|
|
|
*/
|
2014-10-18 22:30:18 +03:00
|
|
|
crypto::secret_key generate(const std::string& wallet, const std::string& password,
|
|
|
|
|
const crypto::secret_key& recovery_param = crypto::secret_key(), bool recover = false,
|
|
|
|
|
bool two_random = false);
|
2016-02-23 00:10:55 +02:00
|
|
|
/*!
|
|
|
|
|
* \brief Creates a wallet from a public address and a spend/view secret key pair.
|
|
|
|
|
* \param wallet_ Name of wallet file
|
|
|
|
|
* \param password Password of wallet file
|
|
|
|
|
* \param viewkey view secret key
|
|
|
|
|
* \param spendkey spend secret key
|
|
|
|
|
*/
|
|
|
|
|
void generate(const std::string& wallet, const std::string& password,
|
|
|
|
|
const cryptonote::account_public_address &account_public_address,
|
|
|
|
|
const crypto::secret_key& spendkey, const crypto::secret_key& viewkey);
|
2015-06-20 14:31:53 +03:00
|
|
|
/*!
|
|
|
|
|
* \brief Creates a watch only wallet from a public address and a view secret key.
|
|
|
|
|
* \param wallet_ Name of wallet file
|
|
|
|
|
* \param password Password of wallet file
|
|
|
|
|
* \param viewkey view secret key
|
|
|
|
|
*/
|
|
|
|
|
void generate(const std::string& wallet, const std::string& password,
|
|
|
|
|
const cryptonote::account_public_address &account_public_address,
|
|
|
|
|
const crypto::secret_key& viewkey = crypto::secret_key());
|
2014-10-18 22:38:21 +03:00
|
|
|
/*!
|
|
|
|
|
* \brief Rewrites to the wallet file for wallet upgrade (doesn't generate key, assumes it's already there)
|
|
|
|
|
* \param wallet_name Name of wallet file (should exist)
|
|
|
|
|
* \param password Password for wallet file
|
|
|
|
|
*/
|
2014-10-18 22:30:18 +03:00
|
|
|
void rewrite(const std::string& wallet_name, const std::string& password);
|
2015-05-31 17:34:55 +03:00
|
|
|
void write_watch_only_wallet(const std::string& wallet_name, const std::string& password);
|
2014-04-02 19:00:17 +03:00
|
|
|
void load(const std::string& wallet, const std::string& password);
|
|
|
|
|
void store();
|
2016-03-15 22:11:38 +02:00
|
|
|
/*!
|
|
|
|
|
* \brief store_to - stores wallet to another file(s), deleting old ones
|
2016-06-22 14:37:53 +03:00
|
|
|
* \param path - path to the wallet file (keys and address filenames will be generated based on this filename)
|
2016-03-15 22:11:38 +02:00
|
|
|
* \param password - password to protect new wallet (TODO: probably better save the password in the wallet object?)
|
|
|
|
|
*/
|
|
|
|
|
void store_to(const std::string &path, const std::string &password);
|
2014-12-06 16:55:56 +02:00
|
|
|
|
2016-11-26 16:19:57 +02:00
|
|
|
std::string path() const;
|
|
|
|
|
|
2014-12-06 16:55:56 +02:00
|
|
|
/*!
|
|
|
|
|
* \brief verifies given password is correct for default wallet keys file
|
|
|
|
|
*/
|
2015-05-27 21:00:57 +03:00
|
|
|
bool verify_password(const std::string& password) const;
|
2014-03-04 00:07:58 +02:00
|
|
|
cryptonote::account_base& get_account(){return m_account;}
|
2015-05-27 21:00:57 +03:00
|
|
|
const cryptonote::account_base& get_account()const{return m_account;}
|
2014-03-04 00:07:58 +02:00
|
|
|
|
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 02:48:11 +02:00
|
|
|
void set_refresh_from_block_height(uint64_t height) {m_refresh_from_block_height = height;}
|
2017-01-10 23:34:15 +02:00
|
|
|
uint64_t get_refresh_from_block_height() const {return m_refresh_from_block_height;}
|
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 02:48:11 +02:00
|
|
|
|
2014-05-26 03:25:37 +03:00
|
|
|
// upper_transaction_size_limit as defined below is set to
|
|
|
|
|
// approximately 125% of the fixed minimum allowable penalty
|
|
|
|
|
// free block size. TODO: fix this so that it actually takes
|
|
|
|
|
// into account the current median block size rather than
|
|
|
|
|
// the minimum block size.
|
2014-03-04 00:07:58 +02:00
|
|
|
bool deinit();
|
2017-02-06 00:48:03 +02:00
|
|
|
bool init(std::string daemon_address = "http://localhost:8080",
|
|
|
|
|
boost::optional<epee::net_utils::http::login> daemon_login = boost::none, uint64_t upper_transaction_size_limit = 0);
|
2014-03-04 00:07:58 +02:00
|
|
|
|
2014-03-20 13:46:11 +02:00
|
|
|
void stop() { m_run.store(false, std::memory_order_relaxed); }
|
|
|
|
|
|
2014-04-02 19:00:17 +03:00
|
|
|
i_wallet2_callback* callback() const { return m_callback; }
|
|
|
|
|
void callback(i_wallet2_callback* callback) { m_callback = callback; }
|
|
|
|
|
|
2014-12-06 11:59:13 +02:00
|
|
|
/*!
|
|
|
|
|
* \brief Checks if deterministic wallet
|
|
|
|
|
*/
|
2015-05-27 21:00:57 +03:00
|
|
|
bool is_deterministic() const;
|
|
|
|
|
bool get_seed(std::string& electrum_words) const;
|
2014-11-07 00:36:36 +02:00
|
|
|
/*!
|
|
|
|
|
* \brief Gets the seed language
|
|
|
|
|
*/
|
2015-05-27 21:00:57 +03:00
|
|
|
const std::string &get_seed_language() const;
|
2014-10-02 15:45:18 +03:00
|
|
|
/*!
|
|
|
|
|
* \brief Sets the seed language
|
|
|
|
|
*/
|
2014-10-17 23:51:37 +03:00
|
|
|
void set_seed_language(const std::string &language);
|
|
|
|
|
/*!
|
|
|
|
|
* \brief Tells if the wallet file is deprecated.
|
|
|
|
|
*/
|
|
|
|
|
bool is_deprecated() const;
|
2014-04-02 19:00:17 +03:00
|
|
|
void refresh();
|
2015-10-27 11:05:07 +02:00
|
|
|
void refresh(uint64_t start_height, uint64_t & blocks_fetched);
|
|
|
|
|
void refresh(uint64_t start_height, uint64_t & blocks_fetched, bool& received_money);
|
|
|
|
|
bool refresh(uint64_t & blocks_fetched, bool& received_money, bool& ok);
|
2014-04-02 19:00:17 +03:00
|
|
|
|
2015-11-22 21:03:10 +02:00
|
|
|
void set_refresh_type(RefreshType refresh_type) { m_refresh_type = refresh_type; }
|
2015-12-05 23:44:25 +02:00
|
|
|
RefreshType get_refresh_type() const { return m_refresh_type; }
|
2015-11-22 21:03:10 +02:00
|
|
|
|
2015-05-27 21:00:57 +03:00
|
|
|
bool testnet() const { return m_testnet; }
|
2015-01-11 13:06:35 +02:00
|
|
|
bool restricted() const { return m_restricted; }
|
2015-05-31 17:34:55 +03:00
|
|
|
bool watch_only() const { return m_watch_only; }
|
2014-09-09 17:58:53 +03:00
|
|
|
|
2015-05-27 21:00:57 +03:00
|
|
|
uint64_t balance() const;
|
|
|
|
|
uint64_t unlocked_balance() const;
|
2015-05-30 11:13:52 +03:00
|
|
|
uint64_t unlocked_dust_balance(const tx_dust_policy &dust_policy) const;
|
2014-03-20 13:46:11 +02:00
|
|
|
template<typename T>
|
2016-04-02 15:06:39 +03:00
|
|
|
void transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, const size_t fake_outputs_count, const std::vector<size_t> &unused_transfers_indices, uint64_t unlock_time, uint64_t fee, const std::vector<uint8_t>& extra, T destination_split_strategy, const tx_dust_policy& dust_policy, bool trusted_daemon);
|
2014-03-04 00:07:58 +02:00
|
|
|
template<typename T>
|
2016-04-02 15:06:39 +03:00
|
|
|
void transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, const size_t fake_outputs_count, const std::vector<size_t> &unused_transfers_indices, uint64_t unlock_time, uint64_t fee, const std::vector<uint8_t>& extra, T destination_split_strategy, const tx_dust_policy& dust_policy, cryptonote::transaction& tx, pending_tx& ptx, bool trusted_daemon);
|
|
|
|
|
void transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, const size_t fake_outputs_count, const std::vector<size_t> &unused_transfers_indices, uint64_t unlock_time, uint64_t fee, const std::vector<uint8_t>& extra, bool trusted_daemon);
|
|
|
|
|
void transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, const size_t fake_outputs_count, const std::vector<size_t> &unused_transfers_indices, uint64_t unlock_time, uint64_t fee, const std::vector<uint8_t>& extra, cryptonote::transaction& tx, pending_tx& ptx, bool trusted_daemon);
|
2015-05-30 11:13:52 +03:00
|
|
|
template<typename T>
|
2016-09-27 01:11:10 +03:00
|
|
|
void transfer_selected(const std::vector<cryptonote::tx_destination_entry>& dsts, const std::list<size_t> selected_transfers, size_t fake_outputs_count,
|
2017-01-07 18:06:07 +02:00
|
|
|
std::vector<std::vector<tools::wallet2::get_outs_entry>> &outs,
|
2015-07-20 01:47:13 +03:00
|
|
|
uint64_t unlock_time, uint64_t fee, const std::vector<uint8_t>& extra, T destination_split_strategy, const tx_dust_policy& dust_policy, cryptonote::transaction& tx, pending_tx &ptx);
|
2016-09-27 01:11:10 +03:00
|
|
|
void transfer_selected_rct(std::vector<cryptonote::tx_destination_entry> dsts, const std::list<size_t> selected_transfers, size_t fake_outputs_count,
|
2017-01-07 18:06:07 +02:00
|
|
|
std::vector<std::vector<tools::wallet2::get_outs_entry>> &outs,
|
2016-06-16 01:37:13 +03:00
|
|
|
uint64_t unlock_time, uint64_t fee, const std::vector<uint8_t>& extra, cryptonote::transaction& tx, pending_tx &ptx);
|
2015-07-20 01:47:13 +03:00
|
|
|
|
2014-06-18 01:15:21 +03:00
|
|
|
void commit_tx(pending_tx& ptx_vector);
|
|
|
|
|
void commit_tx(std::vector<pending_tx>& ptx_vector);
|
2016-09-27 01:11:10 +03:00
|
|
|
bool save_tx(const std::vector<pending_tx>& ptx_vector, const std::string &filename);
|
2017-01-08 14:17:09 +02:00
|
|
|
// load unsigned tx from file and sign it. Takes confirmation callback as argument. Used by the cli wallet
|
2016-11-15 23:22:04 +02:00
|
|
|
bool sign_tx(const std::string &unsigned_filename, const std::string &signed_filename, std::vector<wallet2::pending_tx> &ptx, std::function<bool(const unsigned_tx_set&)> accept_func = NULL);
|
2017-01-08 14:17:09 +02:00
|
|
|
// sign unsigned tx. Takes unsigned_tx_set as argument. Used by GUI
|
|
|
|
|
bool sign_tx(unsigned_tx_set &exported_txs, const std::string &signed_filename, std::vector<wallet2::pending_tx> &ptx);
|
|
|
|
|
// load unsigned_tx_set from file.
|
|
|
|
|
bool load_unsigned_tx(const std::string &unsigned_filename, unsigned_tx_set &exported_txs);
|
2016-10-30 12:49:22 +02:00
|
|
|
bool load_tx(const std::string &signed_filename, std::vector<tools::wallet2::pending_tx> &ptx, std::function<bool(const signed_tx_set&)> accept_func = NULL);
|
2016-09-16 13:50:52 +03:00
|
|
|
std::vector<pending_tx> create_transactions(std::vector<cryptonote::tx_destination_entry> dsts, const size_t fake_outs_count, const uint64_t unlock_time, uint32_t priority, const std::vector<uint8_t> extra, bool trusted_daemon);
|
|
|
|
|
std::vector<wallet2::pending_tx> create_transactions_2(std::vector<cryptonote::tx_destination_entry> dsts, const size_t fake_outs_count, const uint64_t unlock_time, uint32_t priority, const std::vector<uint8_t> extra, bool trusted_daemon);
|
2017-04-16 19:46:01 +03:00
|
|
|
std::vector<wallet2::pending_tx> create_transactions_all(uint64_t below, const cryptonote::account_public_address &address, const size_t fake_outs_count, const uint64_t unlock_time, uint32_t priority, const std::vector<uint8_t> extra, bool trusted_daemon);
|
2016-09-24 10:47:47 +03:00
|
|
|
std::vector<wallet2::pending_tx> create_transactions_from(const cryptonote::account_public_address &address, std::vector<size_t> unused_transfers_indices, std::vector<size_t> unused_dust_indices, const size_t fake_outs_count, const uint64_t unlock_time, uint32_t priority, const std::vector<uint8_t> extra, bool trusted_daemon);
|
2016-03-27 01:22:57 +02:00
|
|
|
std::vector<pending_tx> create_unmixable_sweep_transactions(bool trusted_daemon);
|
2017-01-14 15:41:56 +02:00
|
|
|
bool check_connection(uint32_t *version = NULL, uint32_t timeout = 200000);
|
2014-04-02 19:00:17 +03:00
|
|
|
void get_transfers(wallet2::transfer_container& incoming_transfers) const;
|
2014-07-22 19:00:25 +03:00
|
|
|
void get_payments(const crypto::hash& payment_id, std::list<wallet2::payment_details>& payments, uint64_t min_height = 0) const;
|
2015-11-15 23:59:40 +02:00
|
|
|
void get_payments(std::list<std::pair<crypto::hash,wallet2::payment_details>>& payments, uint64_t min_height, uint64_t max_height = (uint64_t)-1) const;
|
|
|
|
|
void get_payments_out(std::list<std::pair<crypto::hash,wallet2::confirmed_transfer_details>>& confirmed_payments,
|
|
|
|
|
uint64_t min_height, uint64_t max_height = (uint64_t)-1) const;
|
|
|
|
|
void get_unconfirmed_payments_out(std::list<std::pair<crypto::hash,wallet2::unconfirmed_transfer_details>>& unconfirmed_payments) const;
|
2016-05-23 23:40:12 +03:00
|
|
|
void get_unconfirmed_payments(std::list<std::pair<crypto::hash,wallet2::payment_details>>& unconfirmed_payments) const;
|
|
|
|
|
|
2014-03-04 00:07:58 +02:00
|
|
|
uint64_t get_blockchain_current_height() const { return m_local_bc_height; }
|
2015-08-11 17:14:44 +03:00
|
|
|
void rescan_spent();
|
2015-12-30 14:58:15 +02:00
|
|
|
void rescan_blockchain(bool refresh = true);
|
2016-06-16 01:37:13 +03:00
|
|
|
bool is_transfer_unlocked(const transfer_details& td) const;
|
2014-03-04 00:07:58 +02:00
|
|
|
template <class t_archive>
|
|
|
|
|
inline void serialize(t_archive &a, const unsigned int ver)
|
|
|
|
|
{
|
2016-04-29 17:17:12 +03:00
|
|
|
uint64_t dummy_refresh_height = 0; // moved to keys file
|
2014-03-04 00:07:58 +02:00
|
|
|
if(ver < 5)
|
|
|
|
|
return;
|
|
|
|
|
a & m_blockchain;
|
|
|
|
|
a & m_transfers;
|
|
|
|
|
a & m_account_public_address;
|
|
|
|
|
a & m_key_images;
|
2014-04-02 19:00:17 +03:00
|
|
|
if(ver < 6)
|
|
|
|
|
return;
|
|
|
|
|
a & m_unconfirmed_txs;
|
2014-05-03 19:19:43 +03:00
|
|
|
if(ver < 7)
|
|
|
|
|
return;
|
|
|
|
|
a & m_payments;
|
2015-08-19 22:59:44 +03:00
|
|
|
if(ver < 8)
|
|
|
|
|
return;
|
|
|
|
|
a & m_tx_keys;
|
2015-11-15 23:59:40 +02:00
|
|
|
if(ver < 9)
|
|
|
|
|
return;
|
|
|
|
|
a & m_confirmed_txs;
|
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 02:48:11 +02:00
|
|
|
if(ver < 11)
|
|
|
|
|
return;
|
2016-04-29 17:17:12 +03:00
|
|
|
a & dummy_refresh_height;
|
2016-04-20 20:19:42 +03:00
|
|
|
if(ver < 12)
|
|
|
|
|
return;
|
|
|
|
|
a & m_tx_notes;
|
2016-05-23 23:40:12 +03:00
|
|
|
if(ver < 13)
|
|
|
|
|
return;
|
2017-03-04 23:47:53 +02:00
|
|
|
if (ver < 17)
|
|
|
|
|
{
|
|
|
|
|
// we're loading an old version, where m_unconfirmed_payments was a std::map
|
|
|
|
|
std::unordered_map<crypto::hash, payment_details> m;
|
|
|
|
|
a & m;
|
|
|
|
|
for (std::unordered_map<crypto::hash, payment_details>::const_iterator i = m.begin(); i != m.end(); ++i)
|
|
|
|
|
m_unconfirmed_payments.insert(*i);
|
|
|
|
|
}
|
2016-07-12 01:14:58 +03:00
|
|
|
if(ver < 14)
|
|
|
|
|
return;
|
2016-11-07 20:50:05 +02:00
|
|
|
if(ver < 15)
|
|
|
|
|
{
|
|
|
|
|
// we're loading an older wallet without a pubkey map, rebuild it
|
|
|
|
|
for (size_t i = 0; i < m_transfers.size(); ++i)
|
|
|
|
|
{
|
|
|
|
|
const transfer_details &td = m_transfers[i];
|
|
|
|
|
const cryptonote::tx_out &out = td.m_tx.vout[td.m_internal_output_index];
|
|
|
|
|
const cryptonote::txout_to_key &o = boost::get<const cryptonote::txout_to_key>(out.target);
|
|
|
|
|
m_pub_keys.emplace(o.key, i);
|
|
|
|
|
}
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
a & m_pub_keys;
|
2016-12-12 01:42:46 +02:00
|
|
|
if(ver < 16)
|
|
|
|
|
return;
|
|
|
|
|
a & m_address_book;
|
2017-03-04 23:47:53 +02:00
|
|
|
if(ver < 17)
|
|
|
|
|
return;
|
|
|
|
|
a & m_unconfirmed_payments;
|
2017-03-21 12:30:25 +02:00
|
|
|
if(ver < 18)
|
|
|
|
|
return;
|
|
|
|
|
a & m_scanned_pool_txs[0];
|
|
|
|
|
a & m_scanned_pool_txs[1];
|
2014-03-04 00:07:58 +02:00
|
|
|
}
|
|
|
|
|
|
2014-12-11 12:48:04 +02:00
|
|
|
/*!
|
|
|
|
|
* \brief Check if wallet keys and bin files exist
|
|
|
|
|
* \param file_path Wallet file path
|
|
|
|
|
* \param keys_file_exists Whether keys file exists
|
|
|
|
|
* \param wallet_file_exists Whether bin file exists
|
|
|
|
|
*/
|
2014-05-25 20:06:40 +03:00
|
|
|
static void wallet_exists(const std::string& file_path, bool& keys_file_exists, bool& wallet_file_exists);
|
2014-12-11 12:47:24 +02:00
|
|
|
/*!
|
|
|
|
|
* \brief Check if wallet file path is valid format
|
|
|
|
|
* \param file_path Wallet file path
|
|
|
|
|
* \return Whether path is valid format
|
|
|
|
|
*/
|
|
|
|
|
static bool wallet_valid_path_format(const std::string& file_path);
|
2015-08-09 12:09:39 +03:00
|
|
|
static bool parse_long_payment_id(const std::string& payment_id_str, crypto::hash& payment_id);
|
|
|
|
|
static bool parse_short_payment_id(const std::string& payment_id_str, crypto::hash8& payment_id);
|
2014-06-02 01:22:42 +03:00
|
|
|
static bool parse_payment_id(const std::string& payment_id_str, crypto::hash& payment_id);
|
|
|
|
|
|
2015-07-19 00:03:35 +03:00
|
|
|
bool always_confirm_transfers() const { return m_always_confirm_transfers; }
|
|
|
|
|
void always_confirm_transfers(bool always) { m_always_confirm_transfers = always; }
|
2016-12-23 14:04:54 +02:00
|
|
|
bool print_ring_members() const { return m_print_ring_members; }
|
|
|
|
|
void print_ring_members(bool value) { m_print_ring_members = value; }
|
2015-11-22 14:26:27 +02:00
|
|
|
bool store_tx_info() const { return m_store_tx_info; }
|
|
|
|
|
void store_tx_info(bool store) { m_store_tx_info = store; }
|
2015-10-30 23:16:51 +02:00
|
|
|
uint32_t default_mixin() const { return m_default_mixin; }
|
|
|
|
|
void default_mixin(uint32_t m) { m_default_mixin = m; }
|
2016-09-16 13:50:52 +03:00
|
|
|
uint32_t get_default_priority() const { return m_default_priority; }
|
|
|
|
|
void set_default_priority(uint32_t p) { m_default_priority = p; }
|
2015-11-28 14:38:58 +02:00
|
|
|
bool auto_refresh() const { return m_auto_refresh; }
|
|
|
|
|
void auto_refresh(bool r) { m_auto_refresh = r; }
|
2016-10-01 19:03:53 +03:00
|
|
|
bool confirm_missing_payment_id() const { return m_confirm_missing_payment_id; }
|
|
|
|
|
void confirm_missing_payment_id(bool always) { m_confirm_missing_payment_id = always; }
|
2017-01-27 14:26:52 +02:00
|
|
|
bool ask_password() const { return m_ask_password; }
|
|
|
|
|
void ask_password(bool always) { m_ask_password = always; }
|
2017-03-02 00:27:27 +02:00
|
|
|
void set_default_decimal_point(unsigned int decimal_point);
|
|
|
|
|
unsigned int get_default_decimal_point() const;
|
wallet: try to save large outputs when using an unneeded second input
When a single input is enough to satisfy a transfer, the code would
previously try to add a second input, to match the "canonical" makeup
of a transaction with two inputs and two outputs. This would cause
wallets to slowly merge outputs till all the monero ends up in a
single output, which causes trouble when making two transactions
one after the other, since change is locked for 10 blocks, and an
increasing portion of the remaining balance would end up locked on
each transaction.
There are two new settings (min-output-count and min-output-value)
which can control when to stop adding such unneeded second outputs.
The idea is that small "dust" outputs will still get added, but
larger ones will not.
Enable with, eg:
set min-output-count 10
set min-output-value 30
to avoid using an unneeded second output of 30 monero or more, if
there would be less than 10 such outputs left.
This does not invalidate any other reason why such outputs would
be used (ie, when they're really needed to satisfy a transfer, or
when randomly picked in the normal course of selection). This may
be improved in the future.
2017-03-24 22:58:02 +02:00
|
|
|
void set_min_output_count(uint32_t count) { m_min_output_count = count; }
|
|
|
|
|
uint32_t get_min_output_count() const { return m_min_output_count; }
|
|
|
|
|
void set_min_output_value(uint64_t value) { m_min_output_value = value; }
|
|
|
|
|
uint64_t get_min_output_value() const { return m_min_output_value; }
|
2017-03-24 23:56:58 +02:00
|
|
|
void merge_destinations(bool merge) { m_merge_destinations = merge; }
|
|
|
|
|
bool merge_destinations() const { return m_merge_destinations; }
|
2017-08-26 18:23:54 +03:00
|
|
|
bool confirm_backlog() const { return m_confirm_backlog; }
|
|
|
|
|
void confirm_backlog(bool always) { m_confirm_backlog = always; }
|
2015-07-19 00:03:35 +03:00
|
|
|
|
2016-07-24 19:53:34 +03:00
|
|
|
bool get_tx_key(const crypto::hash &txid, crypto::secret_key &tx_key) const;
|
2015-08-19 22:59:44 +03:00
|
|
|
|
2016-12-12 01:42:46 +02:00
|
|
|
/*!
|
|
|
|
|
* \brief GUI Address book get/store
|
|
|
|
|
*/
|
2016-12-12 22:39:29 +02:00
|
|
|
std::vector<address_book_row> get_address_book() const { return m_address_book; }
|
2016-12-12 01:42:46 +02:00
|
|
|
bool add_address_book_row(const cryptonote::account_public_address &address, const crypto::hash &payment_id, const std::string &description);
|
2016-12-14 23:37:49 +02:00
|
|
|
bool delete_address_book_row(std::size_t row_id);
|
2016-12-12 01:42:46 +02:00
|
|
|
|
2016-07-27 23:37:58 +03:00
|
|
|
uint64_t get_num_rct_outputs();
|
2016-10-15 21:18:52 +03:00
|
|
|
const transfer_details &get_transfer_details(size_t idx) const;
|
2016-07-27 23:37:58 +03:00
|
|
|
|
2016-07-27 23:18:08 +03:00
|
|
|
void get_hard_fork_info(uint8_t version, uint64_t &earliest_height);
|
2016-09-15 01:54:01 +03:00
|
|
|
bool use_fork_rules(uint8_t version, int64_t early_blocks = 0);
|
2017-03-14 21:28:38 +02:00
|
|
|
int get_fee_algorithm();
|
2016-03-11 23:31:50 +02:00
|
|
|
|
2016-03-11 16:05:36 +02:00
|
|
|
std::string get_wallet_file() const;
|
|
|
|
|
std::string get_keys_file() const;
|
2016-03-25 16:06:30 +02:00
|
|
|
std::string get_daemon_address() const;
|
2017-02-06 00:48:03 +02:00
|
|
|
const boost::optional<epee::net_utils::http::login>& get_daemon_login() const { return m_daemon_login; }
|
2016-09-26 21:35:00 +03:00
|
|
|
uint64_t get_daemon_blockchain_height(std::string& err);
|
2016-10-03 21:47:41 +03:00
|
|
|
uint64_t get_daemon_blockchain_target_height(std::string& err);
|
2016-11-10 16:36:16 +02:00
|
|
|
/*!
|
|
|
|
|
* \brief Calculates the approximate blockchain height from current date/time.
|
|
|
|
|
*/
|
|
|
|
|
uint64_t get_approximate_blockchain_height() const;
|
2017-02-05 23:30:14 +02:00
|
|
|
std::vector<size_t> select_available_outputs_from_histogram(uint64_t count, bool atleast, bool unlocked, bool allow_rct, bool trusted_daemon);
|
2016-04-17 13:20:44 +03:00
|
|
|
std::vector<size_t> select_available_outputs(const std::function<bool(const transfer_details &td)> &f);
|
|
|
|
|
std::vector<size_t> select_available_unmixable_outputs(bool trusted_daemon);
|
|
|
|
|
std::vector<size_t> select_available_mixable_outputs(bool trusted_daemon);
|
|
|
|
|
|
2017-01-14 19:18:14 +02:00
|
|
|
size_t pop_best_value_from(const transfer_container &transfers, std::vector<size_t> &unused_dust_indices, const std::list<size_t>& selected_transfers, bool smallest = false) const;
|
|
|
|
|
size_t pop_best_value(std::vector<size_t> &unused_dust_indices, const std::list<size_t>& selected_transfers, bool smallest = false) const;
|
2016-07-13 00:00:43 +03:00
|
|
|
|
2016-04-20 20:19:42 +03:00
|
|
|
void set_tx_note(const crypto::hash &txid, const std::string ¬e);
|
|
|
|
|
std::string get_tx_note(const crypto::hash &txid) const;
|
|
|
|
|
|
2016-04-23 23:46:48 +03:00
|
|
|
std::string sign(const std::string &data) const;
|
|
|
|
|
bool verify(const std::string &data, const cryptonote::account_public_address &address, const std::string &signature) const;
|
|
|
|
|
|
2017-08-18 15:27:54 +03:00
|
|
|
// Import/Export wallet data
|
2016-10-30 21:37:09 +02:00
|
|
|
std::vector<tools::wallet2::transfer_details> export_outputs() const;
|
|
|
|
|
size_t import_outputs(const std::vector<tools::wallet2::transfer_details> &outputs);
|
2017-08-18 15:27:54 +03:00
|
|
|
payment_container export_payments() const;
|
|
|
|
|
void import_payments(const payment_container &payments);
|
|
|
|
|
void import_payments_out(const std::list<std::pair<crypto::hash,wallet2::confirmed_transfer_details>> &confirmed_payments);
|
|
|
|
|
std::vector<crypto::hash> export_blockchain() const;
|
|
|
|
|
void import_blockchain(const std::vector<crypto::hash> &bc);
|
2017-01-13 13:02:13 +02:00
|
|
|
bool export_key_images(const std::string filename);
|
2016-07-15 14:11:55 +03:00
|
|
|
std::vector<std::pair<crypto::key_image, crypto::signature>> export_key_images() const;
|
2017-08-18 15:19:07 +03:00
|
|
|
uint64_t import_key_images(const std::vector<std::pair<crypto::key_image, crypto::signature>> &signed_key_images, uint64_t &spent, uint64_t &unspent, bool check_spent = true);
|
2017-01-13 13:02:13 +02:00
|
|
|
uint64_t import_key_images(const std::string &filename, uint64_t &spent, uint64_t &unspent);
|
2016-05-23 23:40:12 +03:00
|
|
|
|
2017-07-25 11:30:06 +03:00
|
|
|
void update_pool_state(bool refreshed = false);
|
2016-11-07 21:28:15 +02:00
|
|
|
|
|
|
|
|
std::string encrypt(const std::string &plaintext, const crypto::secret_key &skey, bool authenticated = true) const;
|
|
|
|
|
std::string encrypt_with_view_secret_key(const std::string &plaintext, bool authenticated = true) const;
|
|
|
|
|
std::string decrypt(const std::string &ciphertext, const crypto::secret_key &skey, bool authenticated = true) const;
|
|
|
|
|
std::string decrypt_with_view_secret_key(const std::string &ciphertext, bool authenticated = true) const;
|
|
|
|
|
|
2016-11-28 16:07:25 +02:00
|
|
|
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);
|
|
|
|
|
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<std::string> &unknown_parameters, std::string &error);
|
|
|
|
|
|
2016-12-25 10:18:15 +02:00
|
|
|
uint64_t get_blockchain_height_by_date(uint16_t year, uint8_t month, uint8_t day); // 1<=month<=12, 1<=day<=31
|
|
|
|
|
|
2017-08-02 16:44:19 +03:00
|
|
|
bool is_synced() const;
|
|
|
|
|
|
2017-08-27 23:04:56 +03:00
|
|
|
std::vector<std::pair<uint64_t, uint64_t>> estimate_backlog(uint64_t min_blob_size, uint64_t max_blob_size, const std::vector<uint64_t> &fees);
|
|
|
|
|
|
|
|
|
|
uint64_t get_fee_multiplier(uint32_t priority, int fee_algorithm = -1);
|
|
|
|
|
uint64_t get_per_kb_fee();
|
2017-08-26 18:23:54 +03:00
|
|
|
|
2014-03-04 00:07:58 +02:00
|
|
|
private:
|
2014-10-18 20:41:05 +03:00
|
|
|
/*!
|
2014-10-18 22:38:21 +03:00
|
|
|
* \brief Stores wallet information to wallet file.
|
|
|
|
|
* \param keys_file_name Name of wallet file
|
|
|
|
|
* \param password Password of wallet file
|
2015-05-31 17:34:55 +03:00
|
|
|
* \param watch_only true to save only view key, false to save both spend and view keys
|
2014-10-18 22:38:21 +03:00
|
|
|
* \return Whether it was successful.
|
2014-10-18 20:41:05 +03:00
|
|
|
*/
|
2015-05-31 17:34:55 +03:00
|
|
|
bool store_keys(const std::string& keys_file_name, const std::string& password, bool watch_only = false);
|
2014-10-18 20:41:05 +03:00
|
|
|
/*!
|
2014-10-18 22:38:21 +03:00
|
|
|
* \brief Load wallet information from wallet file.
|
|
|
|
|
* \param keys_file_name Name of wallet file
|
|
|
|
|
* \param password Password of wallet file
|
2014-10-18 20:41:05 +03:00
|
|
|
*/
|
2016-03-28 00:02:23 +03:00
|
|
|
bool load_keys(const std::string& keys_file_name, const std::string& password);
|
2017-02-27 22:26:17 +02:00
|
|
|
void process_new_transaction(const crypto::hash &txid, const cryptonote::transaction& tx, const std::vector<uint64_t> &o_indices, uint64_t height, uint64_t ts, bool miner_tx, bool pool);
|
2016-07-13 21:26:11 +03:00
|
|
|
void process_new_blockchain_entry(const cryptonote::block& b, const cryptonote::block_complete_entry& bche, const crypto::hash& bl_id, uint64_t height, const cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::block_output_indices &o_indices);
|
2014-04-02 19:00:17 +03:00
|
|
|
void detach_blockchain(uint64_t height);
|
2015-05-27 21:00:57 +03:00
|
|
|
void get_short_chain_history(std::list<crypto::hash>& ids) const;
|
2016-01-29 17:09:17 +02:00
|
|
|
bool is_tx_spendtime_unlocked(uint64_t unlock_time, uint64_t block_height) const;
|
2014-03-04 00:07:58 +02:00
|
|
|
bool clear();
|
2016-07-13 21:26:11 +03:00
|
|
|
void pull_blocks(uint64_t start_height, uint64_t& blocks_start_height, const std::list<crypto::hash> &short_chain_history, std::list<cryptonote::block_complete_entry> &blocks, std::vector<cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::block_output_indices> &o_indices);
|
2016-04-14 01:45:02 +03:00
|
|
|
void pull_hashes(uint64_t start_height, uint64_t& blocks_start_height, const std::list<crypto::hash> &short_chain_history, std::list<crypto::hash> &hashes);
|
|
|
|
|
void fast_refresh(uint64_t stop_height, uint64_t &blocks_start_height, std::list<crypto::hash> &short_chain_history);
|
2016-07-13 21:26:11 +03:00
|
|
|
void pull_next_blocks(uint64_t start_height, uint64_t &blocks_start_height, std::list<crypto::hash> &short_chain_history, const std::list<cryptonote::block_complete_entry> &prev_blocks, std::list<cryptonote::block_complete_entry> &blocks, std::vector<cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::block_output_indices> &o_indices, bool &error);
|
|
|
|
|
void process_blocks(uint64_t start_height, const std::list<cryptonote::block_complete_entry> &blocks, const std::vector<cryptonote::COMMAND_RPC_GET_BLOCKS_FAST::block_output_indices> &o_indices, uint64_t& blocks_added);
|
2016-09-27 01:11:10 +03:00
|
|
|
uint64_t select_transfers(uint64_t needed_money, std::vector<size_t> unused_transfers_indices, std::list<size_t>& selected_transfers, bool trusted_daemon);
|
2014-03-04 00:07:58 +02:00
|
|
|
bool prepare_file_names(const std::string& file_path);
|
2017-02-27 22:26:17 +02:00
|
|
|
void process_unconfirmed(const crypto::hash &txid, const cryptonote::transaction& tx, uint64_t height);
|
|
|
|
|
void process_outgoing(const crypto::hash &txid, const cryptonote::transaction& tx, uint64_t height, uint64_t ts, uint64_t spent, uint64_t received);
|
2016-06-16 01:37:13 +03:00
|
|
|
void add_unconfirmed_tx(const cryptonote::transaction& tx, uint64_t amount_in, const std::vector<cryptonote::tx_destination_entry> &dests, const crypto::hash &payment_id, uint64_t change_amount);
|
2014-07-16 20:30:15 +03:00
|
|
|
void generate_genesis(cryptonote::block& b);
|
2015-05-27 21:00:57 +03:00
|
|
|
void check_genesis(const crypto::hash& genesis_hash) const; //throws
|
2015-08-22 16:21:32 +03:00
|
|
|
bool generate_chacha8_key_from_secret_keys(crypto::chacha8_key &key) const;
|
2015-11-22 14:13:59 +02:00
|
|
|
crypto::hash get_payment_id(const pending_tx &ptx) const;
|
2017-01-08 21:17:36 +02:00
|
|
|
crypto::hash8 get_short_payment_id(const pending_tx &ptx) const;
|
2016-11-01 18:24:04 +02:00
|
|
|
void check_acc_out_precomp(const crypto::public_key &spend_public_key, const cryptonote::tx_out &o, const crypto::key_derivation &derivation, size_t i, bool &received, uint64_t &money_transfered, bool &error) const;
|
2015-11-22 17:18:36 +02:00
|
|
|
void parse_block_round(const cryptonote::blobdata &blob, cryptonote::block &bl, crypto::hash &bl_id, bool &error) const;
|
2017-05-09 18:02:57 +03:00
|
|
|
uint64_t get_upper_transaction_size_limit();
|
2016-03-26 23:15:47 +02:00
|
|
|
std::vector<uint64_t> get_unspent_amounts_vector();
|
2016-10-28 23:41:41 +03:00
|
|
|
uint64_t get_dynamic_per_kb_fee_estimate();
|
2016-07-02 19:37:39 +03:00
|
|
|
float get_output_relatedness(const transfer_details &td0, const transfer_details &td1) const;
|
2016-12-04 15:13:54 +02:00
|
|
|
std::vector<size_t> pick_preferred_rct_inputs(uint64_t needed_money) const;
|
2016-09-27 01:11:10 +03:00
|
|
|
void set_spent(size_t idx, uint64_t height);
|
|
|
|
|
void set_unspent(size_t idx);
|
2017-01-07 18:06:07 +02:00
|
|
|
void get_outs(std::vector<std::vector<get_outs_entry>> &outs, const std::list<size_t> &selected_transfers, size_t fake_outputs_count);
|
2016-10-30 14:14:33 +02:00
|
|
|
bool wallet_generate_key_image_helper(const cryptonote::account_keys& ack, const crypto::public_key& tx_public_key, size_t real_output_index, cryptonote::keypair& in_ephemeral, crypto::key_image& ki);
|
2016-11-19 11:36:40 +02:00
|
|
|
crypto::public_key get_tx_pub_key_from_received_outs(const tools::wallet2::transfer_details &td) const;
|
2017-03-20 10:44:28 +02:00
|
|
|
bool should_pick_a_second_output(bool use_rct, size_t n_transfers, const std::vector<size_t> &unused_transfers_indices, const std::vector<size_t> &unused_dust_indices) const;
|
|
|
|
|
std::vector<size_t> get_only_rct(const std::vector<size_t> &unused_dust_indices, const std::vector<size_t> &unused_transfers_indices) const;
|
2014-03-04 00:07:58 +02:00
|
|
|
|
|
|
|
|
cryptonote::account_base m_account;
|
2017-02-06 00:48:03 +02:00
|
|
|
boost::optional<epee::net_utils::http::login> m_daemon_login;
|
2014-03-04 00:07:58 +02:00
|
|
|
std::string m_daemon_address;
|
|
|
|
|
std::string m_wallet_file;
|
|
|
|
|
std::string m_keys_file;
|
|
|
|
|
epee::net_utils::http::http_simple_client m_http_client;
|
|
|
|
|
std::vector<crypto::hash> m_blockchain;
|
2014-05-03 19:19:43 +03:00
|
|
|
std::atomic<uint64_t> m_local_bc_height; //temporary workaround
|
2014-04-02 19:00:17 +03:00
|
|
|
std::unordered_map<crypto::hash, unconfirmed_transfer_details> m_unconfirmed_txs;
|
2015-11-15 23:59:40 +02:00
|
|
|
std::unordered_map<crypto::hash, confirmed_transfer_details> m_confirmed_txs;
|
2017-03-04 23:47:53 +02:00
|
|
|
std::unordered_multimap<crypto::hash, payment_details> m_unconfirmed_payments;
|
2015-08-19 22:59:44 +03:00
|
|
|
std::unordered_map<crypto::hash, crypto::secret_key> m_tx_keys;
|
2014-03-04 00:07:58 +02:00
|
|
|
|
|
|
|
|
transfer_container m_transfers;
|
2014-05-03 19:19:43 +03:00
|
|
|
payment_container m_payments;
|
2014-03-04 00:07:58 +02:00
|
|
|
std::unordered_map<crypto::key_image, size_t> m_key_images;
|
2016-11-07 20:50:05 +02:00
|
|
|
std::unordered_map<crypto::public_key, size_t> m_pub_keys;
|
2014-03-04 00:07:58 +02:00
|
|
|
cryptonote::account_public_address m_account_public_address;
|
2016-04-20 20:19:42 +03:00
|
|
|
std::unordered_map<crypto::hash, std::string> m_tx_notes;
|
2016-12-12 22:39:29 +02:00
|
|
|
std::vector<tools::wallet2::address_book_row> m_address_book;
|
2014-03-04 00:07:58 +02:00
|
|
|
uint64_t m_upper_transaction_size_limit; //TODO: auto-calc this value or request from daemon, now use some fixed value
|
2014-03-20 13:46:11 +02:00
|
|
|
|
|
|
|
|
std::atomic<bool> m_run;
|
2014-04-02 19:00:17 +03:00
|
|
|
|
2016-03-11 14:25:28 +02:00
|
|
|
boost::mutex m_daemon_rpc_mutex;
|
2015-11-27 19:25:15 +02:00
|
|
|
|
2014-04-02 19:00:17 +03:00
|
|
|
i_wallet2_callback* m_callback;
|
2014-07-16 20:30:15 +03:00
|
|
|
bool m_testnet;
|
2015-01-11 13:06:35 +02:00
|
|
|
bool m_restricted;
|
2014-10-18 20:41:05 +03:00
|
|
|
std::string seed_language; /*!< Language of the mnemonics (seed). */
|
|
|
|
|
bool is_old_file_format; /*!< Whether the wallet file is of an old file format */
|
2015-05-31 17:34:55 +03:00
|
|
|
bool m_watch_only; /*!< no spend key */
|
2015-07-19 00:03:35 +03:00
|
|
|
bool m_always_confirm_transfers;
|
2016-12-23 14:04:54 +02:00
|
|
|
bool m_print_ring_members;
|
2015-11-22 14:26:27 +02:00
|
|
|
bool m_store_tx_info; /*!< request txkey to be returned in RPC, and store in the wallet cache file */
|
2015-10-30 23:16:51 +02:00
|
|
|
uint32_t m_default_mixin;
|
2016-09-16 13:50:52 +03:00
|
|
|
uint32_t m_default_priority;
|
2015-11-22 21:03:10 +02:00
|
|
|
RefreshType m_refresh_type;
|
2015-11-28 14:38:58 +02:00
|
|
|
bool m_auto_refresh;
|
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 02:48:11 +02:00
|
|
|
uint64_t m_refresh_from_block_height;
|
2016-10-01 19:03:53 +03:00
|
|
|
bool m_confirm_missing_payment_id;
|
2017-01-27 14:26:52 +02:00
|
|
|
bool m_ask_password;
|
wallet: try to save large outputs when using an unneeded second input
When a single input is enough to satisfy a transfer, the code would
previously try to add a second input, to match the "canonical" makeup
of a transaction with two inputs and two outputs. This would cause
wallets to slowly merge outputs till all the monero ends up in a
single output, which causes trouble when making two transactions
one after the other, since change is locked for 10 blocks, and an
increasing portion of the remaining balance would end up locked on
each transaction.
There are two new settings (min-output-count and min-output-value)
which can control when to stop adding such unneeded second outputs.
The idea is that small "dust" outputs will still get added, but
larger ones will not.
Enable with, eg:
set min-output-count 10
set min-output-value 30
to avoid using an unneeded second output of 30 monero or more, if
there would be less than 10 such outputs left.
This does not invalidate any other reason why such outputs would
be used (ie, when they're really needed to satisfy a transfer, or
when randomly picked in the normal course of selection). This may
be improved in the future.
2017-03-24 22:58:02 +02:00
|
|
|
uint32_t m_min_output_count;
|
|
|
|
|
uint64_t m_min_output_value;
|
2017-03-24 23:56:58 +02:00
|
|
|
bool m_merge_destinations;
|
2017-08-26 18:23:54 +03:00
|
|
|
bool m_confirm_backlog;
|
2017-06-04 03:56:51 +03:00
|
|
|
bool m_is_initialized;
|
2017-01-07 21:23:57 +02:00
|
|
|
NodeRPCProxy m_node_rpc_proxy;
|
2017-03-21 12:30:25 +02:00
|
|
|
std::unordered_set<crypto::hash> m_scanned_pool_txs[2];
|
2014-03-04 00:07:58 +02:00
|
|
|
};
|
|
|
|
|
}
|
2017-03-21 12:30:25 +02:00
|
|
|
BOOST_CLASS_VERSION(tools::wallet2, 18)
|
2016-12-09 20:21:21 +02:00
|
|
|
BOOST_CLASS_VERSION(tools::wallet2::transfer_details, 7)
|
2016-04-19 23:18:43 +03:00
|
|
|
BOOST_CLASS_VERSION(tools::wallet2::payment_details, 1)
|
2016-11-03 01:11:30 +02:00
|
|
|
BOOST_CLASS_VERSION(tools::wallet2::unconfirmed_transfer_details, 6)
|
2017-07-25 18:28:48 +03:00
|
|
|
BOOST_CLASS_VERSION(tools::wallet2::confirmed_transfer_details, 4)
|
2016-12-12 01:42:46 +02:00
|
|
|
BOOST_CLASS_VERSION(tools::wallet2::address_book_row, 16)
|
2016-12-30 15:51:43 +02:00
|
|
|
BOOST_CLASS_VERSION(tools::wallet2::unsigned_tx_set, 0)
|
|
|
|
|
BOOST_CLASS_VERSION(tools::wallet2::signed_tx_set, 0)
|
|
|
|
|
BOOST_CLASS_VERSION(tools::wallet2::tx_construction_data, 0)
|
|
|
|
|
BOOST_CLASS_VERSION(tools::wallet2::pending_tx, 0)
|
2014-03-04 00:07:58 +02:00
|
|
|
|
|
|
|
|
namespace boost
|
|
|
|
|
{
|
|
|
|
|
namespace serialization
|
|
|
|
|
{
|
2016-06-16 01:37:13 +03:00
|
|
|
template <class Archive>
|
2016-12-16 11:10:03 +02:00
|
|
|
inline typename std::enable_if<!Archive::is_loading::value, void>::type initialize_transfer_details(Archive &a, tools::wallet2::transfer_details &x, const boost::serialization::version_type ver)
|
2016-06-16 01:37:13 +03:00
|
|
|
{
|
|
|
|
|
}
|
2016-12-16 11:10:03 +02:00
|
|
|
template <class Archive>
|
|
|
|
|
inline typename std::enable_if<Archive::is_loading::value, void>::type initialize_transfer_details(Archive &a, tools::wallet2::transfer_details &x, const boost::serialization::version_type ver)
|
2016-06-16 01:37:13 +03:00
|
|
|
{
|
2016-06-17 01:58:54 +03:00
|
|
|
if (ver < 1)
|
|
|
|
|
{
|
|
|
|
|
x.m_mask = rct::identity();
|
|
|
|
|
x.m_amount = x.m_tx.vout[x.m_internal_output_index].amount;
|
|
|
|
|
}
|
|
|
|
|
if (ver < 2)
|
|
|
|
|
{
|
|
|
|
|
x.m_spent_height = 0;
|
|
|
|
|
}
|
2016-08-12 20:45:07 +03:00
|
|
|
if (ver < 4)
|
|
|
|
|
{
|
|
|
|
|
x.m_rct = x.m_tx.vout[x.m_internal_output_index].amount == 0;
|
|
|
|
|
}
|
2016-11-13 13:34:43 +02:00
|
|
|
if (ver < 6)
|
|
|
|
|
{
|
|
|
|
|
x.m_key_image_known = true;
|
|
|
|
|
}
|
2016-12-09 20:21:21 +02:00
|
|
|
if (ver < 7)
|
|
|
|
|
{
|
|
|
|
|
x.m_pk_index = 0;
|
|
|
|
|
}
|
2016-06-16 01:37:13 +03:00
|
|
|
}
|
|
|
|
|
|
2014-03-04 00:07:58 +02:00
|
|
|
template <class Archive>
|
|
|
|
|
inline void serialize(Archive &a, tools::wallet2::transfer_details &x, const boost::serialization::version_type ver)
|
|
|
|
|
{
|
|
|
|
|
a & x.m_block_height;
|
|
|
|
|
a & x.m_global_output_index;
|
|
|
|
|
a & x.m_internal_output_index;
|
2016-08-06 21:19:25 +03:00
|
|
|
if (ver < 3)
|
|
|
|
|
{
|
|
|
|
|
cryptonote::transaction tx;
|
|
|
|
|
a & tx;
|
|
|
|
|
x.m_tx = (const cryptonote::transaction_prefix&)tx;
|
|
|
|
|
x.m_txid = cryptonote::get_transaction_hash(tx);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
a & x.m_tx;
|
|
|
|
|
}
|
2014-03-04 00:07:58 +02:00
|
|
|
a & x.m_spent;
|
|
|
|
|
a & x.m_key_image;
|
2016-06-16 01:37:13 +03:00
|
|
|
if (ver < 1)
|
|
|
|
|
{
|
|
|
|
|
// ensure mask and amount are set
|
2016-06-17 01:58:54 +03:00
|
|
|
initialize_transfer_details(a, x, ver);
|
2016-06-16 01:37:13 +03:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
a & x.m_mask;
|
|
|
|
|
a & x.m_amount;
|
2016-06-17 01:58:54 +03:00
|
|
|
if (ver < 2)
|
|
|
|
|
{
|
|
|
|
|
initialize_transfer_details(a, x, ver);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
a & x.m_spent_height;
|
2016-08-06 21:19:25 +03:00
|
|
|
if (ver < 3)
|
2016-08-12 20:45:07 +03:00
|
|
|
{
|
|
|
|
|
initialize_transfer_details(a, x, ver);
|
2016-08-06 21:19:25 +03:00
|
|
|
return;
|
2016-08-12 20:45:07 +03:00
|
|
|
}
|
2016-08-06 21:19:25 +03:00
|
|
|
a & x.m_txid;
|
2016-08-12 20:45:07 +03:00
|
|
|
if (ver < 4)
|
|
|
|
|
{
|
|
|
|
|
initialize_transfer_details(a, x, ver);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
a & x.m_rct;
|
2016-11-07 20:50:05 +02:00
|
|
|
if (ver < 5)
|
2016-11-13 13:34:43 +02:00
|
|
|
{
|
|
|
|
|
initialize_transfer_details(a, x, ver);
|
2016-11-07 20:50:05 +02:00
|
|
|
return;
|
2016-11-13 13:34:43 +02:00
|
|
|
}
|
|
|
|
|
if (ver < 6)
|
|
|
|
|
{
|
|
|
|
|
// v5 did not properly initialize
|
|
|
|
|
uint8_t u;
|
|
|
|
|
a & u;
|
|
|
|
|
x.m_key_image_known = true;
|
|
|
|
|
return;
|
|
|
|
|
}
|
2016-11-07 20:50:05 +02:00
|
|
|
a & x.m_key_image_known;
|
2016-12-09 20:21:21 +02:00
|
|
|
if (ver < 7)
|
|
|
|
|
{
|
|
|
|
|
initialize_transfer_details(a, x, ver);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
a & x.m_pk_index;
|
2014-03-04 00:07:58 +02:00
|
|
|
}
|
2014-04-02 19:00:17 +03:00
|
|
|
|
|
|
|
|
template <class Archive>
|
|
|
|
|
inline void serialize(Archive &a, tools::wallet2::unconfirmed_transfer_details &x, const boost::serialization::version_type ver)
|
|
|
|
|
{
|
|
|
|
|
a & x.m_change;
|
|
|
|
|
a & x.m_sent_time;
|
2016-08-06 21:19:25 +03:00
|
|
|
if (ver < 5)
|
|
|
|
|
{
|
|
|
|
|
cryptonote::transaction tx;
|
|
|
|
|
a & tx;
|
|
|
|
|
x.m_tx = (const cryptonote::transaction_prefix&)tx;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
a & x.m_tx;
|
|
|
|
|
}
|
2015-12-20 15:51:55 +02:00
|
|
|
if (ver < 1)
|
2015-11-22 14:13:59 +02:00
|
|
|
return;
|
|
|
|
|
a & x.m_dests;
|
|
|
|
|
a & x.m_payment_id;
|
2016-01-29 21:44:48 +02:00
|
|
|
if (ver < 2)
|
|
|
|
|
return;
|
|
|
|
|
a & x.m_state;
|
2016-04-19 23:18:43 +03:00
|
|
|
if (ver < 3)
|
|
|
|
|
return;
|
|
|
|
|
a & x.m_timestamp;
|
2016-06-16 01:37:13 +03:00
|
|
|
if (ver < 4)
|
|
|
|
|
return;
|
|
|
|
|
a & x.m_amount_in;
|
|
|
|
|
a & x.m_amount_out;
|
2016-11-03 01:11:30 +02:00
|
|
|
if (ver < 6)
|
|
|
|
|
{
|
|
|
|
|
// v<6 may not have change accumulated in m_amount_out, which is a pain,
|
|
|
|
|
// as it's readily understood to be sum of outputs.
|
|
|
|
|
// We convert it to include change from v6
|
|
|
|
|
if (!typename Archive::is_saving() && x.m_change != (uint64_t)-1)
|
|
|
|
|
x.m_amount_out += x.m_change;
|
|
|
|
|
}
|
2014-04-02 19:00:17 +03:00
|
|
|
}
|
|
|
|
|
|
2015-11-15 23:59:40 +02:00
|
|
|
template <class Archive>
|
|
|
|
|
inline void serialize(Archive &a, tools::wallet2::confirmed_transfer_details &x, const boost::serialization::version_type ver)
|
|
|
|
|
{
|
|
|
|
|
a & x.m_amount_in;
|
|
|
|
|
a & x.m_amount_out;
|
|
|
|
|
a & x.m_change;
|
|
|
|
|
a & x.m_block_height;
|
2015-12-20 15:51:55 +02:00
|
|
|
if (ver < 1)
|
2015-11-22 14:13:59 +02:00
|
|
|
return;
|
|
|
|
|
a & x.m_dests;
|
|
|
|
|
a & x.m_payment_id;
|
2016-04-19 23:18:43 +03:00
|
|
|
if (ver < 2)
|
|
|
|
|
return;
|
|
|
|
|
a & x.m_timestamp;
|
2016-11-03 01:11:30 +02:00
|
|
|
if (ver < 3)
|
|
|
|
|
{
|
|
|
|
|
// v<3 may not have change accumulated in m_amount_out, which is a pain,
|
|
|
|
|
// as it's readily understood to be sum of outputs. Whether it got added
|
|
|
|
|
// or not depends on whether it came from a unconfirmed_transfer_details
|
|
|
|
|
// (not included) or not (included). We can't reliably tell here, so we
|
|
|
|
|
// check whether either yields a "negative" fee, or use the other if so.
|
|
|
|
|
// We convert it to include change from v3
|
|
|
|
|
if (!typename Archive::is_saving() && x.m_change != (uint64_t)-1)
|
|
|
|
|
{
|
|
|
|
|
if (x.m_amount_in > (x.m_amount_out + x.m_change))
|
|
|
|
|
x.m_amount_out += x.m_change;
|
|
|
|
|
}
|
|
|
|
|
}
|
2017-07-25 18:28:48 +03:00
|
|
|
if (ver < 4)
|
|
|
|
|
{
|
|
|
|
|
if (!typename Archive::is_saving())
|
|
|
|
|
x.m_unlock_time = 0;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
a & x.m_unlock_time;
|
2015-11-15 23:59:40 +02:00
|
|
|
}
|
|
|
|
|
|
2014-05-03 19:19:43 +03:00
|
|
|
template <class Archive>
|
|
|
|
|
inline void serialize(Archive& a, tools::wallet2::payment_details& x, const boost::serialization::version_type ver)
|
|
|
|
|
{
|
|
|
|
|
a & x.m_tx_hash;
|
|
|
|
|
a & x.m_amount;
|
|
|
|
|
a & x.m_block_height;
|
|
|
|
|
a & x.m_unlock_time;
|
2016-04-19 23:18:43 +03:00
|
|
|
if (ver < 1)
|
|
|
|
|
return;
|
|
|
|
|
a & x.m_timestamp;
|
2014-05-03 19:19:43 +03:00
|
|
|
}
|
2015-11-22 14:13:59 +02:00
|
|
|
|
|
|
|
|
template <class Archive>
|
|
|
|
|
inline void serialize(Archive& a, cryptonote::tx_destination_entry& x, const boost::serialization::version_type ver)
|
|
|
|
|
{
|
|
|
|
|
a & x.amount;
|
|
|
|
|
a & x.addr;
|
|
|
|
|
}
|
2016-12-12 01:42:46 +02:00
|
|
|
|
|
|
|
|
template <class Archive>
|
|
|
|
|
inline void serialize(Archive& a, tools::wallet2::address_book_row& x, const boost::serialization::version_type ver)
|
|
|
|
|
{
|
|
|
|
|
a & x.m_address;
|
|
|
|
|
a & x.m_payment_id;
|
|
|
|
|
a & x.m_description;
|
|
|
|
|
}
|
2016-12-30 15:51:43 +02:00
|
|
|
|
|
|
|
|
template <class Archive>
|
|
|
|
|
inline void serialize(Archive &a, tools::wallet2::unsigned_tx_set &x, const boost::serialization::version_type ver)
|
|
|
|
|
{
|
|
|
|
|
a & x.txes;
|
|
|
|
|
a & x.transfers;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class Archive>
|
|
|
|
|
inline void serialize(Archive &a, tools::wallet2::signed_tx_set &x, const boost::serialization::version_type ver)
|
|
|
|
|
{
|
|
|
|
|
a & x.ptx;
|
|
|
|
|
a & x.key_images;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class Archive>
|
|
|
|
|
inline void serialize(Archive &a, tools::wallet2::tx_construction_data &x, const boost::serialization::version_type ver)
|
|
|
|
|
{
|
|
|
|
|
a & x.sources;
|
|
|
|
|
a & x.change_dts;
|
|
|
|
|
a & x.splitted_dsts;
|
|
|
|
|
a & x.selected_transfers;
|
|
|
|
|
a & x.extra;
|
|
|
|
|
a & x.unlock_time;
|
|
|
|
|
a & x.use_rct;
|
|
|
|
|
a & x.dests;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class Archive>
|
|
|
|
|
inline void serialize(Archive &a, tools::wallet2::pending_tx &x, const boost::serialization::version_type ver)
|
|
|
|
|
{
|
|
|
|
|
a & x.tx;
|
|
|
|
|
a & x.dust;
|
|
|
|
|
a & x.fee;
|
|
|
|
|
a & x.dust_added_to_fee;
|
|
|
|
|
a & x.change_dts;
|
|
|
|
|
a & x.selected_transfers;
|
|
|
|
|
a & x.key_images;
|
|
|
|
|
a & x.tx_key;
|
|
|
|
|
a & x.dests;
|
|
|
|
|
a & x.construction_data;
|
|
|
|
|
}
|
2014-03-04 00:07:58 +02:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
namespace tools
|
|
|
|
|
{
|
2014-06-05 01:59:47 +03:00
|
|
|
|
2014-03-04 00:07:58 +02:00
|
|
|
namespace detail
|
|
|
|
|
{
|
|
|
|
|
//----------------------------------------------------------------------------------------------------
|
|
|
|
|
inline void digit_split_strategy(const std::vector<cryptonote::tx_destination_entry>& dsts,
|
|
|
|
|
const cryptonote::tx_destination_entry& change_dst, uint64_t dust_threshold,
|
2015-10-06 18:22:19 +03:00
|
|
|
std::vector<cryptonote::tx_destination_entry>& splitted_dsts, std::vector<cryptonote::tx_destination_entry> &dust_dsts)
|
2014-03-04 00:07:58 +02:00
|
|
|
{
|
|
|
|
|
splitted_dsts.clear();
|
2015-10-06 18:22:19 +03:00
|
|
|
dust_dsts.clear();
|
2014-03-04 00:07:58 +02:00
|
|
|
|
2017-01-22 22:38:10 +02:00
|
|
|
for(auto& de: dsts)
|
2014-03-04 00:07:58 +02:00
|
|
|
{
|
2015-10-06 18:22:19 +03:00
|
|
|
cryptonote::decompose_amount_into_digits(de.amount, 0,
|
2014-03-04 00:07:58 +02:00
|
|
|
[&](uint64_t chunk) { splitted_dsts.push_back(cryptonote::tx_destination_entry(chunk, de.addr)); },
|
|
|
|
|
[&](uint64_t a_dust) { splitted_dsts.push_back(cryptonote::tx_destination_entry(a_dust, de.addr)); } );
|
|
|
|
|
}
|
|
|
|
|
|
2015-10-06 18:22:19 +03:00
|
|
|
cryptonote::decompose_amount_into_digits(change_dst.amount, 0,
|
|
|
|
|
[&](uint64_t chunk) {
|
|
|
|
|
if (chunk <= dust_threshold)
|
|
|
|
|
dust_dsts.push_back(cryptonote::tx_destination_entry(chunk, change_dst.addr));
|
|
|
|
|
else
|
|
|
|
|
splitted_dsts.push_back(cryptonote::tx_destination_entry(chunk, change_dst.addr));
|
|
|
|
|
},
|
|
|
|
|
[&](uint64_t a_dust) { dust_dsts.push_back(cryptonote::tx_destination_entry(a_dust, change_dst.addr)); } );
|
2014-03-04 00:07:58 +02:00
|
|
|
}
|
|
|
|
|
//----------------------------------------------------------------------------------------------------
|
|
|
|
|
inline void null_split_strategy(const std::vector<cryptonote::tx_destination_entry>& dsts,
|
|
|
|
|
const cryptonote::tx_destination_entry& change_dst, uint64_t dust_threshold,
|
2015-10-06 18:22:19 +03:00
|
|
|
std::vector<cryptonote::tx_destination_entry>& splitted_dsts, std::vector<cryptonote::tx_destination_entry> &dust_dsts)
|
2014-03-04 00:07:58 +02:00
|
|
|
{
|
|
|
|
|
splitted_dsts = dsts;
|
|
|
|
|
|
2015-10-06 18:22:19 +03:00
|
|
|
dust_dsts.clear();
|
2014-03-04 00:07:58 +02:00
|
|
|
uint64_t change = change_dst.amount;
|
|
|
|
|
|
|
|
|
|
if (0 != change)
|
|
|
|
|
{
|
|
|
|
|
splitted_dsts.push_back(cryptonote::tx_destination_entry(change, change_dst.addr));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
//----------------------------------------------------------------------------------------------------
|
|
|
|
|
inline void print_source_entry(const cryptonote::tx_source_entry& src)
|
|
|
|
|
{
|
|
|
|
|
std::string indexes;
|
|
|
|
|
std::for_each(src.outputs.begin(), src.outputs.end(), [&](const cryptonote::tx_source_entry::output_entry& s_e) { indexes += boost::to_string(s_e.first) + " "; });
|
2014-03-20 13:46:11 +02:00
|
|
|
LOG_PRINT_L0("amount=" << cryptonote::print_money(src.amount) << ", real_output=" <<src.real_output << ", real_output_in_tx_index=" << src.real_output_in_tx_index << ", indexes: " << indexes);
|
2014-03-04 00:07:58 +02:00
|
|
|
}
|
|
|
|
|
//----------------------------------------------------------------------------------------------------
|
|
|
|
|
}
|
|
|
|
|
//----------------------------------------------------------------------------------------------------
|
|
|
|
|
template<typename T>
|
2016-04-02 15:06:39 +03:00
|
|
|
void wallet2::transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, const size_t fake_outs_count, const std::vector<size_t> &unused_transfers_indices,
|
|
|
|
|
uint64_t unlock_time, uint64_t fee, const std::vector<uint8_t>& extra, T destination_split_strategy, const tx_dust_policy& dust_policy, bool trusted_daemon)
|
2014-03-04 00:07:58 +02:00
|
|
|
{
|
2014-06-16 03:36:44 +03:00
|
|
|
pending_tx ptx;
|
2014-03-04 00:07:58 +02:00
|
|
|
cryptonote::transaction tx;
|
2016-04-02 15:06:39 +03:00
|
|
|
transfer(dsts, fake_outs_count, unused_transfers_indices, unlock_time, fee, extra, destination_split_strategy, dust_policy, tx, ptx, trusted_daemon);
|
2014-03-04 00:07:58 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template<typename T>
|
2016-04-02 15:06:39 +03:00
|
|
|
void wallet2::transfer(const std::vector<cryptonote::tx_destination_entry>& dsts, size_t fake_outputs_count, const std::vector<size_t> &unused_transfers_indices,
|
|
|
|
|
uint64_t unlock_time, uint64_t fee, const std::vector<uint8_t>& extra, T destination_split_strategy, const tx_dust_policy& dust_policy, cryptonote::transaction& tx, pending_tx &ptx, bool trusted_daemon)
|
2014-03-04 00:07:58 +02:00
|
|
|
{
|
|
|
|
|
using namespace cryptonote;
|
2014-06-13 21:05:15 +03:00
|
|
|
// throw if attempting a transaction with no destinations
|
2014-04-07 18:02:15 +03:00
|
|
|
THROW_WALLET_EXCEPTION_IF(dsts.empty(), error::zero_destination);
|
2014-03-04 00:07:58 +02:00
|
|
|
|
2017-05-09 18:02:57 +03:00
|
|
|
uint64_t upper_transaction_size_limit = get_upper_transaction_size_limit();
|
2014-03-04 00:07:58 +02:00
|
|
|
uint64_t needed_money = fee;
|
2014-06-13 21:05:15 +03:00
|
|
|
|
|
|
|
|
// calculate total amount being sent to all destinations
|
|
|
|
|
// throw if total amount overflows uint64_t
|
2017-01-22 22:38:10 +02:00
|
|
|
for(auto& dt: dsts)
|
2014-03-04 00:07:58 +02:00
|
|
|
{
|
2014-04-07 18:02:15 +03:00
|
|
|
THROW_WALLET_EXCEPTION_IF(0 == dt.amount, error::zero_destination);
|
2014-03-04 00:07:58 +02:00
|
|
|
needed_money += dt.amount;
|
2014-09-09 17:58:53 +03:00
|
|
|
THROW_WALLET_EXCEPTION_IF(needed_money < dt.amount, error::tx_sum_overflow, dsts, fee, m_testnet);
|
2014-03-04 00:07:58 +02:00
|
|
|
}
|
|
|
|
|
|
2014-06-13 21:05:15 +03:00
|
|
|
// randomly select inputs for transaction
|
|
|
|
|
// throw if requested send amount is greater than amount available to send
|
2016-09-27 01:11:10 +03:00
|
|
|
std::list<size_t> selected_transfers;
|
2016-04-02 15:06:39 +03:00
|
|
|
uint64_t found_money = select_transfers(needed_money, unused_transfers_indices, selected_transfers, trusted_daemon);
|
2014-04-07 18:02:15 +03:00
|
|
|
THROW_WALLET_EXCEPTION_IF(found_money < needed_money, error::not_enough_money, found_money, needed_money - fee, fee);
|
2014-03-04 00:07:58 +02:00
|
|
|
|
|
|
|
|
typedef COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::out_entry out_entry;
|
|
|
|
|
typedef cryptonote::tx_source_entry::output_entry tx_output_entry;
|
|
|
|
|
|
|
|
|
|
COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::response daemon_resp = AUTO_VAL_INIT(daemon_resp);
|
|
|
|
|
if(fake_outputs_count)
|
|
|
|
|
{
|
|
|
|
|
COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::request req = AUTO_VAL_INIT(req);
|
|
|
|
|
req.outs_count = fake_outputs_count + 1;// add one to make possible (if need) to skip real output key
|
2017-01-22 22:38:10 +02:00
|
|
|
for(size_t idx: selected_transfers)
|
2014-03-04 00:07:58 +02:00
|
|
|
{
|
2016-09-27 01:11:10 +03:00
|
|
|
const transfer_container::const_iterator it = m_transfers.begin() + idx;
|
2014-04-07 18:02:15 +03:00
|
|
|
THROW_WALLET_EXCEPTION_IF(it->m_tx.vout.size() <= it->m_internal_output_index, error::wallet_internal_error,
|
2014-04-02 19:00:17 +03:00
|
|
|
"m_internal_output_index = " + std::to_string(it->m_internal_output_index) +
|
|
|
|
|
" is greater or equal to outputs count = " + std::to_string(it->m_tx.vout.size()));
|
2014-03-04 00:07:58 +02:00
|
|
|
req.amounts.push_back(it->amount());
|
|
|
|
|
}
|
2014-03-20 13:46:11 +02:00
|
|
|
|
2015-11-27 19:25:15 +02:00
|
|
|
m_daemon_rpc_mutex.lock();
|
2017-01-25 07:16:05 +02:00
|
|
|
bool r = epee::net_utils::invoke_http_bin("/getrandom_outs.bin", req, daemon_resp, m_http_client, rpc_timeout);
|
2015-11-27 19:25:15 +02:00
|
|
|
m_daemon_rpc_mutex.unlock();
|
2014-04-07 18:02:15 +03:00
|
|
|
THROW_WALLET_EXCEPTION_IF(!r, error::no_connection_to_daemon, "getrandom_outs.bin");
|
|
|
|
|
THROW_WALLET_EXCEPTION_IF(daemon_resp.status == CORE_RPC_STATUS_BUSY, error::daemon_busy, "getrandom_outs.bin");
|
|
|
|
|
THROW_WALLET_EXCEPTION_IF(daemon_resp.status != CORE_RPC_STATUS_OK, error::get_random_outs_error, daemon_resp.status);
|
|
|
|
|
THROW_WALLET_EXCEPTION_IF(daemon_resp.outs.size() != selected_transfers.size(), error::wallet_internal_error,
|
2014-04-02 19:00:17 +03:00
|
|
|
"daemon returned wrong response for getrandom_outs.bin, wrong amounts count = " +
|
|
|
|
|
std::to_string(daemon_resp.outs.size()) + ", expected " + std::to_string(selected_transfers.size()));
|
|
|
|
|
|
2016-08-02 23:48:09 +03:00
|
|
|
std::unordered_map<uint64_t, uint64_t> scanty_outs;
|
2017-01-22 22:38:10 +02:00
|
|
|
for(COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::outs_for_amount& amount_outs: daemon_resp.outs)
|
2014-03-20 13:46:11 +02:00
|
|
|
{
|
2014-04-02 19:00:17 +03:00
|
|
|
if (amount_outs.outs.size() < fake_outputs_count)
|
2014-03-20 13:46:11 +02:00
|
|
|
{
|
2016-08-02 23:48:09 +03:00
|
|
|
scanty_outs[amount_outs.amount] = amount_outs.outs.size();
|
2014-03-20 13:46:11 +02:00
|
|
|
}
|
|
|
|
|
}
|
2014-04-07 18:02:15 +03:00
|
|
|
THROW_WALLET_EXCEPTION_IF(!scanty_outs.empty(), error::not_enough_outs_to_mix, scanty_outs, fake_outputs_count);
|
2014-03-04 00:07:58 +02:00
|
|
|
}
|
2014-05-03 19:19:43 +03:00
|
|
|
|
2014-03-04 00:07:58 +02:00
|
|
|
//prepare inputs
|
|
|
|
|
size_t i = 0;
|
|
|
|
|
std::vector<cryptonote::tx_source_entry> sources;
|
2017-01-22 22:38:10 +02:00
|
|
|
for(size_t idx: selected_transfers)
|
2014-03-04 00:07:58 +02:00
|
|
|
{
|
|
|
|
|
sources.resize(sources.size()+1);
|
|
|
|
|
cryptonote::tx_source_entry& src = sources.back();
|
2016-09-27 01:11:10 +03:00
|
|
|
const transfer_details& td = m_transfers[idx];
|
2014-03-04 00:07:58 +02:00
|
|
|
src.amount = td.amount();
|
2016-08-12 20:45:07 +03:00
|
|
|
src.rct = false;
|
2014-03-04 00:07:58 +02:00
|
|
|
//paste mixin transaction
|
|
|
|
|
if(daemon_resp.outs.size())
|
|
|
|
|
{
|
|
|
|
|
daemon_resp.outs[i].outs.sort([](const out_entry& a, const out_entry& b){return a.global_amount_index < b.global_amount_index;});
|
2017-01-22 22:38:10 +02:00
|
|
|
for(out_entry& daemon_oe: daemon_resp.outs[i].outs)
|
2014-03-04 00:07:58 +02:00
|
|
|
{
|
|
|
|
|
if(td.m_global_output_index == daemon_oe.global_amount_index)
|
|
|
|
|
continue;
|
|
|
|
|
tx_output_entry oe;
|
|
|
|
|
oe.first = daemon_oe.global_amount_index;
|
2016-06-16 01:37:13 +03:00
|
|
|
oe.second.dest = rct::pk2rct(daemon_oe.out_key);
|
|
|
|
|
oe.second.mask = rct::identity();
|
2014-03-04 00:07:58 +02:00
|
|
|
src.outputs.push_back(oe);
|
|
|
|
|
if(src.outputs.size() >= fake_outputs_count)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//paste real transaction to the random index
|
|
|
|
|
auto it_to_insert = std::find_if(src.outputs.begin(), src.outputs.end(), [&](const tx_output_entry& a)
|
|
|
|
|
{
|
|
|
|
|
return a.first >= td.m_global_output_index;
|
|
|
|
|
});
|
|
|
|
|
//size_t real_index = src.outputs.size() ? (rand() % src.outputs.size() ):0;
|
|
|
|
|
tx_output_entry real_oe;
|
|
|
|
|
real_oe.first = td.m_global_output_index;
|
2016-06-16 01:37:13 +03:00
|
|
|
real_oe.second.dest = rct::pk2rct(boost::get<txout_to_key>(td.m_tx.vout[td.m_internal_output_index].target).key);
|
|
|
|
|
real_oe.second.mask = rct::identity();
|
2014-03-04 00:07:58 +02:00
|
|
|
auto interted_it = src.outputs.insert(it_to_insert, real_oe);
|
|
|
|
|
src.real_out_tx_key = get_tx_pub_key_from_extra(td.m_tx);
|
|
|
|
|
src.real_output = interted_it - src.outputs.begin();
|
|
|
|
|
src.real_output_in_tx_index = td.m_internal_output_index;
|
|
|
|
|
detail::print_source_entry(src);
|
|
|
|
|
++i;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
cryptonote::tx_destination_entry change_dts = AUTO_VAL_INIT(change_dts);
|
|
|
|
|
if (needed_money < found_money)
|
|
|
|
|
{
|
|
|
|
|
change_dts.addr = m_account.get_keys().m_account_address;
|
|
|
|
|
change_dts.amount = found_money - needed_money;
|
|
|
|
|
}
|
|
|
|
|
|
2015-10-06 18:22:19 +03:00
|
|
|
std::vector<cryptonote::tx_destination_entry> splitted_dsts, dust_dsts;
|
2014-03-04 00:07:58 +02:00
|
|
|
uint64_t dust = 0;
|
2015-10-06 18:22:19 +03:00
|
|
|
destination_split_strategy(dsts, change_dts, dust_policy.dust_threshold, splitted_dsts, dust_dsts);
|
2017-01-22 22:38:10 +02:00
|
|
|
for(auto& d: dust_dsts) {
|
2015-10-06 18:22:19 +03:00
|
|
|
THROW_WALLET_EXCEPTION_IF(dust_policy.dust_threshold < d.amount, error::wallet_internal_error, "invalid dust value: dust = " +
|
|
|
|
|
std::to_string(d.amount) + ", dust_threshold = " + std::to_string(dust_policy.dust_threshold));
|
|
|
|
|
}
|
2017-01-22 22:38:10 +02:00
|
|
|
for(auto& d: dust_dsts) {
|
2015-10-06 18:22:19 +03:00
|
|
|
if (!dust_policy.add_to_fee)
|
|
|
|
|
splitted_dsts.push_back(cryptonote::tx_destination_entry(d.amount, dust_policy.addr_for_dust));
|
|
|
|
|
dust += d.amount;
|
2014-03-04 00:07:58 +02:00
|
|
|
}
|
2014-03-20 13:46:11 +02:00
|
|
|
|
2015-08-19 22:59:44 +03:00
|
|
|
crypto::secret_key tx_key;
|
2016-08-10 14:48:20 +03:00
|
|
|
bool r = cryptonote::construct_tx_and_get_tx_key(m_account.get_keys(), sources, splitted_dsts, extra, tx, unlock_time, tx_key);
|
2014-09-09 17:58:53 +03:00
|
|
|
THROW_WALLET_EXCEPTION_IF(!r, error::tx_not_constructed, sources, splitted_dsts, unlock_time, m_testnet);
|
2016-01-10 13:56:13 +02:00
|
|
|
THROW_WALLET_EXCEPTION_IF(upper_transaction_size_limit <= get_object_blobsize(tx), error::tx_too_big, tx, upper_transaction_size_limit);
|
2014-03-04 00:07:58 +02:00
|
|
|
|
2014-04-02 19:00:17 +03:00
|
|
|
std::string key_images;
|
|
|
|
|
bool all_are_txin_to_key = std::all_of(tx.vin.begin(), tx.vin.end(), [&](const txin_v& s_e) -> bool
|
2014-03-04 00:07:58 +02:00
|
|
|
{
|
2014-04-02 19:00:17 +03:00
|
|
|
CHECKED_GET_SPECIFIC_VARIANT(s_e, const txin_to_key, in, false);
|
|
|
|
|
key_images += boost::to_string(in.k_image) + " ";
|
|
|
|
|
return true;
|
|
|
|
|
});
|
2014-04-07 18:02:15 +03:00
|
|
|
THROW_WALLET_EXCEPTION_IF(!all_are_txin_to_key, error::unexpected_txin_type, tx);
|
2016-04-18 05:57:47 +03:00
|
|
|
|
|
|
|
|
bool dust_sent_elsewhere = (dust_policy.addr_for_dust.m_view_public_key != change_dts.addr.m_view_public_key
|
|
|
|
|
|| dust_policy.addr_for_dust.m_spend_public_key != change_dts.addr.m_spend_public_key);
|
|
|
|
|
|
|
|
|
|
if (dust_policy.add_to_fee || dust_sent_elsewhere) change_dts.amount -= dust;
|
2014-03-04 00:07:58 +02:00
|
|
|
|
2014-06-16 03:36:44 +03:00
|
|
|
ptx.key_images = key_images;
|
2016-04-18 05:57:47 +03:00
|
|
|
ptx.fee = (dust_policy.add_to_fee ? fee+dust : fee);
|
|
|
|
|
ptx.dust = ((dust_policy.add_to_fee || dust_sent_elsewhere) ? dust : 0);
|
2016-04-18 11:20:31 +03:00
|
|
|
ptx.dust_added_to_fee = dust_policy.add_to_fee;
|
2014-06-16 03:36:44 +03:00
|
|
|
ptx.tx = tx;
|
|
|
|
|
ptx.change_dts = change_dts;
|
|
|
|
|
ptx.selected_transfers = selected_transfers;
|
2015-08-19 22:59:44 +03:00
|
|
|
ptx.tx_key = tx_key;
|
2015-11-22 14:13:59 +02:00
|
|
|
ptx.dests = dsts;
|
2016-09-27 01:11:10 +03:00
|
|
|
ptx.construction_data.sources = sources;
|
|
|
|
|
ptx.construction_data.change_dts = change_dts;
|
2016-10-25 23:19:47 +03:00
|
|
|
ptx.construction_data.splitted_dsts = splitted_dsts;
|
|
|
|
|
ptx.construction_data.selected_transfers = selected_transfers;
|
2016-09-27 01:11:10 +03:00
|
|
|
ptx.construction_data.extra = tx.extra;
|
|
|
|
|
ptx.construction_data.unlock_time = unlock_time;
|
|
|
|
|
ptx.construction_data.use_rct = false;
|
2016-11-23 22:10:34 +02:00
|
|
|
ptx.construction_data.dests = dsts;
|
2014-06-16 03:36:44 +03:00
|
|
|
}
|
2014-03-04 00:07:58 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|