X-Git-Url: https://git.novaco.in/?a=blobdiff_plain;f=src%2Fwallet.cpp;h=c90b3748bd958ce90f7edf974bdb03850ecab050;hb=fe0b169cd55f903b635a8689c806599f25ea3ae2;hp=beb5d856186664ed5003485a3185c1cfcbeef6b3;hpb=ab0e30c40cc589661ceb4f0d09c9373ecaefc3a9;p=novacoin.git diff --git a/src/wallet.cpp b/src/wallet.cpp index beb5d85..c90b374 100644 --- a/src/wallet.cpp +++ b/src/wallet.cpp @@ -3,6 +3,8 @@ // Distributed under the MIT/X11 software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. +#include + #include "txdb.h" #include "wallet.h" #include "walletdb.h" @@ -11,7 +13,7 @@ #include "base58.h" #include "kernel.h" #include "coincontrol.h" -#include +#include #include "main.h" @@ -23,6 +25,35 @@ extern int64_t nReserveBalance; // mapWallet // +CWallet::CWallet() +{ + SetNull(); +} + +CWallet::CWallet(std::string strWalletFileIn) +{ + SetNull(); + + strWalletFile = strWalletFileIn; + fFileBacked = true; +} + +void CWallet::SetNull() +{ + nWalletVersion = FEATURE_BASE; + nWalletMaxVersion = FEATURE_BASE; + fFileBacked = false; + nMasterKeyMaxID = 0; + pwalletdbEncryption = NULL; + pwalletdbDecryption = NULL; + nNextResend = 0; + nLastResend = 0; + nOrderPosNext = 0; + nKernelsTried = 0; + nCoinDaysTried = 0; + nTimeFirstKey = 0; +} + struct CompareValueOnly { bool operator()(const pair >& t1, @@ -32,6 +63,15 @@ struct CompareValueOnly } }; +const CWalletTx* CWallet::GetWalletTx(const uint256& hash) const +{ + LOCK(cs_wallet); + auto it = mapWallet.find(hash); + if (it == mapWallet.end()) + return NULL; + return &(it->second); +} + CPubKey CWallet::GenerateNewKey() { bool fCompressed = CanSupportFeature(FEATURE_COMPRPUBKEY); // default to compressed public keys if we want 0.6.0 wallets @@ -44,16 +84,16 @@ CPubKey CWallet::GenerateNewKey() if (fCompressed) SetMinVersion(FEATURE_COMPRPUBKEY); - CPubKey pubkey = key.GetPubKey(); + auto pubkey = key.GetPubKey(); // Create new metadata - int64_t nCreationTime = GetTime(); - mapKeyMetadata[pubkey.GetID()] = CKeyMetadata(nCreationTime); + auto nCreationTime = GetTime(); + mapKeyMetadata[CBitcoinAddress(pubkey.GetID())] = CKeyMetadata(nCreationTime); if (!nTimeFirstKey || nCreationTime < nTimeFirstKey) nTimeFirstKey = nCreationTime; if (!AddKey(key)) - throw std::runtime_error("CWallet::GenerateNewKey() : AddKey failed"); + throw runtime_error("CWallet::GenerateNewKey() : AddKey failed"); return key.GetPubKey(); } @@ -69,42 +109,42 @@ CMalleableKeyView CWallet::GenerateNewMalleableKey() const CMalleableKeyView &keyView(mKey); // Create new metadata - int64_t nCreationTime = GetTime(); - mapMalleableKeyMetadata[keyView] = CKeyMetadata(nCreationTime); + auto nCreationTime = GetTime(); + mapKeyMetadata[CBitcoinAddress(keyView.GetMalleablePubKey())] = CKeyMetadata(nCreationTime); if (!nTimeFirstKey || nCreationTime < nTimeFirstKey) nTimeFirstKey = nCreationTime; - if (!AddMalleableKey(mKey)) - throw std::runtime_error("CWallet::GenerateNewMalleableKey() : AddMalleableKey failed"); + if (!AddKey(mKey)) + throw runtime_error("CWallet::GenerateNewMalleableKey() : AddKey failed"); return CMalleableKeyView(mKey); } bool CWallet::AddKey(const CKey& key) { - CPubKey pubkey = key.GetPubKey(); + auto pubkey = key.GetPubKey(); if (!CCryptoKeyStore::AddKey(key)) return false; if (!fFileBacked) return true; if (!IsCrypted()) - return CWalletDB(strWalletFile).WriteKey(pubkey, key.GetPrivKey(), mapKeyMetadata[pubkey.GetID()]); + return CWalletDB(strWalletFile).WriteKey(pubkey, key.GetPrivKey(), mapKeyMetadata[CBitcoinAddress(pubkey.GetID())]); return true; } -bool CWallet::AddMalleableKey(const CMalleableKey& mKey) +bool CWallet::AddKey(const CMalleableKey& mKey) { - CMalleableKeyView keyView = CMalleableKeyView(mKey); - CSecret vchSecretH = mKey.GetSecretH(); + auto keyView = CMalleableKeyView(mKey); + auto vchSecretH = mKey.GetSecretH(); if (!CCryptoKeyStore::AddMalleableKey(keyView, vchSecretH)) return false; if (!fFileBacked) return true; if (!IsCrypted()) - return CWalletDB(strWalletFile).WriteMalleableKey(keyView, vchSecretH, mapMalleableKeyMetadata[keyView]); + return CWalletDB(strWalletFile).WriteMalleableKey(keyView, vchSecretH, mapKeyMetadata[CBitcoinAddress(keyView.GetMalleablePubKey())]); return true; } -bool CWallet::AddCryptedMalleableKey(const CMalleableKeyView& keyView, const std::vector &vchCryptedSecretH) +bool CWallet::AddCryptedMalleableKey(const CMalleableKeyView& keyView, const vector &vchCryptedSecretH) { if (!CCryptoKeyStore::AddCryptedMalleableKey(keyView, vchCryptedSecretH)) return false; @@ -114,10 +154,11 @@ bool CWallet::AddCryptedMalleableKey(const CMalleableKeyView& keyView, const std { LOCK(cs_wallet); + CBitcoinAddress addr(keyView.GetMalleablePubKey()); if (pwalletdbEncryption) - return pwalletdbEncryption->WriteCryptedMalleableKey(keyView, vchCryptedSecretH, mapMalleableKeyMetadata[keyView]); + return pwalletdbEncryption->WriteCryptedMalleableKey(keyView, vchCryptedSecretH, mapKeyMetadata[addr]); else - return CWalletDB(strWalletFile).WriteCryptedMalleableKey(keyView, vchCryptedSecretH, mapMalleableKeyMetadata[keyView]); + return CWalletDB(strWalletFile).WriteCryptedMalleableKey(keyView, vchCryptedSecretH, mapKeyMetadata[addr]); } return true; @@ -138,10 +179,11 @@ bool CWallet::AddCryptedKey(const CPubKey &vchPubKey, const vectorWriteCryptedKey(vchPubKey, vchCryptedSecret, mapKeyMetadata[vchPubKey.GetID()]); + return pwalletdbEncryption->WriteCryptedKey(vchPubKey, vchCryptedSecret, mapKeyMetadata[addr]); else - return CWalletDB(strWalletFile).WriteCryptedKey(vchPubKey, vchCryptedSecret, mapKeyMetadata[vchPubKey.GetID()]); + return CWalletDB(strWalletFile).WriteCryptedKey(vchPubKey, vchCryptedSecret, mapKeyMetadata[addr]); } return false; } @@ -151,16 +193,23 @@ bool CWallet::LoadKeyMetadata(const CPubKey &pubkey, const CKeyMetadata &meta) if (meta.nCreateTime && (!nTimeFirstKey || meta.nCreateTime < nTimeFirstKey)) nTimeFirstKey = meta.nCreateTime; - mapKeyMetadata[pubkey.GetID()] = meta; + mapKeyMetadata[CBitcoinAddress(pubkey.GetID())] = meta; return true; } -bool CWallet::LoadMalleableKeyMetadata(const CMalleableKeyView &keyView, const CKeyMetadata &metadata) +bool CWallet::LoadKeyMetadata(const CMalleableKeyView &keyView, const CKeyMetadata &metadata) { if (metadata.nCreateTime && (!nTimeFirstKey || metadata.nCreateTime < nTimeFirstKey)) nTimeFirstKey = metadata.nCreateTime; - mapMalleableKeyMetadata[keyView] = metadata; + mapKeyMetadata[CBitcoinAddress(keyView.GetMalleablePubKey())] = metadata; + return true; +} + +bool CWallet::LoadMinVersion(int nVersion) +{ + nWalletVersion = nVersion; + nWalletMaxVersion = max(nWalletMaxVersion, nVersion); return true; } @@ -180,7 +229,7 @@ bool CWallet::LoadCScript(const CScript& redeemScript) * these. Do not add them to the wallet and warn. */ if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE) { - std::string strAddr = CBitcoinAddress(redeemScript.GetID()).ToString(); + auto strAddr = CBitcoinAddress(CScriptID(redeemScript)).ToString(); printf("LoadCScript() : Warning: This wallet contains a redeemScript of size %" PRIszu " which exceeds maximum size %i thus can never be redeemed. Do not use address %s.\n", redeemScript.size(), MAX_SCRIPT_ELEMENT_SIZE, strAddr.c_str()); return true; @@ -234,7 +283,7 @@ bool CWallet::Unlock(const SecureString& strWalletPassphrase) { LOCK(cs_wallet); - BOOST_FOREACH(const MasterKeyMap::value_type& pMasterKey, mapMasterKeys) + for(const auto& pMasterKey : mapMasterKeys) { if(!crypter.SetKeyFromPassphrase(strWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod)) return false; @@ -257,7 +306,7 @@ bool CWallet::ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, CCrypter crypter; CKeyingMaterial vMasterKey; - BOOST_FOREACH(MasterKeyMap::value_type& pMasterKey, mapMasterKeys) + for(auto& pMasterKey : mapMasterKeys) { if(!crypter.SetKeyFromPassphrase(strOldWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod)) return false; @@ -265,7 +314,7 @@ bool CWallet::ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, return false; if (CCryptoKeyStore::Unlock(vMasterKey)) { - int64_t nStartTime = GetTimeMillis(); + auto nStartTime = GetTimeMillis(); crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod); double nFirstMultiplier = 1e2 / (GetTimeMillis() - nStartTime); pMasterKey.second.nDeriveIterations = (uint32_t)(pMasterKey.second.nDeriveIterations *nFirstMultiplier); @@ -368,9 +417,9 @@ bool CWallet::EncryptWallet(const SecureString& strWalletPassphrase) RAND_bytes(&kMasterKey.vchSalt[0], WALLET_CRYPTO_SALT_SIZE); CCrypter crypter; - int64_t nStartTime = GetTimeMillis(); + auto nStartTime = GetTimeMillis(); crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, 25000, kMasterKey.nDerivationMethod); - int64_t nDivider = GetTimeMillis() - nStartTime; + auto nDivider = GetTimeMillis() - nStartTime; kMasterKey.nDeriveIterations = (uint32_t)(25e5 / (double)(nDivider)); nStartTime = GetTimeMillis(); @@ -443,7 +492,7 @@ bool CWallet::DecryptWallet(const SecureString& strWalletPassphrase) { LOCK(cs_wallet); - BOOST_FOREACH(const MasterKeyMap::value_type& pMasterKey, mapMasterKeys) + for(const auto& pMasterKey : mapMasterKeys) { if(!crypter.SetKeyFromPassphrase(strWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod)) return false; @@ -470,28 +519,28 @@ bool CWallet::DecryptWallet(const SecureString& strWalletPassphrase) if (fFileBacked) { // Overwrite crypted keys - KeyMap::const_iterator mi = mapKeys.begin(); + auto mi = mapKeys.begin(); while (mi != mapKeys.end()) { CKey key; key.SetSecret((*mi).second.first, (*mi).second.second); pwalletdbDecryption->EraseCryptedKey(key.GetPubKey()); - pwalletdbDecryption->WriteKey(key.GetPubKey(), key.GetPrivKey(), mapKeyMetadata[(*mi).first]); + pwalletdbDecryption->WriteKey(key.GetPubKey(), key.GetPrivKey(), mapKeyMetadata[CBitcoinAddress(mi->first)]); mi++; } - MalleableKeyMap::const_iterator mi2 = mapMalleableKeys.begin(); + auto mi2 = mapMalleableKeys.begin(); while (mi2 != mapMalleableKeys.end()) { - const CSecret &vchSecretH = mi2->second; - const CMalleableKeyView &keyView = mi2->first; + const auto &vchSecretH = mi2->second; + const auto &keyView = mi2->first; pwalletdbDecryption->EraseCryptedMalleableKey(keyView); - pwalletdbDecryption->WriteMalleableKey(keyView, vchSecretH, mapMalleableKeyMetadata[keyView]); + pwalletdbDecryption->WriteMalleableKey(keyView, vchSecretH, mapKeyMetadata[CBitcoinAddress(keyView.GetMalleablePubKey())]); mi2++; } // Erase master keys - MasterKeyMap::const_iterator mk = mapMasterKeys.begin(); + auto mk = mapMasterKeys.begin(); while (mk != mapMasterKeys.end()) { pwalletdbDecryption->EraseMasterKey((*mk).first); @@ -514,6 +563,19 @@ bool CWallet::DecryptWallet(const SecureString& strWalletPassphrase) return true; } +bool CWallet::GetPEM(const CKeyID &keyID, const string &fileName, const SecureString &strPassKey) const +{ + BIO *pemOut = BIO_new_file(fileName.c_str(), "w"); + if (pemOut == NULL) + return error("GetPEM() : failed to create file %s\n", fileName.c_str()); + CKey key; + if (!GetKey(keyID, key)) + return error("GetPEM() : failed to get key for address=%s\n", CBitcoinAddress(keyID).ToString().c_str()); + bool result = key.WritePEM(pemOut, strPassKey); + BIO_free(pemOut); + return result; +} + int64_t CWallet::IncOrderPosNext(CWalletDB *pwalletdb) { int64_t nRet = nOrderPosNext++; @@ -525,7 +587,7 @@ int64_t CWallet::IncOrderPosNext(CWalletDB *pwalletdb) return nRet; } -CWallet::TxItems CWallet::OrderedTxItems(std::list& acentries, std::string strAccount) +CWallet::TxItems CWallet::OrderedTxItems(list& acentries, string strAccount) { CWalletDB walletdb(strWalletFile); @@ -534,16 +596,16 @@ CWallet::TxItems CWallet::OrderedTxItems(std::list& acentries, // Note: maintaining indices in the database of (account,time) --> txid and (account, time) --> acentry // would make this much faster for applications that do this a lot. - for (map::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) + for (auto it = mapWallet.begin(); it != mapWallet.end(); ++it) { CWalletTx* wtx = &((*it).second); - txOrdered.insert(make_pair(wtx->nOrderPos, TxPair(wtx, (CAccountingEntry*)0))); + txOrdered.insert({ wtx->nOrderPos, { wtx, (CAccountingEntry*)0 } }); } acentries.clear(); walletdb.ListAccountCreditDebit(strAccount, acentries); - BOOST_FOREACH(CAccountingEntry& entry, acentries) + for(auto& entry : acentries) { - txOrdered.insert(make_pair(entry.nOrderPos, TxPair((CWalletTx*)0, &entry))); + txOrdered.insert({ entry.nOrderPos, { (CWalletTx*)0, &entry } }); } return txOrdered; @@ -556,12 +618,12 @@ void CWallet::WalletUpdateSpent(const CTransaction &tx, bool fBlock) // restored from backup or the user making copies of wallet.dat. { LOCK(cs_wallet); - BOOST_FOREACH(const CTxIn& txin, tx.vin) + for(const auto& txin : tx.vin) { - map::iterator mi = mapWallet.find(txin.prevout.hash); + auto mi = mapWallet.find(txin.prevout.hash); if (mi != mapWallet.end()) { - CWalletTx& wtx = (*mi).second; + auto& wtx = (*mi).second; if (txin.prevout.n >= wtx.vout.size()) printf("WalletUpdateSpent: bad wtx %s\n", wtx.GetHash().ToString().c_str()); else if (!wtx.IsSpent(txin.prevout.n) && IsMine(wtx.vout[txin.prevout.n])) @@ -577,11 +639,11 @@ void CWallet::WalletUpdateSpent(const CTransaction &tx, bool fBlock) if (fBlock) { - uint256 hash = tx.GetHash(); - map::iterator mi = mapWallet.find(hash); - CWalletTx& wtx = (*mi).second; + auto hash = tx.GetHash(); + auto mi = mapWallet.find(hash); + auto& wtx = (*mi).second; - BOOST_FOREACH(const CTxOut& txout, tx.vout) + for(const CTxOut& txout : tx.vout) { if (IsMine(txout)) { @@ -600,19 +662,19 @@ void CWallet::MarkDirty() { { LOCK(cs_wallet); - BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet) + for(auto& item : mapWallet) item.second.MarkDirty(); } } bool CWallet::AddToWallet(const CWalletTx& wtxIn) { - uint256 hash = wtxIn.GetHash(); + auto hash = wtxIn.GetHash(); { LOCK(cs_wallet); // Inserts only if not already there, returns tx inserted or tx found - pair::iterator, bool> ret = mapWallet.insert(make_pair(hash, wtxIn)); - CWalletTx& wtx = (*ret.first).second; + auto ret = mapWallet.insert({ hash, wtxIn }); + auto& wtx = (*ret.first).second; wtx.BindWallet(this); bool fInsertedNew = ret.second; if (fInsertedNew) @@ -630,9 +692,9 @@ bool CWallet::AddToWallet(const CWalletTx& wtxIn) { // Tolerate times up to the last timestamp in the wallet not more than 5 minutes into the future int64_t latestTolerated = latestNow + 300; - std::list acentries; - TxItems txOrdered = OrderedTxItems(acentries); - for (TxItems::reverse_iterator it = txOrdered.rbegin(); it != txOrdered.rend(); ++it) + list acentries; + auto txOrdered = OrderedTxItems(acentries); + for (auto it = txOrdered.rbegin(); it != txOrdered.rend(); ++it) { CWalletTx *const pwtx = (*it).second.first; if (pwtx == &wtx) @@ -658,7 +720,7 @@ bool CWallet::AddToWallet(const CWalletTx& wtxIn) } unsigned int& blocktime = mapBlockIndex[wtxIn.hashBlock]->nTime; - wtx.nTimeSmart = std::max(latestEntry, std::min(blocktime, latestNow)); + wtx.nTimeSmart = max(latestEntry, min(blocktime, latestNow)); } else printf("AddToWallet() : found %s in block %s not in index\n", @@ -701,7 +763,7 @@ bool CWallet::AddToWallet(const CWalletTx& wtxIn) // If default receiving address gets used, replace it with a new one CScript scriptDefaultKey; scriptDefaultKey.SetDestination(vchDefaultKey.GetID()); - BOOST_FOREACH(const CTxOut& txout, wtx.vout) + for(const CTxOut& txout : wtx.vout) { if (txout.scriptPubKey == scriptDefaultKey) { @@ -721,13 +783,11 @@ bool CWallet::AddToWallet(const CWalletTx& wtxIn) NotifyTransactionChanged(this, hash, fInsertedNew ? CT_NEW : CT_UPDATED); vMintingWalletUpdated.push_back(hash); // notify an external script when a wallet transaction comes in or is updated - std::string strCmd = GetArg("-walletnotify", ""); + auto strCmd = GetArg("-walletnotify", ""); - if ( !strCmd.empty()) - { - boost::replace_all(strCmd, "%s", wtxIn.GetHash().GetHex()); - boost::thread t(runCommand, strCmd); // thread runs free - } + if (!strCmd.empty()) + // thread runs free + boost::thread t(runCommand, regex_replace(strCmd, static_cast("%s"), wtxIn.GetHash().GetHex())); } return true; @@ -736,9 +796,9 @@ bool CWallet::AddToWallet(const CWalletTx& wtxIn) // Add a transaction to the wallet, or update it. // pblock is optional, but should be provided if the transaction is known to be in a block. // If fUpdate is true, existing transactions will be updated. -bool CWallet::AddToWalletIfInvolvingMe(const CTransaction& tx, const CBlock* pblock, bool fUpdate, bool fFindBlock) +bool CWallet::AddToWalletIfInvolvingMe(const CTransaction& tx, const CBlock* pblock, bool fUpdate) { - uint256 hash = tx.GetHash(); + auto hash = tx.GetHash(); { LOCK(cs_wallet); bool fExisted = mapWallet.count(hash) != 0; @@ -785,6 +845,128 @@ isminetype CWallet::IsMine(const CTxIn &txin) const return MINE_NO; } + +CWalletTx::CWalletTx() +{ + Init(NULL); +} + +CWalletTx::CWalletTx(const CWallet* pwalletIn) +{ + Init(pwalletIn); +} + +CWalletTx::CWalletTx(const CWallet* pwalletIn, const CMerkleTx& txIn) : CMerkleTx(txIn) +{ + Init(pwalletIn); +} + +CWalletTx::CWalletTx(const CWallet* pwalletIn, const CTransaction& txIn) : CMerkleTx(txIn) +{ + Init(pwalletIn); +} + +void CWalletTx::Init(const CWallet* pwalletIn) +{ + pwallet = pwalletIn; + vtxPrev.clear(); + mapValue.clear(); + vOrderForm.clear(); + fTimeReceivedIsTxTime = false; + nTimeReceived = 0; + nTimeSmart = 0; + fFromMe = false; + strFromAccount.clear(); + vfSpent.clear(); + fDebitCached = false; + fWatchDebitCached = false; + fCreditCached = false; + fWatchCreditCached = false; + fAvailableCreditCached = false; + fAvailableWatchCreditCached = false; + fImmatureCreditCached = false; + fImmatureWatchCreditCached = false; + fChangeCached = false; + nDebitCached = 0; + nWatchDebitCached = 0; + nCreditCached = 0; + nWatchCreditCached = 0; + nAvailableCreditCached = 0; + nAvailableWatchCreditCached = 0; + nImmatureCreditCached = 0; + nImmatureWatchCreditCached = 0; + nChangeCached = 0; + nOrderPos = -1; +} + +// marks certain txout's as spent +// returns true if any update took place +bool CWalletTx::UpdateSpent(const vector& vfNewSpent) +{ + bool fReturn = false; + for (unsigned int i = 0; i < vfNewSpent.size(); i++) + { + if (i == vfSpent.size()) + break; + + if (vfNewSpent[i] && !vfSpent[i]) + { + vfSpent[i] = true; + fReturn = true; + fAvailableCreditCached = fAvailableWatchCreditCached = false; + } + } + return fReturn; +} + +// make sure balances are recalculated +void CWalletTx::MarkDirty() +{ + fCreditCached = false; + fAvailableCreditCached = fAvailableWatchCreditCached = false; + fDebitCached = fWatchDebitCached = false; + fChangeCached = false; +} + +void CWalletTx::BindWallet(CWallet *pwalletIn) +{ + pwallet = pwalletIn; + MarkDirty(); +} + +void CWalletTx::MarkSpent(unsigned int nOut) +{ + if (nOut >= vout.size()) + throw runtime_error("CWalletTx::MarkSpent() : nOut out of range"); + vfSpent.resize(vout.size()); + if (!vfSpent[nOut]) + { + vfSpent[nOut] = true; + fAvailableCreditCached = fAvailableWatchCreditCached = false; + } +} + +void CWalletTx::MarkUnspent(unsigned int nOut) +{ + if (nOut >= vout.size()) + throw runtime_error("CWalletTx::MarkUnspent() : nOut out of range"); + vfSpent.resize(vout.size()); + if (vfSpent[nOut]) + { + vfSpent[nOut] = false; + fAvailableCreditCached = fAvailableWatchCreditCached = false; + } +} + +bool CWalletTx::IsSpent(unsigned int nOut) const +{ + if (nOut >= vout.size()) + throw runtime_error("CWalletTx::IsSpent() : nOut out of range"); + if (nOut >= vfSpent.size()) + return false; + return (!!vfSpent[nOut]); +} + int64_t CWallet::GetDebit(const CTxIn &txin, const isminefilter& filter) const { { @@ -801,6 +983,18 @@ int64_t CWallet::GetDebit(const CTxIn &txin, const isminefilter& filter) const return 0; } +isminetype CWallet::IsMine(const CTxOut& txout) const +{ + return ::IsMine(*this, txout.scriptPubKey); +} + +int64_t CWallet::GetCredit(const CTxOut& txout, const isminefilter& filter) const +{ + if (!MoneyRange(txout.nValue)) + throw runtime_error("CWallet::GetCredit() : value out of range"); + 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 @@ -823,6 +1017,65 @@ bool CWallet::IsChange(const CTxOut& txout) const return false; } +int64_t CWallet::GetChange(const CTxOut& txout) const +{ + if (!MoneyRange(txout.nValue)) + throw runtime_error("CWallet::GetChange() : 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) && txout.nValue >= nMinimumInputValue) + return true; + return false; +} + +bool CWallet::IsFromMe(const CTransaction& tx) const +{ + return (GetDebit(tx, MINE_ALL) > 0); +} + +int64_t CWallet::GetDebit(const CTransaction& tx, const isminefilter& filter) const +{ + CBigNum nDebit = 0; + for(const CTxIn& txin : tx.vin) + { + auto nValue = GetDebit(txin, filter); + nDebit += nValue; + if (!MoneyRange(nValue) || !MoneyRange(nDebit)) + throw runtime_error("CWallet::GetDebit() : value out of range"); + } + return nDebit.getint64(); +} + +int64_t CWallet::GetCredit(const CTransaction& tx, const isminefilter& filter) const +{ + CBigNum nCredit = 0; + for(const CTxOut& txout : tx.vout) + { + auto nValue = GetCredit(txout, filter); + nCredit += nValue; + if (!MoneyRange(nValue) || !MoneyRange(nCredit)) + throw runtime_error("CWallet::GetCredit() : value out of range"); + } + return nCredit.getint64(); +} + +int64_t CWallet::GetChange(const CTransaction& tx) const +{ + CBigNum nChange = 0; + for(const CTxOut& txout : tx.vout) + { + int64_t nValue = GetChange(txout); + nChange += nValue; + if (!MoneyRange(nValue) || !MoneyRange(nChange)) + throw runtime_error("CWallet::GetChange() : value out of range"); + } + return nChange.getint64(); +} + int64_t CWalletTx::GetTxTime() const { return nTime; @@ -867,8 +1120,210 @@ int CWalletTx::GetRequestCount() const return nRequests; } -void CWalletTx::GetAmounts(int64_t& nGeneratedImmature, int64_t& nGeneratedMature, list >& listReceived, - list >& listSent, int64_t& nFee, string& strSentAccount, const isminefilter& filter) const +bool CWalletTx::InMempool() const +{ + LOCK(mempool.cs); + if (mempool.exists(GetHash())) { + return true; + } + return false; +} + +bool CWalletTx::IsTrusted() const +{ + // Quick answer in most cases + if (!IsFinal()) + return false; + int nDepth = GetDepthInMainChain(); + if (nDepth >= 1) + return true; + if (nDepth < 0) + return false; + if (!fConfChange || !IsFromMe(MINE_ALL)) // using wtx's cached debit + return false; + + // Don't trust unconfirmed transactions from us unless they are in the mempool. + if (!InMempool()) + return false; + + // Trusted if all inputs are from us and are in the mempool: + for(const CTxIn& txin : vin) + { + // Transactions not sent by us: not trusted + const CWalletTx* parent = pwallet->GetWalletTx(txin.prevout.hash); + if (parent == NULL) + return false; + const CTxOut& parentOut = parent->vout[txin.prevout.n]; + if (pwallet->IsMine(parentOut) != MINE_SPENDABLE) + return false; + } + return true; +} + +int64_t CWalletTx::GetDebit(const isminefilter& filter) const +{ + if (vin.empty()) + return 0; + + int64_t nDebit = 0; + if (filter & MINE_SPENDABLE) + { + if (fDebitCached) + nDebit += nDebitCached; + else + { + nDebitCached = pwallet->GetDebit(*this, MINE_SPENDABLE); + fDebitCached = true; + nDebit += nDebitCached; + } + } + if (filter & MINE_WATCH_ONLY) + { + if (fWatchDebitCached) + nDebit += nWatchDebitCached; + else + { + nWatchDebitCached = pwallet->GetDebit(*this, MINE_WATCH_ONLY); + fWatchDebitCached = true; + nDebit += nWatchDebitCached; + } + } + return nDebit; +} + +int64_t CWalletTx::GetCredit(const isminefilter& filter) const +{ + // Must wait until coinbase is safely deep enough in the chain before valuing it + if ((IsCoinBase() || IsCoinStake()) && GetBlocksToMaturity() > 0) + return 0; + + int64_t credit = 0; + if (filter & MINE_SPENDABLE) + { + // GetBalance can assume transactions in mapWallet won't change + if (fCreditCached) + credit += nCreditCached; + else + { + nCreditCached = pwallet->GetCredit(*this, MINE_SPENDABLE); + fCreditCached = true; + credit += nCreditCached; + } + } + if (filter & MINE_WATCH_ONLY) + { + if (fWatchCreditCached) + credit += nWatchCreditCached; + else + { + nWatchCreditCached = pwallet->GetCredit(*this, MINE_WATCH_ONLY); + fWatchCreditCached = true; + credit += nWatchCreditCached; + } + } + return credit; +} + +int64_t CWalletTx::GetImmatureCredit(bool fUseCache) const +{ + if (IsCoinBase() && GetBlocksToMaturity() > 0 && IsInMainChain()) + { + if (fUseCache && fImmatureCreditCached) + return nImmatureCreditCached; + nImmatureCreditCached = pwallet->GetCredit(*this, MINE_SPENDABLE); + fImmatureCreditCached = true; + return nImmatureCreditCached; + } + + return 0; +} + +int64_t CWalletTx::GetImmatureWatchOnlyCredit(bool fUseCache) const +{ + if (IsCoinBase() && GetBlocksToMaturity() > 0 && IsInMainChain()) + { + if (fUseCache && fImmatureWatchCreditCached) + return nImmatureWatchCreditCached; + nImmatureWatchCreditCached = pwallet->GetCredit(*this, MINE_WATCH_ONLY); + fImmatureWatchCreditCached = true; + return nImmatureWatchCreditCached; + } + + return 0; +} + + +int64_t CWalletTx::GetAvailableCredit(bool fUseCache) const +{ + // Must wait until coinbase is safely deep enough in the chain before valuing it + if ((IsCoinBase() || IsCoinStake()) && GetBlocksToMaturity() > 0) + return 0; + + if (fUseCache) { + if (fAvailableCreditCached) + return nAvailableCreditCached; + } + + CBigNum nCredit = 0; + for (uint32_t i = 0; i < vout.size(); i++) + { + if (!IsSpent(i)) + { + const CTxOut &txout = vout[i]; + int64_t nValue = pwallet->GetCredit(txout, MINE_SPENDABLE); + nCredit += nValue; + if (!MoneyRange(nValue) || !MoneyRange(nCredit)) + throw runtime_error("CWalletTx::GetAvailableCredit() : value out of range"); + } + } + + nAvailableCreditCached = nCredit.getint64(); + fAvailableCreditCached = true; + + return nCredit.getint64(); +} + +int64_t CWalletTx::GetAvailableWatchCredit(bool fUseCache) const +{ + // Must wait until coinbase is safely deep enough in the chain before valuing it + if ((IsCoinBase() || IsCoinStake()) && GetBlocksToMaturity() > 0) + return 0; + + if (fUseCache) { + if (fAvailableWatchCreditCached) + return nAvailableWatchCreditCached; + } + + CBigNum nCredit = 0; + for (unsigned int i = 0; i < vout.size(); i++) + { + if (!IsSpent(i)) + { + const CTxOut &txout = vout[i]; + int64_t nValue = pwallet->GetCredit(txout, MINE_WATCH_ONLY); + nCredit += nValue; + if (!MoneyRange(nValue) || !MoneyRange(nCredit)) + throw runtime_error("CWalletTx::GetAvailableCredit() : value out of range"); + } + } + + nAvailableWatchCreditCached = nCredit.getint64(); + fAvailableWatchCreditCached = true; + + return nCredit.getint64(); +} + +int64_t CWalletTx::GetChange() const +{ + if (fChangeCached) + return nChangeCached; + nChangeCached = pwallet->GetChange(*this); + fChangeCached = true; + return nChangeCached; +} + +void CWalletTx::GetAmounts(int64_t& nGeneratedImmature, int64_t& nGeneratedMature, list >& listReceived, + list >& listSent, int64_t& nFee, string& strSentAccount, const isminefilter& filter) const { nGeneratedImmature = nGeneratedMature = nFee = 0; listReceived.clear(); @@ -885,17 +1340,17 @@ void CWalletTx::GetAmounts(int64_t& nGeneratedImmature, int64_t& nGeneratedMatur } // Compute fee: - int64_t nDebit = GetDebit(filter); + auto nDebit = GetDebit(filter); if (nDebit > 0) // debit>0 means we signed/sent this transaction { - int64_t nValueOut = GetValueOut(); + auto nValueOut = GetValueOut(); nFee = nDebit - nValueOut; } // Sent/received. - BOOST_FOREACH(const CTxOut& txout, vout) + for(const CTxOut& txout : vout) { - isminetype fIsMine = pwallet->IsMine(txout); + auto 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) @@ -909,21 +1364,21 @@ void CWalletTx::GetAmounts(int64_t& nGeneratedImmature, int64_t& nGeneratedMatur continue; // In either case, we need to get the destination address - CTxDestination address; - if (!ExtractDestination(txout.scriptPubKey, address)) + CBitcoinAddress address; + if (!ExtractAddress(*pwallet, txout.scriptPubKey, address)) { printf("CWalletTx::GetAmounts: Unknown transaction type found, txid %s\n", this->GetHash().ToString().c_str()); - address = CNoDestination(); + address = CBitcoinAddress(); } // If we are debited by the transaction, add the output as a "sent" entry if (nDebit > 0) - listSent.push_back(make_pair(address, txout.nValue)); + listSent.push_back({ address, txout.nValue }); // If we are receiving the output, add it as a "received" entry if (fIsMine & filter) - listReceived.push_back(make_pair(address, txout.nValue)); + listReceived.push_back({ address, txout.nValue }); } } @@ -936,25 +1391,25 @@ void CWalletTx::GetAccountAmounts(const string& strAccount, int64_t& nGenerated, int64_t allGeneratedImmature, allGeneratedMature, allFee; allGeneratedImmature = allGeneratedMature = allFee = 0; string strSentAccount; - list > listReceived; - list > listSent; + list > listReceived; + list > listSent; GetAmounts(allGeneratedImmature, allGeneratedMature, listReceived, listSent, allFee, strSentAccount, filter); - if (strAccount == "") + if (strAccount.empty()) nGenerated = allGeneratedMature; if (strAccount == strSentAccount) { - BOOST_FOREACH(const PAIRTYPE(CTxDestination,int64_t)& s, listSent) + for(const auto& s : listSent) nSent += s.second; nFee = allFee; } { LOCK(pwallet->cs_wallet); - BOOST_FOREACH(const PAIRTYPE(CTxDestination,int64_t)& r, listReceived) + for(const auto& r : listReceived) { if (pwallet->mapAddressBook.count(r.first)) { - map::const_iterator mi = pwallet->mapAddressBook.find(r.first); + map::const_iterator mi = pwallet->mapAddressBook.find(r.first); if (mi != pwallet->mapAddressBook.end() && (*mi).second == strAccount) nReceived += r.second; } @@ -974,7 +1429,7 @@ void CWalletTx::AddSupportingTransactions(CTxDB& txdb) if (SetMerkleBranch() < COPY_DEPTH) { vector vWorkQueue; - BOOST_FOREACH(const CTxIn& txin, vin) + for(const CTxIn& txin : vin) vWorkQueue.push_back(txin.prevout.hash); // This critsect is OK because txdb is already open @@ -984,7 +1439,7 @@ void CWalletTx::AddSupportingTransactions(CTxDB& txdb) set setAlreadyDone; for (unsigned int i = 0; i < vWorkQueue.size(); i++) { - uint256 hash = vWorkQueue[i]; + auto hash = vWorkQueue[i]; if (setAlreadyDone.count(hash)) continue; setAlreadyDone.insert(hash); @@ -994,7 +1449,7 @@ void CWalletTx::AddSupportingTransactions(CTxDB& txdb) if (mi != pwallet->mapWallet.end()) { tx = (*mi).second; - BOOST_FOREACH(const CMerkleTx& txWalletPrev, (*mi).second.vtxPrev) + for(const CMerkleTx& txWalletPrev : (*mi).second.vtxPrev) mapWalletPrev[txWalletPrev.GetHash()] = &txWalletPrev; } else if (mapWalletPrev.count(hash)) @@ -1016,7 +1471,7 @@ void CWalletTx::AddSupportingTransactions(CTxDB& txdb) if (nDepth < COPY_DEPTH) { - BOOST_FOREACH(const CTxIn& txin, tx.vin) + for(const CTxIn& txin : tx.vin) vWorkQueue.push_back(txin.prevout.hash); } } @@ -1045,7 +1500,7 @@ int CWallet::ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate) { CBlock block; block.ReadFromDisk(pindex, true); - BOOST_FOREACH(CTransaction& tx, block.vtx) + for(CTransaction& tx : block.vtx) { if (AddToWalletIfInvolvingMe(tx, &block, fUpdate)) ret++; @@ -1060,7 +1515,7 @@ int CWallet::ScanForWalletTransaction(const uint256& hashTx) { CTransaction tx; tx.ReadFromDisk(COutPoint(hashTx, 0)); - if (AddToWalletIfInvolvingMe(tx, NULL, true, true)) + if (AddToWalletIfInvolvingMe(tx, NULL, true)) return 1; return 0; } @@ -1074,9 +1529,9 @@ void CWallet::ReacceptWalletTransactions() LOCK(cs_wallet); fRepeat = false; vector vMissingTx; - BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet) + for(auto& item : mapWallet) { - CWalletTx& wtx = item.second; + auto& wtx = item.second; if ((wtx.IsCoinBase() && wtx.IsSpent(0)) || (wtx.IsCoinStake() && wtx.IsSpent(1))) continue; @@ -1124,83 +1579,85 @@ void CWallet::ReacceptWalletTransactions() } } -void CWalletTx::RelayWalletTransaction(CTxDB& txdb) +bool CWalletTx::RelayWalletTransaction(CTxDB& txdb) { - BOOST_FOREACH(const CMerkleTx& tx, vtxPrev) - { - if (!(tx.IsCoinBase() || tx.IsCoinStake())) - { - uint256 hash = tx.GetHash(); - if (!txdb.ContainsTx(hash)) - RelayTransaction((CTransaction)tx, hash); - } - } - if (!(IsCoinBase() || IsCoinStake())) + auto hash = GetHash(); + if (IsCoinBase() || IsCoinStake() || txdb.ContainsTx(hash) || !InMempool()) + return false; + + for(auto it = vtxPrev.begin(); it != vtxPrev.end(); it++) { - uint256 hash = GetHash(); + const CMerkleTx& tx = *it; + auto hash = tx.GetHash(); + + if (tx.IsCoinBase() || tx.IsCoinStake()) + continue; + if (!txdb.ContainsTx(hash)) - { - printf("Relaying wtx %s\n", hash.ToString().substr(0,10).c_str()); - RelayTransaction((CTransaction)*this, hash); - } + RelayTransaction((CTransaction)tx, hash); } + + printf("Relaying wtx %s\n", hash.ToString().substr(0,10).c_str()); + RelayTransaction((CTransaction)*this, hash); + return true; } -void CWalletTx::RelayWalletTransaction() +bool CWalletTx::RelayWalletTransaction() { CTxDB txdb("r"); - RelayWalletTransaction(txdb); + return RelayWalletTransaction(txdb); +} + +vector CWallet::ResendWalletTransactionsBefore(int64_t nTime) +{ + vector result; + + LOCK(cs_wallet); + // Sort them in chronological order + map mapSorted; + for(auto& item : mapWallet) + { + auto& wtx = item.second; + // Don't rebroadcast if newer than nTime: + if (wtx.nTimeReceived > nTime) + continue; + mapSorted.insert({ wtx.nTimeReceived, &wtx }); + } + for(auto& item : mapSorted) + { + auto& wtx = *item.second; + if (wtx.RelayWalletTransaction()) + result.push_back(wtx.GetHash()); + } + return result; } -void CWallet::ResendWalletTransactions() +void CWallet::ResendWalletTransactions(int64_t nBestBlockTime) { + auto nNow = GetTime(); + // Do this infrequently and randomly to avoid giving away // that these are our transactions. - static int64_t nNextTime = GetRand(GetTime() + 30 * 60); - if (GetTime() < nNextTime) + if (nNow < nNextResend) return; - bool fFirst = (nNextTime == 0); - nNextTime = GetTime() + GetRand(30 * 60); + bool fFirst = (nNextResend == 0); + nNextResend = PoissonNextSend(nNow, 5*60); if (fFirst) return; // Only do it if there's been a new block since last time - static int64_t nLastTime = 0; - if (nTimeBestReceived < nLastTime) + if (nBestBlockTime < nLastResend) return; - nLastTime = GetTime(); + nLastResend = nNow; - // Rebroadcast any of our txes that aren't in a block yet - printf("ResendWalletTransactions()\n"); - CTxDB txdb("r"); - { - LOCK(cs_wallet); - // Sort them in chronological order - multimap mapSorted; - BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet) - { - CWalletTx& wtx = item.second; - // Don't rebroadcast until it's had plenty of time that - // it should have gotten in already by now. - if (nTimeBestReceived - (int64_t)wtx.nTimeReceived > 5 * 60) - mapSorted.insert(make_pair(wtx.nTimeReceived, &wtx)); - } - BOOST_FOREACH(PAIRTYPE(const unsigned int, CWalletTx*)& item, mapSorted) - { - CWalletTx& wtx = *item.second; - if (wtx.CheckTransaction()) - wtx.RelayWalletTransaction(txdb); - else - printf("ResendWalletTransactions() : CheckTransaction failed for transaction %s\n", wtx.GetHash().ToString().c_str()); - } - } + // Rebroadcast unconfirmed txes older than 5 minutes before the last + // block was found: + auto relayed = ResendWalletTransactionsBefore(nBestBlockTime - 5*60); + if (!relayed.empty()) + printf("CWallet::ResendWalletTransactions: rebroadcast %" PRIszu " unconfirmed transactions\n", relayed.size()); } - - - - ////////////////////////////////////////////////////////////////////////////// // // Actions @@ -1212,7 +1669,7 @@ int64_t CWallet::GetBalance() const int64_t nTotal = 0; { LOCK(cs_wallet); - for (map::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) + for (auto it = mapWallet.begin(); it != mapWallet.end(); ++it) { const CWalletTx* pcoin = &(*it).second; if (pcoin->IsTrusted()) @@ -1228,7 +1685,7 @@ int64_t CWallet::GetWatchOnlyBalance() const int64_t nTotal = 0; { LOCK(cs_wallet); - for (map::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) + for (auto it = mapWallet.begin(); it != mapWallet.end(); ++it) { const CWalletTx* pcoin = &(*it).second; if (pcoin->IsTrusted()) @@ -1244,7 +1701,7 @@ int64_t CWallet::GetUnconfirmedBalance() const int64_t nTotal = 0; { LOCK(cs_wallet); - for (map::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) + for (auto it = mapWallet.begin(); it != mapWallet.end(); ++it) { const CWalletTx* pcoin = &(*it).second; if (!pcoin->IsFinal() || !pcoin->IsTrusted()) @@ -1259,7 +1716,7 @@ int64_t CWallet::GetUnconfirmedWatchOnlyBalance() const int64_t nTotal = 0; { LOCK(cs_wallet); - for (map::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) + for (auto it = mapWallet.begin(); it != mapWallet.end(); ++it) { const CWalletTx* pcoin = &(*it).second; if (!pcoin->IsFinal() || !pcoin->IsTrusted()) @@ -1274,7 +1731,7 @@ int64_t CWallet::GetImmatureBalance() const int64_t nTotal = 0; { LOCK(cs_wallet); - for (map::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) + for (auto it = mapWallet.begin(); it != mapWallet.end(); ++it) { const CWalletTx* pcoin = &(*it).second; nTotal += pcoin->GetImmatureCredit(); @@ -1288,7 +1745,7 @@ int64_t CWallet::GetImmatureWatchOnlyBalance() const int64_t nTotal = 0; { LOCK(cs_wallet); - for (map::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) + for (auto it = mapWallet.begin(); it != mapWallet.end(); ++it) { const CWalletTx* pcoin = &(*it).second; nTotal += pcoin->GetImmatureWatchOnlyCredit(); @@ -1304,7 +1761,7 @@ void CWallet::AvailableCoins(vector& vCoins, bool fOnlyConfirmed, const { LOCK(cs_wallet); - for (map::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) + for (auto it = mapWallet.begin(); it != mapWallet.end(); ++it) { const CWalletTx* pcoin = &(*it).second; @@ -1321,7 +1778,7 @@ void CWallet::AvailableCoins(vector& vCoins, bool fOnlyConfirmed, const continue; for (unsigned int i = 0; i < pcoin->vout.size(); i++) { - isminetype mine = IsMine(pcoin->vout[i]); + auto mine = IsMine(pcoin->vout[i]); if (!(pcoin->IsSpent(i)) && mine != MINE_NO && pcoin->vout[i].nValue >= nMinimumInputValue && (!coinControl || !coinControl->HasSelected() || coinControl->IsSelected((*it).first, i))) @@ -1339,7 +1796,7 @@ void CWallet::AvailableCoinsMinConf(vector& vCoins, int nConf, int64_t { LOCK(cs_wallet); - for (map::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) + for (auto it = mapWallet.begin(); it != mapWallet.end(); ++it) { const CWalletTx* pcoin = &(*it).second; @@ -1350,7 +1807,7 @@ void CWallet::AvailableCoinsMinConf(vector& vCoins, int nConf, int64_t continue; for (unsigned int i = 0; i < pcoin->vout.size(); i++) { - isminetype mine = IsMine(pcoin->vout[i]); + auto mine = IsMine(pcoin->vout[i]); // ignore coin if it was already spent or we don't own it if (pcoin->IsSpent(i) || mine == MINE_NO) @@ -1406,7 +1863,7 @@ int64_t CWallet::GetStake() const { int64_t nTotal = 0; LOCK(cs_wallet); - for (map::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) + for (auto it = mapWallet.begin(); it != mapWallet.end(); ++it) { const CWalletTx* pcoin = &(*it).second; if (pcoin->IsCoinStake() && pcoin->GetBlocksToMaturity() > 0 && pcoin->GetDepthInMainChain() > 0) @@ -1419,7 +1876,7 @@ int64_t CWallet::GetWatchOnlyStake() const { int64_t nTotal = 0; LOCK(cs_wallet); - for (map::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) + for (auto it = mapWallet.begin(); it != mapWallet.end(); ++it) { const CWalletTx* pcoin = &(*it).second; if (pcoin->IsCoinStake() && pcoin->GetBlocksToMaturity() > 0 && pcoin->GetDepthInMainChain() > 0) @@ -1432,7 +1889,7 @@ int64_t CWallet::GetNewMint() const { int64_t nTotal = 0; LOCK(cs_wallet); - for (map::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) + for (auto it = mapWallet.begin(); it != mapWallet.end(); ++it) { const CWalletTx* pcoin = &(*it).second; if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0 && pcoin->GetDepthInMainChain() > 0) @@ -1445,7 +1902,7 @@ int64_t CWallet::GetWatchOnlyNewMint() const { int64_t nTotal = 0; LOCK(cs_wallet); - for (map::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) + for (auto it = mapWallet.begin(); it != mapWallet.end(); ++it) { const CWalletTx* pcoin = &(*it).second; if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0 && pcoin->GetDepthInMainChain() > 0) @@ -1461,14 +1918,14 @@ bool CWallet::SelectCoinsMinConf(int64_t nTargetValue, unsigned int nSpendTime, // List of values less than target pair > coinLowestLarger; - coinLowestLarger.first = std::numeric_limits::max(); + coinLowestLarger.first = numeric_limits::max(); coinLowestLarger.second.first = NULL; vector > > vValue; int64_t nTotalLower = 0; random_shuffle(vCoins.begin(), vCoins.end(), GetRandInt); - BOOST_FOREACH(const COutput &output, vCoins) + for(const COutput &output : vCoins) { if (!output.fSpendable) continue; @@ -1484,9 +1941,8 @@ bool CWallet::SelectCoinsMinConf(int64_t nTargetValue, unsigned int nSpendTime, if (pcoin->nTime > nSpendTime) continue; - int64_t n = pcoin->vout[i].nValue; - - pair > coin = make_pair(n,make_pair(pcoin, i)); + auto n = pcoin->vout[i].nValue; + auto coin = make_pair(n, make_pair(pcoin, i)); if (n == nTargetValue) { @@ -1571,12 +2027,12 @@ bool CWallet::SelectCoins(int64_t nTargetValue, unsigned int nSpendTime, set return all selected outputs (we want all selected to go into the transaction for sure) if (coinControl && coinControl->HasSelected()) { - BOOST_FOREACH(const COutput& out, vCoins) + for(const COutput& out : vCoins) { if(!out.fSpendable) continue; nValueRet += out.tx->vout[out.i].nValue; - setCoinsRet.insert(make_pair(out.tx, out.i)); + setCoinsRet.insert({ out.tx, out.i }); } return (nValueRet >= nTargetValue); } @@ -1595,7 +2051,7 @@ bool CWallet::SelectCoinsSimple(int64_t nTargetValue, int64_t nMinValue, int64_t setCoinsRet.clear(); nValueRet = 0; - BOOST_FOREACH(COutput output, vCoins) + for(COutput output : vCoins) { if(!output.fSpendable) continue; @@ -1614,9 +2070,8 @@ bool CWallet::SelectCoinsSimple(int64_t nTargetValue, int64_t nMinValue, int64_t if (pcoin->nTime > nSpendTime) continue; - int64_t n = pcoin->vout[i].nValue; - - pair > coin = make_pair(n,make_pair(pcoin, i)); + auto n = pcoin->vout[i].nValue; + auto coin = make_pair(n, make_pair(pcoin, i)); if (n >= nTargetValue) { @@ -1639,7 +2094,7 @@ bool CWallet::SelectCoinsSimple(int64_t nTargetValue, int64_t nMinValue, int64_t bool CWallet::CreateTransaction(const vector >& vecSend, CWalletTx& wtxNew, CReserveKey& reservekey, int64_t& nFeeRet, const CCoinControl* coinControl) { int64_t nValue = 0; - BOOST_FOREACH (const PAIRTYPE(CScript, int64_t)& s, vecSend) + for(auto& s : vecSend) { if (nValue < 0) return false; @@ -1656,16 +2111,16 @@ bool CWallet::CreateTransaction(const vector >& vecSend, CTxDB txdb("r"); { nFeeRet = nTransactionFee; - while (true) + for ( ; ; ) { wtxNew.vin.clear(); wtxNew.vout.clear(); wtxNew.fFromMe = true; - int64_t nTotalValue = nValue + nFeeRet; + auto nTotalValue = nValue + nFeeRet; double dPriority = 0; // vouts to the payees - BOOST_FOREACH (const PAIRTYPE(CScript, int64_t)& s, vecSend) + for(const auto& s : vecSend) wtxNew.vout.push_back(CTxOut(s.second, s.first)); // Choose coins to use @@ -1673,13 +2128,13 @@ bool CWallet::CreateTransaction(const vector >& vecSend, int64_t nValueIn = 0; if (!SelectCoins(nTotalValue, wtxNew.nTime, setCoins, nValueIn, coinControl)) return false; - BOOST_FOREACH(PAIRTYPE(const CWalletTx*, unsigned int) pcoin, setCoins) + for(auto& pcoin : setCoins) { - int64_t nCredit = pcoin.first->vout[pcoin.second].nValue; + auto nCredit = pcoin.first->vout[pcoin.second].nValue; dPriority += (double)nCredit * pcoin.first->GetDepthInMainChain(); } - int64_t nChange = nValueIn - nValue - nFeeRet; + auto nChange = nValueIn - nValue - nFeeRet; if (nChange > 0) { // Fill a vout to ourself @@ -1702,25 +2157,25 @@ bool CWallet::CreateTransaction(const vector >& vecSend, // post-backup change. // Reserve a new key pair from key pool - CPubKey vchPubKey = reservekey.GetReservedKey(); + auto vchPubKey = reservekey.GetReservedKey(); scriptChange.SetDestination(vchPubKey.GetID()); } // Insert change txn at random position: - vector::iterator position = wtxNew.vout.begin()+GetRandInt(wtxNew.vout.size()); + auto position = wtxNew.vout.begin()+GetRandInt(wtxNew.vout.size()); wtxNew.vout.insert(position, CTxOut(nChange, scriptChange)); } else reservekey.ReturnKey(); // Fill vin - BOOST_FOREACH(const PAIRTYPE(const CWalletTx*,unsigned int)& coin, setCoins) + for(const auto& coin : setCoins) wtxNew.vin.push_back(CTxIn(coin.first->GetHash(),coin.second)); // Sign - int nIn = 0; - BOOST_FOREACH(const PAIRTYPE(const CWalletTx*,unsigned int)& coin, setCoins) + uint32_t nIn = 0; + for(const auto& coin : setCoins) if (!SignSignature(*this, *coin.first, wtxNew, nIn++)) return false; @@ -1732,8 +2187,8 @@ bool CWallet::CreateTransaction(const vector >& vecSend, // Check that enough fee is included bool fAllowFree = CTransaction::AllowFree(dPriority); - int64_t nPayFee = nTransactionFee * (1 + (int64_t)nBytes / 1000); - int64_t nMinFee = wtxNew.GetMinFee(1, fAllowFree, GMF_SEND, nBytes); + auto nPayFee = nTransactionFee * (1 + (int64_t)nBytes / 1000); + auto nMinFee = wtxNew.GetMinFee(1, fAllowFree, GMF_SEND, nBytes); if (nFeeRet < max(nPayFee, nMinFee)) { @@ -1755,13 +2210,13 @@ bool CWallet::CreateTransaction(const vector >& vecSend, bool CWallet::CreateTransaction(CScript scriptPubKey, int64_t nValue, CWalletTx& wtxNew, CReserveKey& reservekey, int64_t& nFeeRet, const CCoinControl* coinControl) { vector< pair > vecSend; - vecSend.push_back(make_pair(scriptPubKey, nValue)); + vecSend.push_back({ scriptPubKey, nValue }); return CreateTransaction(vecSend, wtxNew, reservekey, nFeeRet, coinControl); } void CWallet::GetStakeWeightFromValue(const int64_t& nTime, const int64_t& nValue, uint64_t& nWeight) { - int64_t nTimeWeight = GetWeight(nTime, GetTime()); + auto nTimeWeight = GetWeight(nTime, GetTime()); // If time weight is lower or equal to zero then weight is zero. if (nTimeWeight <= 0) @@ -1770,13 +2225,13 @@ void CWallet::GetStakeWeightFromValue(const int64_t& nTime, const int64_t& nValu return; } - CBigNum bnCoinDayWeight = CBigNum(nValue) * nTimeWeight / COIN / nOneDay; + auto bnCoinDayWeight = CBigNum(nValue) * nTimeWeight / COIN / nOneDay; nWeight = bnCoinDayWeight.getuint64(); } bool CWallet::MergeCoins(const int64_t& nAmount, const int64_t& nMinValue, const int64_t& nOutputValue, list& listMerged) { - int64_t nBalance = GetBalance(); + auto nBalance = GetBalance(); if (nAmount > nBalance) return false; @@ -1797,7 +2252,7 @@ bool CWallet::MergeCoins(const int64_t& nAmount, const int64_t& nMinValue, const // Reserve a new key pair from key pool CReserveKey reservekey(this); - CPubKey vchPubKey = reservekey.GetReservedKey(); + auto vchPubKey = reservekey.GetReservedKey(); // Output script CScript scriptOutput; @@ -1807,9 +2262,9 @@ bool CWallet::MergeCoins(const int64_t& nAmount, const int64_t& nMinValue, const wtxNew.vout.push_back(CTxOut(0, scriptOutput)); double dWeight = 0; - BOOST_FOREACH(PAIRTYPE(const CWalletTx*, unsigned int) pcoin, setCoins) + for(auto& pcoin : setCoins) { - int64_t nCredit = pcoin.first->vout[pcoin.second].nValue; + auto nCredit = pcoin.first->vout[pcoin.second].nValue; // Add current coin to inputs list and add its credit to transaction output wtxNew.vin.push_back(CTxIn(pcoin.first->GetHash(), pcoin.second)); @@ -1829,14 +2284,14 @@ bool CWallet::MergeCoins(const int64_t& nAmount, const int64_t& nMinValue, const */ // Assuming that average scriptsig size is 110 bytes - int64_t nBytes = ::GetSerializeSize(*(CTransaction*)&wtxNew, SER_NETWORK, PROTOCOL_VERSION) + wtxNew.vin.size() * 110; + auto nBytes = ::GetSerializeSize(*(CTransaction*)&wtxNew, SER_NETWORK, PROTOCOL_VERSION) + wtxNew.vin.size() * 110; dWeight += (double)nCredit * pcoin.first->GetDepthInMainChain(); double dFinalPriority = dWeight /= nBytes; bool fAllowFree = CTransaction::AllowFree(dFinalPriority); // Get actual transaction fee according to its estimated size and priority - int64_t nMinFee = wtxNew.GetMinFee(1, fAllowFree, GMF_SEND, nBytes); + auto nMinFee = wtxNew.GetMinFee(1, fAllowFree, GMF_SEND, nBytes); // Prepare transaction for commit if sum is enough ot its size is too big if (nBytes >= MAX_BLOCK_SIZE_GEN/6 || wtxNew.vout[0].nValue >= nOutputValue) @@ -1872,14 +2327,14 @@ bool CWallet::MergeCoins(const int64_t& nAmount, const int64_t& nMinValue, const bool fAllowFree = CTransaction::AllowFree(dFinalPriority); // Get actual transaction fee according to its size and priority - int64_t nMinFee = wtxNew.GetMinFee(1, fAllowFree, GMF_SEND, nBytes); + auto nMinFee = wtxNew.GetMinFee(1, fAllowFree, GMF_SEND, nBytes); wtxNew.vout[0].nValue -= nMinFee; // Set actual fee if (wtxNew.vout[0].nValue <= 0) return false; - for (unsigned int i = 0; i < wtxNew.vin.size(); i++) { + for (uint32_t i = 0; i < wtxNew.vin.size(); i++) { const CWalletTx *txin = vwtxPrev[i]; // Sign all scripts again @@ -1906,7 +2361,7 @@ bool CWallet::CreateCoinStake(uint256 &hashTx, uint32_t nOut, uint32_t nGenerati vector vSolutions; txnouttype whichType; CScript scriptPubKeyOut; - CScript scriptPubKeyKernel = wtx.vout[nOut].scriptPubKey; + auto scriptPubKeyKernel = wtx.vout[nOut].scriptPubKey; if (!Solver(scriptPubKeyKernel, whichType, vSolutions)) return error("CreateCoinStake : failed to parse kernel\n"); @@ -1926,7 +2381,7 @@ bool CWallet::CreateCoinStake(uint256 &hashTx, uint32_t nOut, uint32_t nGenerati } if (whichType == TX_PUBKEY) { - valtype& vchPubKey = vSolutions[0]; + auto& vchPubKey = vSolutions[0]; if (!GetKey(Hash160(vchPubKey), key)) return error("CreateCoinStake : failed to get key for kernel type=%d\n", whichType); if (key.GetPubKey() != vchPubKey) @@ -1936,10 +2391,10 @@ bool CWallet::CreateCoinStake(uint256 &hashTx, uint32_t nOut, uint32_t nGenerati // The following combine threshold is important to security // Should not be adjusted if you don't understand the consequences - int64_t nCombineThreshold = GetProofOfWorkReward(GetLastBlockIndex(pindexBest, false)->nBits) / 3; + auto nCombineThreshold = GetProofOfWorkReward(GetLastBlockIndex(pindexBest, false)->nBits) / 3; - int64_t nBalance = GetBalance(); - int64_t nCredit = wtx.vout[nOut].nValue; + auto nBalance = GetBalance(); + auto nCredit = wtx.vout[nOut].nValue; txNew.vin.clear(); txNew.vout.clear(); @@ -1979,7 +2434,7 @@ bool CWallet::CreateCoinStake(uint256 &hashTx, uint32_t nOut, uint32_t nGenerati // * Value is higher than 0.01 NVC; // * Only add inputs of the same key/address as kernel; // * Input hash and kernel parent hash should be different. - for(CoinsSet::iterator pcoin = setCoins.begin(); pcoin != setCoins.end(); pcoin++) + for(auto pcoin = setCoins.begin(); pcoin != setCoins.end(); pcoin++) { // Stop adding more inputs if already too many inputs if (txNew.vin.size() >= 100) @@ -1991,7 +2446,7 @@ bool CWallet::CreateCoinStake(uint256 &hashTx, uint32_t nOut, uint32_t nGenerati if (nCredit + pcoin->first->vout[pcoin->second].nValue > nBalance - nReserveBalance) break; - int64_t nTimeWeight = GetWeight((int64_t)pcoin->first->nTime, (int64_t)nGenerationTime); + auto nTimeWeight = GetWeight((int64_t)pcoin->first->nTime, (int64_t)nGenerationTime); // Do not add input that is still too young if (nTimeWeight < nStakeMaxAge) @@ -2015,7 +2470,7 @@ bool CWallet::CreateCoinStake(uint256 &hashTx, uint32_t nOut, uint32_t nGenerati } else { - int64_t nSplitThreshold = GetArg("-splitthreshold", nCombineThreshold); + auto nSplitThreshold = GetArg("-splitthreshold", nCombineThreshold); if (fDebug && GetBoolArg("-printcoinstake")) printf("CreateCoinStake : nSplitThreshold=%" PRId64 "\n", nSplitThreshold); @@ -2044,7 +2499,7 @@ bool CWallet::CreateCoinStake(uint256 &hashTx, uint32_t nOut, uint32_t nGenerati nCredit += GetProofOfStakeReward(nCoinAge, nBits, nGenerationTime); int64_t nMinFee = 0; - while (true) + for ( ; ; ) { // Set output amount if (fDontSplitCoins) @@ -2056,15 +2511,15 @@ bool CWallet::CreateCoinStake(uint256 &hashTx, uint32_t nOut, uint32_t nGenerati } // Sign - int nIn = 0; - BOOST_FOREACH(const CWalletTx* pcoin, vwtxPrev) + uint32_t nIn = 0; + for(const CWalletTx* pcoin : vwtxPrev) { if (!SignSignature(*this, *pcoin, txNew, nIn++)) return error("CreateCoinStake : failed to sign coinstake\n"); } // Limit size - unsigned int nBytes = ::GetSerializeSize(txNew, SER_NETWORK, PROTOCOL_VERSION); + auto nBytes = ::GetSerializeSize(txNew, SER_NETWORK, PROTOCOL_VERSION); if (nBytes >= MAX_BLOCK_SIZE_GEN/5) return error("CreateCoinStake : exceeded coinstake size limit\n"); @@ -2121,7 +2576,7 @@ bool CWallet::CommitTransaction(CWalletTx& wtxNew, CReserveKey& reservekey) AddToWallet(wtxNew); // Mark old coins as spent - BOOST_FOREACH(const CTxIn& txin, wtxNew.vin) + for(const CTxIn& txin : wtxNew.vin) { CWalletTx &coin = mapWallet[txin.prevout.hash]; coin.BindWallet(this); @@ -2145,22 +2600,22 @@ string CWallet::SendMoney(CScript scriptPubKey, int64_t nValue, CWalletTx& wtxNe { // Check amount if (nValue <= 0) - return _("Invalid amount"); + return "Invalid amount"; if (nValue + nTransactionFee > GetBalance()) - return _("Insufficient funds"); + return "Insufficient funds"; CReserveKey reservekey(this); int64_t nFeeRequired; if (IsLocked()) { - string strError = _("Error: Wallet locked, unable to create transaction "); + string strError("Error: Wallet locked, unable to create transaction "); printf("SendMoney() : %s", strError.c_str()); return strError; } if (fWalletUnlockMintOnly) { - string strError = _("Error: Wallet unlocked for block minting only, unable to create transaction."); + string strError("Error: Wallet unlocked for block minting only, unable to create transaction."); printf("SendMoney() : %s", strError.c_str()); return strError; } @@ -2179,7 +2634,7 @@ string CWallet::SendMoney(CScript scriptPubKey, int64_t nValue, CWalletTx& wtxNe return "ABORTED"; if (!CommitTransaction(wtxNew, reservekey)) - return _("Error: The transaction was rejected. This might happen if some of the coins in your wallet were already spent, such as if you used a copy of wallet.dat and coins were spent in the copy but not marked as spent here."); + return "Error: The transaction was rejected. This might happen if some of the coins in your wallet were already spent, such as if you used a copy of wallet.dat and coins were spent in the copy but not marked as spent here."; return ""; } @@ -2234,21 +2689,26 @@ DBErrors CWallet::ZapWalletTx() bool CWallet::SetAddressBookName(const CTxDestination& address, const string& strName) { - std::map::iterator mi = mapAddressBook.find(address); + return SetAddressBookName(CBitcoinAddress(address), strName); +} + +bool CWallet::SetAddressBookName(const CBitcoinAddress& address, const string& strName) +{ + auto mi = mapAddressBook.find(address); mapAddressBook[address] = strName; NotifyAddressBookChanged(this, address, strName, ::IsMine(*this, address) != MINE_NO, (mi == mapAddressBook.end()) ? CT_NEW : CT_UPDATED); if (!fFileBacked) return false; - return CWalletDB(strWalletFile).WriteName(CBitcoinAddress(address).ToString(), strName); + return CWalletDB(strWalletFile).WriteName(address.ToString(), strName); } -bool CWallet::DelAddressBookName(const CTxDestination& address) +bool CWallet::DelAddressBookName(const CBitcoinAddress& address) { mapAddressBook.erase(address); NotifyAddressBookChanged(this, address, "", ::IsMine(*this, address) != MINE_NO, CT_DELETED); if (!fFileBacked) return false; - return CWalletDB(strWalletFile).EraseName(CBitcoinAddress(address).ToString()); + return CWalletDB(strWalletFile).EraseName(address.ToString()); } @@ -2258,23 +2718,33 @@ void CWallet::PrintWallet(const CBlock& block) LOCK(cs_wallet); if (block.IsProofOfStake() && mapWallet.count(block.vtx[1].GetHash())) { - CWalletTx& wtx = mapWallet[block.vtx[1].GetHash()]; + auto& wtx = mapWallet[block.vtx[1].GetHash()]; printf(" PoS: %d %d %" PRId64 "", wtx.GetDepthInMainChain(), wtx.GetBlocksToMaturity(), wtx.GetCredit(MINE_ALL)); } else if (mapWallet.count(block.vtx[0].GetHash())) { - CWalletTx& wtx = mapWallet[block.vtx[0].GetHash()]; + auto& wtx = mapWallet[block.vtx[0].GetHash()]; printf(" PoW: %d %d %" PRId64 "", wtx.GetDepthInMainChain(), wtx.GetBlocksToMaturity(), wtx.GetCredit(MINE_ALL)); } } printf("\n"); } +void CWallet::Inventory(const uint256 &hash) +{ + { + LOCK(cs_wallet); + auto mi = mapRequestCount.find(hash); + if (mi != mapRequestCount.end()) + (*mi).second++; + } +} + bool CWallet::GetTransaction(const uint256 &hashTx, CWalletTx& wtx) { { LOCK(cs_wallet); - map::iterator mi = mapWallet.find(hashTx); + auto mi = mapWallet.find(hashTx); if (mi != mapWallet.end()) { wtx = (*mi).second; @@ -2312,7 +2782,7 @@ bool CWallet::NewKeyPool(unsigned int nSize) { LOCK(cs_wallet); CWalletDB walletdb(strWalletFile); - BOOST_FOREACH(int64_t nIndex, setKeyPool) + for(int64_t nIndex : setKeyPool) walletdb.ErasePool(nIndex); setKeyPool.clear(); @@ -2327,7 +2797,7 @@ bool CWallet::NewKeyPool(unsigned int nSize) for (uint64_t i = 0; i < nKeys; i++) { - uint64_t nIndex = i+1; + auto nIndex = i+1; walletdb.WritePool(nIndex, CKeyPool(GenerateNewKey())); setKeyPool.insert(nIndex); } @@ -2468,13 +2938,13 @@ int64_t CWallet::GetOldestKeyPoolTime() return keypool.nTime; } -std::map CWallet::GetAddressBalances() +map CWallet::GetAddressBalances() { - map balances; + map balances; { LOCK(cs_wallet); - BOOST_FOREACH(PAIRTYPE(uint256, CWalletTx) walletEntry, mapWallet) + for(auto& walletEntry : mapWallet) { CWalletTx *pcoin = &walletEntry.second; @@ -2490,13 +2960,13 @@ std::map CWallet::GetAddressBalances() for (unsigned int i = 0; i < pcoin->vout.size(); i++) { - CTxDestination addr; + CBitcoinAddress addr; if (!IsMine(pcoin->vout[i])) continue; - if(!ExtractDestination(pcoin->vout[i].scriptPubKey, addr)) + if(!ExtractAddress(*this, pcoin->vout[i].scriptPubKey, addr)) continue; - int64_t n = pcoin->IsSpent(i) ? 0 : pcoin->vout[i].nValue; + auto n = pcoin->IsSpent(i) ? 0 : pcoin->vout[i].nValue; if (!balances.count(addr)) balances[addr] = 0; @@ -2508,46 +2978,55 @@ std::map CWallet::GetAddressBalances() return balances; } -set< set > CWallet::GetAddressGroupings() +set< set > CWallet::GetAddressGroupings() { - set< set > groupings; - set grouping; + set< set > groupings; + set grouping; - BOOST_FOREACH(PAIRTYPE(uint256, CWalletTx) walletEntry, mapWallet) + for(auto& walletEntry : mapWallet) { CWalletTx *pcoin = &walletEntry.second; - if (pcoin->vin.size() > 0 && IsMine(pcoin->vin[0])) + if (pcoin->vin.size() > 0) { + bool any_mine = false; // group all input addresses with each other - BOOST_FOREACH(CTxIn txin, pcoin->vin) + for(CTxIn txin : pcoin->vin) { - CTxDestination address; - if(!ExtractDestination(mapWallet[txin.prevout.hash].vout[txin.prevout.n].scriptPubKey, address)) + CBitcoinAddress address; + if(!IsMine(txin)) // If this input isn't mine, ignore it + continue; + if(!ExtractAddress(*this, mapWallet[txin.prevout.hash].vout[txin.prevout.n].scriptPubKey, address)) continue; grouping.insert(address); + any_mine = true; } // group change with input addresses - BOOST_FOREACH(CTxOut txout, pcoin->vout) + if (any_mine) + { + for(CTxOut txout : pcoin->vout) if (IsChange(txout)) { - CWalletTx tx = mapWallet[pcoin->vin[0].prevout.hash]; - CTxDestination txoutAddr; - if(!ExtractDestination(txout.scriptPubKey, txoutAddr)) + CBitcoinAddress txoutAddr; + if(!ExtractAddress(*this, txout.scriptPubKey, txoutAddr)) continue; grouping.insert(txoutAddr); } - groupings.insert(grouping); - grouping.clear(); + } + if (!grouping.empty()) + { + groupings.insert(grouping); + grouping.clear(); + } } // group lone addrs by themselves for (unsigned int i = 0; i < pcoin->vout.size(); i++) if (IsMine(pcoin->vout[i])) { - CTxDestination address; - if(!ExtractDestination(pcoin->vout[i].scriptPubKey, address)) + CBitcoinAddress address; + if(!ExtractAddress(*this, pcoin->vout[i].scriptPubKey, address)) continue; grouping.insert(address); groupings.insert(grouping); @@ -2555,20 +3034,20 @@ set< set > CWallet::GetAddressGroupings() } } - set< set* > uniqueGroupings; // a set of pointers to groups of addresses - map< CTxDestination, set* > setmap; // map addresses to the unique group containing it - BOOST_FOREACH(set grouping, groupings) + set< set* > uniqueGroupings; // a set of pointers to groups of addresses + map< CBitcoinAddress, set* > setmap; // map addresses to the unique group containing it + for(auto& grouping : groupings) { // make a set of all the groups hit by this new group - set< set* > hits; - map< CTxDestination, set* >::iterator it; - BOOST_FOREACH(CTxDestination address, grouping) + set< set* > hits; + map< CBitcoinAddress, set* >::iterator it; + for(auto& 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); - BOOST_FOREACH(set* hit, hits) + set* merged = new set(grouping); + for(auto hit : hits) { merged->insert(hit->begin(), hit->end()); uniqueGroupings.erase(hit); @@ -2577,12 +3056,12 @@ set< set > CWallet::GetAddressGroupings() uniqueGroupings.insert(merged); // update setmap - BOOST_FOREACH(CTxDestination element, *merged) + for(CBitcoinAddress element : *merged) setmap[element] = merged; } - set< set > ret; - BOOST_FOREACH(set* uniqueGrouping, uniqueGroupings) + set< set > ret; + for(auto uniqueGrouping : uniqueGroupings) { ret.insert(*uniqueGrouping); delete uniqueGrouping; @@ -2601,11 +3080,11 @@ void CWallet::FixSpentCoins(int& nMismatchFound, int64_t& nBalanceInQuestion, bo LOCK(cs_wallet); vector vCoins; vCoins.reserve(mapWallet.size()); - for (map::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) + for (auto it = mapWallet.begin(); it != mapWallet.end(); ++it) vCoins.push_back(&(*it).second); CTxDB txdb("r"); - BOOST_FOREACH(CWalletTx* pcoin, vCoins) + for(auto pcoin : vCoins) { // Find the corresponding transaction index CTxIndex txindex; @@ -2658,12 +3137,12 @@ void CWallet::DisableTransaction(const CTransaction &tx) return; // only disconnecting coinstake requires marking input unspent LOCK(cs_wallet); - BOOST_FOREACH(const CTxIn& txin, tx.vin) + for(const auto& txin : tx.vin) { - map::iterator mi = mapWallet.find(txin.prevout.hash); + auto mi = mapWallet.find(txin.prevout.hash); if (mi != mapWallet.end()) { - CWalletTx& prev = (*mi).second; + auto& prev = (*mi).second; if (txin.prevout.n < prev.vout.size() && IsMine(prev.vout[txin.prevout.n])) { prev.MarkUnspent(txin.prevout.n); @@ -2714,13 +3193,13 @@ void CWallet::GetAllReserveKeys(set& setAddress) const CWalletDB walletdb(strWalletFile); LOCK2(cs_main, cs_wallet); - BOOST_FOREACH(const int64_t& id, setKeyPool) + for(const int64_t& id : setKeyPool) { CKeyPool keypool; if (!walletdb.ReadPool(id, keypool)) throw runtime_error("GetAllReserveKeyHashes() : read failed"); assert(keypool.vchPubKey.IsValid()); - CKeyID keyID = keypool.vchPubKey.GetID(); + auto keyID = keypool.vchPubKey.GetID(); if (!HaveKey(keyID)) throw runtime_error("GetAllReserveKeyHashes() : unknown key in key pool"); setAddress.insert(keyID); @@ -2732,7 +3211,7 @@ 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); + auto mi = mapWallet.find(hashTx); if (mi != mapWallet.end()) { NotifyTransactionChanged(this, hashTx, CT_UPDATED); @@ -2741,49 +3220,41 @@ void CWallet::UpdatedTransaction(const uint256 &hashTx) } } -void CWallet::GetAddresses(std::map &mapAddresses) const { +void CWallet::GetAddresses(map &mapAddresses) const { mapAddresses.clear(); // get birth times for keys with metadata - for (std::map::const_iterator it = mapMalleableKeyMetadata.begin(); it != mapMalleableKeyMetadata.end(); it++) { - CBitcoinAddress addr(it->first.GetMalleablePubKey()); - mapAddresses[addr] = it->second.nCreateTime ? it->second.nCreateTime : 0; + for (auto it = mapKeyMetadata.begin(); it != mapKeyMetadata.end(); it++) { + mapAddresses[it->first] = it->second.nCreateTime ? it->second.nCreateTime : 0; } - for (std::map::const_iterator it = mapKeyMetadata.begin(); it != mapKeyMetadata.end(); it++) { - CBitcoinAddress addr(it->first); - mapAddresses[addr] = it->second.nCreateTime ? it->second.nCreateTime : 0; - } - - for (std::map::const_iterator it = mapWallet.begin(); it != mapWallet.end(); it++) { + for (auto it = mapWallet.begin(); it != mapWallet.end(); it++) { // iterate over all wallet transactions... - const CWalletTx &wtx = (*it).second; + const auto &wtx = (*it).second; if (wtx.hashBlock == 0) continue; // skip unconfirmed transactions - for(std::vector::const_iterator it2 = wtx.vout.begin(); it2 != wtx.vout.end(); it2++) { + for(auto it2 = wtx.vout.begin(); it2 != wtx.vout.end(); it2++) { const CTxOut &out = (*it2); // iterate over all their outputs CBitcoinAddress addressRet; - if (const_cast(this)->ExtractAddress(out.scriptPubKey, addressRet)) { - if (mapAddresses.find(addressRet) != mapAddresses.end() && mapAddresses[addressRet] > wtx.nTime) + if (ExtractAddress(*this, out.scriptPubKey, addressRet)) { + if (mapAddresses.find(addressRet) != mapAddresses.end() && (mapAddresses[addressRet] == 0 || mapAddresses[addressRet] > wtx.nTime)) mapAddresses[addressRet] = wtx.nTime; } else { // multisig output affects more than one key - std::vector vAffected; + vector vAffected; ::ExtractAffectedKeys(*this, out.scriptPubKey, vAffected); - for(std::vector::const_iterator it3 = vAffected.begin(); it3 != vAffected.end(); it3++) { + for(auto it3 = vAffected.begin(); it3 != vAffected.end(); it3++) { CBitcoinAddress addrAffected(*it3); - - if (mapAddresses.find(addrAffected) != mapAddresses.end() && mapAddresses[addrAffected] > wtx.nTime) + if (mapAddresses.find(addrAffected) != mapAddresses.end() && (mapAddresses[addrAffected] == 0 || mapAddresses[addrAffected] > wtx.nTime)) mapAddresses[addrAffected] = wtx.nTime; } vAffected.clear(); } } - } } @@ -2792,7 +3263,7 @@ void CWallet::ClearOrphans() list orphans; LOCK(cs_wallet); - for(map::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it) + for(auto it = mapWallet.begin(); it != mapWallet.end(); ++it) { const CWalletTx *wtx = &(*it).second; if((wtx->IsCoinBase() || wtx->IsCoinStake()) && !wtx->IsInMainChain()) @@ -2801,42 +3272,7 @@ void CWallet::ClearOrphans() } } - for(list::const_iterator it = orphans.begin(); it != orphans.end(); ++it) + for(auto it = orphans.begin(); it != orphans.end(); ++it) EraseFromWallet(*it); } -bool CWallet::ExtractAddress(const CScript& scriptPubKey, CBitcoinAddress& addressRet) -{ - vector vSolutions; - txnouttype whichType; - if (!Solver(scriptPubKey, whichType, vSolutions)) - return false; - - if (whichType == TX_PUBKEY) - { - addressRet = CBitcoinAddress(CPubKey(vSolutions[0]).GetID()); - return true; - } - if (whichType == TX_PUBKEY_DROP) - { - // Pay-to-Pubkey-R - CMalleableKeyView view; - if (!CheckOwnership(CPubKey(vSolutions[0]), CPubKey(vSolutions[1]), view)) - return false; - - addressRet = CBitcoinAddress(view.GetMalleablePubKey()); - return true; - } - else if (whichType == TX_PUBKEYHASH) - { - addressRet = CBitcoinAddress(CKeyID(uint160(vSolutions[0]))); - return true; - } - else if (whichType == TX_SCRIPTHASH) - { - addressRet = CBitcoinAddress(CScriptID(uint160(vSolutions[0]))); - return true; - } - // Multisig txns have more than one address... - return false; -}