No OneTemporary
Actions

Size

221 KB

Subscribers

None

View Options

	diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
	index 761cf2332..0cb078c3a 100644
	--- a/src/wallet/wallet.cpp
	+++ b/src/wallet/wallet.cpp
	@@ -1,4500 +1,4502 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2019 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/wallet.h>

	#include <chain.h>
	#include <chainparams.h>
	#include <config.h>
	#include <consensus/consensus.h>
	#include <consensus/validation.h>
	#include <fs.h>
	#include <interfaces/wallet.h>
	#include <key.h>
	#include <key_io.h>
	#include <policy/mempool.h>
	#include <policy/policy.h>
	#include <primitives/block.h>
	#include <primitives/transaction.h>
	#include <random.h>
	#include <script/descriptor.h>
	#include <script/script.h>
	#include <script/sighashtype.h>
	#include <script/sign.h>
	#include <script/signingprovider.h>
	#include <util/bip32.h>
	#include <util/error.h>
	#include <util/moneystr.h>
	#include <util/translation.h>
	#include <util/validation.h>
	#include <wallet/coincontrol.h>
	#include <wallet/fees.h>

	#include <boost/algorithm/string/replace.hpp>

	#include <cassert>

	const std::map<uint64_t, std::string> WALLET_FLAG_CAVEATS{
	{WALLET_FLAG_AVOID_REUSE,
	"You need to rescan the blockchain in order to correctly mark used "
	"destinations in the past. Until this is done, some destinations may "
	"be considered unused, even if the opposite is the case."},
	};

	static RecursiveMutex cs_wallets;
	static std::vector<std::shared_ptr<CWallet>> vpwallets GUARDED_BY(cs_wallets);

	bool AddWallet(const std::shared_ptr<CWallet> &wallet) {
	LOCK(cs_wallets);
	assert(wallet);
	std::vector<std::shared_ptr<CWallet>>::const_iterator i =
	std::find(vpwallets.begin(), vpwallets.end(), wallet);
	if (i != vpwallets.end()) {
	return false;
	}
	vpwallets.push_back(wallet);
	return true;
	}

	bool RemoveWallet(const std::shared_ptr<CWallet> &wallet) {
	assert(wallet);
	// Unregister with the validation interface which also drops shared ponters.
	wallet->m_chain_notifications_handler.reset();
	LOCK(cs_wallets);
	std::vector<std::shared_ptr<CWallet>>::iterator i =
	std::find(vpwallets.begin(), vpwallets.end(), wallet);
	if (i == vpwallets.end()) {
	return false;
	}
	vpwallets.erase(i);
	return true;
	}

	bool HasWallets() {
	LOCK(cs_wallets);
	return !vpwallets.empty();
	}

	std::vector<std::shared_ptr<CWallet>> GetWallets() {
	LOCK(cs_wallets);
	return vpwallets;
	}

	std::shared_ptr<CWallet> GetWallet(const std::string &name) {
	LOCK(cs_wallets);
	for (const std::shared_ptr<CWallet> &wallet : vpwallets) {
	if (wallet->GetName() == name) {
	return wallet;
	}
	}
	return nullptr;
	}

	static Mutex g_wallet_release_mutex;
	static std::condition_variable g_wallet_release_cv;
	static std::set<std::string> g_unloading_wallet_set;

	// Custom deleter for shared_ptr<CWallet>.
	static void ReleaseWallet(CWallet *wallet) {
	const std::string name = wallet->GetName();
	wallet->WalletLogPrintf("Releasing wallet\n");
	wallet->Flush();
	delete wallet;
	// Wallet is now released, notify UnloadWallet, if any.
	{
	LOCK(g_wallet_release_mutex);
	if (g_unloading_wallet_set.erase(name) == 0) {
	// UnloadWallet was not called for this wallet, all done.
	return;
	}
	}
	g_wallet_release_cv.notify_all();
	}

	void UnloadWallet(std::shared_ptr<CWallet> &&wallet) {
	// Mark wallet for unloading.
	const std::string name = wallet->GetName();
	{
	LOCK(g_wallet_release_mutex);
	auto it = g_unloading_wallet_set.insert(name);
	assert(it.second);
	}
	// The wallet can be in use so it's not possible to explicitly unload here.
	// Notify the unload intent so that all remaining shared pointers are
	// released.
	wallet->NotifyUnload();

	// Time to ditch our shared_ptr and wait for ReleaseWallet call.
	wallet.reset();
	{
	WAIT_LOCK(g_wallet_release_mutex, lock);
	while (g_unloading_wallet_set.count(name) == 1) {
	g_wallet_release_cv.wait(lock);
	}
	}
	}

	static const size_t OUTPUT_GROUP_MAX_ENTRIES = 10;

	std::shared_ptr<CWallet> LoadWallet(const CChainParams &chainParams,
	interfaces::Chain &chain,
	const WalletLocation &location,
	std::string &error,
	std::vector<std::string> &warnings) {
	if (!CWallet::Verify(chainParams, chain, location, false, error,
	warnings)) {
	error = "Wallet file verification failed: " + error;
	return nullptr;
	}

	std::shared_ptr<CWallet> wallet = CWallet::CreateWalletFromFile(
	chainParams, chain, location, error, warnings);
	if (!wallet) {
	error = "Wallet loading failed: " + error;
	return nullptr;
	}
	AddWallet(wallet);
	wallet->postInitProcess();
	return wallet;
	}

	std::shared_ptr<CWallet> LoadWallet(const CChainParams &chainParams,
	interfaces::Chain &chain,
	const std::string &name, std::string &error,
	std::vector<std::string> &warnings) {
	return LoadWallet(chainParams, chain, WalletLocation(name), error,
	warnings);
	}

	WalletCreationStatus CreateWallet(const CChainParams &params,
	interfaces::Chain &chain,
	const SecureString &passphrase,
	uint64_t wallet_creation_flags,
	const std::string &name, std::string &error,
	std::vector<std::string> &warnings,
	std::shared_ptr<CWallet> &result) {
	// Indicate that the wallet is actually supposed to be blank and not just
	// blank to make it encrypted
	bool create_blank = (wallet_creation_flags & WALLET_FLAG_BLANK_WALLET);

	// Born encrypted wallets need to be created blank first.
	if (!passphrase.empty()) {
	wallet_creation_flags \|= WALLET_FLAG_BLANK_WALLET;
	}

	// Check the wallet file location
	WalletLocation location(name);
	if (location.Exists()) {
	error = "Wallet " + location.GetName() + " already exists.";
	return WalletCreationStatus::CREATION_FAILED;
	}

	// Wallet::Verify will check if we're trying to create a wallet with a
	// duplicate name.
	if (!CWallet::Verify(params, chain, location, false, error, warnings)) {
	error = "Wallet file verification failed: " + error;
	return WalletCreationStatus::CREATION_FAILED;
	}

	// Do not allow a passphrase when private keys are disabled
	if (!passphrase.empty() &&
	(wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
	error = "Passphrase provided but private keys are disabled. A "
	"passphrase is only used to encrypt private keys, so cannot be "
	"used for wallets with private keys disabled.";
	return WalletCreationStatus::CREATION_FAILED;
	}

	// Make the wallet
	std::shared_ptr<CWallet> wallet = CWallet::CreateWalletFromFile(
	params, chain, location, error, warnings, wallet_creation_flags);
	if (!wallet) {
	error = "Wallet creation failed: " + error;
	return WalletCreationStatus::CREATION_FAILED;
	}

	// Encrypt the wallet
	if (!passphrase.empty() &&
	!(wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
	if (!wallet->EncryptWallet(passphrase)) {
	error = "Error: Wallet created but failed to encrypt.";
	return WalletCreationStatus::ENCRYPTION_FAILED;
	}
	if (!create_blank) {
	// Unlock the wallet
	if (!wallet->Unlock(passphrase)) {
	error = "Error: Wallet was encrypted but could not be unlocked";
	return WalletCreationStatus::ENCRYPTION_FAILED;
	}

	// Set a seed for the wallet
	{
	if (auto spk_man = wallet->m_spk_man.get()) {
	if (!spk_man->SetupGeneration()) {
	error = "Unable to generate initial keys";
	return WalletCreationStatus::CREATION_FAILED;
	}
	}
	}

	// Relock the wallet
	wallet->Lock();
	}
	}
	AddWallet(wallet);
	wallet->postInitProcess();
	result = wallet;
	return WalletCreationStatus::SUCCESS;
	}

	const BlockHash CWalletTx::ABANDON_HASH(uint256S(
	"0000000000000000000000000000000000000000000000000000000000000001"));

	/** @defgroup mapWallet
	*
	* @{
	*/

	std::string COutput::ToString() const {
	return strprintf("COutput(%s, %d, %d) [%s]", tx->GetId().ToString(), i,
	nDepth, FormatMoney(tx->tx->vout[i].nValue));
	}

	const CWalletTx *CWallet::GetWalletTx(const TxId &txid) const {
	LOCK(cs_wallet);
	std::map<TxId, CWalletTx>::const_iterator it = mapWallet.find(txid);
	if (it == mapWallet.end()) {
	return nullptr;
	}

	return &(it->second);
	}

	void CWallet::UpgradeKeyMetadata() {
	if (IsLocked() \|\| IsWalletFlagSet(WALLET_FLAG_KEY_ORIGIN_METADATA)) {
	return;
	}

	if (m_spk_man) {
	AssertLockHeld(m_spk_man->cs_wallet);
	m_spk_man->UpgradeKeyMetadata();
	}
	SetWalletFlag(WALLET_FLAG_KEY_ORIGIN_METADATA);
	}

	bool CWallet::Unlock(const SecureString &strWalletPassphrase,
	bool accept_no_keys) {
	CCrypter crypter;
	CKeyingMaterial _vMasterKey;

	{
	LOCK(cs_wallet);
	for (const MasterKeyMap::value_type &pMasterKey : mapMasterKeys) {
	if (!crypter.SetKeyFromPassphrase(
	strWalletPassphrase, pMasterKey.second.vchSalt,
	pMasterKey.second.nDeriveIterations,
	pMasterKey.second.nDerivationMethod)) {
	return false;
	}
	if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey,
	_vMasterKey)) {
	// try another master key
	continue;
	}
	if (Unlock(_vMasterKey, accept_no_keys)) {
	// Now that we've unlocked, upgrade the key metadata
	UpgradeKeyMetadata();
	return true;
	}
	}
	}

	return false;
	}

	bool CWallet::ChangeWalletPassphrase(
	const SecureString &strOldWalletPassphrase,
	const SecureString &strNewWalletPassphrase) {
	bool fWasLocked = IsLocked();

	LOCK(cs_wallet);
	Lock();

	CCrypter crypter;
	CKeyingMaterial _vMasterKey;
	for (MasterKeyMap::value_type &pMasterKey : mapMasterKeys) {
	if (!crypter.SetKeyFromPassphrase(
	strOldWalletPassphrase, pMasterKey.second.vchSalt,
	pMasterKey.second.nDeriveIterations,
	pMasterKey.second.nDerivationMethod)) {
	return false;
	}

	if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, _vMasterKey)) {
	return false;
	}

	if (Unlock(_vMasterKey)) {
	int64_t nStartTime = GetTimeMillis();
	crypter.SetKeyFromPassphrase(strNewWalletPassphrase,
	pMasterKey.second.vchSalt,
	pMasterKey.second.nDeriveIterations,
	pMasterKey.second.nDerivationMethod);
	pMasterKey.second.nDeriveIterations = static_cast<unsigned int>(
	pMasterKey.second.nDeriveIterations *
	(100 / ((double)(GetTimeMillis() - nStartTime))));

	nStartTime = GetTimeMillis();
	crypter.SetKeyFromPassphrase(strNewWalletPassphrase,
	pMasterKey.second.vchSalt,
	pMasterKey.second.nDeriveIterations,
	pMasterKey.second.nDerivationMethod);
	pMasterKey.second.nDeriveIterations =
	(pMasterKey.second.nDeriveIterations +
	static_cast<unsigned int>(
	pMasterKey.second.nDeriveIterations * 100 /
	double(GetTimeMillis() - nStartTime))) /
	2;

	if (pMasterKey.second.nDeriveIterations < 25000) {
	pMasterKey.second.nDeriveIterations = 25000;
	}

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

	if (!crypter.SetKeyFromPassphrase(
	strNewWalletPassphrase, pMasterKey.second.vchSalt,
	pMasterKey.second.nDeriveIterations,
	pMasterKey.second.nDerivationMethod)) {
	return false;
	}

	if (!crypter.Encrypt(_vMasterKey,
	pMasterKey.second.vchCryptedKey)) {
	return false;
	}

	WalletBatch(*database).WriteMasterKey(pMasterKey.first,
	pMasterKey.second);
	if (fWasLocked) {
	Lock();
	}

	return true;
	}
	}

	return false;
	}

	void CWallet::ChainStateFlushed(const CBlockLocator &loc) {
	WalletBatch batch(*database);
	batch.WriteBestBlock(loc);
	}

	void CWallet::SetMinVersion(enum WalletFeature nVersion, WalletBatch *batch_in,
	bool fExplicit) {
	LOCK(cs_wallet);
	if (nWalletVersion >= nVersion) {
	return;
	}

	// When doing an explicit upgrade, if we pass the max version permitted,
	// upgrade all the way.
	if (fExplicit && nVersion > nWalletMaxVersion) {
	nVersion = FEATURE_LATEST;
	}

	nWalletVersion = nVersion;

	if (nVersion > nWalletMaxVersion) {
	nWalletMaxVersion = nVersion;
	}

	WalletBatch batch = batch_in ? batch_in : new WalletBatch(database);
	if (nWalletVersion > 40000) {
	batch->WriteMinVersion(nWalletVersion);
	}
	if (!batch_in) {
	delete batch;
	}
	}

	bool CWallet::SetMaxVersion(int nVersion) {
	LOCK(cs_wallet);

	// Cannot downgrade below current version
	if (nWalletVersion > nVersion) {
	return false;
	}

	nWalletMaxVersion = nVersion;

	return true;
	}

	std::set<TxId> CWallet::GetConflicts(const TxId &txid) const {
	std::set<TxId> result;
	AssertLockHeld(cs_wallet);

	std::map<TxId, CWalletTx>::const_iterator it = mapWallet.find(txid);
	if (it == mapWallet.end()) {
	return result;
	}

	const CWalletTx &wtx = it->second;

	std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;

	for (const CTxIn &txin : wtx.tx->vin) {
	if (mapTxSpends.count(txin.prevout) <= 1) {
	// No conflict if zero or one spends.
	continue;
	}

	range = mapTxSpends.equal_range(txin.prevout);
	for (TxSpends::const_iterator _it = range.first; _it != range.second;
	++_it) {
	result.insert(_it->second);
	}
	}

	return result;
	}

	bool CWallet::HasWalletSpend(const TxId &txid) const {
	AssertLockHeld(cs_wallet);
	auto iter = mapTxSpends.lower_bound(COutPoint(txid, 0));
	return (iter != mapTxSpends.end() && iter->first.GetTxId() == txid);
	}

	void CWallet::Flush(bool shutdown) {
	database->Flush(shutdown);
	}

	void CWallet::SyncMetaData(
	std::pair<TxSpends::iterator, TxSpends::iterator> range) {
	// We want all the wallet transactions in range to have the same metadata as
	// the oldest (smallest nOrderPos).
	// So: find smallest nOrderPos:

	int nMinOrderPos = std::numeric_limits<int>::max();
	const CWalletTx *copyFrom = nullptr;
	for (TxSpends::iterator it = range.first; it != range.second; ++it) {
	const CWalletTx *wtx = &mapWallet.at(it->second);
	if (wtx->nOrderPos < nMinOrderPos) {
	nMinOrderPos = wtx->nOrderPos;
	copyFrom = wtx;
	}
	}

	if (!copyFrom) {
	return;
	}

	// Now copy data from copyFrom to rest:
	for (TxSpends::iterator it = range.first; it != range.second; ++it) {
	const TxId &txid = it->second;
	CWalletTx *copyTo = &mapWallet.at(txid);
	if (copyFrom == copyTo) {
	continue;
	}

	assert(
	copyFrom &&
	"Oldest wallet transaction in range assumed to have been found.");

	if (!copyFrom->IsEquivalentTo(*copyTo)) {
	continue;
	}

	copyTo->mapValue = copyFrom->mapValue;
	copyTo->vOrderForm = copyFrom->vOrderForm;
	// fTimeReceivedIsTxTime not copied on purpose nTimeReceived not copied
	// on purpose.
	copyTo->nTimeSmart = copyFrom->nTimeSmart;
	copyTo->fFromMe = copyFrom->fFromMe;
	// nOrderPos not copied on purpose cached members not copied on purpose.
	}
	}

	/**
	* Outpoint is spent if any non-conflicted transaction, spends it:
	*/
	bool CWallet::IsSpent(interfaces::Chain::Lock &locked_chain,
	const COutPoint &outpoint) const {
	std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range =
	mapTxSpends.equal_range(outpoint);

	for (TxSpends::const_iterator it = range.first; it != range.second; ++it) {
	const TxId &wtxid = it->second;
	std::map<TxId, CWalletTx>::const_iterator mit = mapWallet.find(wtxid);
	if (mit != mapWallet.end()) {
	int depth = mit->second.GetDepthInMainChain(locked_chain);
	if (depth > 0 \|\| (depth == 0 && !mit->second.isAbandoned())) {
	// Spent
	return true;
	}
	}
	}

	return false;
	}

	void CWallet::AddToSpends(const COutPoint &outpoint, const TxId &wtxid) {
	mapTxSpends.insert(std::make_pair(outpoint, wtxid));

	setLockedCoins.erase(outpoint);

	std::pair<TxSpends::iterator, TxSpends::iterator> range;
	range = mapTxSpends.equal_range(outpoint);
	SyncMetaData(range);
	}

	void CWallet::AddToSpends(const TxId &wtxid) {
	auto it = mapWallet.find(wtxid);
	assert(it != mapWallet.end());
	CWalletTx &thisTx = it->second;
	// Coinbases don't spend anything!
	if (thisTx.IsCoinBase()) {
	return;
	}

	for (const CTxIn &txin : thisTx.tx->vin) {
	AddToSpends(txin.prevout, wtxid);
	}
	}

	bool CWallet::EncryptWallet(const SecureString &strWalletPassphrase) {
	if (IsCrypted()) {
	return false;
	}

	CKeyingMaterial _vMasterKey;

	_vMasterKey.resize(WALLET_CRYPTO_KEY_SIZE);
	GetStrongRandBytes(&_vMasterKey[0], WALLET_CRYPTO_KEY_SIZE);

	CMasterKey kMasterKey;

	kMasterKey.vchSalt.resize(WALLET_CRYPTO_SALT_SIZE);
	GetStrongRandBytes(&kMasterKey.vchSalt[0], WALLET_CRYPTO_SALT_SIZE);

	CCrypter crypter;
	int64_t nStartTime = GetTimeMillis();
	crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, 25000,
	kMasterKey.nDerivationMethod);
	kMasterKey.nDeriveIterations = static_cast<unsigned int>(
	2500000 / double(GetTimeMillis() - nStartTime));

	nStartTime = GetTimeMillis();
	crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt,
	kMasterKey.nDeriveIterations,
	kMasterKey.nDerivationMethod);
	kMasterKey.nDeriveIterations =
	(kMasterKey.nDeriveIterations +
	static_cast<unsigned int>(kMasterKey.nDeriveIterations * 100 /
	double(GetTimeMillis() - nStartTime))) /
	2;

	if (kMasterKey.nDeriveIterations < 25000) {
	kMasterKey.nDeriveIterations = 25000;
	}

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

	if (!crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt,
	kMasterKey.nDeriveIterations,
	kMasterKey.nDerivationMethod)) {
	return false;
	}

	if (!crypter.Encrypt(_vMasterKey, kMasterKey.vchCryptedKey)) {
	return false;
	}

	{
	LOCK(cs_wallet);
	mapMasterKeys[++nMasterKeyMaxID] = kMasterKey;
	assert(!encrypted_batch);
	encrypted_batch = new WalletBatch(*database);
	if (!encrypted_batch->TxnBegin()) {
	delete encrypted_batch;
	encrypted_batch = nullptr;
	return false;
	}
	encrypted_batch->WriteMasterKey(nMasterKeyMaxID, kMasterKey);

	if (auto spk_man = m_spk_man.get()) {
	if (!spk_man->EncryptKeys(_vMasterKey)) {
	encrypted_batch->TxnAbort();
	delete encrypted_batch;
	encrypted_batch = nullptr;
	// We now probably have half of our keys encrypted in memory,
	// and half not... die and let the user reload the unencrypted
	// wallet.
	assert(false);
	}
	}

	// Encryption was introduced in version 0.4.0
	SetMinVersion(FEATURE_WALLETCRYPT, encrypted_batch, true);

	if (!encrypted_batch->TxnCommit()) {
	delete encrypted_batch;
	encrypted_batch = nullptr;
	// We now have keys encrypted in memory, but not on disk...
	// die to avoid confusion and let the user reload the unencrypted
	// wallet.
	assert(false);
	}

	delete encrypted_batch;
	encrypted_batch = nullptr;

	Lock();
	Unlock(strWalletPassphrase);

	// if we are using HD, replace the HD seed with a new one
	if (auto spk_man = m_spk_man.get()) {
	if (spk_man->IsHDEnabled()) {
	if (!spk_man->SetupGeneration(true)) {
	return false;
	}
	}
	}
	Lock();

	// Need to completely rewrite the wallet file; if we don't, bdb might
	// keep bits of the unencrypted private key in slack space in the
	// database file.
	database->Rewrite();

	// 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();
	}

	NotifyStatusChanged(this);
	return true;
	}

	DBErrors CWallet::ReorderTransactions() {
	LOCK(cs_wallet);
	WalletBatch batch(*database);

	// Old wallets didn't have any defined order for transactions. Probably a
	// bad idea to change the output of this.

	// First: get all CWalletTx into a sorted-by-time
	// multimap.
	TxItems txByTime;

	for (auto &entry : mapWallet) {
	CWalletTx *wtx = &entry.second;
	txByTime.insert(std::make_pair(wtx->nTimeReceived, wtx));
	}

	nOrderPosNext = 0;
	std::vector<int64_t> nOrderPosOffsets;
	for (TxItems::iterator it = txByTime.begin(); it != txByTime.end(); ++it) {
	CWalletTx const pwtx = (it).second;
	int64_t &nOrderPos = pwtx->nOrderPos;

	if (nOrderPos == -1) {
	nOrderPos = nOrderPosNext++;
	nOrderPosOffsets.push_back(nOrderPos);

	if (!batch.WriteTx(*pwtx)) {
	return DBErrors::LOAD_FAIL;
	}
	} else {
	int64_t nOrderPosOff = 0;
	for (const int64_t &nOffsetStart : nOrderPosOffsets) {
	if (nOrderPos >= nOffsetStart) {
	++nOrderPosOff;
	}
	}

	nOrderPos += nOrderPosOff;
	nOrderPosNext = std::max(nOrderPosNext, nOrderPos + 1);

	if (!nOrderPosOff) {
	continue;
	}

	// Since we're changing the order, write it back.
	if (!batch.WriteTx(*pwtx)) {
	return DBErrors::LOAD_FAIL;
	}
	}
	}

	batch.WriteOrderPosNext(nOrderPosNext);

	return DBErrors::LOAD_OK;
	}

	int64_t CWallet::IncOrderPosNext(WalletBatch *batch) {
	AssertLockHeld(cs_wallet);
	int64_t nRet = nOrderPosNext++;
	if (batch) {
	batch->WriteOrderPosNext(nOrderPosNext);
	} else {
	WalletBatch(*database).WriteOrderPosNext(nOrderPosNext);
	}

	return nRet;
	}

	void CWallet::MarkDirty() {
	LOCK(cs_wallet);
	for (std::pair<const TxId, CWalletTx> &item : mapWallet) {
	item.second.MarkDirty();
	}
	}

	void CWallet::SetUsedDestinationState(const TxId &hash, unsigned int n,
	bool used) {
	const CWalletTx *srctx = GetWalletTx(hash);
	if (!srctx) {
	return;
	}

	CTxDestination dst;
	if (ExtractDestination(srctx->tx->vout[n].scriptPubKey, dst)) {
	if (IsMine(dst)) {
	LOCK(cs_wallet);
	if (used && !GetDestData(dst, "used", nullptr)) {
	// p for "present", opposite of absent (null)
	AddDestData(dst, "used", "p");
	} else if (!used && GetDestData(dst, "used", nullptr)) {
	EraseDestData(dst, "used");
	}
	}
	}
	}

	bool CWallet::IsUsedDestination(const CTxDestination &dst) const {
	LOCK(cs_wallet);
	return IsMine(dst) && GetDestData(dst, "used", nullptr);
	}

	bool CWallet::IsUsedDestination(const TxId &txid, unsigned int n) const {
	CTxDestination dst;
	const CWalletTx *srctx = GetWalletTx(txid);
	return srctx && ExtractDestination(srctx->tx->vout[n].scriptPubKey, dst) &&
	IsUsedDestination(dst);
	}

	bool CWallet::AddToWallet(const CWalletTx &wtxIn, bool fFlushOnClose) {
	LOCK(cs_wallet);

	WalletBatch batch(*database, "r+", fFlushOnClose);

	const TxId &txid = wtxIn.GetId();

	if (IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE)) {
	// Mark used destinations
	for (const CTxIn &txin : wtxIn.tx->vin) {
	const COutPoint &op = txin.prevout;
	SetUsedDestinationState(op.GetTxId(), op.GetN(), true);
	}
	}

	// Inserts only if not already there, returns tx inserted or tx found.
	std::pair<std::map<TxId, CWalletTx>::iterator, bool> ret =
	mapWallet.insert(std::make_pair(txid, wtxIn));
	CWalletTx &wtx = (*ret.first).second;
	wtx.BindWallet(this);
	bool fInsertedNew = ret.second;
	if (fInsertedNew) {
	wtx.nTimeReceived = chain().getAdjustedTime();
	wtx.nOrderPos = IncOrderPosNext(&batch);
	wtx.m_it_wtxOrdered =
	wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));
	wtx.nTimeSmart = ComputeTimeSmart(wtx);
	AddToSpends(txid);
	}

	bool fUpdated = false;
	if (!fInsertedNew) {
	if (wtxIn.m_confirm.status != wtx.m_confirm.status) {
	wtx.m_confirm.status = wtxIn.m_confirm.status;
	wtx.m_confirm.nIndex = wtxIn.m_confirm.nIndex;
	wtx.m_confirm.hashBlock = wtxIn.m_confirm.hashBlock;
	wtx.m_confirm.block_height = wtxIn.m_confirm.block_height;
	fUpdated = true;
	} else {
	assert(wtx.m_confirm.nIndex == wtxIn.m_confirm.nIndex);
	assert(wtx.m_confirm.hashBlock == wtxIn.m_confirm.hashBlock);
	assert(wtx.m_confirm.block_height == wtxIn.m_confirm.block_height);
	}

	if (wtxIn.fFromMe && wtxIn.fFromMe != wtx.fFromMe) {
	wtx.fFromMe = wtxIn.fFromMe;
	fUpdated = true;
	}
	}

	//// debug print
	WalletLogPrintf("AddToWallet %s %s%s\n", wtxIn.GetId().ToString(),
	(fInsertedNew ? "new" : ""), (fUpdated ? "update" : ""));

	// Write to disk
	if ((fInsertedNew \|\| fUpdated) && !batch.WriteTx(wtx)) {
	return false;
	}

	// Break debit/credit balance caches:
	wtx.MarkDirty();

	// Notify UI of new or updated transaction.
	NotifyTransactionChanged(this, txid, fInsertedNew ? CT_NEW : CT_UPDATED);

	#if defined(HAVE_SYSTEM)
	// Notify an external script when a wallet transaction comes in or is
	// updated.
	std::string strCmd = gArgs.GetArg("-walletnotify", "");

	if (!strCmd.empty()) {
	boost::replace_all(strCmd, "%s", wtxIn.GetId().GetHex());
	std::thread t(runCommand, strCmd);
	// Thread runs free.
	t.detach();
	}
	#endif

	return true;
	}

	void CWallet::LoadToWallet(CWalletTx &wtxIn) {
	// If wallet doesn't have a chain (e.g wallet-tool), lock can't be taken.
	auto locked_chain = LockChain();
	if (locked_chain) {
	Optional<int> block_height =
	locked_chain->getBlockHeight(wtxIn.m_confirm.hashBlock);
	if (block_height) {
	// Update cached block height variable since it not stored in the
	// serialized transaction.
	wtxIn.m_confirm.block_height = *block_height;
	} else if (wtxIn.isConflicted() \|\| wtxIn.isConfirmed()) {
	// If tx block (or conflicting block) was reorged out of chain
	// while the wallet was shutdown, change tx status to UNCONFIRMED
	// and reset block height, hash, and index. ABANDONED tx don't have
	// associated blocks and don't need to be updated. The case where a
	// transaction was reorged out while online and then reconfirmed
	// while offline is covered by the rescan logic.
	wtxIn.setUnconfirmed();
	wtxIn.m_confirm.hashBlock = BlockHash();
	wtxIn.m_confirm.block_height = 0;
	wtxIn.m_confirm.nIndex = 0;
	}
	}
	const TxId &txid = wtxIn.GetId();
	const auto &ins = mapWallet.emplace(txid, wtxIn);
	CWalletTx &wtx = ins.first->second;
	wtx.BindWallet(this);
	if (/* insertion took place */ ins.second) {
	wtx.m_it_wtxOrdered =
	wtxOrdered.insert(std::make_pair(wtx.nOrderPos, &wtx));
	}
	AddToSpends(txid);
	for (const CTxIn &txin : wtx.tx->vin) {
	auto it = mapWallet.find(txin.prevout.GetTxId());
	if (it != mapWallet.end()) {
	CWalletTx &prevtx = it->second;
	if (prevtx.isConflicted()) {
	MarkConflicted(prevtx.m_confirm.hashBlock,
	prevtx.m_confirm.block_height, wtx.GetId());
	}
	}
	}
	}

	bool CWallet::AddToWalletIfInvolvingMe(const CTransactionRef &ptx,
	CWalletTx::Confirmation confirm,
	bool fUpdate) {
	const CTransaction &tx = *ptx;
	AssertLockHeld(cs_wallet);

	if (!confirm.hashBlock.IsNull()) {
	for (const CTxIn &txin : tx.vin) {
	std::pair<TxSpends::const_iterator, TxSpends::const_iterator>
	range = mapTxSpends.equal_range(txin.prevout);
	while (range.first != range.second) {
	if (range.first->second != tx.GetId()) {
	WalletLogPrintf(
	"Transaction %s (in block %s) conflicts with wallet "
	"transaction %s (both spend %s:%i)\n",
	tx.GetId().ToString(), confirm.hashBlock.ToString(),
	range.first->second.ToString(),
	range.first->first.GetTxId().ToString(),
	range.first->first.GetN());
	MarkConflicted(confirm.hashBlock, confirm.block_height,
	range.first->second);
	}
	range.first++;
	}
	}
	}

	bool fExisted = mapWallet.count(tx.GetId()) != 0;
	if (fExisted && !fUpdate) {
	return false;
	}
	if (fExisted \|\| IsMine(tx) \|\| IsFromMe(tx)) {
	/**
	* Check if any keys in the wallet keypool that were supposed to be
	* unused have appeared in a new transaction. If so, remove those keys
	* from the keypool. This can happen when restoring an old wallet backup
	* that does not contain the mostly recently created transactions from
	* newer versions of the wallet.
	*/

	// loop though all outputs
	for (const CTxOut &txout : tx.vout) {
	if (auto spk_man = m_spk_man.get()) {
	spk_man->MarkUnusedAddresses(txout.scriptPubKey);
	}
	}

	CWalletTx wtx(this, ptx);

	// Block disconnection override an abandoned tx as unconfirmed
	// which means user may have to call abandontransaction again
	wtx.m_confirm = confirm;

	return AddToWallet(wtx, false);
	}

	return false;
	}

	bool CWallet::TransactionCanBeAbandoned(const TxId &txid) const {
	auto locked_chain = chain().lock();
	LOCK(cs_wallet);
	const CWalletTx *wtx = GetWalletTx(txid);
	return wtx && !wtx->isAbandoned() &&
	wtx->GetDepthInMainChain(*locked_chain) == 0 && !wtx->InMempool();
	}

	void CWallet::MarkInputsDirty(const CTransactionRef &tx) {
	for (const CTxIn &txin : tx->vin) {
	auto it = mapWallet.find(txin.prevout.GetTxId());
	if (it != mapWallet.end()) {
	it->second.MarkDirty();
	}
	}
	}

	bool CWallet::AbandonTransaction(interfaces::Chain::Lock &locked_chain,
	const TxId &txid) {
	// Temporary. Removed in upcoming lock cleanup
	auto locked_chain_recursive = chain().lock();
	LOCK(cs_wallet);

	WalletBatch batch(*database, "r+");

	std::set<TxId> todo;
	std::set<TxId> done;

	// Can't mark abandoned if confirmed or in mempool
	auto it = mapWallet.find(txid);
	assert(it != mapWallet.end());
	CWalletTx &origtx = it->second;
	if (origtx.GetDepthInMainChain(locked_chain) != 0 \|\| origtx.InMempool()) {
	return false;
	}

	todo.insert(txid);

	while (!todo.empty()) {
	const TxId now = *todo.begin();
	todo.erase(now);
	done.insert(now);
	it = mapWallet.find(now);
	assert(it != mapWallet.end());
	CWalletTx &wtx = it->second;
	int currentconfirm = wtx.GetDepthInMainChain(locked_chain);
	// If the orig tx was not in block, none of its spends can be.
	assert(currentconfirm <= 0);
	// If (currentconfirm < 0) {Tx and spends are already conflicted, no
	// need to abandon}
	if (currentconfirm == 0 && !wtx.isAbandoned()) {
	// If the orig tx was not in block/mempool, none of its spends can
	// be in mempool.
	assert(!wtx.InMempool());
	wtx.setAbandoned();
	wtx.MarkDirty();
	batch.WriteTx(wtx);
	NotifyTransactionChanged(this, wtx.GetId(), CT_UPDATED);
	// Iterate over all its outputs, and mark transactions in the wallet
	// that spend them abandoned too.
	TxSpends::const_iterator iter =
	mapTxSpends.lower_bound(COutPoint(now, 0));
	while (iter != mapTxSpends.end() && iter->first.GetTxId() == now) {
	if (!done.count(iter->second)) {
	todo.insert(iter->second);
	}
	iter++;
	}

	// If a transaction changes 'conflicted' state, that changes the
	// balance available of the outputs it spends. So force those to be
	// recomputed.
	MarkInputsDirty(wtx.tx);
	}
	}

	return true;
	}

	void CWallet::MarkConflicted(const BlockHash &hashBlock, int conflicting_height,
	const TxId &txid) {
	auto locked_chain = chain().lock();
	LOCK(cs_wallet);

	int conflictconfirms = -locked_chain->getBlockDepth(hashBlock);

	// If number of conflict confirms cannot be determined, this means that the
	// block is still unknown or not yet part of the main chain, for example
	// when loading the wallet during a reindex. Do nothing in that case.
	if (conflictconfirms >= 0) {
	return;
	}

	// Do not flush the wallet here for performance reasons.
	WalletBatch batch(*database, "r+", false);

	std::set<TxId> todo;
	std::set<TxId> done;

	todo.insert(txid);

	while (!todo.empty()) {
	const TxId now = *todo.begin();
	todo.erase(now);
	done.insert(now);
	auto it = mapWallet.find(now);
	assert(it != mapWallet.end());
	CWalletTx &wtx = it->second;
	int currentconfirm = wtx.GetDepthInMainChain(*locked_chain);
	if (conflictconfirms < currentconfirm) {
	// Block is 'more conflicted' than current confirm; update.
	// Mark transaction as conflicted with this block.
	wtx.m_confirm.nIndex = 0;
	wtx.m_confirm.hashBlock = hashBlock;
	wtx.m_confirm.block_height = conflicting_height;
	wtx.setConflicted();
	wtx.MarkDirty();
	batch.WriteTx(wtx);
	// Iterate over all its outputs, and mark transactions in the wallet
	// that spend them conflicted too.
	TxSpends::const_iterator iter =
	mapTxSpends.lower_bound(COutPoint(now, 0));
	while (iter != mapTxSpends.end() && iter->first.GetTxId() == now) {
	if (!done.count(iter->second)) {
	todo.insert(iter->second);
	}
	iter++;
	}
	// If a transaction changes 'conflicted' state, that changes the
	// balance available of the outputs it spends. So force those to be
	// recomputed.
	MarkInputsDirty(wtx.tx);
	}
	}
	}

	void CWallet::SyncTransaction(const CTransactionRef &ptx,
	CWalletTx::Confirmation confirm, bool update_tx) {
	if (!AddToWalletIfInvolvingMe(ptx, confirm, update_tx)) {
	// Not one of ours
	return;
	}

	// If a transaction changes 'conflicted' state, that changes the balance
	// available of the outputs it spends. So force those to be
	// recomputed, also:
	MarkInputsDirty(ptx);
	}

	void CWallet::TransactionAddedToMempool(const CTransactionRef &ptx) {
	auto locked_chain = chain().lock();
	LOCK(cs_wallet);
	CWalletTx::Confirmation confirm(CWalletTx::Status::UNCONFIRMED,
	/* block_height */ 0, BlockHash(),
	/* nIndex */ 0);
	SyncTransaction(ptx, confirm);

	auto it = mapWallet.find(ptx->GetId());
	if (it != mapWallet.end()) {
	it->second.fInMempool = true;
	}
	}

	void CWallet::TransactionRemovedFromMempool(const CTransactionRef &ptx) {
	LOCK(cs_wallet);
	auto it = mapWallet.find(ptx->GetId());
	if (it != mapWallet.end()) {
	it->second.fInMempool = false;
	}
	}

	void CWallet::BlockConnected(const CBlock &block,
	const std::vector<CTransactionRef> &vtxConflicted,
	int height) {
	const BlockHash &block_hash = block.GetHash();
	auto locked_chain = chain().lock();
	LOCK(cs_wallet);

	m_last_block_processed_height = height;
	m_last_block_processed = block_hash;
	for (size_t index = 0; index < block.vtx.size(); index++) {
	CWalletTx::Confirmation confirm(CWalletTx::Status::CONFIRMED, height,
	block_hash, index);
	SyncTransaction(block.vtx[index], confirm);
	TransactionRemovedFromMempool(block.vtx[index]);
	}
	for (const CTransactionRef &ptx : vtxConflicted) {
	TransactionRemovedFromMempool(ptx);
	}
	}

	void CWallet::BlockDisconnected(const CBlock &block, int height) {
	auto locked_chain = chain().lock();
	LOCK(cs_wallet);

	// At block disconnection, this will change an abandoned transaction to
	// be unconfirmed, whether or not the transaction is added back to the
	// mempool. User may have to call abandontransaction again. It may be
	// addressed in the future with a stickier abandoned state or even removing
	// abandontransaction call.
	m_last_block_processed_height = height - 1;
	m_last_block_processed = block.hashPrevBlock;
	for (const CTransactionRef &ptx : block.vtx) {
	CWalletTx::Confirmation confirm(CWalletTx::Status::UNCONFIRMED,
	/* block_height */ 0, BlockHash(),
	/* nIndex */ 0);
	SyncTransaction(ptx, confirm);
	}
	}

	void CWallet::UpdatedBlockTip() {
	m_best_block_time = GetTime();
	}

	void CWallet::BlockUntilSyncedToCurrentChain() {
	AssertLockNotHeld(cs_wallet);
	// Skip the queue-draining stuff if we know we're caught up with
	// chainActive.Tip(), otherwise put a callback in the validation interface
	// queue and wait for the queue to drain enough to execute it (indicating we
	// are caught up at least with the time we entered this function).
	const BlockHash last_block_hash =
	WITH_LOCK(cs_wallet, return m_last_block_processed);
	chain().waitForNotificationsIfTipChanged(last_block_hash);
	}

	isminetype CWallet::IsMine(const CTxIn &txin) const {
	LOCK(cs_wallet);
	std::map<TxId, CWalletTx>::const_iterator mi =
	mapWallet.find(txin.prevout.GetTxId());
	if (mi != mapWallet.end()) {
	const CWalletTx &prev = (*mi).second;
	if (txin.prevout.GetN() < prev.tx->vout.size()) {
	return IsMine(prev.tx->vout[txin.prevout.GetN()]);
	}
	}

	return ISMINE_NO;
	}

	// Note that this function doesn't distinguish between a 0-valued input, and a
	// not-"is mine" (according to the filter) input.
	Amount CWallet::GetDebit(const CTxIn &txin, const isminefilter &filter) const {
	LOCK(cs_wallet);
	std::map<TxId, CWalletTx>::const_iterator mi =
	mapWallet.find(txin.prevout.GetTxId());
	if (mi != mapWallet.end()) {
	const CWalletTx &prev = (*mi).second;
	if (txin.prevout.GetN() < prev.tx->vout.size()) {
	if (IsMine(prev.tx->vout[txin.prevout.GetN()]) & filter) {
	return prev.tx->vout[txin.prevout.GetN()].nValue;
	}
	}
	}

	return Amount::zero();
	}

	isminetype CWallet::IsMine(const CTxOut &txout) const {
	return IsMine(txout.scriptPubKey);
	}

	isminetype CWallet::IsMine(const CTxDestination &dest) const {
	return IsMine(GetScriptForDestination(dest));
	}

	isminetype CWallet::IsMine(const CScript &script) const {
	isminetype result = ISMINE_NO;
	if (auto spk_man = m_spk_man.get()) {
	result = spk_man->IsMine(script);
	}
	return result;
	}

	Amount CWallet::GetCredit(const CTxOut &txout,
	const isminefilter &filter) const {
	if (!MoneyRange(txout.nValue)) {
	throw std::runtime_error(std::string(__func__) +
	": value out of range");
	}

	return (IsMine(txout) & filter) ? txout.nValue : Amount::zero();
	}

	bool CWallet::IsChange(const CTxOut &txout) const {
	return IsChange(txout.scriptPubKey);
	}

	bool CWallet::IsChange(const CScript &script) const {
	// TODO: fix handling of 'change' outputs. The assumption is that any
	// payment to a script that is ours, but is not in the address book is
	// change. That assumption is likely to break when we implement
	// multisignature wallets that return change back into a
	// multi-signature-protected address; a better way of identifying which
	// outputs are 'the send' and which are 'the change' will need to be
	// implemented (maybe extend CWalletTx to remember which output, if any, was
	// change).
	if (IsMine(script)) {
	CTxDestination address;
	if (!ExtractDestination(script, address)) {
	return true;
	}

	LOCK(cs_wallet);
	if (!mapAddressBook.count(address)) {
	return true;
	}
	}

	return false;
	}

	Amount CWallet::GetChange(const CTxOut &txout) const {
	if (!MoneyRange(txout.nValue)) {
	throw std::runtime_error(std::string(__func__) +
	": value out of range");
	}

	return (IsChange(txout) ? txout.nValue : Amount::zero());
	}

	bool CWallet::IsMine(const CTransaction &tx) const {
	for (const CTxOut &txout : tx.vout) {
	if (IsMine(txout)) {
	return true;
	}
	}

	return false;
	}

	bool CWallet::IsFromMe(const CTransaction &tx) const {
	return GetDebit(tx, ISMINE_ALL) > Amount::zero();
	}

	Amount CWallet::GetDebit(const CTransaction &tx,
	const isminefilter &filter) const {
	Amount nDebit = Amount::zero();
	for (const CTxIn &txin : tx.vin) {
	nDebit += GetDebit(txin, filter);
	if (!MoneyRange(nDebit)) {
	throw std::runtime_error(std::string(__func__) +
	": value out of range");
	}
	}

	return nDebit;
	}

	bool CWallet::IsAllFromMe(const CTransaction &tx,
	const isminefilter &filter) const {
	LOCK(cs_wallet);

	for (const CTxIn &txin : tx.vin) {
	auto mi = mapWallet.find(txin.prevout.GetTxId());
	if (mi == mapWallet.end()) {
	// Any unknown inputs can't be from us.
	return false;
	}

	const CWalletTx &prev = (*mi).second;

	if (txin.prevout.GetN() >= prev.tx->vout.size()) {
	// Invalid input!
	return false;
	}

	if (!(IsMine(prev.tx->vout[txin.prevout.GetN()]) & filter)) {
	return false;
	}
	}

	return true;
	}

	Amount CWallet::GetCredit(const CTransaction &tx,
	const isminefilter &filter) const {
	Amount nCredit = Amount::zero();
	for (const CTxOut &txout : tx.vout) {
	nCredit += GetCredit(txout, filter);
	if (!MoneyRange(nCredit)) {
	throw std::runtime_error(std::string(__func__) +
	": value out of range");
	}
	}

	return nCredit;
	}

	Amount CWallet::GetChange(const CTransaction &tx) const {
	Amount nChange = Amount::zero();
	for (const CTxOut &txout : tx.vout) {
	nChange += GetChange(txout);
	if (!MoneyRange(nChange)) {
	throw std::runtime_error(std::string(__func__) +
	": value out of range");
	}
	}

	return nChange;
	}

	bool CWallet::IsHDEnabled() const {
	bool result = true;
	if (auto spk_man = m_spk_man.get()) {
	result &= spk_man->IsHDEnabled();
	}
	return result;
	}

	bool CWallet::CanGetAddresses(bool internal) {
	{
	auto spk_man = m_spk_man.get();
	if (spk_man && spk_man->CanGetAddresses(internal)) {
	return true;
	}
	}
	return false;
	}

	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");
	}
	}

	void CWallet::UnsetWalletFlag(uint64_t flag) {
	WalletBatch batch(*database);
	UnsetWalletFlagWithDB(batch, flag);
	}

	void CWallet::UnsetWalletFlagWithDB(WalletBatch &batch, uint64_t flag) {
	LOCK(cs_wallet);
	m_wallet_flags &= ~flag;
	if (!batch.WriteWalletFlags(m_wallet_flags)) {
	throw std::runtime_error(std::string(__func__) +
	": writing wallet flags failed");
	}
	}

	void CWallet::UnsetBlankWalletFlag(WalletBatch &batch) {
	UnsetWalletFlagWithDB(batch, WALLET_FLAG_BLANK_WALLET);
	}

	bool CWallet::IsWalletFlagSet(uint64_t flag) const {
	return (m_wallet_flags & flag);
	}

	bool CWallet::SetWalletFlags(uint64_t overwriteFlags, bool memonly) {
	LOCK(cs_wallet);
	m_wallet_flags = overwriteFlags;
	if (((overwriteFlags & 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 {
	// Fill in dummy signatures for fee calculation.
	const CScript &scriptPubKey = txout.scriptPubKey;
	SignatureData sigdata;

	const SigningProvider *provider = GetSigningProvider();

	if (!ProduceSignature(*provider,
	use_max_sig ? DUMMY_MAXIMUM_SIGNATURE_CREATOR
	: DUMMY_SIGNATURE_CREATOR,
	scriptPubKey, sigdata)) {
	return false;
	}

	UpdateInput(tx_in, sigdata);
	return true;
	}

	// 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 {
	// Fill in dummy signatures for fee calculation.
	int nIn = 0;
	for (const auto &txout : txouts) {
	if (!DummySignInput(txNew.vin[nIn], txout, use_max_sig)) {
	return false;
	}

	nIn++;
	}
	return true;
	}

	bool CWallet::ImportScripts(const std::set<CScript> scripts,
	int64_t timestamp) {
	auto spk_man = GetLegacyScriptPubKeyMan();
	if (!spk_man) {
	return false;
	}
	AssertLockHeld(spk_man->cs_wallet);
	return spk_man->ImportScripts(scripts, timestamp);
	}

	bool CWallet::ImportPrivKeys(const std::map<CKeyID, CKey> &privkey_map,
	const int64_t timestamp) {
	auto spk_man = GetLegacyScriptPubKeyMan();
	if (!spk_man) {
	return false;
	}
	AssertLockHeld(spk_man->cs_wallet);
	return spk_man->ImportPrivKeys(privkey_map, timestamp);
	}

	bool CWallet::ImportPubKeys(
	const std::vector<CKeyID> &ordered_pubkeys,
	const std::map<CKeyID, CPubKey> &pubkey_map,
	const std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>> &key_origins,
	const bool add_keypool, const bool internal, const int64_t timestamp) {
	auto spk_man = GetLegacyScriptPubKeyMan();
	if (!spk_man) {
	return false;
	}
	AssertLockHeld(spk_man->cs_wallet);
	return spk_man->ImportPubKeys(ordered_pubkeys, pubkey_map, key_origins,
	add_keypool, internal, timestamp);
	}

	bool CWallet::ImportScriptPubKeys(const std::string &label,
	const std::set<CScript> &script_pub_keys,
	const bool have_solving_data,
	const bool apply_label,
	const int64_t timestamp) {
	auto spk_man = GetLegacyScriptPubKeyMan();
	if (!spk_man) {
	return false;
	}
	AssertLockHeld(spk_man->cs_wallet);
	if (!spk_man->ImportScriptPubKeys(script_pub_keys, have_solving_data,
	timestamp)) {
	return false;
	}
	if (apply_label) {
	WalletBatch batch(*database);
	for (const CScript &script : script_pub_keys) {
	CTxDestination dest;
	ExtractDestination(script, dest);
	if (IsValidDestination(dest)) {
	SetAddressBookWithDB(batch, dest, label, "receive");
	}
	}
	}
	return true;
	}

	int64_t CalculateMaximumSignedTxSize(const CTransaction &tx,
	const CWallet *wallet, bool use_max_sig) {
	std::vector<CTxOut> txouts;
	// Look up the inputs. We should have already checked that this transaction
	// IsAllFromMe(ISMINE_SPENDABLE), so every input should already be in our
	// wallet, with a valid index into the vout array, and the ability to sign.
	for (auto &input : tx.vin) {
	const auto mi = wallet->mapWallet.find(input.prevout.GetTxId());
	if (mi == wallet->mapWallet.end()) {
	return -1;
	}
	assert(input.prevout.GetN() < mi->second.tx->vout.size());
	txouts.emplace_back(mi->second.tx->vout[input.prevout.GetN()]);
	}
	return CalculateMaximumSignedTxSize(tx, wallet, txouts, use_max_sig);
	}

	// txouts needs to be in the order of tx.vin
	int64_t CalculateMaximumSignedTxSize(const CTransaction &tx,
	const CWallet *wallet,
	const std::vector<CTxOut> &txouts,
	bool use_max_sig) {
	CMutableTransaction txNew(tx);
	if (!wallet->DummySignTx(txNew, txouts, use_max_sig)) {
	// This should never happen, because IsAllFromMe(ISMINE_SPENDABLE)
	// implies that we can sign for every input.
	return -1;
	}
	return GetSerializeSize(txNew, PROTOCOL_VERSION);
	}

	int CalculateMaximumSignedInputSize(const CTxOut &txout, const CWallet *wallet,
	bool use_max_sig) {
	CMutableTransaction txn;
	txn.vin.push_back(CTxIn(COutPoint()));
	if (!wallet->DummySignInput(txn.vin[0], txout, use_max_sig)) {
	// This should never happen, because IsAllFromMe(ISMINE_SPENDABLE)
	// implies that we can sign for every input.
	return -1;
	}
	return GetSerializeSize(txn.vin[0], PROTOCOL_VERSION);
	}

	void CWalletTx::GetAmounts(std::list<COutputEntry> &listReceived,
	std::list<COutputEntry> &listSent, Amount &nFee,
	const isminefilter &filter) const {
	nFee = Amount::zero();
	listReceived.clear();
	listSent.clear();

	// Compute fee:
	Amount nDebit = GetDebit(filter);
	// debit>0 means we signed/sent this transaction.
	if (nDebit > Amount::zero()) {
	Amount nValueOut = tx->GetValueOut();
	nFee = (nDebit - nValueOut);
	}

	// Sent/received.
	for (unsigned int i = 0; i < tx->vout.size(); ++i) {
	const CTxOut &txout = tx->vout[i];
	isminetype fIsMine = pwallet->IsMine(txout);
	// Only need to handle txouts if AT LEAST one of these is true:
	// 1) they debit from us (sent)
	// 2) the output is to us (received)
	if (nDebit > Amount::zero()) {
	// Don't report 'change' txouts
	if (pwallet->IsChange(txout)) {
	continue;
	}
	} else if (!(fIsMine & filter)) {
	continue;
	}

	// In either case, we need to get the destination address.
	CTxDestination address;

	if (!ExtractDestination(txout.scriptPubKey, address) &&
	!txout.scriptPubKey.IsUnspendable()) {
	pwallet->WalletLogPrintf("CWalletTx::GetAmounts: Unknown "
	"transaction type found, txid %s\n",
	this->GetId().ToString());
	address = CNoDestination();
	}

	COutputEntry output = {address, txout.nValue, (int)i};

	// If we are debited by the transaction, add the output as a "sent"
	// entry.
	if (nDebit > Amount::zero()) {
	listSent.push_back(output);
	}

	// If we are receiving the output, add it as a "received" entry.
	if (fIsMine & filter) {
	listReceived.push_back(output);
	}
	}
	}

	/**
	* Scan active chain for relevant transactions after importing keys. This should
	* be called whenever new keys are added to the wallet, with the oldest key
	* creation time.
	*
	* @return Earliest timestamp that could be successfully scanned from. Timestamp
	* returned will be higher than startTime if relevant blocks could not be read.
	*/
	int64_t CWallet::RescanFromTime(int64_t startTime,
	const WalletRescanReserver &reserver,
	bool update) {
	// Find starting block. May be null if nCreateTime is greater than the
	// highest blockchain timestamp, in which case there is nothing that needs
	// to be scanned.
	BlockHash start_block;
	{
	auto locked_chain = chain().lock();
	const Optional<int> start_height =
	locked_chain->findFirstBlockWithTimeAndHeight(
	startTime - TIMESTAMP_WINDOW, 0, &start_block);
	const Optional<int> tip_height = locked_chain->getHeight();
	WalletLogPrintf(
	"%s: Rescanning last %i blocks\n", __func__,
	tip_height && start_height ? tip_height - start_height + 1 : 0);
	}

	if (!start_block.IsNull()) {
	// TODO: this should take into account failure by ScanResult::USER_ABORT
	ScanResult result = ScanForWalletTransactions(start_block, BlockHash(),
	reserver, update);
	if (result.status == ScanResult::FAILURE) {
	int64_t time_max;
	if (!chain().findBlock(result.last_failed_block,
	nullptr /* block /, nullptr / time */,
	&time_max)) {
	throw std::logic_error(
	"ScanForWalletTransactions returned invalid block hash");
	}
	return time_max + TIMESTAMP_WINDOW + 1;
	}
	}
	return startTime;
	}

	/**
	* Scan the block chain (starting in start_block) for transactions from or to
	* us. If fUpdate is true, found transactions that already exist in the wallet
	* will be updated.
	*
	* @param[in] start_block Scan starting block. If block is not on the active
	* chain, the scan will return SUCCESS immediately.
	* @param[in] stop_block Scan ending block. If block is not on the active
	* chain, the scan will continue until it reaches the
	* chain tip.
	*
	* @return ScanResult returning scan information and indicating success or
	* failure. Return status will be set to SUCCESS if scan was
	* successful. FAILURE if a complete rescan was not possible (due to
	* pruning or corruption). USER_ABORT if the rescan was aborted before
	* it could complete.
	*
	* @pre Caller needs to make sure start_block (and the optional stop_block) are
	* on the main chain after to the addition of any new keys you want to detect
	* transactions for.
	*/
	CWallet::ScanResult CWallet::ScanForWalletTransactions(
	const BlockHash &start_block, const BlockHash &stop_block,
	const WalletRescanReserver &reserver, bool fUpdate) {
	int64_t nNow = GetTime();
	int64_t start_time = GetTimeMillis();

	assert(reserver.isReserved());

	BlockHash block_hash = start_block;
	ScanResult result;

	WalletLogPrintf("Rescan started from block %s...\n",
	start_block.ToString());

	fAbortRescan = false;

	// Show rescan progress in GUI as dialog or on splashscreen, if -rescan
	// on startup.
	ShowProgress(
	strprintf("%s " + _("Rescanning...").translated, GetDisplayName()), 0);
	BlockHash tip_hash;
	// The way the 'block_height' is initialized is just a workaround for
	// the gcc bug #47679 since version 4.6.0.
	Optional<int> block_height = MakeOptional(false, int());
	double progress_begin;
	double progress_end;
	{
	auto locked_chain = chain().lock();
	if (Optional<int> tip_height = locked_chain->getHeight()) {
	tip_hash = locked_chain->getBlockHash(*tip_height);
	}
	block_height = locked_chain->getBlockHeight(block_hash);
	progress_begin = chain().guessVerificationProgress(block_hash);
	progress_end = chain().guessVerificationProgress(
	stop_block.IsNull() ? tip_hash : stop_block);
	}
	double progress_current = progress_begin;
	while (block_height && !fAbortRescan && !chain().shutdownRequested()) {
	m_scanning_progress = (progress_current - progress_begin) /
	(progress_end - progress_begin);
	if (*block_height % 100 == 0 && progress_end - progress_begin > 0.0) {
	ShowProgress(
	strprintf("%s " + _("Rescanning...").translated,
	GetDisplayName()),
	std::max(1, std::min(99, int(m_scanning_progress * 100))));
	}
	if (GetTime() >= nNow + 60) {
	nNow = GetTime();
	WalletLogPrintf("Still rescanning. At block %d. Progress=%f\n",
	*block_height, progress_current);
	}

	CBlock block;
	if (chain().findBlock(block_hash, &block) && !block.IsNull()) {
	auto locked_chain = chain().lock();
	LOCK(cs_wallet);
	if (!locked_chain->getBlockHeight(block_hash)) {
	// Abort scan if current block is no longer active, to
	// prevent marking transactions as coming from the wrong
	// block.
	// TODO: This should return success instead of failure, see
	// https://github.com/bitcoin/bitcoin/pull/14711#issuecomment-458342518
	result.last_failed_block = block_hash;
	result.status = ScanResult::FAILURE;
	break;
	}
	for (size_t posInBlock = 0; posInBlock < block.vtx.size();
	++posInBlock) {
	CWalletTx::Confirmation confirm(CWalletTx::Status::CONFIRMED,
	*block_height, block_hash,
	posInBlock);
	SyncTransaction(block.vtx[posInBlock], confirm, fUpdate);
	}
	// scan succeeded, record block as most recent successfully
	// scanned
	result.last_scanned_block = block_hash;
	result.last_scanned_height = *block_height;
	} else {
	// could not scan block, keep scanning but record this block as
	// the most recent failure
	result.last_failed_block = block_hash;
	result.status = ScanResult::FAILURE;
	}
	if (block_hash == stop_block) {
	break;
	}
	{
	auto locked_chain = chain().lock();
	Optional<int> tip_height = locked_chain->getHeight();
	if (!tip_height \|\| *tip_height <= block_height \|\|
	!locked_chain->getBlockHeight(block_hash)) {
	// break successfully when rescan has reached the tip, or
	// previous block is no longer on the chain due to a reorg
	break;
	}

	// increment block and verification progress
	block_hash = locked_chain->getBlockHash(++*block_height);
	progress_current = chain().guessVerificationProgress(block_hash);

	// handle updated tip hash
	const BlockHash prev_tip_hash = tip_hash;
	tip_hash = locked_chain->getBlockHash(*tip_height);
	if (stop_block.IsNull() && prev_tip_hash != tip_hash) {
	// in case the tip has changed, update progress max
	progress_end = chain().guessVerificationProgress(tip_hash);
	}
	}
	}

	// Hide progress dialog in GUI.
	ShowProgress(
	strprintf("%s " + _("Rescanning...").translated, GetDisplayName()),
	100);
	if (block_height && fAbortRescan) {
	WalletLogPrintf("Rescan aborted at block %d. Progress=%f\n",
	*block_height, progress_current);
	result.status = ScanResult::USER_ABORT;
	} else if (block_height && chain().shutdownRequested()) {
	WalletLogPrintf("Rescan interrupted by shutdown request at block "
	"%d. Progress=%f\n",
	*block_height, progress_current);
	result.status = ScanResult::USER_ABORT;
	} else {
	WalletLogPrintf("Rescan completed in %15dms\n",
	GetTimeMillis() - start_time);
	}
	return result;
	}

	void CWallet::ReacceptWalletTransactions(
	interfaces::Chain::Lock &locked_chain) {
	// If transactions aren't being broadcasted, don't let them into local
	// mempool either.
	if (!fBroadcastTransactions) {
	return;
	}

	std::map<int64_t, CWalletTx *> mapSorted;

	// Sort pending wallet transactions based on their initial wallet insertion
	// order.
	for (std::pair<const TxId, CWalletTx> &item : mapWallet) {
	const TxId &wtxid = item.first;
	CWalletTx &wtx = item.second;
	assert(wtx.GetId() == wtxid);

	int nDepth = wtx.GetDepthInMainChain(locked_chain);

	if (!wtx.IsCoinBase() && (nDepth == 0 && !wtx.isAbandoned())) {
	mapSorted.insert(std::make_pair(wtx.nOrderPos, &wtx));
	}
	}

	// Try to add wallet transactions to memory pool.
	for (const std::pair<const int64_t, CWalletTx *> &item : mapSorted) {
	CWalletTx &wtx = *(item.second);
	std::string unused_err_string;
	wtx.SubmitMemoryPoolAndRelay(unused_err_string, false, locked_chain);
	}
	}

	bool CWalletTx::SubmitMemoryPoolAndRelay(
	std::string &err_string, bool relay,
	interfaces::Chain::Lock &locked_chain) {
	// Can't relay if wallet is not broadcasting
	if (!pwallet->GetBroadcastTransactions()) {
	return false;
	}
	// Don't relay abandoned transactions
	if (isAbandoned()) {
	return false;
	}
	// Don't try to submit coinbase transactions. These would fail anyway but
	// would cause log spam.
	if (IsCoinBase()) {
	return false;
	}
	// Don't try to submit conflicted or confirmed transactions.
	if (GetDepthInMainChain(locked_chain) != 0) {
	return false;
	}

	// Submit transaction to mempool for relay
	pwallet->WalletLogPrintf("Submitting wtx %s to mempool for relay\n",
	GetId().ToString());
	// We must set fInMempool here - while it will be re-set to true by the
	// entered-mempool callback, if we did not there would be a race where a
	// user could call sendmoney in a loop and hit spurious out of funds errors
	// because we think that this newly generated transaction's change is
	// unavailable as we're not yet aware that it is in the mempool.
	//
	// Irrespective of the failure reason, un-marking fInMempool
	// out-of-order is incorrect - it should be unmarked when
	// TransactionRemovedFromMempool fires.
	bool ret = pwallet->chain().broadcastTransaction(
	GetConfig(), tx, err_string, pwallet->m_default_max_tx_fee, relay);
	fInMempool \|= ret;
	return ret;
	}

	std::set<TxId> CWalletTx::GetConflicts() const {
	std::set<TxId> result;
	if (pwallet != nullptr) {
	const TxId &txid = GetId();
	result = pwallet->GetConflicts(txid);
	result.erase(txid);
	}

	return result;
	}

	Amount CWalletTx::GetCachableAmount(AmountType type, const isminefilter &filter,
	bool recalculate) const {
	auto &amount = m_amounts[type];
	if (recalculate \|\| !amount.m_cached[filter]) {
	amount.Set(filter, type == DEBIT ? pwallet->GetDebit(*tx, filter)
	: pwallet->GetCredit(*tx, filter));
	}
	return amount.m_value[filter];
	}

	Amount CWalletTx::GetDebit(const isminefilter &filter) const {
	if (tx->vin.empty()) {
	return Amount::zero();
	}

	Amount debit = Amount::zero();
	if (filter & ISMINE_SPENDABLE) {
	debit += GetCachableAmount(DEBIT, ISMINE_SPENDABLE);
	}
	if (filter & ISMINE_WATCH_ONLY) {
	debit += GetCachableAmount(DEBIT, ISMINE_WATCH_ONLY);
	}

	return debit;
	}

	Amount CWalletTx::GetCredit(interfaces::Chain::Lock &locked_chain,
	const isminefilter &filter) const {
	// Must wait until coinbase is safely deep enough in the chain before
	// valuing it.
	if (IsImmatureCoinBase(locked_chain)) {
	return Amount::zero();
	}

	Amount credit = Amount::zero();
	if (filter & ISMINE_SPENDABLE) {
	// GetBalance can assume transactions in mapWallet won't change.
	credit += GetCachableAmount(CREDIT, ISMINE_SPENDABLE);
	}

	if (filter & ISMINE_WATCH_ONLY) {
	credit += GetCachableAmount(CREDIT, ISMINE_WATCH_ONLY);
	}

	return credit;
	}

	Amount CWalletTx::GetImmatureCredit(interfaces::Chain::Lock &locked_chain,
	bool fUseCache) const {
	if (IsImmatureCoinBase(locked_chain) && IsInMainChain(locked_chain)) {
	return GetCachableAmount(IMMATURE_CREDIT, ISMINE_SPENDABLE, !fUseCache);
	}

	return Amount::zero();
	}

	Amount CWalletTx::GetAvailableCredit(interfaces::Chain::Lock &locked_chain,
	bool fUseCache,
	const isminefilter &filter) const {
	if (pwallet == nullptr) {
	return Amount::zero();
	}

	// Avoid caching ismine for NO or ALL cases (could remove this check and
	// simplify in the future).
	bool allow_cache =
	(filter & ISMINE_ALL) && (filter & ISMINE_ALL) != ISMINE_ALL;

	// Must wait until coinbase is safely deep enough in the chain before
	// valuing it.
	if (IsImmatureCoinBase(locked_chain)) {
	return Amount::zero();
	}

	if (fUseCache && allow_cache &&
	m_amounts[AVAILABLE_CREDIT].m_cached[filter]) {
	return m_amounts[AVAILABLE_CREDIT].m_value[filter];
	}

	bool allow_used_addresses =
	(filter & ISMINE_USED) \|\|
	!pwallet->IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE);
	Amount nCredit = Amount::zero();
	const TxId &txid = GetId();
	for (uint32_t i = 0; i < tx->vout.size(); i++) {
	if (!pwallet->IsSpent(locked_chain, COutPoint(txid, i)) &&
	(allow_used_addresses \|\| !pwallet->IsUsedDestination(txid, i))) {
	const CTxOut &txout = tx->vout[i];
	nCredit += pwallet->GetCredit(txout, filter);
	if (!MoneyRange(nCredit)) {
	throw std::runtime_error(std::string(__func__) +
	" : value out of range");
	}
	}
	}

	if (allow_cache) {
	m_amounts[AVAILABLE_CREDIT].Set(filter, nCredit);
	}

	return nCredit;
	}

	Amount
	CWalletTx::GetImmatureWatchOnlyCredit(interfaces::Chain::Lock &locked_chain,
	const bool fUseCache) const {
	if (IsImmatureCoinBase(locked_chain) && IsInMainChain(locked_chain)) {
	return GetCachableAmount(IMMATURE_CREDIT, ISMINE_WATCH_ONLY,
	!fUseCache);
	}

	return Amount::zero();
	}

	Amount CWalletTx::GetChange() const {
	if (fChangeCached) {
	return nChangeCached;
	}

	nChangeCached = pwallet->GetChange(*tx);
	fChangeCached = true;
	return nChangeCached;
	}

	bool CWalletTx::InMempool() const {
	return fInMempool;
	}

	bool CWalletTx::IsTrusted(interfaces::Chain::Lock &locked_chain) const {
	// Quick answer in most cases
	TxValidationState state;
	if (!locked_chain.contextualCheckTransactionForCurrentBlock(
	Params().GetConsensus(), *tx, state)) {
	return false;
	}

	int nDepth = GetDepthInMainChain(locked_chain);
	if (nDepth >= 1) {
	return true;
	}

	if (nDepth < 0) {
	return false;
	}

	// using wtx's cached debit
	if (!pwallet->m_spend_zero_conf_change \|\| !IsFromMe(ISMINE_ALL)) {
	return false;
	}

	// Don't trust unconfirmed transactions from us unless they are in the
	// mempool.
	if (!InMempool()) {
	return false;
	}

	// Trusted if all inputs are from us and are in the mempool:
	for (const CTxIn &txin : tx->vin) {
	// Transactions not sent by us: not trusted
	const CWalletTx *parent = pwallet->GetWalletTx(txin.prevout.GetTxId());
	if (parent == nullptr) {
	return false;
	}

	const CTxOut &parentOut = parent->tx->vout[txin.prevout.GetN()];
	if (pwallet->IsMine(parentOut) != ISMINE_SPENDABLE) {
	return false;
	}
	}

	return true;
	}

	bool CWalletTx::IsEquivalentTo(const CWalletTx &_tx) const {
	CMutableTransaction tx1{*this->tx};
	CMutableTransaction tx2{*_tx.tx};
	for (auto &txin : tx1.vin) {
	txin.scriptSig = CScript();
	}

	for (auto &txin : tx2.vin) {
	txin.scriptSig = CScript();
	}

	return CTransaction(tx1) == CTransaction(tx2);
	}

	// Rebroadcast transactions from the wallet. We do this on a random timer
	// to slightly obfuscate which transactions come from our wallet.
	//
	// Ideally, we'd only resend transactions that we think should have been
	// mined in the most recent block. Any transaction that wasn't in the top
	// blockweight of transactions in the mempool shouldn't have been mined,
	// and so is probably just sitting in the mempool waiting to be confirmed.
	// Rebroadcasting does nothing to speed up confirmation and only damages
	// privacy.
	void CWallet::ResendWalletTransactions() {
	// During reindex, importing and IBD, old wallet transactions become
	// unconfirmed. Don't resend them as that would spam other nodes.
	if (!chain().isReadyToBroadcast()) {
	return;
	}

	// Do this infrequently and randomly to avoid giving away that these are our
	// transactions.
	if (GetTime() < nNextResend \|\| !fBroadcastTransactions) {
	return;
	}

	bool fFirst = (nNextResend == 0);
	nNextResend = GetTime() + GetRand(30 * 60);
	if (fFirst) {
	return;
	}

	// Only do it if there's been a new block since last time
	if (m_best_block_time < nLastResend) {
	return;
	}

	nLastResend = GetTime();

	int submitted_tx_count = 0;

	{ // locked_chain and cs_wallet scope
	auto locked_chain = chain().lock();
	LOCK(cs_wallet);

	// Relay transactions
	for (std::pair<const TxId, CWalletTx> &item : mapWallet) {
	CWalletTx &wtx = item.second;
	// Attempt to rebroadcast all txes more than 5 minutes older than
	// the last block. SubmitMemoryPoolAndRelay() will not rebroadcast
	// any confirmed or conflicting txs.
	if (wtx.nTimeReceived > m_best_block_time - 5 * 60) {
	continue;
	}
	std::string unused_err_string;
	if (wtx.SubmitMemoryPoolAndRelay(unused_err_string, true,
	*locked_chain)) {
	++submitted_tx_count;
	}
	}
	} // locked_chain and cs_wallet

	if (submitted_tx_count > 0) {
	WalletLogPrintf("%s: resubmit %u unconfirmed transactions\n", __func__,
	submitted_tx_count);
	}
	}

	/** @} */ // end of mapWallet

	void MaybeResendWalletTxs() {
	for (const std::shared_ptr<CWallet> &pwallet : GetWallets()) {
	pwallet->ResendWalletTransactions();
	}
	}

	/**
	* @defgroup Actions
	*
	* @{
	*/
	CWallet::Balance CWallet::GetBalance(const int min_depth,
	bool avoid_reuse) const {
	Balance ret;
	isminefilter reuse_filter = avoid_reuse ? ISMINE_NO : ISMINE_USED;
	auto locked_chain = chain().lock();
	LOCK(cs_wallet);
	for (const auto &entry : mapWallet) {
	const CWalletTx &wtx = entry.second;
	const bool is_trusted{wtx.IsTrusted(*locked_chain)};
	const int tx_depth{wtx.GetDepthInMainChain(*locked_chain)};
	const Amount tx_credit_mine{
	wtx.GetAvailableCredit(locked_chain, / fUseCache */ true,
	ISMINE_SPENDABLE \| reuse_filter)};
	const Amount tx_credit_watchonly{
	wtx.GetAvailableCredit(locked_chain, / fUseCache */ true,
	ISMINE_WATCH_ONLY \| reuse_filter)};
	if (is_trusted && tx_depth >= min_depth) {
	ret.m_mine_trusted += tx_credit_mine;
	ret.m_watchonly_trusted += tx_credit_watchonly;
	}
	if (!is_trusted && tx_depth == 0 && wtx.InMempool()) {
	ret.m_mine_untrusted_pending += tx_credit_mine;
	ret.m_watchonly_untrusted_pending += tx_credit_watchonly;
	}
	ret.m_mine_immature += wtx.GetImmatureCredit(*locked_chain);
	ret.m_watchonly_immature +=
	wtx.GetImmatureWatchOnlyCredit(*locked_chain);
	}
	return ret;
	}

	Amount CWallet::GetAvailableBalance(const CCoinControl *coinControl) const {
	auto locked_chain = chain().lock();
	LOCK(cs_wallet);

	Amount balance = Amount::zero();
	std::vector<COutput> vCoins;
	AvailableCoins(*locked_chain, vCoins, true, coinControl);
	for (const COutput &out : vCoins) {
	if (out.fSpendable) {
	balance += out.tx->tx->vout[out.i].nValue;
	}
	}
	return balance;
	}

	void CWallet::AvailableCoins(interfaces::Chain::Lock &locked_chain,
	std::vector<COutput> &vCoins, bool fOnlySafe,
	const CCoinControl *coinControl,
	const Amount nMinimumAmount,
	const Amount nMaximumAmount,
	const Amount nMinimumSumAmount,
	const uint64_t nMaximumCount) const {
	AssertLockHeld(cs_wallet);

	vCoins.clear();
	Amount nTotal = Amount::zero();
	// Either the WALLET_FLAG_AVOID_REUSE flag is not set (in which case we
	// always allow), or we default to avoiding, and only in the case where a
	// coin control object is provided, and has the avoid address reuse flag set
	// to false, do we allow already used addresses
	bool allow_used_addresses =
	!IsWalletFlagSet(WALLET_FLAG_AVOID_REUSE) \|\|
	(coinControl && !coinControl->m_avoid_address_reuse);
	const int min_depth = {coinControl ? coinControl->m_min_depth
	: DEFAULT_MIN_DEPTH};
	const int max_depth = {coinControl ? coinControl->m_max_depth
	: DEFAULT_MAX_DEPTH};

	const Consensus::Params params = Params().GetConsensus();

	for (const auto &entry : mapWallet) {
	const TxId &wtxid = entry.first;
	const CWalletTx &wtx = entry.second;

	TxValidationState state;
	if (!locked_chain.contextualCheckTransactionForCurrentBlock(
	params, *wtx.tx, state)) {
	continue;
	}

	if (wtx.IsImmatureCoinBase(locked_chain)) {
	continue;
	}

	int nDepth = wtx.GetDepthInMainChain(locked_chain);
	if (nDepth < 0) {
	continue;
	}

	// We should not consider coins which aren't at least in our mempool.
	// It's possible for these to be conflicted via ancestors which we may
	// never be able to detect.
	if (nDepth == 0 && !wtx.InMempool()) {
	continue;
	}

	bool safeTx = wtx.IsTrusted(locked_chain);

	// Bitcoin-ABC: Removed check that prevents consideration of coins from
	// transactions that are replacing other transactions. This check based
	// on wtx.mapValue.count("replaces_txid") which was not being set
	// anywhere.

	// Similarly, we should not consider coins from transactions that have
	// been replaced. In the example above, we would want to prevent
	// creation of a transaction A' spending an output of A, because if
	// transaction B were initially confirmed, conflicting with A and A', we
	// wouldn't want to the user to create a transaction D intending to
	// replace A', but potentially resulting in a scenario where A, A', and
	// D could all be accepted (instead of just B and D, or just A and A'
	// like the user would want).

	// Bitcoin-ABC: retained this check as 'replaced_by_txid' is still set
	// in the wallet code.
	if (nDepth == 0 && wtx.mapValue.count("replaced_by_txid")) {
	safeTx = false;
	}

	if (fOnlySafe && !safeTx) {
	continue;
	}

	if (nDepth < min_depth \|\| nDepth > max_depth) {
	continue;
	}

	for (uint32_t i = 0; i < wtx.tx->vout.size(); i++) {
	if (wtx.tx->vout[i].nValue < nMinimumAmount \|\|
	wtx.tx->vout[i].nValue > nMaximumAmount) {
	continue;
	}

	const COutPoint outpoint(wtxid, i);

	if (coinControl && coinControl->HasSelected() &&
	!coinControl->fAllowOtherInputs &&
	!coinControl->IsSelected(outpoint)) {
	continue;
	}

	if (IsLockedCoin(outpoint)) {
	continue;
	}

	if (IsSpent(locked_chain, outpoint)) {
	continue;
	}

	isminetype mine = IsMine(wtx.tx->vout[i]);

	if (mine == ISMINE_NO) {
	continue;
	}

	if (!allow_used_addresses && IsUsedDestination(wtxid, i)) {
	continue;
	}

	const SigningProvider *provider = GetSigningProvider();

	bool solvable =
	provider ? IsSolvable(*provider, wtx.tx->vout[i].scriptPubKey)
	: false;
	bool spendable =
	((mine & ISMINE_SPENDABLE) != ISMINE_NO) \|\|
	(((mine & ISMINE_WATCH_ONLY) != ISMINE_NO) &&
	(coinControl && coinControl->fAllowWatchOnly && solvable));

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

	// Checks the sum amount of all UTXO's.
	if (nMinimumSumAmount != MAX_MONEY) {
	nTotal += wtx.tx->vout[i].nValue;

	if (nTotal >= nMinimumSumAmount) {
	return;
	}
	}

	// Checks the maximum number of UTXO's.
	if (nMaximumCount > 0 && vCoins.size() >= nMaximumCount) {
	return;
	}
	}
	}
	}

	std::map<CTxDestination, std::vector<COutput>>
	CWallet::ListCoins(interfaces::Chain::Lock &locked_chain) const {
	AssertLockHeld(cs_wallet);

	std::map<CTxDestination, std::vector<COutput>> result;
	std::vector<COutput> availableCoins;

	AvailableCoins(locked_chain, availableCoins);

	for (const auto &coin : availableCoins) {
	CTxDestination address;
	if (coin.fSpendable &&
	ExtractDestination(
	FindNonChangeParentOutput(*coin.tx->tx, coin.i).scriptPubKey,
	address)) {
	result[address].emplace_back(std::move(coin));
	}
	}

	std::vector<COutPoint> lockedCoins;
	ListLockedCoins(lockedCoins);
	for (const auto &output : lockedCoins) {
	auto it = mapWallet.find(output.GetTxId());
	if (it != mapWallet.end()) {
	int depth = it->second.GetDepthInMainChain(locked_chain);
	if (depth >= 0 && output.GetN() < it->second.tx->vout.size() &&
	IsMine(it->second.tx->vout[output.GetN()]) ==
	ISMINE_SPENDABLE) {
	CTxDestination address;
	if (ExtractDestination(
	FindNonChangeParentOutput(*it->second.tx, output.GetN())
	.scriptPubKey,
	address)) {
	result[address].emplace_back(
	&it->second, output.GetN(), depth, true /* spendable */,
	true /* solvable /, false / safe */);
	}
	}
	}
	}

	return result;
	}

	const CTxOut &CWallet::FindNonChangeParentOutput(const CTransaction &tx,
	int output) const {
	const CTransaction *ptx = &tx;
	int n = output;
	while (IsChange(ptx->vout[n]) && ptx->vin.size() > 0) {
	const COutPoint &prevout = ptx->vin[0].prevout;
	auto it = mapWallet.find(prevout.GetTxId());
	if (it == mapWallet.end() \|\|
	it->second.tx->vout.size() <= prevout.GetN() \|\|
	!IsMine(it->second.tx->vout[prevout.GetN()])) {
	break;
	}
	ptx = it->second.tx.get();
	n = prevout.GetN();
	}
	return ptx->vout[n];
	}

	bool CWallet::SelectCoinsMinConf(
	const Amount nTargetValue, const CoinEligibilityFilter &eligibility_filter,
	std::vector<OutputGroup> groups, std::set<CInputCoin> &setCoinsRet,
	Amount &nValueRet, const CoinSelectionParams &coin_selection_params,
	bool &bnb_used) const {
	setCoinsRet.clear();
	nValueRet = Amount::zero();

	std::vector<OutputGroup> utxo_pool;
	if (coin_selection_params.use_bnb) {
	// Get long term estimate
	CCoinControl temp;
	temp.m_confirm_target = 1008;
	CFeeRate long_term_feerate = GetMinimumFeeRate(*this, temp);

	// Calculate cost of change
	Amount cost_of_change = chain().relayDustFee().GetFee(
	coin_selection_params.change_spend_size) +
	coin_selection_params.effective_fee.GetFee(
	coin_selection_params.change_output_size);

	// Filter by the min conf specs and add to utxo_pool and calculate
	// effective value
	for (OutputGroup &group : groups) {
	if (!group.EligibleForSpending(eligibility_filter)) {
	continue;
	}

	group.fee = Amount::zero();
	group.long_term_fee = Amount::zero();
	group.effective_value = Amount::zero();
	for (auto it = group.m_outputs.begin();
	it != group.m_outputs.end();) {
	const CInputCoin &coin = *it;
	Amount effective_value =
	coin.txout.nValue -
	(coin.m_input_bytes < 0
	? Amount::zero()
	: 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 > Amount::zero()) {
	group.fee +=
	coin.m_input_bytes < 0
	? Amount::zero()
	: coin_selection_params.effective_fee.GetFee(
	coin.m_input_bytes);
	group.long_term_fee +=
	coin.m_input_bytes < 0
	? Amount::zero()
	: long_term_feerate.GetFee(coin.m_input_bytes);
	group.effective_value += effective_value;
	++it;
	} else {
	it = group.Discard(coin);
	}
	}
	if (group.effective_value > Amount::zero()) {
	utxo_pool.push_back(group);
	}
	}
	// Calculate the fees for things that aren't inputs
	Amount not_input_fees = coin_selection_params.effective_fee.GetFee(
	coin_selection_params.tx_noinputs_size);
	bnb_used = true;
	return SelectCoinsBnB(utxo_pool, nTargetValue, cost_of_change,
	setCoinsRet, nValueRet, not_input_fees);
	} else {
	// Filter by the min conf specs and add to utxo_pool
	for (const OutputGroup &group : groups) {
	if (!group.EligibleForSpending(eligibility_filter)) {
	continue;
	}
	utxo_pool.push_back(group);
	}
	bnb_used = false;
	return KnapsackSolver(nTargetValue, utxo_pool, setCoinsRet, nValueRet);
	}
	}

	bool CWallet::SelectCoins(const std::vector<COutput> &vAvailableCoins,
	const Amount nTargetValue,
	std::set<CInputCoin> &setCoinsRet, Amount &nValueRet,
	const CCoinControl &coin_control,
	CoinSelectionParams &coin_selection_params,
	bool &bnb_used) const {
	std::vector<COutput> vCoins(vAvailableCoins);

	// coin control -> return all selected outputs (we want all selected to go
	// into the transaction for sure)
	if (coin_control.HasSelected() && !coin_control.fAllowOtherInputs) {
	// We didn't use BnB here, so set it to false.
	bnb_used = false;

	for (const COutput &out : vCoins) {
	if (!out.fSpendable) {
	continue;
	}

	nValueRet += out.tx->tx->vout[out.i].nValue;
	setCoinsRet.insert(out.GetInputCoin());
	}

	return (nValueRet >= nTargetValue);
	}

	// Calculate value from preset inputs and store them.
	std::set<CInputCoin> setPresetCoins;
	Amount nValueFromPresetInputs = Amount::zero();

	std::vector<COutPoint> vPresetInputs;
	coin_control.ListSelected(vPresetInputs);

	for (const COutPoint &outpoint : vPresetInputs) {
	// For now, don't use BnB if preset inputs are selected. TODO: Enable
	// this later
	bnb_used = false;
	coin_selection_params.use_bnb = false;

	std::map<TxId, CWalletTx>::const_iterator it =
	mapWallet.find(outpoint.GetTxId());
	if (it == mapWallet.end()) {
	// TODO: Allow non-wallet inputs
	return false;
	}

	const CWalletTx &wtx = it->second;
	// Clearly invalid input, fail.
	if (wtx.tx->vout.size() <= outpoint.GetN()) {
	return false;
	}

	// Just to calculate the marginal byte size
	nValueFromPresetInputs += wtx.tx->vout[outpoint.GetN()].nValue;
	setPresetCoins.insert(CInputCoin(wtx.tx, outpoint.GetN()));
	}

	// Remove preset inputs from vCoins
	for (std::vector<COutput>::iterator it = vCoins.begin();
	it != vCoins.end() && coin_control.HasSelected();) {
	if (setPresetCoins.count(it->GetInputCoin())) {
	it = vCoins.erase(it);
	} else {
	++it;
	}
	}

	// 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
	Shuffle(vCoins.begin(), vCoins.end(), FastRandomContext());
	}
	std::vector<OutputGroup> groups =
	GroupOutputs(vCoins, !coin_control.m_avoid_partial_spends);

	size_t max_ancestors{0};
	size_t max_descendants{0};
	chain().getPackageLimits(max_ancestors, max_descendants);
	bool fRejectLongChains = gArgs.GetBoolArg(
	"-walletrejectlongchains", DEFAULT_WALLET_REJECT_LONG_CHAINS);

	bool res =
	nTargetValue <= nValueFromPresetInputs \|\|
	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));

	// Because SelectCoinsMinConf clears the setCoinsRet, we now add the
	// possible inputs to the coinset.
	util::insert(setCoinsRet, setPresetCoins);

	// Add preset inputs to the total value selected.
	nValueRet += nValueFromPresetInputs;

	return res;
	}

	bool CWallet::SignTransaction(CMutableTransaction &tx) {
	AssertLockHeld(cs_wallet);
	// sign the new tx
	int nIn = 0;
	for (CTxIn &input : tx.vin) {
	auto mi = mapWallet.find(input.prevout.GetTxId());
	if (mi == mapWallet.end() \|\|
	input.prevout.GetN() >= mi->second.tx->vout.size()) {
	return false;
	}
	const CScript &scriptPubKey =
	mi->second.tx->vout[input.prevout.GetN()].scriptPubKey;
	const Amount amount = mi->second.tx->vout[input.prevout.GetN()].nValue;
	SignatureData sigdata;
	SigHashType sigHashType = SigHashType().withForkId();

	const SigningProvider *provider = GetSigningProvider();
	if (!provider) {
	return false;
	}

	if (!ProduceSignature(*provider,
	MutableTransactionSignatureCreator(
	&tx, nIn, amount, sigHashType),
	scriptPubKey, sigdata)) {
	return false;
	}
	UpdateInput(input, sigdata);
	nIn++;
	}
	return true;
	}

	bool CWallet::FundTransaction(CMutableTransaction &tx, Amount &nFeeRet,
	int &nChangePosInOut, std::string &strFailReason,
	bool lockUnspents,
	const std::set<int> &setSubtractFeeFromOutputs,
	CCoinControl coinControl) {
	std::vector<CRecipient> vecSend;

	// Turn the txout set into a CRecipient vector.
	for (size_t idx = 0; idx < tx.vout.size(); idx++) {
	const CTxOut &txOut = tx.vout[idx];
	CRecipient recipient = {txOut.scriptPubKey, txOut.nValue,
	setSubtractFeeFromOutputs.count(idx) == 1};
	vecSend.push_back(recipient);
	}

	coinControl.fAllowOtherInputs = true;

	for (const CTxIn &txin : tx.vin) {
	coinControl.Select(txin.prevout);
	}

	// Acquire the locks to prevent races to the new locked unspents between the
	// CreateTransaction call and LockCoin calls (when lockUnspents is true).
	auto locked_chain = chain().lock();
	LOCK(cs_wallet);

	CTransactionRef tx_new;
	if (!CreateTransaction(*locked_chain, vecSend, tx_new, nFeeRet,
	nChangePosInOut, strFailReason, coinControl,
	false)) {
	return false;
	}

	if (nChangePosInOut != -1) {
	tx.vout.insert(tx.vout.begin() + nChangePosInOut,
	tx_new->vout[nChangePosInOut]);
	}

	// Copy output sizes from new transaction; they may have had the fee
	// subtracted from them.
	for (size_t idx = 0; idx < tx.vout.size(); idx++) {
	tx.vout[idx].nValue = tx_new->vout[idx].nValue;
	}

	// Add new txins (keeping original txin scriptSig/order)
	for (const CTxIn &txin : tx_new->vin) {
	if (!coinControl.IsSelected(txin.prevout)) {
	tx.vin.push_back(txin);

	if (lockUnspents) {
	LockCoin(txin.prevout);
	}
	}
	}

	return true;
	}

	static bool IsCurrentForAntiFeeSniping(interfaces::Chain &chain,
	interfaces::Chain::Lock &locked_chain) {
	if (chain.isInitialBlockDownload()) {
	return false;
	}

	// in seconds
	constexpr int64_t MAX_ANTI_FEE_SNIPING_TIP_AGE = 8 * 60 * 60;
	if (locked_chain.getBlockTime(*locked_chain.getHeight()) <
	(GetTime() - MAX_ANTI_FEE_SNIPING_TIP_AGE)) {
	return false;
	}
	return true;
	}

	/**
	* Return a height-based locktime for new transactions (uses the height of the
	* current chain tip unless we are not synced with the current chain
	*/
	static uint32_t
	GetLocktimeForNewTransaction(interfaces::Chain &chain,
	interfaces::Chain::Lock &locked_chain) {
	uint32_t const height = locked_chain.getHeight().value_or(-1);
	uint32_t locktime;
	// Discourage fee sniping.
	//
	// For a large miner the value of the transactions in the best block and
	// the mempool can exceed the cost of deliberately attempting to mine two
	// blocks to orphan the current best block. By setting nLockTime such that
	// only the next block can include the transaction, we discourage this
	// practice as the height restricted and limited blocksize gives miners
	// considering fee sniping fewer options for pulling off this attack.
	//
	// A simple way to think about this is from the wallet's point of view we
	// always want the blockchain to move forward. By setting nLockTime this
	// way we're basically making the statement that we only want this
	// transaction to appear in the next block; we don't want to potentially
	// encourage reorgs by allowing transactions to appear at lower heights
	// than the next block in forks of the best chain.
	//
	// Of course, the subsidy is high enough, and transaction volume low
	// enough, that fee sniping isn't a problem yet, but by implementing a fix
	// now we ensure code won't be written that makes assumptions about
	// nLockTime that preclude a fix later.
	if (IsCurrentForAntiFeeSniping(chain, locked_chain)) {
	locktime = height;

	// Secondly occasionally randomly pick a nLockTime even further back, so
	// that transactions that are delayed after signing for whatever reason,
	// e.g. high-latency mix networks and some CoinJoin implementations,
	// have better privacy.
	if (GetRandInt(10) == 0) {
	locktime = std::max(0, int(locktime) - GetRandInt(100));
	}
	} else {
	// If our chain is lagging behind, we can't discourage fee sniping nor
	// help the privacy of high-latency transactions. To avoid leaking a
	// potentially unique "nLockTime fingerprint", set nLockTime to a
	// constant.
	locktime = 0;
	}
	assert(locktime <= height);
	assert(locktime < LOCKTIME_THRESHOLD);
	return locktime;
	}

	OutputType
	CWallet::TransactionChangeType(OutputType change_type,
	const std::vector<CRecipient> &vecSend) {
	// If -changetype is specified, always use that change type.
	if (change_type != OutputType::CHANGE_AUTO) {
	return change_type;
	}

	// if m_default_address_type is legacy, use legacy address as change.
	if (m_default_address_type == OutputType::LEGACY) {
	return OutputType::LEGACY;
	}

	// else use m_default_address_type for change
	return m_default_address_type;
	}

	bool CWallet::CreateTransaction(interfaces::Chain::Lock &locked_chainIn,
	const std::vector<CRecipient> &vecSend,
	CTransactionRef &tx, Amount &nFeeRet,
	int &nChangePosInOut,
	std::string &strFailReason,
	const CCoinControl &coinControl, bool sign) {
	Amount nValue = Amount::zero();
	ReserveDestination reservedest(this);
	int nChangePosRequest = nChangePosInOut;
	unsigned int nSubtractFeeFromAmount = 0;
	for (const auto &recipient : vecSend) {
	if (nValue < Amount::zero() \|\| recipient.nAmount < Amount::zero()) {
	strFailReason =
	_("Transaction amounts must not be negative").translated;
	return false;
	}

	nValue += recipient.nAmount;

	if (recipient.fSubtractFeeFromAmount) {
	nSubtractFeeFromAmount++;
	}
	}

	if (vecSend.empty()) {
	strFailReason =
	_("Transaction must have at least one recipient").translated;
	return false;
	}

	CMutableTransaction txNew;

	txNew.nLockTime = GetLocktimeForNewTransaction(chain(), locked_chainIn);

	{
	std::set<CInputCoin> setCoins;
	auto locked_chain = chain().lock();
	LOCK(cs_wallet);

	std::vector<COutput> vAvailableCoins;
	AvailableCoins(*locked_chain, vAvailableCoins, true, &coinControl);
	// Parameters for coin selection, init with dummy
	CoinSelectionParams coin_selection_params;

	// Create change script that will be used if we need change
	// TODO: pass in scriptChange instead of reservedest so
	// change transaction isn't always pay-to-bitcoin-address
	CScript scriptChange;

	// coin control: send change to custom address
	if (!boost::get<CNoDestination>(&coinControl.destChange)) {
	scriptChange = GetScriptForDestination(coinControl.destChange);

	// no coin control: send change to newly generated address
	} else {
	// Note: We use a new key here to keep it from being obvious
	// which side is the change.
	// The drawback is that by not reusing a previous key, the
	// change may be lost if a backup is restored, if the backup
	// doesn't have the new private key for the change. If we
	// reused the old key, it would be possible to add code to look
	// for and rediscover unknown transactions that were written
	// with keys of ours to recover post-backup change.

	// Reserve a new key pair from key pool
	if (!CanGetAddresses(true)) {
	strFailReason =
	_("Can't generate a change-address key. No keys in the "
	"internal keypool and can't generate any keys.")
	.translated;
	return false;
	}
	CTxDestination dest;
	const OutputType change_type = TransactionChangeType(
	coinControl.m_change_type ? *coinControl.m_change_type
	: m_default_change_type,
	vecSend);
	bool ret =
	reservedest.GetReservedDestination(change_type, dest, true);
	if (!ret) {
	strFailReason =
	_("Keypool ran out, please call keypoolrefill first")
	.translated;
	return false;
	}

	scriptChange = GetScriptForDestination(dest);
	}
	CTxOut change_prototype_txout(Amount::zero(), scriptChange);
	coin_selection_params.change_output_size =
	GetSerializeSize(change_prototype_txout);

	// Get the fee rate to use effective values in coin selection
	CFeeRate nFeeRateNeeded = GetMinimumFeeRate(*this, coinControl);

	nFeeRet = Amount::zero();
	bool pick_new_inputs = true;
	Amount nValueIn = Amount::zero();

	// BnB selector is the only selector used when this is true.
	// That should only happen on the first pass through the loop.
	// If we are doing subtract fee from recipient, then don't use BnB
	coin_selection_params.use_bnb = nSubtractFeeFromAmount == 0;
	// Start with no fee and loop until there is enough fee
	while (true) {
	nChangePosInOut = nChangePosRequest;
	txNew.vin.clear();
	txNew.vout.clear();
	bool fFirst = true;

	Amount nValueToSelect = nValue;
	if (nSubtractFeeFromAmount == 0) {
	nValueToSelect += nFeeRet;
	}

	// Static size overhead + outputs vsize. 4 nVersion, 4 nLocktime, 1
	// input count, 1 output count
	coin_selection_params.tx_noinputs_size = 10;
	// vouts to the payees
	for (const auto &recipient : vecSend) {
	CTxOut txout(recipient.nAmount, recipient.scriptPubKey);

	if (recipient.fSubtractFeeFromAmount) {
	assert(nSubtractFeeFromAmount != 0);
	// Subtract fee equally from each selected recipient.
	txout.nValue -= nFeeRet / int(nSubtractFeeFromAmount);

	// First receiver pays the remainder not divisible by output
	// count.
	if (fFirst) {
	fFirst = false;
	txout.nValue -= nFeeRet % int(nSubtractFeeFromAmount);
	}
	}

	// Include the fee cost for outputs. Note this is only used for
	// BnB right now
	coin_selection_params.tx_noinputs_size +=
	::GetSerializeSize(txout, PROTOCOL_VERSION);

	if (IsDust(txout, chain().relayDustFee())) {
	if (recipient.fSubtractFeeFromAmount &&
	nFeeRet > Amount::zero()) {
	if (txout.nValue < Amount::zero()) {
	strFailReason = _("The transaction amount is too "
	"small to pay the fee")
	.translated;
	} else {
	strFailReason =
	_("The transaction amount is too small to "
	"send after the fee has been deducted")
	.translated;
	}
	} else {
	strFailReason =
	_("Transaction amount too small").translated;
	}

	return false;
	}

	txNew.vout.push_back(txout);
	}

	// Choose coins to use
	bool bnb_used;
	if (pick_new_inputs) {
	nValueIn = Amount::zero();
	setCoins.clear();
	coin_selection_params.change_spend_size =
	CalculateMaximumSignedInputSize(change_prototype_txout,
	this);
	coin_selection_params.effective_fee = nFeeRateNeeded;
	if (!SelectCoins(vAvailableCoins, nValueToSelect, setCoins,
	nValueIn, coinControl, coin_selection_params,
	bnb_used)) {
	// If BnB was used, it was the first pass. No longer the
	// first pass and continue loop with knapsack.
	if (bnb_used) {
	coin_selection_params.use_bnb = false;
	continue;
	} else {
	strFailReason = _("Insufficient funds").translated;
	return false;
	}
	}
	} else {
	bnb_used = false;
	}

	const Amount nChange = nValueIn - nValueToSelect;
	if (nChange > Amount::zero()) {
	// Fill a vout to ourself.
	CTxOut newTxOut(nChange, scriptChange);

	// Never create dust outputs; if we would, just add the dust to
	// the fee.
	// The nChange when BnB is used is always going to go to fees.
	if (IsDust(newTxOut, chain().relayDustFee()) \|\| bnb_used) {
	nChangePosInOut = -1;
	nFeeRet += nChange;
	} else {
	if (nChangePosInOut == -1) {
	// Insert change txn at random position:
	nChangePosInOut = GetRandInt(txNew.vout.size() + 1);
	} else if ((unsigned int)nChangePosInOut >
	txNew.vout.size()) {
	strFailReason =
	_("Change index out of range").translated;
	return false;
	}

	std::vector<CTxOut>::iterator position =
	txNew.vout.begin() + nChangePosInOut;
	txNew.vout.insert(position, newTxOut);
	}
	} else {
	nChangePosInOut = -1;
	}

	// Dummy fill vin for maximum size estimation
	//
	for (const auto &coin : setCoins) {
	txNew.vin.push_back(CTxIn(coin.outpoint, CScript()));
	}

	CTransaction txNewConst(txNew);
	int nBytes = CalculateMaximumSignedTxSize(
	txNewConst, this, coinControl.fAllowWatchOnly);
	if (nBytes < 0) {
	strFailReason = _("Signing transaction failed").translated;
	return false;
	}

	Amount nFeeNeeded = GetMinimumFee(*this, nBytes, coinControl);

	if (nFeeRet >= nFeeNeeded) {
	// Reduce fee to only the needed amount if possible. This
	// prevents potential overpayment in fees if the coins selected
	// to meet nFeeNeeded result in a transaction that requires less
	// fee than the prior iteration.

	// If we have no change and a big enough excess fee, then try to
	// construct transaction again only without picking new inputs.
	// We now know we only need the smaller fee (because of reduced
	// tx size) and so we should add a change output. Only try this
	// once.
	if (nChangePosInOut == -1 && nSubtractFeeFromAmount == 0 &&
	pick_new_inputs) {
	// Add 2 as a buffer in case increasing # of outputs changes
	// compact size
	unsigned int tx_size_with_change =
	nBytes + coin_selection_params.change_output_size + 2;
	Amount fee_needed_with_change =
	GetMinimumFee(*this, tx_size_with_change, coinControl);
	Amount minimum_value_for_change = GetDustThreshold(
	change_prototype_txout, chain().relayDustFee());
	if (nFeeRet >=
	fee_needed_with_change + minimum_value_for_change) {
	pick_new_inputs = false;
	nFeeRet = fee_needed_with_change;
	continue;
	}
	}

	// If we have change output already, just increase it
	if (nFeeRet > nFeeNeeded && nChangePosInOut != -1 &&
	nSubtractFeeFromAmount == 0) {
	Amount extraFeePaid = nFeeRet - nFeeNeeded;
	std::vector<CTxOut>::iterator change_position =
	txNew.vout.begin() + nChangePosInOut;
	change_position->nValue += extraFeePaid;
	nFeeRet -= extraFeePaid;
	}

	// Done, enough fee included.
	break;
	} else if (!pick_new_inputs) {
	// This shouldn't happen, we should have had enough excess fee
	// to pay for the new output and still meet nFeeNeeded.
	// Or we should have just subtracted fee from recipients and
	// nFeeNeeded should not have changed.
	strFailReason =
	_("Transaction fee and change calculation failed")
	.translated;
	return false;
	}

	// Try to reduce change to include necessary fee.
	if (nChangePosInOut != -1 && nSubtractFeeFromAmount == 0) {
	Amount additionalFeeNeeded = nFeeNeeded - nFeeRet;
	std::vector<CTxOut>::iterator change_position =
	txNew.vout.begin() + nChangePosInOut;
	// Only reduce change if remaining amount is still a large
	// enough output.
	if (change_position->nValue >=
	MIN_FINAL_CHANGE + additionalFeeNeeded) {
	change_position->nValue -= additionalFeeNeeded;
	nFeeRet += additionalFeeNeeded;
	// Done, able to increase fee from change.
	break;
	}
	}

	// If subtracting fee from recipients, we now know what fee we
	// need to subtract, we have no reason to reselect inputs.
	if (nSubtractFeeFromAmount > 0) {
	pick_new_inputs = false;
	}

	// Include more fee and try again.
	nFeeRet = nFeeNeeded;
	coin_selection_params.use_bnb = false;
	continue;
	}

	// Shuffle selected coins and fill in final vin
	txNew.vin.clear();
	std::vector<CInputCoin> selected_coins(setCoins.begin(),
	setCoins.end());
	Shuffle(selected_coins.begin(), selected_coins.end(),
	FastRandomContext());

	// Note how the sequence number is set to non-maxint so that
	// the nLockTime set above actually works.
	for (const auto &coin : selected_coins) {
	txNew.vin.push_back(
	CTxIn(coin.outpoint, CScript(),
	std::numeric_limits<uint32_t>::max() - 1));
	}

	if (sign) {
	SigHashType sigHashType = SigHashType().withForkId();

	int nIn = 0;
	for (const auto &coin : selected_coins) {
	const CScript &scriptPubKey = coin.txout.scriptPubKey;
	SignatureData sigdata;

	const SigningProvider *provider = GetSigningProvider();
	if (!provider \|\|
	!ProduceSignature(
	*provider,
	MutableTransactionSignatureCreator(
	&txNew, nIn, coin.txout.nValue, sigHashType),
	scriptPubKey, sigdata)) {
	strFailReason = _("Signing transaction failed").translated;
	return false;
	}

	UpdateInput(txNew.vin.at(nIn), sigdata);
	nIn++;
	}
	}

	// Return the constructed transaction data.
	tx = MakeTransactionRef(std::move(txNew));

	// Limit size.
	if (tx->GetTotalSize() > MAX_STANDARD_TX_SIZE) {
	strFailReason = _("Transaction too large").translated;
	return false;
	}
	}

	if (nFeeRet > m_default_max_tx_fee) {
	strFailReason =
	TransactionErrorString(TransactionError::MAX_FEE_EXCEEDED);
	return false;
	}

	if (gArgs.GetBoolArg("-walletrejectlongchains",
	DEFAULT_WALLET_REJECT_LONG_CHAINS)) {
	// Lastly, ensure this tx will pass the mempool's chain limits
	if (!chain().checkChainLimits(tx)) {
	strFailReason =
	_("Transaction has too long of a mempool chain").translated;
	return false;
	}
	}

	// Before we return success, we assume any change key will be used to
	// prevent accidental re-use.
	reservedest.KeepDestination();

	return true;
	}

	void CWallet::CommitTransaction(
	CTransactionRef tx, mapValue_t mapValue,
	std::vector<std::pair<std::string, std::string>> orderForm) {
	auto locked_chain = chain().lock();
	LOCK(cs_wallet);

	CWalletTx wtxNew(this, std::move(tx));
	wtxNew.mapValue = std::move(mapValue);
	wtxNew.vOrderForm = std::move(orderForm);
	wtxNew.fTimeReceivedIsTxTime = true;
	wtxNew.fFromMe = true;

	WalletLogPrintfToBeContinued("CommitTransaction:\n%s",
	wtxNew.tx->ToString());

	// Add tx to wallet, because if it has change it's also ours, otherwise just
	// for transaction history.
	AddToWallet(wtxNew);

	// Notify that old coins are spent.
	for (const CTxIn &txin : wtxNew.tx->vin) {
	CWalletTx &coin = mapWallet.at(txin.prevout.GetTxId());
	coin.BindWallet(this);
	NotifyTransactionChanged(this, coin.GetId(), CT_UPDATED);
	}

	// Get the inserted-CWalletTx from mapWallet so that the
	// fInMempool flag is cached properly
	CWalletTx &wtx = mapWallet.at(wtxNew.GetId());

	if (!fBroadcastTransactions) {
	// Don't submit tx to the mempool
	return;
	}

	std::string err_string;
	if (!wtx.SubmitMemoryPoolAndRelay(err_string, true, *locked_chain)) {
	WalletLogPrintf("CommitTransaction(): Transaction cannot be broadcast "
	"immediately, %s\n",
	err_string);
	// TODO: if we expect the failure to be long term or permanent, instead
	// delete wtx from the wallet and return failure.
	}
	}

	DBErrors CWallet::LoadWallet(bool &fFirstRunRet) {
	// Even if we don't use this lock in this function, we want to preserve
	// lock order in LoadToWallet if query of chain state is needed to know
	// tx status. If lock can't be taken (e.g wallet-tool), tx confirmation
	// status may be not reliable.
	auto locked_chain = LockChain();
	LOCK(cs_wallet);

	fFirstRunRet = false;
	DBErrors nLoadWalletRet = WalletBatch(*database, "cr+").LoadWallet(this);
	if (nLoadWalletRet == DBErrors::NEED_REWRITE) {
	if (database->Rewrite("\x04pool")) {
	if (auto spk_man = m_spk_man.get()) {
	spk_man->RewriteDB();
	}
	}
	}

	{
	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) &&
	!IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET);
	}

	if (nLoadWalletRet != DBErrors::LOAD_OK) {
	return nLoadWalletRet;
	}

	return DBErrors::LOAD_OK;
	}

	DBErrors CWallet::ZapSelectTx(std::vector<TxId> &txIdsIn,
	std::vector<TxId> &txIdsOut) {
	AssertLockHeld(cs_wallet);
	DBErrors nZapSelectTxRet =
	WalletBatch(*database, "cr+").ZapSelectTx(txIdsIn, txIdsOut);
	for (const TxId &txid : txIdsOut) {
	const auto &it = mapWallet.find(txid);
	wtxOrdered.erase(it->second.m_it_wtxOrdered);
	mapWallet.erase(it);
	NotifyTransactionChanged(this, txid, CT_DELETED);
	}

	if (nZapSelectTxRet == DBErrors::NEED_REWRITE) {
	if (database->Rewrite("\x04pool")) {
	if (auto spk_man = m_spk_man.get()) {
	spk_man->RewriteDB();
	}
	}
	}

	if (nZapSelectTxRet != DBErrors::LOAD_OK) {
	return nZapSelectTxRet;
	}

	MarkDirty();

	return DBErrors::LOAD_OK;
	}

	DBErrors CWallet::ZapWalletTx(std::vector<CWalletTx> &vWtx) {
	DBErrors nZapWalletTxRet = WalletBatch(*database, "cr+").ZapWalletTx(vWtx);
	if (nZapWalletTxRet == DBErrors::NEED_REWRITE) {
	if (database->Rewrite("\x04pool")) {
	if (auto spk_man = m_spk_man.get()) {
	spk_man->RewriteDB();
	}
	}
	}

	if (nZapWalletTxRet != DBErrors::LOAD_OK) {
	return nZapWalletTxRet;
	}

	return DBErrors::LOAD_OK;
	}

	bool CWallet::SetAddressBookWithDB(WalletBatch &batch,
	const CTxDestination &address,
	const std::string &strName,
	const std::string &strPurpose) {
	bool fUpdated = false;
	{
	LOCK(cs_wallet);
	std::map<CTxDestination, CAddressBookData>::iterator mi =
	mapAddressBook.find(address);
	fUpdated = mi != mapAddressBook.end();
	mapAddressBook[address].name = strName;
	// Update purpose only if requested.
	if (!strPurpose.empty()) {
	mapAddressBook[address].purpose = strPurpose;
	}
	}

	NotifyAddressBookChanged(this, address, strName,
	IsMine(address) != ISMINE_NO, strPurpose,
	(fUpdated ? CT_UPDATED : CT_NEW));
	if (!strPurpose.empty() && !batch.WritePurpose(address, strPurpose)) {
	return false;
	}
	return batch.WriteName(address, strName);
	}

	bool CWallet::SetAddressBook(const CTxDestination &address,
	const std::string &strName,
	const std::string &strPurpose) {
	WalletBatch batch(*database);
	return SetAddressBookWithDB(batch, address, strName, strPurpose);
	}

	bool CWallet::DelAddressBook(const CTxDestination &address) {
	{
	LOCK(cs_wallet);

	// Delete destdata tuples associated with address.
	for (const std::pair<const std::string, std::string> &item :
	mapAddressBook[address].destdata) {
	WalletBatch(*database).EraseDestData(address, item.first);
	}

	mapAddressBook.erase(address);
	}

	NotifyAddressBookChanged(this, address, "", IsMine(address) != ISMINE_NO,
	"", CT_DELETED);

	WalletBatch(*database).ErasePurpose(address);
	return WalletBatch(*database).EraseName(address);
	}

	size_t CWallet::KeypoolCountExternalKeys() {
	AssertLockHeld(cs_wallet);

	unsigned int count = 0;
	if (auto spk_man = m_spk_man.get()) {
	AssertLockHeld(spk_man->cs_wallet);
	count += spk_man->KeypoolCountExternalKeys();
	}

	return count;
	}

	unsigned int CWallet::GetKeyPoolSize() const {
	AssertLockHeld(cs_wallet);

	unsigned int count = 0;
	if (auto spk_man = m_spk_man.get()) {
	count += spk_man->GetKeyPoolSize();
	}
	return count;
	}

	bool CWallet::TopUpKeyPool(unsigned int kpSize) {
	bool res = true;
	if (auto spk_man = m_spk_man.get()) {
	res &= spk_man->TopUp(kpSize);
	}
	return res;
	}

	bool CWallet::GetNewDestination(const OutputType type, const std::string label,
	CTxDestination &dest, std::string &error) {
	LOCK(cs_wallet);
	error.clear();
	bool result = false;
	auto spk_man = m_spk_man.get();
	if (spk_man) {
	result = spk_man->GetNewDestination(type, dest, error);
	}
	if (result) {
	SetAddressBook(dest, label, "receive");
	}

	return result;
	}

	bool CWallet::GetNewChangeDestination(const OutputType type,
	CTxDestination &dest,
	std::string &error) {
	error.clear();

	m_spk_man->TopUp();

	ReserveDestination reservedest(this);
	if (!reservedest.GetReservedDestination(type, dest, true)) {
	error = "Error: Keypool ran out, please call keypoolrefill first";
	return false;
	}

	reservedest.KeepDestination();
	return true;
	}

	int64_t CWallet::GetOldestKeyPoolTime() {
	int64_t oldestKey = std::numeric_limits<int64_t>::max();
	if (auto spk_man = m_spk_man.get()) {
	oldestKey = spk_man->GetOldestKeyPoolTime();
	}
	return oldestKey;
	}

	std::map<CTxDestination, Amount>
	CWallet::GetAddressBalances(interfaces::Chain::Lock &locked_chain) {
	std::map<CTxDestination, Amount> balances;

	LOCK(cs_wallet);
	for (const auto &walletEntry : mapWallet) {
	const CWalletTx &wtx = walletEntry.second;

	if (!wtx.IsTrusted(locked_chain)) {
	continue;
	}

	if (wtx.IsImmatureCoinBase(locked_chain)) {
	continue;
	}

	int nDepth = wtx.GetDepthInMainChain(locked_chain);
	if (nDepth < (wtx.IsFromMe(ISMINE_ALL) ? 0 : 1)) {
	continue;
	}

	for (uint32_t i = 0; i < wtx.tx->vout.size(); i++) {
	CTxDestination addr;
	if (!IsMine(wtx.tx->vout[i])) {
	continue;
	}

	if (!ExtractDestination(wtx.tx->vout[i].scriptPubKey, addr)) {
	continue;
	}

	Amount n = IsSpent(locked_chain, COutPoint(walletEntry.first, i))
	? Amount::zero()
	: wtx.tx->vout[i].nValue;

	if (!balances.count(addr)) {
	balances[addr] = Amount::zero();
	}
	balances[addr] += n;
	}
	}

	return balances;
	}

	std::set<std::set<CTxDestination>> CWallet::GetAddressGroupings() {
	AssertLockHeld(cs_wallet);
	std::set<std::set<CTxDestination>> groupings;
	std::set<CTxDestination> grouping;

	for (const auto &walletEntry : mapWallet) {
	const CWalletTx &wtx = walletEntry.second;

	if (wtx.tx->vin.size() > 0) {
	bool any_mine = false;
	// Group all input addresses with each other.
	for (const auto &txin : wtx.tx->vin) {
	CTxDestination address;
	// If this input isn't mine, ignore it.
	if (!IsMine(txin)) {
	continue;
	}

	if (!ExtractDestination(mapWallet.at(txin.prevout.GetTxId())
	.tx->vout[txin.prevout.GetN()]
	.scriptPubKey,
	address)) {
	continue;
	}

	grouping.insert(address);
	any_mine = true;
	}

	// Group change with input addresses.
	if (any_mine) {
	for (const auto &txout : wtx.tx->vout) {
	if (IsChange(txout)) {
	CTxDestination txoutAddr;
	if (!ExtractDestination(txout.scriptPubKey,
	txoutAddr)) {
	continue;
	}

	grouping.insert(txoutAddr);
	}
	}
	}

	if (grouping.size() > 0) {
	groupings.insert(grouping);
	grouping.clear();
	}
	}

	// Group lone addrs by themselves.
	for (const auto &txout : wtx.tx->vout) {
	if (IsMine(txout)) {
	CTxDestination address;
	if (!ExtractDestination(txout.scriptPubKey, address)) {
	continue;
	}

	grouping.insert(address);
	groupings.insert(grouping);
	grouping.clear();
	}
	}
	}

	// A set of pointers to groups of addresses.
	std::set<std::set<CTxDestination> *> uniqueGroupings;
	// Map addresses to the unique group containing it.
	std::map<CTxDestination, std::set<CTxDestination> *> setmap;
	for (std::set<CTxDestination> _grouping : groupings) {
	// Make a set of all the groups hit by this new group.
	std::set<std::set<CTxDestination> *> hits;
	std::map<CTxDestination, std::set<CTxDestination> *>::iterator it;
	for (const CTxDestination &address : _grouping) {
	if ((it = setmap.find(address)) != setmap.end()) {
	hits.insert((*it).second);
	}
	}

	// Merge all hit groups into a new single group and delete old groups.
	std::set<CTxDestination> *merged =
	new std::set<CTxDestination>(_grouping);
	for (std::set<CTxDestination> *hit : hits) {
	merged->insert(hit->begin(), hit->end());
	uniqueGroupings.erase(hit);
	delete hit;
	}
	uniqueGroupings.insert(merged);

	// Update setmap.
	for (const CTxDestination &element : *merged) {
	setmap[element] = merged;
	}
	}

	std::set<std::set<CTxDestination>> ret;
	for (const std::set<CTxDestination> *uniqueGrouping : uniqueGroupings) {
	ret.insert(*uniqueGrouping);
	delete uniqueGrouping;
	}

	return ret;
	}

	std::set<CTxDestination>
	CWallet::GetLabelAddresses(const std::string &label) const {
	LOCK(cs_wallet);
	std::set<CTxDestination> result;
	for (const std::pair<const CTxDestination, CAddressBookData> &item :
	mapAddressBook) {
	const CTxDestination &address = item.first;
	const std::string &strName = item.second.name;
	if (strName == label) {
	result.insert(address);
	}
	}

	return result;
	}

	bool ReserveDestination::GetReservedDestination(const OutputType type,
	CTxDestination &dest,
	bool internal) {
	m_spk_man = pwallet->GetLegacyScriptPubKeyMan();
	if (!m_spk_man) {
	return false;
	}

	if (!pwallet->CanGetAddresses(internal)) {
	return false;
	}

	if (nIndex == -1) {
	CKeyPool keypool;
	if (!m_spk_man->GetReservedDestination(type, internal, nIndex,
	keypool)) {
	return false;
	}

	vchPubKey = keypool.vchPubKey;
	fInternal = keypool.fInternal;
	}

	assert(vchPubKey.IsValid());
	m_spk_man->LearnRelatedScripts(vchPubKey, type);
	address = GetDestinationForKey(vchPubKey, type);
	dest = address;
	return true;
	}

	void ReserveDestination::KeepDestination() {
	if (nIndex != -1) {
	m_spk_man->KeepDestination(nIndex);
	}

	nIndex = -1;
	vchPubKey = CPubKey();
	address = CNoDestination();
	}

	void ReserveDestination::ReturnDestination() {
	if (nIndex != -1) {
	m_spk_man->ReturnDestination(nIndex, fInternal, vchPubKey);
	}
	nIndex = -1;
	vchPubKey = CPubKey();
	address = CNoDestination();
	}

	void CWallet::LockCoin(const COutPoint &output) {
	AssertLockHeld(cs_wallet);
	setLockedCoins.insert(output);
	}

	void CWallet::UnlockCoin(const COutPoint &output) {
	AssertLockHeld(cs_wallet);
	setLockedCoins.erase(output);
	}

	void CWallet::UnlockAllCoins() {
	AssertLockHeld(cs_wallet);
	setLockedCoins.clear();
	}

	bool CWallet::IsLockedCoin(const COutPoint &outpoint) const {
	AssertLockHeld(cs_wallet);

	return setLockedCoins.count(outpoint) > 0;
	}

	void CWallet::ListLockedCoins(std::vector<COutPoint> &vOutpts) const {
	AssertLockHeld(cs_wallet);
	for (COutPoint outpoint : setLockedCoins) {
	vOutpts.push_back(outpoint);
	}
	}

	/** @} */ // end of Actions

	void CWallet::GetKeyBirthTimes(interfaces::Chain::Lock &locked_chain,
	std::map<CKeyID, int64_t> &mapKeyBirth) const {
	AssertLockHeld(cs_wallet);
	mapKeyBirth.clear();

	LegacyScriptPubKeyMan *spk_man = GetLegacyScriptPubKeyMan();
	assert(spk_man != nullptr);
	AssertLockHeld(spk_man->cs_wallet);

	// Get birth times for keys with metadata.
	for (const auto &entry : spk_man->mapKeyMetadata) {
	if (entry.second.nCreateTime) {
	mapKeyBirth[entry.first] = entry.second.nCreateTime;
	}
	}

	// Map in which we'll infer heights of other keys
	const Optional<int> tip_height = locked_chain.getHeight();
	// the tip can be reorganized; use a 144-block safety margin
	const int max_height =
	tip_height && tip_height > 144 ? tip_height - 144 : 0;
	std::map<CKeyID, int> mapKeyFirstBlock;
	for (const CKeyID &keyid : spk_man->GetKeys()) {
	if (mapKeyBirth.count(keyid) == 0) {
	mapKeyFirstBlock[keyid] = max_height;
	}
	}

	// If there are no such keys, we're done.
	if (mapKeyFirstBlock.empty()) {
	return;
	}

	// Find first block that affects those keys, if there are any left.
	for (const auto &entry : mapWallet) {
	// iterate over all wallet transactions...
	const CWalletTx &wtx = entry.second;
	if (Optional<int> height =
	locked_chain.getBlockHeight(wtx.m_confirm.hashBlock)) {
	// ... which are already in a block
	for (const CTxOut &txout : wtx.tx->vout) {
	// Iterate over all their outputs...
	for (const auto &keyid :
	GetAffectedKeys(txout.scriptPubKey, *spk_man)) {
	// ... and all their affected keys.
	std::map<CKeyID, int>::iterator rit =
	mapKeyFirstBlock.find(keyid);
	if (rit != mapKeyFirstBlock.end() &&
	*height < rit->second) {
	rit->second = *height;
	}
	}
	}
	}
	}

	// Extract block timestamps for those keys.
	for (const auto &entry : mapKeyFirstBlock) {
	// block times can be 2h off
	mapKeyBirth[entry.first] =
	locked_chain.getBlockTime(entry.second) - TIMESTAMP_WINDOW;
	}
	}

	/**
	* Compute smart timestamp for a transaction being added to the wallet.
	*
	* Logic:
	* - If sending a transaction, assign its timestamp to the current time.
	* - If receiving a transaction outside a block, assign its timestamp to the
	* current time.
	* - If receiving a block with a future timestamp, assign all its (not already
	* known) transactions' timestamps to the current time.
	* - If receiving a block with a past timestamp, before the most recent known
	* transaction (that we care about), assign all its (not already known)
	* transactions' timestamps to the same timestamp as that most-recent-known
	* transaction.
	* - If receiving a block with a past timestamp, but after the most recent known
	* transaction, assign all its (not already known) transactions' timestamps to
	* the block time.
	*
	* For more information see CWalletTx::nTimeSmart,
	* https://bitcointalk.org/?topic=54527, or
	* https://github.com/bitcoin/bitcoin/pull/1393.
	*/
	unsigned int CWallet::ComputeTimeSmart(const CWalletTx &wtx) const {
	unsigned int nTimeSmart = wtx.nTimeReceived;
	if (!wtx.isUnconfirmed() && !wtx.isAbandoned()) {
	int64_t blocktime;
	if (chain().findBlock(wtx.m_confirm.hashBlock, nullptr /* block */,
	&blocktime)) {
	int64_t latestNow = wtx.nTimeReceived;
	int64_t latestEntry = 0;

	// Tolerate times up to the last timestamp in the wallet not more
	// than 5 minutes into the future
	int64_t latestTolerated = latestNow + 300;
	const TxItems &txOrdered = wtxOrdered;
	for (auto it = txOrdered.rbegin(); it != txOrdered.rend(); ++it) {
	CWalletTx *const pwtx = it->second;
	if (pwtx == &wtx) {
	continue;
	}
	int64_t nSmartTime;
	nSmartTime = pwtx->nTimeSmart;
	if (!nSmartTime) {
	nSmartTime = pwtx->nTimeReceived;
	}
	if (nSmartTime <= latestTolerated) {
	latestEntry = nSmartTime;
	if (nSmartTime > latestNow) {
	latestNow = nSmartTime;
	}
	break;
	}
	}

	nTimeSmart = std::max(latestEntry, std::min(blocktime, latestNow));
	} else {
	WalletLogPrintf("%s: found %s in block %s not in index\n", __func__,
	wtx.GetId().ToString(),
	wtx.m_confirm.hashBlock.ToString());
	}
	}
	return nTimeSmart;
	}

	bool CWallet::AddDestData(const CTxDestination &dest, const std::string &key,
	const std::string &value) {
	if (boost::get<CNoDestination>(&dest)) {
	return false;
	}

	mapAddressBook[dest].destdata.insert(std::make_pair(key, value));
	return WalletBatch(*database).WriteDestData(dest, key, value);
	}

	bool CWallet::EraseDestData(const CTxDestination &dest,
	const std::string &key) {
	if (!mapAddressBook[dest].destdata.erase(key)) {
	return false;
	}

	return WalletBatch(*database).EraseDestData(dest, key);
	}

	void CWallet::LoadDestData(const CTxDestination &dest, const std::string &key,
	const std::string &value) {
	mapAddressBook[dest].destdata.insert(std::make_pair(key, value));
	}

	bool CWallet::GetDestData(const CTxDestination &dest, const std::string &key,
	std::string *value) const {
	std::map<CTxDestination, CAddressBookData>::const_iterator i =
	mapAddressBook.find(dest);
	if (i != mapAddressBook.end()) {
	CAddressBookData::StringMap::const_iterator j =
	i->second.destdata.find(key);
	if (j != i->second.destdata.end()) {
	if (value) {
	*value = j->second;
	}

	return true;
	}
	}
	return false;
	}

	std::vector<std::string>
	CWallet::GetDestValues(const std::string &prefix) const {
	std::vector<std::string> values;
	for (const auto &address : mapAddressBook) {
	for (const auto &data : address.second.destdata) {
	if (!data.first.compare(0, prefix.size(), prefix)) {
	values.emplace_back(data.second);
	}
	}
	}
	return values;
	}

	bool CWallet::Verify(const CChainParams &chainParams, interfaces::Chain &chain,
	const WalletLocation &location, bool salvage_wallet,
	std::string &error_string,
	std::vector<std::string> &warnings) {
	// Do some checking on wallet path. It should be either a:
	//
	// 1. Path where a directory can be created.
	// 2. Path to an existing directory.
	// 3. Path to a symlink to a directory.
	// 4. For backwards compatibility, the name of a data file in -walletdir.
	LOCK(cs_wallets);
	const fs::path &wallet_path = location.GetPath();
	fs::file_type path_type = fs::symlink_status(wallet_path).type();
	if (!(path_type == fs::file_not_found \|\| path_type == fs::directory_file \|\|
	(path_type == fs::symlink_file && fs::is_directory(wallet_path)) \|\|
	(path_type == fs::regular_file &&
	fs::path(location.GetName()).filename() == location.GetName()))) {
	error_string =
	strprintf("Invalid -wallet path '%s'. -wallet path should point to "
	"a directory where wallet.dat and "
	"database/log.?????????? files can be stored, a location "
	"where such a directory could be created, "
	"or (for backwards compatibility) the name of an "
	"existing data file in -walletdir (%s)",
	location.GetName(), GetWalletDir());
	return false;
	}

	// Make sure that the wallet path doesn't clash with an existing wallet path
	if (IsWalletLoaded(wallet_path)) {
	error_string = strprintf(
	"Error loading wallet %s. Duplicate -wallet filename specified.",
	location.GetName());
	return false;
	}

	// Keep same database environment instance across Verify/Recover calls
	// below.
	std::unique_ptr<WalletDatabase> database =
	WalletDatabase::Create(wallet_path);

	try {
	if (!WalletBatch::VerifyEnvironment(wallet_path, error_string)) {
	return false;
	}
	} catch (const fs::filesystem_error &e) {
	error_string =
	strprintf("Error loading wallet %s. %s", location.GetName(),
	fsbridge::get_filesystem_error_message(e));
	return false;
	}

	if (salvage_wallet) {
	// Recover readable keypairs:
	CWallet dummyWallet(chainParams, &chain, WalletLocation(),
	WalletDatabase::CreateDummy());
	std::string backup_filename;
	// Even if we don't use this lock in this function, we want to preserve
	// lock order in LoadToWallet if query of chain state is needed to know
	// tx status. If lock can't be taken, tx confirmation status may be not
	// reliable.
	auto locked_chain = dummyWallet.LockChain();
	if (!WalletBatch::Recover(
	wallet_path, static_cast<void *>(&dummyWallet),
	WalletBatch::RecoverKeysOnlyFilter, backup_filename)) {
	return false;
	}
	}

	return WalletBatch::VerifyDatabaseFile(wallet_path, warnings, error_string);
	}

	std::shared_ptr<CWallet> CWallet::CreateWalletFromFile(
	const CChainParams &chainParams, interfaces::Chain &chain,
	const WalletLocation &location, std::string &error,
	std::vector<std::string> &warnings, uint64_t wallet_creation_flags) {
	const std::string walletFile =
	WalletDataFilePath(location.GetPath()).string();

	// Needed to restore wallet transaction meta data after -zapwallettxes
	std::vector<CWalletTx> vWtx;

	if (gArgs.GetBoolArg("-zapwallettxes", false)) {
	chain.initMessage(
	_("Zapping all transactions from wallet...").translated);

	std::unique_ptr<CWallet> tempWallet = std::make_unique<CWallet>(
	chainParams, &chain, location,
	WalletDatabase::Create(location.GetPath()));
	DBErrors nZapWalletRet = tempWallet->ZapWalletTx(vWtx);
	if (nZapWalletRet != DBErrors::LOAD_OK) {
	error = strprintf(
	_("Error loading %s: Wallet corrupted").translated, walletFile);
	return nullptr;
	}
	}

	chain.initMessage(_("Loading wallet...").translated);

	int64_t nStart = GetTimeMillis();
	bool fFirstRun = true;
	// 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(chainParams, &chain, location,
	WalletDatabase::Create(location.GetPath())),
	ReleaseWallet);
	DBErrors nLoadWalletRet = walletInstance->LoadWallet(fFirstRun);
	if (nLoadWalletRet != DBErrors::LOAD_OK) {
	if (nLoadWalletRet == DBErrors::CORRUPT) {
	error = strprintf(
	_("Error loading %s: Wallet corrupted").translated, walletFile);
	return nullptr;
	}

	if (nLoadWalletRet == DBErrors::NONCRITICAL_ERROR) {
	warnings.push_back(strprintf(
	_("Error reading %s! All keys read correctly, but transaction "
	"data or address book entries might be missing or incorrect.")
	.translated,
	walletFile));
	} else if (nLoadWalletRet == DBErrors::TOO_NEW) {
	error = strprintf(
	_("Error loading %s: Wallet requires newer version of %s")
	.translated,
	walletFile, PACKAGE_NAME);
	return nullptr;
	} else if (nLoadWalletRet == DBErrors::NEED_REWRITE) {
	error = strprintf(
	_("Wallet needed to be rewritten: restart %s to complete")
	.translated,
	PACKAGE_NAME);
	return nullptr;
	} else {
	error = strprintf(_("Error loading %s").translated, walletFile);
	return nullptr;
	}
	}

	int prev_version = walletInstance->GetVersion();
	if (gArgs.GetBoolArg("-upgradewallet", fFirstRun)) {
	int nMaxVersion = gArgs.GetArg("-upgradewallet", 0);
	// The -upgradewallet without argument case
	if (nMaxVersion == 0) {
	walletInstance->WalletLogPrintf("Performing wallet upgrade to %i\n",
	FEATURE_LATEST);
	nMaxVersion = FEATURE_LATEST;
	// permanently upgrade the wallet immediately
	walletInstance->SetMinVersion(FEATURE_LATEST);
	} else {
	walletInstance->WalletLogPrintf(
	"Allowing wallet upgrade up to %i\n", nMaxVersion);
	}

	if (nMaxVersion < walletInstance->GetVersion()) {
	error = _("Cannot downgrade wallet").translated;
	return nullptr;
	}

	walletInstance->SetMaxVersion(nMaxVersion);
	}

	// Upgrade to HD if explicit upgrade
	if (gArgs.GetBoolArg("-upgradewallet", false)) {
	LOCK(walletInstance->cs_wallet);

	// Do not upgrade versions to any version between HD_SPLIT and
	// FEATURE_PRE_SPLIT_KEYPOOL unless already supporting HD_SPLIT
	int max_version = walletInstance->GetVersion();
	if (!walletInstance->CanSupportFeature(FEATURE_HD_SPLIT) &&
	max_version >= FEATURE_HD_SPLIT &&
	max_version < FEATURE_PRE_SPLIT_KEYPOOL) {
	error =
	_("Cannot upgrade a non HD split wallet without upgrading to "
	"support pre split keypool. Please use -upgradewallet=200300 "
	"or -upgradewallet with no version specified.")
	.translated;
	return nullptr;
	}

	if (auto spk_man = walletInstance->m_spk_man.get()) {
	if (!spk_man->Upgrade(prev_version, error)) {
	chain.initError(error);
	return nullptr;
	}
	}
	}

	if (fFirstRun) {
	// Ensure this wallet.dat can only be opened by clients supporting
	// HD with chain split and expects no default key.
	walletInstance->SetMinVersion(FEATURE_LATEST);

	walletInstance->SetWalletFlags(wallet_creation_flags, false);
	if (!(wallet_creation_flags &
	(WALLET_FLAG_DISABLE_PRIVATE_KEYS \| WALLET_FLAG_BLANK_WALLET))) {
	if (auto spk_man = walletInstance->m_spk_man.get()) {
	if (!spk_man->SetupGeneration()) {
	error = _("Unable to generate initial keys").translated;
	return nullptr;
	}
	}
	}

	auto locked_chain = chain.lock();
	walletInstance->ChainStateFlushed(locked_chain->getTipLocator());
	} else if (wallet_creation_flags & WALLET_FLAG_DISABLE_PRIVATE_KEYS) {
	// Make it impossible to disable private keys after creation
	error = strprintf(_("Error loading %s: Private keys can only be "
	"disabled during creation")
	.translated,
	walletFile);
	return nullptr;
	} else if (walletInstance->IsWalletFlagSet(
	WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
	if (walletInstance->m_spk_man) {
	if (walletInstance->m_spk_man->HavePrivateKeys()) {
	warnings.push_back(
	strprintf(_("Warning: Private keys detected in wallet {%s} "
	"with disabled private keys")
	.translated,
	walletFile));
	}
	}
	}

	if (gArgs.IsArgSet("-mintxfee")) {
	Amount n = Amount::zero();
	if (!ParseMoney(gArgs.GetArg("-mintxfee", ""), n) \|\|
	n == Amount::zero()) {
	error = AmountErrMsg("mintxfee", gArgs.GetArg("-mintxfee", ""))
	.translated;
	return nullptr;
	}
	if (n > HIGH_TX_FEE_PER_KB) {
	warnings.push_back(AmountHighWarn("-mintxfee").translated + " " +
	_("This is the minimum transaction fee you pay "
	"on every transaction.")
	.translated);
	}
	walletInstance->m_min_fee = CFeeRate(n);
	}

	if (gArgs.IsArgSet("-fallbackfee")) {
	Amount nFeePerK = Amount::zero();
	if (!ParseMoney(gArgs.GetArg("-fallbackfee", ""), nFeePerK)) {
	error = strprintf(
	_("Invalid amount for -fallbackfee=<amount>: '%s'").translated,
	gArgs.GetArg("-fallbackfee", ""));
	return nullptr;
	}
	if (nFeePerK > HIGH_TX_FEE_PER_KB) {
	warnings.push_back(AmountHighWarn("-fallbackfee").translated + " " +
	_("This is the transaction fee you may pay when "
	"fee estimates are not available.")
	.translated);
	}
	walletInstance->m_fallback_fee = CFeeRate(nFeePerK);
	}
	// Disable fallback fee in case value was set to 0, enable if non-null value
	walletInstance->m_allow_fallback_fee =
	walletInstance->m_fallback_fee.GetFeePerK() != Amount::zero();

	if (gArgs.IsArgSet("-paytxfee")) {
	Amount nFeePerK = Amount::zero();
	if (!ParseMoney(gArgs.GetArg("-paytxfee", ""), nFeePerK)) {
	error = AmountErrMsg("paytxfee", gArgs.GetArg("-paytxfee", ""))
	.translated;
	return nullptr;
	}
	if (nFeePerK > HIGH_TX_FEE_PER_KB) {
	warnings.push_back(AmountHighWarn("-paytxfee").translated + " " +
	_("This is the transaction fee you will pay if "
	"you send a transaction.")
	.translated);
	}
	walletInstance->m_pay_tx_fee = CFeeRate(nFeePerK, 1000);
	if (walletInstance->m_pay_tx_fee < chain.relayMinFee()) {
	error = strprintf(_("Invalid amount for -paytxfee=<amount>: '%s' "
	"(must be at least %s)")
	.translated,
	gArgs.GetArg("-paytxfee", ""),
	chain.relayMinFee().ToString());
	return nullptr;
	}
	}

	if (gArgs.IsArgSet("-maxtxfee")) {
	Amount nMaxFee = Amount::zero();
	if (!ParseMoney(gArgs.GetArg("-maxtxfee", ""), nMaxFee)) {
	error = AmountErrMsg("maxtxfee", gArgs.GetArg("-maxtxfee", ""))
	.translated;
	return nullptr;
	}
	if (nMaxFee > HIGH_MAX_TX_FEE) {
	warnings.push_back(_("-maxtxfee is set very high! Fees this large "
	"could be paid on a single transaction.")
	.translated);
	}
	if (CFeeRate(nMaxFee, 1000) < chain.relayMinFee()) {
	error = strprintf(
	_("Invalid amount for -maxtxfee=<amount>: '%s' (must be at "
	"least the minrelay fee of %s to prevent stuck transactions)")
	.translated,
	gArgs.GetArg("-maxtxfee", ""), chain.relayMinFee().ToString());
	return nullptr;
	}
	walletInstance->m_default_max_tx_fee = nMaxFee;
	}

	if (chain.relayMinFee().GetFeePerK() > HIGH_TX_FEE_PER_KB) {
	warnings.push_back(
	AmountHighWarn("-minrelaytxfee").translated + " " +
	_("The wallet will avoid paying less than the minimum relay fee.")
	.translated);
	}

	walletInstance->m_spend_zero_conf_change =
	gArgs.GetBoolArg("-spendzeroconfchange", DEFAULT_SPEND_ZEROCONF_CHANGE);

	walletInstance->m_default_address_type = DEFAULT_ADDRESS_TYPE;
	walletInstance->m_default_change_type = DEFAULT_CHANGE_TYPE;

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

	// Try to top up keypool. No-op if the wallet is locked.
	walletInstance->TopUpKeyPool();

	auto locked_chain = chain.lock();
	LOCK(walletInstance->cs_wallet);

	int rescan_height = 0;
	if (!gArgs.GetBoolArg("-rescan", false)) {
	WalletBatch batch(*walletInstance->database);
	CBlockLocator locator;
	if (batch.ReadBestBlock(locator)) {
	if (const Optional<int> fork_height =
	locked_chain->findLocatorFork(locator)) {
	rescan_height = *fork_height;
	}
	}
	}

	const Optional<int> tip_height = locked_chain->getHeight();
	if (tip_height) {
	walletInstance->m_last_block_processed =
	locked_chain->getBlockHash(*tip_height);
	walletInstance->m_last_block_processed_height = *tip_height;
	} else {
	walletInstance->m_last_block_processed.SetNull();
	walletInstance->m_last_block_processed_height = -1;
	}

	if (tip_height && *tip_height != rescan_height) {
	// We can't rescan beyond non-pruned blocks, stop and throw an error.
	// This might happen if a user uses an old wallet within a pruned node
	// or if they ran -disablewallet for a longer time, then decided to
	// re-enable
	if (chain.havePruned()) {
	// Exit early and print an error.
	// If a block is pruned after this check, we will load the wallet,
	// but fail the rescan with a generic error.
	int block_height = *tip_height;
	while (block_height > 0 &&
	locked_chain->haveBlockOnDisk(block_height - 1) &&
	rescan_height != block_height) {
	--block_height;
	}

	if (rescan_height != block_height) {
	error = _("Prune: last wallet synchronisation goes beyond "
	"pruned data. You need to -reindex (download the "
	"whole blockchain again in case of pruned node)")
	.translated;
	return nullptr;
	}
	}

	chain.initMessage(_("Rescanning...").translated);
	walletInstance->WalletLogPrintf(
	"Rescanning last %i blocks (from block %i)...\n",
	*tip_height - rescan_height, rescan_height);

	// No need to read and scan block if block was created before our wallet
	// birthday (as adjusted for block time variability)
	Optional<int64_t> time_first_key;
	if (auto spk_man = walletInstance->m_spk_man.get()) {
	int64_t time = spk_man->GetTimeFirstKey();
	if (!time_first_key \|\| time < *time_first_key) {
	time_first_key = time;
	}
	}
	if (time_first_key) {
	if (Optional<int> first_block =
	locked_chain->findFirstBlockWithTimeAndHeight(
	*time_first_key - TIMESTAMP_WINDOW, rescan_height,
	nullptr)) {
	rescan_height = *first_block;
	}
	}

	{
	WalletRescanReserver reserver(walletInstance.get());
	if (!reserver.reserve() \|\|
	(ScanResult::SUCCESS !=
	walletInstance
	->ScanForWalletTransactions(
	locked_chain->getBlockHash(rescan_height), BlockHash(),
	reserver, true /* update */)
	.status)) {
	error = _("Failed to rescan the wallet during initialization")
	.translated;
	return nullptr;
	}
	}
	walletInstance->ChainStateFlushed(locked_chain->getTipLocator());
	walletInstance->database->IncrementUpdateCounter();

	// Restore wallet transaction metadata after -zapwallettxes=1
	if (gArgs.GetBoolArg("-zapwallettxes", false) &&
	gArgs.GetArg("-zapwallettxes", "1") != "2") {
	WalletBatch batch(*walletInstance->database);

	for (const CWalletTx &wtxOld : vWtx) {
	const TxId txid = wtxOld.GetId();
	std::map<TxId, CWalletTx>::iterator mi =
	walletInstance->mapWallet.find(txid);
	if (mi != walletInstance->mapWallet.end()) {
	const CWalletTx *copyFrom = &wtxOld;
	CWalletTx *copyTo = &mi->second;
	copyTo->mapValue = copyFrom->mapValue;
	copyTo->vOrderForm = copyFrom->vOrderForm;
	copyTo->nTimeReceived = copyFrom->nTimeReceived;
	copyTo->nTimeSmart = copyFrom->nTimeSmart;
	copyTo->fFromMe = copyFrom->fFromMe;
	copyTo->nOrderPos = copyFrom->nOrderPos;
	batch.WriteTx(*copyTo);
	}
	}
	}
	}

	chain.loadWallet(interfaces::MakeWallet(walletInstance));

	// Register with the validation interface. It's ok to do this after rescan
	// since we're still holding locked_chain.
	walletInstance->m_chain_notifications_handler =
	walletInstance->chain().handleNotifications(walletInstance);

	walletInstance->SetBroadcastTransactions(
	gArgs.GetBoolArg("-walletbroadcast", DEFAULT_WALLETBROADCAST));

	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());

	return walletInstance;
	}

	void CWallet::postInitProcess() {
	auto locked_chain = chain().lock();
	LOCK(cs_wallet);

	// Add wallet transactions that aren't already in a block to mempool.
	// Do this here as mempool requires genesis block to be loaded.
	ReacceptWalletTransactions(*locked_chain);

	// Update wallet transactions with current mempool transactions.
	chain().requestMempoolTransactions(*this);
	}

	bool CWallet::BackupWallet(const std::string &strDest) {
	return database->Backup(strDest);
	}

	CKeyPool::CKeyPool() {
	nTime = GetTime();
	fInternal = false;
	m_pre_split = false;
	}

	CKeyPool::CKeyPool(const CPubKey &vchPubKeyIn, bool internalIn) {
	nTime = GetTime();
	vchPubKey = vchPubKeyIn;
	fInternal = internalIn;
	m_pre_split = false;
	}

	int CWalletTx::GetDepthInMainChain(
	interfaces::Chain::Lock &locked_chain) const {
	+ assert(pwallet != nullptr);
	+ AssertLockHeld(pwallet->cs_wallet);
	if (isUnconfirmed() \|\| isAbandoned()) {
	return 0;
	}

	- return locked_chain.getBlockDepth(m_confirm.hashBlock) *
	+ return (pwallet->GetLastBlockHeight() - m_confirm.block_height + 1) *
	(isConflicted() ? -1 : 1);
	}

	int CWalletTx::GetBlocksToMaturity(
	interfaces::Chain::Lock &locked_chain) const {
	if (!IsCoinBase()) {
	return 0;
	}

	int chain_depth = GetDepthInMainChain(locked_chain);
	// coinbase tx should not be conflicted
	assert(chain_depth >= 0);
	return std::max(0, (COINBASE_MATURITY + 1) - chain_depth);
	}

	bool CWalletTx::IsImmatureCoinBase(
	interfaces::Chain::Lock &locked_chain) const {
	// note GetBlocksToMaturity is 0 for non-coinbase tx
	return GetBlocksToMaturity(locked_chain) > 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;
	chain().getTransactionAncestry(output.tx->GetId(), 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::SetCrypted() {
	LOCK(cs_KeyStore);
	if (fUseCrypto) {
	return true;
	}
	if (!mapKeys.empty()) {
	return false;
	}
	fUseCrypto = true;
	return true;
	}

	bool CWallet::IsLocked() const {
	if (!IsCrypted()) {
	return false;
	}
	LOCK(cs_KeyStore);
	return vMasterKey.empty();
	}

	bool CWallet::Lock() {
	if (!SetCrypted()) {
	return false;
	}

	{
	LOCK(cs_KeyStore);
	vMasterKey.clear();
	}

	NotifyStatusChanged(this);
	return true;
	}

	ScriptPubKeyMan *CWallet::GetScriptPubKeyMan() const {
	return m_spk_man.get();
	}

	const SigningProvider *CWallet::GetSigningProvider() const {
	return m_spk_man.get();
	}

	LegacyScriptPubKeyMan *CWallet::GetLegacyScriptPubKeyMan() const {
	return m_spk_man.get();
	}
	diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
	index bef6ca993..1e9eabdce 100644
	--- a/src/wallet/wallet.h
	+++ b/src/wallet/wallet.h
	@@ -1,1447 +1,1454 @@
	// Copyright (c) 2009-2010 Satoshi Nakamoto
	// Copyright (c) 2009-2016 The Bitcoin Core developers
	// Copyright (c) 2018-2020 The Bitcoin developers
	// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#ifndef BITCOIN_WALLET_WALLET_H
	#define BITCOIN_WALLET_WALLET_H

	#include <amount.h>
	#include <interfaces/chain.h>
	#include <interfaces/handler.h>
	#include <outputtype.h>
	#include <primitives/blockhash.h>
	#include <tinyformat.h>
	#include <ui_interface.h>
	#include <util/strencodings.h>
	#include <util/system.h>
	#include <validationinterface.h>
	#include <wallet/coinselection.h>
	#include <wallet/crypter.h>
	#include <wallet/rpcwallet.h>
	#include <wallet/scriptpubkeyman.h>
	#include <wallet/walletdb.h>
	#include <wallet/walletutil.h>

	#include <algorithm>
	#include <atomic>
	#include <cstdint>
	#include <map>
	#include <memory>
	#include <set>
	#include <stdexcept>
	#include <string>
	#include <utility>
	#include <vector>

	#include <boost/signals2/signal.hpp>

	//! Explicitly unload and delete the wallet.
	//! Blocks the current thread after signaling the unload intent so that all
	//! wallet clients release the wallet.
	//! Note that, when blocking is not required, the wallet is implicitly unloaded
	//! by the shared pointer deleter.
	void UnloadWallet(std::shared_ptr<CWallet> &&wallet);

	bool AddWallet(const std::shared_ptr<CWallet> &wallet);
	bool RemoveWallet(const std::shared_ptr<CWallet> &wallet);
	bool HasWallets();
	std::vector<std::shared_ptr<CWallet>> GetWallets();
	std::shared_ptr<CWallet> GetWallet(const std::string &name);
	std::shared_ptr<CWallet> LoadWallet(const CChainParams &chainParams,
	interfaces::Chain &chain,
	const WalletLocation &location,
	std::string &error,
	std::vector<std::string> &warnings);

	enum class WalletCreationStatus { SUCCESS, CREATION_FAILED, ENCRYPTION_FAILED };

	WalletCreationStatus CreateWallet(const CChainParams &params,
	interfaces::Chain &chain,
	const SecureString &passphrase,
	uint64_t wallet_creation_flags,
	const std::string &name, std::string &error,
	std::vector<std::string> &warnings,
	std::shared_ptr<CWallet> &result);

	//! -paytxfee default
	constexpr Amount DEFAULT_PAY_TX_FEE = Amount::zero();
	//! -fallbackfee default
	static const Amount DEFAULT_FALLBACK_FEE = Amount::zero();
	//! -mintxfee default
	static const Amount DEFAULT_TRANSACTION_MINFEE_PER_KB = 1000 * SATOSHI;
	//! minimum recommended increment for BIP 125 replacement txs
	static const Amount WALLET_INCREMENTAL_RELAY_FEE(5000 * SATOSHI);
	//! Default for -spendzeroconfchange
	static const bool DEFAULT_SPEND_ZEROCONF_CHANGE = true;
	//! Default for -walletrejectlongchains
	static const bool DEFAULT_WALLET_REJECT_LONG_CHAINS = false;
	//! Default for -avoidpartialspends
	static const bool DEFAULT_AVOIDPARTIALSPENDS = false;
	static const bool DEFAULT_WALLETBROADCAST = true;
	static const bool DEFAULT_DISABLE_WALLET = false;
	//! -maxtxfee default
	constexpr Amount DEFAULT_TRANSACTION_MAXFEE{COIN / 10};
	//! Discourage users to set fees higher than this amount (in satoshis) per kB
	constexpr Amount HIGH_TX_FEE_PER_KB{COIN / 100};
	//! -maxtxfee will warn if called with a higher fee than this amount (in
	//! satoshis)
	constexpr Amount HIGH_MAX_TX_FEE{100 * HIGH_TX_FEE_PER_KB};

	class CChainParams;
	class CCoinControl;
	class COutput;
	class CScript;
	class CTxMemPool;
	class CWalletTx;
	class ReserveDestination;

	//! Default for -addresstype
	constexpr OutputType DEFAULT_ADDRESS_TYPE{OutputType::LEGACY};

	//! Default for -changetype
	constexpr OutputType DEFAULT_CHANGE_TYPE{OutputType::CHANGE_AUTO};

	static constexpr uint64_t KNOWN_WALLET_FLAGS =
	WALLET_FLAG_AVOID_REUSE \| WALLET_FLAG_BLANK_WALLET \|
	WALLET_FLAG_KEY_ORIGIN_METADATA \| WALLET_FLAG_DISABLE_PRIVATE_KEYS;

	static constexpr uint64_t MUTABLE_WALLET_FLAGS = WALLET_FLAG_AVOID_REUSE;

	static const std::map<std::string, WalletFlags> WALLET_FLAG_MAP{
	{"avoid_reuse", WALLET_FLAG_AVOID_REUSE},
	{"blank", WALLET_FLAG_BLANK_WALLET},
	{"key_origin_metadata", WALLET_FLAG_KEY_ORIGIN_METADATA},
	{"disable_private_keys", WALLET_FLAG_DISABLE_PRIVATE_KEYS},
	};

	extern const std::map<uint64_t, std::string> WALLET_FLAG_CAVEATS;

	/**
	* A wrapper to reserve an address from a wallet
	*
	* ReserveDestination is used to reserve an address.
	* It is currently only used inside of CreateTransaction.
	*
	* Instantiating a ReserveDestination does not reserve an address. To do so,
	* GetReservedDestination() needs to be called on the object. Once an address
	* has been reserved, call KeepDestination() on the ReserveDestination object to
	* make sure it is not returned. Call ReturnDestination() to return the address
	* so it can be re-used (for example, if the address was used in a new
	* transaction and that transaction was not completed and needed to be aborted).
	*
	* If an address is reserved and KeepDestination() is not called, then the
	* address will be returned when the ReserveDestination goes out of scope.
	*/
	class ReserveDestination {
	protected:
	//! The wallet to reserve from
	CWallet *pwallet;
	LegacyScriptPubKeyMan *m_spk_man{nullptr};
	//! The index of the address's key in the keypool
	int64_t nIndex{-1};
	//! The public key for the address
	CPubKey vchPubKey;
	//! The destination
	CTxDestination address;
	//! Whether this is from the internal (change output) keypool
	bool fInternal{false};

	public:
	//! Construct a ReserveDestination object. This does NOT reserve an address
	//! yet
	explicit ReserveDestination(CWallet *pwalletIn) { pwallet = pwalletIn; }

	ReserveDestination(const ReserveDestination &) = delete;
	ReserveDestination &operator=(const ReserveDestination &) = delete;

	//! Destructor. If a key has been reserved and not KeepKey'ed, it will be
	//! returned to the keypool
	~ReserveDestination() { ReturnDestination(); }

	//! Reserve an address
	bool GetReservedDestination(const OutputType type, CTxDestination &pubkey,
	bool internal);
	//! Return reserved address
	void ReturnDestination();
	//! Keep the address. Do not return it's key to the keypool when this object
	//! goes out of scope
	void KeepDestination();
	};

	/** Address book data */
	class CAddressBookData {
	public:
	std::string name;
	std::string purpose;

	CAddressBookData() : purpose("unknown") {}

	typedef std::map<std::string, std::string> StringMap;
	StringMap destdata;
	};

	struct CRecipient {
	CScript scriptPubKey;
	Amount nAmount;
	bool fSubtractFeeFromAmount;
	};

	typedef std::map<std::string, std::string> mapValue_t;

	static inline void ReadOrderPos(int64_t &nOrderPos, mapValue_t &mapValue) {
	if (!mapValue.count("n")) {
	// TODO: calculate elsewhere
	nOrderPos = -1;
	return;
	}

	nOrderPos = atoi64(mapValue["n"].c_str());
	}

	static inline void WriteOrderPos(const int64_t &nOrderPos,
	mapValue_t &mapValue) {
	if (nOrderPos == -1) {
	return;
	}
	mapValue["n"] = i64tostr(nOrderPos);
	}

	struct COutputEntry {
	CTxDestination destination;
	Amount amount;
	int vout;
	};

	/**
	* Legacy class used for deserializing vtxPrev for backwards compatibility.
	* vtxPrev was removed in commit 93a18a3650292afbb441a47d1fa1b94aeb0164e3,
	* but old wallet.dat files may still contain vtxPrev vectors of CMerkleTxs.
	* These need to get deserialized for field alignment when deserializing
	* a CWalletTx, but the deserialized values are discarded.
	*/
	class CMerkleTx {
	public:
	template <typename Stream> void Unserialize(Stream &s) {
	CTransactionRef tx;
	BlockHash hashBlock;
	std::vector<uint256> vMerkleBranch;
	int nIndex = 0;

	s >> tx >> hashBlock >> vMerkleBranch >> nIndex;
	}
	};

	// Get the marginal bytes of spending the specified output
	int CalculateMaximumSignedInputSize(const CTxOut &txout, const CWallet *pwallet,
	bool use_max_sig = false);

	/**
	* A transaction with a bunch of additional info that only the owner cares
	* about. It includes any unrecorded transactions needed to link it back to the
	* block chain.
	*/
	class CWalletTx {
	private:
	const CWallet *pwallet;

	/**
	* Constant used in hashBlock to indicate tx has been abandoned, only used
	* at serialization/deserialization to avoid ambiguity with conflicted.
	*/
	static const BlockHash ABANDON_HASH;

	public:
	/**
	* Key/value map with information about the transaction.
	*
	* The following keys can be read and written through the map and are
	* serialized in the wallet database:
	*
	* "comment", "to" - comment strings provided to sendtoaddress,
	* and sendmany wallet RPCs
	* "replaces_txid" - txid (as HexStr) of transaction replaced by
	* bumpfee on transaction created by bumpfee
	* "replaced_by_txid" - txid (as HexStr) of transaction created by
	* bumpfee on transaction replaced by bumpfee
	* "from", "message" - obsolete fields that could be set in UI prior to
	* 2011 (removed in commit 4d9b223)
	*
	* The following keys are serialized in the wallet database, but shouldn't
	* be read or written through the map (they will be temporarily added and
	* removed from the map during serialization):
	*
	* "fromaccount" - serialized strFromAccount value
	* "n" - serialized nOrderPos value
	* "timesmart" - serialized nTimeSmart value
	* "spent" - serialized vfSpent value that existed prior to
	* 2014 (removed in commit 93a18a3)
	*/
	mapValue_t mapValue;
	std::vector<std::pair<std::string, std::string>> vOrderForm;
	unsigned int fTimeReceivedIsTxTime;
	//! time received by this node
	unsigned int nTimeReceived;
	/**
	* Stable timestamp that never changes, and reflects the order a transaction
	* was added to the wallet. Timestamp is based on the block time for a
	* transaction added as part of a block, or else the time when the
	* transaction was received if it wasn't part of a block, with the timestamp
	* adjusted in both cases so timestamp order matches the order transactions
	* were added to the wallet. More details can be found in
	* CWallet::ComputeTimeSmart().
	*/
	unsigned int nTimeSmart;
	/**
	* From me flag is set to 1 for transactions that were created by the wallet
	* on this bitcoin node, and set to 0 for transactions that were created
	* externally and came in through the network or sendrawtransaction RPC.
	*/
	bool fFromMe;
	//! position in ordered transaction list
	int64_t nOrderPos;
	std::multimap<int64_t, CWalletTx *>::const_iterator m_it_wtxOrdered;

	// memory only
	enum AmountType {
	DEBIT,
	CREDIT,
	IMMATURE_CREDIT,
	AVAILABLE_CREDIT,
	AMOUNTTYPE_ENUM_ELEMENTS
	};
	Amount GetCachableAmount(AmountType type, const isminefilter &filter,
	bool recalculate = false) const;
	mutable CachableAmount m_amounts[AMOUNTTYPE_ENUM_ELEMENTS];
	mutable bool fChangeCached;
	mutable bool fInMempool;
	mutable Amount nChangeCached;

	CWalletTx(const CWallet *pwalletIn, CTransactionRef arg)
	: tx(std::move(arg)) {
	Init(pwalletIn);
	}

	void Init(const CWallet *pwalletIn) {
	pwallet = pwalletIn;
	mapValue.clear();
	vOrderForm.clear();
	fTimeReceivedIsTxTime = false;
	nTimeReceived = 0;
	nTimeSmart = 0;
	fFromMe = false;
	fChangeCached = false;
	fInMempool = false;
	nChangeCached = Amount::zero();
	nOrderPos = -1;
	m_confirm = Confirmation{};
	}

	CTransactionRef tx;

	/**
	* New transactions start as UNCONFIRMED. At BlockConnected,
	* they will transition to CONFIRMED. In case of reorg, at
	* BlockDisconnected, they roll back to UNCONFIRMED. If we detect a
	* conflicting transaction at block connection, we update conflicted tx and
	* its dependencies as CONFLICTED. If tx isn't confirmed and outside of
	* mempool, the user may switch it to ABANDONED by using the
	* abandontransaction call. This last status may be override by a CONFLICTED
	* or CONFIRMED transition.
	*/
	enum Status { UNCONFIRMED, CONFIRMED, CONFLICTED, ABANDONED };

	/**
	* Confirmation includes tx status and a triplet of {block height/block
	* hash/tx index in block} at which tx has been confirmed. All three are set
	* to 0 if tx is unconfirmed or abandoned. Meaning of these fields changes
	* with CONFLICTED state where they instead point to block hash and block
	* height of the deepest conflicting tx.
	*/
	struct Confirmation {
	Status status;
	int block_height;
	BlockHash hashBlock;
	int nIndex;
	Confirmation(Status s = UNCONFIRMED, int b = 0,
	BlockHash h = BlockHash(), int i = 0)
	: status(s), block_height(b), hashBlock(h), nIndex(i) {}
	};

	Confirmation m_confirm;

	template <typename Stream> void Serialize(Stream &s) const {
	mapValue_t mapValueCopy = mapValue;

	mapValueCopy["fromaccount"] = "";
	WriteOrderPos(nOrderPos, mapValueCopy);
	if (nTimeSmart) {
	mapValueCopy["timesmart"] = strprintf("%u", nTimeSmart);
	}

	//! Used to be vMerkleBranch
	std::vector<char> dummy_vector1;
	//! Used to be vtxPrev
	std::vector<char> dummy_vector2;
	//! Used to be fSpent
	bool dummy_bool = false;
	uint256 serializedHash =
	isAbandoned() ? ABANDON_HASH : m_confirm.hashBlock;
	int serializedIndex =
	isAbandoned() \|\| isConflicted() ? -1 : m_confirm.nIndex;
	s << tx << serializedHash << dummy_vector1 << serializedIndex
	<< dummy_vector2 << mapValueCopy << vOrderForm
	<< fTimeReceivedIsTxTime << nTimeReceived << fFromMe << dummy_bool;
	}

	template <typename Stream> void Unserialize(Stream &s) {
	Init(nullptr);

	//! Used to be vMerkleBranch
	std::vector<uint256> dummy_vector1;
	//! Used to be vtxPrev
	std::vector<CMerkleTx> dummy_vector2;
	//! Used to be fSpent
	bool dummy_bool;
	int serializedIndex;
	s >> tx >> m_confirm.hashBlock >> dummy_vector1 >> serializedIndex >>
	dummy_vector2 >> mapValue >> vOrderForm >> fTimeReceivedIsTxTime >>
	nTimeReceived >> fFromMe >> dummy_bool;

	/*
	* At serialization/deserialization, an nIndex == -1 means that
	* hashBlock refers to the earliest block in the chain we know this or
	* any in-wallet ancestor conflicts with. If nIndex == -1 and hashBlock
	* is ABANDON_HASH, it means transaction is abandoned. In same context,
	* an nIndex >= 0 refers to a confirmed transaction (if hashBlock set)
	* or unconfirmed one. Older clients interpret nIndex == -1 as
	* unconfirmed for backward compatibility (pre-commit 9ac63d6).
	*/
	if (serializedIndex == -1 && m_confirm.hashBlock == ABANDON_HASH) {
	setAbandoned();
	} else if (serializedIndex == -1) {
	setConflicted();
	} else if (!m_confirm.hashBlock.IsNull()) {
	m_confirm.nIndex = serializedIndex;
	setConfirmed();
	}

	ReadOrderPos(nOrderPos, mapValue);
	nTimeSmart = mapValue.count("timesmart")
	? (unsigned int)atoi64(mapValue["timesmart"])
	: 0;

	mapValue.erase("fromaccount");
	mapValue.erase("spent");
	mapValue.erase("n");
	mapValue.erase("timesmart");
	}

	void SetTx(CTransactionRef arg) { tx = std::move(arg); }

	//! make sure balances are recalculated
	void MarkDirty() {
	m_amounts[DEBIT].Reset();
	m_amounts[CREDIT].Reset();
	m_amounts[IMMATURE_CREDIT].Reset();
	m_amounts[AVAILABLE_CREDIT].Reset();
	fChangeCached = false;
	}

	void BindWallet(CWallet *pwalletIn) {
	pwallet = pwalletIn;
	MarkDirty();
	}

	//! filter decides which addresses will count towards the debit
	Amount GetDebit(const isminefilter &filter) const;
	Amount GetCredit(interfaces::Chain::Lock &locked_chain,
	const isminefilter &filter) const;
	Amount GetImmatureCredit(interfaces::Chain::Lock &locked_chain,
	bool fUseCache = true) const;
	// TODO: Remove "NO_THREAD_SAFETY_ANALYSIS" and replace it with the correct
	// annotation "EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)". The
	// annotation "NO_THREAD_SAFETY_ANALYSIS" was temporarily added to avoid
	// having to resolve the issue of member access into incomplete type
	// CWallet.
	Amount GetAvailableCredit(interfaces::Chain::Lock &locked_chain,
	bool fUseCache = true,
	const isminefilter &filter = ISMINE_SPENDABLE)
	const NO_THREAD_SAFETY_ANALYSIS;
	Amount GetImmatureWatchOnlyCredit(interfaces::Chain::Lock &locked_chain,
	const bool fUseCache = true) const;
	Amount GetChange() const;

	// Get the marginal bytes if spending the specified output from this
	// transaction
	int GetSpendSize(unsigned int out, bool use_max_sig = false) const {
	return CalculateMaximumSignedInputSize(tx->vout[out], pwallet,
	use_max_sig);
	}

	void GetAmounts(std::list<COutputEntry> &listReceived,
	std::list<COutputEntry> &listSent, Amount &nFee,
	const isminefilter &filter) const;

	bool IsFromMe(const isminefilter &filter) const {
	return GetDebit(filter) > Amount::zero();
	}

	// True if only scriptSigs are different
	bool IsEquivalentTo(const CWalletTx &tx) const;

	bool InMempool() const;
	bool IsTrusted(interfaces::Chain::Lock &locked_chain) const;

	int64_t GetTxTime() const;

	// Pass this transaction to node for mempool insertion and relay to peers if
	// flag set to true
	bool SubmitMemoryPoolAndRelay(std::string &err_string, bool relay,
	interfaces::Chain::Lock &locked_chain);

	// TODO: Remove "NO_THREAD_SAFETY_ANALYSIS" and replace it with the correct
	// annotation "EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)". The annotation
	// "NO_THREAD_SAFETY_ANALYSIS" was temporarily added to avoid having to
	// resolve the issue of member access into incomplete type CWallet. Note
	// that we still have the runtime check "AssertLockHeld(pwallet->cs_wallet)"
	// in place.
	std::set<TxId> GetConflicts() const NO_THREAD_SAFETY_ANALYSIS;

	/**
	* Return depth of transaction in blockchain:
	* <0 : conflicts with a transaction this deep in the blockchain
	* 0 : in memory pool, waiting to be included in a block
	* >=1 : this many blocks deep in the main chain
	*/
	- int GetDepthInMainChain(interfaces::Chain::Lock &locked_chain) const;
	+ // TODO: Remove "NO_THREAD_SAFETY_ANALYSIS" and replace it with the correct
	+ // annotation "EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)". The annotation
	+ // "NO_THREAD_SAFETY_ANALYSIS" was temporarily added to avoid having to
	+ // resolve the issue of member access into incomplete type CWallet. Note
	+ // that we still have the runtime check "AssertLockHeld(pwallet->cs_wallet)"
	+ // in place.
	+ int GetDepthInMainChain(interfaces::Chain::Lock &locked_chain) const
	+ NO_THREAD_SAFETY_ANALYSIS;
	bool IsInMainChain(interfaces::Chain::Lock &locked_chain) const {
	return GetDepthInMainChain(locked_chain) > 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(interfaces::Chain::Lock &locked_chain) const;
	bool isAbandoned() const {
	return m_confirm.status == CWalletTx::ABANDONED;
	}
	void setAbandoned() {
	m_confirm.status = CWalletTx::ABANDONED;
	m_confirm.hashBlock = BlockHash();
	m_confirm.block_height = 0;
	m_confirm.nIndex = 0;
	}
	bool isConflicted() const {
	return m_confirm.status == CWalletTx::CONFLICTED;
	}
	void setConflicted() { m_confirm.status = CWalletTx::CONFLICTED; }
	bool isUnconfirmed() const {
	return m_confirm.status == CWalletTx::UNCONFIRMED;
	}
	void setUnconfirmed() { m_confirm.status = CWalletTx::UNCONFIRMED; }
	bool isConfirmed() const {
	return m_confirm.status == CWalletTx::CONFIRMED;
	}
	void setConfirmed() { m_confirm.status = CWalletTx::CONFIRMED; }
	TxId GetId() const { return tx->GetId(); }
	bool IsCoinBase() const { return tx->IsCoinBase(); }
	bool IsImmatureCoinBase(interfaces::Chain::Lock &locked_chain) const;
	};

	class COutput {
	public:
	const CWalletTx *tx;
	int i;
	int nDepth;

	/**
	* 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 nInputBytes;

	/** Whether we have the private keys to spend this output */
	bool fSpendable;

	/** Whether we know how to spend this output, ignoring the lack of keys */
	bool fSolvable;

	/**
	* 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;

	/**
	* Whether this output is considered safe to spend. Unconfirmed transactions
	* from outside keys are considered unsafe and will not be used to fund new
	* spending transactions.
	*/
	bool fSafe;

	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;
	// If known and signable by the given wallet, compute nInputBytes
	// Failure will keep this value -1
	if (fSpendable && tx) {
	nInputBytes = tx->GetSpendSize(i, use_max_sig);
	}
	}

	std::string ToString() const;

	inline CInputCoin GetInputCoin() const {
	return CInputCoin(tx->tx, i, nInputBytes);
	}
	};

	struct CoinSelectionParams {
	bool use_bnb = true;
	size_t change_output_size = 0;
	size_t change_spend_size = 0;
	CFeeRate effective_fee = CFeeRate(Amount::zero());
	size_t tx_noinputs_size = 0;

	CoinSelectionParams(bool use_bnb_, size_t change_output_size_,
	size_t change_spend_size_, CFeeRate effective_fee_,
	size_t tx_noinputs_size_)
	: use_bnb(use_bnb_), change_output_size(change_output_size_),
	change_spend_size(change_spend_size_), effective_fee(effective_fee_),
	tx_noinputs_size(tx_noinputs_size_) {}
	CoinSelectionParams() {}
	};

	// forward declarations for ScanForWalletTransactions/RescanFromTime
	class WalletRescanReserver;

	/**
	* A CWallet maintains a set of transactions and balances, and provides the
	* ability to create new transactions.
	*/
	class CWallet final : public WalletStorage,
	public interfaces::Chain::Notifications {
	private:
	CKeyingMaterial vMasterKey GUARDED_BY(cs_KeyStore);

	//! if fUseCrypto is true, mapKeys must be empty
	//! if fUseCrypto is false, vMasterKey must be empty
	std::atomic<bool> fUseCrypto;

	//! keeps track of whether Unlock has run a thorough check before
	bool fDecryptionThoroughlyChecked;

	bool SetCrypted();
	bool Unlock(const CKeyingMaterial &vMasterKeyIn,
	bool accept_no_keys = false);

	std::atomic<bool> fAbortRescan{false};
	// controlled by WalletRescanReserver
	std::atomic<bool> fScanningWallet{false};
	std::atomic<int64_t> m_scanning_start{0};
	std::atomic<double> m_scanning_progress{0};
	std::mutex mutexScanning;
	friend class WalletRescanReserver;

	//! the current wallet version: clients below this version are not able to
	//! load the wallet
	int nWalletVersion GUARDED_BY(cs_wallet) = FEATURE_BASE;

	//! the maximum wallet format version: memory-only variable that specifies
	//! to what version this wallet may be upgraded
	int nWalletMaxVersion GUARDED_BY(cs_wallet) = FEATURE_BASE;

	int64_t nNextResend = 0;
	int64_t nLastResend = 0;
	bool fBroadcastTransactions = false;
	// Local time that the tip block was received. Used to schedule wallet
	// rebroadcasts.
	std::atomic<int64_t> m_best_block_time{0};

	/**
	* Used to keep track of spent outpoints, and detect and report conflicts
	* (double-spends or mutated transactions where the mutant gets mined).
	*/
	typedef std::multimap<COutPoint, TxId> TxSpends;
	TxSpends mapTxSpends GUARDED_BY(cs_wallet);
	void AddToSpends(const COutPoint &outpoint, const TxId &wtxid)
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
	void AddToSpends(const TxId &wtxid) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

	/**
	* 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,
	CWalletTx::Confirmation confirm, bool fUpdate)
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

	/**
	* Mark a transaction (and its in-wallet descendants) as conflicting with a
	* particular block.
	*/
	void MarkConflicted(const BlockHash &hashBlock, int conflicting_height,
	const TxId &txid);

	/**
	* Mark a transaction's inputs dirty, thus forcing the outputs to be
	* recomputed
	*/
	void MarkInputsDirty(const CTransactionRef &tx)
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

	void SyncMetaData(std::pair<TxSpends::iterator, TxSpends::iterator>)
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

	/**
	* Used by
	* TransactionAddedToMemorypool/BlockConnected/Disconnected/ScanForWalletTransactions.
	* Should be called with non-zero block_hash and posInBlock if this is for a
	* transaction that is included in a block.
	*/
	void SyncTransaction(const CTransactionRef &tx,
	CWalletTx::Confirmation confirm, bool update_tx = true)
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

	std::atomic<uint64_t> m_wallet_flags{0};

	bool SetAddressBookWithDB(WalletBatch &batch, const CTxDestination &address,
	const std::string &strName,
	const std::string &strPurpose);

	//! Unsets a wallet flag and saves it to disk
	void UnsetWalletFlagWithDB(WalletBatch &batch, uint64_t flag);

	//! Unset the blank wallet flag and saves it to disk
	void UnsetBlankWalletFlag(WalletBatch &batch) override;

	/** Interface for accessing chain state. */
	interfaces::Chain *m_chain;

	/**
	* Wallet location which includes wallet name (see WalletLocation).
	*/
	WalletLocation m_location;

	/** Internal database handle. */
	std::unique_ptr<WalletDatabase> database;

	/**
	* The following is used to keep track of how far behind the wallet is
	* from the chain sync, and to allow clients to block on us being caught up.
	*
	* Processed hash is a pointer on node's tip and doesn't imply that the
	* wallet has scanned sequentially all blocks up to this one.
	*/
	BlockHash m_last_block_processed GUARDED_BY(cs_wallet);

	/* Height of last block processed is used by wallet to know depth of
	* transactions without relying on Chain interface beyond asynchronous
	* updates. For safety, we initialize it to -1. Height is a pointer on
	* node's tip and doesn't imply that the wallet has scanned sequentially all
	* blocks up to this one.
	*/
	int m_last_block_processed_height GUARDED_BY(cs_wallet) = -1;

	public:
	const CChainParams &chainParams;
	/*
	* Main wallet lock.
	* This lock protects all the fields added by CWallet.
	*/
	mutable RecursiveMutex cs_wallet;

	/**
	* Get database handle used by this wallet. Ideally this function would not
	* be necessary.
	*/
	WalletDatabase &GetDBHandle() { return *database; }
	WalletDatabase &GetDatabase() override { return *database; }

	/**
	* Select a set of coins such that nValueRet >= nTargetValue and at least
	* all coins from coinControl are selected; Never select unconfirmed coins
	* if they are not ours.
	*/
	bool SelectCoins(const std::vector<COutput> &vAvailableCoins,
	const Amount nTargetValue,
	std::set<CInputCoin> &setCoinsRet, Amount &nValueRet,
	const CCoinControl &coin_control,
	CoinSelectionParams &coin_selection_params,
	bool &bnb_used) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

	const WalletLocation &GetLocation() const { return m_location; }

	/**
	* Get a name for this wallet for logging/debugging purposes.
	*/
	const std::string &GetName() const { return m_location.GetName(); }

	typedef std::map<unsigned int, CMasterKey> MasterKeyMap;
	MasterKeyMap mapMasterKeys;
	unsigned int nMasterKeyMaxID = 0;

	/** Construct wallet with specified name and database implementation. */
	CWallet(const CChainParams &chainParamsIn, interfaces::Chain *chain,
	const WalletLocation &location,
	std::unique_ptr<WalletDatabase> databaseIn)
	: fUseCrypto(false), fDecryptionThoroughlyChecked(false),
	m_chain(chain), m_location(location), database(std::move(databaseIn)),
	chainParams(chainParamsIn) {}

	~CWallet() {
	// Should not have slots connected at this point.
	assert(NotifyUnload.empty());
	delete encrypted_batch;
	encrypted_batch = nullptr;
	}

	bool IsCrypted() const { return fUseCrypto; }
	bool IsLocked() const override;
	bool Lock();

	/** Interface to assert chain access and if successful lock it */
	std::unique_ptr<interfaces::Chain::Lock> LockChain() {
	return m_chain ? m_chain->lock() : nullptr;
	}

	std::map<TxId, CWalletTx> mapWallet GUARDED_BY(cs_wallet);

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

	int64_t nOrderPosNext GUARDED_BY(cs_wallet) = 0;
	uint64_t nAccountingEntryNumber = 0;

	std::map<CTxDestination, CAddressBookData>
	mapAddressBook GUARDED_BY(cs_wallet);

	std::set<COutPoint> setLockedCoins GUARDED_BY(cs_wallet);

	/** Registered interfaces::Chain::Notifications handler. */
	std::unique_ptr<interfaces::Handler> m_chain_notifications_handler;

	/** Interface for accessing chain state. */
	interfaces::Chain &chain() const {
	assert(m_chain);
	return *m_chain;
	}

	const CWalletTx *GetWalletTx(const TxId &txid) const;

	//! check whether we are allowed to upgrade (or already support) to the
	//! named feature
	bool CanSupportFeature(enum WalletFeature wf) const override
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
	AssertLockHeld(cs_wallet);
	return nWalletMaxVersion >= wf;
	}

	/**
	* populate vCoins with vector of available COutputs.
	*/
	void AvailableCoins(interfaces::Chain::Lock &locked_chain,
	std::vector<COutput> &vCoins, bool fOnlySafe = true,
	const CCoinControl *coinControl = nullptr,
	const Amount nMinimumAmount = SATOSHI,
	const Amount nMaximumAmount = MAX_MONEY,
	const Amount nMinimumSumAmount = MAX_MONEY,
	const uint64_t nMaximumCount = 0) const
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

	/**
	* Return list of available coins and locked coins grouped by non-change
	* output address.
	*/
	std::map<CTxDestination, std::vector<COutput>>
	ListCoins(interfaces::Chain::Lock &locked_chain) const
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

	/**
	* Find non-change parent output.
	*/
	const CTxOut &FindNonChangeParentOutput(const CTransaction &tx,
	int output) const
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

	/**
	* Shuffle and select coins until nTargetValue is reached while avoiding
	* small change; This method is stochastic for some inputs and upon
	* completion the coin set and corresponding actual target value is
	* assembled.
	*/
	bool SelectCoinsMinConf(const Amount nTargetValue,
	const CoinEligibilityFilter &eligibility_filter,
	std::vector<OutputGroup> groups,
	std::set<CInputCoin> &setCoinsRet,
	Amount &nValueRet,
	const CoinSelectionParams &coin_selection_params,
	bool &bnb_used) const;

	bool IsSpent(interfaces::Chain::Lock &locked_chain,
	const COutPoint &outpoint) const
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

	// Whether this or any UTXO with the same CTxDestination has been spent.
	bool IsUsedDestination(const CTxDestination &dst) const;
	bool IsUsedDestination(const TxId &txid, unsigned int n) const;
	void SetUsedDestinationState(const TxId &hash, unsigned int n, bool used);

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

	bool IsLockedCoin(const COutPoint &outpoint) const
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
	void LockCoin(const COutPoint &output) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
	void UnlockCoin(const COutPoint &output)
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
	void UnlockAllCoins() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
	void ListLockedCoins(std::vector<COutPoint> &vOutpts) const
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

	/*
	* Rescan abort properties
	*/
	void AbortRescan() { fAbortRescan = true; }
	bool IsAbortingRescan() { return fAbortRescan; }
	bool IsScanning() { return fScanningWallet; }
	int64_t ScanningDuration() const {
	return fScanningWallet ? GetTimeMillis() - m_scanning_start : 0;
	}
	double ScanningProgress() const {
	return fScanningWallet ? double(m_scanning_progress) : 0;
	}

	//! Upgrade stored CKeyMetadata objects to store key origin info as
	//! KeyOriginInfo
	void UpgradeKeyMetadata() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

	bool LoadMinVersion(int nVersion) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
	AssertLockHeld(cs_wallet);
	nWalletVersion = nVersion;
	nWalletMaxVersion = std::max(nWalletMaxVersion, nVersion);
	return true;
	}

	//! Adds a destination data tuple to the store, and saves it to disk
	bool AddDestData(const CTxDestination &dest, const std::string &key,
	const std::string &value)
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
	//! Erases a destination data tuple in the store and on disk
	bool EraseDestData(const CTxDestination &dest, const std::string &key)
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
	//! Adds a destination data tuple to the store, without saving it to disk
	void LoadDestData(const CTxDestination &dest, const std::string &key,
	const std::string &value)
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
	//! Look up a destination data tuple in the store, return true if found
	//! false otherwise
	bool GetDestData(const CTxDestination &dest, const std::string &key,
	std::string *value) const
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
	//! Get all destination values matching a prefix.
	std::vector<std::string> GetDestValues(const std::string &prefix) const
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

	//! Holds a timestamp at which point the wallet is scheduled (externally) to
	//! be relocked. Caller must arrange for actual relocking to occur via
	//! Lock().
	int64_t nRelockTime = 0;

	bool Unlock(const SecureString &strWalletPassphrase,
	bool accept_no_keys = false);
	bool ChangeWalletPassphrase(const SecureString &strOldWalletPassphrase,
	const SecureString &strNewWalletPassphrase);
	bool EncryptWallet(const SecureString &strWalletPassphrase);

	void GetKeyBirthTimes(interfaces::Chain::Lock &locked_chain,
	std::map<CKeyID, int64_t> &mapKeyBirth) const
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
	unsigned int ComputeTimeSmart(const CWalletTx &wtx) const;

	/**
	* Increment the next transaction order id
	* @return next transaction order id
	*/
	int64_t IncOrderPosNext(WalletBatch *batch = nullptr)
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
	DBErrors ReorderTransactions();

	void MarkDirty();
	bool AddToWallet(const CWalletTx &wtxIn, bool fFlushOnClose = true);
	void LoadToWallet(CWalletTx &wtxIn) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
	void TransactionAddedToMempool(const CTransactionRef &tx) override;
	void BlockConnected(const CBlock &block,
	const std::vector<CTransactionRef> &vtxConflicted,
	int height) override;
	void BlockDisconnected(const CBlock &block, int height) override;
	void UpdatedBlockTip() override;
	int64_t RescanFromTime(int64_t startTime,
	const WalletRescanReserver &reserver, bool update);

	struct ScanResult {
	enum { SUCCESS, FAILURE, USER_ABORT } status = SUCCESS;

	//! Hash and height of most recent block that was successfully scanned.
	//! Unset if no blocks were scanned due to read errors or the chain
	//! being empty.
	BlockHash last_scanned_block;
	Optional<int> last_scanned_height;

	//! Hash of the most recent block that could not be scanned due to
	//! read errors or pruning. Will be set if status is FAILURE, unset if
	//! status is SUCCESS, and may or may not be set if status is
	//! USER_ABORT.
	BlockHash last_failed_block;
	};
	ScanResult ScanForWalletTransactions(const BlockHash &first_block,
	const BlockHash &last_block,
	const WalletRescanReserver &reserver,
	bool fUpdate);
	void TransactionRemovedFromMempool(const CTransactionRef &ptx) override;
	void ReacceptWalletTransactions(interfaces::Chain::Lock &locked_chain)
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
	void ResendWalletTransactions();
	struct Balance {
	//! Trusted, at depth=GetBalance.min_depth or more
	Amount m_mine_trusted{Amount::zero()};
	//! Untrusted, but in mempool (pending)
	Amount m_mine_untrusted_pending{Amount::zero()};
	//! Immature coinbases in the main chain
	Amount m_mine_immature{Amount::zero()};
	Amount m_watchonly_trusted{Amount::zero()};
	Amount m_watchonly_untrusted_pending{Amount::zero()};
	Amount m_watchonly_immature{Amount::zero()};
	};
	Balance GetBalance(int min_depth = 0, bool avoid_reuse = true) const;
	Amount GetAvailableBalance(const CCoinControl *coinControl = nullptr) const;

	OutputType TransactionChangeType(OutputType change_type,
	const std::vector<CRecipient> &vecSend);

	/**
	* Insert additional inputs into the transaction by calling
	* CreateTransaction();
	*/
	bool FundTransaction(CMutableTransaction &tx, Amount &nFeeRet,
	int &nChangePosInOut, std::string &strFailReason,
	bool lockUnspents,
	const std::set<int> &setSubtractFeeFromOutputs,
	CCoinControl coinControl);
	bool SignTransaction(CMutableTransaction &tx)
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

	/**
	* Create a new transaction paying the recipients with a set of coins
	* selected by SelectCoins(); Also create the change output, when needed
	* @note passing nChangePosInOut as -1 will result in setting a random
	* position
	*/
	bool CreateTransaction(interfaces::Chain::Lock &locked_chain,
	const std::vector<CRecipient> &vecSend,
	CTransactionRef &tx, Amount &nFeeRet,
	int &nChangePosInOut, std::string &strFailReason,
	const CCoinControl &coin_control, bool sign = true);
	/**
	* Submit the transaction to the node's mempool and then relay to peers.
	* Should be called after CreateTransaction unless you want to abort
	* broadcasting the transaction.
	*
	* @param tx[in] The transaction to be broadcast.
	* @param mapValue[in] key-values to be set on the transaction.
	* @param orderForm[in] BIP 70 / BIP 21 order form details to be set on the
	* transaction.
	*/
	void CommitTransaction(
	CTransactionRef tx, mapValue_t mapValue,
	std::vector<std::pair<std::string, std::string>> orderForm);

	bool DummySignTx(CMutableTransaction &txNew, const std::set<CTxOut> &txouts,
	bool use_max_sig = false) const {
	std::vector<CTxOut> v_txouts(txouts.size());
	std::copy(txouts.begin(), txouts.end(), v_txouts.begin());
	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 ImportScripts(const std::set<CScript> scripts, int64_t timestamp)
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
	bool ImportPrivKeys(const std::map<CKeyID, CKey> &privkey_map,
	const int64_t timestamp)
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
	bool ImportPubKeys(
	const std::vector<CKeyID> &ordered_pubkeys,
	const std::map<CKeyID, CPubKey> &pubkey_map,
	const std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>> &key_origins,
	const bool add_keypool, const bool internal, const int64_t timestamp)
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
	bool ImportScriptPubKeys(const std::string &label,
	const std::set<CScript> &script_pub_keys,
	const bool have_solving_data,
	const bool apply_label, const int64_t timestamp)
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

	CFeeRate m_pay_tx_fee{DEFAULT_PAY_TX_FEE};
	bool m_spend_zero_conf_change{DEFAULT_SPEND_ZEROCONF_CHANGE};
	//! will be false if -fallbackfee=0
	bool m_allow_fallback_fee{true};
	// Override with -mintxfee
	CFeeRate m_min_fee{DEFAULT_TRANSACTION_MINFEE_PER_KB};
	/**
	* If fee estimation does not have enough data to provide estimates, use
	* this fee instead. Has no effect if not using fee estimation Override with
	* -fallbackfee
	*/
	CFeeRate m_fallback_fee{DEFAULT_FALLBACK_FEE};
	OutputType m_default_address_type{DEFAULT_ADDRESS_TYPE};
	OutputType m_default_change_type{DEFAULT_CHANGE_TYPE};
	/**
	* Absolute maximum transaction fee (in satoshis) used by default for the
	* wallet.
	*/
	Amount m_default_max_tx_fee{DEFAULT_TRANSACTION_MAXFEE};

	size_t KeypoolCountExternalKeys() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
	bool TopUpKeyPool(unsigned int kpSize = 0);

	int64_t GetOldestKeyPoolTime();

	std::set<std::set<CTxDestination>> GetAddressGroupings()
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
	std::map<CTxDestination, Amount>
	GetAddressBalances(interfaces::Chain::Lock &locked_chain);

	std::set<CTxDestination> GetLabelAddresses(const std::string &label) const;

	bool GetNewDestination(const OutputType type, const std::string label,
	CTxDestination &dest, std::string &error);
	bool GetNewChangeDestination(const OutputType type, CTxDestination &dest,
	std::string &error);

	isminetype IsMine(const CTxDestination &dest) const;
	isminetype IsMine(const CScript &script) const;
	isminetype IsMine(const CTxIn &txin) const;
	/**
	* Returns amount of debit if the input matches the filter, otherwise
	* returns 0
	*/
	Amount GetDebit(const CTxIn &txin, const isminefilter &filter) const;
	isminetype IsMine(const CTxOut &txout) const;
	Amount GetCredit(const CTxOut &txout, const isminefilter &filter) const;
	bool IsChange(const CTxOut &txout) const;
	bool IsChange(const CScript &script) const;
	Amount GetChange(const CTxOut &txout) const;
	bool IsMine(const CTransaction &tx) const;
	/** should probably be renamed to IsRelevantToMe */
	bool IsFromMe(const CTransaction &tx) const;
	Amount GetDebit(const CTransaction &tx, const isminefilter &filter) const;
	/** Returns whether all of the inputs match the filter */
	bool IsAllFromMe(const CTransaction &tx, const isminefilter &filter) const;
	Amount GetCredit(const CTransaction &tx, const isminefilter &filter) const;
	Amount GetChange(const CTransaction &tx) const;
	void ChainStateFlushed(const CBlockLocator &loc) override;

	DBErrors LoadWallet(bool &fFirstRunRet);
	DBErrors ZapWalletTx(std::vector<CWalletTx> &vWtx);
	DBErrors ZapSelectTx(std::vector<TxId> &txIdsIn,
	std::vector<TxId> &txIdsOut)
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

	bool SetAddressBook(const CTxDestination &address,
	const std::string &strName, const std::string &purpose);

	bool DelAddressBook(const CTxDestination &address);

	unsigned int GetKeyPoolSize() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

	//! signify that a particular wallet feature is now used. this may change
	//! nWalletVersion and nWalletMaxVersion if those are lower
	void SetMinVersion(enum WalletFeature, WalletBatch *batch_in = nullptr,
	bool fExplicit = false) override;

	//! change which version we're allowed to upgrade to (note that this does
	//! not immediately imply upgrading to that format)
	bool SetMaxVersion(int nVersion);

	//! get the current wallet format (the oldest client version guaranteed to
	//! understand this wallet)
	int GetVersion() {
	LOCK(cs_wallet);
	return nWalletVersion;
	}

	//! Get wallet transactions that conflict with given transaction (spend same
	//! outputs)
	std::set<TxId> GetConflicts(const TxId &txid) const
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

	//! Check if a given transaction has any of its outputs spent by another
	//! transaction in the wallet
	bool HasWalletSpend(const TxId &txid) const
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

	//! Flush wallet (bitdb flush)
	void Flush(bool shutdown = false);

	/** Wallet is about to be unloaded */
	boost::signals2::signal<void()> NotifyUnload;

	/**
	* Address book entry changed.
	* @note called with lock cs_wallet held.
	*/
	boost::signals2::signal<void(CWallet *wallet, const CTxDestination &address,
	const std::string &label, bool isMine,
	const std::string &purpose, ChangeType status)>
	NotifyAddressBookChanged;

	/**
	* Wallet transaction added, removed or updated.
	* @note called with lock cs_wallet held.
	*/
	boost::signals2::signal<void(CWallet *wallet, const TxId &txid,
	ChangeType status)>
	NotifyTransactionChanged;

	/** Show progress e.g. for rescan */
	boost::signals2::signal<void(const std::string &title, int nProgress)>
	ShowProgress;

	/** Watch-only address added */
	boost::signals2::signal<void(bool fHaveWatchOnly)> NotifyWatchonlyChanged;

	/** Keypool has new keys */
	boost::signals2::signal<void()> NotifyCanGetAddressesChanged;

	/**
	* Wallet status (encrypted, locked) changed.
	* Note: Called without locks held.
	*/
	boost::signals2::signal<void(CWallet *wallet)> NotifyStatusChanged;

	/** Inquire whether this wallet broadcasts transactions. */
	bool GetBroadcastTransactions() const { return fBroadcastTransactions; }
	/** Set whether this wallet broadcasts transactions. */
	void SetBroadcastTransactions(bool broadcast) {
	fBroadcastTransactions = broadcast;
	}

	/** Return whether transaction can be abandoned */
	bool TransactionCanBeAbandoned(const TxId &txid) const;

	/**
	* Mark a transaction (and it in-wallet descendants) as abandoned so its
	* inputs may be respent.
	*/
	bool AbandonTransaction(interfaces::Chain::Lock &locked_chain,
	const TxId &txid);

	//! Verify wallet naming and perform salvage on the wallet if required
	static bool Verify(const CChainParams &chainParams,
	interfaces::Chain &chain, const WalletLocation &location,
	bool salvage_wallet, std::string &error_string,
	std::vector<std::string> &warnings);

	/**
	* Initializes the wallet, returns a new CWallet instance or a null pointer
	* in case of an error.
	*/
	static std::shared_ptr<CWallet> CreateWalletFromFile(
	const CChainParams &chainParams, interfaces::Chain &chain,
	const WalletLocation &location, std::string &error,
	std::vector<std::string> &warnings, uint64_t wallet_creation_flags = 0);

	/**
	* Wallet post-init setup
	* Gives the wallet a chance to register repetitive tasks and complete
	* post-init tasks
	*/
	void postInitProcess();

	bool BackupWallet(const std::string &strDest);

	/* Returns true if HD is enabled */
	bool IsHDEnabled() const;

	/**
	* Returns true if the wallet can give out new addresses. This means it has
	* keys in the keypool or can generate new keys.
	*/
	bool CanGetAddresses(bool internal = false);

	/**
	* Blocks until the wallet state is up-to-date to /at least/ the current
	* chain at the time this function is entered.
	* Obviously holding cs_main/cs_wallet when going into this call may cause
	* deadlock
	*/
	void BlockUntilSyncedToCurrentChain() LOCKS_EXCLUDED(cs_main, cs_wallet);

	/**
	* Set a single wallet flag.
	*/
	void SetWalletFlag(uint64_t flags);

	/**
	* Unsets a single wallet flag.
	*/
	void UnsetWalletFlag(uint64_t flag);

	/**
	* Check if a certain wallet flag is set.
	*/
	bool IsWalletFlagSet(uint64_t flag) const override;

	/**
	* 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 override {
	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...);
	};

	template <typename... Params>
	void WalletLogPrintfToBeContinued(std::string fmt,
	Params... parameters) const {
	LogPrintfToBeContinued(("%s " + fmt).c_str(), GetDisplayName(),
	parameters...);
	};

	ScriptPubKeyMan *GetScriptPubKeyMan() const;
	const SigningProvider *GetSigningProvider() const;
	LegacyScriptPubKeyMan *GetLegacyScriptPubKeyMan() const;

	// Temporary LegacyScriptPubKeyMan accessors and aliases.
	friend class LegacyScriptPubKeyMan;
	std::unique_ptr<LegacyScriptPubKeyMan> m_spk_man =
	std::make_unique<LegacyScriptPubKeyMan>(*this);
	RecursiveMutex &cs_KeyStore = m_spk_man->cs_KeyStore;
	LegacyScriptPubKeyMan::KeyMap &
	mapKeys GUARDED_BY(cs_KeyStore) = m_spk_man->mapKeys;
	LegacyScriptPubKeyMan::ScriptMap &
	mapScripts GUARDED_BY(cs_KeyStore) = m_spk_man->mapScripts;
	LegacyScriptPubKeyMan::CryptedKeyMap &
	mapCryptedKeys GUARDED_BY(cs_KeyStore) = m_spk_man->mapCryptedKeys;
	LegacyScriptPubKeyMan::WatchOnlySet &
	setWatchOnly GUARDED_BY(cs_KeyStore) = m_spk_man->setWatchOnly;
	LegacyScriptPubKeyMan::WatchKeyMap &
	mapWatchKeys GUARDED_BY(cs_KeyStore) = m_spk_man->mapWatchKeys;
	WalletBatch *&
	encrypted_batch GUARDED_BY(cs_wallet) = m_spk_man->encrypted_batch;
	using CryptedKeyMap = LegacyScriptPubKeyMan::CryptedKeyMap;

	/** Get last block processed height */
	int GetLastBlockHeight() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
	AssertLockHeld(cs_wallet);
	assert(m_last_block_processed_height >= 0);
	return m_last_block_processed_height;
	};
	/** Set last block processed height, currently only use in unit test */
	void SetLastBlockProcessed(int block_height, BlockHash block_hash)
	EXCLUSIVE_LOCKS_REQUIRED(cs_wallet) {
	AssertLockHeld(cs_wallet);
	m_last_block_processed_height = block_height;
	m_last_block_processed = block_hash;
	};
	};

	/**
	* Called periodically by the schedule thread. Prompts individual wallets to
	* resend their transactions. Actual rebroadcast schedule is managed by the
	* wallets themselves.
	*/
	void MaybeResendWalletTxs();

	/** RAII object to check and reserve a wallet rescan */
	class WalletRescanReserver {
	private:
	CWallet *m_wallet;
	bool m_could_reserve;

	public:
	explicit WalletRescanReserver(CWallet *w)
	: m_wallet(w), m_could_reserve(false) {}

	bool reserve() {
	assert(!m_could_reserve);
	std::lock_guard<std::mutex> lock(m_wallet->mutexScanning);
	if (m_wallet->fScanningWallet) {
	return false;
	}
	m_wallet->m_scanning_start = GetTimeMillis();
	m_wallet->m_scanning_progress = 0;
	m_wallet->fScanningWallet = true;
	m_could_reserve = true;
	return true;
	}

	bool isReserved() const {
	return (m_could_reserve && m_wallet->fScanningWallet);
	}

	~WalletRescanReserver() {
	std::lock_guard<std::mutex> lock(m_wallet->mutexScanning);
	if (m_could_reserve) {
	m_wallet->fScanningWallet = false;
	}
	}
	};

	// Calculate the size of the transaction assuming all signatures are max size
	// Use DummySignatureCreator, which inserts 71 byte signatures everywhere.
	// NOTE: this requires that all inputs must be in mapWallet (eg the tx should
	// be IsAllFromMe).
	int64_t CalculateMaximumSignedTxSize(const CTransaction &tx,
	const CWallet *wallet,
	bool use_max_sig = false)
	EXCLUSIVE_LOCKS_REQUIRED(wallet->cs_wallet);
	int64_t CalculateMaximumSignedTxSize(const CTransaction &tx,
	const CWallet *wallet,
	const std::vector<CTxOut> &txouts,
	bool use_max_sig = false);

	#endif // BITCOIN_WALLET_WALLET_H

File Metadata

Mime Type: text/x-diff
Expires: Sun, Mar 2, 11:43 (1 d, 6 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 5187677
Default Alt Text: (221 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions