// Copyright (c) 2009-2010 Satoshi Nakamoto

// Copyright (c) 2009-2016 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 "base58.h"

#include "checkpoints.h"

#include "chain.h"

#include "wallet/coincontrol.h"

#include "consensus/consensus.h"

#include "consensus/validation.h"

#include "fs.h"

#include "key.h"

#include "keystore.h"

#include "validation.h"

#include "net.h"

#include "policy/fees.h"

#include "policy/policy.h"

#include "policy/rbf.h"

#include "primitives/block.h"

#include "primitives/transaction.h"

#include "script/script.h"

#include "script/sign.h"

#include "scheduler.h"

#include "timedata.h"

#include "txmempool.h"

#include "util.h"

#include "ui_interface.h"

#include "utilmoneystr.h"

#include <assert.h>

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

#include <boost/thread.hpp>

std::vector<CWalletRef> vpwallets;

/** Transaction fee set by the user */

CFeeRate payTxFee(DEFAULT_TRANSACTION_FEE);

unsigned int nTxConfirmTarget = DEFAULT_TX_CONFIRM_TARGET;

bool bSpendZeroConfChange = DEFAULT_SPEND_ZEROCONF_CHANGE;

bool fWalletRbf = DEFAULT_WALLET_RBF;

const char * DEFAULT_WALLET_DAT = "wallet.dat";

const uint32_t BIP32_HARDENED_KEY_LIMIT = 0x80000000;

/**

* Fees smaller than this (in satoshi) are considered zero fee (for transaction creation)

* Override with -mintxfee

*/

CFeeRate CWallet::minTxFee = CFeeRate(DEFAULT_TRANSACTION_MINFEE);

/**

* 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 CWallet::fallbackFee = CFeeRate(DEFAULT_FALLBACK_FEE);

CFeeRate CWallet::m_discard_rate = CFeeRate(DEFAULT_DISCARD_FEE);

const uint256 CMerkleTx::ABANDON_HASH(uint256S("0000000000000000000000000000000000000000000000000000000000000001"));

/** @defgroup mapWallet

*

* @{

*/

struct CompareValueOnly

{

bool operator()(const CInputCoin& t1,

const CInputCoin& t2) const

{

return t1.txout.nValue < t2.txout.nValue;

}

};

std::string COutput::ToString() const

{

return strprintf("COutput(%s, %d, %d) [%s]", tx->GetHash().ToString(), i, nDepth, FormatMoney(tx->tx->vout[i].nValue));

}

const CWalletTx* CWallet::GetWalletTx(const uint256& hash) const

{

LOCK(cs_wallet);

std::map<uint256, CWalletTx>::const_iterator it = mapWallet.find(hash);

if (it == mapWallet.end())

return NULL;

return &(it->second);

}

CPubKey CWallet::GenerateNewKey(CWalletDB &walletdb, bool internal)

{

AssertLockHeld(cs_wallet); // mapKeyMetadata

bool fCompressed = CanSupportFeature(FEATURE_COMPRPUBKEY); // default to compressed public keys if we want 0.6.0 wallets

CKey secret;

// Create new metadata

int64_t nCreationTime = GetTime();

CKeyMetadata metadata(nCreationTime);

// use HD key derivation if HD was enabled during wallet creation

if (0 && IsHDEnabled()) {

DeriveNewChildKey(walletdb, metadata, secret, (CanSupportFeature(FEATURE_HD_SPLIT) ? internal : false));

} else {

secret.MakeNewKey(fCompressed);

}

// Compressed public keys were introduced in version 0.6.0

if (fCompressed) {

SetMinVersion(FEATURE_COMPRPUBKEY);

}

CPubKey pubkey = secret.GetPubKey();

assert(secret.VerifyPubKey(pubkey));

mapKeyMetadata[pubkey.GetID()] = metadata;

UpdateTimeFirstKey(nCreationTime);

if (!AddKeyPubKeyWithDB(walletdb, secret, pubkey)) {

throw std::runtime_error(std::string(__func__) + ": AddKey failed");

}

return pubkey;

}

