+// Copyright (c) 2018 The Bitcoin Core developers

+// Distributed under the MIT software license, see the accompanying

+// file COPYING or http://www.opensource.org/licenses/mit-license.php.

+

+#include <wallet/coincontrol.h>

+

+#include <util.h>

+

+void CCoinControl::SetNull()

+{

+ destChange = CNoDestination();

+ m_change_type.reset();

+ fAllowOtherInputs = false;

+ fAllowWatchOnly = false;

+ m_avoid_partial_spends = gArgs.GetBoolArg("-avoidpartialspends", DEFAULT_AVOIDPARTIALSPENDS);

+ setSelected.clear();

+ m_feerate.reset();

+ fOverrideFeeRate = false;

+ m_confirm_target.reset();

+ m_signal_bip125_rbf.reset();

+ m_fee_mode = FeeEstimateMode::UNSET;

+}

+

+// Copyright (c) 2011-2018 The Bitcoin Core developers

+ //! Avoid partial use of funds sent to a given address

+ bool m_avoid_partial_spends;

+ void SetNull();

+// Copyright (c) 2017-2018 The Bitcoin Core developers

+

+#include <boost/optional.hpp>

+

+ bool operator()(const OutputGroup& a, const OutputGroup& b) const

+bool SelectCoinsBnB(std::vector<OutputGroup>& utxo_pool, const CAmount& target_value, const CAmount& cost_of_change, std::set<CInputCoin>& out_set, CAmount& value_ret, CAmount not_input_fees)

+ for (const OutputGroup& utxo : utxo_pool) {

+ }

+ OutputGroup& utxo = utxo_pool.at(curr_selection.size() - 1);

+ OutputGroup& utxo = utxo_pool.at(curr_selection.size());

+ util::insert(out_set, utxo_pool.at(i).m_outputs);

+ value_ret += utxo_pool.at(i).m_value;

