2015-12-31 08:39:56 +02:00
|
|
|
// Copyright (c) 2014-2016, 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>
|
|
|
|
#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"
|
|
|
|
#include "cryptonote_core/account.h"
|
|
|
|
#include "cryptonote_core/account_boost_serialization.h"
|
|
|
|
#include "cryptonote_core/cryptonote_basic_impl.h"
|
|
|
|
#include "net/http_client.h"
|
|
|
|
#include "storages/http_abstract_invoke.h"
|
|
|
|
#include "rpc/core_rpc_server_commands_defs.h"
|
|
|
|
#include "cryptonote_core/cryptonote_format_utils.h"
|
|
|
|
#include "common/unordered_containers_boost_serialization.h"
|
|
|
|
#include "crypto/chacha8.h"
|
|
|
|
#include "crypto/hash.h"
|
|
|
|
|
2014-04-02 19:00:17 +03:00
|
|
|
#include "wallet_errors.h"
|
|
|
|
|
2014-06-17 04:52:06 +03:00
|
|
|
#include <iostream>
|
2014-03-04 00:07:58 +02:00
|
|
|
#define WALLET_RCP_CONNECTION_TIMEOUT 200000
|
|
|
|
|
|
|
|
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) {}
|
|
|
|
virtual void on_money_received(uint64_t height, const cryptonote::transaction& tx, size_t out_index) {}
|
|
|
|
virtual void on_money_spent(uint64_t height, const cryptonote::transaction& in_tx, size_t out_index, const cryptonote::transaction& spend_tx) {}
|
2014-05-03 19:19:43 +03:00
|
|
|
virtual void on_skip_transaction(uint64_t height, const cryptonote::transaction& tx) {}
|
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
|
|
|
|
{
|
|
|
|
public:
|
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:
|
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
|
|
|
wallet2(const wallet2&) : m_run(true), m_callback(0), m_testnet(false), m_always_confirm_transfers (false), m_store_tx_info(true), m_default_mixin(0), m_refresh_type(RefreshOptimizeCoinbase), m_auto_refresh(true), m_refresh_from_block_height(0) {}
|
2015-11-22 21:03:10 +02:00
|
|
|
|
|
|
|
public:
|
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
|
|
|
wallet2(bool testnet = false, bool restricted = false) : m_run(true), m_callback(0), m_testnet(testnet), m_restricted(restricted), is_old_file_format(false), m_store_tx_info(true), m_default_mixin(0), m_refresh_type(RefreshOptimizeCoinbase), m_auto_refresh(true), m_refresh_from_block_height(0) {}
|
2014-03-04 00:07:58 +02:00
|
|
|
struct transfer_details
|
|
|
|
{
|
|
|
|
uint64_t m_block_height;
|
|
|
|
cryptonote::transaction m_tx;
|
|
|
|
size_t m_internal_output_index;
|
|
|
|
uint64_t m_global_output_index;
|
|
|
|
bool m_spent;
|
|
|
|
crypto::key_image m_key_image; //TODO: key_image stored twice :(
|
|
|
|
|
|
|
|
uint64_t amount() const { return m_tx.vout[m_internal_output_index].amount; }
|
|
|
|
};
|
|
|
|
|
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
|
|
|
{
|
2014-04-02 19:00:17 +03:00
|
|
|
cryptonote::transaction m_tx;
|
|
|
|
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;
|
2015-11-22 14:13:59 +02: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) {}
|
2015-11-15 23:59:40 +02:00
|
|
|
confirmed_transfer_details(const unconfirmed_transfer_details &utd, uint64_t height):
|
2016-04-19 23:18:43 +03:00
|
|
|
m_amount_out(get_outs_money_amount(utd.m_tx)), 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) { get_inputs_money_amount(utd.m_tx, m_amount_in); }
|
2015-11-15 23:59:40 +02: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
|
|
|
|
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;
|
|
|
|
std::list<transfer_container::iterator> selected_transfers;
|
|
|
|
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;
|
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()
|
|
|
|
};
|
|
|
|
|
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
|
|
|
|
* \param path - path to the wallet file (keys and address filenames will be generated based on this filename)
|
|
|
|
* \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
|
|
|
|
|
|
|
/*!
|
|
|
|
* \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;}
|
|
|
|
|
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.
|
2016-01-10 13:56:13 +02:00
|
|
|
void init(const std::string& daemon_address = "http://localhost:8080", uint64_t upper_transaction_size_limit = 0);
|
2014-03-04 00:07:58 +02:00
|
|
|
bool deinit();
|
|
|
|
|
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-03-26 23:15:47 +02:00
|
|
|
void transfer_from(const std::vector<size_t> &outs, size_t num_outputs, uint64_t unlock_time, uint64_t needed_fee, T destination_split_strategy, const tx_dust_policy& dust_policy, const std::vector<uint8_t>& extra, cryptonote::transaction& tx, pending_tx &ptx);
|
2015-07-20 01:47:13 +03:00
|
|
|
template<typename T>
|
|
|
|
void transfer_selected(const std::vector<cryptonote::tx_destination_entry>& dsts, const std::list<transfer_container::iterator> selected_transfers, size_t fake_outputs_count,
|
|
|
|
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);
|
|
|
|
|
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-04-02 15:06:39 +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, const uint64_t fee, 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, const uint64_t fee_UNUSED, const std::vector<uint8_t> extra, bool trusted_daemon);
|
2016-04-19 23:20:27 +03:00
|
|
|
std::vector<wallet2::pending_tx> create_transactions_all(const cryptonote::account_public_address &address, const size_t fake_outs_count, const uint64_t unlock_time, const uint64_t fee_UNUSED, 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);
|
2014-03-04 00:07:58 +02:00
|
|
|
bool check_connection();
|
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;
|
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);
|
2014-03-04 00:07:58 +02:00
|
|
|
template <class t_archive>
|
|
|
|
inline void serialize(t_archive &a, const unsigned int ver)
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
a & m_refresh_from_block_height;
|
2016-04-20 20:19:42 +03:00
|
|
|
if(ver < 12)
|
|
|
|
return;
|
|
|
|
a & m_tx_notes;
|
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);
|
2014-05-03 19:19:43 +03:00
|
|
|
|
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);
|
|
|
|
|
2014-09-18 00:38:54 +03:00
|
|
|
static std::vector<std::string> addresses_from_url(const std::string& url, bool& dnssec_valid);
|
2014-09-18 00:26:51 +03:00
|
|
|
|
|
|
|
static std::string address_from_txt_record(const std::string& s);
|
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; }
|
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; }
|
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; }
|
2015-07-19 00:03:35 +03:00
|
|
|
|
2015-08-19 22:59:44 +03:00
|
|
|
bool get_tx_key(const crypto::hash &txid, crypto::secret_key &tx_key) const;
|
|
|
|
|
2016-03-11 16:05:36 +02:00
|
|
|
|
2016-03-11 23:31:50 +02:00
|
|
|
bool use_fork_rules(uint8_t version);
|
|
|
|
|
2016-03-11 16:05:36 +02:00
|
|
|
std::string get_wallet_file() const;
|
|
|
|
std::string get_keys_file() const;
|
2016-04-17 13:20:44 +03:00
|
|
|
|
|
|
|
std::vector<size_t> select_available_outputs_from_histogram(uint64_t count, bool atleast, bool trusted_daemon);
|
|
|
|
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);
|
|
|
|
|
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;
|
|
|
|
|
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);
|
2016-04-19 23:18:43 +03:00
|
|
|
void process_new_transaction(const cryptonote::transaction& tx, uint64_t height, uint64_t ts, bool miner_tx);
|
2015-11-22 17:18:36 +02:00
|
|
|
void process_new_blockchain_entry(const cryptonote::block& b, const cryptonote::block_complete_entry& bche, const crypto::hash& bl_id, uint64_t height);
|
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 is_transfer_unlocked(const transfer_details& td) const;
|
|
|
|
bool clear();
|
2015-11-27 02:35:41 +02: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);
|
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);
|
2015-12-30 14:43:15 +02: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, bool &error);
|
2015-11-27 02:03:43 +02:00
|
|
|
void process_blocks(uint64_t start_height, const std::list<cryptonote::block_complete_entry> &blocks, uint64_t& blocks_added);
|
2016-04-02 15:06:39 +03:00
|
|
|
uint64_t select_transfers(uint64_t needed_money, std::vector<size_t> unused_transfers_indices, std::list<transfer_container::iterator>& selected_transfers, bool trusted_daemon);
|
2014-03-04 00:07:58 +02:00
|
|
|
bool prepare_file_names(const std::string& file_path);
|
2015-11-15 23:59:40 +02:00
|
|
|
void process_unconfirmed(const cryptonote::transaction& tx, uint64_t height);
|
2016-04-19 23:18:43 +03:00
|
|
|
void process_outgoing(const cryptonote::transaction& tx, uint64_t height, uint64_t ts, uint64_t spent, uint64_t received);
|
2015-11-22 14:13:59 +02:00
|
|
|
void add_unconfirmed_tx(const cryptonote::transaction& tx, 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;
|
2015-11-22 17:18:36 +02:00
|
|
|
void check_acc_out(const cryptonote::account_keys &acc, const cryptonote::tx_out &o, const crypto::public_key &tx_pub_key, size_t i, uint64_t &money_transfered, bool &error) const;
|
|
|
|
void parse_block_round(const cryptonote::blobdata &blob, cryptonote::block &bl, crypto::hash &bl_id, bool &error) const;
|
2016-01-10 13:56:13 +02:00
|
|
|
uint64_t get_upper_tranaction_size_limit();
|
2016-01-29 21:44:48 +02:00
|
|
|
void check_pending_txes();
|
2016-03-26 23:15:47 +02:00
|
|
|
std::vector<uint64_t> get_unspent_amounts_vector();
|
2014-03-04 00:07:58 +02:00
|
|
|
|
|
|
|
cryptonote::account_base m_account;
|
|
|
|
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;
|
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;
|
|
|
|
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;
|
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;
|
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;
|
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;
|
2014-03-04 00:07:58 +02:00
|
|
|
};
|
|
|
|
}
|
2016-04-20 20:19:42 +03:00
|
|
|
BOOST_CLASS_VERSION(tools::wallet2, 12)
|
2016-04-19 23:18:43 +03:00
|
|
|
BOOST_CLASS_VERSION(tools::wallet2::payment_details, 1)
|
|
|
|
BOOST_CLASS_VERSION(tools::wallet2::unconfirmed_transfer_details, 3)
|
|
|
|
BOOST_CLASS_VERSION(tools::wallet2::confirmed_transfer_details, 2)
|
2014-03-04 00:07:58 +02:00
|
|
|
|
|
|
|
namespace boost
|
|
|
|
{
|
|
|
|
namespace serialization
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
a & x.m_tx;
|
|
|
|
a & x.m_spent;
|
|
|
|
a & x.m_key_image;
|
|
|
|
}
|
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;
|
|
|
|
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;
|
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;
|
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;
|
|
|
|
}
|
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
|
|
|
|
|
|
|
BOOST_FOREACH(auto& de, dsts)
|
|
|
|
{
|
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
|
|
|
|
2016-01-10 13:56:13 +02:00
|
|
|
uint64_t upper_transaction_size_limit = get_upper_tranaction_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
|
2014-03-04 00:07:58 +02:00
|
|
|
BOOST_FOREACH(auto& dt, dsts)
|
|
|
|
{
|
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
|
2014-03-04 00:07:58 +02:00
|
|
|
std::list<transfer_container::iterator> 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
|
|
|
|
BOOST_FOREACH(transfer_container::iterator it, selected_transfers)
|
|
|
|
{
|
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();
|
2014-05-25 20:06:40 +03:00
|
|
|
bool r = epee::net_utils::invoke_http_bin_remote_command2(m_daemon_address + "/getrandom_outs.bin", req, daemon_resp, m_http_client, 200000);
|
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()));
|
|
|
|
|
|
|
|
std::vector<COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::outs_for_amount> scanty_outs;
|
2014-03-20 13:46:11 +02:00
|
|
|
BOOST_FOREACH(COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::outs_for_amount& amount_outs, daemon_resp.outs)
|
|
|
|
{
|
2014-04-02 19:00:17 +03:00
|
|
|
if (amount_outs.outs.size() < fake_outputs_count)
|
2014-03-20 13:46:11 +02:00
|
|
|
{
|
2014-04-02 19:00:17 +03:00
|
|
|
scanty_outs.push_back(amount_outs);
|
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;
|
|
|
|
BOOST_FOREACH(transfer_container::iterator it, selected_transfers)
|
|
|
|
{
|
|
|
|
sources.resize(sources.size()+1);
|
|
|
|
cryptonote::tx_source_entry& src = sources.back();
|
|
|
|
transfer_details& td = *it;
|
|
|
|
src.amount = td.amount();
|
|
|
|
//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;});
|
|
|
|
BOOST_FOREACH(out_entry& daemon_oe, daemon_resp.outs[i].outs)
|
|
|
|
{
|
|
|
|
if(td.m_global_output_index == daemon_oe.global_amount_index)
|
|
|
|
continue;
|
|
|
|
tx_output_entry oe;
|
|
|
|
oe.first = daemon_oe.global_amount_index;
|
|
|
|
oe.second = daemon_oe.out_key;
|
|
|
|
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;
|
|
|
|
real_oe.second = boost::get<txout_to_key>(td.m_tx.vout[td.m_internal_output_index].target).key;
|
|
|
|
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);
|
|
|
|
BOOST_FOREACH(auto& d, dust_dsts) {
|
|
|
|
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));
|
|
|
|
}
|
|
|
|
BOOST_FOREACH(auto& d, dust_dsts) {
|
|
|
|
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;
|
2015-08-19 22:59:44 +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;
|
2014-06-16 03:36:44 +03:00
|
|
|
}
|
2014-03-04 00:07:58 +02:00
|
|
|
|
|
|
|
|
|
|
|
}
|