void CWallet::DeriveNewChildKey(CWalletDB &walletdb, CKeyMetadata& metadata, CKey& secret, bool internal)

{

// for now we use a fixed keypath scheme of m/0'/0'/k

CKey key; //master key seed (256bit)

CExtKey masterKey; //hd master key

CExtKey accountKey; //key at m/0'

CExtKey chainChildKey; //key at m/0'/0' (external) or m/0'/1' (internal)

CExtKey childKey; //key at m/0'/0'/<n>'

// try to get the master key

if (!GetKey(hdChain.masterKeyID, key))

throw std::runtime_error(std::string(__func__) + ": Master key not found");

masterKey.SetMaster(key.begin(), key.size());

// derive m/0'

// use hardened derivation (child keys >= 0x80000000 are hardened after bip32)

masterKey.Derive(accountKey, BIP32_HARDENED_KEY_LIMIT);

// derive m/0'/0' (external chain) OR m/0'/1' (internal chain)

assert(internal ? CanSupportFeature(FEATURE_HD_SPLIT) : true);

accountKey.Derive(chainChildKey, BIP32_HARDENED_KEY_LIMIT+(internal ? 1 : 0));

// derive child key at next index, skip keys already known to the wallet

do {

// always derive hardened keys

// childIndex | BIP32_HARDENED_KEY_LIMIT = derive childIndex in hardened child-index-range

// example: 1 | BIP32_HARDENED_KEY_LIMIT == 0x80000001 == 2147483649

if (internal) {

chainChildKey.Derive(childKey, hdChain.nInternalChainCounter | BIP32_HARDENED_KEY_LIMIT);

metadata.hdKeypath = "m/0'/1'/" + std::to_string(hdChain.nInternalChainCounter) + "'";

hdChain.nInternalChainCounter++;

}

else {

chainChildKey.Derive(childKey, hdChain.nExternalChainCounter | BIP32_HARDENED_KEY_LIMIT);

metadata.hdKeypath = "m/0'/0'/" + std::to_string(hdChain.nExternalChainCounter) + "'";

hdChain.nExternalChainCounter++;

}

} while (HaveKey(childKey.key.GetPubKey().GetID()));

secret = childKey.key;

metadata.hdMasterKeyID = hdChain.masterKeyID;

// update the chain model in the database

if (!walletdb.WriteHDChain(hdChain))

throw std::runtime_error(std::string(__func__) + ": Writing HD chain model failed");

}

bool CWallet::AddKeyPubKeyWithDB(CWalletDB &walletdb, const CKey& secret, const CPubKey &pubkey)

{

AssertLockHeld(cs_wallet); // mapKeyMetadata

// CCryptoKeyStore has no concept of wallet databases, but calls AddCryptedKey

// which is overridden below. To avoid flushes, the database handle is

// tunneled through to it.

bool needsDB = !pwalletdbEncryption;

if (needsDB) {

pwalletdbEncryption = &walletdb;

}

if (!CCryptoKeyStore::AddKeyPubKey(secret, pubkey)) {

if (needsDB) pwalletdbEncryption = NULL;

return false;

}

if (needsDB) pwalletdbEncryption = NULL;

// check if we need to remove from watch-only

CScript script;

script = GetScriptForDestination(pubkey.GetID());

if (HaveWatchOnly(script)) {

RemoveWatchOnly(script);

}

script = GetScriptForRawPubKey(pubkey);

if (HaveWatchOnly(script)) {

RemoveWatchOnly(script);

}

if (!IsCrypted()) {

return walletdb.WriteKey(pubkey,

secret.GetPrivKey(),

mapKeyMetadata[pubkey.GetID()]);

}

return true;

}

bool CWallet::AddKeyPubKey(const CKey& secret, const CPubKey &pubkey)

{

CWalletDB walletdb(*dbw);

return CWallet::AddKeyPubKeyWithDB(walletdb, secret, pubkey);

}

bool CWallet::AddCryptedKey(const CPubKey &vchPubKey,

const std::vector<unsigned char> &vchCryptedSecret)