+static void ApproximateBestSubset(const std::vector<OutputGroup>& groups, const CAmount& nTotalLower, const CAmount& nTargetValue,

+ vfBest.assign(groups.size(), true);

+ vfIncluded.assign(groups.size(), false);

+ for (unsigned int i = 0; i < groups.size(); i++)

+ nTotal += groups[i].m_value;

+ nTotal -= groups[i].m_value;

+bool KnapsackSolver(const CAmount& nTargetValue, std::vector<OutputGroup>& groups, std::set<CInputCoin>& setCoinsRet, CAmount& nValueRet)

+ boost::optional<OutputGroup> lowest_larger;

+ std::vector<OutputGroup> applicable_groups;

+ random_shuffle(groups.begin(), groups.end(), GetRandInt);

+ for (const OutputGroup& group : groups) {

+ if (group.m_value == nTargetValue) {

+ util::insert(setCoinsRet, group.m_outputs);

+ nValueRet += group.m_value;

+ } else if (group.m_value < nTargetValue + MIN_CHANGE) {

+ applicable_groups.push_back(group);

+ nTotalLower += group.m_value;

+ } else if (!lowest_larger || group.m_value < lowest_larger->m_value) {

+ lowest_larger = group;

+ if (nTotalLower == nTargetValue) {

+ for (const auto& group : applicable_groups) {

+ util::insert(setCoinsRet, group.m_outputs);

+ nValueRet += group.m_value;

+ if (nTotalLower < nTargetValue) {

+ if (!lowest_larger) return false;

+ util::insert(setCoinsRet, lowest_larger->m_outputs);

+ nValueRet += lowest_larger->m_value;

+ std::sort(applicable_groups.begin(), applicable_groups.end(), descending);

+ ApproximateBestSubset(applicable_groups, nTotalLower, nTargetValue, vfBest, nBest);

+ if (nBest != nTargetValue && nTotalLower >= nTargetValue + MIN_CHANGE) {

+ ApproximateBestSubset(applicable_groups, nTotalLower, nTargetValue + MIN_CHANGE, vfBest, nBest);

+ }

+ if (lowest_larger &&

+ ((nBest != nTargetValue && nBest < nTargetValue + MIN_CHANGE) || lowest_larger->m_value <= nBest)) {

+ util::insert(setCoinsRet, lowest_larger->m_outputs);

+ nValueRet += lowest_larger->m_value;

+ } else {

+ for (unsigned int i = 0; i < applicable_groups.size(); i++) {

+ if (vfBest[i]) {

+ util::insert(setCoinsRet, applicable_groups[i].m_outputs);

+ nValueRet += applicable_groups[i].m_value;

+ }

+ for (unsigned int i = 0; i < applicable_groups.size(); i++) {

+ LogPrint(BCLog::SELECTCOINS, "%s ", FormatMoney(applicable_groups[i].m_value)); /* Continued */

+

+/******************************************************************************

+

+ OutputGroup

+

+ ******************************************************************************/

+

+void OutputGroup::Insert(const CInputCoin& output, int depth, bool from_me, size_t ancestors, size_t descendants) {

+ m_outputs.push_back(output);

+ m_from_me &= from_me;

+ m_value += output.effective_value;

+ m_depth = std::min(m_depth, depth);

+ // ancestors here express the number of ancestors the new coin will end up having, which is

+ // the sum, rather than the max; this will overestimate in the cases where multiple inputs

+ // have common ancestors

+ m_ancestors += ancestors;

+ // descendants is the count as seen from the top ancestor, not the descendants as seen from the

+ // coin itself; thus, this value is counted as the max, not the sum

+ m_descendants = std::max(m_descendants, descendants);

+ effective_value = m_value;

+}

+

+std::vector<CInputCoin>::iterator OutputGroup::Discard(const CInputCoin& output) {

+ auto it = m_outputs.begin();

+ while (it != m_outputs.end() && it->outpoint != output.outpoint) ++it;

+ if (it == m_outputs.end()) return it;

+ m_value -= output.effective_value;

+ effective_value -= output.effective_value;

+ return m_outputs.erase(it);

+}

+

+bool OutputGroup::EligibleForSpending(const CoinEligibilityFilter& eligibility_filter) const

+{

+ return m_depth >= (m_from_me ? eligibility_filter.conf_mine : eligibility_filter.conf_theirs)

+ && m_ancestors <= eligibility_filter.max_ancestors

+ && m_descendants <= eligibility_filter.max_descendants;

+}

+// Copyright (c) 2017-2018 The Bitcoin Core developers

+ CInputCoin(const CTransactionRef& tx, unsigned int i, int input_bytes) : CInputCoin(tx, i)

+ {

+ m_input_bytes = input_bytes;

+ }

+

+

+ /** Pre-computed estimated size of this output as a fully-signed input in a transaction. Can be -1 if it could not be calculated */

+ int m_input_bytes{-1};

+struct CoinEligibilityFilter

+{

+ const int conf_mine;

+ const int conf_theirs;

+ const uint64_t max_ancestors;

+ const uint64_t max_descendants;

+

+ CoinEligibilityFilter(int conf_mine, int conf_theirs, uint64_t max_ancestors) : conf_mine(conf_mine), conf_theirs(conf_theirs), max_ancestors(max_ancestors), max_descendants(max_ancestors) {}

+ CoinEligibilityFilter(int conf_mine, int conf_theirs, uint64_t max_ancestors, uint64_t max_descendants) : conf_mine(conf_mine), conf_theirs(conf_theirs), max_ancestors(max_ancestors), max_descendants(max_descendants) {}

+};

+

+struct OutputGroup

+{

+ std::vector<CInputCoin> m_outputs;

+ bool m_from_me{true};

+ CAmount m_value{0};

+ int m_depth{999};

+ size_t m_ancestors{0};

+ size_t m_descendants{0};

+ CAmount effective_value{0};

+ CAmount fee{0};

+ CAmount long_term_fee{0};

+

+ OutputGroup() {}

+ OutputGroup(std::vector<CInputCoin>&& outputs, bool from_me, CAmount value, int depth, size_t ancestors, size_t descendants)

+ : m_outputs(std::move(outputs))

+ , m_from_me(from_me)

+ , m_value(value)

+ , m_depth(depth)

+ , m_ancestors(ancestors)

+ , m_descendants(descendants)

+ {}

+ OutputGroup(const CInputCoin& output, int depth, bool from_me, size_t ancestors, size_t descendants) : OutputGroup() {

+ Insert(output, depth, from_me, ancestors, descendants);

+ }

+ void Insert(const CInputCoin& output, int depth, bool from_me, size_t ancestors, size_t descendants);

+ std::vector<CInputCoin>::iterator Discard(const CInputCoin& output);

+ bool EligibleForSpending(const CoinEligibilityFilter& eligibility_filter) const;

+};

+

+bool SelectCoinsBnB(std::vector<OutputGroup>& utxo_pool, const CAmount& target_value, const CAmount& cost_of_change, std::set<CInputCoin>& out_set, CAmount& value_ret, CAmount not_input_fees);

+bool KnapsackSolver(const CAmount& nTargetValue, std::vector<OutputGroup>& groups, std::set<CInputCoin>& setCoinsRet, CAmount& nValueRet);

+

+// Copyright (c) 2009-2018 The Bitcoin Core developers

+ for (const KeyMap::value_type& mKey : mapKeys)

+// Copyright (c) 2009-2018 The Bitcoin Core developers

+ CKeyingMaterial vMasterKey GUARDED_BY(cs_KeyStore);

+ using CryptedKeyMap = std::map<CKeyID, std::pair<CPubKey, std::vector<unsigned char>>>;

+

+ CryptedKeyMap mapCryptedKeys GUARDED_BY(cs_KeyStore);

+// Copyright (c) 2009-2018 The Bitcoin Core developers

+ // Note: An unused temporary BerkeleyEnvironment object may be created inside the

+ for (const auto& env : g_dbenvs) {

+ env->m_db_in_use.notify_all();

+void BerkeleyEnvironment::ReloadDbEnv()

+{

+ // Make sure that no Db's are in use

+ AssertLockNotHeld(cs_db);

+ std::unique_lock<CCriticalSection> lock(cs_db);

+ m_db_in_use.wait(lock, [this](){

+ for (auto& count : mapFileUseCount) {

+ if (count.second > 0) return false;

+ }

+ return true;

+ });

+

+ std::vector<std::string> filenames;

+ for (auto it : mapDb) {

+ filenames.push_back(it.first);

+ }

+ // Close the individual Db's

+ for (const std::string& filename : filenames) {

+ CloseDb(filename);

+ }

+ // Reset the environment

+ Flush(true); // This will flush and close the environment

+ Reset();

+ Open(true);

+}

+

+ if (!fMockDb) {

+ }

+ fs::path pathSrc = env->Directory() / strFile;

+ LogPrintf("error copying %s to %s - %s\n", strFile, pathDest.string(), fsbridge::get_filesystem_error_message(e));

+ if (shutdown) {

+ LOCK(cs_db);

+ g_dbenvs.erase(env->Directory().string());

+ env = nullptr;

+ }

+ }

+}

+

+void BerkeleyDatabase::ReloadDbEnv()

+{

+ if (!IsDummy()) {

+ env->ReloadDbEnv();

+// Copyright (c) 2009-2018 The Bitcoin Core developers

+ std::condition_variable_any m_db_in_use;

+ void ReloadDbEnv();

+ void ReloadDbEnv();

+

+// Copyright (c) 2017-2018 The Bitcoin Core developers

+static feebumper::Result PreconditionChecks(const CWallet* wallet, const CWalletTx& wtx, std::vector<std::string>& errors) EXCLUSIVE_LOCKS_REQUIRED(cs_main, wallet->cs_wallet)

+ wallet->WalletLogPrintf("Bumping fee and discarding dust output\n");

+ if (!wallet->CommitTransaction(tx, std::move(mapValue), oldWtx.vOrderForm, reservekey, g_connman.get(), state)) {

+// Copyright (c) 2017-2018 The Bitcoin Core developers

+// Copyright (c) 2009-2018 The Bitcoin Core developers

+// Copyright (c) 2009-2018 The Bitcoin Core developers

+// Copyright (c) 2009-2018 The Bitcoin Core developers

+#include <outputtype.h>

+ //! Was the wallet component compiled in.

+ bool HasWalletSupport() const override {return true;}

+

+ gArgs.AddArg("-avoidpartialspends", strprintf(_("Group outputs by address, selecting all or none, instead of selecting on a per-output basis. Privacy is improved as an address is only used once (unless someone sends to it after spending from it), but may result in slightly higher fees as suboptimal coin selection may result due to the added limitation (default: %u)"), DEFAULT_AVOIDPARTIALSPENDS), false, OptionsCategory::WALLET);

+ " (1 = keep tx meta data e.g. payment request information, 2 = drop tx meta data)", false, OptionsCategory::WALLET);

+ for (const auto& wallet_file : wallet_files) {

+// Copyright (c) 2009-2018 The Bitcoin Core developers

+ for (const unsigned char c : str) {

+static const int64_t TIMESTAMP_MIN = 0;

+

+static void RescanWallet(CWallet& wallet, const WalletRescanReserver& reserver, int64_t time_begin = TIMESTAMP_MIN, bool update = true)

+{

+ int64_t scanned_time = wallet.RescanFromTime(time_begin, reserver, update);

+ if (wallet.IsAbortingRescan()) {

+ throw JSONRPCError(RPC_MISC_ERROR, "Rescan aborted by user.");

+ } else if (scanned_time > time_begin) {

+ throw JSONRPCError(RPC_WALLET_ERROR, "Rescan was unable to fully rescan the blockchain. Some transactions may be missing.");

+ }

+}

+ "\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\n"

+ RescanWallet(*pwallet, reserver);

+ "\nAdds an address or script (in hex) that can be watched as if it were in your wallet but cannot be used to spend. Requires a new wallet backup.\n"

+ "1. \"address\" (string, required) The Bitcoin address (or hex-encoded script)\n"

+ "\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\n"

+ "\nImport an address with rescan\n"

+ + HelpExampleCli("importaddress", "\"myaddress\"") +

+ + HelpExampleCli("importaddress", "\"myaddress\" \"testing\" false") +

+ + HelpExampleRpc("importaddress", "\"myaddress\", \"testing\", false")

+ RescanWallet(*pwallet, reserver);

+ if (request.fHelp || request.params.size() < 1 || request.params.size() > 3)

+ "\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\n"

+ RescanWallet(*pwallet, reserver);

+ uiInterface.ShowProgress(strprintf("%s " + _("Importing..."), pwallet->GetDisplayName()), 0, false); // show progress dialog in GUI

+ pwallet->WalletLogPrintf("Skipping import of %s (key already present)\n", EncodeDestination(keyid));

+ if (vstr[nStr].front() == '#')

+ if (vstr[nStr].substr(0,6) == "label=") {

+ pwallet->WalletLogPrintf("Importing %s...\n", EncodeDestination(keyid));

+ pwallet->WalletLogPrintf("Skipping import of %s (script already present)\n", vstr[0]);

+ pwallet->WalletLogPrintf("Error importing script %s\n", vstr[0]);

+ RescanWallet(*pwallet, reserver, nTimeBegin, false /* update */);

+ fs::path filepath = request.params[0].get_str();

+ filepath = fs::absolute(filepath);

+ if (fs::exists(filepath)) {

+ if (!ExtractDestination(script, dest) && !internal) {

+ throw JSONRPCError(RPC_INVALID_PARAMETER, "Internal must be set to true for nonstandard scriptPubKey imports.");

+ }

+ if (!(pubkey_dest == dest)) {

+ if (!(pubkey_dest == dest)) {

+ // add to address book or update label

+ if (IsValidDestination(dest)) {

+ pwallet->SetAddressBook(dest, label, "receive");

+ " \"label\": <label> , (string, optional, default: '') Label to assign to the address, only allowed with internal=false\n"

+ "\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\n"

+// Copyright (c) 2009-2018 The Bitcoin Core developers

+#include <outputtype.h>

+#include <shutdown.h>

+bool GetWalletNameFromJSONRPCRequest(const JSONRPCRequest& request, std::string& wallet_name)

+ wallet_name = urlDecode(request.URI.substr(WALLET_ENDPOINT_BASE.size()));

+ return true;

+ }

+ return false;

+}

+

+std::shared_ptr<CWallet> GetWalletForJSONRPCRequest(const JSONRPCRequest& request)

+{

+ std::string wallet_name;

+ if (GetWalletNameFromJSONRPCRequest(request, wallet_name)) {

+ std::shared_ptr<CWallet> pwallet = GetWallet(wallet_name);

+static void WalletTxToJSON(const CWalletTx& wtx, UniValue& entry) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

+ for (const std::pair<const std::string, std::string>& item : wtx.mapValue)

+ if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {

+ throw JSONRPCError(RPC_WALLET_ERROR, "Error: Private keys are disabled for this wallet");

+ }

+

+ LOCK(pwallet->cs_wallet);

+ if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {

+ throw JSONRPCError(RPC_WALLET_ERROR, "Error: Private keys are disabled for this wallet");

+ }

+

+ LOCK(pwallet->cs_wallet);

+ LOCK(pwallet->cs_wallet);

+static CTransactionRef SendMoney(CWallet * const pwallet, const CTxDestination &address, CAmount nValue, bool fSubtractFeeFromAmount, const CCoinControl& coin_control, mapValue_t mapValue)

+ if (!pwallet->CommitTransaction(tx, std::move(mapValue), {} /* orderForm */, reservekey, g_connman.get(), state)) {

+ CTransactionRef tx = SendMoney(pwallet, dest, nAmount, fSubtractFeeFromAmount, coin_control, std::move(mapValue));

+ for (const std::pair<const uint256, CWalletTx>& pairWtx : pwallet->mapWallet) {

+ for (const std::pair<const uint256, CWalletTx>& pairWtx : pwallet->mapWallet) {

+ if (request.fHelp || (request.params.size() > 3 ))

+ "getbalance ( \"(dummy)\" minconf include_watchonly )\n"

+ "\nReturns the total available balance.\n"

+ "1. (dummy) (string, optional) Remains for backward compatibility. Must be excluded or set to \"*\".\n"

+ "2. minconf (numeric, optional, default=0) Only include transactions confirmed at least this many times.\n"

+ "3. include_watchonly (bool, optional, default=false) Also include balance in watch-only addresses (see 'importaddress')\n"

+ "amount (numeric) The total amount in " + CURRENCY_UNIT + " received for this wallet.\n"

+ const UniValue& dummy_value = request.params[0];

+ if (!dummy_value.isNull() && dummy_value.get_str() != "*") {

+ throw JSONRPCError(RPC_METHOD_DEPRECATED, "dummy first argument must be excluded or set to \"*\".");

+ }

+ int min_depth = 0;

+ if (!request.params[1].isNull()) {

+ min_depth = request.params[1].get_int();

+ }

+ isminefilter filter = ISMINE_SPENDABLE;

+ if (!request.params[2].isNull() && request.params[2].get_bool()) {

+ filter = filter | ISMINE_WATCH_ONLY;

+ return ValueFromAmount(pwallet->GetBalance(filter, min_depth));

+ if (request.fHelp || request.params.size() < 2 || request.params.size() > 8)

+ throw std::runtime_error(

+ "sendmany \"\" {\"address\":amount,...} ( minconf \"comment\" [\"address\",...] replaceable conf_target \"estimate_mode\")\n"

+ + HelpExampleRpc("sendmany", "\"\", {\"1D1ZrZNe3JUo7ZycKEYQQiQAWd9y54F4XX\":0.01,\"1353tsE8YMTA4EuV7dgUXGjNFf9KpVvKHz\":0.02}, 6, \"testing\"")

+ );

+ if (!request.params[0].isNull() && !request.params[0].get_str().empty()) {

+ if (totalAmount > pwallet->GetLegacyBalance(ISMINE_SPENDABLE, nMinDepth)) {

+ throw JSONRPCError(RPC_WALLET_INSUFFICIENT_FUNDS, "Wallet has insufficient funds");

+ }

+ if (!pwallet->CommitTransaction(tx, std::move(mapValue), {} /* orderForm */, keyChange, g_connman.get(), state)) {

+ CTxDestination dest = AddAndGetDestinationForScript(*pwallet, inner, output_type);

+static UniValue ListReceived(CWallet * const pwallet, const UniValue& params, bool by_label) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

+ for (const std::pair<const uint256, CWalletTx>& pairWtx : pwallet->mapWallet) {

+static void ListTransactions(CWallet* const pwallet, const CWalletTx& wtx, int nMinDepth, bool fLong, UniValue& ret, const isminefilter& filter) EXCLUSIVE_LOCKS_REQUIRED(cs_main)

+ wtx.GetAmounts(listReceived, listSent, nFee, filter);

+ if ((!listSent.empty() || nFee != 0))

+ std::string label;

+ label = pwallet->mapAddressBook[r.destination].name;

+ UniValue entry(UniValue::VOBJ);

+ if (involvesWatchonly || (::IsMine(*pwallet, r.destination) & ISMINE_WATCH_ONLY)) {

+ entry.pushKV("involvesWatchonly", true);

+ }

+ MaybePushAddress(entry, r.destination);

+ if (wtx.IsCoinBase())

+ if (wtx.GetDepthInMainChain() < 1)

+ entry.pushKV("category", "orphan");

+ else if (wtx.IsImmatureCoinBase())

+ entry.pushKV("category", "immature");

+ entry.pushKV("category", "generate");

+ else

+ {

+ entry.pushKV("category", "receive");

+ }

+ entry.pushKV("amount", ValueFromAmount(r.amount));

+ if (pwallet->mapAddressBook.count(r.destination)) {

+ entry.pushKV("label", label);

+ }

+ entry.pushKV("vout", r.vout);

+ if (fLong)

+ WalletTxToJSON(wtx, entry);

+ ret.push_back(entry);

+ if (request.fHelp || request.params.size() > 4)

+ throw std::runtime_error(

+ "listtransactions (dummy count skip include_watchonly)\n"

+ "\nReturns up to 'count' most recent transactions skipping the first 'from' transactions.\n"

+ + HelpExampleRpc("listtransactions", "\"*\", 20, 100")

+ );

+ if (!request.params[0].isNull() && request.params[0].get_str() != "*") {

+ throw JSONRPCError(RPC_INVALID_PARAMETER, "Dummy value must be set to \"*\"");

+ CWalletTx *const pwtx = (*it).second;

+ ListTransactions(pwallet, *pwtx, 0, true, ret, filter);

+ for (const std::pair<const uint256, CWalletTx>& pairWtx : pwallet->mapWallet) {

+ ListTransactions(pwallet, tx, 0, true, transactions, filter);

+ ListTransactions(pwallet, it->second, -100000000, true, removed, filter);

+ ListTransactions(pwallet, wtx, 0, false, details, filter);

+ if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {

+ throw JSONRPCError(RPC_WALLET_ERROR, "Error: Private keys are disabled for this wallet");

+ }

+

+ return "wallet encrypted; The keypool has been flushed and a new HD seed was generated (if you are using HD). You need to make a new backup.";

+ for (const COutPoint& outpt : vOutpts) {

+ CFeeRate tx_fee_rate(nAmount, 1000);

+ if (tx_fee_rate == 0) {

+ // automatic selection

+ } else if (tx_fee_rate < ::minRelayTxFee) {

+ throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("txfee cannot be less than min relay tx fee (%s)", ::minRelayTxFee.ToString()));

+ } else if (tx_fee_rate < pwallet->m_min_fee) {

+ throw JSONRPCError(RPC_INVALID_PARAMETER, strprintf("txfee cannot be less than wallet min fee (%s)", pwallet->m_min_fee.ToString()));

+ }

+ pwallet->m_pay_tx_fee = tx_fee_rate;

+ " \"walletname\": xxxxx, (string) the wallet name\n"

+ " \"walletversion\": xxxxx, (numeric) the wallet version\n"

+ " \"balance\": xxxxxxx, (numeric) the total confirmed balance of the wallet in " + CURRENCY_UNIT + "\n"

+ " \"unconfirmed_balance\": xxx, (numeric) the total unconfirmed balance of the wallet in " + CURRENCY_UNIT + "\n"

+ " \"immature_balance\": xxxxxx, (numeric) the total immature balance of the wallet in " + CURRENCY_UNIT + "\n"

+ " \"txcount\": xxxxxxx, (numeric) the total number of transactions in the wallet\n"

+ " \"keypoololdest\": xxxxxx, (numeric) the timestamp (seconds since Unix epoch) of the oldest pre-generated key in the key pool\n"

+ " \"keypoolsize\": xxxx, (numeric) how many new keys are pre-generated (only counts external keys)\n"

+ " \"keypoolsize_hd_internal\": xxxx, (numeric) how many new keys are pre-generated for internal use (used for change outputs, only appears if the wallet is using this feature, otherwise external keys are used)\n"

+ " \"unlocked_until\": ttt, (numeric) the timestamp in seconds since epoch (midnight Jan 1 1970 GMT) that the wallet is unlocked for transfers, or 0 if the wallet is locked\n"

+ " \"paytxfee\": x.xxxx, (numeric) the transaction fee configuration, set in " + CURRENCY_UNIT + "/kB\n"

+ " \"hdseedid\": \"<hash160>\" (string, optional) the Hash160 of the HD seed (only present when HD is enabled)\n"

+ " \"hdmasterkeyid\": \"<hash160>\" (string, optional) alias for hdseedid retained for backwards-compatibility. Will be removed in V0.18.\n"

+ " \"private_keys_enabled\": true|false (boolean) false if privatekeys are disabled for this wallet (enforced watch-only wallet)\n"

+ obj.pushKV("private_keys_enabled", !pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));

+static UniValue loadwallet(const JSONRPCRequest& request)

+ } else if (fs::is_directory(wallet_path)) {

+ // The given filename is a directory. Check that there's a wallet.dat file.

+ fs::path wallet_dat_file = wallet_path / "wallet.dat";

+ if (fs::symlink_status(wallet_dat_file).type() == fs::file_not_found) {

+ throw JSONRPCError(RPC_WALLET_NOT_FOUND, "Directory " + wallet_file + " does not contain a wallet.dat file.");

+ }

+static UniValue createwallet(const JSONRPCRequest& request)

+ if (request.fHelp || request.params.size() < 1 || request.params.size() > 2) {

+ "createwallet \"wallet_name\" ( disable_private_keys )\n"

+ "1. \"wallet_name\" (string, required) The name for the new wallet. If this is a path, the wallet will be created at the path location.\n"

+ "2. disable_private_keys (boolean, optional, default: false) Disable the possibility of private keys (only watchonlys are possible in this mode).\n"

+ bool disable_privatekeys = false;

+ if (!request.params[1].isNull()) {

+ disable_privatekeys = request.params[1].get_bool();

+ }

+

+ std::shared_ptr<CWallet> const wallet = CWallet::CreateWalletFromFile(wallet_name, fs::absolute(wallet_name, GetWalletDir()), (disable_privatekeys ? (uint64_t)WALLET_FLAG_DISABLE_PRIVATE_KEYS : 0));

+static UniValue unloadwallet(const JSONRPCRequest& request)

+{

+ if (request.fHelp || request.params.size() > 1) {

+ throw std::runtime_error(

+ "unloadwallet ( \"wallet_name\" )\n"

+ "Unloads the wallet referenced by the request endpoint otherwise unloads the wallet specified in the argument.\n"

+ "Specifying the wallet name on a wallet endpoint is invalid."

+ "\nArguments:\n"

+ "1. \"wallet_name\" (string, optional) The name of the wallet to unload.\n"

+ "\nExamples:\n"

+ + HelpExampleCli("unloadwallet", "wallet_name")

+ + HelpExampleRpc("unloadwallet", "wallet_name")

+ );

+ }

+

+ std::string wallet_name;

+ if (GetWalletNameFromJSONRPCRequest(request, wallet_name)) {

+ if (!request.params[0].isNull()) {

+ throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot unload the requested wallet");

+ }

+ } else {

+ wallet_name = request.params[0].get_str();

+ }

+

+ std::shared_ptr<CWallet> wallet = GetWallet(wallet_name);

+ if (!wallet) {

+ throw JSONRPCError(RPC_WALLET_NOT_FOUND, "Requested wallet does not exist or is not loaded");

+ }

+

+ // Release the "main" shared pointer and prevent further notifications.

+ // Note that any attempt to load the same wallet would fail until the wallet

+ // is destroyed (see CheckUniqueFileid).

+ if (!RemoveWallet(wallet)) {

+ throw JSONRPCError(RPC_MISC_ERROR, "Requested wallet already unloaded");

+ }

+ UnregisterValidationInterface(wallet.get());

+

+ // The wallet can be in use so it's not possible to explicitly unload here.

+ // Just notify the unload intent so that all shared pointers are released.

+ // The wallet will be destroyed once the last shared pointer is released.

+ wallet->NotifyUnload();

+

+ // There's no point in waiting for the wallet to unload.

+ // At this point this method should never fail. The unloading could only

+ // fail due to an unexpected error which would cause a process termination.

+

+ return NullUniValue;

+}

+

+void FundTransaction(CWallet* const pwallet, CMutableTransaction& tx, CAmount& fee_out, int& change_position, UniValue options)

+ change_position = -1;

+ if (!options.isNull()) {

+ if (options.type() == UniValue::VBOOL) {

+ coinControl.fAllowWatchOnly = options.get_bool();

+ RPCTypeCheckArgument(options, UniValue::VOBJ);

+ change_position = options["changePosition"].get_int();

+ if (change_position != -1 && (change_position < 0 || (unsigned int)change_position > tx.vout.size()))

+ if (!pwallet->FundTransaction(tx, fee_out, change_position, strFailReason, lockUnspents, setSubtractFeeFromOutputs, coinControl)) {

+}

+

+static UniValue fundrawtransaction(const JSONRPCRequest& request)

+{

+ std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);

+ CWallet* const pwallet = wallet.get();

+

+ if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {

+ return NullUniValue;

+ }

+

+ if (request.fHelp || request.params.size() < 1 || request.params.size() > 3)

+ throw std::runtime_error(

+ "fundrawtransaction \"hexstring\" ( options iswitness )\n"

+ "\nAdd inputs to a transaction until it has enough in value to meet its out value.\n"

+ "This will not modify existing inputs, and will add at most one change output to the outputs.\n"

+ "No existing outputs will be modified unless \"subtractFeeFromOutputs\" is specified.\n"

+ "Note that inputs which were signed may need to be resigned after completion since in/outputs have been added.\n"

+ "The inputs added will not be signed, use signrawtransaction for that.\n"

+ "Note that all existing inputs must have their previous output transaction be in the wallet.\n"

+ "Note that all inputs selected must be of standard form and P2SH scripts must be\n"

+ "in the wallet using importaddress or addmultisigaddress (to calculate fees).\n"

+ "You can see whether this is the case by checking the \"solvable\" field in the listunspent output.\n"

+ "Only pay-to-pubkey, multisig, and P2SH versions thereof are currently supported for watch-only\n"

+ "\nArguments:\n"

+ "1. \"hexstring\" (string, required) The hex string of the raw transaction\n"

+ "2. options (object, optional)\n"

+ " {\n"

+ " \"changeAddress\" (string, optional, default pool address) The bitcoin address to receive the change\n"

+ " \"changePosition\" (numeric, optional, default random) The index of the change output\n"

+ " \"change_type\" (string, optional) The output type to use. Only valid if changeAddress is not specified. Options are \"legacy\", \"p2sh-segwit\", and \"bech32\". Default is set by -changetype.\n"

+ " \"includeWatching\" (boolean, optional, default false) Also select inputs which are watch only\n"

+ " \"lockUnspents\" (boolean, optional, default false) Lock selected unspent outputs\n"

+ " \"feeRate\" (numeric, optional, default not set: makes wallet determine the fee) Set a specific fee rate in " + CURRENCY_UNIT + "/kB\n"

+ " \"subtractFeeFromOutputs\" (array, optional) A json array of integers.\n"

+ " The fee will be equally deducted from the amount of each specified output.\n"

+ " The outputs are specified by their zero-based index, before any change output is added.\n"

+ " Those recipients will receive less bitcoins than you enter in their corresponding amount field.\n"

+ " If no outputs are specified here, the sender pays the fee.\n"

+ " [vout_index,...]\n"

+ " \"replaceable\" (boolean, optional) Marks this transaction as BIP125 replaceable.\n"

+ " Allows this transaction to be replaced by a transaction with higher fees\n"

+ " \"conf_target\" (numeric, optional) Confirmation target (in blocks)\n"

+ " \"estimate_mode\" (string, optional, default=UNSET) The fee estimate mode, must be one of:\n"

+ " \"UNSET\"\n"

+ " \"ECONOMICAL\"\n"

+ " \"CONSERVATIVE\"\n"

+ " }\n"

+ " for backward compatibility: passing in a true instead of an object will result in {\"includeWatching\":true}\n"

+ "3. iswitness (boolean, optional) Whether the transaction hex is a serialized witness transaction \n"

+ " If iswitness is not present, heuristic tests will be used in decoding\n"

+

+ "\nResult:\n"

+ "{\n"

+ " \"hex\": \"value\", (string) The resulting raw transaction (hex-encoded string)\n"

+ " \"fee\": n, (numeric) Fee in " + CURRENCY_UNIT + " the resulting transaction pays\n"

+ " \"changepos\": n (numeric) The position of the added change output, or -1\n"

+ "}\n"

+ "\nExamples:\n"

+ "\nCreate a transaction with no inputs\n"

+ + HelpExampleCli("createrawtransaction", "\"[]\" \"{\\\"myaddress\\\":0.01}\"") +

+ "\nAdd sufficient unsigned inputs to meet the output value\n"

+ + HelpExampleCli("fundrawtransaction", "\"rawtransactionhex\"") +

+ "\nSign the transaction\n"

+ + HelpExampleCli("signrawtransaction", "\"fundedtransactionhex\"") +

+ "\nSend the transaction\n"

+ + HelpExampleCli("sendrawtransaction", "\"signedtransactionhex\"")

+ );

+

+ RPCTypeCheck(request.params, {UniValue::VSTR, UniValueType(), UniValue::VBOOL});

+

+ // parse hex string from parameter

+ CMutableTransaction tx;

+ bool try_witness = request.params[2].isNull() ? true : request.params[2].get_bool();

+ bool try_no_witness = request.params[2].isNull() ? true : !request.params[2].get_bool();

+ if (!DecodeHexTx(tx, request.params[0].get_str(), try_no_witness, try_witness)) {

+ throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "TX decode failed");

+ }

+

+ CAmount fee;

+ int change_position;

+ FundTransaction(pwallet, tx, fee, change_position, request.params[1]);

+ result.pushKV("fee", ValueFromAmount(fee));

+ result.pushKV("changepos", change_position);

+ txnouttype which_type = Solver(subscript, solutions_data);

+ " \"embedded\" : {...}, (object, optional) Information about the address embedded in P2SH or P2WSH, if relevant and known. It includes all getaddressinfo output fields for the embedded address, excluding metadata (\"timestamp\", \"hdkeypath\", \"hdseedid\") and relation to the wallet (\"ismine\", \"iswatchonly\").\n"

+ " \"label\" : \"label\" (string) The label associated with the address, \"\" is the default label\n"

+ for (const std::pair<const CTxDestination, CAddressBookData>& item : pwallet->mapAddressBook) {

+ for (const std::pair<const CTxDestination, CAddressBookData>& entry : pwallet->mapAddressBook) {

+void AddKeypathToMap(const CWallet* pwallet, const CKeyID& keyID, std::map<CPubKey, KeyOriginInfo>& hd_keypaths)

+{

+ CPubKey vchPubKey;

+ if (!pwallet->GetPubKey(keyID, vchPubKey)) {

+ return;

+ }

+ KeyOriginInfo info;

+ if (!pwallet->GetKeyOrigin(keyID, info)) {

+ throw JSONRPCError(RPC_INTERNAL_ERROR, "Internal keypath is broken");

+ }

+ hd_keypaths.emplace(vchPubKey, std::move(info));

+}

+

+bool FillPSBT(const CWallet* pwallet, PartiallySignedTransaction& psbtx, const CTransaction* txConst, int sighash_type, bool sign, bool bip32derivs)

+{

+ LOCK(pwallet->cs_wallet);

+ // Get all of the previous transactions

+ bool complete = true;

+ for (unsigned int i = 0; i < txConst->vin.size(); ++i) {

+ const CTxIn& txin = txConst->vin[i];

+ PSBTInput& input = psbtx.inputs.at(i);

+

+ // If we don't know about this input, skip it and let someone else deal with it

+ const uint256& txhash = txin.prevout.hash;

+ const auto it = pwallet->mapWallet.find(txhash);

+ if (it != pwallet->mapWallet.end()) {

+ const CWalletTx& wtx = it->second;

+ CTxOut utxo = wtx.tx->vout[txin.prevout.n];

+ // Update both UTXOs from the wallet.

+ input.non_witness_utxo = wtx.tx;

+ input.witness_utxo = utxo;

+ }

+

+ // Get the Sighash type

+ if (sign && input.sighash_type > 0 && input.sighash_type != sighash_type) {

+ throw JSONRPCError(RPC_DESERIALIZATION_ERROR, "Specified Sighash and sighash in PSBT do not match.");

+ }

+

+ complete &= SignPSBTInput(HidingSigningProvider(pwallet, !sign, !bip32derivs), *psbtx.tx, input, i, sighash_type);

+ }

+

+ // Fill in the bip32 keypaths and redeemscripts for the outputs so that hardware wallets can identify change

+ for (unsigned int i = 0; i < txConst->vout.size(); ++i) {

+ const CTxOut& out = txConst->vout.at(i);

+ PSBTOutput& psbt_out = psbtx.outputs.at(i);

+

+ // Fill a SignatureData with output info

+ SignatureData sigdata;

+ psbt_out.FillSignatureData(sigdata);

+

+ MutableTransactionSignatureCreator creator(psbtx.tx.get_ptr(), 0, out.nValue, 1);

+ ProduceSignature(HidingSigningProvider(pwallet, true, !bip32derivs), creator, out.scriptPubKey, sigdata);

+ psbt_out.FromSignatureData(sigdata);

+ }

+ return complete;

+}

+

+UniValue walletprocesspsbt(const JSONRPCRequest& request)

+{

+ std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);

+ CWallet* const pwallet = wallet.get();

+

+ if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {

+ return NullUniValue;

+ }

+

+ if (request.fHelp || request.params.size() < 1 || request.params.size() > 4)

+ throw std::runtime_error(

+ "walletprocesspsbt \"psbt\" ( sign \"sighashtype\" bip32derivs )\n"

+ "\nUpdate a PSBT with input information from our wallet and then sign inputs\n"

+ "that we can sign for.\n"

+ + HelpRequiringPassphrase(pwallet) + "\n"

+

+ "\nArguments:\n"

+ "1. \"psbt\" (string, required) The transaction base64 string\n"

+ "2. sign (boolean, optional, default=true) Also sign the transaction when updating\n"

+ "3. \"sighashtype\" (string, optional, default=ALL) The signature hash type to sign with if not specified by the PSBT. Must be one of\n"

+ " \"ALL\"\n"

+ " \"NONE\"\n"

+ " \"SINGLE\"\n"

+ " \"ALL|ANYONECANPAY\"\n"

+ " \"NONE|ANYONECANPAY\"\n"

+ " \"SINGLE|ANYONECANPAY\"\n"

+ "4. bip32derivs (boolean, optional, default=false) If true, includes the BIP 32 derivation paths for public keys if we know them\n"

+

+ "\nResult:\n"

+ "{\n"

+ " \"psbt\" : \"value\", (string) The base64-encoded partially signed transaction\n"

+ " \"complete\" : true|false, (boolean) If the transaction has a complete set of signatures\n"

+ " ]\n"

+ "}\n"

+

+ "\nExamples:\n"

+ + HelpExampleCli("walletprocesspsbt", "\"psbt\"")

+ );

+

+ RPCTypeCheck(request.params, {UniValue::VSTR, UniValue::VBOOL, UniValue::VSTR});

+

+ // Unserialize the transaction

+ PartiallySignedTransaction psbtx;

+ std::string error;

+ if (!DecodePSBT(psbtx, request.params[0].get_str(), error)) {

+ throw JSONRPCError(RPC_DESERIALIZATION_ERROR, strprintf("TX decode failed %s", error));

+ }

+

+ // Get the sighash type

+ int nHashType = ParseSighashString(request.params[2]);

+

+ // Use CTransaction for the constant parts of the

+ // transaction to avoid rehashing.

+ const CTransaction txConst(*psbtx.tx);

+

+ // Fill transaction with our data and also sign

+ bool sign = request.params[1].isNull() ? true : request.params[1].get_bool();

+ bool bip32derivs = request.params[3].isNull() ? false : request.params[3].get_bool();

+ bool complete = FillPSBT(pwallet, psbtx, &txConst, nHashType, sign, bip32derivs);

+

+ UniValue result(UniValue::VOBJ);

+ CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);

+ ssTx << psbtx;

+ result.pushKV("psbt", EncodeBase64((unsigned char*)ssTx.data(), ssTx.size()));

+ result.pushKV("complete", complete);

+

+ return result;

+}

+

+UniValue walletcreatefundedpsbt(const JSONRPCRequest& request)

+{

+ std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);

+ CWallet* const pwallet = wallet.get();

+

+ if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {

+ return NullUniValue;

+ }

+ if (request.fHelp || request.params.size() < 2 || request.params.size() > 5)

+ throw std::runtime_error(

+ "walletcreatefundedpsbt [{\"txid\":\"id\",\"vout\":n},...] [{\"address\":amount},{\"data\":\"hex\"},...] ( locktime ) ( replaceable ) ( options bip32derivs )\n"

+ "\nCreates and funds a transaction in the Partially Signed Transaction format. Inputs will be added if supplied inputs are not enough\n"

+ "Implements the Creator and Updater roles.\n"

+ "\nArguments:\n"

+ "1. \"inputs\" (array, required) A json array of json objects\n"

+ " [\n"

+ " {\n"

+ " \"txid\":\"id\", (string, required) The transaction id\n"

+ " \"vout\":n, (numeric, required) The output number\n"

+ " \"sequence\":n (numeric, optional) The sequence number\n"

+ " } \n"

+ " ,...\n"

+ " ]\n"

+ "2. \"outputs\" (array, required) a json array with outputs (key-value pairs)\n"

+ " [\n"

+ " {\n"

+ " \"address\": x.xxx, (obj, optional) A key-value pair. The key (string) is the bitcoin address, the value (float or string) is the amount in " + CURRENCY_UNIT + "\n"

+ " },\n"

+ " {\n"

+ " \"data\": \"hex\" (obj, optional) A key-value pair. The key must be \"data\", the value is hex encoded data\n"

+ " }\n"

+ " ,... More key-value pairs of the above form. For compatibility reasons, a dictionary, which holds the key-value pairs directly, is also\n"

+ " accepted as second parameter.\n"

+ " ]\n"

+ "3. locktime (numeric, optional, default=0) Raw locktime. Non-0 value also locktime-activates inputs\n"

+ " Allows this transaction to be replaced by a transaction with higher fees. If provided, it is an error if explicit sequence numbers are incompatible.\n"

+ "4. options (object, optional)\n"

+ " {\n"

+ " \"changeAddress\" (string, optional, default pool address) The bitcoin address to receive the change\n"

+ " \"changePosition\" (numeric, optional, default random) The index of the change output\n"

+ " \"change_type\" (string, optional) The output type to use. Only valid if changeAddress is not specified. Options are \"legacy\", \"p2sh-segwit\", and \"bech32\". Default is set by -changetype.\n"

+ " \"includeWatching\" (boolean, optional, default false) Also select inputs which are watch only\n"

+ " \"lockUnspents\" (boolean, optional, default false) Lock selected unspent outputs\n"

+ " \"feeRate\" (numeric, optional, default not set: makes wallet determine the fee) Set a specific fee rate in " + CURRENCY_UNIT + "/kB\n"

+ " \"subtractFeeFromOutputs\" (array, optional) A json array of integers.\n"

+ " The fee will be equally deducted from the amount of each specified output.\n"

+ " The outputs are specified by their zero-based index, before any change output is added.\n"

+ " Those recipients will receive less bitcoins than you enter in their corresponding amount field.\n"

+ " If no outputs are specified here, the sender pays the fee.\n"

+ " [vout_index,...]\n"

+ " \"replaceable\" (boolean, optional) Marks this transaction as BIP125 replaceable.\n"

+ " Allows this transaction to be replaced by a transaction with higher fees\n"

+ " \"conf_target\" (numeric, optional) Confirmation target (in blocks)\n"

+ " \"estimate_mode\" (string, optional, default=UNSET) The fee estimate mode, must be one of:\n"

+ " \"UNSET\"\n"

+ " \"ECONOMICAL\"\n"

+ " \"CONSERVATIVE\"\n"

+ " }\n"

+ "5. bip32derivs (boolean, optional, default=false) If true, includes the BIP 32 derivation paths for public keys if we know them\n"

+ "\nResult:\n"

+ "{\n"

+ " \"psbt\": \"value\", (string) The resulting raw transaction (base64-encoded string)\n"

+ " \"fee\": n, (numeric) Fee in " + CURRENCY_UNIT + " the resulting transaction pays\n"

+ " \"changepos\": n (numeric) The position of the added change output, or -1\n"

+ "}\n"

+ "\nExamples:\n"

+ "\nCreate a transaction with no inputs\n"

+ + HelpExampleCli("walletcreatefundedpsbt", "\"[{\\\"txid\\\":\\\"myid\\\",\\\"vout\\\":0}]\" \"[{\\\"data\\\":\\\"00010203\\\"}]\"")

+ );

+

+ RPCTypeCheck(request.params, {

+ UniValue::VARR,

+ UniValueType(), // ARR or OBJ, checked later

+ UniValue::VNUM,

+ UniValue::VOBJ,

+ UniValue::VBOOL

+ }, true

+ );

+

+ CAmount fee;

+ int change_position;

+ CMutableTransaction rawTx = ConstructTransaction(request.params[0], request.params[1], request.params[2], request.params[3]["replaceable"]);

+ FundTransaction(pwallet, rawTx, fee, change_position, request.params[3]);

+

+ // Make a blank psbt

+ PartiallySignedTransaction psbtx;

+ psbtx.tx = rawTx;

+ for (unsigned int i = 0; i < rawTx.vin.size(); ++i) {

+ psbtx.inputs.push_back(PSBTInput());

+ }

+ for (unsigned int i = 0; i < rawTx.vout.size(); ++i) {

+ psbtx.outputs.push_back(PSBTOutput());

+ }

+

+ // Use CTransaction for the constant parts of the

+ // transaction to avoid rehashing.

+ const CTransaction txConst(*psbtx.tx);

+

+ // Fill transaction with out data but don't sign

+ bool bip32derivs = request.params[4].isNull() ? false : request.params[4].get_bool();

+ FillPSBT(pwallet, psbtx, &txConst, 1, false, bip32derivs);

+

+ // Serialize the PSBT

+ CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);

+ ssTx << psbtx;

+

+ UniValue result(UniValue::VOBJ);

+ result.pushKV("psbt", EncodeBase64((unsigned char*)ssTx.data(), ssTx.size()));

+ result.pushKV("fee", ValueFromAmount(fee));

+ result.pushKV("changepos", change_position);

+ return result;

+}

+

+UniValue abortrescan(const JSONRPCRequest& request); // in rpcdump.cpp

+UniValue dumpprivkey(const JSONRPCRequest& request); // in rpcdump.cpp

+UniValue importprivkey(const JSONRPCRequest& request);

+UniValue importaddress(const JSONRPCRequest& request);

+UniValue importpubkey(const JSONRPCRequest& request);

+UniValue dumpwallet(const JSONRPCRequest& request);

+UniValue importwallet(const JSONRPCRequest& request);

+UniValue importprunedfunds(const JSONRPCRequest& request);

+UniValue removeprunedfunds(const JSONRPCRequest& request);

+UniValue importmulti(const JSONRPCRequest& request);

+

+// clang-format off

+ { "generating", "generate", &generate, {"nblocks","maxtries"} },

+ { "hidden", "addwitnessaddress", &addwitnessaddress, {"address","p2sh"} },

+ { "rawtransactions", "fundrawtransaction", &fundrawtransaction, {"hexstring","options","iswitness"} },

+ { "wallet", "addmultisigaddress", &addmultisigaddress, {"nrequired","keys","label","address_type"} },

+ { "wallet", "createwallet", &createwallet, {"wallet_name", "disable_private_keys"} },

+ { "wallet", "getaddressesbylabel", &getaddressesbylabel, {"label"} },

+ { "wallet", "getbalance", &getbalance, {"dummy","minconf","include_watchonly"} },

+ { "wallet", "getnewaddress", &getnewaddress, {"label","address_type"} },

+ { "wallet", "getreceivedbylabel", &getreceivedbylabel, {"label","minconf"} },

+ { "wallet", "importaddress", &importaddress, {"address","label","rescan","p2sh"} },

+ { "wallet", "importwallet", &importwallet, {"filename"} },

+ { "wallet", "listlabels", &listlabels, {"purpose"} },

+ { "wallet", "listreceivedbylabel", &listreceivedbylabel, {"minconf","include_empty","include_watchonly"} },

+ { "wallet", "listtransactions", &listtransactions, {"dummy","count","skip","include_watchonly"} },

+ { "wallet", "removeprunedfunds", &removeprunedfunds, {"txid"} },

+ { "wallet", "rescanblockchain", &rescanblockchain, {"start_height", "stop_height"} },

+ { "wallet", "sendmany", &sendmany, {"dummy","amounts","minconf","comment","subtractfeefrom","replaceable","conf_target","estimate_mode"} },

+ { "wallet", "sethdseed", &sethdseed, {"newkeypool","seed"} },

+ { "wallet", "setlabel", &setlabel, {"address","label"} },

+ { "wallet", "unloadwallet", &unloadwallet, {"wallet_name"} },

+ { "wallet", "walletcreatefundedpsbt", &walletcreatefundedpsbt, {"inputs","outputs","locktime","options","bip32derivs"} },

+ { "wallet", "walletpassphrasechange", &walletpassphrasechange, {"oldpassphrase","newpassphrase"} },

+ { "wallet", "walletprocesspsbt", &walletprocesspsbt, {"psbt","sign","sighashtype","bip32derivs"} },

+// clang-format on

+// Copyright (c) 2016-2018 The Bitcoin Core developers

+struct PartiallySignedTransaction;

+class CTransaction;

+bool FillPSBT(const CWallet* pwallet, PartiallySignedTransaction& psbtx, const CTransaction* txConst, int sighash_type = 1, bool sign = true, bool bip32derivs = false);

+// Copyright (c) 2017-2018 The Bitcoin Core developers

+#include <wallet/wallet.h>

+#include <wallet/coinselection.h>

+#include <wallet/coincontrol.h>

+#include <amount.h>

+#include <primitives/transaction.h>

+#include <random.h>

+#include <test/test_bitcoin.h>

+#include <wallet/test/wallet_test_fixture.h>

+ std::unique_ptr<CWalletTx> wtx = MakeUnique<CWalletTx>(&testWallet, MakeTransactionRef(std::move(tx)));

+inline std::vector<OutputGroup>& GroupCoins(const std::vector<CInputCoin>& coins)

+{

+ static std::vector<OutputGroup> static_groups;

+ static_groups.clear();

+ for (auto& coin : coins) static_groups.emplace_back(coin, 0, true, 0, 0);

+ return static_groups;

+}

+

+inline std::vector<OutputGroup>& GroupCoins(const std::vector<COutput>& coins)

+{

+ static std::vector<OutputGroup> static_groups;

+ static_groups.clear();

+ for (auto& coin : coins) static_groups.emplace_back(coin.GetInputCoin(), coin.nDepth, coin.tx->fDebitCached && coin.tx->nDebitCached == 1 /* HACK: we can't figure out the is_me flag so we use the conditions defined above; perhaps set safe to false for !fIsFromMe in add_coin() */, 0, 0);

+ return static_groups;

+}

+

+ BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), 1 * CENT, 0.5 * CENT, selection, value_ret, not_input_fees));

+ BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 1 * CENT, 0.5 * CENT, selection, value_ret, not_input_fees));

+ BOOST_CHECK_EQUAL(value_ret, 1 * CENT);

+ BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 2 * CENT, 0.5 * CENT, selection, value_ret, not_input_fees));

+ BOOST_CHECK_EQUAL(value_ret, 2 * CENT);

+ BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 5 * CENT, 0.5 * CENT, selection, value_ret, not_input_fees));

+ BOOST_CHECK_EQUAL(value_ret, 5 * CENT);

+ BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), 11 * CENT, 0.5 * CENT, selection, value_ret, not_input_fees));

+ BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 10 * CENT, 0.5 * CENT, selection, value_ret, not_input_fees));

+ BOOST_CHECK_EQUAL(value_ret, 10 * CENT);

+ BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 10 * CENT, 5000, selection, value_ret, not_input_fees));

+ BOOST_CHECK_EQUAL(value_ret, 10 * CENT);

+ // FIXME: this test is redundant with the above, because 1 Cent is selected, not "too small"

+ // BOOST_CHECK(equal_sets(selection, actual_selection));

+ BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), 0.25 * CENT, 0.5 * CENT, selection, value_ret, not_input_fees));

+ BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), target, 0, selection, value_ret, not_input_fees)); // Should exhaust

+ BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), target, 0, selection, value_ret, not_input_fees)); // Should not exhaust

