// 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<int64_t, pair<const CWalletTx*, unsigned int> >& t1,
const CWalletTx* CWallet::GetWalletTx(const uint256& hash) const
{
LOCK(cs_wallet);
- std::map<uint256, CWalletTx>::const_iterator it = mapWallet.find(hash);
+ auto it = mapWallet.find(hash);
if (it == mapWallet.end())
return NULL;
return &(it->second);
if (fCompressed)
SetMinVersion(FEATURE_COMPRPUBKEY);
- CPubKey pubkey = key.GetPubKey();
+ auto pubkey = key.GetPubKey();
// Create new metadata
- int64_t nCreationTime = GetTime();
+ 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();
}
const CMalleableKeyView &keyView(mKey);
// Create new metadata
- int64_t nCreationTime = GetTime();
+ auto nCreationTime = GetTime();
mapKeyMetadata[CBitcoinAddress(keyView.GetMalleablePubKey())] = CKeyMetadata(nCreationTime);
if (!nTimeFirstKey || nCreationTime < nTimeFirstKey)
nTimeFirstKey = nCreationTime;
if (!AddKey(mKey))
- throw std::runtime_error("CWallet::GenerateNewMalleableKey() : AddKey failed");
+ 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)
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;
}
-bool CWallet::AddCryptedMalleableKey(const CMalleableKeyView& keyView, const std::vector<unsigned char> &vchCryptedSecretH)
+bool CWallet::AddCryptedMalleableKey(const CMalleableKeyView& keyView, const vector<unsigned char> &vchCryptedSecretH)
{
if (!CCryptoKeyStore::AddCryptedMalleableKey(keyView, vchCryptedSecretH))
return false;
* 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(redeemScript.GetID()).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;
{
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;
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;
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);
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();
{
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;
if (fFileBacked)
{
// Overwrite crypted keys
- KeyMap::const_iterator mi = mapKeys.begin();
+ auto mi = mapKeys.begin();
while (mi != mapKeys.end())
{
CKey key;
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, 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);
return true;
}
-bool CWallet::GetPEM(const CKeyID &keyID, const std::string &fileName, const SecureString &strPassKey) const
+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 nRet;
}
-CWallet::TxItems CWallet::OrderedTxItems(std::list<CAccountingEntry>& acentries, std::string strAccount)
+CWallet::TxItems CWallet::OrderedTxItems(list<CAccountingEntry>& acentries, string strAccount)
{
CWalletDB walletdb(strWalletFile);
// 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<uint256, CWalletTx>::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;
// 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<uint256, CWalletTx>::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]))
if (fBlock)
{
- uint256 hash = tx.GetHash();
- map<uint256, CWalletTx>::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))
{
{
{
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<map<uint256, CWalletTx>::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)
{
// 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<CAccountingEntry> acentries;
- TxItems txOrdered = OrderedTxItems(acentries);
- for (TxItems::reverse_iterator it = txOrdered.rbegin(); it != txOrdered.rend(); ++it)
+ list<CAccountingEntry> acentries;
+ auto txOrdered = OrderedTxItems(acentries);
+ for (auto it = txOrdered.rbegin(); it != txOrdered.rend(); ++it)
{
CWalletTx *const pwtx = (*it).second.first;
if (pwtx == &wtx)
}
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",
// 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)
{
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())
{
// If fUpdate is true, existing transactions will be updated.
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;
CWalletTx wtx(this,tx);
// Get merkle branch if transaction was found in a block
if (pblock)
- wtx.SetMerkleBranch(*pblock);
+ wtx.SetMerkleBranch(pblock);
return AddToWallet(wtx);
}
else
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<char>& 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
{
{
int64_t CWallet::GetCredit(const CTxOut& txout, const isminefilter& filter) const
{
if (!MoneyRange(txout.nValue))
- throw std::runtime_error("CWallet::GetCredit() : value out of range");
+ throw runtime_error("CWallet::GetCredit() : value out of range");
return (IsMine(txout) & filter ? txout.nValue : 0);
}
int64_t CWallet::GetChange(const CTxOut& txout) const
{
if (!MoneyRange(txout.nValue))
- throw std::runtime_error("CWallet::GetChange() : value out of range");
+ throw runtime_error("CWallet::GetChange() : value out of range");
return (IsChange(txout) ? txout.nValue : 0);
}
bool CWallet::IsMine(const CTransaction& tx) const
{
- BOOST_FOREACH(const CTxOut& txout, tx.vout)
+ for(const CTxOut& txout : tx.vout)
if (IsMine(txout) && txout.nValue >= nMinimumInputValue)
return true;
return false;
int64_t CWallet::GetDebit(const CTransaction& tx, const isminefilter& filter) const
{
int64_t nDebit = 0;
- BOOST_FOREACH(const CTxIn& txin, tx.vin)
+ for(const CTxIn& txin : tx.vin)
{
nDebit += GetDebit(txin, filter);
if (!MoneyRange(nDebit))
- throw std::runtime_error("CWallet::GetDebit() : value out of range");
+ throw runtime_error("CWallet::GetDebit() : value out of range");
}
return nDebit;
}
int64_t CWallet::GetCredit(const CTransaction& tx, const isminefilter& filter) const
{
int64_t nCredit = 0;
- BOOST_FOREACH(const CTxOut& txout, tx.vout)
+ for(const CTxOut& txout : tx.vout)
{
nCredit += GetCredit(txout, filter);
if (!MoneyRange(nCredit))
- throw std::runtime_error("CWallet::GetCredit() : value out of range");
+ throw runtime_error("CWallet::GetCredit() : value out of range");
}
return nCredit;
}
int64_t CWallet::GetChange(const CTransaction& tx) const
{
int64_t nChange = 0;
- BOOST_FOREACH(const CTxOut& txout, tx.vout)
+ for(const CTxOut& txout : tx.vout)
{
nChange += GetChange(txout);
if (!MoneyRange(nChange))
- throw std::runtime_error("CWallet::GetChange() : value out of range");
+ throw runtime_error("CWallet::GetChange() : value out of range");
}
return nChange;
}
return false;
// Trusted if all inputs are from us and are in the mempool:
- BOOST_FOREACH(const CTxIn& txin, vin)
+ for(const CTxIn& txin : vin)
{
// Transactions not sent by us: not trusted
const CWalletTx* parent = pwallet->GetWalletTx(txin.prevout.hash);
const CTxOut &txout = vout[i];
nCredit += pwallet->GetCredit(txout, MINE_SPENDABLE);
if (!MoneyRange(nCredit))
- throw std::runtime_error("CWalletTx::GetAvailableCredit() : value out of range");
+ throw runtime_error("CWalletTx::GetAvailableCredit() : value out of range");
}
}
const CTxOut &txout = vout[i];
nCredit += pwallet->GetCredit(txout, MINE_WATCH_ONLY);
if (!MoneyRange(nCredit))
- throw std::runtime_error("CWalletTx::GetAvailableCredit() : value out of range");
+ throw runtime_error("CWalletTx::GetAvailableCredit() : value out of range");
}
}
}
// 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)
// 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 });
}
}
nGenerated = allGeneratedMature;
if (strAccount == strSentAccount)
{
- BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress,int64_t)& s, listSent)
+ for(const auto& s : listSent)
nSent += s.second;
nFee = allFee;
}
{
LOCK(pwallet->cs_wallet);
- BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress,int64_t)& r, listReceived)
+ for(const auto& r : listReceived)
{
if (pwallet->mapAddressBook.count(r.first))
{
if (SetMerkleBranch() < COPY_DEPTH)
{
vector<uint256> 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
set<uint256> 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);
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))
if (nDepth < COPY_DEPTH)
{
- BOOST_FOREACH(const CTxIn& txin, tx.vin)
+ for(const CTxIn& txin : tx.vin)
vWorkQueue.push_back(txin.prevout.hash);
}
}
{
CBlock block;
block.ReadFromDisk(pindex, true);
- BOOST_FOREACH(CTransaction& tx, block.vtx)
+ for(CTransaction& tx : block.vtx)
{
if (AddToWalletIfInvolvingMe(tx, &block, fUpdate))
ret++;
LOCK(cs_wallet);
fRepeat = false;
vector<CDiskTxPos> 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;
}
}
-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);
}
-void CWallet::ResendWalletTransactions(bool fForceResend)
+vector<uint256> CWallet::ResendWalletTransactionsBefore(int64_t nTime)
{
- if (!fForceResend) {
- // 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)
- return;
- bool fFirst = (nNextTime == 0);
- nNextTime = GetTime() + GetRand(30 * 60);
- if (fFirst)
- return;
+ vector<uint256> result;
- // Only do it if there's been a new block since last time
- static int64_t nLastTime = 0;
- if (nTimeBestReceived < nLastTime)
- return;
- nLastTime = GetTime();
+ LOCK(cs_wallet);
+ // Sort them in chronological order
+ map<unsigned int, CWalletTx*> 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 });
}
-
- // Rebroadcast any of our txes that aren't in a block yet
- printf("ResendWalletTransactions()\n");
- CTxDB txdb("r");
+ for(auto& item : mapSorted)
{
- LOCK(cs_wallet);
- // Sort them in chronological order
- multimap<unsigned int, CWalletTx*> 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 (fForceResend || 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());
- }
+ auto& wtx = *item.second;
+ if (wtx.RelayWalletTransaction())
+ result.push_back(wtx.GetHash());
}
+ return result;
}
+void CWallet::ResendWalletTransactions(int64_t nBestBlockTime)
+{
+ auto nNow = GetTime();
+ // Do this infrequently and randomly to avoid giving away
+ // that these are our transactions.
+ if (nNow < nNextResend)
+ return;
+ 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
+ if (nBestBlockTime < nLastResend)
+ return;
+ nLastResend = nNow;
+ // 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());
+}
//////////////////////////////////////////////////////////////////////////////
int64_t nTotal = 0;
{
LOCK(cs_wallet);
- for (map<uint256, CWalletTx>::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())
int64_t nTotal = 0;
{
LOCK(cs_wallet);
- for (map<uint256, CWalletTx>::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())
int64_t nTotal = 0;
{
LOCK(cs_wallet);
- for (map<uint256, CWalletTx>::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())
int64_t nTotal = 0;
{
LOCK(cs_wallet);
- for (map<uint256, CWalletTx>::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())
int64_t nTotal = 0;
{
LOCK(cs_wallet);
- for (map<uint256, CWalletTx>::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();
int64_t nTotal = 0;
{
LOCK(cs_wallet);
- for (map<uint256, CWalletTx>::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();
{
LOCK(cs_wallet);
- for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
+ for (auto it = mapWallet.begin(); it != mapWallet.end(); ++it)
{
const CWalletTx* pcoin = &(*it).second;
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)))
{
LOCK(cs_wallet);
- for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
+ for (auto it = mapWallet.begin(); it != mapWallet.end(); ++it)
{
const CWalletTx* pcoin = &(*it).second;
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)
{
int64_t nTotal = 0;
LOCK(cs_wallet);
- for (map<uint256, CWalletTx>::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)
{
int64_t nTotal = 0;
LOCK(cs_wallet);
- for (map<uint256, CWalletTx>::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)
{
int64_t nTotal = 0;
LOCK(cs_wallet);
- for (map<uint256, CWalletTx>::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)
{
int64_t nTotal = 0;
LOCK(cs_wallet);
- for (map<uint256, CWalletTx>::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)
// List of values less than target
pair<int64_t, pair<const CWalletTx*,unsigned int> > coinLowestLarger;
- coinLowestLarger.first = std::numeric_limits<int64_t>::max();
+ coinLowestLarger.first = numeric_limits<int64_t>::max();
coinLowestLarger.second.first = NULL;
vector<pair<int64_t, pair<const CWalletTx*,unsigned int> > > 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;
if (pcoin->nTime > nSpendTime)
continue;
- int64_t n = pcoin->vout[i].nValue;
-
- pair<int64_t,pair<const CWalletTx*,unsigned int> > 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)
{
// coin control -> 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);
}
setCoinsRet.clear();
nValueRet = 0;
- BOOST_FOREACH(COutput output, vCoins)
+ for(COutput output : vCoins)
{
if(!output.fSpendable)
continue;
if (pcoin->nTime > nSpendTime)
continue;
- int64_t n = pcoin->vout[i].nValue;
-
- pair<int64_t,pair<const CWalletTx*,unsigned int> > 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)
{
bool CWallet::CreateTransaction(const vector<pair<CScript, int64_t> >& 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;
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
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
// 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<CTxOut>::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)
+ for(const auto& coin : setCoins)
if (!SignSignature(*this, *coin.first, wtxNew, nIn++))
return false;
// 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))
{
bool CWallet::CreateTransaction(CScript scriptPubKey, int64_t nValue, CWalletTx& wtxNew, CReserveKey& reservekey, int64_t& nFeeRet, const CCoinControl* coinControl)
{
vector< pair<CScript, int64_t> > 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)
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<uint256>& listMerged)
{
- int64_t nBalance = GetBalance();
+ auto nBalance = GetBalance();
if (nAmount > nBalance)
return false;
// Reserve a new key pair from key pool
CReserveKey reservekey(this);
- CPubKey vchPubKey = reservekey.GetReservedKey();
+ auto vchPubKey = reservekey.GetReservedKey();
// Output script
CScript scriptOutput;
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));
*/
// 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)
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
vector<valtype> 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");
}
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)
// 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();
// * 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)
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)
}
else
{
- int64_t nSplitThreshold = GetArg("-splitthreshold", nCombineThreshold);
+ auto nSplitThreshold = GetArg("-splitthreshold", nCombineThreshold);
if (fDebug && GetBoolArg("-printcoinstake"))
printf("CreateCoinStake : nSplitThreshold=%" PRId64 "\n", nSplitThreshold);
// Sign
int nIn = 0;
- BOOST_FOREACH(const CWalletTx* pcoin, vwtxPrev)
+ 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");
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);
bool CWallet::SetAddressBookName(const CBitcoinAddress& address, const string& strName)
{
- std::map<CBitcoinAddress, string>::iterator mi = mapAddressBook.find(address);
+ 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)
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));
}
}
{
{
LOCK(cs_wallet);
- map<uint256, CWalletTx>::iterator mi = mapWallet.find(hashTx);
+ auto mi = mapWallet.find(hashTx);
if (mi != mapWallet.end())
{
wtx = (*mi).second;
{
LOCK(cs_wallet);
CWalletDB walletdb(strWalletFile);
- BOOST_FOREACH(int64_t nIndex, setKeyPool)
+ for(int64_t nIndex : setKeyPool)
walletdb.ErasePool(nIndex);
setKeyPool.clear();
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);
}
return keypool.nTime;
}
-std::map<CBitcoinAddress, int64_t> CWallet::GetAddressBalances()
+map<CBitcoinAddress, int64_t> CWallet::GetAddressBalances()
{
map<CBitcoinAddress, int64_t> balances;
{
LOCK(cs_wallet);
- BOOST_FOREACH(PAIRTYPE(uint256, CWalletTx) walletEntry, mapWallet)
+ for(auto& walletEntry : mapWallet)
{
CWalletTx *pcoin = &walletEntry.second;
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;
set< set<CBitcoinAddress> > groupings;
set<CBitcoinAddress> 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]))
{
// group all input addresses with each other
- BOOST_FOREACH(CTxIn txin, pcoin->vin)
+ for(CTxIn txin : pcoin->vin)
{
CBitcoinAddress address;
if(!ExtractAddress(*this, mapWallet[txin.prevout.hash].vout[txin.prevout.n].scriptPubKey, address))
}
// group change with input addresses
- BOOST_FOREACH(CTxOut txout, pcoin->vout)
+ for(CTxOut txout : pcoin->vout)
if (IsChange(txout))
{
- CWalletTx tx = mapWallet[pcoin->vin[0].prevout.hash];
+ auto tx = mapWallet[pcoin->vin[0].prevout.hash];
CBitcoinAddress txoutAddr;
if(!ExtractAddress(*this, txout.scriptPubKey, txoutAddr))
continue;
set< set<CBitcoinAddress>* > uniqueGroupings; // a set of pointers to groups of addresses
map< CBitcoinAddress, set<CBitcoinAddress>* > setmap; // map addresses to the unique group containing it
- BOOST_FOREACH(set<CBitcoinAddress> grouping, groupings)
+ for(auto& grouping : groupings)
{
// make a set of all the groups hit by this new group
set< set<CBitcoinAddress>* > hits;
map< CBitcoinAddress, set<CBitcoinAddress>* >::iterator it;
- BOOST_FOREACH(CBitcoinAddress address, grouping)
+ 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<CBitcoinAddress>* merged = new set<CBitcoinAddress>(grouping);
- BOOST_FOREACH(set<CBitcoinAddress>* hit, hits)
+ for(auto hit : hits)
{
merged->insert(hit->begin(), hit->end());
uniqueGroupings.erase(hit);
uniqueGroupings.insert(merged);
// update setmap
- BOOST_FOREACH(CBitcoinAddress element, *merged)
+ for(CBitcoinAddress element : *merged)
setmap[element] = merged;
}
set< set<CBitcoinAddress> > ret;
- BOOST_FOREACH(set<CBitcoinAddress>* uniqueGrouping, uniqueGroupings)
+ for(auto uniqueGrouping : uniqueGroupings)
{
ret.insert(*uniqueGrouping);
delete uniqueGrouping;
LOCK(cs_wallet);
vector<CWalletTx*> vCoins;
vCoins.reserve(mapWallet.size());
- for (map<uint256, CWalletTx>::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;
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<uint256, CWalletTx>::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);
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);
{
LOCK(cs_wallet);
// Only notify UI if this transaction is in this wallet
- map<uint256, CWalletTx>::const_iterator mi = mapWallet.find(hashTx);
+ auto mi = mapWallet.find(hashTx);
if (mi != mapWallet.end())
{
NotifyTransactionChanged(this, hashTx, CT_UPDATED);
}
}
-void CWallet::GetAddresses(std::map<CBitcoinAddress, int64_t> &mapAddresses) const {
+void CWallet::GetAddresses(map<CBitcoinAddress, int64_t> &mapAddresses) const {
mapAddresses.clear();
// get birth times for keys with metadata
- for (std::map<CBitcoinAddress, CKeyMetadata>::const_iterator it = mapKeyMetadata.begin(); it != mapKeyMetadata.end(); it++) {
+ for (auto it = mapKeyMetadata.begin(); it != mapKeyMetadata.end(); it++) {
mapAddresses[it->first] = it->second.nCreateTime ? it->second.nCreateTime : 0;
}
- for (std::map<uint256, CWalletTx>::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<CTxOut>::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;
}
else {
// multisig output affects more than one key
- std::vector<CKeyID> vAffected;
+ vector<CKeyID> vAffected;
::ExtractAffectedKeys(*this, out.scriptPubKey, vAffected);
- for(std::vector<CKeyID>::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] == 0 || mapAddresses[addrAffected] > wtx.nTime))
mapAddresses[addrAffected] = wtx.nTime;
list<uint256> orphans;
LOCK(cs_wallet);
- for(map<uint256, CWalletTx>::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())
}
}
- for(list<uint256>::const_iterator it = orphans.begin(); it != orphans.end(); ++it)
+ for(auto it = orphans.begin(); it != orphans.end(); ++it)
EraseFromWallet(*it);
}
git://git.novaco.in / novacoin.git / blobdiff