{

if (!CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret))

return false;

{

LOCK(cs_wallet);

if (pwalletdbEncryption)

return pwalletdbEncryption->WriteCryptedKey(vchPubKey,

vchCryptedSecret,

mapKeyMetadata[vchPubKey.GetID()]);

else

return CWalletDB(*dbw).WriteCryptedKey(vchPubKey,

vchCryptedSecret,

mapKeyMetadata[vchPubKey.GetID()]);

}

}

bool CWallet::LoadKeyMetadata(const CTxDestination& keyID, const CKeyMetadata &meta)

{

AssertLockHeld(cs_wallet); // mapKeyMetadata

UpdateTimeFirstKey(meta.nCreateTime);

mapKeyMetadata[keyID] = meta;

return true;

}

bool CWallet::LoadCryptedKey(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret)

{

return CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret);

}

/**

* Update wallet first key creation time. This should be called whenever keys

* are added to the wallet, with the oldest key creation time.

*/

void CWallet::UpdateTimeFirstKey(int64_t nCreateTime)

{

AssertLockHeld(cs_wallet);

if (nCreateTime <= 1) {

// Cannot determine birthday information, so set the wallet birthday to

// the beginning of time.

nTimeFirstKey = 1;

} else if (!nTimeFirstKey || nCreateTime < nTimeFirstKey) {

nTimeFirstKey = nCreateTime;

}

}

bool CWallet::AddCScript(const CScript& redeemScript)

{

if (!CCryptoKeyStore::AddCScript(redeemScript))

return false;

return CWalletDB(*dbw).WriteCScript(Hash160(redeemScript), redeemScript);

}

bool CWallet::LoadCScript(const CScript& redeemScript)

{

/* A sanity check was added in pull #3843 to avoid adding redeemScripts

* that never can be redeemed. However, old wallets may still contain

* these. Do not add them to the wallet and warn. */

if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE)

{

std::string strAddr = CBitcoinAddress(CScriptID(redeemScript)).ToString();

LogPrintf("%s: Warning: This wallet contains a redeemScript of size %i which exceeds maximum size %i thus can never be redeemed. Do not use address %s.\n",

__func__, redeemScript.size(), MAX_SCRIPT_ELEMENT_SIZE, strAddr);

return true;

}

return CCryptoKeyStore::AddCScript(redeemScript);

}

bool CWallet::AddWatchOnly(const CScript& dest)

{

if (!CCryptoKeyStore::AddWatchOnly(dest))

return false;

const CKeyMetadata& meta = mapKeyMetadata[CScriptID(dest)];

UpdateTimeFirstKey(meta.nCreateTime);

NotifyWatchonlyChanged(true);

return CWalletDB(*dbw).WriteWatchOnly(dest, meta);

}

bool CWallet::AddWatchOnly(const CScript& dest, int64_t nCreateTime)

{

mapKeyMetadata[CScriptID(dest)].nCreateTime = nCreateTime;

return AddWatchOnly(dest);

}

bool CWallet::RemoveWatchOnly(const CScript &dest)

{

AssertLockHeld(cs_wallet);

if (!CCryptoKeyStore::RemoveWatchOnly(dest))

return false;

if (!HaveWatchOnly())

NotifyWatchonlyChanged(false);

if (!CWalletDB(*dbw).EraseWatchOnly(dest))

return false;

return true;

}

bool CWallet::LoadWatchOnly(const CScript &dest)

{

return CCryptoKeyStore::AddWatchOnly(dest);

}

bool CWallet::Unlock(const SecureString& strWalletPassphrase)

{

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

continue; // try another master key

if (CCryptoKeyStore::Unlock(_vMasterKey))

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 (CCryptoKeyStore::Unlock(_vMasterKey))

{

int64_t nStartTime = GetTimeMillis();

crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);

pMasterKey.second.nDeriveIterations = 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 + pMasterKey.second.nDeriveIterations * 100 / ((double)(GetTimeMillis() - nStartTime))) / 2;

if (pMasterKey.second.nDeriveIterations < 25000)

