diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp index b356c299a..ae28c1f94 100644 --- a/src/wallet/wallet.cpp +++ b/src/wallet/wallet.cpp @@ -1,3983 +1,4482 @@ // 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 "chain.h" #include "checkpoints.h" #include "config.h" #include "consensus/consensus.h" #include "consensus/validation.h" #include "key.h" #include "keystore.h" #include "net.h" #include "policy/policy.h" #include "primitives/block.h" #include "primitives/transaction.h" #include "script/script.h" #include "script/sign.h" #include "timedata.h" #include "txmempool.h" #include "ui_interface.h" #include "util.h" #include "utilmoneystr.h" #include "validation.h" #include "wallet/coincontrol.h" #include "wallet/finaltx.h" -#include +#include #include #include #include -using namespace std; - -CWallet *pwalletMain = NULL; +CWallet *pwalletMain = nullptr; /** 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 fSendFreeTransactions = DEFAULT_SEND_FREE_TRANSACTIONS; 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. + * fee instead. Has no effect if not using fee estimation. * Override with -fallbackfee */ CFeeRate CWallet::fallbackFee = CFeeRate(DEFAULT_FALLBACK_FEE); const uint256 CMerkleTx::ABANDON_HASH(uint256S( "0000000000000000000000000000000000000000000000000000000000000001")); /** @defgroup mapWallet * * @{ */ struct CompareValueOnly { bool operator()( - const pair> &t1, - const pair> &t2) const { + const std::pair> + &t1, + const std::pair> + &t2) const { return t1.first < t2.first; } }; 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 uint256 &hash) const { LOCK(cs_wallet); std::map::const_iterator it = mapWallet.find(hash); - if (it == mapWallet.end()) return NULL; + if (it == mapWallet.end()) { + return nullptr; + } + return &(it->second); } CPubKey CWallet::GenerateNewKey() { // mapKeyMetadata AssertLockHeld(cs_wallet); // default to compressed public keys if we want 0.6.0 wallets bool fCompressed = CanSupportFeature(FEATURE_COMPRPUBKEY); CKey secret; // Create new metadata int64_t nCreationTime = GetTime(); CKeyMetadata metadata(nCreationTime); // use HD key derivation if HD was enabled during wallet creation if (IsHDEnabled()) { DeriveNewChildKey(metadata, secret); } else { secret.MakeNewKey(fCompressed); } // Compressed public keys were introduced in version 0.6.0 - if (fCompressed) SetMinVersion(FEATURE_COMPRPUBKEY); + if (fCompressed) { + SetMinVersion(FEATURE_COMPRPUBKEY); + } CPubKey pubkey = secret.GetPubKey(); assert(secret.VerifyPubKey(pubkey)); mapKeyMetadata[pubkey.GetID()] = metadata; UpdateTimeFirstKey(nCreationTime); - if (!AddKeyPubKey(secret, pubkey)) + if (!AddKeyPubKey(secret, pubkey)) { throw std::runtime_error(std::string(__func__) + ": AddKey failed"); + } + return pubkey; } void CWallet::DeriveNewChildKey(CKeyMetadata &metadata, CKey &secret) { // for now we use a fixed keypath scheme of m/0'/0'/k // master key seed (256bit) CKey key; // hd master key CExtKey masterKey; // key at m/0' CExtKey accountKey; // key at m/0'/0' CExtKey externalChainChildKey; // key at m/0'/0'/' CExtKey childKey; // try to get the master key - if (!GetKey(hdChain.masterKeyID, 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' accountKey.Derive(externalChainChildKey, BIP32_HARDENED_KEY_LIMIT); // 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 externalChainChildKey.Derive(childKey, hdChain.nExternalChainCounter | BIP32_HARDENED_KEY_LIMIT); metadata.hdKeypath = "m/0'/0'/" + std::to_string(hdChain.nExternalChainCounter) + "'"; metadata.hdMasterKeyID = hdChain.masterKeyID; // increment childkey index hdChain.nExternalChainCounter++; } while (HaveKey(childKey.key.GetPubKey().GetID())); secret = childKey.key; // update the chain model in the database - if (!CWalletDB(strWalletFile).WriteHDChain(hdChain)) + if (!CWalletDB(strWalletFile).WriteHDChain(hdChain)) { throw std::runtime_error(std::string(__func__) + ": Writing HD chain model failed"); + } } bool CWallet::AddKeyPubKey(const CKey &secret, const CPubKey &pubkey) { // mapKeyMetadata AssertLockHeld(cs_wallet); - if (!CCryptoKeyStore::AddKeyPubKey(secret, pubkey)) return false; + if (!CCryptoKeyStore::AddKeyPubKey(secret, pubkey)) { + return false; + } - // check if we need to remove from watch-only + // Check if we need to remove from watch-only. CScript script; script = GetScriptForDestination(pubkey.GetID()); - if (HaveWatchOnly(script)) RemoveWatchOnly(script); + if (HaveWatchOnly(script)) { + RemoveWatchOnly(script); + } + script = GetScriptForRawPubKey(pubkey); - if (HaveWatchOnly(script)) RemoveWatchOnly(script); + if (HaveWatchOnly(script)) { + RemoveWatchOnly(script); + } - if (!fFileBacked) return true; - if (!IsCrypted()) { - return CWalletDB(strWalletFile) - .WriteKey(pubkey, secret.GetPrivKey(), - mapKeyMetadata[pubkey.GetID()]); + if (!fFileBacked) { + return true; } - return true; + + if (IsCrypted()) { + return true; + } + + return CWalletDB(strWalletFile) + .WriteKey(pubkey, secret.GetPrivKey(), mapKeyMetadata[pubkey.GetID()]); } -bool CWallet::AddCryptedKey(const CPubKey &vchPubKey, - const vector &vchCryptedSecret) { - if (!CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret)) +bool CWallet::AddCryptedKey( + const CPubKey &vchPubKey, + const std::vector &vchCryptedSecret) { + if (!CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret)) { return false; - if (!fFileBacked) return true; - { - LOCK(cs_wallet); - if (pwalletdbEncryption) - return pwalletdbEncryption->WriteCryptedKey( - vchPubKey, vchCryptedSecret, mapKeyMetadata[vchPubKey.GetID()]); - else - return CWalletDB(strWalletFile) - .WriteCryptedKey(vchPubKey, vchCryptedSecret, - mapKeyMetadata[vchPubKey.GetID()]); } - return false; + + if (!fFileBacked) { + return true; + } + + LOCK(cs_wallet); + if (pwalletdbEncryption) { + return pwalletdbEncryption->WriteCryptedKey( + vchPubKey, vchCryptedSecret, mapKeyMetadata[vchPubKey.GetID()]); + } + + return CWalletDB(strWalletFile) + .WriteCryptedKey(vchPubKey, vchCryptedSecret, + mapKeyMetadata[vchPubKey.GetID()]); } bool CWallet::LoadKeyMetadata(const CTxDestination &keyID, const CKeyMetadata &meta) { // mapKeyMetadata AssertLockHeld(cs_wallet); UpdateTimeFirstKey(meta.nCreateTime); mapKeyMetadata[keyID] = meta; return true; } bool CWallet::LoadCryptedKey( const CPubKey &vchPubKey, const std::vector &vchCryptedSecret) { return CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret); } 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; - if (!fFileBacked) return true; + if (!CCryptoKeyStore::AddCScript(redeemScript)) { + return false; + } + + if (!fFileBacked) { + return true; + } + return CWalletDB(strWalletFile) .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; + if (!CCryptoKeyStore::AddWatchOnly(dest)) { + return false; + } + const CKeyMetadata &meta = mapKeyMetadata[CScriptID(dest)]; UpdateTimeFirstKey(meta.nCreateTime); NotifyWatchonlyChanged(true); - if (!fFileBacked) return true; + + if (!fFileBacked) { + return true; + } + return CWalletDB(strWalletFile).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 (fFileBacked) - if (!CWalletDB(strWalletFile).EraseWatchOnly(dest)) return false; + if (!CCryptoKeyStore::RemoveWatchOnly(dest)) { + return false; + } + + if (!HaveWatchOnly()) { + NotifyWatchonlyChanged(false); + } + + if (fFileBacked && !CWalletDB(strWalletFile).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)) { - // try another master key - continue; - } - if (CCryptoKeyStore::Unlock(vMasterKey)) return true; + 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 (CCryptoKeyStore::Unlock(vMasterKey)) { + return true; } } + return false; } bool CWallet::ChangeWalletPassphrase( const SecureString &strOldWalletPassphrase, const SecureString &strNewWalletPassphrase) { bool fWasLocked = IsLocked(); - { - LOCK(cs_wallet); - Lock(); + 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); - CCrypter crypter; - CKeyingMaterial vMasterKey; - for (MasterKeyMap::value_type &pMasterKey : mapMasterKeys) { if (!crypter.SetKeyFromPassphrase( - strOldWalletPassphrase, pMasterKey.second.vchSalt, + strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, - pMasterKey.second.nDerivationMethod)) + pMasterKey.second.nDerivationMethod)) { return false; - if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, vMasterKey)) + } + + if (!crypter.Encrypt(vMasterKey, pMasterKey.second.vchCryptedKey)) { 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(strWalletFile) - .WriteMasterKey(pMasterKey.first, pMasterKey.second); - if (fWasLocked) Lock(); - return true; + CWalletDB(strWalletFile) + .WriteMasterKey(pMasterKey.first, pMasterKey.second); + if (fWasLocked) { + Lock(); } + + return true; } } return false; } void CWallet::SetBestChain(const CBlockLocator &loc) { CWalletDB walletdb(strWalletFile); walletdb.WriteBestBlock(loc); } bool CWallet::SetMinVersion(enum WalletFeature nVersion, CWalletDB *pwalletdbIn, bool fExplicit) { // nWalletVersion LOCK(cs_wallet); - if (nWalletVersion >= nVersion) return true; + 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; + // 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; + if (nVersion > nWalletMaxVersion) { + nWalletMaxVersion = nVersion; + } if (fFileBacked) { CWalletDB *pwalletdb = pwalletdbIn ? pwalletdbIn : new CWalletDB(strWalletFile); - if (nWalletVersion > 40000) pwalletdb->WriteMinVersion(nWalletVersion); - if (!pwalletdbIn) delete pwalletdb; + if (nWalletVersion > 40000) { + pwalletdb->WriteMinVersion(nWalletVersion); + } + + if (!pwalletdbIn) { + delete pwalletdb; + } } return true; } bool CWallet::SetMaxVersion(int nVersion) { // nWalletVersion, nWalletMaxVersion LOCK(cs_wallet); - // cannot downgrade below current version - if (nWalletVersion > nVersion) return false; + + // Cannot downgrade below current version + if (nWalletVersion > nVersion) { + return false; + } nWalletMaxVersion = nVersion; return true; } -set CWallet::GetConflicts(const uint256 &txid) const { - set result; +std::set CWallet::GetConflicts(const uint256 &txid) const { + std::set result; AssertLockHeld(cs_wallet); std::map::const_iterator it = mapWallet.find(txid); - if (it == mapWallet.end()) return result; + if (it == mapWallet.end()) { + return result; + } + const CWalletTx &wtx = it->second; std::pair range; for (const CTxIn &txin : wtx.tx->vin) { if (mapTxSpends.count(txin.prevout) <= 1) { - // No conflict if zero or one spends + // 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) + ++_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) { bitdb.Flush(shutdown); } bool CWallet::Verify() { - if (GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET)) return true; + if (GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET)) { + return true; + } LogPrintf("Using BerkeleyDB version %s\n", DbEnv::version(0, 0, 0)); std::string walletFile = GetArg("-wallet", DEFAULT_WALLET_DAT); LogPrintf("Using wallet %s\n", walletFile); uiInterface.InitMessage(_("Verifying wallet...")); - // Wallet file must be a plain filename without a directory + // Wallet file must be a plain filename without a directory. if (walletFile != boost::filesystem::basename(walletFile) + - boost::filesystem::extension(walletFile)) + boost::filesystem::extension(walletFile)) { return InitError( strprintf(_("Wallet %s resides outside data directory %s"), walletFile, GetDataDir().string())); + } if (!bitdb.Open(GetDataDir())) { - // try moving the database env out of the way + // Try moving the database env out of the way. boost::filesystem::path pathDatabase = GetDataDir() / "database"; boost::filesystem::path pathDatabaseBak = GetDataDir() / strprintf("database.%d.bak", GetTime()); try { boost::filesystem::rename(pathDatabase, pathDatabaseBak); LogPrintf("Moved old %s to %s. Retrying.\n", pathDatabase.string(), pathDatabaseBak.string()); } catch (const boost::filesystem::filesystem_error &) { - // failure is ok (well, not really, but it's not worse than what we + // Failure is ok (well, not really, but it's not worse than what we // started with) } // try again if (!bitdb.Open(GetDataDir())) { - // if it still fails, it probably means we can't even create the - // database env + // If it still fails, it probably means we can't even create the + // database env. return InitError(strprintf( _("Error initializing wallet database environment %s!"), GetDataDir())); } } if (GetBoolArg("-salvagewallet", false)) { // Recover readable keypairs: if (!CWalletDB::Recover(bitdb, walletFile, true)) return false; } if (boost::filesystem::exists(GetDataDir() / walletFile)) { CDBEnv::VerifyResult r = bitdb.Verify(walletFile, CWalletDB::Recover); if (r == CDBEnv::RECOVER_OK) { InitWarning(strprintf( _("Warning: Wallet file corrupt, data salvaged!" " Original %s saved as %s in %s; if" " your balance or transactions are incorrect you should" " restore from a backup."), walletFile, "wallet.{timestamp}.bak", GetDataDir())); } - if (r == CDBEnv::RECOVER_FAIL) + + if (r == CDBEnv::RECOVER_FAIL) { return InitError( strprintf(_("%s corrupt, salvage failed"), walletFile)); + } } return true; } -void CWallet::SyncMetaData(pair range) { +void CWallet::SyncMetaData( + std::pair 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::max(); - const CWalletTx *copyFrom = NULL; + const CWalletTx *copyFrom = nullptr; 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; + 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 + // 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 + // nOrderPos not copied on purpose cached members not copied on purpose. } } /** - * Outpoint is spent if any non-conflicted transaction - * spends it: + * 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); - pair range; + std::pair range; range = mapTxSpends.equal_range(outpoint); for (TxSpends::const_iterator it = range.first; it != range.second; ++it) { const uint256 &wtxid = it->second; std::map::const_iterator mit = mapWallet.find(wtxid); if (mit != mapWallet.end()) { int depth = mit->second.GetDepthInMainChain(); if (depth > 0 || (depth == 0 && !mit->second.isAbandoned())) { // Spent return true; } } } + return false; } void CWallet::AddToSpends(const COutPoint &outpoint, const uint256 &wtxid) { - mapTxSpends.insert(make_pair(outpoint, wtxid)); + mapTxSpends.insert(std::make_pair(outpoint, wtxid)); - pair range; + std::pair range; range = mapTxSpends.equal_range(outpoint); SyncMetaData(range); } void CWallet::AddToSpends(const uint256 &wtxid) { assert(mapWallet.count(wtxid)); CWalletTx &thisTx = mapWallet[wtxid]; // Coinbases don't spend anything! - if (thisTx.IsCoinBase()) return; + 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; + 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) + 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)) + kMasterKey.nDerivationMethod)) { return false; - if (!crypter.Encrypt(vMasterKey, kMasterKey.vchCryptedKey)) return false; + } + + if (!crypter.Encrypt(vMasterKey, kMasterKey.vchCryptedKey)) { + return false; + } { LOCK(cs_wallet); mapMasterKeys[++nMasterKeyMaxID] = kMasterKey; if (fFileBacked) { assert(!pwalletdbEncryption); pwalletdbEncryption = new CWalletDB(strWalletFile); if (!pwalletdbEncryption->TxnBegin()) { delete pwalletdbEncryption; - pwalletdbEncryption = NULL; + pwalletdbEncryption = nullptr; return false; } + pwalletdbEncryption->WriteMasterKey(nMasterKeyMaxID, kMasterKey); } if (!EncryptKeys(vMasterKey)) { if (fFileBacked) { 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 (fFileBacked) { 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; + pwalletdbEncryption = nullptr; } Lock(); Unlock(strWalletPassphrase); - // if we are using HD, replace the HD master key (seed) with a new one + // If we are using HD, replace the HD master key (seed) with a new one. if (IsHDEnabled()) { CKey key; CPubKey masterPubKey = GenerateNewHDMasterKey(); - if (!SetHDMasterKey(masterPubKey)) return false; + if (!SetHDMasterKey(masterPubKey)) { + 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. CDB::Rewrite(strWalletFile); } - NotifyStatusChanged(this); + NotifyStatusChanged(this); return true; } DBErrors CWallet::ReorderTransactions() { LOCK(cs_wallet); CWalletDB walletdb(strWalletFile); - // Old wallets didn't have any defined order for transactions - // Probably a bad idea to change the output of this + // 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 pair TxPair; - typedef multimap TxItems; + typedef std::pair TxPair; + typedef std::multimap TxItems; TxItems txByTime; - for (map::iterator it = mapWallet.begin(); + for (std::map::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) { CWalletTx *wtx = &((*it).second); txByTime.insert( - make_pair(wtx->nTimeReceived, TxPair(wtx, (CAccountingEntry *)0))); + std::make_pair(wtx->nTimeReceived, TxPair(wtx, nullptr))); } - list acentries; + + std::list acentries; walletdb.ListAccountCreditDebit("", acentries); for (CAccountingEntry &entry : acentries) { - txByTime.insert(make_pair(entry.nTime, TxPair((CWalletTx *)0, &entry))); + txByTime.insert(std::make_pair(entry.nTime, TxPair(nullptr, &entry))); } nOrderPosNext = 0; std::vector 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; + if (!walletdb.WriteTx(*pwtx)) { + return DB_LOAD_FAIL; + } } else if (!walletdb.WriteAccountingEntry(pacentry->nEntryNo, - *pacentry)) + *pacentry)) { return DB_LOAD_FAIL; + } } else { int64_t nOrderPosOff = 0; for (const int64_t &nOffsetStart : nOrderPosOffsets) { - if (nOrderPos >= nOffsetStart) ++nOrderPosOff; + if (nOrderPos >= nOffsetStart) { + ++nOrderPosOff; + } } + nOrderPos += nOrderPosOff; nOrderPosNext = std::max(nOrderPosNext, nOrderPos + 1); - if (!nOrderPosOff) continue; + if (!nOrderPosOff) { + continue; + } - // Since we're changing the order, write it back + // Since we're changing the order, write it back. if (pwtx) { - if (!walletdb.WriteTx(*pwtx)) return DB_LOAD_FAIL; + if (!walletdb.WriteTx(*pwtx)) { + return DB_LOAD_FAIL; + } } else if (!walletdb.WriteAccountingEntry(pacentry->nEntryNo, - *pacentry)) + *pacentry)) { return DB_LOAD_FAIL; + } } } + walletdb.WriteOrderPosNext(nOrderPosNext); return DB_LOAD_OK; } int64_t CWallet::IncOrderPosNext(CWalletDB *pwalletdb) { // nOrderPosNext AssertLockHeld(cs_wallet); int64_t nRet = nOrderPosNext++; if (pwalletdb) { pwalletdb->WriteOrderPosNext(nOrderPosNext); } else { CWalletDB(strWalletFile).WriteOrderPosNext(nOrderPosNext); } + return nRet; } bool CWallet::AccountMove(std::string strFrom, std::string strTo, CAmount nAmount, std::string strComment) { CWalletDB walletdb(strWalletFile); - if (!walletdb.TxnBegin()) return false; + 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; + if (!walletdb.TxnCommit()) { + return false; + } return true; } bool CWallet::GetAccountPubkey(CPubKey &pubKey, std::string strAccount, bool bForceNew) { CWalletDB walletdb(strWalletFile); CAccount account; walletdb.ReadAccount(strAccount, account); if (!bForceNew) { - if (!account.vchPubKey.IsValid()) + if (!account.vchPubKey.IsValid()) { bForceNew = true; - else { - // Check if the current key has been used + } else { + // Check if the current key has been used. CScript scriptPubKey = GetScriptForDestination(account.vchPubKey.GetID()); - for (map::iterator it = mapWallet.begin(); - it != mapWallet.end() && account.vchPubKey.IsValid(); ++it) + for (std::map::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)) return false; + if (!GetKeyFromPool(account.vchPubKey)) { + 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 &item : mapWallet) { - item.second.MarkDirty(); - } + LOCK(cs_wallet); + for (std::pair &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 + // 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(strWalletFile, "r+"); bool success = true; if (!walletdb.WriteTx(wtx)) { LogPrintf("%s: Updating walletdb tx %s failed", __func__, wtx.GetId().ToString()); success = false; } NotifyTransactionChanged(this, originalHash, CT_UPDATED); return success; } bool CWallet::AddToWallet(const CWalletTx &wtxIn, bool fFlushOnClose) { LOCK(cs_wallet); CWalletDB walletdb(strWalletFile, "r+", fFlushOnClose); uint256 hash = wtxIn.GetId(); - // Inserts only if not already there, returns tx inserted or tx found - pair::iterator, bool> ret = - mapWallet.insert(make_pair(hash, wtxIn)); + // Inserts only if not already there, returns tx inserted or tx found. + std::pair::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( - make_pair(wtx.nOrderPos, TxPair(&wtx, (CAccountingEntry *)0))); + wtxOrdered.insert(std::make_pair(wtx.nOrderPos, TxPair(&wtx, nullptr))); wtx.nTimeSmart = wtx.nTimeReceived; if (!wtxIn.hashUnset()) { if (mapBlockIndex.count(wtxIn.hashBlock)) { 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 + // more than 5 minutes into the future. int64_t latestTolerated = latestNow + 300; const TxItems &txOrdered = wtxOrdered; for (TxItems::const_reverse_iterator it = txOrdered.rbegin(); it != txOrdered.rend(); ++it) { CWalletTx *const pwtx = (*it).second.first; - if (pwtx == &wtx) continue; + if (pwtx == &wtx) { + continue; + } + CAccountingEntry *const pacentry = (*it).second.second; int64_t nSmartTime; if (pwtx) { nSmartTime = pwtx->nTimeSmart; - if (!nSmartTime) nSmartTime = pwtx->nTimeReceived; - } else + if (!nSmartTime) { + nSmartTime = pwtx->nTimeReceived; + } + } else { nSmartTime = pacentry->nTime; + } + if (nSmartTime <= latestTolerated) { latestEntry = nSmartTime; - if (nSmartTime > latestNow) latestNow = nSmartTime; + if (nSmartTime > latestNow) { + latestNow = nSmartTime; + } + break; } } } int64_t blocktime = mapBlockIndex[wtxIn.hashBlock]->GetBlockTime(); wtx.nTimeSmart = std::max(latestEntry, std::min(blocktime, latestNow)); - } else + } else { LogPrintf("AddToWallet(): found %s in block %s not in index\n", wtxIn.GetId().ToString(), wtxIn.hashBlock.ToString()); + } } + 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.GetId().ToString(), (fInsertedNew ? "new" : ""), (fUpdated ? "update" : "")); // Write to disk - if (fInsertedNew || fUpdated) - if (!walletdb.WriteTx(wtx)) return false; + if ((fInsertedNew || fUpdated) && !walletdb.WriteTx(wtx)) { + return false; + } // Break debit/credit balance caches: wtx.MarkDirty(); - // Notify UI of new or updated transaction + // 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 + // 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.GetId().GetHex()); - // thread runs free + // Thread runs free. boost::thread t(runCommand, strCmd); } return true; } bool CWallet::LoadToWallet(const CWalletTx &wtxIn) { uint256 txid = wtxIn.GetId(); mapWallet[txid] = wtxIn; CWalletTx &wtx = mapWallet[txid]; wtx.BindWallet(this); - wtxOrdered.insert( - make_pair(wtx.nOrderPos, TxPair(&wtx, (CAccountingEntry *)0))); + wtxOrdered.insert(std::make_pair(wtx.nOrderPos, TxPair(&wtx, nullptr))); AddToSpends(txid); 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.GetId()); } } } 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 - * posInBlock = SYNC_TRANSACTION_NOT_IN_BLOCK (-1) , then wallet state is not + * posInBlock = SYNC_TRANSACTION_NOT_IN_BLOCK (-1), 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. + * 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 carefuly tracked via different * posInBlock signals or by checking mempool presence when necessary. */ bool CWallet::AddToWalletIfInvolvingMe(const CTransaction &tx, const CBlockIndex *pIndex, int posInBlock, bool fUpdate) { - { - AssertLockHeld(cs_wallet); + AssertLockHeld(cs_wallet); - if (posInBlock != -1) { - for (const CTxIn &txin : tx.vin) { - std::pair - range = mapTxSpends.equal_range(txin.prevout); - while (range.first != range.second) { - if (range.first->second != tx.GetId()) { - LogPrintf("Transaction %s (in block %s) conflicts with " - "wallet transaction %s (both spend %s:%i)\n", - tx.GetId().ToString(), - pIndex->GetBlockHash().ToString(), - range.first->second.ToString(), - range.first->first.hash.ToString(), - range.first->first.n); - MarkConflicted(pIndex->GetBlockHash(), - range.first->second); - } - range.first++; + if (posInBlock != -1) { + for (const CTxIn &txin : tx.vin) { + std::pair + range = mapTxSpends.equal_range(txin.prevout); + while (range.first != range.second) { + if (range.first->second != tx.GetId()) { + LogPrintf("Transaction %s (in block %s) conflicts with " + "wallet transaction %s (both spend %s:%i)\n", + tx.GetId().ToString(), + pIndex->GetBlockHash().ToString(), + range.first->second.ToString(), + range.first->first.hash.ToString(), + range.first->first.n); + MarkConflicted(pIndex->GetBlockHash(), range.first->second); } + range.first++; } } + } - bool fExisted = mapWallet.count(tx.GetId()) != 0; - if (fExisted && !fUpdate) return false; - if (fExisted || IsMine(tx) || IsFromMe(tx)) { - CWalletTx wtx(this, MakeTransactionRef(tx)); + bool fExisted = mapWallet.count(tx.GetId()) != 0; + if (fExisted && !fUpdate) { + return false; + } - // Get merkle branch if transaction was found in a block - if (posInBlock != -1) wtx.SetMerkleBranch(pIndex, posInBlock); + if (fExisted || IsMine(tx) || IsFromMe(tx)) { + CWalletTx wtx(this, MakeTransactionRef(tx)); - return AddToWallet(wtx, false); + // Get merkle branch if transaction was found in a block. + if (posInBlock != -1) { + wtx.SetMerkleBranch(pIndex, posInBlock); } + + return AddToWallet(wtx, false); } + return false; } bool CWallet::AbandonTransaction(const uint256 &hashTx) { LOCK2(cs_main, cs_wallet); CWalletDB walletdb(strWalletFile, "r+"); std::set todo; std::set done; - // Can't mark abandoned if confirmed or in mempool + // Can't mark abandoned if confirmed or in mempool. assert(mapWallet.count(hashTx)); CWalletTx &origtx = mapWallet[hashTx]; if (origtx.GetDepthInMainChain() > 0 || origtx.InMempool()) { return false; } todo.insert(hashTx); while (!todo.empty()) { uint256 now = *todo.begin(); todo.erase(now); done.insert(now); assert(mapWallet.count(now)); CWalletTx &wtx = mapWallet[now]; int currentconfirm = wtx.GetDepthInMainChain(); - // If the orig tx was not in block, none of its spends can be + // 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 + // 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 + // be in mempool. assert(!wtx.InMempool()); wtx.nIndex = -1; wtx.setAbandoned(); wtx.MarkDirty(); walletdb.WriteTx(wtx); NotifyTransactionChanged(this, wtx.GetId(), CT_UPDATED); // Iterate over all its outputs, and mark transactions in the wallet - // that spend them abandoned too + // that spend them abandoned too. TxSpends::const_iterator iter = mapTxSpends.lower_bound(COutPoint(hashTx, 0)); while (iter != mapTxSpends.end() && iter->first.hash == 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 + // recomputed. for (const CTxIn &txin : wtx.tx->vin) { if (mapWallet.count(txin.prevout.hash)) mapWallet[txin.prevout.hash].MarkDirty(); } } } return true; } void CWallet::MarkConflicted(const uint256 &hashBlock, const uint256 &hashTx) { LOCK2(cs_main, cs_wallet); int conflictconfirms = 0; if (mapBlockIndex.count(hashBlock)) { CBlockIndex *pindex = mapBlockIndex[hashBlock]; if (chainActive.Contains(pindex)) { conflictconfirms = -(chainActive.Height() - pindex->nHeight + 1); } } + // 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; + if (conflictconfirms >= 0) { + return; + } // Do not flush the wallet here for performance reasons CWalletDB walletdb(strWalletFile, "r+", false); std::set todo; std::set done; todo.insert(hashTx); while (!todo.empty()) { uint256 now = *todo.begin(); todo.erase(now); done.insert(now); assert(mapWallet.count(now)); CWalletTx &wtx = mapWallet[now]; int currentconfirm = wtx.GetDepthInMainChain(); if (conflictconfirms < currentconfirm) { // Block is 'more conflicted' than current confirm; update. // Mark transaction as conflicted with this block. wtx.nIndex = -1; wtx.hashBlock = hashBlock; wtx.MarkDirty(); walletdb.WriteTx(wtx); // Iterate over all its outputs, and mark transactions in the wallet - // that spend them conflicted too + // that spend them conflicted too. TxSpends::const_iterator iter = mapTxSpends.lower_bound(COutPoint(now, 0)); while (iter != mapTxSpends.end() && iter->first.hash == 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 + // recomputed. for (const CTxIn &txin : wtx.tx->vin) { - if (mapWallet.count(txin.prevout.hash)) + if (mapWallet.count(txin.prevout.hash)) { mapWallet[txin.prevout.hash].MarkDirty(); + } } } } } void CWallet::SyncTransaction(const CTransaction &tx, const CBlockIndex *pindex, int posInBlock) { LOCK2(cs_main, cs_wallet); - if (!AddToWalletIfInvolvingMe(tx, pindex, posInBlock, true)) - return; // Not one of ours + if (!AddToWalletIfInvolvingMe(tx, pindex, posInBlock, true)) { + // 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: for (const CTxIn &txin : tx.vin) { if (mapWallet.count(txin.prevout.hash)) mapWallet[txin.prevout.hash].MarkDirty(); } } isminetype CWallet::IsMine(const CTxIn &txin) const { - { - LOCK(cs_wallet); - map::const_iterator mi = - mapWallet.find(txin.prevout.hash); - if (mi != mapWallet.end()) { - const CWalletTx &prev = (*mi).second; - if (txin.prevout.n < prev.tx->vout.size()) - return IsMine(prev.tx->vout[txin.prevout.n]); + LOCK(cs_wallet); + std::map::const_iterator mi = + mapWallet.find(txin.prevout.hash); + if (mi != mapWallet.end()) { + const CWalletTx &prev = (*mi).second; + if (txin.prevout.n < prev.tx->vout.size()) { + return IsMine(prev.tx->vout[txin.prevout.n]); } } + 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. CAmount CWallet::GetDebit(const CTxIn &txin, const isminefilter &filter) const { - { - LOCK(cs_wallet); - map::const_iterator mi = - mapWallet.find(txin.prevout.hash); - if (mi != mapWallet.end()) { - const CWalletTx &prev = (*mi).second; - if (txin.prevout.n < prev.tx->vout.size()) - if (IsMine(prev.tx->vout[txin.prevout.n]) & filter) - return prev.tx->vout[txin.prevout.n].nValue; + LOCK(cs_wallet); + std::map::const_iterator mi = + mapWallet.find(txin.prevout.hash); + if (mi != mapWallet.end()) { + const CWalletTx &prev = (*mi).second; + if (txin.prevout.n < prev.tx->vout.size()) { + if (IsMine(prev.tx->vout[txin.prevout.n]) & filter) { + return prev.tx->vout[txin.prevout.n].nValue; + } } } + return 0; } isminetype CWallet::IsMine(const CTxOut &txout) const { return ::IsMine(*this, txout.scriptPubKey); } CAmount CWallet::GetCredit(const CTxOut &txout, const isminefilter &filter) const { - if (!MoneyRange(txout.nValue)) + if (!MoneyRange(txout.nValue)) { throw std::runtime_error(std::string(__func__) + ": value out of range"); - return ((IsMine(txout) & filter) ? txout.nValue : 0); + } + + return (IsMine(txout) & filter) ? txout.nValue : 0; } bool CWallet::IsChange(const CTxOut &txout) 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(*this, txout.scriptPubKey)) { CTxDestination address; - if (!ExtractDestination(txout.scriptPubKey, address)) return true; + if (!ExtractDestination(txout.scriptPubKey, address)) { + return true; + } LOCK(cs_wallet); - if (!mapAddressBook.count(address)) return true; + if (!mapAddressBook.count(address)) { + return true; + } } + return false; } CAmount CWallet::GetChange(const CTxOut &txout) const { - if (!MoneyRange(txout.nValue)) + if (!MoneyRange(txout.nValue)) { throw std::runtime_error(std::string(__func__) + ": value out of range"); + } + return (IsChange(txout) ? txout.nValue : 0); } bool CWallet::IsMine(const CTransaction &tx) const { for (const CTxOut &txout : tx.vout) { - if (IsMine(txout)) return true; + if (IsMine(txout)) { + return true; + } } + return false; } bool CWallet::IsFromMe(const CTransaction &tx) const { - return (GetDebit(tx, ISMINE_ALL) > 0); + return GetDebit(tx, ISMINE_ALL) > 0; } CAmount CWallet::GetDebit(const CTransaction &tx, const isminefilter &filter) const { CAmount nDebit = 0; for (const CTxIn &txin : tx.vin) { nDebit += GetDebit(txin, filter); - if (!MoneyRange(nDebit)) + 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.hash); if (mi == mapWallet.end()) { - // any unknown inputs can't be from us + // Any unknown inputs can't be from us. return false; } const CWalletTx &prev = (*mi).second; if (txin.prevout.n >= prev.tx->vout.size()) { - // invalid input! + // Invalid input! return false; } - if (!(IsMine(prev.tx->vout[txin.prevout.n]) & filter)) return false; + if (!(IsMine(prev.tx->vout[txin.prevout.n]) & filter)) { + return false; + } } + return true; } CAmount CWallet::GetCredit(const CTransaction &tx, const isminefilter &filter) const { CAmount nCredit = 0; for (const CTxOut &txout : tx.vout) { nCredit += GetCredit(txout, filter); - if (!MoneyRange(nCredit)) + if (!MoneyRange(nCredit)) { throw std::runtime_error(std::string(__func__) + ": value out of range"); + } } + return nCredit; } CAmount CWallet::GetChange(const CTransaction &tx) const { CAmount nChange = 0; for (const CTxOut &txout : tx.vout) { nChange += GetChange(txout); - if (!MoneyRange(nChange)) + if (!MoneyRange(nChange)) { throw std::runtime_error(std::string(__func__) + ": value out of range"); + } } + return nChange; } CPubKey CWallet::GenerateNewHDMasterKey() { CKey key; key.MakeNewKey(true); int64_t nCreationTime = GetTime(); CKeyMetadata metadata(nCreationTime); - // calculate the pubkey + // Calculate the pubkey. CPubKey pubkey = key.GetPubKey(); assert(key.VerifyPubKey(pubkey)); - // set the hd keypath to "m" -> Master, refers the masterkeyid to itself + // Set the hd keypath to "m" -> Master, refers the masterkeyid to itself. metadata.hdKeypath = "m"; metadata.hdMasterKeyID = pubkey.GetID(); - { - LOCK(cs_wallet); + LOCK(cs_wallet); - // mem store the metadata - mapKeyMetadata[pubkey.GetID()] = metadata; + // mem store the metadata + mapKeyMetadata[pubkey.GetID()] = metadata; - // write the key&metadata to the database - if (!AddKeyPubKey(key, pubkey)) - throw std::runtime_error(std::string(__func__) + - ": AddKeyPubKey failed"); + // Write the key&metadata to the database. + if (!AddKeyPubKey(key, pubkey)) { + throw std::runtime_error(std::string(__func__) + + ": AddKeyPubKey failed"); } return pubkey; } bool CWallet::SetHDMasterKey(const CPubKey &pubkey) { LOCK(cs_wallet); - // ensure this wallet.dat can only be opened by clients supporting HD + // Ensure this wallet.dat can only be opened by clients supporting HD. SetMinVersion(FEATURE_HD); - // store the keyid (hash160) together with the child index counter in the - // database as a hdchain object + // Store the keyid (hash160) together with the child index counter in the + // database as a hdchain object. CHDChain newHdChain; newHdChain.masterKeyID = pubkey.GetID(); SetHDChain(newHdChain, false); return true; } bool CWallet::SetHDChain(const CHDChain &chain, bool memonly) { LOCK(cs_wallet); - if (!memonly && !CWalletDB(strWalletFile).WriteHDChain(chain)) - throw runtime_error(std::string(__func__) + ": writing chain failed"); + if (!memonly && !CWalletDB(strWalletFile).WriteHDChain(chain)) { + throw std::runtime_error(std::string(__func__) + + ": writing chain failed"); + } hdChain = chain; return true; } bool CWallet::IsHDEnabled() { return !hdChain.masterKeyID.IsNull(); } int64_t CWalletTx::GetTxTime() const { int64_t n = nTimeSmart; return n ? n : nTimeReceived; } int CWalletTx::GetRequestCount() const { - // Returns -1 if it wasn't being tracked + LOCK(pwallet->cs_wallet); + + // Returns -1 if it wasn't being tracked. int nRequests = -1; - { - LOCK(pwallet->cs_wallet); - if (IsCoinBase()) { - // Generated block - if (!hashUnset()) { - map::const_iterator mi = - pwallet->mapRequestCount.find(hashBlock); - if (mi != pwallet->mapRequestCount.end()) - nRequests = (*mi).second; - } - } else { - // Did anyone request this transaction? - map::const_iterator mi = - pwallet->mapRequestCount.find(GetId()); + + if (IsCoinBase()) { + // Generated block. + if (!hashUnset()) { + std::map::const_iterator mi = + pwallet->mapRequestCount.find(hashBlock); if (mi != pwallet->mapRequestCount.end()) { nRequests = (*mi).second; - - // How about the block it's in? - if (nRequests == 0 && !hashUnset()) { - map::const_iterator _mi = - pwallet->mapRequestCount.find(hashBlock); - if (_mi != pwallet->mapRequestCount.end()) { - nRequests = (*_mi).second; - } else { - // If it's in someone else's block it must have got out - nRequests = 1; - } + } + } + } else { + // Did anyone request this transaction? + std::map::const_iterator mi = + pwallet->mapRequestCount.find(GetId()); + if (mi != pwallet->mapRequestCount.end()) { + nRequests = (*mi).second; + + // How about the block it's in? + if (nRequests == 0 && !hashUnset()) { + std::map::const_iterator _mi = + pwallet->mapRequestCount.find(hashBlock); + if (_mi != pwallet->mapRequestCount.end()) { + nRequests = (*_mi).second; + } else { + // If it's in someone else's block it must have got out. + nRequests = 1; } } } } + return nRequests; } -void CWalletTx::GetAmounts(list &listReceived, - list &listSent, CAmount &nFee, - string &strSentAccount, +void CWalletTx::GetAmounts(std::list &listReceived, + std::list &listSent, CAmount &nFee, + std::string &strSentAccount, const isminefilter &filter) const { nFee = 0; listReceived.clear(); listSent.clear(); strSentAccount = strFromAccount; // Compute fee: CAmount nDebit = GetDebit(filter); - // debit>0 means we signed/sent this transaction + // debit>0 means we signed/sent this transaction. if (nDebit > 0) { CAmount 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 > 0) { // Don't report 'change' txouts - if (pwallet->IsChange(txout)) continue; - } else if (!(fIsMine & filter)) - continue; + if (pwallet->IsChange(txout)) { + continue; + } + } else if (!(fIsMine & filter)) { + continue; + } - // In either case, we need to get the destination address + // In either case, we need to get the destination address. CTxDestination address; if (!ExtractDestination(txout.scriptPubKey, address) && !txout.scriptPubKey.IsUnspendable()) { LogPrintf("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 > 0) listSent.push_back(output); + // entry. + if (nDebit > 0) { + listSent.push_back(output); + } - // If we are receiving the output, add it as a "received" entry - if (fIsMine & filter) listReceived.push_back(output); + // If we are receiving the output, add it as a "received" entry. + if (fIsMine & filter) { + listReceived.push_back(output); + } } } -void CWalletTx::GetAccountAmounts(const string &strAccount, CAmount &nReceived, - CAmount &nSent, CAmount &nFee, +void CWalletTx::GetAccountAmounts(const std::string &strAccount, + CAmount &nReceived, CAmount &nSent, + CAmount &nFee, const isminefilter &filter) const { nReceived = nSent = nFee = 0; CAmount allFee; - string strSentAccount; - list listReceived; - list listSent; + std::string strSentAccount; + std::list listReceived; + std::list listSent; GetAmounts(listReceived, listSent, allFee, strSentAccount, filter); if (strAccount == strSentAccount) { for (const COutputEntry &s : listSent) { nSent += s.amount; } nFee = allFee; } - { - LOCK(pwallet->cs_wallet); - for (const COutputEntry &r : listReceived) { - if (pwallet->mapAddressBook.count(r.destination)) { - map::const_iterator mi = - pwallet->mapAddressBook.find(r.destination); - if (mi != pwallet->mapAddressBook.end() && - (*mi).second.name == strAccount) - nReceived += r.amount; - } else if (strAccount.empty()) { + + LOCK(pwallet->cs_wallet); + for (const COutputEntry &r : listReceived) { + if (pwallet->mapAddressBook.count(r.destination)) { + std::map::const_iterator mi = + pwallet->mapAddressBook.find(r.destination); + if (mi != pwallet->mapAddressBook.end() && + (*mi).second.name == strAccount) { nReceived += r.amount; } + } else if (strAccount.empty()) { + nReceived += r.amount; } } } /** * Scan the block chain (starting in pindexStart) for transactions from or to * us. If fUpdate is true, found transactions that already exist in the wallet * will be updated. * * Returns pointer to the first block in the last contiguous range that was * successfully scanned. */ CBlockIndex *CWallet::ScanForWalletTransactions(CBlockIndex *pindexStart, bool fUpdate) { + LOCK2(cs_main, cs_wallet); + CBlockIndex *ret = nullptr; int64_t nNow = GetTime(); const CChainParams &chainParams = Params(); CBlockIndex *pindex = pindexStart; - { - LOCK2(cs_main, cs_wallet); - // no need to read and scan block, if block was created before our - // wallet birthday (as adjusted for block time variability) - while (pindex && nTimeFirstKey && - (pindex->GetBlockTime() < (nTimeFirstKey - 7200))) - pindex = chainActive.Next(pindex); - - // show rescan progress in GUI as dialog or on splashscreen, if -rescan - // on startup - ShowProgress(_("Rescanning..."), 0); - double dProgressStart = - GuessVerificationProgress(chainParams.TxData(), pindex); - double dProgressTip = - GuessVerificationProgress(chainParams.TxData(), chainActive.Tip()); - while (pindex) { - if (pindex->nHeight % 100 == 0 && - dProgressTip - dProgressStart > 0.0) - ShowProgress( - _("Rescanning..."), - std::max( - 1, - std::min(99, (int)((GuessVerificationProgress( - chainParams.TxData(), pindex) - - dProgressStart) / - (dProgressTip - dProgressStart) * - 100)))); - - CBlock block; - if (ReadBlockFromDisk(block, pindex, Params().GetConsensus())) { - for (size_t posInBlock = 0; posInBlock < block.vtx.size(); - ++posInBlock) { - AddToWalletIfInvolvingMe(*block.vtx[posInBlock], pindex, - posInBlock, fUpdate); - } - if (!ret) { - ret = pindex; - } - } else { - ret = nullptr; + // No need to read and scan block, if block was created before our wallet + // birthday (as adjusted for block time variability) + while (pindex && nTimeFirstKey && + (pindex->GetBlockTime() < (nTimeFirstKey - 7200))) { + pindex = chainActive.Next(pindex); + } + + // Show rescan progress in GUI as dialog or on splashscreen, if -rescan on + // startup. + ShowProgress(_("Rescanning..."), 0); + double dProgressStart = + GuessVerificationProgress(chainParams.TxData(), pindex); + double dProgressTip = + GuessVerificationProgress(chainParams.TxData(), chainActive.Tip()); + while (pindex) { + if (pindex->nHeight % 100 == 0 && dProgressTip - dProgressStart > 0.0) { + ShowProgress( + _("Rescanning..."), + std::max(1, + std::min(99, (int)((GuessVerificationProgress( + chainParams.TxData(), pindex) - + dProgressStart) / + (dProgressTip - dProgressStart) * + 100)))); + } + + CBlock block; + if (ReadBlockFromDisk(block, pindex, Params().GetConsensus())) { + for (size_t posInBlock = 0; posInBlock < block.vtx.size(); + ++posInBlock) { + AddToWalletIfInvolvingMe(*block.vtx[posInBlock], pindex, + posInBlock, fUpdate); } - pindex = chainActive.Next(pindex); - if (GetTime() >= nNow + 60) { - nNow = GetTime(); - LogPrintf("Still rescanning. At block %d. Progress=%f\n", - pindex->nHeight, GuessVerificationProgress( - chainParams.TxData(), pindex)); + + if (!ret) { + ret = pindex; } + } else { + ret = nullptr; + } + + pindex = chainActive.Next(pindex); + if (GetTime() >= nNow + 60) { + nNow = GetTime(); + LogPrintf("Still rescanning. At block %d. Progress=%f\n", + pindex->nHeight, + GuessVerificationProgress(chainParams.TxData(), pindex)); } - // hide progress dialog in GUI - ShowProgress(_("Rescanning..."), 100); } + + // Hide progress dialog in GUI. + ShowProgress(_("Rescanning..."), 100); + return ret; } void CWallet::ReacceptWalletTransactions() { // If transactions aren't being broadcasted, don't let them into local - // mempool either - if (!fBroadcastTransactions) return; + // mempool either. + if (!fBroadcastTransactions) { + return; + } + LOCK2(cs_main, cs_wallet); std::map mapSorted; // Sort pending wallet transactions based on their initial wallet insertion - // order + // order. for (std::pair &item : mapWallet) { const uint256 &wtxid = item.first; CWalletTx &wtx = item.second; assert(wtx.GetId() == wtxid); int nDepth = wtx.GetDepthInMainChain(); if (!wtx.IsCoinBase() && (nDepth == 0 && !wtx.isAbandoned())) { mapSorted.insert(std::make_pair(wtx.nOrderPos, &wtx)); } } - // Try to add wallet transactions to memory pool + // Try to add wallet transactions to memory pool. for (std::pair &item : mapSorted) { CWalletTx &wtx = *(item.second); LOCK(mempool.cs); CValidationState state; wtx.AcceptToMemoryPool(maxTxFee, state); } } bool CWalletTx::RelayWalletTransaction(CConnman *connman) { assert(pwallet->GetBroadcastTransactions()); - if (!IsCoinBase() && !isAbandoned() && GetDepthInMainChain() == 0) { - CValidationState state; - /* GetDepthInMainChain already catches known conflicts. */ - if (InMempool() || AcceptToMemoryPool(maxTxFee, state)) { - LogPrintf("Relaying wtx %s\n", GetId().ToString()); - if (connman) { - CInv inv(MSG_TX, GetId()); - connman->ForEachNode( - [&inv](CNode *pnode) { pnode->PushInventory(inv); }); - return true; - } + if (IsCoinBase() || isAbandoned() || GetDepthInMainChain() != 0) { + return false; + } + + CValidationState state; + // GetDepthInMainChain already catches known conflicts. + if (InMempool() || AcceptToMemoryPool(maxTxFee, state)) { + LogPrintf("Relaying wtx %s\n", GetId().ToString()); + if (connman) { + CInv inv(MSG_TX, GetId()); + connman->ForEachNode( + [&inv](CNode *pnode) { pnode->PushInventory(inv); }); + return true; } } + return false; } -set CWalletTx::GetConflicts() const { - set result; - if (pwallet != NULL) { +std::set CWalletTx::GetConflicts() const { + std::set result; + if (pwallet != nullptr) { uint256 myHash = GetId(); result = pwallet->GetConflicts(myHash); result.erase(myHash); } + return result; } CAmount CWalletTx::GetDebit(const isminefilter &filter) const { if (tx->vin.empty()) return 0; CAmount debit = 0; if (filter & ISMINE_SPENDABLE) { - if (fDebitCached) + if (fDebitCached) { debit += nDebitCached; - else { + } else { nDebitCached = pwallet->GetDebit(*this, ISMINE_SPENDABLE); fDebitCached = true; debit += nDebitCached; } } + if (filter & ISMINE_WATCH_ONLY) { - if (fWatchDebitCached) + if (fWatchDebitCached) { debit += nWatchDebitCached; - else { + } else { nWatchDebitCached = pwallet->GetDebit(*this, ISMINE_WATCH_ONLY); fWatchDebitCached = true; debit += nWatchDebitCached; } } + return debit; } CAmount CWalletTx::GetCredit(const isminefilter &filter) const { // Must wait until coinbase is safely deep enough in the chain before - // valuing it - if (IsCoinBase() && GetBlocksToMaturity() > 0) return 0; + // valuing it. + if (IsCoinBase() && GetBlocksToMaturity() > 0) { + return 0; + } CAmount credit = 0; if (filter & ISMINE_SPENDABLE) { - // GetBalance can assume transactions in mapWallet won't change - if (fCreditCached) + // GetBalance can assume transactions in mapWallet won't change. + if (fCreditCached) { credit += nCreditCached; - else { + } else { nCreditCached = pwallet->GetCredit(*this, ISMINE_SPENDABLE); fCreditCached = true; credit += nCreditCached; } } + if (filter & ISMINE_WATCH_ONLY) { - if (fWatchCreditCached) + if (fWatchCreditCached) { credit += nWatchCreditCached; - else { + } else { nWatchCreditCached = pwallet->GetCredit(*this, ISMINE_WATCH_ONLY); fWatchCreditCached = true; credit += nWatchCreditCached; } } + return credit; } CAmount CWalletTx::GetImmatureCredit(bool fUseCache) const { if (IsCoinBase() && GetBlocksToMaturity() > 0 && IsInMainChain()) { if (fUseCache && fImmatureCreditCached) return nImmatureCreditCached; nImmatureCreditCached = pwallet->GetCredit(*this, ISMINE_SPENDABLE); fImmatureCreditCached = true; return nImmatureCreditCached; } return 0; } CAmount CWalletTx::GetAvailableCredit(bool fUseCache) const { - if (pwallet == 0) return 0; + if (pwallet == 0) { + return 0; + } // Must wait until coinbase is safely deep enough in the chain before - // valuing it - if (IsCoinBase() && GetBlocksToMaturity() > 0) return 0; + // valuing it. + if (IsCoinBase() && GetBlocksToMaturity() > 0) { + return 0; + } - if (fUseCache && fAvailableCreditCached) return nAvailableCreditCached; + if (fUseCache && fAvailableCreditCached) { + return nAvailableCreditCached; + } CAmount nCredit = 0; uint256 hashTx = GetId(); for (unsigned int i = 0; i < tx->vout.size(); i++) { if (!pwallet->IsSpent(hashTx, i)) { const CTxOut &txout = tx->vout[i]; nCredit += pwallet->GetCredit(txout, ISMINE_SPENDABLE); - if (!MoneyRange(nCredit)) + if (!MoneyRange(nCredit)) { throw std::runtime_error( "CWalletTx::GetAvailableCredit() : value out of range"); + } } } nAvailableCreditCached = nCredit; fAvailableCreditCached = true; return nCredit; } CAmount CWalletTx::GetImmatureWatchOnlyCredit(const bool &fUseCache) const { if (IsCoinBase() && GetBlocksToMaturity() > 0 && IsInMainChain()) { - if (fUseCache && fImmatureWatchCreditCached) + if (fUseCache && fImmatureWatchCreditCached) { return nImmatureWatchCreditCached; + } + nImmatureWatchCreditCached = pwallet->GetCredit(*this, ISMINE_WATCH_ONLY); fImmatureWatchCreditCached = true; return nImmatureWatchCreditCached; } return 0; } CAmount CWalletTx::GetAvailableWatchOnlyCredit(const bool &fUseCache) const { - if (pwallet == 0) return 0; + if (pwallet == 0) { + return 0; + } // Must wait until coinbase is safely deep enough in the chain before - // valuing it - if (IsCoinBase() && GetBlocksToMaturity() > 0) return 0; + // valuing it. + if (IsCoinBase() && GetBlocksToMaturity() > 0) { + return 0; + } - if (fUseCache && fAvailableWatchCreditCached) + if (fUseCache && fAvailableWatchCreditCached) { return nAvailableWatchCreditCached; + } CAmount nCredit = 0; for (unsigned int i = 0; i < tx->vout.size(); i++) { if (!pwallet->IsSpent(GetId(), i)) { const CTxOut &txout = tx->vout[i]; nCredit += pwallet->GetCredit(txout, ISMINE_WATCH_ONLY); - if (!MoneyRange(nCredit)) + if (!MoneyRange(nCredit)) { throw std::runtime_error( "CWalletTx::GetAvailableCredit() : value out of range"); + } } } nAvailableWatchCreditCached = nCredit; fAvailableWatchCreditCached = true; return nCredit; } CAmount CWalletTx::GetChange() const { - if (fChangeCached) return nChangeCached; + if (fChangeCached) { + return nChangeCached; + } + nChangeCached = pwallet->GetChange(*this); fChangeCached = true; return nChangeCached; } bool CWalletTx::InMempool() const { LOCK(mempool.cs); if (mempool.exists(GetId())) { return true; } + return false; } bool CWalletTx::IsTrusted() const { // Quick answer in most cases - if (!CheckFinalTx(*this)) return false; + if (!CheckFinalTx(*this)) { + return false; + } + int nDepth = GetDepthInMainChain(); - if (nDepth >= 1) return true; - if (nDepth < 0) return false; + if (nDepth >= 1) { + return true; + } + + if (nDepth < 0) { + return false; + } + // using wtx's cached debit - if (!bSpendZeroConfChange || !IsFromMe(ISMINE_ALL)) return false; + if (!bSpendZeroConfChange || !IsFromMe(ISMINE_ALL)) { + return false; + } // Don't trust unconfirmed transactions from us unless they are in the // mempool. - if (!InMempool()) return false; + 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.hash); - if (parent == NULL) return false; + if (parent == nullptr) { + return false; + } + const CTxOut &parentOut = parent->tx->vout[txin.prevout.n]; - if (pwallet->IsMine(parentOut) != ISMINE_SPENDABLE) return false; + 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 (unsigned int i = 0; i < tx1.vin.size(); i++) + for (unsigned int i = 0; i < tx1.vin.size(); i++) { tx1.vin[i].scriptSig = CScript(); - for (unsigned int i = 0; i < tx2.vin.size(); i++) + } + + for (unsigned int i = 0; i < tx2.vin.size(); i++) { tx2.vin[i].scriptSig = CScript(); + } + return CTransaction(tx1) == CTransaction(tx2); } std::vector CWallet::ResendWalletTransactionsBefore(int64_t nTime, CConnman *connman) { std::vector result; LOCK(cs_wallet); // Sort them in chronological order - multimap mapSorted; + std::multimap mapSorted; for (std::pair &item : mapWallet) { CWalletTx &wtx = item.second; // Don't rebroadcast if newer than nTime: - if (wtx.nTimeReceived > nTime) continue; - mapSorted.insert(make_pair(wtx.nTimeReceived, &wtx)); + if (wtx.nTimeReceived > nTime) { + continue; + } + + mapSorted.insert(std::make_pair(wtx.nTimeReceived, &wtx)); } + for (std::pair &item : mapSorted) { CWalletTx &wtx = *item.second; - if (wtx.RelayWalletTransaction(connman)) result.push_back(wtx.GetId()); + if (wtx.RelayWalletTransaction(connman)) { + result.push_back(wtx.GetId()); + } } + return result; } void CWallet::ResendWalletTransactions(int64_t nBestBlockTime, CConnman *connman) { // Do this infrequently and randomly to avoid giving away that these are our // transactions. - if (GetTime() < nNextResend || !fBroadcastTransactions) return; + if (GetTime() < nNextResend || !fBroadcastTransactions) { + return; + } + bool fFirst = (nNextResend == 0); nNextResend = GetTime() + GetRand(30 * 60); - if (fFirst) return; + if (fFirst) { + return; + } // Only do it if there's been a new block since last time - if (nBestBlockTime < nLastResend) return; + if (nBestBlockTime < nLastResend) { + return; + } + nLastResend = GetTime(); // Rebroadcast unconfirmed txes older than 5 minutes before the last block // was found: std::vector relayed = ResendWalletTransactionsBefore(nBestBlockTime - 5 * 60, connman); - if (!relayed.empty()) + if (!relayed.empty()) { LogPrintf("%s: rebroadcast %u unconfirmed transactions\n", __func__, relayed.size()); + } } /** @} */ // end of mapWallet -/** @defgroup Actions +/** + * @defgroup Actions * * @{ */ CAmount CWallet::GetBalance() const { + LOCK2(cs_main, cs_wallet); + CAmount nTotal = 0; - { - LOCK2(cs_main, cs_wallet); - for (map::const_iterator it = mapWallet.begin(); - it != mapWallet.end(); ++it) { - const CWalletTx *pcoin = &(*it).second; - if (pcoin->IsTrusted()) nTotal += pcoin->GetAvailableCredit(); + for (std::map::const_iterator it = mapWallet.begin(); + it != mapWallet.end(); ++it) { + const CWalletTx *pcoin = &(*it).second; + if (pcoin->IsTrusted()) { + nTotal += pcoin->GetAvailableCredit(); } } return nTotal; } CAmount CWallet::GetUnconfirmedBalance() const { + LOCK2(cs_main, cs_wallet); + CAmount nTotal = 0; - { - LOCK2(cs_main, cs_wallet); - for (map::const_iterator it = mapWallet.begin(); - it != mapWallet.end(); ++it) { - const CWalletTx *pcoin = &(*it).second; - if (!pcoin->IsTrusted() && pcoin->GetDepthInMainChain() == 0 && - pcoin->InMempool()) - nTotal += pcoin->GetAvailableCredit(); + for (std::map::const_iterator it = mapWallet.begin(); + it != mapWallet.end(); ++it) { + const CWalletTx *pcoin = &(*it).second; + if (!pcoin->IsTrusted() && pcoin->GetDepthInMainChain() == 0 && + pcoin->InMempool()) { + nTotal += pcoin->GetAvailableCredit(); } } + return nTotal; } CAmount CWallet::GetImmatureBalance() const { + LOCK2(cs_main, cs_wallet); + CAmount nTotal = 0; - { - LOCK2(cs_main, cs_wallet); - for (map::const_iterator it = mapWallet.begin(); - it != mapWallet.end(); ++it) { - const CWalletTx *pcoin = &(*it).second; - nTotal += pcoin->GetImmatureCredit(); - } + for (std::map::const_iterator it = mapWallet.begin(); + it != mapWallet.end(); ++it) { + const CWalletTx *pcoin = &(*it).second; + nTotal += pcoin->GetImmatureCredit(); } + return nTotal; } CAmount CWallet::GetWatchOnlyBalance() const { + LOCK2(cs_main, cs_wallet); + CAmount nTotal = 0; - { - LOCK2(cs_main, cs_wallet); - for (map::const_iterator it = mapWallet.begin(); - it != mapWallet.end(); ++it) { - const CWalletTx *pcoin = &(*it).second; - if (pcoin->IsTrusted()) - nTotal += pcoin->GetAvailableWatchOnlyCredit(); + for (std::map::const_iterator it = mapWallet.begin(); + it != mapWallet.end(); ++it) { + const CWalletTx *pcoin = &(*it).second; + if (pcoin->IsTrusted()) { + nTotal += pcoin->GetAvailableWatchOnlyCredit(); } } return nTotal; } CAmount CWallet::GetUnconfirmedWatchOnlyBalance() const { + LOCK2(cs_main, cs_wallet); + CAmount nTotal = 0; - { - LOCK2(cs_main, cs_wallet); - for (map::const_iterator it = mapWallet.begin(); - it != mapWallet.end(); ++it) { - const CWalletTx *pcoin = &(*it).second; - if (!pcoin->IsTrusted() && pcoin->GetDepthInMainChain() == 0 && - pcoin->InMempool()) - nTotal += pcoin->GetAvailableWatchOnlyCredit(); + for (std::map::const_iterator it = mapWallet.begin(); + it != mapWallet.end(); ++it) { + const CWalletTx *pcoin = &(*it).second; + if (!pcoin->IsTrusted() && pcoin->GetDepthInMainChain() == 0 && + pcoin->InMempool()) { + nTotal += pcoin->GetAvailableWatchOnlyCredit(); } } + return nTotal; } CAmount CWallet::GetImmatureWatchOnlyBalance() const { + LOCK2(cs_main, cs_wallet); + CAmount nTotal = 0; - { - LOCK2(cs_main, cs_wallet); - for (map::const_iterator it = mapWallet.begin(); - it != mapWallet.end(); ++it) { - const CWalletTx *pcoin = &(*it).second; - nTotal += pcoin->GetImmatureWatchOnlyCredit(); - } + for (std::map::const_iterator it = mapWallet.begin(); + it != mapWallet.end(); ++it) { + const CWalletTx *pcoin = &(*it).second; + nTotal += pcoin->GetImmatureWatchOnlyCredit(); } + return nTotal; } -void CWallet::AvailableCoins(vector &vCoins, bool fOnlyConfirmed, +void CWallet::AvailableCoins(std::vector &vCoins, bool fOnlyConfirmed, const CCoinControl *coinControl, bool fIncludeZeroValue) const { vCoins.clear(); - { - LOCK2(cs_main, cs_wallet); - for (map::const_iterator it = mapWallet.begin(); - it != mapWallet.end(); ++it) { - const uint256 &wtxid = it->first; - const CWalletTx *pcoin = &(*it).second; + LOCK2(cs_main, cs_wallet); + for (std::map::const_iterator it = mapWallet.begin(); + it != mapWallet.end(); ++it) { + const uint256 &wtxid = it->first; + const CWalletTx *pcoin = &(*it).second; - if (!CheckFinalTx(*pcoin)) continue; + if (!CheckFinalTx(*pcoin)) { + continue; + } - if (fOnlyConfirmed && !pcoin->IsTrusted()) continue; + if (fOnlyConfirmed && !pcoin->IsTrusted()) { + continue; + } - if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0) - continue; + if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0) { + continue; + } - int nDepth = pcoin->GetDepthInMainChain(); - 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 && !pcoin->InMempool()) continue; - - // Bitcoin-ABC: Removed check that prevents consideration of coins - // from transactions that are replacing other transactions. This - // check based on pcoin->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 && fOnlyConfirmed && - pcoin->mapValue.count("replaced_by_txid")) { - continue; - } + int nDepth = pcoin->GetDepthInMainChain(); + if (nDepth < 0) { + continue; + } - for (unsigned int i = 0; i < pcoin->tx->vout.size(); i++) { - isminetype mine = IsMine(pcoin->tx->vout[i]); - if (!(IsSpent(wtxid, i)) && mine != ISMINE_NO && - !IsLockedCoin((*it).first, i) && - (pcoin->tx->vout[i].nValue > 0 || fIncludeZeroValue) && - (!coinControl || !coinControl->HasSelected() || - coinControl->fAllowOtherInputs || - coinControl->IsSelected(COutPoint((*it).first, i)))) - vCoins.push_back(COutput( - pcoin, i, nDepth, - ((mine & ISMINE_SPENDABLE) != ISMINE_NO) || - (coinControl && coinControl->fAllowWatchOnly && - (mine & ISMINE_WATCH_SOLVABLE) != ISMINE_NO), - (mine & (ISMINE_SPENDABLE | ISMINE_WATCH_SOLVABLE)) != - ISMINE_NO)); + // 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 && !pcoin->InMempool()) { + continue; + } + + // Bitcoin-ABC: Removed check that prevents consideration of coins from + // transactions that are replacing other transactions. This check based + // on pcoin->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 && fOnlyConfirmed && + pcoin->mapValue.count("replaced_by_txid")) { + continue; + } + + for (unsigned int i = 0; i < pcoin->tx->vout.size(); i++) { + isminetype mine = IsMine(pcoin->tx->vout[i]); + if (!(IsSpent(wtxid, i)) && mine != ISMINE_NO && + !IsLockedCoin((*it).first, i) && + (pcoin->tx->vout[i].nValue > 0 || fIncludeZeroValue) && + (!coinControl || !coinControl->HasSelected() || + coinControl->fAllowOtherInputs || + coinControl->IsSelected(COutPoint((*it).first, i)))) { + vCoins.push_back(COutput( + pcoin, i, nDepth, + ((mine & ISMINE_SPENDABLE) != ISMINE_NO) || + (coinControl && coinControl->fAllowWatchOnly && + (mine & ISMINE_WATCH_SOLVABLE) != ISMINE_NO), + (mine & (ISMINE_SPENDABLE | ISMINE_WATCH_SOLVABLE)) != + ISMINE_NO)); } } } } static void ApproximateBestSubset( - vector>> vValue, + std::vector>> + vValue, const CAmount &nTotalLower, const CAmount &nTargetValue, - vector &vfBest, CAmount &nBest, int iterations = 1000) { - vector vfIncluded; + std::vector &vfBest, CAmount &nBest, int iterations = 1000) { + std::vector vfIncluded; vfBest.assign(vValue.size(), true); nBest = nTotalLower; FastRandomContext insecure_rand; for (int nRep = 0; nRep < iterations && nBest != nTargetValue; nRep++) { vfIncluded.assign(vValue.size(), false); CAmount nTotal = 0; bool fReachedTarget = false; for (int nPass = 0; nPass < 2 && !fReachedTarget; nPass++) { - for (unsigned int i = 0; i < vValue.size(); i++) { + for (size_t i = 0; i < vValue.size(); i++) { // The solver here uses a randomized algorithm, the randomness // serves no real security purpose but is just needed to prevent // degenerate behavior and it is important that the rng is fast. // We do not use a constant random sequence, because there may // be some privacy improvement by making the selection random. if (nPass == 0 ? insecure_rand.rand32() & 1 : !vfIncluded[i]) { nTotal += vValue[i].first; vfIncluded[i] = true; if (nTotal >= nTargetValue) { fReachedTarget = true; if (nTotal < nBest) { nBest = nTotal; vfBest = vfIncluded; } + nTotal -= vValue[i].first; vfIncluded[i] = false; } } } } } } bool CWallet::SelectCoinsMinConf( const CAmount &nTargetValue, const int nConfMine, const int nConfTheirs, - const uint64_t nMaxAncestors, vector vCoins, - set> &setCoinsRet, + const uint64_t nMaxAncestors, std::vector vCoins, + std::set> &setCoinsRet, CAmount &nValueRet) const { setCoinsRet.clear(); nValueRet = 0; // List of values less than target - pair> coinLowestLarger; + std::pair> + coinLowestLarger; coinLowestLarger.first = std::numeric_limits::max(); - coinLowestLarger.second.first = NULL; - vector>> vValue; + coinLowestLarger.second.first = nullptr; + std::vector>> + vValue; CAmount nTotalLower = 0; random_shuffle(vCoins.begin(), vCoins.end(), GetRandInt); for (const COutput &output : vCoins) { - if (!output.fSpendable) continue; + if (!output.fSpendable) { + continue; + } const CWalletTx *pcoin = output.tx; if (output.nDepth < - (pcoin->IsFromMe(ISMINE_ALL) ? nConfMine : nConfTheirs)) + (pcoin->IsFromMe(ISMINE_ALL) ? nConfMine : nConfTheirs)) { continue; + } - if (!mempool.TransactionWithinChainLimit(pcoin->GetId(), nMaxAncestors)) + if (!mempool.TransactionWithinChainLimit(pcoin->GetId(), + nMaxAncestors)) { continue; + } int i = output.i; CAmount n = pcoin->tx->vout[i].nValue; - pair> coin = - make_pair(n, make_pair(pcoin, i)); + std::pair> coin = + std::make_pair(n, std::make_pair(pcoin, i)); if (n == nTargetValue) { setCoinsRet.insert(coin.second); nValueRet += coin.first; return true; } else if (n < nTargetValue + MIN_CHANGE) { vValue.push_back(coin); nTotalLower += n; } else if (n < coinLowestLarger.first) { coinLowestLarger = coin; } } if (nTotalLower == nTargetValue) { for (unsigned int i = 0; i < vValue.size(); ++i) { setCoinsRet.insert(vValue[i].second); nValueRet += vValue[i].first; } + return true; } if (nTotalLower < nTargetValue) { - if (coinLowestLarger.second.first == NULL) return false; + if (coinLowestLarger.second.first == nullptr) { + return false; + } + setCoinsRet.insert(coinLowestLarger.second); nValueRet += coinLowestLarger.first; return true; } // Solve subset sum by stochastic approximation std::sort(vValue.begin(), vValue.end(), CompareValueOnly()); std::reverse(vValue.begin(), vValue.end()); - vector vfBest; + std::vector vfBest; CAmount nBest; ApproximateBestSubset(vValue, nTotalLower, nTargetValue, vfBest, nBest); - if (nBest != nTargetValue && nTotalLower >= nTargetValue + MIN_CHANGE) + if (nBest != nTargetValue && nTotalLower >= nTargetValue + MIN_CHANGE) { ApproximateBestSubset(vValue, nTotalLower, nTargetValue + MIN_CHANGE, vfBest, nBest); + } // If we have a bigger coin and (either the stochastic approximation didn't // find a good solution, or the next bigger coin is closer), return the - // bigger coin + // bigger coin. if (coinLowestLarger.second.first && ((nBest != nTargetValue && nBest < nTargetValue + MIN_CHANGE) || coinLowestLarger.first <= nBest)) { setCoinsRet.insert(coinLowestLarger.second); nValueRet += coinLowestLarger.first; } else { - for (unsigned int i = 0; i < vValue.size(); i++) + for (unsigned int i = 0; i < vValue.size(); i++) { if (vfBest[i]) { setCoinsRet.insert(vValue[i].second); nValueRet += vValue[i].first; } + } LogPrint("selectcoins", "SelectCoins() best subset: "); - for (unsigned int i = 0; i < vValue.size(); i++) - if (vfBest[i]) + for (unsigned int i = 0; i < vValue.size(); i++) { + if (vfBest[i]) { LogPrint("selectcoins", "%s ", FormatMoney(vValue[i].first)); + } + } + LogPrint("selectcoins", "total %s\n", FormatMoney(nBest)); } return true; } bool CWallet::SelectCoins( - const vector &vAvailableCoins, const CAmount &nTargetValue, - set> &setCoinsRet, CAmount &nValueRet, - const CCoinControl *coinControl) const { - vector vCoins(vAvailableCoins); + const std::vector &vAvailableCoins, const CAmount &nTargetValue, + std::set> &setCoinsRet, + CAmount &nValueRet, const CCoinControl *coinControl) const { + std::vector vCoins(vAvailableCoins); // coin control -> return all selected outputs (we want all selected to go - // into the transaction for sure) + // into the transaction for sure). if (coinControl && coinControl->HasSelected() && !coinControl->fAllowOtherInputs) { for (const COutput &out : vCoins) { - if (!out.fSpendable) continue; + if (!out.fSpendable) { + continue; + } + nValueRet += out.tx->tx->vout[out.i].nValue; - setCoinsRet.insert(make_pair(out.tx, out.i)); + setCoinsRet.insert(std::make_pair(out.tx, out.i)); } + return (nValueRet >= nTargetValue); } - // calculate value from preset inputs and store them - set> setPresetCoins; + // Calculate value from preset inputs and store them. + std::set> setPresetCoins; CAmount nValueFromPresetInputs = 0; std::vector vPresetInputs; - if (coinControl) coinControl->ListSelected(vPresetInputs); + if (coinControl) { + coinControl->ListSelected(vPresetInputs); + } + for (const COutPoint &outpoint : vPresetInputs) { - map::const_iterator it = + std::map::const_iterator it = mapWallet.find(outpoint.hash); - if (it != mapWallet.end()) { - const CWalletTx *pcoin = &it->second; - // Clearly invalid input, fail - if (pcoin->tx->vout.size() <= outpoint.n) return false; - nValueFromPresetInputs += pcoin->tx->vout[outpoint.n].nValue; - setPresetCoins.insert(make_pair(pcoin, outpoint.n)); - } else { + if (it == mapWallet.end()) { // TODO: Allow non-wallet inputs return false; } + + const CWalletTx *pcoin = &it->second; + // Clearly invalid input, fail. + if (pcoin->tx->vout.size() <= outpoint.n) { + return false; + } + + nValueFromPresetInputs += pcoin->tx->vout[outpoint.n].nValue; + setPresetCoins.insert(std::make_pair(pcoin, outpoint.n)); } - // remove preset inputs from vCoins - for (vector::iterator it = vCoins.begin(); + // Remove preset inputs from vCoins. + for (std::vector::iterator it = vCoins.begin(); it != vCoins.end() && coinControl && coinControl->HasSelected();) { - if (setPresetCoins.count(make_pair(it->tx, it->i))) + if (setPresetCoins.count(std::make_pair(it->tx, it->i))) { it = vCoins.erase(it); - else + } else { ++it; + } } size_t nMaxChainLength = std::min(GetArg("-limitancestorcount", DEFAULT_ANCESTOR_LIMIT), GetArg("-limitdescendantcount", DEFAULT_DESCENDANT_LIMIT)); bool fRejectLongChains = GetBoolArg("-walletrejectlongchains", DEFAULT_WALLET_REJECT_LONG_CHAINS); bool res = nTargetValue <= nValueFromPresetInputs || SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 1, 6, 0, vCoins, setCoinsRet, nValueRet) || SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 1, 1, 0, vCoins, setCoinsRet, nValueRet) || (bSpendZeroConfChange && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 0, 1, 2, vCoins, setCoinsRet, nValueRet)) || (bSpendZeroConfChange && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 0, 1, std::min((size_t)4, nMaxChainLength / 3), vCoins, setCoinsRet, nValueRet)) || (bSpendZeroConfChange && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 0, 1, nMaxChainLength / 2, vCoins, setCoinsRet, nValueRet)) || (bSpendZeroConfChange && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 0, 1, nMaxChainLength, vCoins, setCoinsRet, nValueRet)) || (bSpendZeroConfChange && !fRejectLongChains && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 0, 1, std::numeric_limits::max(), vCoins, setCoinsRet, nValueRet)); - // because SelectCoinsMinConf clears the setCoinsRet, we now add the - // possible inputs to the coinset + // Because SelectCoinsMinConf clears the setCoinsRet, we now add the + // possible inputs to the coinset. setCoinsRet.insert(setPresetCoins.begin(), setPresetCoins.end()); - // add preset inputs to the total value selected + // Add preset inputs to the total value selected. nValueRet += nValueFromPresetInputs; return res; } bool CWallet::FundTransaction(CMutableTransaction &tx, CAmount &nFeeRet, bool overrideEstimatedFeeRate, const CFeeRate &specificFeeRate, int &nChangePosInOut, std::string &strFailReason, bool includeWatching, bool lockUnspents, const std::set &setSubtractFeeFromOutputs, bool keepReserveKey, const CTxDestination &destChange) { - vector vecSend; + std::vector vecSend; - // Turn the txout set into a CRecipient vector + // 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); } CCoinControl coinControl; coinControl.destChange = destChange; coinControl.fAllowOtherInputs = true; coinControl.fAllowWatchOnly = includeWatching; coinControl.fOverrideFeeRate = overrideEstimatedFeeRate; coinControl.nFeeRate = specificFeeRate; for (const CTxIn &txin : tx.vin) { coinControl.Select(txin.prevout); } CReserveKey reservekey(this); CWalletTx wtx; if (!CreateTransaction(vecSend, wtx, reservekey, nFeeRet, nChangePosInOut, - strFailReason, &coinControl, false)) + strFailReason, &coinControl, false)) { return false; + } - if (nChangePosInOut != -1) + if (nChangePosInOut != -1) { tx.vout.insert(tx.vout.begin() + nChangePosInOut, wtx.tx->vout[nChangePosInOut]); + } // Copy output sizes from new transaction; they may have had the fee - // subtracted from them - for (unsigned int idx = 0; idx < tx.vout.size(); idx++) + // subtracted from them. + for (unsigned int idx = 0; idx < tx.vout.size(); idx++) { tx.vout[idx].nValue = wtx.tx->vout[idx].nValue; + } // Add new txins (keeping original txin scriptSig/order) for (const CTxIn &txin : wtx.tx->vin) { if (!coinControl.IsSelected(txin.prevout)) { tx.vin.push_back(txin); if (lockUnspents) { LOCK2(cs_main, cs_wallet); LockCoin(txin.prevout); } } } - // optionally keep the change output key - if (keepReserveKey) reservekey.KeepKey(); + // Optionally keep the change output key. + if (keepReserveKey) { + reservekey.KeepKey(); + } return true; } -bool CWallet::CreateTransaction(const vector &vecSend, +bool CWallet::CreateTransaction(const std::vector &vecSend, CWalletTx &wtxNew, CReserveKey &reservekey, CAmount &nFeeRet, int &nChangePosInOut, std::string &strFailReason, const CCoinControl *coinControl, bool sign) { CAmount nValue = 0; int nChangePosRequest = nChangePosInOut; unsigned int nSubtractFeeFromAmount = 0; for (const auto &recipient : vecSend) { if (nValue < 0 || recipient.nAmount < 0) { strFailReason = _("Transaction amounts must not be negative"); return false; } + nValue += recipient.nAmount; - if (recipient.fSubtractFeeFromAmount) nSubtractFeeFromAmount++; + if (recipient.fSubtractFeeFromAmount) { + nSubtractFeeFromAmount++; + } } + if (vecSend.empty()) { strFailReason = _("Transaction must have at least one recipient"); return false; } wtxNew.fTimeReceivedIsTxTime = true; wtxNew.BindWallet(this); CMutableTransaction txNew; // 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. txNew.nLockTime = chainActive.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) + if (GetRandInt(10) == 0) { txNew.nLockTime = std::max(0, (int)txNew.nLockTime - GetRandInt(100)); + } assert(txNew.nLockTime <= (unsigned int)chainActive.Height()); assert(txNew.nLockTime < LOCKTIME_THRESHOLD); { - set> setCoins; + std::set> setCoins; LOCK2(cs_main, cs_wallet); - { - std::vector vAvailableCoins; - AvailableCoins(vAvailableCoins, true, coinControl); - - nFeeRet = 0; - // Start with no fee and loop until there is enough fee - while (true) { - nChangePosInOut = nChangePosRequest; - txNew.vin.clear(); - txNew.vout.clear(); - wtxNew.fFromMe = true; - bool fFirst = true; - - CAmount nValueToSelect = nValue; - if (nSubtractFeeFromAmount == 0) nValueToSelect += nFeeRet; - double dPriority = 0; - // vouts to the payees - for (const auto &recipient : vecSend) { - CTxOut txout(recipient.nAmount, recipient.scriptPubKey); - - if (recipient.fSubtractFeeFromAmount) { - // Subtract fee equally from each selected recipient - txout.nValue -= nFeeRet / nSubtractFeeFromAmount; - - // first receiver pays the remainder not divisible by - // output count - if (fFirst) { - fFirst = false; - txout.nValue -= nFeeRet % nSubtractFeeFromAmount; - } - } - if (txout.IsDust(dustRelayFee)) { - if (recipient.fSubtractFeeFromAmount && nFeeRet > 0) { - if (txout.nValue < 0) - strFailReason = _("The transaction amount is " - "too small to pay the fee"); - else - strFailReason = - _("The transaction amount is too small to " - "send after the fee has been deducted"); - } else - strFailReason = _("Transaction amount too small"); - return false; + std::vector vAvailableCoins; + AvailableCoins(vAvailableCoins, true, coinControl); + + nFeeRet = 0; + // Start with no fee and loop until there is enough fee. + while (true) { + nChangePosInOut = nChangePosRequest; + txNew.vin.clear(); + txNew.vout.clear(); + wtxNew.fFromMe = true; + bool fFirst = true; + + CAmount nValueToSelect = nValue; + if (nSubtractFeeFromAmount == 0) { + nValueToSelect += nFeeRet; + } + + double dPriority = 0; + // vouts to the payees + for (const auto &recipient : vecSend) { + CTxOut txout(recipient.nAmount, recipient.scriptPubKey); + + if (recipient.fSubtractFeeFromAmount) { + // Subtract fee equally from each selected recipient. + txout.nValue -= nFeeRet / nSubtractFeeFromAmount; + + // First receiver pays the remainder not divisible by output + // count. + if (fFirst) { + fFirst = false; + txout.nValue -= nFeeRet % nSubtractFeeFromAmount; } - txNew.vout.push_back(txout); } - // Choose coins to use - CAmount nValueIn = 0; - setCoins.clear(); - if (!SelectCoins(vAvailableCoins, nValueToSelect, setCoins, - nValueIn, coinControl)) { - strFailReason = _("Insufficient funds"); + if (txout.IsDust(dustRelayFee)) { + if (recipient.fSubtractFeeFromAmount && nFeeRet > 0) { + if (txout.nValue < 0) { + strFailReason = _("The transaction amount is " + "too small to pay the fee"); + } else { + strFailReason = + _("The transaction amount is too small to " + "send after the fee has been deducted"); + } + } else { + strFailReason = _("Transaction amount too small"); + } + return false; } - for (const auto &pcoin : setCoins) { - CAmount nCredit = - pcoin.first->tx->vout[pcoin.second].nValue; - // The coin age after the next block (depth+1) is used - // instead of the current, reflecting an assumption the user - // would accept a bit more delay for a chance at a free - // transaction. But mempool inputs might still be in the - // mempool, so their age stays 0 - int age = pcoin.first->GetDepthInMainChain(); - assert(age >= 0); - if (age != 0) age += 1; - dPriority += (double)nCredit * age; - } - const CAmount nChange = nValueIn - nValueToSelect; - if (nChange > 0) { - // Fill a vout to ourself - // TODO: pass in scriptChange instead of reservekey so - // change transaction isn't always pay-to-bitcoin-address - CScript scriptChange; - - // coin control: send change to custom address - if (coinControl && - !boost::get(&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 - CPubKey vchPubKey; - bool ret; - ret = reservekey.GetReservedKey(vchPubKey); - if (!ret) { - strFailReason = _("Keypool ran out, please call " - "keypoolrefill first"); - return false; - } + txNew.vout.push_back(txout); + } + + // Choose coins to use. + CAmount nValueIn = 0; + setCoins.clear(); + if (!SelectCoins(vAvailableCoins, nValueToSelect, setCoins, + nValueIn, coinControl)) { + strFailReason = _("Insufficient funds"); + return false; + } - scriptChange = - GetScriptForDestination(vchPubKey.GetID()); + for (const auto &pcoin : setCoins) { + CAmount nCredit = pcoin.first->tx->vout[pcoin.second].nValue; + // The coin age after the next block (depth+1) is used instead + // of the current, reflecting an assumption the user would + // accept a bit more delay for a chance at a free transaction. + // But mempool inputs might still be in the mempool, so their + // age stays 0. + int age = pcoin.first->GetDepthInMainChain(); + assert(age >= 0); + if (age != 0) age += 1; + dPriority += (double)nCredit * age; + } + + const CAmount nChange = nValueIn - nValueToSelect; + if (nChange > 0) { + // Fill a vout to ourself. + // TODO: pass in scriptChange instead of reservekey so change + // transaction isn't always pay-to-bitcoin-address. + CScript scriptChange; + + // Coin control: send change to custom address. + if (coinControl && + !boost::get(&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. + CPubKey vchPubKey; + bool ret; + ret = reservekey.GetReservedKey(vchPubKey); + if (!ret) { + strFailReason = _("Keypool ran out, please call " + "keypoolrefill first"); + return false; } - CTxOut newTxOut(nChange, scriptChange); - - // We do not move dust-change to fees, because the sender - // would end up paying more than requested. This would be - // against the purpose of the all-inclusive feature. So - // instead we raise the change and deduct from the - // recipient. - if (nSubtractFeeFromAmount > 0 && - newTxOut.IsDust(dustRelayFee)) { - CAmount nDust = - newTxOut.GetDustThreshold(dustRelayFee) - - newTxOut.nValue; - // raise change until no more dust - newTxOut.nValue += nDust; - // subtract from first recipient - for (unsigned int i = 0; i < vecSend.size(); i++) { - if (vecSend[i].fSubtractFeeFromAmount) { - txNew.vout[i].nValue -= nDust; - if (txNew.vout[i].IsDust(dustRelayFee)) { - strFailReason = - _("The transaction amount is too small " - "to send after the fee has been " - "deducted"); - return false; - } - break; + scriptChange = GetScriptForDestination(vchPubKey.GetID()); + } + + CTxOut newTxOut(nChange, scriptChange); + + // We do not move dust-change to fees, because the sender would + // end up paying more than requested. This would be against the + // purpose of the all-inclusive feature. So instead we raise the + // change and deduct from the recipient. + if (nSubtractFeeFromAmount > 0 && + newTxOut.IsDust(dustRelayFee)) { + CAmount nDust = newTxOut.GetDustThreshold(dustRelayFee) - + newTxOut.nValue; + // Raise change until no more dust. + newTxOut.nValue += nDust; + // Subtract from first recipient. + for (unsigned int i = 0; i < vecSend.size(); i++) { + if (vecSend[i].fSubtractFeeFromAmount) { + txNew.vout[i].nValue -= nDust; + if (txNew.vout[i].IsDust(dustRelayFee)) { + strFailReason = + _("The transaction amount is too small " + "to send after the fee has been " + "deducted"); + return false; } - } - } - // Never create dust outputs; if we would, just add the dust - // to the fee. - if (newTxOut.IsDust(dustRelayFee)) { - nChangePosInOut = -1; - nFeeRet += nChange; - reservekey.ReturnKey(); - } 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"); - return false; + break; } - - vector::iterator position = - txNew.vout.begin() + nChangePosInOut; - txNew.vout.insert(position, newTxOut); } - } else + } + + // Never create dust outputs; if we would, just add the dust to + // the fee. + if (newTxOut.IsDust(dustRelayFee)) { + nChangePosInOut = -1; + nFeeRet += nChange; reservekey.ReturnKey(); + } 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"); + return false; + } - // Fill vin - // - // Note how the sequence number is set to non-maxint so that the - // nLockTime set above actually works. - for (const auto &coin : setCoins) - txNew.vin.push_back( - CTxIn(coin.first->GetId(), coin.second, CScript(), - std::numeric_limits::max() - 1)); - - // Fill in dummy signatures for fee calculation. - if (!DummySignTx(txNew, setCoins)) { - strFailReason = _("Signing transaction failed"); - return false; + std::vector::iterator position = + txNew.vout.begin() + nChangePosInOut; + txNew.vout.insert(position, newTxOut); } + } else { + reservekey.ReturnKey(); + } - unsigned int nBytes = GetTransactionSize(txNew); + // Fill vin + // + // Note how the sequence number is set to non-maxint so that the + // nLockTime set above actually works. + for (const auto &coin : setCoins) { + txNew.vin.push_back( + CTxIn(coin.first->GetId(), coin.second, CScript(), + std::numeric_limits::max() - 1)); + } - CTransaction txNewConst(txNew); - dPriority = txNewConst.ComputePriority(dPriority, nBytes); + // Fill in dummy signatures for fee calculation. + if (!DummySignTx(txNew, setCoins)) { + strFailReason = _("Signing transaction failed"); + return false; + } - // Remove scriptSigs to eliminate the fee calculation dummy - // signatures - for (auto &vin : txNew.vin) { - vin.scriptSig = CScript(); - } + unsigned int nBytes = GetTransactionSize(txNew); - // Allow to override the default confirmation target over the - // CoinControl instance - int currentConfirmationTarget = nTxConfirmTarget; - if (coinControl && coinControl->nConfirmTarget > 0) - currentConfirmationTarget = coinControl->nConfirmTarget; - - // Can we complete this as a free transaction? - if (fSendFreeTransactions && - nBytes <= MAX_FREE_TRANSACTION_CREATE_SIZE) { - // Not enough fee: enough priority? - double dPriorityNeeded = mempool.estimateSmartPriority( - currentConfirmationTarget); - // Require at least hard-coded AllowFree. - if (dPriority >= dPriorityNeeded && AllowFree(dPriority)) - break; - } + CTransaction txNewConst(txNew); + dPriority = txNewConst.ComputePriority(dPriority, nBytes); - CAmount nFeeNeeded = - GetMinimumFee(nBytes, currentConfirmationTarget, mempool); - if (coinControl && nFeeNeeded > 0 && - coinControl->nMinimumTotalFee > nFeeNeeded) { - nFeeNeeded = coinControl->nMinimumTotalFee; - } - if (coinControl && coinControl->fOverrideFeeRate) - nFeeNeeded = coinControl->nFeeRate.GetFee(nBytes); - - // If we made it here and we aren't even able to meet the relay - // fee on the next pass, give up because we must be at the - // maximum allowed fee. - if (nFeeNeeded < ::minRelayTxFee.GetFee(nBytes)) { - strFailReason = _("Transaction too large for fee policy"); - return false; - } + // Remove scriptSigs to eliminate the fee calculation dummy + // signatures. + for (auto &vin : txNew.vin) { + vin.scriptSig = CScript(); + } - if (nFeeRet >= nFeeNeeded) { - // Reduce fee to only the needed amount if we have change - // output to increase. 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. - // TODO: The case where nSubtractFeeFromAmount > 0 remains - // to be addressed because it requires returning the fee to - // the payees and not the change output. - // TODO: The case where there is no change output remains to - // be addressed so we avoid creating too small an output. - if (nFeeRet > nFeeNeeded && nChangePosInOut != -1 && - nSubtractFeeFromAmount == 0) { - CAmount extraFeePaid = nFeeRet - nFeeNeeded; - vector::iterator change_position = - txNew.vout.begin() + nChangePosInOut; - change_position->nValue += extraFeePaid; - nFeeRet -= extraFeePaid; - } - // Done, enough fee included. + // Allow to override the default confirmation target over the + // CoinControl instance. + int currentConfirmationTarget = nTxConfirmTarget; + if (coinControl && coinControl->nConfirmTarget > 0) { + currentConfirmationTarget = coinControl->nConfirmTarget; + } + + // Can we complete this as a free transaction? + if (fSendFreeTransactions && + nBytes <= MAX_FREE_TRANSACTION_CREATE_SIZE) { + // Not enough fee: enough priority? + double dPriorityNeeded = + mempool.estimateSmartPriority(currentConfirmationTarget); + // Require at least hard-coded AllowFree. + if (dPriority >= dPriorityNeeded && AllowFree(dPriority)) { break; } + } + + CAmount nFeeNeeded = + GetMinimumFee(nBytes, currentConfirmationTarget, mempool); + if (coinControl && nFeeNeeded > 0 && + coinControl->nMinimumTotalFee > nFeeNeeded) { + nFeeNeeded = coinControl->nMinimumTotalFee; + } - // Try to reduce change to include necessary fee - if (nChangePosInOut != -1 && nSubtractFeeFromAmount == 0) { - CAmount additionalFeeNeeded = nFeeNeeded - nFeeRet; - vector::iterator change_position = + if (coinControl && coinControl->fOverrideFeeRate) { + nFeeNeeded = coinControl->nFeeRate.GetFee(nBytes); + } + + // If we made it here and we aren't even able to meet the relay fee + // on the next pass, give up because we must be at the maximum + // allowed fee. + if (nFeeNeeded < ::minRelayTxFee.GetFee(nBytes)) { + strFailReason = _("Transaction too large for fee policy"); + return false; + } + + if (nFeeRet >= nFeeNeeded) { + // Reduce fee to only the needed amount if we have change output + // to increase. 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. + // TODO: The case where nSubtractFeeFromAmount > 0 remains to be + // addressed because it requires returning the fee to the payees + // and not the change output. + // TODO: The case where there is no change output remains to be + // addressed so we avoid creating too small an output. + if (nFeeRet > nFeeNeeded && nChangePosInOut != -1 && + nSubtractFeeFromAmount == 0) { + CAmount extraFeePaid = nFeeRet - nFeeNeeded; + std::vector::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; - } + change_position->nValue += extraFeePaid; + nFeeRet -= extraFeePaid; } - // Include more fee and try again. - nFeeRet = nFeeNeeded; - continue; + // Done, enough fee included. + break; + } + + // Try to reduce change to include necessary fee. + if (nChangePosInOut != -1 && nSubtractFeeFromAmount == 0) { + CAmount additionalFeeNeeded = nFeeNeeded - nFeeRet; + std::vector::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; + } } + + // Include more fee and try again. + nFeeRet = nFeeNeeded; + continue; } if (sign) { CTransaction txNewConst(txNew); int nIn = 0; for (const auto &coin : setCoins) { const CScript &scriptPubKey = coin.first->tx->vout[coin.second].scriptPubKey; SignatureData sigdata; if (!ProduceSignature( TransactionSignatureCreator( this, &txNewConst, nIn, coin.first->tx->vout[coin.second].nValue, SIGHASH_ALL), scriptPubKey, sigdata)) { strFailReason = _("Signing transaction failed"); return false; } else { UpdateTransaction(txNew, nIn, sigdata); } nIn++; } } // Embed the constructed transaction data in wtxNew. wtxNew.SetTx(MakeTransactionRef(std::move(txNew))); - // Limit size + // Limit size. if (GetTransactionSize(wtxNew) >= MAX_STANDARD_TX_SIZE) { strFailReason = _("Transaction too large"); return false; } } if (GetBoolArg("-walletrejectlongchains", DEFAULT_WALLET_REJECT_LONG_CHAINS)) { - // Lastly, ensure this tx will pass the mempool's chain limits + // Lastly, ensure this tx will pass the mempool's chain limits. LockPoints lp; CTxMemPoolEntry entry(wtxNew.tx, 0, 0, 0, 0, 0, false, 0, lp); CTxMemPool::setEntries setAncestors; size_t nLimitAncestors = GetArg("-limitancestorcount", DEFAULT_ANCESTOR_LIMIT); size_t nLimitAncestorSize = GetArg("-limitancestorsize", DEFAULT_ANCESTOR_SIZE_LIMIT) * 1000; size_t nLimitDescendants = GetArg("-limitdescendantcount", DEFAULT_DESCENDANT_LIMIT); size_t nLimitDescendantSize = GetArg("-limitdescendantsize", DEFAULT_DESCENDANT_SIZE_LIMIT) * 1000; std::string errString; if (!mempool.CalculateMemPoolAncestors( entry, setAncestors, nLimitAncestors, nLimitAncestorSize, nLimitDescendants, nLimitDescendantSize, errString)) { strFailReason = _("Transaction has too long of a mempool chain"); return false; } } + return true; } /** * Call after CreateTransaction unless you want to abort */ bool CWallet::CommitTransaction(CWalletTx &wtxNew, CReserveKey &reservekey, CConnman *connman, CValidationState &state) { - { - LOCK2(cs_main, cs_wallet); - LogPrintf("CommitTransaction:\n%s", wtxNew.tx->ToString()); - { - // Take key pair from key pool so it won't be used again - reservekey.KeepKey(); + LOCK2(cs_main, cs_wallet); + LogPrintf("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); + // Take key pair from key pool so it won't be used again. + reservekey.KeepKey(); - // Notify that old coins are spent - for (const CTxIn &txin : wtxNew.tx->vin) { - CWalletTx &coin = mapWallet[txin.prevout.hash]; - coin.BindWallet(this); - NotifyTransactionChanged(this, coin.GetId(), CT_UPDATED); - } - } + // Add tx to wallet, because if it has change it's also ours, otherwise just + // for transaction history. + AddToWallet(wtxNew); - // Track how many getdata requests our transaction gets - mapRequestCount[wtxNew.GetId()] = 0; + // Notify that old coins are spent. + for (const CTxIn &txin : wtxNew.tx->vin) { + CWalletTx &coin = mapWallet[txin.prevout.hash]; + coin.BindWallet(this); + NotifyTransactionChanged(this, coin.GetId(), CT_UPDATED); + } - if (fBroadcastTransactions) { - // Broadcast - if (!wtxNew.AcceptToMemoryPool(maxTxFee, state)) { - LogPrintf("CommitTransaction(): Transaction cannot be " - "broadcast immediately, %s\n", - state.GetRejectReason()); - // TODO: if we expect the failure to be long term or permanent, - // instead delete wtx from the wallet and return failure. - } else { - wtxNew.RelayWalletTransaction(connman); - } + // Track how many getdata requests our transaction gets. + mapRequestCount[wtxNew.GetId()] = 0; + + if (fBroadcastTransactions) { + // Broadcast + if (!wtxNew.AcceptToMemoryPool(maxTxFee, state)) { + LogPrintf("CommitTransaction(): Transaction cannot be " + "broadcast immediately, %s\n", + state.GetRejectReason()); + // TODO: if we expect the failure to be long term or permanent, + // instead delete wtx from the wallet and return failure. + } else { + wtxNew.RelayWalletTransaction(connman); } } + return true; } void CWallet::ListAccountCreditDebit(const std::string &strAccount, std::list &entries) { CWalletDB walletdb(strWalletFile); return walletdb.ListAccountCreditDebit(strAccount, entries); } bool CWallet::AddAccountingEntry(const CAccountingEntry &acentry) { CWalletDB walletdb(strWalletFile); return AddAccountingEntry(acentry, &walletdb); } bool CWallet::AddAccountingEntry(const CAccountingEntry &acentry, CWalletDB *pwalletdb) { - if (!pwalletdb->WriteAccountingEntry_Backend(acentry)) return false; + if (!pwalletdb->WriteAccountingEntry_Backend(acentry)) { + return false; + } laccentries.push_back(acentry); CAccountingEntry &entry = laccentries.back(); - wtxOrdered.insert( - make_pair(entry.nOrderPos, TxPair((CWalletTx *)0, &entry))); + wtxOrdered.insert(std::make_pair(entry.nOrderPos, TxPair(nullptr, &entry))); return true; } CAmount CWallet::GetRequiredFee(unsigned int nTxBytes) { return std::max(minTxFee.GetFee(nTxBytes), ::minRelayTxFee.GetFee(nTxBytes)); } CAmount CWallet::GetMinimumFee(unsigned int nTxBytes, unsigned int nConfirmTarget, const CTxMemPool &pool) { - // payTxFee is the user-set global for desired feerate + // payTxFee is the user-set global for desired feerate. return GetMinimumFee(nTxBytes, nConfirmTarget, pool, payTxFee.GetFee(nTxBytes)); } CAmount CWallet::GetMinimumFee(unsigned int nTxBytes, unsigned int nConfirmTarget, const CTxMemPool &pool, CAmount targetFee) { CAmount nFeeNeeded = targetFee; // User didn't set: use -txconfirmtarget to estimate... if (nFeeNeeded == 0) { int estimateFoundTarget = nConfirmTarget; nFeeNeeded = pool.estimateSmartFee(nConfirmTarget, &estimateFoundTarget) .GetFee(nTxBytes); // ... unless we don't have enough mempool data for estimatefee, then - // use fallbackFee - if (nFeeNeeded == 0) nFeeNeeded = fallbackFee.GetFee(nTxBytes); + // use fallbackFee. + if (nFeeNeeded == 0) { + nFeeNeeded = fallbackFee.GetFee(nTxBytes); + } } - // prevent user from paying a fee below minRelayTxFee or minTxFee + + // Prevent user from paying a fee below minRelayTxFee or minTxFee. nFeeNeeded = std::max(nFeeNeeded, GetRequiredFee(nTxBytes)); - // But always obey the maximum - if (nFeeNeeded > maxTxFee) nFeeNeeded = maxTxFee; + + // But always obey the maximum. + if (nFeeNeeded > maxTxFee) { + nFeeNeeded = maxTxFee; + } + return nFeeNeeded; } DBErrors CWallet::LoadWallet(bool &fFirstRunRet) { - if (!fFileBacked) return DB_LOAD_OK; + if (!fFileBacked) { + return DB_LOAD_OK; + } + fFirstRunRet = false; DBErrors nLoadWalletRet = CWalletDB(strWalletFile, "cr+").LoadWallet(this); if (nLoadWalletRet == DB_NEED_REWRITE) { if (CDB::Rewrite(strWalletFile, "\x04pool")) { LOCK(cs_wallet); setKeyPool.clear(); - // Note: can't top-up keypool here, because wallet is locked. - // User will be prompted to unlock wallet the next operation that + // Note: can't top-up keypool here, because wallet is locked. User + // will be prompted to unlock wallet the next operation that // requires a new key. } } - if (nLoadWalletRet != DB_LOAD_OK) return nLoadWalletRet; + if (nLoadWalletRet != DB_LOAD_OK) { + return nLoadWalletRet; + } + fFirstRunRet = !vchDefaultKey.IsValid(); uiInterface.LoadWallet(this); return DB_LOAD_OK; } -DBErrors CWallet::ZapSelectTx(vector &vHashIn, - vector &vHashOut) { - if (!fFileBacked) return DB_LOAD_OK; +DBErrors CWallet::ZapSelectTx(std::vector &vHashIn, + std::vector &vHashOut) { + if (!fFileBacked) { + return DB_LOAD_OK; + } + DBErrors nZapSelectTxRet = CWalletDB(strWalletFile, "cr+").ZapSelectTx(this, vHashIn, vHashOut); if (nZapSelectTxRet == DB_NEED_REWRITE) { if (CDB::Rewrite(strWalletFile, "\x04pool")) { LOCK(cs_wallet); setKeyPool.clear(); - // Note: can't top-up keypool here, because wallet is locked. - // User will be prompted to unlock wallet the next operation that + // Note: can't top-up keypool here, because wallet is locked. User + // will be prompted to unlock wallet the next operation that // requires a new key. } } - if (nZapSelectTxRet != DB_LOAD_OK) return nZapSelectTxRet; + if (nZapSelectTxRet != DB_LOAD_OK) { + return nZapSelectTxRet; + } MarkDirty(); return DB_LOAD_OK; } DBErrors CWallet::ZapWalletTx(std::vector &vWtx) { - if (!fFileBacked) return DB_LOAD_OK; + if (!fFileBacked) { + return DB_LOAD_OK; + } + DBErrors nZapWalletTxRet = CWalletDB(strWalletFile, "cr+").ZapWalletTx(this, vWtx); if (nZapWalletTxRet == DB_NEED_REWRITE) { if (CDB::Rewrite(strWalletFile, "\x04pool")) { LOCK(cs_wallet); setKeyPool.clear(); - // Note: can't top-up keypool here, because wallet is locked. - // User will be prompted to unlock wallet the next operation that + // Note: can't top-up keypool here, because wallet is locked. User + // will be prompted to unlock wallet the next operation that // requires a new key. } } - if (nZapWalletTxRet != DB_LOAD_OK) return nZapWalletTxRet; + if (nZapWalletTxRet != DB_LOAD_OK) { + return nZapWalletTxRet; + } return DB_LOAD_OK; } bool CWallet::SetAddressBook(const CTxDestination &address, - const string &strName, const string &strPurpose) { + const std::string &strName, + const std::string &strPurpose) { bool fUpdated = false; { // mapAddressBook LOCK(cs_wallet); std::map::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; + // Update purpose only if requested. + if (!strPurpose.empty()) { + mapAddressBook[address].purpose = strPurpose; + } } + NotifyAddressBookChanged(this, address, strName, ::IsMine(*this, address) != ISMINE_NO, strPurpose, (fUpdated ? CT_UPDATED : CT_NEW)); - if (!fFileBacked) return false; + if (!fFileBacked) { + return false; + } + if (!strPurpose.empty() && !CWalletDB(strWalletFile) - .WritePurpose(CBitcoinAddress(address).ToString(), strPurpose)) + .WritePurpose(CBitcoinAddress(address).ToString(), strPurpose)) { return false; + } + return CWalletDB(strWalletFile) .WriteName(CBitcoinAddress(address).ToString(), strName); } bool CWallet::DelAddressBook(const CTxDestination &address) { { // mapAddressBook LOCK(cs_wallet); if (fFileBacked) { - // Delete destdata tuples associated with address + // Delete destdata tuples associated with address. std::string strAddress = CBitcoinAddress(address).ToString(); - for (const std::pair &item : + for (const std::pair &item : mapAddressBook[address].destdata) { CWalletDB(strWalletFile).EraseDestData(strAddress, item.first); } } mapAddressBook.erase(address); } NotifyAddressBookChanged(this, address, "", ::IsMine(*this, address) != ISMINE_NO, "", CT_DELETED); - if (!fFileBacked) return false; + if (!fFileBacked) { + return false; + } + CWalletDB(strWalletFile).ErasePurpose(CBitcoinAddress(address).ToString()); return CWalletDB(strWalletFile) .EraseName(CBitcoinAddress(address).ToString()); } bool CWallet::SetDefaultKey(const CPubKey &vchPubKey) { - if (fFileBacked) { - if (!CWalletDB(strWalletFile).WriteDefaultKey(vchPubKey)) return false; + if (fFileBacked && !CWalletDB(strWalletFile).WriteDefaultKey(vchPubKey)) { + return false; } + vchDefaultKey = vchPubKey; return true; } /** - * Mark old keypool keys as used, and generate all new keys + * Mark old keypool keys as used, and generate all new keys. */ bool CWallet::NewKeyPool() { LOCK(cs_wallet); CWalletDB walletdb(strWalletFile); for (int64_t nIndex : setKeyPool) { walletdb.ErasePool(nIndex); } setKeyPool.clear(); - if (IsLocked()) return false; + if (IsLocked()) { + return false; + } - int64_t nKeys = max(GetArg("-keypool", DEFAULT_KEYPOOL_SIZE), (int64_t)0); + int64_t nKeys = + std::max(GetArg("-keypool", DEFAULT_KEYPOOL_SIZE), int64_t(0)); for (int i = 0; i < nKeys; i++) { int64_t nIndex = i + 1; walletdb.WritePool(nIndex, CKeyPool(GenerateNewKey())); setKeyPool.insert(nIndex); } + LogPrintf("CWallet::NewKeyPool wrote %d new keys\n", nKeys); return true; } bool CWallet::TopUpKeyPool(unsigned int kpSize) { LOCK(cs_wallet); - if (IsLocked()) return false; + if (IsLocked()) { + return false; + } CWalletDB walletdb(strWalletFile); - // Top up key pool + // Top up key pool. unsigned int nTargetSize; - if (kpSize > 0) + if (kpSize > 0) { nTargetSize = kpSize; - else - nTargetSize = max(GetArg("-keypool", DEFAULT_KEYPOOL_SIZE), (int64_t)0); + } else { + nTargetSize = + std::max(GetArg("-keypool", DEFAULT_KEYPOOL_SIZE), int64_t(0)); + } while (setKeyPool.size() < (nTargetSize + 1)) { int64_t nEnd = 1; - if (!setKeyPool.empty()) nEnd = *(--setKeyPool.end()) + 1; - if (!walletdb.WritePool(nEnd, CKeyPool(GenerateNewKey()))) - throw runtime_error(std::string(__func__) + - ": writing generated key failed"); + if (!setKeyPool.empty()) { + nEnd = *(--setKeyPool.end()) + 1; + } + + if (!walletdb.WritePool(nEnd, CKeyPool(GenerateNewKey()))) { + throw std::runtime_error(std::string(__func__) + + ": writing generated key failed"); + } + setKeyPool.insert(nEnd); LogPrintf("keypool added key %d, size=%u\n", nEnd, setKeyPool.size()); } + return true; } void CWallet::ReserveKeyFromKeyPool(int64_t &nIndex, CKeyPool &keypool) { nIndex = -1; keypool.vchPubKey = CPubKey(); - { - LOCK(cs_wallet); - if (!IsLocked()) TopUpKeyPool(); + LOCK(cs_wallet); - // Get the oldest key - if (setKeyPool.empty()) return; + if (!IsLocked()) { + TopUpKeyPool(); + } - CWalletDB walletdb(strWalletFile); + // Get the oldest key. + if (setKeyPool.empty()) { + return; + } - nIndex = *(setKeyPool.begin()); - setKeyPool.erase(setKeyPool.begin()); - if (!walletdb.ReadPool(nIndex, keypool)) - throw runtime_error(std::string(__func__) + ": read failed"); - if (!HaveKey(keypool.vchPubKey.GetID())) - throw runtime_error(std::string(__func__) + - ": unknown key in key pool"); - assert(keypool.vchPubKey.IsValid()); - LogPrintf("keypool reserve %d\n", nIndex); + CWalletDB walletdb(strWalletFile); + + nIndex = *(setKeyPool.begin()); + setKeyPool.erase(setKeyPool.begin()); + if (!walletdb.ReadPool(nIndex, keypool)) { + throw std::runtime_error(std::string(__func__) + ": read failed"); + } + + if (!HaveKey(keypool.vchPubKey.GetID())) { + throw std::runtime_error(std::string(__func__) + + ": unknown key in key pool"); } + + assert(keypool.vchPubKey.IsValid()); + LogPrintf("keypool reserve %d\n", nIndex); } void CWallet::KeepKey(int64_t nIndex) { - // Remove from key pool + // Remove from key pool. if (fFileBacked) { CWalletDB walletdb(strWalletFile); walletdb.ErasePool(nIndex); } + LogPrintf("keypool keep %d\n", nIndex); } void CWallet::ReturnKey(int64_t nIndex) { - // Return to key pool + // Return to key pool. { LOCK(cs_wallet); setKeyPool.insert(nIndex); } + LogPrintf("keypool return %d\n", nIndex); } bool CWallet::GetKeyFromPool(CPubKey &result) { + LOCK(cs_wallet); + int64_t nIndex = 0; CKeyPool keypool; - { - LOCK(cs_wallet); - ReserveKeyFromKeyPool(nIndex, keypool); - if (nIndex == -1) { - if (IsLocked()) return false; - result = GenerateNewKey(); - return true; + + ReserveKeyFromKeyPool(nIndex, keypool); + if (nIndex == -1) { + if (IsLocked()) { + return false; } - KeepKey(nIndex); - result = keypool.vchPubKey; + + result = GenerateNewKey(); + return true; } + + KeepKey(nIndex); + result = keypool.vchPubKey; + return true; } int64_t CWallet::GetOldestKeyPoolTime() { LOCK(cs_wallet); - // if the keypool is empty, return - if (setKeyPool.empty()) return GetTime(); + // If the keypool is empty, return + if (setKeyPool.empty()) { + return GetTime(); + } - // load oldest key from keypool, get time and return + // Load oldest key from keypool, get time and return. CKeyPool keypool; CWalletDB walletdb(strWalletFile); int64_t nIndex = *(setKeyPool.begin()); - if (!walletdb.ReadPool(nIndex, keypool)) - throw runtime_error(std::string(__func__) + - ": read oldest key in keypool failed"); + if (!walletdb.ReadPool(nIndex, keypool)) { + throw std::runtime_error(std::string(__func__) + + ": read oldest key in keypool failed"); + } + assert(keypool.vchPubKey.IsValid()); return keypool.nTime; } std::map CWallet::GetAddressBalances() { - map balances; - - { - LOCK(cs_wallet); - for (std::pair walletEntry : mapWallet) { - CWalletTx *pcoin = &walletEntry.second; + std::map balances; - if (!pcoin->IsTrusted()) continue; + LOCK(cs_wallet); + for (std::pair walletEntry : mapWallet) { + CWalletTx *pcoin = &walletEntry.second; - if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0) - continue; + if (!pcoin->IsTrusted()) { + continue; + } - int nDepth = pcoin->GetDepthInMainChain(); - if (nDepth < (pcoin->IsFromMe(ISMINE_ALL) ? 0 : 1)) continue; + if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0) { + continue; + } - for (unsigned int i = 0; i < pcoin->tx->vout.size(); i++) { - CTxDestination addr; - if (!IsMine(pcoin->tx->vout[i])) continue; - if (!ExtractDestination(pcoin->tx->vout[i].scriptPubKey, addr)) - continue; + int nDepth = pcoin->GetDepthInMainChain(); + if (nDepth < (pcoin->IsFromMe(ISMINE_ALL) ? 0 : 1)) { + continue; + } - CAmount n = IsSpent(walletEntry.first, i) - ? 0 - : pcoin->tx->vout[i].nValue; + for (unsigned int i = 0; i < pcoin->tx->vout.size(); i++) { + CTxDestination addr; + if (!IsMine(pcoin->tx->vout[i])) { + continue; + } - if (!balances.count(addr)) balances[addr] = 0; - balances[addr] += n; + if (!ExtractDestination(pcoin->tx->vout[i].scriptPubKey, addr)) { + continue; } + + CAmount n = + IsSpent(walletEntry.first, i) ? 0 : pcoin->tx->vout[i].nValue; + + if (!balances.count(addr)) balances[addr] = 0; + balances[addr] += n; } } return balances; } -set> CWallet::GetAddressGroupings() { +std::set> CWallet::GetAddressGroupings() { // mapWallet AssertLockHeld(cs_wallet); - set> groupings; - set grouping; + std::set> groupings; + std::set grouping; for (std::pair walletEntry : mapWallet) { CWalletTx *pcoin = &walletEntry.second; if (pcoin->tx->vin.size() > 0) { bool any_mine = false; - // group all input addresses with each other + // Group all input addresses with each other. for (CTxIn txin : pcoin->tx->vin) { CTxDestination address; - /* If this input isn't mine, ignore it */ - if (!IsMine(txin)) continue; + // If this input isn't mine, ignore it. + if (!IsMine(txin)) { + continue; + } + if (!ExtractDestination(mapWallet[txin.prevout.hash] .tx->vout[txin.prevout.n] .scriptPubKey, - address)) + address)) { continue; + } + grouping.insert(address); any_mine = true; } - // group change with input addresses + // Group change with input addresses. if (any_mine) { for (CTxOut txout : pcoin->tx->vout) { if (IsChange(txout)) { CTxDestination txoutAddr; - if (!ExtractDestination(txout.scriptPubKey, txoutAddr)) + if (!ExtractDestination(txout.scriptPubKey, + txoutAddr)) { continue; + } + grouping.insert(txoutAddr); } } } + if (grouping.size() > 0) { groupings.insert(grouping); grouping.clear(); } } - // group lone addrs by themselves + // Group lone addrs by themselves. for (unsigned int i = 0; i < pcoin->tx->vout.size(); i++) if (IsMine(pcoin->tx->vout[i])) { CTxDestination address; if (!ExtractDestination(pcoin->tx->vout[i].scriptPubKey, - address)) + address)) { continue; + } + grouping.insert(address); groupings.insert(grouping); grouping.clear(); } } - // a set of pointers to groups of addresses - set *> uniqueGroupings; - // map addresses to the unique group containing it - map *> setmap; - for (set _grouping : groupings) { - // make a set of all the groups hit by this new group - set *> hits; - map *>::iterator it; + // A set of pointers to groups of addresses. + std::set *> uniqueGroupings; + // Map addresses to the unique group containing it. + std::map *> setmap; + for (std::set _grouping : groupings) { + // Make a set of all the groups hit by this new group. + std::set *> hits; + std::map *>::iterator it; for (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 - set *merged = new set(_grouping); - for (set *hit : hits) { + // Merge all hit groups into a new single group and delete old groups. + std::set *merged = + new std::set(_grouping); + for (std::set *hit : hits) { merged->insert(hit->begin(), hit->end()); uniqueGroupings.erase(hit); delete hit; } uniqueGroupings.insert(merged); - // update setmap + // Update setmap. for (CTxDestination element : *merged) { setmap[element] = merged; } } - set> ret; - for (set *uniqueGrouping : uniqueGroupings) { + std::set> ret; + for (std::set *uniqueGrouping : uniqueGroupings) { ret.insert(*uniqueGrouping); delete uniqueGrouping; } return ret; } CAmount CWallet::GetAccountBalance(const std::string &strAccount, int nMinDepth, const isminefilter &filter) { CWalletDB walletdb(strWalletFile); return GetAccountBalance(walletdb, strAccount, nMinDepth, filter); } CAmount CWallet::GetAccountBalance(CWalletDB &walletdb, const std::string &strAccount, int nMinDepth, const isminefilter &filter) { CAmount nBalance = 0; - // Tally wallet transactions - for (map::iterator it = mapWallet.begin(); + // Tally wallet transactions. + for (std::map::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) { const CWalletTx &wtx = (*it).second; if (!CheckFinalTx(wtx) || wtx.GetBlocksToMaturity() > 0 || - wtx.GetDepthInMainChain() < 0) + wtx.GetDepthInMainChain() < 0) { continue; + } CAmount nReceived, nSent, nFee; wtx.GetAccountAmounts(strAccount, nReceived, nSent, nFee, filter); - if (nReceived != 0 && wtx.GetDepthInMainChain() >= nMinDepth) + if (nReceived != 0 && wtx.GetDepthInMainChain() >= nMinDepth) { nBalance += nReceived; + } + nBalance -= nSent + nFee; } - // Tally internal accounting entries + // Tally internal accounting entries. nBalance += walletdb.GetAccountCreditDebit(strAccount); return nBalance; } std::set CWallet::GetAccountAddresses(const std::string &strAccount) const { LOCK(cs_wallet); - set result; + std::set result; for (const std::pair &item : mapAddressBook) { const CTxDestination &address = item.first; - const string &strName = item.second.name; - if (strName == strAccount) result.insert(address); + const std::string &strName = item.second.name; + if (strName == strAccount) { + result.insert(address); + } } + return result; } bool CReserveKey::GetReservedKey(CPubKey &pubkey) { if (nIndex == -1) { CKeyPool keypool; pwallet->ReserveKeyFromKeyPool(nIndex, keypool); - if (nIndex != -1) + if (nIndex != -1) { vchPubKey = keypool.vchPubKey; - else { + } else { return false; } } + assert(vchPubKey.IsValid()); pubkey = vchPubKey; return true; } void CReserveKey::KeepKey() { - if (nIndex != -1) pwallet->KeepKey(nIndex); + if (nIndex != -1) { + pwallet->KeepKey(nIndex); + } + nIndex = -1; vchPubKey = CPubKey(); } void CReserveKey::ReturnKey() { - if (nIndex != -1) pwallet->ReturnKey(nIndex); + if (nIndex != -1) { + pwallet->ReturnKey(nIndex); + } + nIndex = -1; vchPubKey = CPubKey(); } -void CWallet::GetAllReserveKeys(set &setAddress) const { +void CWallet::GetAllReserveKeys(std::set &setAddress) const { setAddress.clear(); CWalletDB walletdb(strWalletFile); LOCK2(cs_main, cs_wallet); for (const int64_t &id : setKeyPool) { CKeyPool keypool; - if (!walletdb.ReadPool(id, keypool)) - throw runtime_error(std::string(__func__) + ": read failed"); + if (!walletdb.ReadPool(id, keypool)) { + throw std::runtime_error(std::string(__func__) + ": read failed"); + } + assert(keypool.vchPubKey.IsValid()); CKeyID keyID = keypool.vchPubKey.GetID(); - if (!HaveKey(keyID)) - throw runtime_error(std::string(__func__) + - ": unknown key in key pool"); + if (!HaveKey(keyID)) { + throw std::runtime_error(std::string(__func__) + + ": unknown key in key pool"); + } + setAddress.insert(keyID); } } void CWallet::UpdatedTransaction(const uint256 &hashTx) { LOCK(cs_wallet); - // Only notify UI if this transaction is in this wallet - map::const_iterator mi = mapWallet.find(hashTx); - if (mi != mapWallet.end()) + // Only notify UI if this transaction is in this wallet. + std::map::const_iterator mi = mapWallet.find(hashTx); + if (mi != mapWallet.end()) { NotifyTransactionChanged(this, hashTx, CT_UPDATED); + } } void CWallet::GetScriptForMining(boost::shared_ptr &script) { boost::shared_ptr rKey(new CReserveKey(this)); CPubKey pubkey; - if (!rKey->GetReservedKey(pubkey)) return; + if (!rKey->GetReservedKey(pubkey)) { + return; + } script = rKey; script->reserveScript = CScript() << ToByteVector(pubkey) << OP_CHECKSIG; } void CWallet::LockCoin(const COutPoint &output) { // setLockedCoins AssertLockHeld(cs_wallet); setLockedCoins.insert(output); } void CWallet::UnlockCoin(const COutPoint &output) { // setLockedCoins AssertLockHeld(cs_wallet); setLockedCoins.erase(output); } void CWallet::UnlockAllCoins() { // setLockedCoins AssertLockHeld(cs_wallet); setLockedCoins.clear(); } bool CWallet::IsLockedCoin(uint256 hash, unsigned int n) const { // setLockedCoins AssertLockHeld(cs_wallet); COutPoint outpt(hash, n); - return (setLockedCoins.count(outpt) > 0); + return setLockedCoins.count(outpt) > 0; } void CWallet::ListLockedCoins(std::vector &vOutpts) { // setLockedCoins AssertLockHeld(cs_wallet); for (std::set::iterator it = setLockedCoins.begin(); it != setLockedCoins.end(); it++) { COutPoint outpt = (*it); vOutpts.push_back(outpt); } } /** @} */ // end of Actions class CAffectedKeysVisitor : public boost::static_visitor { private: const CKeyStore &keystore; std::vector &vKeys; public: CAffectedKeysVisitor(const CKeyStore &keystoreIn, std::vector &vKeysIn) : keystore(keystoreIn), vKeys(vKeysIn) {} void Process(const CScript &script) { txnouttype type; std::vector vDest; int nRequired; if (ExtractDestinations(script, type, vDest, nRequired)) { for (const CTxDestination &dest : vDest) { boost::apply_visitor(*this, dest); } } } void operator()(const CKeyID &keyId) { - if (keystore.HaveKey(keyId)) vKeys.push_back(keyId); + if (keystore.HaveKey(keyId)) { + vKeys.push_back(keyId); + } } void operator()(const CScriptID &scriptId) { CScript script; - if (keystore.GetCScript(scriptId, script)) Process(script); + if (keystore.GetCScript(scriptId, script)) { + Process(script); + } } void operator()(const CNoDestination &none) {} }; void CWallet::GetKeyBirthTimes( std::map &mapKeyBirth) const { // mapKeyMetadata AssertLockHeld(cs_wallet); mapKeyBirth.clear(); - // get birth times for keys with metadata + // Get birth times for keys with metadata. for (const auto &entry : mapKeyMetadata) { if (entry.second.nCreateTime) { mapKeyBirth[entry.first] = entry.second.nCreateTime; } } - // map in which we'll infer heights of other keys - // the tip can be reorganized; use a 144-block safety margin + // Map in which we'll infer heights of other keys the tip can be + // reorganized; use a 144-block safety margin. CBlockIndex *pindexMax = chainActive[std::max(0, chainActive.Height() - 144)]; std::map mapKeyFirstBlock; std::set setKeys; GetKeys(setKeys); for (const CKeyID &keyid : setKeys) { - if (mapKeyBirth.count(keyid) == 0) mapKeyFirstBlock[keyid] = pindexMax; + if (mapKeyBirth.count(keyid) == 0) { + mapKeyFirstBlock[keyid] = pindexMax; + } } setKeys.clear(); - // if there are no such keys, we're done - if (mapKeyFirstBlock.empty()) return; + // 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 + // Find first block that affects those keys, if there are any left. std::vector vAffected; for (std::map::const_iterator it = mapWallet.begin(); it != mapWallet.end(); it++) { - // iterate over all wallet transactions... + // Iterate over all wallet transactions... const CWalletTx &wtx = (*it).second; BlockMap::const_iterator blit = mapBlockIndex.find(wtx.hashBlock); if (blit != mapBlockIndex.end() && chainActive.Contains(blit->second)) { - // ... which are already in a block + // ... which are already in a block. int nHeight = blit->second->nHeight; for (const CTxOut &txout : wtx.tx->vout) { - // iterate over all their outputs + // Iterate over all their outputs... CAffectedKeysVisitor(*this, vAffected) .Process(txout.scriptPubKey); for (const CKeyID &keyid : vAffected) { - // ... and all their affected keys + // ... and all their affected keys. std::map::iterator rit = mapKeyFirstBlock.find(keyid); if (rit != mapKeyFirstBlock.end() && - nHeight < rit->second->nHeight) + nHeight < rit->second->nHeight) { rit->second = blit->second; + } } vAffected.clear(); } } } - // Extract block timestamps for those keys + // Extract block timestamps for those keys. for (std::map::const_iterator it = mapKeyFirstBlock.begin(); it != mapKeyFirstBlock.end(); it++) { - // block times can be 2h off + // Block times can be 2h off. mapKeyBirth[it->first] = it->second->GetBlockTime() - 7200; } } bool CWallet::AddDestData(const CTxDestination &dest, const std::string &key, const std::string &value) { - if (boost::get(&dest)) return false; + if (boost::get(&dest)) { + return false; + } mapAddressBook[dest].destdata.insert(std::make_pair(key, value)); - if (!fFileBacked) return true; + if (!fFileBacked) { + return true; + } + return CWalletDB(strWalletFile) .WriteDestData(CBitcoinAddress(dest).ToString(), key, value); } bool CWallet::EraseDestData(const CTxDestination &dest, const std::string &key) { - if (!mapAddressBook[dest].destdata.erase(key)) return false; - if (!fFileBacked) return true; + if (!mapAddressBook[dest].destdata.erase(key)) { + return false; + } + + if (!fFileBacked) { + return true; + } + return CWalletDB(strWalletFile) .EraseDestData(CBitcoinAddress(dest).ToString(), key); } bool CWallet::LoadDestData(const CTxDestination &dest, const std::string &key, const std::string &value) { mapAddressBook[dest].destdata.insert(std::make_pair(key, value)); return true; } bool CWallet::GetDestData(const CTxDestination &dest, const std::string &key, std::string *value) const { std::map::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; + if (value) { + *value = j->second; + } + return true; } } + return false; } std::string CWallet::GetWalletHelpString(bool showDebug) { std::string strUsage = HelpMessageGroup(_("Wallet options:")); strUsage += HelpMessageOpt( "-disablewallet", _("Do not load the wallet and disable wallet RPC calls")); strUsage += HelpMessageOpt( "-keypool=", strprintf(_("Set key pool size to (default: %u)"), DEFAULT_KEYPOOL_SIZE)); strUsage += HelpMessageOpt( "-fallbackfee=", strprintf(_("A fee rate (in %s/kB) that will be used when fee " "estimation has insufficient data (default: %s)"), CURRENCY_UNIT, FormatMoney(DEFAULT_FALLBACK_FEE))); strUsage += HelpMessageOpt( "-mintxfee=", strprintf(_("Fees (in %s/kB) smaller than this are considered zero fee " "for transaction creation (default: %s)"), CURRENCY_UNIT, FormatMoney(DEFAULT_TRANSACTION_MINFEE))); strUsage += HelpMessageOpt( "-paytxfee=", strprintf( _("Fee (in %s/kB) to add to transactions you send (default: %s)"), CURRENCY_UNIT, FormatMoney(payTxFee.GetFeePerK()))); strUsage += HelpMessageOpt( "-rescan", _("Rescan the block chain for missing wallet transactions on startup")); strUsage += HelpMessageOpt( "-salvagewallet", _("Attempt to recover private keys from a corrupt wallet on startup")); - if (showDebug) + if (showDebug) { strUsage += HelpMessageOpt( "-sendfreetransactions", strprintf(_("Send transactions as zero-fee transactions if " "possible (default: %u)"), DEFAULT_SEND_FREE_TRANSACTIONS)); + } + strUsage += HelpMessageOpt("-spendzeroconfchange", strprintf(_("Spend unconfirmed change when sending " "transactions (default: %u)"), DEFAULT_SPEND_ZEROCONF_CHANGE)); strUsage += HelpMessageOpt("-txconfirmtarget=", strprintf(_("If paytxfee is not set, include enough fee " "so transactions begin confirmation on " "average within n blocks (default: %u)"), DEFAULT_TX_CONFIRM_TARGET)); strUsage += HelpMessageOpt( "-usehd", _("Use hierarchical deterministic key generation (HD) after BIP32. " "Only has effect during wallet creation/first start") + " " + strprintf(_("(default: %u)"), DEFAULT_USE_HD_WALLET)); strUsage += HelpMessageOpt("-upgradewallet", _("Upgrade wallet to latest format on startup")); strUsage += HelpMessageOpt("-wallet=", _("Specify wallet file (within data directory)") + " " + strprintf(_("(default: %s)"), DEFAULT_WALLET_DAT)); strUsage += HelpMessageOpt( "-walletbroadcast", _("Make the wallet broadcast transactions") + " " + strprintf(_("(default: %u)"), DEFAULT_WALLETBROADCAST)); strUsage += HelpMessageOpt("-walletnotify=", _("Execute command when a wallet transaction " "changes (%s in cmd is replaced by TxID)")); strUsage += HelpMessageOpt( "-zapwallettxes=", _("Delete all wallet transactions and only recover those parts of the " "blockchain through -rescan on startup") + " " + _("(1 = keep tx meta data e.g. account owner and payment " "request information, 2 = drop tx meta data)")); if (showDebug) { strUsage += HelpMessageGroup(_("Wallet debugging/testing options:")); strUsage += HelpMessageOpt( "-dblogsize=", strprintf("Flush wallet database activity from memory to disk log " "every megabytes (default: %u)", DEFAULT_WALLET_DBLOGSIZE)); strUsage += HelpMessageOpt( "-flushwallet", strprintf("Run a thread to flush wallet periodically (default: %u)", DEFAULT_FLUSHWALLET)); strUsage += HelpMessageOpt( "-privdb", strprintf("Sets the DB_PRIVATE flag in the wallet db " "environment (default: %u)", DEFAULT_WALLET_PRIVDB)); strUsage += HelpMessageOpt( "-walletrejectlongchains", strprintf(_("Wallet will not create transactions that violate " "mempool chain limits (default: %u)"), DEFAULT_WALLET_REJECT_LONG_CHAINS)); } return strUsage; } CWallet *CWallet::CreateWalletFromFile(const std::string walletFile) { - // needed to restore wallet transaction meta data after -zapwallettxes + // Needed to restore wallet transaction meta data after -zapwallettxes std::vector vWtx; if (GetBoolArg("-zapwallettxes", false)) { uiInterface.InitMessage(_("Zapping all transactions from wallet...")); CWallet *tempWallet = new CWallet(walletFile); DBErrors nZapWalletRet = tempWallet->ZapWalletTx(vWtx); if (nZapWalletRet != DB_LOAD_OK) { InitError( strprintf(_("Error loading %s: Wallet corrupted"), walletFile)); - return NULL; + return nullptr; } delete tempWallet; - tempWallet = NULL; + tempWallet = nullptr; } uiInterface.InitMessage(_("Loading wallet...")); int64_t nStart = GetTimeMillis(); bool fFirstRun = true; CWallet *walletInstance = new CWallet(walletFile); DBErrors nLoadWalletRet = walletInstance->LoadWallet(fFirstRun); if (nLoadWalletRet != DB_LOAD_OK) { if (nLoadWalletRet == DB_CORRUPT) { InitError( strprintf(_("Error loading %s: Wallet corrupted"), walletFile)); - return NULL; - } else if (nLoadWalletRet == DB_NONCRITICAL_ERROR) { + return nullptr; + } + + if (nLoadWalletRet == DB_NONCRITICAL_ERROR) { InitWarning(strprintf( _("Error reading %s! All keys read correctly, but transaction " "data" " or address book entries might be missing or incorrect."), walletFile)); } else if (nLoadWalletRet == DB_TOO_NEW) { InitError(strprintf( _("Error loading %s: Wallet requires newer version of %s"), walletFile, _(PACKAGE_NAME))); - return NULL; + return nullptr; } else if (nLoadWalletRet == DB_NEED_REWRITE) { InitError(strprintf( _("Wallet needed to be rewritten: restart %s to complete"), _(PACKAGE_NAME))); - return NULL; + return nullptr; } else { InitError(strprintf(_("Error loading %s"), walletFile)); - return NULL; + return nullptr; } } if (GetBoolArg("-upgradewallet", fFirstRun)) { int nMaxVersion = GetArg("-upgradewallet", 0); - // the -upgradewallet without argument case + // The -upgradewallet without argument case if (nMaxVersion == 0) { LogPrintf("Performing wallet upgrade to %i\n", FEATURE_LATEST); nMaxVersion = CLIENT_VERSION; // permanently upgrade the wallet immediately walletInstance->SetMinVersion(FEATURE_LATEST); - } else + } else { LogPrintf("Allowing wallet upgrade up to %i\n", nMaxVersion); + } + if (nMaxVersion < walletInstance->GetVersion()) { InitError(_("Cannot downgrade wallet")); - return NULL; + return nullptr; } + walletInstance->SetMaxVersion(nMaxVersion); } if (fFirstRun) { - // Create new keyUser and set as default key + // Create new keyUser and set as default key. if (GetBoolArg("-usehd", DEFAULT_USE_HD_WALLET) && !walletInstance->IsHDEnabled()) { - // generate a new master key + // Generate a new master key. CPubKey masterPubKey = walletInstance->GenerateNewHDMasterKey(); - if (!walletInstance->SetHDMasterKey(masterPubKey)) + if (!walletInstance->SetHDMasterKey(masterPubKey)) { throw std::runtime_error(std::string(__func__) + ": Storing master key failed"); + } } + CPubKey newDefaultKey; if (walletInstance->GetKeyFromPool(newDefaultKey)) { walletInstance->SetDefaultKey(newDefaultKey); if (!walletInstance->SetAddressBook( walletInstance->vchDefaultKey.GetID(), "", "receive")) { InitError(_("Cannot write default address") += "\n"); - return NULL; + return nullptr; } } walletInstance->SetBestChain(chainActive.GetLocator()); } else if (IsArgSet("-usehd")) { bool useHD = GetBoolArg("-usehd", DEFAULT_USE_HD_WALLET); if (walletInstance->IsHDEnabled() && !useHD) { InitError(strprintf(_("Error loading %s: You can't disable HD on a " "already existing HD wallet"), walletFile)); - return NULL; + return nullptr; } + if (!walletInstance->IsHDEnabled() && useHD) { InitError(strprintf(_("Error loading %s: You can't enable HD on a " "already existing non-HD wallet"), walletFile)); - return NULL; + return nullptr; } } LogPrintf(" wallet %15dms\n", GetTimeMillis() - nStart); RegisterValidationInterface(walletInstance); CBlockIndex *pindexRescan = chainActive.Tip(); - if (GetBoolArg("-rescan", false)) + if (GetBoolArg("-rescan", false)) { pindexRescan = chainActive.Genesis(); - else { + } else { CWalletDB walletdb(walletFile); CBlockLocator locator; - if (walletdb.ReadBestBlock(locator)) + if (walletdb.ReadBestBlock(locator)) { pindexRescan = FindForkInGlobalIndex(chainActive, locator); - else + } else { pindexRescan = chainActive.Genesis(); + } } + if (chainActive.Tip() && chainActive.Tip() != pindexRescan) { // We can't rescan beyond non-pruned blocks, stop and throw an error. // This might happen if a user uses a old wallet within a pruned node or - // if he ran -disablewallet for a longer time, then decided to re-enable + // if he ran -disablewallet for a longer time, then decided to + // re-enable. if (fPruneMode) { CBlockIndex *block = chainActive.Tip(); while (block && block->pprev && (block->pprev->nStatus & BLOCK_HAVE_DATA) && - block->pprev->nTx > 0 && pindexRescan != block) + block->pprev->nTx > 0 && pindexRescan != block) { block = block->pprev; + } if (pindexRescan != block) { InitError(_("Prune: last wallet synchronisation goes beyond " "pruned data. You need to -reindex (download the " "whole blockchain again in case of pruned node)")); - return NULL; + return nullptr; } } uiInterface.InitMessage(_("Rescanning...")); LogPrintf("Rescanning last %i blocks (from block %i)...\n", chainActive.Height() - pindexRescan->nHeight, pindexRescan->nHeight); nStart = GetTimeMillis(); walletInstance->ScanForWalletTransactions(pindexRescan, true); LogPrintf(" rescan %15dms\n", GetTimeMillis() - nStart); walletInstance->SetBestChain(chainActive.GetLocator()); CWalletDB::IncrementUpdateCounter(); // Restore wallet transaction metadata after -zapwallettxes=1 if (GetBoolArg("-zapwallettxes", false) && GetArg("-zapwallettxes", "1") != "2") { CWalletDB walletdb(walletFile); for (const CWalletTx &wtxOld : vWtx) { uint256 txid = wtxOld.GetId(); std::map::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->strFromAccount = copyFrom->strFromAccount; copyTo->nOrderPos = copyFrom->nOrderPos; walletdb.WriteTx(*copyTo); } } } } + walletInstance->SetBroadcastTransactions( GetBoolArg("-walletbroadcast", DEFAULT_WALLETBROADCAST)); - { - LOCK(walletInstance->cs_wallet); - LogPrintf("setKeyPool.size() = %u\n", walletInstance->GetKeyPoolSize()); - LogPrintf("mapWallet.size() = %u\n", walletInstance->mapWallet.size()); - LogPrintf("mapAddressBook.size() = %u\n", - walletInstance->mapAddressBook.size()); - } + LOCK(walletInstance->cs_wallet); + LogPrintf("setKeyPool.size() = %u\n", walletInstance->GetKeyPoolSize()); + LogPrintf("mapWallet.size() = %u\n", walletInstance->mapWallet.size()); + LogPrintf("mapAddressBook.size() = %u\n", + walletInstance->mapAddressBook.size()); return walletInstance; } bool CWallet::InitLoadWallet() { if (GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET)) { - pwalletMain = NULL; + pwalletMain = nullptr; LogPrintf("Wallet disabled!\n"); return true; } std::string walletFile = GetArg("-wallet", DEFAULT_WALLET_DAT); CWallet *const pwallet = CreateWalletFromFile(walletFile); if (!pwallet) { return false; } + pwalletMain = pwallet; return true; } std::atomic CWallet::fFlushThreadRunning(false); void CWallet::postInitProcess(boost::thread_group &threadGroup) { // Add wallet transactions that aren't already in a block to mempool. // Do this here as mempool requires genesis block to be loaded. ReacceptWalletTransactions(); // Run a thread to flush wallet periodically. if (!CWallet::fFlushThreadRunning.exchange(true)) { threadGroup.create_thread(ThreadFlushWalletDB); } } bool CWallet::ParameterInteraction() { - if (GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET)) return true; + if (GetBoolArg("-disablewallet", DEFAULT_DISABLE_WALLET)) { + return true; + } if (GetBoolArg("-blocksonly", DEFAULT_BLOCKSONLY) && SoftSetBoolArg("-walletbroadcast", false)) { LogPrintf("%s: parameter interaction: -blocksonly=1 -> setting " "-walletbroadcast=0\n", __func__); } if (GetBoolArg("-salvagewallet", false) && SoftSetBoolArg("-rescan", true)) { // Rewrite just private keys: rescan to find transactions LogPrintf("%s: parameter interaction: -salvagewallet=1 -> setting " "-rescan=1\n", __func__); } // -zapwallettx implies a rescan if (GetBoolArg("-zapwallettxes", false) && SoftSetBoolArg("-rescan", true)) { LogPrintf("%s: parameter interaction: -zapwallettxes= -> setting " "-rescan=1\n", __func__); } - if (GetBoolArg("-sysperms", false)) + if (GetBoolArg("-sysperms", false)) { return InitError("-sysperms is not allowed in combination with enabled " "wallet functionality"); - if (GetArg("-prune", 0) && GetBoolArg("-rescan", false)) + } + + if (GetArg("-prune", 0) && GetBoolArg("-rescan", false)) { return InitError( _("Rescans are not possible in pruned mode. You will need to use " "-reindex which will download the whole blockchain again.")); + } - if (::minRelayTxFee.GetFeePerK() > HIGH_TX_FEE_PER_KB) + if (::minRelayTxFee.GetFeePerK() > HIGH_TX_FEE_PER_KB) { InitWarning( AmountHighWarn("-minrelaytxfee") + " " + _("The wallet will avoid paying less than the minimum relay fee.")); + } if (IsArgSet("-mintxfee")) { CAmount n = 0; - if (!ParseMoney(GetArg("-mintxfee", ""), n) || 0 == n) + if (!ParseMoney(GetArg("-mintxfee", ""), n) || 0 == n) { return InitError(AmountErrMsg("mintxfee", GetArg("-mintxfee", ""))); - if (n > HIGH_TX_FEE_PER_KB) + } + + if (n > HIGH_TX_FEE_PER_KB) { InitWarning(AmountHighWarn("-mintxfee") + " " + _("This is the minimum transaction fee you pay on " "every transaction.")); + } + CWallet::minTxFee = CFeeRate(n); } + if (IsArgSet("-fallbackfee")) { CAmount nFeePerK = 0; - if (!ParseMoney(GetArg("-fallbackfee", ""), nFeePerK)) + if (!ParseMoney(GetArg("-fallbackfee", ""), nFeePerK)) { return InitError( strprintf(_("Invalid amount for -fallbackfee=: '%s'"), GetArg("-fallbackfee", ""))); - if (nFeePerK > HIGH_TX_FEE_PER_KB) + } + + if (nFeePerK > HIGH_TX_FEE_PER_KB) { InitWarning(AmountHighWarn("-fallbackfee") + " " + _("This is the transaction fee you may pay when fee " "estimates are not available.")); + } + CWallet::fallbackFee = CFeeRate(nFeePerK); } + if (IsArgSet("-paytxfee")) { CAmount nFeePerK = 0; - if (!ParseMoney(GetArg("-paytxfee", ""), nFeePerK)) + if (!ParseMoney(GetArg("-paytxfee", ""), nFeePerK)) { return InitError(AmountErrMsg("paytxfee", GetArg("-paytxfee", ""))); - if (nFeePerK > HIGH_TX_FEE_PER_KB) + } + + if (nFeePerK > HIGH_TX_FEE_PER_KB) { InitWarning(AmountHighWarn("-paytxfee") + " " + _("This is the transaction fee you will pay if you " "send a transaction.")); + } payTxFee = CFeeRate(nFeePerK, 1000); if (payTxFee < ::minRelayTxFee) { return InitError( strprintf(_("Invalid amount for -paytxfee=: '%s' (must " "be at least %s)"), GetArg("-paytxfee", ""), ::minRelayTxFee.ToString())); } } + if (IsArgSet("-maxtxfee")) { CAmount nMaxFee = 0; - if (!ParseMoney(GetArg("-maxtxfee", ""), nMaxFee)) + if (!ParseMoney(GetArg("-maxtxfee", ""), nMaxFee)) { return InitError(AmountErrMsg("maxtxfee", GetArg("-maxtxfee", ""))); - if (nMaxFee > HIGH_MAX_TX_FEE) + } + + if (nMaxFee > HIGH_MAX_TX_FEE) { InitWarning(_("-maxtxfee is set very high! Fees this large could " "be paid on a single transaction.")); + } + maxTxFee = nMaxFee; if (CFeeRate(maxTxFee, 1000) < ::minRelayTxFee) { return InitError( strprintf(_("Invalid amount for -maxtxfee=: '%s' (must " "be at least the minrelay fee of %s to prevent " "stuck transactions)"), GetArg("-maxtxfee", ""), ::minRelayTxFee.ToString())); } } + nTxConfirmTarget = GetArg("-txconfirmtarget", DEFAULT_TX_CONFIRM_TARGET); bSpendZeroConfChange = GetBoolArg("-spendzeroconfchange", DEFAULT_SPEND_ZEROCONF_CHANGE); fSendFreeTransactions = GetBoolArg("-sendfreetransactions", DEFAULT_SEND_FREE_TRANSACTIONS); if (fSendFreeTransactions && - GetArg("-limitfreerelay", DEFAULT_LIMITFREERELAY) <= 0) + GetArg("-limitfreerelay", DEFAULT_LIMITFREERELAY) <= 0) { return InitError("Creation of free transactions with their relay " "disabled is not supported."); + } return true; } bool CWallet::BackupWallet(const std::string &strDest) { - if (!fFileBacked) return false; + if (!fFileBacked) { + return false; + } + while (true) { { LOCK(bitdb.cs_db); if (!bitdb.mapFileUseCount.count(strWalletFile) || bitdb.mapFileUseCount[strWalletFile] == 0) { - // Flush log data to the dat file + // Flush log data to the dat file. bitdb.CloseDb(strWalletFile); bitdb.CheckpointLSN(strWalletFile); bitdb.mapFileUseCount.erase(strWalletFile); - // Copy wallet file + // Copy wallet file. boost::filesystem::path pathSrc = GetDataDir() / strWalletFile; boost::filesystem::path pathDest(strDest); - if (boost::filesystem::is_directory(pathDest)) + if (boost::filesystem::is_directory(pathDest)) { pathDest /= strWalletFile; + } try { #if BOOST_VERSION >= 104000 boost::filesystem::copy_file( pathSrc, pathDest, boost::filesystem::copy_option::overwrite_if_exists); #else boost::filesystem::copy_file(pathSrc, pathDest); #endif LogPrintf("copied %s to %s\n", strWalletFile, pathDest.string()); return true; } catch (const boost::filesystem::filesystem_error &e) { LogPrintf("error copying %s to %s - %s\n", strWalletFile, pathDest.string(), e.what()); return false; } } } + MilliSleep(100); } + return false; } CKeyPool::CKeyPool() { nTime = GetTime(); } CKeyPool::CKeyPool(const CPubKey &vchPubKeyIn) { nTime = GetTime(); vchPubKey = vchPubKeyIn; } CWalletKey::CWalletKey(int64_t nExpires) { nTimeCreated = (nExpires ? GetTime() : 0); nTimeExpires = nExpires; } void CMerkleTx::SetMerkleBranch(const CBlockIndex *pindex, int posInBlock) { // Update the tx's hashBlock hashBlock = pindex->GetBlockHash(); - // set the position of the transaction in the block + // Set the position of the transaction in the block. nIndex = posInBlock; } int CMerkleTx::GetDepthInMainChain(const CBlockIndex *&pindexRet) const { - if (hashUnset()) return 0; + if (hashUnset()) { + return 0; + } AssertLockHeld(cs_main); - // Find the block it claims to be in + // Find the block it claims to be in. BlockMap::iterator mi = mapBlockIndex.find(hashBlock); - if (mi == mapBlockIndex.end()) return 0; + if (mi == mapBlockIndex.end()) { + return 0; + } + CBlockIndex *pindex = (*mi).second; - if (!pindex || !chainActive.Contains(pindex)) return 0; + if (!pindex || !chainActive.Contains(pindex)) { + return 0; + } pindexRet = pindex; return ((nIndex == -1) ? (-1) : 1) * (chainActive.Height() - pindex->nHeight + 1); } int CMerkleTx::GetBlocksToMaturity() const { - if (!IsCoinBase()) return 0; - return max(0, (COINBASE_MATURITY + 1) - GetDepthInMainChain()); + if (!IsCoinBase()) { + return 0; + } + + return std::max(0, (COINBASE_MATURITY + 1) - GetDepthInMainChain()); } bool CMerkleTx::AcceptToMemoryPool(const CAmount &nAbsurdFee, CValidationState &state) { - return ::AcceptToMemoryPool(GetConfig(), mempool, state, tx, true, NULL, - NULL, false, nAbsurdFee); + return ::AcceptToMemoryPool(GetConfig(), mempool, state, tx, true, nullptr, + nullptr, false, nAbsurdFee); } diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h index 20b47a774..e0fd80265 100644 --- a/src/wallet/wallet.h +++ b/src/wallet/wallet.h @@ -1,1118 +1,1139 @@ // 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. #ifndef BITCOIN_WALLET_WALLET_H #define BITCOIN_WALLET_WALLET_H #include "amount.h" #include "script/ismine.h" #include "script/sign.h" #include "streams.h" #include "tinyformat.h" #include "ui_interface.h" #include "utilstrencodings.h" #include "validationinterface.h" #include "wallet/crypter.h" #include "wallet/rpcwallet.h" #include "wallet/walletdb.h" #include #include +#include #include #include #include -#include #include #include #include #include #include extern CWallet *pwalletMain; /** * Settings */ extern CFeeRate payTxFee; extern unsigned int nTxConfirmTarget; extern bool bSpendZeroConfChange; extern bool fSendFreeTransactions; static const unsigned int DEFAULT_KEYPOOL_SIZE = 100; //! -paytxfee default static const CAmount DEFAULT_TRANSACTION_FEE = 0; //! -fallbackfee default static const CAmount DEFAULT_FALLBACK_FEE = 20000; //! -mintxfee default static const CAmount DEFAULT_TRANSACTION_MINFEE = 1000; //! minimum recommended increment for BIP 125 replacement txs static const CAmount WALLET_INCREMENTAL_RELAY_FEE = 5000; //! target minimum change amount static const CAmount MIN_CHANGE = CENT; //! final minimum change amount after paying for fees static const CAmount MIN_FINAL_CHANGE = MIN_CHANGE / 2; //! Default for -spendzeroconfchange static const bool DEFAULT_SPEND_ZEROCONF_CHANGE = true; //! Default for -sendfreetransactions static const bool DEFAULT_SEND_FREE_TRANSACTIONS = false; //! Default for -walletrejectlongchains static const bool DEFAULT_WALLET_REJECT_LONG_CHAINS = false; //! -txconfirmtarget default static const unsigned int DEFAULT_TX_CONFIRM_TARGET = 6; //! Largest (in bytes) free transaction we're willing to create static const unsigned int MAX_FREE_TRANSACTION_CREATE_SIZE = 1000; static const bool DEFAULT_WALLETBROADCAST = true; static const bool DEFAULT_DISABLE_WALLET = false; //! if set, all keys will be derived by using BIP32 static const bool DEFAULT_USE_HD_WALLET = true; extern const char *DEFAULT_WALLET_DAT; class CBlockIndex; class CCoinControl; class COutput; class CReserveKey; class CScript; class CTxMemPool; class CWalletTx; /** (client) version numbers for particular wallet features */ enum WalletFeature { - FEATURE_BASE = 10500, // the earliest version new wallets supports (only - // useful for getinfo's clientversion output) + // the earliest version new wallets supports (only useful for getinfo's + // clientversion output) + FEATURE_BASE = 10500, - FEATURE_WALLETCRYPT = 40000, // wallet encryption - FEATURE_COMPRPUBKEY = 60000, // compressed public keys + // wallet encryption + FEATURE_WALLETCRYPT = 40000, + // compressed public keys + FEATURE_COMPRPUBKEY = 60000, - FEATURE_HD = 130000, // Hierarchical key derivation after BIP32 (HD Wallet) - FEATURE_LATEST = FEATURE_COMPRPUBKEY // HD is optional, use - // FEATURE_COMPRPUBKEY as latest - // version + // Hierarchical key derivation after BIP32 (HD Wallet) + FEATURE_HD = 130000, + + // HD is optional, use FEATURE_COMPRPUBKEY as latest version + FEATURE_LATEST = FEATURE_COMPRPUBKEY, }; /** A key pool entry */ class CKeyPool { public: int64_t nTime; CPubKey vchPubKey; CKeyPool(); CKeyPool(const CPubKey &vchPubKeyIn); ADD_SERIALIZE_METHODS; template inline void SerializationOp(Stream &s, Operation ser_action) { int nVersion = s.GetVersion(); - if (!(s.GetType() & SER_GETHASH)) READWRITE(nVersion); + if (!(s.GetType() & SER_GETHASH)) { + READWRITE(nVersion); + } + READWRITE(nTime); READWRITE(vchPubKey); } }; /** Address book data */ class CAddressBookData { public: std::string name; std::string purpose; CAddressBookData() { purpose = "unknown"; } typedef std::map StringMap; StringMap destdata; }; struct CRecipient { CScript scriptPubKey; CAmount nAmount; bool fSubtractFeeFromAmount; }; typedef std::map mapValue_t; static inline void ReadOrderPos(int64_t &nOrderPos, mapValue_t &mapValue) { if (!mapValue.count("n")) { - nOrderPos = -1; // TODO: calculate elsewhere + // 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; CAmount amount; int vout; }; /** A transaction with a merkle branch linking it to the block chain. */ class CMerkleTx { private: /** Constant used in hashBlock to indicate tx has been abandoned */ static const uint256 ABANDON_HASH; public: CTransactionRef tx; uint256 hashBlock; /** * An nIndex == -1 means that hashBlock (in nonzero) refers to the earliest * block in the chain we know this or any in-wallet dependency conflicts * with. Older clients interpret nIndex == -1 as unconfirmed for backward * compatibility. */ int nIndex; CMerkleTx() { SetTx(MakeTransactionRef()); Init(); } CMerkleTx(CTransactionRef arg) { SetTx(std::move(arg)); Init(); } - /** Helper conversion operator to allow passing CMerkleTx where CTransaction + /** + * Helper conversion operator to allow passing CMerkleTx where CTransaction * is expected. - * TODO: adapt callers and remove this operator. */ + * TODO: adapt callers and remove this operator. + */ operator const CTransaction &() const { return *tx; } void Init() { hashBlock = uint256(); nIndex = -1; } void SetTx(CTransactionRef arg) { tx = std::move(arg); } ADD_SERIALIZE_METHODS; template inline void SerializationOp(Stream &s, Operation ser_action) { // For compatibility with older versions. std::vector vMerkleBranch; READWRITE(tx); READWRITE(hashBlock); READWRITE(vMerkleBranch); READWRITE(nIndex); } void SetMerkleBranch(const CBlockIndex *pIndex, int posInBlock); /** * 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(const CBlockIndex *&pindexRet) const; int GetDepthInMainChain() const { const CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); } bool IsInMainChain() const { const CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet) > 0; } int GetBlocksToMaturity() const; - /** Pass this transaction to the mempool. Fails if absolute fee exceeds - * absurd fee. */ + /** + * Pass this transaction to the mempool. Fails if absolute fee exceeds + * absurd fee. + */ bool AcceptToMemoryPool(const CAmount &nAbsurdFee, CValidationState &state); bool hashUnset() const { return (hashBlock.IsNull() || hashBlock == ABANDON_HASH); } bool isAbandoned() const { return (hashBlock == ABANDON_HASH); } void setAbandoned() { hashBlock = ABANDON_HASH; } const uint256 &GetId() const { return tx->GetId(); } bool IsCoinBase() const { return tx->IsCoinBase(); } }; /** * 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. + * about. It includes any unrecorded transactions needed to link it back to the + * block chain. */ class CWalletTx : public CMerkleTx { private: const CWallet *pwallet; public: mapValue_t mapValue; std::vector> vOrderForm; unsigned int fTimeReceivedIsTxTime; //!< time received by this node unsigned int nTimeReceived; 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. */ char fFromMe; std::string strFromAccount; //!< position in ordered transaction list int64_t nOrderPos; // memory only mutable bool fDebitCached; mutable bool fCreditCached; mutable bool fImmatureCreditCached; mutable bool fAvailableCreditCached; mutable bool fWatchDebitCached; mutable bool fWatchCreditCached; mutable bool fImmatureWatchCreditCached; mutable bool fAvailableWatchCreditCached; mutable bool fChangeCached; mutable CAmount nDebitCached; mutable CAmount nCreditCached; mutable CAmount nImmatureCreditCached; mutable CAmount nAvailableCreditCached; mutable CAmount nWatchDebitCached; mutable CAmount nWatchCreditCached; mutable CAmount nImmatureWatchCreditCached; mutable CAmount nAvailableWatchCreditCached; mutable CAmount nChangeCached; CWalletTx() { Init(NULL); } CWalletTx(const CWallet *pwalletIn, CTransactionRef arg) : CMerkleTx(std::move(arg)) { Init(pwalletIn); } void Init(const CWallet *pwalletIn) { pwallet = pwalletIn; mapValue.clear(); vOrderForm.clear(); fTimeReceivedIsTxTime = false; nTimeReceived = 0; nTimeSmart = 0; fFromMe = false; strFromAccount.clear(); fDebitCached = false; fCreditCached = false; fImmatureCreditCached = false; fAvailableCreditCached = false; fWatchDebitCached = false; fWatchCreditCached = false; fImmatureWatchCreditCached = false; fAvailableWatchCreditCached = false; fChangeCached = false; nDebitCached = 0; nCreditCached = 0; nImmatureCreditCached = 0; nAvailableCreditCached = 0; nWatchDebitCached = 0; nWatchCreditCached = 0; nAvailableWatchCreditCached = 0; nImmatureWatchCreditCached = 0; nChangeCached = 0; nOrderPos = -1; } ADD_SERIALIZE_METHODS; template inline void SerializationOp(Stream &s, Operation ser_action) { if (ser_action.ForRead()) Init(NULL); char fSpent = false; if (!ser_action.ForRead()) { mapValue["fromaccount"] = strFromAccount; WriteOrderPos(nOrderPos, mapValue); if (nTimeSmart) mapValue["timesmart"] = strprintf("%u", nTimeSmart); } READWRITE(*(CMerkleTx *)this); //!< Used to be vtxPrev std::vector vUnused; READWRITE(vUnused); READWRITE(mapValue); READWRITE(vOrderForm); READWRITE(fTimeReceivedIsTxTime); READWRITE(nTimeReceived); READWRITE(fFromMe); READWRITE(fSpent); if (ser_action.ForRead()) { strFromAccount = mapValue["fromaccount"]; ReadOrderPos(nOrderPos, mapValue); nTimeSmart = mapValue.count("timesmart") ? (unsigned int)atoi64(mapValue["timesmart"]) : 0; } mapValue.erase("fromaccount"); mapValue.erase("version"); mapValue.erase("spent"); mapValue.erase("n"); mapValue.erase("timesmart"); } //! make sure balances are recalculated void MarkDirty() { fCreditCached = false; fAvailableCreditCached = false; fImmatureCreditCached = false; fWatchDebitCached = false; fWatchCreditCached = false; fAvailableWatchCreditCached = false; fImmatureWatchCreditCached = false; fDebitCached = false; fChangeCached = false; } void BindWallet(CWallet *pwalletIn) { pwallet = pwalletIn; MarkDirty(); } //! filter decides which addresses will count towards the debit CAmount GetDebit(const isminefilter &filter) const; CAmount GetCredit(const isminefilter &filter) const; CAmount GetImmatureCredit(bool fUseCache = true) const; CAmount GetAvailableCredit(bool fUseCache = true) const; CAmount GetImmatureWatchOnlyCredit(const bool &fUseCache = true) const; CAmount GetAvailableWatchOnlyCredit(const bool &fUseCache = true) const; CAmount GetChange() const; void GetAmounts(std::list &listReceived, std::list &listSent, CAmount &nFee, std::string &strSentAccount, const isminefilter &filter) const; void GetAccountAmounts(const std::string &strAccount, CAmount &nReceived, CAmount &nSent, CAmount &nFee, const isminefilter &filter) const; bool IsFromMe(const isminefilter &filter) const { return (GetDebit(filter) > 0); } // True if only scriptSigs are different bool IsEquivalentTo(const CWalletTx &tx) const; bool InMempool() const; bool IsTrusted() const; int64_t GetTxTime() const; int GetRequestCount() const; bool RelayWalletTransaction(CConnman *connman); std::set GetConflicts() const; }; class COutput { public: const CWalletTx *tx; int i; int nDepth; bool fSpendable; bool fSolvable; COutput(const CWalletTx *txIn, int iIn, int nDepthIn, bool fSpendableIn, bool fSolvableIn) { tx = txIn; i = iIn; nDepth = nDepthIn; fSpendable = fSpendableIn; fSolvable = fSolvableIn; } std::string ToString() const; }; /** Private key that includes an expiration date in case it never gets used. */ class CWalletKey { public: CPrivKey vchPrivKey; int64_t nTimeCreated; int64_t nTimeExpires; std::string strComment; //! todo: add something to note what created it (user, getnewaddress, - //! change) - //! maybe should have a map property map + //! change) maybe should have a map property map CWalletKey(int64_t nExpires = 0); ADD_SERIALIZE_METHODS; template inline void SerializationOp(Stream &s, Operation ser_action) { int nVersion = s.GetVersion(); if (!(s.GetType() & SER_GETHASH)) READWRITE(nVersion); READWRITE(vchPrivKey); READWRITE(nTimeCreated); READWRITE(nTimeExpires); READWRITE(LIMITED_STRING(strComment, 65536)); } }; /** * Internal transfers. * Database key is acentry. */ class CAccountingEntry { public: std::string strAccount; CAmount nCreditDebit; int64_t nTime; std::string strOtherAccount; std::string strComment; mapValue_t mapValue; //!< position in ordered transaction list int64_t nOrderPos; uint64_t nEntryNo; CAccountingEntry() { SetNull(); } void SetNull() { nCreditDebit = 0; nTime = 0; strAccount.clear(); strOtherAccount.clear(); strComment.clear(); nOrderPos = -1; nEntryNo = 0; } ADD_SERIALIZE_METHODS; template inline void SerializationOp(Stream &s, Operation ser_action) { int nVersion = s.GetVersion(); if (!(s.GetType() & SER_GETHASH)) READWRITE(nVersion); //! Note: strAccount is serialized as part of the key, not here. READWRITE(nCreditDebit); READWRITE(nTime); READWRITE(LIMITED_STRING(strOtherAccount, 65536)); if (!ser_action.ForRead()) { WriteOrderPos(nOrderPos, mapValue); if (!(mapValue.empty() && _ssExtra.empty())) { CDataStream ss(s.GetType(), s.GetVersion()); ss.insert(ss.begin(), '\0'); ss << mapValue; ss.insert(ss.end(), _ssExtra.begin(), _ssExtra.end()); strComment.append(ss.str()); } } READWRITE(LIMITED_STRING(strComment, 65536)); size_t nSepPos = strComment.find("\0", 0, 1); if (ser_action.ForRead()) { mapValue.clear(); if (std::string::npos != nSepPos) { CDataStream ss( std::vector(strComment.begin() + nSepPos + 1, strComment.end()), s.GetType(), s.GetVersion()); ss >> mapValue; _ssExtra = std::vector(ss.begin(), ss.end()); } ReadOrderPos(nOrderPos, mapValue); } if (std::string::npos != nSepPos) strComment.erase(nSepPos); mapValue.erase("n"); } private: std::vector _ssExtra; }; /** * A CWallet is an extension of a keystore, which also maintains a set of * transactions and balances, and provides the ability to create new * transactions. */ class CWallet : public CCryptoKeyStore, public CValidationInterface { private: static std::atomic fFlushThreadRunning; /** * 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 &vAvailableCoins, const CAmount &nTargetValue, std::set> &setCoinsRet, CAmount &nValueRet, const CCoinControl *coinControl = NULL) const; CWalletDB *pwalletdbEncryption; //! the current wallet version: clients below this version are not able to //! load the wallet int nWalletVersion; //! the maximum wallet format version: memory-only variable that specifies //! to what version this wallet may be upgraded int nWalletMaxVersion; int64_t nNextResend; int64_t nLastResend; bool fBroadcastTransactions; /** * 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 TxSpends; TxSpends mapTxSpends; void AddToSpends(const COutPoint &outpoint, const uint256 &wtxid); void AddToSpends(const uint256 &wtxid); /* Mark a transaction (and its in-wallet descendants) as conflicting with a * particular block. */ void MarkConflicted(const uint256 &hashBlock, const uint256 &hashTx); void SyncMetaData(std::pair); /* the HD chain data model (external chain counters) */ CHDChain hdChain; bool fFileBacked; std::set setKeyPool; int64_t nTimeFirstKey; /** * Private version of AddWatchOnly method which does not accept a timestamp, * and which will reset the wallet's nTimeFirstKey value to 1 if the watch * key did not previously have a timestamp associated with it. Because this * is an inherited virtual method, it is accessible despite being marked * private, but it is marked private anyway to encourage use of the other * AddWatchOnly which accepts a timestamp and sets nTimeFirstKey more * intelligently for more efficient rescans. */ bool AddWatchOnly(const CScript &dest) override; public: /* * Main wallet lock. * This lock protects all the fields added by CWallet * except for: * fFileBacked (immutable after instantiation) * strWalletFile (immutable after instantiation) */ mutable CCriticalSection cs_wallet; const std::string strWalletFile; void LoadKeyPool(int nIndex, const CKeyPool &keypool) { setKeyPool.insert(nIndex); // If no metadata exists yet, create a default with the pool key's // creation time. Note that this may be overwritten by actually stored // metadata for that key later, which is fine. CKeyID keyid = keypool.vchPubKey.GetID(); if (mapKeyMetadata.count(keyid) == 0) mapKeyMetadata[keyid] = CKeyMetadata(keypool.nTime); } // Map from Key ID (for regular keys) or Script ID (for watch-only keys) to // key metadata. std::map mapKeyMetadata; typedef std::map MasterKeyMap; MasterKeyMap mapMasterKeys; unsigned int nMasterKeyMaxID; CWallet() { SetNull(); } CWallet(const std::string &strWalletFileIn) : strWalletFile(strWalletFileIn) { SetNull(); fFileBacked = true; } ~CWallet() { delete pwalletdbEncryption; pwalletdbEncryption = NULL; } void SetNull() { nWalletVersion = FEATURE_BASE; nWalletMaxVersion = FEATURE_BASE; fFileBacked = false; nMasterKeyMaxID = 0; pwalletdbEncryption = NULL; nOrderPosNext = 0; nNextResend = 0; nLastResend = 0; nTimeFirstKey = 0; fBroadcastTransactions = false; } std::map mapWallet; std::list laccentries; typedef std::pair TxPair; typedef std::multimap TxItems; TxItems wtxOrdered; int64_t nOrderPosNext; std::map mapRequestCount; std::map mapAddressBook; CPubKey vchDefaultKey; std::set setLockedCoins; const CWalletTx *GetWalletTx(const uint256 &hash) const; //! check whether we are allowed to upgrade (or already support) to the //! named feature bool CanSupportFeature(enum WalletFeature wf) { AssertLockHeld(cs_wallet); return nWalletMaxVersion >= wf; } /** * populate vCoins with vector of available COutputs. */ void AvailableCoins(std::vector &vCoins, bool fOnlyConfirmed = true, const CCoinControl *coinControl = NULL, bool fIncludeZeroValue = false) const; /** * 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 CAmount &nTargetValue, int nConfMine, int nConfTheirs, uint64_t nMaxAncestors, std::vector vCoins, std::set> &setCoinsRet, CAmount &nValueRet) const; bool IsSpent(const uint256 &hash, unsigned int n) const; bool IsLockedCoin(uint256 hash, unsigned int n) const; void LockCoin(const COutPoint &output); void UnlockCoin(const COutPoint &output); void UnlockAllCoins(); void ListLockedCoins(std::vector &vOutpts); /** * keystore implementation * Generate a new key */ CPubKey GenerateNewKey(); void DeriveNewChildKey(CKeyMetadata &metadata, CKey &secret); //! Adds a key to the store, and saves it to disk. bool AddKeyPubKey(const CKey &key, const CPubKey &pubkey) override; //! Adds a key to the store, without saving it to disk (used by LoadWallet) bool LoadKey(const CKey &key, const CPubKey &pubkey) { return CCryptoKeyStore::AddKeyPubKey(key, pubkey); } + //! Load metadata (used by LoadWallet) bool LoadKeyMetadata(const CTxDestination &pubKey, const CKeyMetadata &metadata); bool LoadMinVersion(int nVersion) { AssertLockHeld(cs_wallet); nWalletVersion = nVersion; nWalletMaxVersion = std::max(nWalletMaxVersion, nVersion); return true; } void UpdateTimeFirstKey(int64_t nCreateTime); //! Adds an encrypted key to the store, and saves it to disk. bool AddCryptedKey(const CPubKey &vchPubKey, const std::vector &vchCryptedSecret) override; //! Adds an encrypted key to the store, without saving it to disk (used by //! LoadWallet) bool LoadCryptedKey(const CPubKey &vchPubKey, const std::vector &vchCryptedSecret); bool AddCScript(const CScript &redeemScript) override; bool LoadCScript(const CScript &redeemScript); //! 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); //! Erases a destination data tuple in the store and on disk bool EraseDestData(const CTxDestination &dest, const std::string &key); //! Adds a destination data tuple to the store, without saving it to disk bool LoadDestData(const CTxDestination &dest, const std::string &key, const std::string &value); //! 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; //! Adds a watch-only address to the store, and saves it to disk. bool AddWatchOnly(const CScript &dest, int64_t nCreateTime); bool RemoveWatchOnly(const CScript &dest) override; //! Adds a watch-only address to the store, without saving it to disk (used //! by LoadWallet) bool LoadWatchOnly(const CScript &dest); bool Unlock(const SecureString &strWalletPassphrase); bool ChangeWalletPassphrase(const SecureString &strOldWalletPassphrase, const SecureString &strNewWalletPassphrase); bool EncryptWallet(const SecureString &strWalletPassphrase); void GetKeyBirthTimes(std::map &mapKeyBirth) const; /** * Increment the next transaction order id * @return next transaction order id */ int64_t IncOrderPosNext(CWalletDB *pwalletdb = NULL); DBErrors ReorderTransactions(); bool AccountMove(std::string strFrom, std::string strTo, CAmount nAmount, std::string strComment = ""); bool GetAccountPubkey(CPubKey &pubKey, std::string strAccount, bool bForceNew = false); void MarkDirty(); bool AddToWallet(const CWalletTx &wtxIn, bool fFlushOnClose = true); bool LoadToWallet(const CWalletTx &wtxIn); void SyncTransaction(const CTransaction &tx, const CBlockIndex *pindex, int posInBlock) override; bool AddToWalletIfInvolvingMe(const CTransaction &tx, const CBlockIndex *pIndex, int posInBlock, bool fUpdate); CBlockIndex *ScanForWalletTransactions(CBlockIndex *pindexStart, bool fUpdate = false); void ReacceptWalletTransactions(); void ResendWalletTransactions(int64_t nBestBlockTime, CConnman *connman) override; std::vector ResendWalletTransactionsBefore(int64_t nTime, CConnman *connman); CAmount GetBalance() const; CAmount GetUnconfirmedBalance() const; CAmount GetImmatureBalance() const; CAmount GetWatchOnlyBalance() const; CAmount GetUnconfirmedWatchOnlyBalance() const; CAmount GetImmatureWatchOnlyBalance() const; /** * Insert additional inputs into the transaction by calling * CreateTransaction(); */ bool FundTransaction(CMutableTransaction &tx, CAmount &nFeeRet, bool overrideEstimatedFeeRate, const CFeeRate &specificFeeRate, int &nChangePosInOut, std::string &strFailReason, bool includeWatching, bool lockUnspents, const std::set &setSubtractFeeFromOutputs, bool keepReserveKey = true, const CTxDestination &destChange = CNoDestination()); /** * 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(const std::vector &vecSend, CWalletTx &wtxNew, CReserveKey &reservekey, CAmount &nFeeRet, int &nChangePosInOut, std::string &strFailReason, const CCoinControl *coinControl = NULL, bool sign = true); bool CommitTransaction(CWalletTx &wtxNew, CReserveKey &reservekey, CConnman *connman, CValidationState &state); void ListAccountCreditDebit(const std::string &strAccount, std::list &entries); bool AddAccountingEntry(const CAccountingEntry &); bool AddAccountingEntry(const CAccountingEntry &, CWalletDB *pwalletdb); template bool DummySignTx(CMutableTransaction &txNew, const ContainerType &coins); static CFeeRate minTxFee; static CFeeRate fallbackFee; /** * Estimate the minimum fee considering user set parameters and the required * fee */ static CAmount GetMinimumFee(unsigned int nTxBytes, unsigned int nConfirmTarget, const CTxMemPool &pool); /** * Estimate the minimum fee considering required fee and targetFee or if 0 * then fee estimation for nConfirmTarget */ static CAmount GetMinimumFee(unsigned int nTxBytes, unsigned int nConfirmTarget, const CTxMemPool &pool, CAmount targetFee); /** * Return the minimum required fee taking into account the floating relay * fee and user set minimum transaction fee */ static CAmount GetRequiredFee(unsigned int nTxBytes); bool NewKeyPool(); bool TopUpKeyPool(unsigned int kpSize = 0); void ReserveKeyFromKeyPool(int64_t &nIndex, CKeyPool &keypool); void KeepKey(int64_t nIndex); void ReturnKey(int64_t nIndex); bool GetKeyFromPool(CPubKey &key); int64_t GetOldestKeyPoolTime(); void GetAllReserveKeys(std::set &setAddress) const; std::set> GetAddressGroupings(); std::map GetAddressBalances(); CAmount GetAccountBalance(const std::string &strAccount, int nMinDepth, const isminefilter &filter); CAmount GetAccountBalance(CWalletDB &walletdb, const std::string &strAccount, int nMinDepth, const isminefilter &filter); std::set GetAccountAddresses(const std::string &strAccount) const; isminetype IsMine(const CTxIn &txin) const; /** * Returns amount of debit if the input matches the filter, otherwise * returns 0 */ CAmount GetDebit(const CTxIn &txin, const isminefilter &filter) const; isminetype IsMine(const CTxOut &txout) const; CAmount GetCredit(const CTxOut &txout, const isminefilter &filter) const; bool IsChange(const CTxOut &txout) const; CAmount GetChange(const CTxOut &txout) const; bool IsMine(const CTransaction &tx) const; /** should probably be renamed to IsRelevantToMe */ bool IsFromMe(const CTransaction &tx) const; CAmount 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; CAmount GetCredit(const CTransaction &tx, const isminefilter &filter) const; CAmount GetChange(const CTransaction &tx) const; void SetBestChain(const CBlockLocator &loc) override; DBErrors LoadWallet(bool &fFirstRunRet); DBErrors ZapWalletTx(std::vector &vWtx); DBErrors ZapSelectTx(std::vector &vHashIn, std::vector &vHashOut); bool SetAddressBook(const CTxDestination &address, const std::string &strName, const std::string &purpose); bool DelAddressBook(const CTxDestination &address); void UpdatedTransaction(const uint256 &hashTx) override; void Inventory(const uint256 &hash) override { - { - LOCK(cs_wallet); - std::map::iterator mi = mapRequestCount.find(hash); - if (mi != mapRequestCount.end()) (*mi).second++; + LOCK(cs_wallet); + std::map::iterator mi = mapRequestCount.find(hash); + if (mi != mapRequestCount.end()) { + (*mi).second++; } } void GetScriptForMining(boost::shared_ptr &script) override; void ResetRequestCount(const uint256 &hash) override { LOCK(cs_wallet); mapRequestCount[hash] = 0; }; unsigned int GetKeyPoolSize() { // setKeyPool AssertLockHeld(cs_wallet); return setKeyPool.size(); } bool SetDefaultKey(const CPubKey &vchPubKey); //! signify that a particular wallet feature is now used. this may change //! nWalletVersion and nWalletMaxVersion if those are lower bool SetMinVersion(enum WalletFeature, CWalletDB *pwalletdbIn = NULL, bool fExplicit = false); //! 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 GetConflicts(const uint256 &txid) const; //! Check if a given transaction has any of its outputs spent by another //! transaction in the wallet bool HasWalletSpend(const uint256 &txid) const; //! Flush wallet (bitdb flush) void Flush(bool shutdown = false); //! Verify the wallet database and perform salvage if required static bool Verify(); /** * Address book entry changed. * @note called with lock cs_wallet held. */ boost::signals2::signal NotifyAddressBookChanged; /** * Wallet transaction added, removed or updated. * @note called with lock cs_wallet held. */ boost::signals2::signal NotifyTransactionChanged; /** Show progress e.g. for rescan */ boost::signals2::signal ShowProgress; /** Watch-only address added */ boost::signals2::signal NotifyWatchonlyChanged; /** Inquire whether this wallet broadcasts transactions. */ bool GetBroadcastTransactions() const { return fBroadcastTransactions; } /** Set whether this wallet broadcasts transactions. */ void SetBroadcastTransactions(bool broadcast) { fBroadcastTransactions = broadcast; } - /* Mark a transaction (and it in-wallet descendants) as abandoned so its - * inputs may be respent. */ + /** + * Mark a transaction (and it in-wallet descendants) as abandoned so its + * inputs may be respent. + */ bool AbandonTransaction(const uint256 &hashTx); - /** Mark a transaction as replaced by another transaction (e.g., BIP 125). + /** + * Mark a transaction as replaced by another transaction (e.g., BIP 125). */ bool MarkReplaced(const uint256 &originalHash, const uint256 &newHash); /* Returns the wallets help message */ static std::string GetWalletHelpString(bool showDebug); - /* Initializes the wallet, returns a new CWallet instance or a null pointer - * in case of an error */ + /** + * Initializes the wallet, returns a new CWallet instance or a null pointer + * in case of an error. + */ static CWallet *CreateWalletFromFile(const std::string walletFile); static bool InitLoadWallet(); /** * Wallet post-init setup * Gives the wallet a chance to register repetitive tasks and complete * post-init tasks */ void postInitProcess(boost::thread_group &threadGroup); /* Wallets parameter interaction */ static bool ParameterInteraction(); bool BackupWallet(const std::string &strDest); /* Set the HD chain model (chain child index counters) */ bool SetHDChain(const CHDChain &chain, bool memonly); const CHDChain &GetHDChain() { return hdChain; } /* Returns true if HD is enabled */ bool IsHDEnabled(); /* Generates a new HD master key (will not be activated) */ CPubKey GenerateNewHDMasterKey(); /* Set the current HD master key (will reset the chain child index counters) */ bool SetHDMasterKey(const CPubKey &key); }; /** A key allocated from the key pool. */ class CReserveKey : public CReserveScript { protected: CWallet *pwallet; int64_t nIndex; CPubKey vchPubKey; public: CReserveKey(CWallet *pwalletIn) { nIndex = -1; pwallet = pwalletIn; } ~CReserveKey() { ReturnKey(); } void ReturnKey(); bool GetReservedKey(CPubKey &pubkey); void KeepKey(); void KeepScript() { KeepKey(); } }; /** * Account information. * Stored in wallet with key "acc"+string account name. */ class CAccount { public: CPubKey vchPubKey; CAccount() { SetNull(); } void SetNull() { vchPubKey = CPubKey(); } ADD_SERIALIZE_METHODS; template inline void SerializationOp(Stream &s, Operation ser_action) { int nVersion = s.GetVersion(); - if (!(s.GetType() & SER_GETHASH)) READWRITE(nVersion); + if (!(s.GetType() & SER_GETHASH)) { + READWRITE(nVersion); + } + READWRITE(vchPubKey); } }; // Helper for producing a bunch of max-sized low-S signatures (eg 72 bytes) // ContainerType is meant to hold pair, and be iterable so // that each entry corresponds to each vIn, in order. template bool CWallet::DummySignTx(CMutableTransaction &txNew, const ContainerType &coins) { // Fill in dummy signatures for fee calculation. int nIn = 0; for (const auto &coin : coins) { const CScript &scriptPubKey = coin.first->tx->vout[coin.second].scriptPubKey; SignatureData sigdata; if (!ProduceSignature(DummySignatureCreator(this), scriptPubKey, sigdata)) { return false; } else { UpdateTransaction(txNew, nIn, sigdata); } nIn++; } + return true; } #endif // BITCOIN_WALLET_WALLET_H