+ utxo_pool.clear();

+ BOOST_CHECK(SelectCoinsBnB(GroupCoins(utxo_pool), 30 * CENT, 5000, selection, value_ret, not_input_fees));

+ BOOST_CHECK_EQUAL(value_ret, 30 * CENT);

+ BOOST_CHECK(equal_sets(selection, actual_selection));

+ BOOST_CHECK(!SelectCoinsBnB(GroupCoins(utxo_pool), 1 * CENT, 2 * CENT, selection, value_ret, not_input_fees));

+ BOOST_CHECK(!testWallet.SelectCoinsMinConf( 1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params_bnb, bnb_used));

+ BOOST_CHECK(!testWallet.SelectCoinsMinConf( 1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK(!testWallet.SelectCoinsMinConf( 1 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf( 1 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK(!testWallet.SelectCoinsMinConf( 3 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf( 3 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK(!testWallet.SelectCoinsMinConf(38 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK(!testWallet.SelectCoinsMinConf(38 * CENT, filter_standard_extra, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf(37 * CENT, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf(38 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf(34 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf( 7 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf( 8 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf( 9 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf(71 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK(!testWallet.SelectCoinsMinConf(72 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf(16 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf(16 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf(16 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf(11 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf(95 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf(195 * CENT, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf(MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf(1 * MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf(1 * MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf(500000 * COIN, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf(1 * MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK( testWallet.SelectCoinsMinConf(MIN_CHANGE, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK(testWallet.SelectCoinsMinConf(MIN_CHANGE * 10001 / 100, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK(testWallet.SelectCoinsMinConf(MIN_CHANGE * 9990 / 100, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ }

+

+ // test with many inputs

+ for (CAmount amt=1500; amt < COIN; amt*=10) {

+ empty_wallet();

+ // Create 676 inputs (= (old MAX_STANDARD_TX_SIZE == 100000) / 148 bytes per input)

+ for (uint16_t j = 0; j < 676; j++)

+ add_coin(amt);

+

+ // We only create the wallet once to save time, but we still run the coin selection RUN_TESTS times.

+ for (int i = 0; i < RUN_TESTS; i++) {

+ BOOST_CHECK(testWallet.SelectCoinsMinConf(2000, filter_confirmed, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ }

+ }

+ // test randomness

+ {

+ empty_wallet();

+ for (int i2 = 0; i2 < 100; i2++)

+ add_coin(COIN);

+ // Again, we only create the wallet once to save time, but we still run the coin selection RUN_TESTS times.

+ for (int i = 0; i < RUN_TESTS; i++) {

+ BOOST_CHECK(testWallet.SelectCoinsMinConf(50 * COIN, filter_standard, GroupCoins(vCoins), setCoinsRet , nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK(testWallet.SelectCoinsMinConf(50 * COIN, filter_standard, GroupCoins(vCoins), setCoinsRet2, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK(testWallet.SelectCoinsMinConf(COIN, filter_standard, GroupCoins(vCoins), setCoinsRet , nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK(testWallet.SelectCoinsMinConf(COIN, filter_standard, GroupCoins(vCoins), setCoinsRet2, nValueRet, coin_selection_params, bnb_used));

+ }

+

+ // add 75 cents in small change. not enough to make 90 cents,

+ // then try making 90 cents. there are multiple competing "smallest bigger" coins,

+ // one of which should be picked at random

+ add_coin(5 * CENT);

+ add_coin(10 * CENT);

+ add_coin(15 * CENT);

+ add_coin(20 * CENT);

+ add_coin(25 * CENT);

+

+ for (int i = 0; i < RUN_TESTS; i++) {

+ int fails = 0;

+ BOOST_CHECK(testWallet.SelectCoinsMinConf(90*CENT, filter_standard, GroupCoins(vCoins), setCoinsRet , nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK(testWallet.SelectCoinsMinConf(90*CENT, filter_standard, GroupCoins(vCoins), setCoinsRet2, nValueRet, coin_selection_params, bnb_used));

+ }

+ }

+

+ BOOST_CHECK(testWallet.SelectCoinsMinConf(1003 * COIN, filter_standard, GroupCoins(vCoins), setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ BOOST_CHECK(testWallet.SelectCoinsMinConf(target, filter_standard, GroupCoins(vCoins), out_set, out_value, coin_selection_params_bnb, bnb_used) ||

+ testWallet.SelectCoinsMinConf(target, filter_standard, GroupCoins(vCoins), out_set, out_value, coin_selection_params_knapsack, bnb_used));

+// Copyright (c) 2017-2018 The Bitcoin Core developers

+// Distributed under the MIT software license, see the accompanying

+// file COPYING or http://www.opensource.org/licenses/mit-license.php.

+

+#include <key_io.h>

+#include <script/sign.h>

+#include <utilstrencodings.h>

+#include <wallet/rpcwallet.h>

+#include <wallet/wallet.h>

+#include <univalue.h>

+

+#include <boost/test/unit_test.hpp>

+#include <test/test_bitcoin.h>

+#include <wallet/test/wallet_test_fixture.h>

+

+BOOST_FIXTURE_TEST_SUITE(psbt_wallet_tests, WalletTestingSetup)

+

+BOOST_AUTO_TEST_CASE(psbt_updater_test)

+{

+ // Create prevtxs and add to wallet

+ CDataStream s_prev_tx1(ParseHex("0200000000010158e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd7501000000171600145f275f436b09a8cc9a2eb2a2f528485c68a56323feffffff02d8231f1b0100000017a914aed962d6654f9a2b36608eb9d64d2b260db4f1118700c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e88702483045022100a22edcc6e5bc511af4cc4ae0de0fcd75c7e04d8c1c3a8aa9d820ed4b967384ec02200642963597b9b1bc22c75e9f3e117284a962188bf5e8a74c895089046a20ad770121035509a48eb623e10aace8bfd0212fdb8a8e5af3c94b0b133b95e114cab89e4f7965000000"), SER_NETWORK, PROTOCOL_VERSION);

+ CTransactionRef prev_tx1;

+ s_prev_tx1 >> prev_tx1;

+ CWalletTx prev_wtx1(&m_wallet, prev_tx1);

+ m_wallet.mapWallet.emplace(prev_wtx1.GetHash(), std::move(prev_wtx1));

+

+ CDataStream s_prev_tx2(ParseHex("0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f618765000000"), SER_NETWORK, PROTOCOL_VERSION);

+ CTransactionRef prev_tx2;

+ s_prev_tx2 >> prev_tx2;

+ CWalletTx prev_wtx2(&m_wallet, prev_tx2);

+ m_wallet.mapWallet.emplace(prev_wtx2.GetHash(), std::move(prev_wtx2));

+

+ // Add scripts

+ CScript rs1;

+ CDataStream s_rs1(ParseHex("475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae"), SER_NETWORK, PROTOCOL_VERSION);

+ s_rs1 >> rs1;

+ m_wallet.AddCScript(rs1);

+

+ CScript rs2;

+ CDataStream s_rs2(ParseHex("2200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903"), SER_NETWORK, PROTOCOL_VERSION);

+ s_rs2 >> rs2;

+ m_wallet.AddCScript(rs2);

+

+ CScript ws1;

+ CDataStream s_ws1(ParseHex("47522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae"), SER_NETWORK, PROTOCOL_VERSION);

+ s_ws1 >> ws1;

+ m_wallet.AddCScript(ws1);

+

+ // Add hd seed

+ CKey key = DecodeSecret("5KSSJQ7UNfFGwVgpCZDSHm5rVNhMFcFtvWM3zQ8mW4qNDEN7LFd"); // Mainnet and uncompressed form of cUkG8i1RFfWGWy5ziR11zJ5V4U4W3viSFCfyJmZnvQaUsd1xuF3T

+ CPubKey master_pub_key = m_wallet.DeriveNewSeed(key);

+ m_wallet.SetHDSeed(master_pub_key);

+ m_wallet.NewKeyPool();

+

+ // Call FillPSBT

+ PartiallySignedTransaction psbtx;

+ CDataStream ssData(ParseHex("70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f000000000000000000"), SER_NETWORK, PROTOCOL_VERSION);

+ ssData >> psbtx;

+

+ // Use CTransaction for the constant parts of the

+ // transaction to avoid rehashing.

+ const CTransaction txConst(*psbtx.tx);

+

+ // Fill transaction with our data

+ FillPSBT(&m_wallet, psbtx, &txConst, 1, false, true);

+

+ // Get the final tx

+ CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);

+ ssTx << psbtx;

+ std::string final_hex = HexStr(ssTx.begin(), ssTx.end());

+ BOOST_CHECK_EQUAL(final_hex, "70736274ff01009a020000000258e87a21b56daf0c23be8e7070456c336f7cbaa5c8757924f545887bb2abdd750000000000ffffffff838d0427d0ec650a68aa46bb0b098aea4422c071b2ca78352a077959d07cea1d0100000000ffffffff0270aaf00800000000160014d85c2b71d0060b09c9886aeb815e50991dda124d00e1f5050000000016001400aea9a2e5f0f876a588df5546e8742d1d87008f00000000000100bb0200000001aad73931018bd25f84ae400b68848be09db706eac2ac18298babee71ab656f8b0000000048473044022058f6fc7c6a33e1b31548d481c826c015bd30135aad42cd67790dab66d2ad243b02204a1ced2604c6735b6393e5b41691dd78b00f0c5942fb9f751856faa938157dba01feffffff0280f0fa020000000017a9140fb9463421696b82c833af241c78c17ddbde493487d0f20a270100000017a91429ca74f8a08f81999428185c97b5d852e4063f6187650000000104475221029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f2102dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d752ae2206029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f10d90c6a4f000000800000008000000080220602dab61ff49a14db6a7d02b0cd1fbb78fc4b18312b5b4e54dae4dba2fbfef536d710d90c6a4f0000008000000080010000800001012000c2eb0b0000000017a914b7f5faf40e3d40a5a459b1db3535f2b72fa921e88701042200208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903010547522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae2206023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7310d90c6a4f000000800000008003000080220603089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc10d90c6a4f00000080000000800200008000220203a9a4c37f5996d3aa25dbac6b570af0650394492942460b354753ed9eeca5877110d90c6a4f000000800000008004000080002202027f6399757d2eff55a136ad02c684b1838b6556e5f1b6b34282a94b6b5005109610d90c6a4f00000080000000800500008000");

+}

+

+BOOST_AUTO_TEST_CASE(parse_hd_keypath)

+{

+ std::vector<uint32_t> keypath;

+

+ BOOST_CHECK(ParseHDKeypath("1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1", keypath));

+ BOOST_CHECK(!ParseHDKeypath("///////////////////////////", keypath));

+

+ BOOST_CHECK(ParseHDKeypath("1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1'/1", keypath));

+ BOOST_CHECK(!ParseHDKeypath("//////////////////////////'/", keypath));

+

+ BOOST_CHECK(ParseHDKeypath("1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/", keypath));

+ BOOST_CHECK(!ParseHDKeypath("1///////////////////////////", keypath));

+

+ BOOST_CHECK(ParseHDKeypath("1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1/1'/", keypath));

+ BOOST_CHECK(!ParseHDKeypath("1/'//////////////////////////", keypath));

+

+ BOOST_CHECK(ParseHDKeypath("", keypath));

+ BOOST_CHECK(!ParseHDKeypath(" ", keypath));

+

+ BOOST_CHECK(ParseHDKeypath("0", keypath));

+ BOOST_CHECK(!ParseHDKeypath("O", keypath));

+

+ BOOST_CHECK(ParseHDKeypath("0000'/0000'/0000'", keypath));

+ BOOST_CHECK(!ParseHDKeypath("0000,/0000,/0000,", keypath));

+

+ BOOST_CHECK(ParseHDKeypath("01234", keypath));

+ BOOST_CHECK(!ParseHDKeypath("0x1234", keypath));

+

+ BOOST_CHECK(ParseHDKeypath("1", keypath));

+ BOOST_CHECK(!ParseHDKeypath(" 1", keypath));

+

+ BOOST_CHECK(ParseHDKeypath("42", keypath));

+ BOOST_CHECK(!ParseHDKeypath("m42", keypath));

+

+ BOOST_CHECK(ParseHDKeypath("4294967295", keypath)); // 4294967295 == 0xFFFFFFFF (uint32_t max)

+ BOOST_CHECK(!ParseHDKeypath("4294967296", keypath)); // 4294967296 == 0xFFFFFFFF (uint32_t max) + 1

+

+ BOOST_CHECK(ParseHDKeypath("m", keypath));

+ BOOST_CHECK(!ParseHDKeypath("n", keypath));

+

+ BOOST_CHECK(ParseHDKeypath("m/", keypath));

+ BOOST_CHECK(!ParseHDKeypath("n/", keypath));

+

+ BOOST_CHECK(ParseHDKeypath("m/0", keypath));

+ BOOST_CHECK(!ParseHDKeypath("n/0", keypath));

+

+ BOOST_CHECK(ParseHDKeypath("m/0'", keypath));

+ BOOST_CHECK(!ParseHDKeypath("m/0''", keypath));

+

+ BOOST_CHECK(ParseHDKeypath("m/0'/0'", keypath));

+ BOOST_CHECK(!ParseHDKeypath("m/'0/0'", keypath));

+

+ BOOST_CHECK(ParseHDKeypath("m/0/0", keypath));

+ BOOST_CHECK(!ParseHDKeypath("n/0/0", keypath));

+

+ BOOST_CHECK(ParseHDKeypath("m/0/0/00", keypath));

+ BOOST_CHECK(!ParseHDKeypath("m/0/0/f00", keypath));

+

+ BOOST_CHECK(ParseHDKeypath("m/0/0/000000000000000000000000000000000000000000000000000000000000000000000000000000000000", keypath));

+ BOOST_CHECK(!ParseHDKeypath("m/1/1/111111111111111111111111111111111111111111111111111111111111111111111111111111111111", keypath));

+

+ BOOST_CHECK(ParseHDKeypath("m/0/00/0", keypath));

+ BOOST_CHECK(!ParseHDKeypath("m/0'/00/'0", keypath));

+

+ BOOST_CHECK(ParseHDKeypath("m/1/", keypath));

+ BOOST_CHECK(!ParseHDKeypath("m/1//", keypath));

+

+ BOOST_CHECK(ParseHDKeypath("m/0/4294967295", keypath)); // 4294967295 == 0xFFFFFFFF (uint32_t max)

+ BOOST_CHECK(!ParseHDKeypath("m/0/4294967296", keypath)); // 4294967296 == 0xFFFFFFFF (uint32_t max) + 1

+

+ BOOST_CHECK(ParseHDKeypath("m/4294967295", keypath)); // 4294967295 == 0xFFFFFFFF (uint32_t max)

+ BOOST_CHECK(!ParseHDKeypath("m/4294967296", keypath)); // 4294967296 == 0xFFFFFFFF (uint32_t max) + 1

+}

+

+BOOST_AUTO_TEST_SUITE_END()

+// Copyright (c) 2014-2018 The Bitcoin Core developers

+// Copyright (c) 2016-2018 The Bitcoin Core developers

+// Copyright (c) 2016-2018 The Bitcoin Core developers

+// Copyright (c) 2012-2018 The Bitcoin Core developers

+ std::string backup_file = (SetDataDir("importwallet_rescan") / "wallet.backup").string();

+

+ request.params.push_back(backup_file);

+ request.params.push_back(backup_file);

+ BOOST_CHECK(wallet->CommitTransaction(tx, {}, {}, reservekey, nullptr, state));

+ std::map<CTxDestination, std::vector<COutput>> list;

+ {

+ LOCK2(cs_main, wallet->cs_wallet);

+ list = wallet->ListCoins();

+ }

+ {

+ LOCK2(cs_main, wallet->cs_wallet);

+ list = wallet->ListCoins();

+ }

+ {

+ LOCK2(cs_main, wallet->cs_wallet);

+ list = wallet->ListCoins();

+ }

+BOOST_FIXTURE_TEST_CASE(wallet_disableprivkeys, TestChain100Setup)

+{

+ std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>("dummy", WalletDatabase::CreateDummy());

+ wallet->SetWalletFlag(WALLET_FLAG_DISABLE_PRIVATE_KEYS);

+ BOOST_CHECK(!wallet->TopUpKeyPool(1000));

+ CPubKey pubkey;

+ BOOST_CHECK(!wallet->GetKeyFromPool(pubkey, false));

+}

+

+// Copyright (c) 2009-2018 The Bitcoin Core developers

+#include <shutdown.h>

+static const size_t OUTPUT_GROUP_MAX_ENTRIES = 10;

+

+// Custom deleter for shared_ptr<CWallet>.

+static void ReleaseWallet(CWallet* wallet)

+{

+ wallet->WalletLogPrintf("Releasing wallet\n");

+ wallet->BlockUntilSyncedToCurrentChain();

+ wallet->Flush();

+ delete wallet;

+}

+

+/** A class to identify which pubkeys a script and a keystore have in common. */

+ /**

+ * @param[in] keystoreIn The CKeyStore that is queried for the presence of a pubkey.

+ * @param[out] vKeysIn A vector to which a script's pubkey identifiers are appended if they are in the keystore.

+ */

+ /**

+ * Apply the visitor to each destination in a script, recursively to the redeemscript

+ * in the case of p2sh destinations.

+ * @param[in] script The CScript from which destinations are extracted.

+ * @post Any CKeyIDs that script and keystore have in common are appended to the visitor's vKeys.

+ */

+ assert(!IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));

+void CWallet::LoadKeyMetadata(const CKeyID& keyID, const CKeyMetadata &meta)

+void CWallet::LoadScriptMetadata(const CScriptID& script_id, const CKeyMetadata &meta)

+ WalletLogPrintf("%s: Warning: This wallet contains a redeemScript of size %i which exceeds maximum size %i thus can never be redeemed. Do not use address %s.\n", __func__, redeemScript.size(), MAX_SCRIPT_ELEMENT_SIZE, strAddr);

+ WalletLogPrintf("Wallet passphrase changed to an nDeriveIterations of %i\n", pMasterKey.second.nDeriveIterations);

+void CWallet::SetMinVersion(enum WalletFeature nVersion, WalletBatch* batch_in, bool fExplicit)

+ return;

+ nMinOrderPos = wtx->nOrderPos;

+ setLockedCoins.erase(outpoint);

+

+ WalletLogPrintf("Encrypting Wallet with an nDeriveIterations of %i\n", kMasterKey.nDeriveIterations);

+ encrypted_batch = nullptr;

+ encrypted_batch = nullptr;

+ SetHDSeed(GenerateNewSeed());

+ // BDB seems to have a bad habit of writing old data into

+ // slack space in .dat files; that is bad if the old data is

+ // unencrypted private keys. So:

+ database->ReloadDbEnv();

+

+ // First: get all CWalletTx into a sorted-by-time multimap.

+ typedef std::multimap<int64_t, CWalletTx*> TxItems;

+ txByTime.insert(std::make_pair(wtx->nTimeReceived, wtx));

+ CWalletTx *const pwtx = (*it).second;

+ int64_t& nOrderPos = pwtx->nOrderPos;

+ if (!batch.WriteTx(*pwtx))

+ return DBErrors::LOAD_FAIL;

+ if (!batch.WriteTx(*pwtx))

+ return DBErrors::LOAD_FAIL;

+ WalletLogPrintf("%s: Updating batch tx %s failed\n", __func__, wtx.GetHash().ToString());

+ if (fInsertedNew) {

+ wtx.m_it_wtxOrdered = wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));

+ WalletLogPrintf("AddToWallet %s %s%s\n", wtxIn.GetHash().ToString(), (fInsertedNew ? "new" : ""), (fUpdated ? "update" : ""));

+void CWallet::LoadToWallet(const CWalletTx& wtxIn)

+ const auto& ins = mapWallet.emplace(hash, wtxIn);

+ CWalletTx& wtx = ins.first->second;

+ if (/* insertion took place */ ins.second) {

+ wtx.m_it_wtxOrdered = wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));

+ }

+ WalletLogPrintf("Transaction %s (in block %s) conflicts with wallet transaction %s (both spend %s:%i)\n", tx.GetHash().ToString(), pIndex->GetBlockHash().ToString(), range.first->second.ToString(), range.first->first.hash.ToString(), range.first->first.n);

+ WalletLogPrintf("%s: Detected a used keypool key, mark all keypool key up to this key as used\n", __func__);

+ WalletLogPrintf("%s: Topping up keypool failed (locked wallet)\n", __func__);

+void CWallet::MarkInputsDirty(const CTransactionRef& tx)

+{

+ for (const CTxIn& txin : tx->vin) {

+ auto it = mapWallet.find(txin.prevout.hash);

+ if (it != mapWallet.end()) {

+ it->second.MarkDirty();

+ }

+ }

+}

+

+ TxSpends::const_iterator iter = mapTxSpends.lower_bound(COutPoint(now, 0));

+ MarkInputsDirty(wtx.tx);

+ MarkInputsDirty(wtx.tx);

+void CWallet::SyncTransaction(const CTransactionRef& ptx, const CBlockIndex *pindex, int posInBlock, bool update_tx) {

+ if (!AddToWalletIfInvolvingMe(ptx, pindex, posInBlock, update_tx))

+ MarkInputsDirty(ptx);

+ if (m_last_block_processed && m_last_block_processed->GetAncestor(initialChainTip->nHeight) == initialChainTip) {

+ assert(!IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS));

+void CWallet::SetHDSeed(const CPubKey& seed)

+void CWallet::SetHDChain(const CHDChain& chain, bool memonly)

+void CWallet::SetWalletFlag(uint64_t flags)

+ LOCK(cs_wallet);

+ m_wallet_flags |= flags;

+ if (!WalletBatch(*database).WriteWalletFlags(m_wallet_flags))

+ throw std::runtime_error(std::string(__func__) + ": writing wallet flags failed");

+bool CWallet::IsWalletFlagSet(uint64_t flag)

+ return (m_wallet_flags & flag);

+}

+bool CWallet::SetWalletFlags(uint64_t overwriteFlags, bool memonly)

+{

+ LOCK(cs_wallet);

+ m_wallet_flags = overwriteFlags;

+ if (((overwriteFlags & g_known_wallet_flags) >> 32) ^ (overwriteFlags >> 32)) {

+ // contains unknown non-tolerable wallet flags

+ return false;

+ }

+ if (!memonly && !WalletBatch(*database).WriteWalletFlags(m_wallet_flags)) {

+ throw std::runtime_error(std::string(__func__) + ": writing wallet flags failed");

+

+ return true;

+int64_t CWalletTx::GetTxTime() const

+{

+ int64_t n = nTimeSmart;

+ return n ? n : nTimeReceived;

+}

+

+// Helper for producing a max-sized low-S low-R signature (eg 71 bytes)

+// or a max-sized low-S signature (e.g. 72 bytes) if use_max_sig is true

+bool CWallet::DummySignInput(CTxIn &tx_in, const CTxOut &txout, bool use_max_sig) const

+ if (!ProduceSignature(*this, use_max_sig ? DUMMY_MAXIMUM_SIGNATURE_CREATOR : DUMMY_SIGNATURE_CREATOR, scriptPubKey, sigdata)) {

+ UpdateInput(tx_in, sigdata);

+// Helper for producing a bunch of max-sized low-S low-R signatures (eg 71 bytes)

+bool CWallet::DummySignTx(CMutableTransaction &txNew, const std::vector<CTxOut> &txouts, bool use_max_sig) const

+ if (!DummySignInput(txNew.vin[nIn], txout, use_max_sig)) {

+int64_t CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *wallet, bool use_max_sig)

+ for (const CTxIn& input : tx.vin) {

+ return CalculateMaximumSignedTxSize(tx, wallet, txouts, use_max_sig);

+int64_t CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *wallet, const std::vector<CTxOut>& txouts, bool use_max_sig)

+ if (!wallet->DummySignTx(txNew, txouts, use_max_sig)) {

+int CalculateMaximumSignedInputSize(const CTxOut& txout, const CWallet* wallet, bool use_max_sig)

+ if (!wallet->DummySignInput(txn.vin[0], txout, use_max_sig)) {

+ std::list<COutputEntry>& listSent, CAmount& nFee, const isminefilter& filter) const

+ pwallet->WalletLogPrintf("CWalletTx::GetAmounts: Unknown transaction type found, txid %s\n",

+ this->GetHash().ToString());

+ WalletLogPrintf("%s: Rescanning last %i blocks\n", __func__, startBlock ? chainActive.Height() - startBlock->nHeight + 1 : 0);

+ if (pindex) WalletLogPrintf("Rescan started from block %d...\n", pindex->nHeight);

+ ShowProgress(strprintf("%s " + _("Rescanning..."), GetDisplayName()), 0); // show rescan progress in GUI as dialog or on splashscreen, if -rescan on startup

+ ShowProgress(strprintf("%s " + _("Rescanning..."), GetDisplayName()), std::max(1, std::min(99, (int)((progress_current - progress_begin) / (progress_end - progress_begin) * 100))));

+ WalletLogPrintf("Still rescanning. At block %d. Progress=%f\n", pindex->nHeight, progress_current);

+ SyncTransaction(block.vtx[posInBlock], pindex, posInBlock, fUpdate);

+ WalletLogPrintf("Rescan aborted at block %d. Progress=%f\n", pindex->nHeight, progress_current);

+ WalletLogPrintf("Rescan interrupted by shutdown request at block %d. Progress=%f\n", pindex->nHeight, progress_current);

+ ShowProgress(strprintf("%s " + _("Rescanning..."), GetDisplayName()), 100); // hide progress dialog in GUI

+ for (const std::pair<const int64_t, CWalletTx*>& item : mapSorted) {

+ pwallet->WalletLogPrintf("Relaying wtx %s\n", GetHash().ToString());

+ if (IsImmatureCoinBase())

+ if (IsImmatureCoinBase() && IsInMainChain()) {

+CAmount CWalletTx::GetAvailableCredit(bool fUseCache, const isminefilter& filter) const

+ if (IsImmatureCoinBase())

+ CAmount* cache = nullptr;

+ bool* cache_used = nullptr;

+

+ if (filter == ISMINE_SPENDABLE) {

+ cache = &nAvailableCreditCached;

+ cache_used = &fAvailableCreditCached;

+ } else if (filter == ISMINE_WATCH_ONLY) {

+ cache = &nAvailableWatchCreditCached;

+ cache_used = &fAvailableWatchCreditCached;

+ }

+

+ if (fUseCache && cache_used && *cache_used) {

+ return *cache;

+ }

+ nCredit += pwallet->GetCredit(txout, filter);

+ if (cache) {

+ *cache = nCredit;

+ assert(cache_used);

+ *cache_used = true;

+ }

+ if (IsImmatureCoinBase() && IsInMainChain()) {

+ for (const std::pair<const unsigned int, CWalletTx*>& item : mapSorted)

+ WalletLogPrintf("%s: rebroadcast %u unconfirmed transactions\n", __func__, relayed.size());

+CAmount CWallet::GetBalance(const isminefilter& filter, const int min_depth) const

+ if (pcoin->IsTrusted() && pcoin->GetDepthInMainChain() >= min_depth) {

+ nTotal += pcoin->GetAvailableCredit(true, filter);

+ }

+ nTotal += pcoin->GetAvailableCredit(true, ISMINE_WATCH_ONLY);

+CAmount CWallet::GetLegacyBalance(const isminefilter& filter, int minDepth) const

+ if (depth < 0 || !CheckFinalTx(*wtx.tx) || wtx.IsImmatureCoinBase()) {

+ } else if (IsMine(out) & filter && depth >= minDepth) {

+ if (outgoing) {

+ if (pcoin->IsImmatureCoinBase())

+ vCoins.push_back(COutput(pcoin, i, nDepth, spendable, solvable, safeTx, (coinControl && coinControl->fAllowWatchOnly)));

+ AssertLockHeld(cs_main);

+ AssertLockHeld(cs_wallet);

+ for (const COutput& coin : availableCoins) {

+ for (const COutPoint& output : lockedCoins) {

+bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, const CoinEligibilityFilter& eligibility_filter, std::vector<OutputGroup> groups,

+ std::vector<OutputGroup> utxo_pool;

+ for (OutputGroup& group : groups) {

+ if (!group.EligibleForSpending(eligibility_filter)) continue;

+

+ group.fee = 0;

+ group.long_term_fee = 0;

+ group.effective_value = 0;

+ for (auto it = group.m_outputs.begin(); it != group.m_outputs.end(); ) {

+ const CInputCoin& coin = *it;

+ CAmount effective_value = coin.txout.nValue - (coin.m_input_bytes < 0 ? 0 : coin_selection_params.effective_fee.GetFee(coin.m_input_bytes));

+ // Only include outputs that are positive effective value (i.e. not dust)

+ if (effective_value > 0) {

+ group.fee += coin.m_input_bytes < 0 ? 0 : coin_selection_params.effective_fee.GetFee(coin.m_input_bytes);

+ group.long_term_fee += coin.m_input_bytes < 0 ? 0 : long_term_feerate.GetFee(coin.m_input_bytes);

+ group.effective_value += effective_value;

+ ++it;

+ } else {

+ it = group.Discard(coin);

+ }

+ if (group.effective_value > 0) utxo_pool.push_back(group);

+ for (const OutputGroup& group : groups) {

+ if (!group.EligibleForSpending(eligibility_filter)) continue;

+ utxo_pool.push_back(group);

+ setCoinsRet.insert(out.GetInputCoin());

+ if (setPresetCoins.count(it->GetInputCoin()))

+ // form groups from remaining coins; note that preset coins will not

+ // automatically have their associated (same address) coins included

+ if (coin_control.m_avoid_partial_spends && vCoins.size() > OUTPUT_GROUP_MAX_ENTRIES) {

+ // Cases where we have 11+ outputs all pointing to the same destination may result in

+ // privacy leaks as they will potentially be deterministically sorted. We solve that by

+ // explicitly shuffling the outputs before processing

+ std::shuffle(vCoins.begin(), vCoins.end(), FastRandomContext());

+ }

+ std::vector<OutputGroup> groups = GroupOutputs(vCoins, !coin_control.m_avoid_partial_spends);

+

+ size_t max_ancestors = (size_t)std::max<int64_t>(1, gArgs.GetArg("-limitancestorcount", DEFAULT_ANCESTOR_LIMIT));

+ size_t max_descendants = (size_t)std::max<int64_t>(1, gArgs.GetArg("-limitdescendantcount", DEFAULT_DESCENDANT_LIMIT));

+ SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(1, 6, 0), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used) ||

+ SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(1, 1, 0), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used) ||

+ (m_spend_zero_conf_change && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(0, 1, 2), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used)) ||

+ (m_spend_zero_conf_change && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(0, 1, std::min((size_t)4, max_ancestors/3), std::min((size_t)4, max_descendants/3)), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used)) ||

+ (m_spend_zero_conf_change && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(0, 1, max_ancestors/2, max_descendants/2), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used)) ||

+ (m_spend_zero_conf_change && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(0, 1, max_ancestors-1, max_descendants-1), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used)) ||

+ (m_spend_zero_conf_change && !fRejectLongChains && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, CoinEligibilityFilter(0, 1, std::numeric_limits<uint64_t>::max()), groups, setCoinsRet, nValueRet, coin_selection_params, bnb_used));

+ util::insert(setCoinsRet, setPresetCoins);

+ int& nChangePosInOut, std::string& strFailReason, const CCoinControl& coin_control, bool sign)

+ if (IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {

+ strFailReason = _("Can't generate a change-address key. Private keys are disabled for this wallet.");

+ return false;

+ }

+ coin_selection_params.change_output_size = GetSerializeSize(change_prototype_txout);

+ coin_selection_params.tx_noinputs_size += ::GetSerializeSize(txout, PROTOCOL_VERSION);

+ } else {

+ bnb_used = false;

+ nBytes = CalculateMaximumSignedTxSize(txNew, this, coin_control.fAllowWatchOnly);

+ if (GetTransactionWeight(*tx) > MAX_STANDARD_TX_WEIGHT)

+ LOCK(::mempool.cs);

+ if (!::mempool.CalculateMemPoolAncestors(entry, setAncestors, nLimitAncestors, nLimitAncestorSize, nLimitDescendants, nLimitDescendantSize, errString)) {

+ WalletLogPrintf("Fee Calculation: Fee:%d Bytes:%u Needed:%d Tgt:%d (requested %d) Reason:\"%s\" Decay %.5f: Estimation: (%g - %g) %.2f%% %.1f/(%.1f %d mem %.1f out) Fail: (%g - %g) %.2f%% %.1f/(%.1f %d mem %.1f out)\n",

+bool CWallet::CommitTransaction(CTransactionRef tx, mapValue_t mapValue, std::vector<std::pair<std::string, std::string>> orderForm, CReserveKey& reservekey, CConnman* connman, CValidationState& state)

+ WalletLogPrintf("CommitTransaction:\n%s", wtxNew.tx->ToString()); /* Continued */

+ WalletLogPrintf("CommitTransaction(): Transaction cannot be broadcast immediately, %s\n", FormatStateMessage(state));

+ {

+ LOCK(cs_KeyStore);

+ // This wallet is in its first run if all of these are empty

+ fFirstRunRet = mapKeys.empty() && mapCryptedKeys.empty() && mapWatchKeys.empty() && setWatchOnly.empty() && mapScripts.empty() && !IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS);

+ }

+ for (uint256 hash : vHashOut) {

+ const auto& it = mapWallet.find(hash);

+ wtxOrdered.erase(it->second.m_it_wtxOrdered);

+ mapWallet.erase(it);

+ }

+ for (const std::pair<const std::string, std::string> &item : mapAddressBook[address].destdata)

+ if (IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {

+ return false;

+ }

+ for (const int64_t nIndex : setInternalKeyPool) {

+ for (const int64_t nIndex : setExternalKeyPool) {

+ for (const int64_t nIndex : set_pre_split_keypool) {

+ WalletLogPrintf("CWallet::NewKeyPool rewrote keypool\n");

+ if (IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {

+ return false;

+ }

+ WalletLogPrintf("keypool added %d keys (%d internal), size=%u (%u internal)\n", missingInternal + missingExternal, missingInternal, setInternalKeyPool.size() + setExternalKeyPool.size() + set_pre_split_keypool.size(), setInternalKeyPool.size());

+ WalletLogPrintf("keypool reserve %d\n", nIndex);

+ WalletLogPrintf("keypool keep %d\n", nIndex);

+ WalletLogPrintf("keypool return %d\n", nIndex);

+ if (IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {

+ return false;

+ }

+

+ if (pcoin->IsImmatureCoinBase())

+ for (const CTxIn& txin : pcoin->tx->vin)

+ for (const CTxOut& txout : pcoin->tx->vout)

+ for (const CTxDestination& address : _grouping)

+ for (const CTxDestination& element : *merged)

+ for (const std::set<CTxDestination>* uniqueGrouping : uniqueGroupings)

+ for (const std::pair<const CTxDestination, CAddressBookData>& item : mapAddressBook)

+ WalletLogPrintf("keypool index %d removed\n", index);

+ CWalletTx* const pwtx = it->second;

+ nSmartTime = pwtx->nTimeSmart;

+ if (!nSmartTime) {

+ nSmartTime = pwtx->nTimeReceived;

+ WalletLogPrintf("%s: found %s in block %s not in index\n", __func__, wtx.GetHash().ToString(), wtx.hashBlock.ToString());

+void CWallet::LoadDestData(const CTxDestination &dest, const std::string &key, const std::string &value)

+ try {

+ if (!WalletBatch::VerifyEnvironment(wallet_path, error_string)) {

+ return false;

+ }

+ } catch (const fs::filesystem_error& e) {

+ error_string = strprintf("Error loading wallet %s. %s", wallet_file, fsbridge::get_filesystem_error_message(e));

+std::shared_ptr<CWallet> CWallet::CreateWalletFromFile(const std::string& name, const fs::path& path, uint64_t wallet_creation_flags)

+ // TODO: Can't use std::make_shared because we need a custom deleter but

+ // should be possible to use std::allocate_shared.

+ std::shared_ptr<CWallet> walletInstance(new CWallet(name, WalletDatabase::Create(path)), ReleaseWallet);

+ walletInstance->WalletLogPrintf("Performing wallet upgrade to %i\n", FEATURE_LATEST);

+ nMaxVersion = FEATURE_LATEST;

+ walletInstance->WalletLogPrintf("Allowing wallet upgrade up to %i\n", nMaxVersion);

+ walletInstance->WalletLogPrintf("Upgrading wallet to HD\n");

+ walletInstance->SetHDSeed(masterPubKey);

+ walletInstance->WalletLogPrintf("Upgrading wallet to use HD chain split\n");

+ InitError(_("Unable to generate keys"));

+ if ((wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {

+ //selective allow to set flags

+ walletInstance->SetWalletFlag(WALLET_FLAG_DISABLE_PRIVATE_KEYS);

+ } else {

+ // generate a new seed

+ CPubKey seed = walletInstance->GenerateNewSeed();

+ walletInstance->SetHDSeed(seed);

+ }

+ if (!walletInstance->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) && !walletInstance->TopUpKeyPool()) {

+ InitError(_("Unable to generate initial keys"));

+ } else if (wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS) {

+ // Make it impossible to disable private keys after creation

+ InitError(strprintf(_("Error loading %s: Private keys can only be disabled during creation"), walletFile));

+ return NULL;

+ } else if (walletInstance->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {

+ LOCK(walletInstance->cs_KeyStore);

+ if (!walletInstance->mapKeys.empty() || !walletInstance->mapCryptedKeys.empty()) {

+ InitWarning(strprintf(_("Warning: Private keys detected in wallet {%s} with disabled private keys"), walletFile));

+ }

+ walletInstance->WalletLogPrintf("Wallet completed loading in %15dms\n", GetTimeMillis() - nStart);

+ walletInstance->WalletLogPrintf("Rescanning last %i blocks (from block %i)...\n", chainActive.Height() - pindexRescan->nHeight, pindexRescan->nHeight);

+ walletInstance->WalletLogPrintf("Rescan completed in %15dms\n", GetTimeMillis() - nStart);

+ uiInterface.LoadWallet(walletInstance);

+

+ walletInstance->WalletLogPrintf("setKeyPool.size() = %u\n", walletInstance->GetKeyPoolSize());

+ walletInstance->WalletLogPrintf("mapWallet.size() = %u\n", walletInstance->mapWallet.size());

+ walletInstance->WalletLogPrintf("mapAddressBook.size() = %u\n", walletInstance->mapAddressBook.size());

+int CMerkleTx::GetDepthInMainChain() const

+ int chain_depth = GetDepthInMainChain();

+ assert(chain_depth >= 0); // coinbase tx should not be conflicted

+ return std::max(0, (COINBASE_MATURITY+1) - chain_depth);

+bool CMerkleTx::IsImmatureCoinBase() const

+{

+ // note GetBlocksToMaturity is 0 for non-coinbase tx

+ return GetBlocksToMaturity() > 0;

+}

+std::vector<OutputGroup> CWallet::GroupOutputs(const std::vector<COutput>& outputs, bool single_coin) const {

+ std::vector<OutputGroup> groups;

+ std::map<CTxDestination, OutputGroup> gmap;

+ CTxDestination dst;

+ for (const auto& output : outputs) {

+ if (output.fSpendable) {

+ CInputCoin input_coin = output.GetInputCoin();

+

+ size_t ancestors, descendants;

+ mempool.GetTransactionAncestry(output.tx->GetHash(), ancestors, descendants);

+ if (!single_coin && ExtractDestination(output.tx->tx->vout[output.i].scriptPubKey, dst)) {

+ // Limit output groups to no more than 10 entries, to protect

+ // against inadvertently creating a too-large transaction

+ // when using -avoidpartialspends

+ if (gmap[dst].m_outputs.size() >= OUTPUT_GROUP_MAX_ENTRIES) {

+ groups.push_back(gmap[dst]);

+ gmap.erase(dst);

+ }

+ gmap[dst].Insert(input_coin, output.nDepth, output.tx->IsFromMe(ISMINE_ALL), ancestors, descendants);

+ } else {

+ groups.emplace_back(input_coin, output.nDepth, output.tx->IsFromMe(ISMINE_ALL), ancestors, descendants);

+ }

+ if (!single_coin) {

+ for (const auto& it : gmap) groups.push_back(it.second);

+ return groups;

+bool CWallet::GetKeyOrigin(const CKeyID& keyID, KeyOriginInfo& info) const

+ CKeyMetadata meta;

+ {

+ LOCK(cs_wallet);

+ auto it = mapKeyMetadata.find(keyID);

+ if (it != mapKeyMetadata.end()) {

+ meta = it->second;

+ }

+ }

+ if (!meta.hdKeypath.empty()) {

+ if (!ParseHDKeypath(meta.hdKeypath, info.path)) return false;

+ // Get the proper master key id

+ CKey key;

+ GetKey(meta.hd_seed_id, key);

+ CExtKey masterKey;

+ masterKey.SetSeed(key.begin(), key.size());

+ // Compute identifier

+ CKeyID masterid = masterKey.key.GetPubKey().GetID();

+ std::copy(masterid.begin(), masterid.begin() + 4, info.fingerprint);

+ } else { // Single pubkeys get the master fingerprint of themselves

+ std::copy(keyID.begin(), keyID.begin() + 4, info.fingerprint);

+ return true;

+// Copyright (c) 2009-2018 The Bitcoin Core developers

+#include <outputtype.h>

+//! Default for -avoidpartialspends

+static const bool DEFAULT_AVOIDPARTIALSPENDS = false;

+enum WalletFlags : uint64_t {

+ // wallet flags in the upper section (> 1 << 31) will lead to not opening the wallet if flag is unknown

+ // unknown wallet flags in the lower section <= (1 << 31) will be tolerated

+

+ // will enforce the rule that the wallet can't contain any private keys (only watch-only/pubkeys)

+ WALLET_FLAG_DISABLE_PRIVATE_KEYS = (1ULL << 32),

+};

+

+static constexpr uint64_t g_known_wallet_flags = WALLET_FLAG_DISABLE_PRIVATE_KEYS;

+

+ int GetDepthInMainChain() const EXCLUSIVE_LOCKS_REQUIRED(cs_main);

+ bool IsInMainChain() const EXCLUSIVE_LOCKS_REQUIRED(cs_main) { return GetDepthInMainChain() > 0; }

+

+ /**

+ * @return number of blocks to maturity for this transaction:

+ * 0 : is not a coinbase transaction, or is a mature coinbase transaction

+ * >0 : is a coinbase transaction which matures in this many blocks

+ */

+ int GetBlocksToMaturity() const EXCLUSIVE_LOCKS_REQUIRED(cs_main);

+ bool IsImmatureCoinBase() const EXCLUSIVE_LOCKS_REQUIRED(cs_main);

+int CalculateMaximumSignedInputSize(const CTxOut& txout, const CWallet* pwallet, bool use_max_sig = false);

+ * and sendmany wallet RPCs

+ std::multimap<int64_t, CWalletTx*>::const_iterator m_it_wtxOrdered;

+ mapValueCopy["fromaccount"] = "";

+ CAmount GetCredit(const isminefilter& filter) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);

+ CAmount GetImmatureCredit(bool fUseCache=true) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);

+ CAmount GetAvailableCredit(bool fUseCache=true, const isminefilter& filter=ISMINE_SPENDABLE) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);

+ CAmount GetImmatureWatchOnlyCredit(const bool fUseCache=true) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);

+ int GetSpendSize(unsigned int out, bool use_max_sig = false) const

+ return CalculateMaximumSignedInputSize(tx->vout[out], pwallet, use_max_sig);

+ std::list<COutputEntry>& listSent, CAmount& nFee, const isminefilter& filter) const;

+ bool IsTrusted() const EXCLUSIVE_LOCKS_REQUIRED(cs_main);

+ bool RelayWalletTransaction(CConnman* connman) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

+ bool AcceptToMemoryPool(const CAmount& nAbsurdFee, CValidationState& state) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

+ /** Whether to use the maximum sized, 72 byte signature when calculating the size of the input spend. This should only be set when watch-only outputs are allowed */

+ bool use_max_sig;

+

+ COutput(const CWalletTx *txIn, int iIn, int nDepthIn, bool fSpendableIn, bool fSolvableIn, bool fSafeIn, bool use_max_sig_in = false)

+ tx = txIn; i = iIn; nDepth = nDepthIn; fSpendable = fSpendableIn; fSolvable = fSolvableIn; fSafe = fSafeIn; nInputBytes = -1; use_max_sig = use_max_sig_in;

+ nInputBytes = tx->GetSpendSize(i, use_max_sig);

+ inline CInputCoin GetInputCoin() const

+ {

+ return CInputCoin(tx->tx, i, nInputBytes);

+ }

+};

+ /**

+ * Add a transaction to the wallet, or update it. pIndex and posInBlock should

+ * be set when the transaction was known to be included in a block. When

+ * pIndex == nullptr, then wallet state is not updated in AddToWallet, but

+ * notifications happen and cached balances are marked dirty.

+ *

+ * If fUpdate is true, existing transactions will be updated.

+ * TODO: One exception to this is that the abandoned state is cleared under the

+ * assumption that any further notification of a transaction that was considered

+ * abandoned is an indication that it is not safe to be considered abandoned.

+ * Abandoned state should probably be more carefully tracked via different

+ * posInBlock signals or by checking mempool presence when necessary.

+ */

+ bool AddToWalletIfInvolvingMe(const CTransactionRef& tx, const CBlockIndex* pIndex, int posInBlock, bool fUpdate) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

+

+ /* Mark a transaction's inputs dirty, thus forcing the outputs to be recomputed */

+ void MarkInputsDirty(const CTransactionRef& tx);

+

+ /* Used by TransactionAddedToMemorypool/BlockConnected/Disconnected/ScanForWalletTransactions.

+ void SyncTransaction(const CTransactionRef& tx, const CBlockIndex *pindex = nullptr, int posInBlock = 0, bool update_tx = true) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

+ std::atomic<uint64_t> m_wallet_flags{0};

+ typedef std::multimap<int64_t, CWalletTx*> TxItems;

+ void AvailableCoins(std::vector<COutput>& vCoins, bool fOnlySafe=true, const CCoinControl *coinControl = nullptr, const CAmount& nMinimumAmount = 1, const CAmount& nMaximumAmount = MAX_MONEY, const CAmount& nMinimumSumAmount = MAX_MONEY, const uint64_t nMaximumCount = 0, const int nMinDepth = 0, const int nMaxDepth = 9999999) const EXCLUSIVE_LOCKS_REQUIRED(cs_main, cs_wallet);

+ std::map<CTxDestination, std::vector<COutput>> ListCoins() const EXCLUSIVE_LOCKS_REQUIRED(cs_main, cs_wallet);

+ bool SelectCoinsMinConf(const CAmount& nTargetValue, const CoinEligibilityFilter& eligibility_filter, std::vector<OutputGroup> groups,

+ bool IsSpent(const uint256& hash, unsigned int n) const EXCLUSIVE_LOCKS_REQUIRED(cs_main);

+ std::vector<OutputGroup> GroupOutputs(const std::vector<COutput>& outputs, bool single_coin) const;

+ void LoadKeyMetadata(const CKeyID& keyID, const CKeyMetadata &metadata) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

+ void LoadScriptMetadata(const CScriptID& script_id, const CKeyMetadata &metadata) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

+ void LoadDestData(const CTxDestination &dest, const std::string &key, const std::string &value);

+ void LoadToWallet(const CWalletTx& wtxIn);

+ void ResendWalletTransactions(int64_t nBestBlockTime, CConnman* connman) override EXCLUSIVE_LOCKS_REQUIRED(cs_main);

+ std::vector<uint256> ResendWalletTransactionsBefore(int64_t nTime, CConnman* connman) EXCLUSIVE_LOCKS_REQUIRED(cs_main);

+ CAmount GetBalance(const isminefilter& filter=ISMINE_SPENDABLE, const int min_depth=0) const;

+ CAmount GetLegacyBalance(const isminefilter& filter, int minDepth) const;

+ bool CommitTransaction(CTransactionRef tx, mapValue_t mapValue, std::vector<std::pair<std::string, std::string>> orderForm, CReserveKey& reservekey, CConnman* connman, CValidationState& state);

+ bool DummySignTx(CMutableTransaction &txNew, const std::set<CTxOut> &txouts, bool use_max_sig = false) const

+ return DummySignTx(txNew, v_txouts, use_max_sig);

+ bool DummySignTx(CMutableTransaction &txNew, const std::vector<CTxOut> &txouts, bool use_max_sig = false) const;

+ bool DummySignInput(CTxIn &tx_in, const CTxOut &txout, bool use_max_sig = false) const;

+ bool m_allow_fallback_fee{true}; //!< will be defined via chainparams

+ std::map<CTxDestination, CAmount> GetAddressBalances() EXCLUSIVE_LOCKS_REQUIRED(cs_main);

+ void SetMinVersion(enum WalletFeature, WalletBatch* batch_in = nullptr, bool fExplicit = false);

+ /** Wallet is about to be unloaded */

+ boost::signals2::signal<void ()> NotifyUnload;

+

+ static std::shared_ptr<CWallet> CreateWalletFromFile(const std::string& name, const fs::path& path, uint64_t wallet_creation_flags = 0);

+ void SetHDChain(const CHDChain& chain, bool memonly);

+ void SetHDSeed(const CPubKey& key);

+ void BlockUntilSyncedToCurrentChain() LOCKS_EXCLUDED(cs_main, cs_wallet);

+ /** set a single wallet flag */

+ void SetWalletFlag(uint64_t flags);

+

+ /** check if a certain wallet flag is set */

+ bool IsWalletFlagSet(uint64_t flag);

+

+ /** overwrite all flags by the given uint64_t

+ returns false if unknown, non-tolerable flags are present */

+ bool SetWalletFlags(uint64_t overwriteFlags, bool memOnly);

+

+ /** Returns a bracketed wallet name for displaying in logs, will return [default wallet] if the wallet has no name */

+ const std::string GetDisplayName() const {

+ std::string wallet_name = GetName().length() == 0 ? "default wallet" : GetName();

+ return strprintf("[%s]", wallet_name);

+ };

+ /** Prepends the wallet name in logging output to ease debugging in multi-wallet use cases */

+ template<typename... Params>

+ void WalletLogPrintf(std::string fmt, Params... parameters) const {

+ LogPrintf(("%s " + fmt).c_str(), GetDisplayName(), parameters...);

+ };

+

+ /** Implement lookup of key origin information through wallet key metadata. */

+ bool GetKeyOrigin(const CKeyID& keyid, KeyOriginInfo& info) const override;

+// Use DummySignatureCreator, which inserts 71 byte signatures everywhere.

+int64_t CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *wallet, bool use_max_sig = false);

+int64_t CalculateMaximumSignedTxSize(const CTransaction &tx, const CWallet *wallet, const std::vector<CTxOut>& txouts, bool use_max_sig = false);

+// Copyright (c) 2009-2018 The Bitcoin Core developers

+#include <string>

+ std::string unused_string;

+ ssValue >> fTmp >> fUnused >> unused_string;

+ strErr = strprintf("LoadWallet() upgrading tx ver=%d %d %s",

+ wtx.fTimeReceivedIsTxTime, fTmp, hash.ToString());

+ pwallet->LoadDestData(DecodeDestination(strAddress), strKey, strValue);

+ pwallet->SetHDChain(chain, true);

+ } else if (strType == "flags") {

+ uint64_t flags;

+ ssValue >> flags;

+ if (!pwallet->SetWalletFlags(flags, true)) {

+ strErr = "Error reading wallet database: Unknown non-tolerable wallet flags found";

+ } else if (strType != "bestblock" && strType != "bestblock_nomerkle" &&

+ strType != "minversion" && strType != "acentry") {

+ if (nMinVersion > FEATURE_LATEST)

+ pwallet->WalletLogPrintf("Error getting wallet database cursor\n");

+ pwallet->WalletLogPrintf("Error reading next record from wallet database\n");

+ if (IsKeyType(strType) || strType == "defaultkey") {

+ } else if(strType == "flags") {

+ // reading the wallet flags can only fail if unknown flags are present

+ result = DBErrors::TOO_NEW;

+ } else {

+ pwallet->WalletLogPrintf("%s\n", strErr);

+ pwallet->WalletLogPrintf("nFileVersion = %d\n", wss.nFileVersion);

+ pwallet->WalletLogPrintf("Keys: %u plaintext, %u encrypted, %u w/ metadata, %u total. Unknown wallet records: %u\n",

+ for (const uint256& hash : wss.vWalletUpgrade)

+ if (nMinVersion > FEATURE_LATEST)

+ for (const uint256& hash : vTxHash) {

+ for (const uint256& hash : vTxHash) {

+bool WalletBatch::WriteWalletFlags(const uint64_t flags)

+{

+ return WriteIC(std::string("flags"), flags);

+}

+

+// Copyright (c) 2009-2018 The Bitcoin Core developers

+ bool WriteWalletFlags(const uint64_t flags);

+// Copyright (c) 2017-2018 The Bitcoin Core developers

+// Copyright (c) 2017-2018 The Bitcoin Core developers