pMasterKey.second.nDeriveIterations = 25000;

LogPrintf("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;

CWalletDB(*dbw).WriteMasterKey(pMasterKey.first, pMasterKey.second);

if (fWasLocked)

Lock();

return true;

}

}

}

return false;

}

void CWallet::SetBestChain(const CBlockLocator& loc)

{

CWalletDB walletdb(*dbw);

walletdb.WriteBestBlock(loc);

}

bool CWallet::SetMinVersion(enum WalletFeature nVersion, CWalletDB* pwalletdbIn, bool fExplicit)

{

LOCK(cs_wallet); // nWalletVersion

if (nWalletVersion >= nVersion)

return true;

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

{

CWalletDB* pwalletdb = pwalletdbIn ? pwalletdbIn : new CWalletDB(*dbw);

if (nWalletVersion > 40000)

pwalletdb->WriteMinVersion(nWalletVersion);

if (!pwalletdbIn)

delete pwalletdb;

}

return true;

}

bool CWallet::SetMaxVersion(int nVersion)

{

LOCK(cs_wallet); // nWalletVersion, nWalletMaxVersion

// cannot downgrade below current version

if (nWalletVersion > nVersion)

return false;

nWalletMaxVersion = nVersion;

return true;

}

std::set<uint256> CWallet::GetConflicts(const uint256& txid) const

{

std::set<uint256> result;

AssertLockHeld(cs_wallet);

std::map<uint256, 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)

continue; // No conflict if zero or one spends

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 uint256& txid) const

{

AssertLockHeld(cs_wallet);

auto iter = mapTxSpends.lower_bound(COutPoint(txid, 0));

return (iter != mapTxSpends.end() && iter->first.hash == txid);

}

void CWallet::Flush(bool shutdown)

{

dbw->Flush(shutdown);

}

bool CWallet::Verify()

{

if (GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET))

return true;

uiInterface.InitMessage(_("Verifying wallet(s)..."));

// Keep track of each wallet absolute path to detect duplicates.

std::set<fs::path> wallet_paths;

for (const std::string& walletFile : gArgs.GetArgs("-wallet")) {

if (boost::filesystem::path(walletFile).filename() != walletFile) {

return InitError(strprintf(_("Error loading wallet %s. -wallet parameter must only specify a filename (not a path)."), walletFile));

}

if (SanitizeString(walletFile, SAFE_CHARS_FILENAME) != walletFile) {

return InitError(strprintf(_("Error loading wallet %s. Invalid characters in -wallet filename."), walletFile));

}

fs::path wallet_path = fs::absolute(walletFile, GetDataDir());

if (fs::exists(wallet_path) && (!fs::is_regular_file(wallet_path) || fs::is_symlink(wallet_path))) {

return InitError(strprintf(_("Error loading wallet %s. -wallet filename must be a regular file."), walletFile));

}

if (!wallet_paths.insert(wallet_path).second) {

return InitError(strprintf(_("Error loading wallet %s. Duplicate -wallet filename specified."), walletFile));

}

std::string strError;

if (!CWalletDB::VerifyEnvironment(walletFile, GetDataDir().string(), strError)) {

return InitError(strError);

}

if (GetBoolArg("-salvagewallet", false)) {

// Recover readable keypairs:

CWallet dummyWallet;

std::string backup_filename;

if (!CWalletDB::Recover(walletFile, (void *)&dummyWallet, CWalletDB::RecoverKeysOnlyFilter, backup_filename)) {

return false;

}

}

std::string strWarning;

bool dbV = CWalletDB::VerifyDatabaseFile(walletFile, GetDataDir().string(), strWarning, strError);

if (!strWarning.empty()) {

InitWarning(strWarning);

}

if (!dbV) {

InitError(strError);

return false;

}

}

return true;

}

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 = NULL;

for (TxSpends::iterator it = range.first; it != range.second; ++it)

{

const uint256& hash = it->second;

int n = mapWallet[hash].nOrderPos;

if (n < nMinOrderPos)

{

nMinOrderPos = n;

copyFrom = &mapWallet[hash];

}

}

// Now copy data from copyFrom to rest:

for (TxSpends::iterator it = range.first; it != range.second; ++it)

{

const uint256& hash = it->second;

CWalletTx* copyTo = &mapWallet[hash];

if (copyFrom == copyTo) continue;

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;

copyTo->strFromAccount = copyFrom->strFromAccount;

// nOrderPos not copied on purpose

// cached members not copied on purpose

}

}

/**

* Outpoint is spent if any non-conflicted transaction

* spends it:

*/

bool CWallet::IsSpent(const uint256& hash, unsigned int n) const

{

const COutPoint outpoint(hash, n);

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

range = mapTxSpends.equal_range(outpoint);

for (TxSpends::const_iterator it = range.first; it != range.second; ++it)

{

const uint256& wtxid = it->second;

std::map<uint256, CWalletTx>::const_iterator mit = mapWallet.find(wtxid);

if (mit != mapWallet.end()) {

int depth = mit->second.GetDepthInMainChain();

if (depth > 0 || (depth == 0 && !mit->second.isAbandoned()))

return true; // Spent

}

}

return false;

}

void CWallet::AddToSpends(const COutPoint& outpoint, const uint256& wtxid)

{

mapTxSpends.insert(std::make_pair(outpoint, wtxid));

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

range = mapTxSpends.equal_range(outpoint);

SyncMetaData(range);

}

void CWallet::AddToSpends(const uint256& wtxid)

{

assert(mapWallet.count(wtxid));

CWalletTx& thisTx = mapWallet[wtxid];

if (thisTx.IsCoinBase()) // Coinbases don't spend anything!

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 = 2500000 / ((double)(GetTimeMillis() - nStartTime));

nStartTime = GetTimeMillis();

crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, kMasterKey.nDeriveIterations, kMasterKey.nDerivationMethod);

kMasterKey.nDeriveIterations = (kMasterKey.nDeriveIterations + kMasterKey.nDeriveIterations * 100 / ((double)(GetTimeMillis() - nStartTime))) / 2;

if (kMasterKey.nDeriveIterations < 25000)

kMasterKey.nDeriveIterations = 25000;

LogPrintf("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(!pwalletdbEncryption);

pwalletdbEncryption = new CWalletDB(*dbw);

if (!pwalletdbEncryption->TxnBegin()) {

delete pwalletdbEncryption;

pwalletdbEncryption = NULL;

return false;

}

pwalletdbEncryption->WriteMasterKey(nMasterKeyMaxID, kMasterKey);

if (!EncryptKeys(_vMasterKey))

{

pwalletdbEncryption->TxnAbort();

delete pwalletdbEncryption;

// 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, pwalletdbEncryption, true);

if (!pwalletdbEncryption->TxnCommit()) {

delete pwalletdbEncryption;

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

pwalletdbEncryption = NULL;

Lock();

Unlock(strWalletPassphrase);

// if we are using HD, replace the HD master key (seed) with a new one

if (IsHDEnabled()) {

if (!SetHDMasterKey(GenerateNewHDMasterKey())) {

return false;

}

}

NewKeyPool();

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.

dbw->Rewrite();

}

NotifyStatusChanged(this);

return true;

}

DBErrors CWallet::ReorderTransactions()

{

LOCK(cs_wallet);

CWalletDB walletdb(*dbw);

// Old wallets didn't have any defined order for transactions

// Probably a bad idea to change the output of this

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

typedef std::pair<CWalletTx*, CAccountingEntry*> TxPair;

typedef std::multimap<int64_t, TxPair > TxItems;

TxItems txByTime;

for (std::map<uint256, CWalletTx>::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)

{

CWalletTx* wtx = &((*it).second);

txByTime.insert(std::make_pair(wtx->nTimeReceived, TxPair(wtx, (CAccountingEntry*)0)));

}

std::list<CAccountingEntry> acentries;

walletdb.ListAccountCreditDebit("", acentries);

for (CAccountingEntry& entry : acentries)

{

txByTime.insert(std::make_pair(entry.nTime, TxPair((CWalletTx*)0, &entry)));

}

nOrderPosNext = 0;

std::vector<int64_t> nOrderPosOffsets;

for (TxItems::iterator it = txByTime.begin(); it != txByTime.end(); ++it)

{

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

CAccountingEntry *const pacentry = (*it).second.second;

int64_t& nOrderPos = (pwtx != 0) ? pwtx->nOrderPos : pacentry->nOrderPos;

if (nOrderPos == -1)

{

nOrderPos = nOrderPosNext++;

nOrderPosOffsets.push_back(nOrderPos);

if (pwtx)

{

if (!walletdb.WriteTx(*pwtx))

return DB_LOAD_FAIL;

}

else

if (!walletdb.WriteAccountingEntry(pacentry->nEntryNo, *pacentry))

return DB_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 (pwtx)

{

if (!walletdb.WriteTx(*pwtx))

return DB_LOAD_FAIL;

}

else

if (!walletdb.WriteAccountingEntry(pacentry->nEntryNo, *pacentry))

return DB_LOAD_FAIL;

}

}

walletdb.WriteOrderPosNext(nOrderPosNext);

return DB_LOAD_OK;

}

int64_t CWallet::IncOrderPosNext(CWalletDB *pwalletdb)

{

AssertLockHeld(cs_wallet); // nOrderPosNext

int64_t nRet = nOrderPosNext++;

if (pwalletdb) {

pwalletdb->WriteOrderPosNext(nOrderPosNext);

} else {

CWalletDB(*dbw).WriteOrderPosNext(nOrderPosNext);

}

return nRet;

}

bool CWallet::AccountMove(std::string strFrom, std::string strTo, CAmount nAmount, std::string strComment)

{

CWalletDB walletdb(*dbw);

if (!walletdb.TxnBegin())

return false;

int64_t nNow = GetAdjustedTime();

// Debit

CAccountingEntry debit;

debit.nOrderPos = IncOrderPosNext(&walletdb);

debit.strAccount = strFrom;

debit.nCreditDebit = -nAmount;

debit.nTime = nNow;

debit.strOtherAccount = strTo;

debit.strComment = strComment;

AddAccountingEntry(debit, &walletdb);

// Credit

CAccountingEntry credit;

credit.nOrderPos = IncOrderPosNext(&walletdb);

credit.strAccount = strTo;

credit.nCreditDebit = nAmount;

credit.nTime = nNow;

credit.strOtherAccount = strFrom;

credit.strComment = strComment;

AddAccountingEntry(credit, &walletdb);

if (!walletdb.TxnCommit())

return false;

return true;

}

bool CWallet::GetAccountPubkey(CPubKey &pubKey, std::string strAccount, bool bForceNew)

{

CWalletDB walletdb(*dbw);

CAccount account;

walletdb.ReadAccount(strAccount, account);

if (!bForceNew) {

if (!account.vchPubKey.IsValid())

bForceNew = true;

else {

// Check if the current key has been used

CScript scriptPubKey = GetScriptForDestination(account.vchPubKey.GetID());

for (std::map<uint256, CWalletTx>::iterator it = mapWallet.begin();

it != mapWallet.end() && account.vchPubKey.IsValid();

++it)

for (const CTxOut& txout : (*it).second.tx->vout)

if (txout.scriptPubKey == scriptPubKey) {

bForceNew = true;

break;

}

}

}

// Generate a new key

if (bForceNew) {

if (!GetKeyFromPool(account.vchPubKey, false))

return false;

SetAddressBook(account.vchPubKey.GetID(), strAccount, "receive");

walletdb.WriteAccount(strAccount, account);

}

pubKey = account.vchPubKey;

return true;

}

void CWallet::MarkDirty()

{

{

LOCK(cs_wallet);

for (std::pair<const uint256, CWalletTx>& item : mapWallet)

item.second.MarkDirty();

}

}

bool CWallet::MarkReplaced(const uint256& originalHash, const uint256& newHash)

{

LOCK(cs_wallet);

auto mi = mapWallet.find(originalHash);

// There is a bug if MarkReplaced is not called on an existing wallet transaction.

assert(mi != mapWallet.end());

CWalletTx& wtx = (*mi).second;

// Ensure for now that we're not overwriting data

assert(wtx.mapValue.count("replaced_by_txid") == 0);

wtx.mapValue["replaced_by_txid"] = newHash.ToString();

CWalletDB walletdb(*dbw, "r+");

bool success = true;

if (!walletdb.WriteTx(wtx)) {

LogPrintf("%s: Updating walletdb tx %s failed", __func__, wtx.GetHash().ToString());

success = false;

}

NotifyTransactionChanged(this, originalHash, CT_UPDATED);

return success;

}

bool CWallet::AddToWallet(const CWalletTx& wtxIn, bool fFlushOnClose)

{

LOCK(cs_wallet);

CWalletDB walletdb(*dbw, "r+", fFlushOnClose);

uint256 hash = wtxIn.GetHash();

// Inserts only if not already there, returns tx inserted or tx found

std::pair<std::map<uint256, CWalletTx>::iterator, bool> ret = mapWallet.insert(std::make_pair(hash, wtxIn));

CWalletTx& wtx = (*ret.first).second;

wtx.BindWallet(this);

bool fInsertedNew = ret.second;

if (fInsertedNew)

{

wtx.nTimeReceived = GetAdjustedTime();

wtx.nOrderPos = IncOrderPosNext(&walletdb);

wtxOrdered.insert(std::make_pair(wtx.nOrderPos, TxPair(&wtx, (CAccountingEntry*)0)));

wtx.nTimeSmart = ComputeTimeSmart(wtx);

AddToSpends(hash);

}

bool fUpdated = false;

if (!fInsertedNew)

{

// Merge

if (!wtxIn.hashUnset() && wtxIn.hashBlock != wtx.hashBlock)

{

wtx.hashBlock = wtxIn.hashBlock;

fUpdated = true;

}

// If no longer abandoned, update

if (wtxIn.hashBlock.IsNull() && wtx.isAbandoned())

{

wtx.hashBlock = wtxIn.hashBlock;

fUpdated = true;

}

if (wtxIn.nIndex != -1 && (wtxIn.nIndex != wtx.nIndex))

{

wtx.nIndex = wtxIn.nIndex;

fUpdated = true;

}

if (wtxIn.fFromMe && wtxIn.fFromMe != wtx.fFromMe)

{

wtx.fFromMe = wtxIn.fFromMe;

fUpdated = true;

}

}

//// debug print

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

// Write to disk

if (fInsertedNew || fUpdated)

if (!walletdb.WriteTx(wtx))

return false;

// Break debit/credit balance caches:

wtx.MarkDirty();

// Notify UI of new or updated transaction

NotifyTransactionChanged(this, hash, fInsertedNew ? CT_NEW : CT_UPDATED);

// notify an external script when a wallet transaction comes in or is updated

std::string strCmd = GetArg("-walletnotify", "");

if ( !strCmd.empty())

{

boost::replace_all(strCmd, "%s", wtxIn.GetHash().GetHex());

boost::thread t(runCommand, strCmd); // thread runs free

}

return true;

}

bool CWallet::LoadToWallet(const CWalletTx& wtxIn)

{

uint256 hash = wtxIn.GetHash();

mapWallet[hash] = wtxIn;

CWalletTx& wtx = mapWallet[hash];

wtx.BindWallet(this);

wtxOrdered.insert(std::make_pair(wtx.nOrderPos, TxPair(&wtx, (CAccountingEntry*)0)));

AddToSpends(hash);

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

if (mapWallet.count(txin.prevout.hash)) {

CWalletTx& prevtx = mapWallet[txin.prevout.hash];

if (prevtx.nIndex == -1 && !prevtx.hashUnset()) {

MarkConflicted(prevtx.hashBlock, wtx.GetHash());

}

}

}

return true;

}

/**

* 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 == NULL, 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.

*/