src/wallet/wallet.cpp

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2014 The Bitcoin Core developers
   3 // Distributed under the MIT software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5
   6 #include "wallet/wallet.h"
   7
   8 #include "base58.h"
   9 #include "checkpoints.h"
  10 #include "coincontrol.h"
  11 #include "consensus/upgrades.h"
  12 #include "consensus/validation.h"
  13 #include "init.h"
  14 #include "main.h"
  15 #include "net.h"
  16 #include "script/script.h"
  17 #include "script/sign.h"
  18 #include "timedata.h"
  19 #include "utilmoneystr.h"
  20 #include "zcash/Note.hpp"
  21 #include "crypter.h"
  22
  23 #include <assert.h>
  24
  25 #include <boost/algorithm/string/replace.hpp>
  26 #include <boost/filesystem.hpp>
  27 #include <boost/thread.hpp>
  28
  29 using namespace std;
  30 using namespace libzcash;
  31
  32 /**
  33  * Settings
  34  */
  35 CFeeRate payTxFee(DEFAULT_TRANSACTION_FEE);
  36 CAmount maxTxFee = DEFAULT_TRANSACTION_MAXFEE;
  37 unsigned int nTxConfirmTarget = DEFAULT_TX_CONFIRM_TARGET;
  38 bool bSpendZeroConfChange = true;
  39 bool fSendFreeTransactions = false;
  40 bool fPayAtLeastCustomFee = true;
  41
  42 /**
  43  * Fees smaller than this (in satoshi) are considered zero fee (for transaction creation)
  44  * Override with -mintxfee
  45  */
  46 CFeeRate CWallet::minTxFee = CFeeRate(1000);
  47
  48 /** @defgroup mapWallet
  49  *
  50  * @{
  51  */
  52
  53 struct CompareValueOnly
  54 {
  55     bool operator()(const pair<CAmount, pair<const CWalletTx*, unsigned int> >& t1,
  56                     const pair<CAmount, pair<const CWalletTx*, unsigned int> >& t2) const
  57     {
  58         return t1.first < t2.first;
  59     }
  60 };
  61
  62 std::string JSOutPoint::ToString() const
  63 {
  64     return strprintf("JSOutPoint(%s, %d, %d)", hash.ToString().substr(0,10), js, n);
  65 }
  66
  67 std::string COutput::ToString() const
  68 {
  69     return strprintf("COutput(%s, %d, %d) [%s]", tx->GetHash().ToString(), i, nDepth, FormatMoney(tx->vout[i].nValue));
  70 }
  71
  72 const CWalletTx* CWallet::GetWalletTx(const uint256& hash) const
  73 {
  74     LOCK(cs_wallet);
  75     std::map<uint256, CWalletTx>::const_iterator it = mapWallet.find(hash);
  76     if (it == mapWallet.end())
  77         return NULL;
  78     return &(it->second);
  79 }
  80
  81 // Generate a new spending key and return its public payment address
  82 CZCPaymentAddress CWallet::GenerateNewZKey()
  83 {
  84     AssertLockHeld(cs_wallet); // mapZKeyMetadata
  85     auto k = SpendingKey::random();
  86     auto addr = k.address();
  87
  88     // Check for collision, even though it is unlikely to ever occur
  89     if (CCryptoKeyStore::HaveSpendingKey(addr))
  90         throw std::runtime_error("CWallet::GenerateNewZKey(): Collision detected");
  91
  92     // Create new metadata
  93     int64_t nCreationTime = GetTime();
  94     mapZKeyMetadata[addr] = CKeyMetadata(nCreationTime);
  95
  96     CZCPaymentAddress pubaddr(addr);
  97     if (!AddZKey(k))
  98         throw std::runtime_error("CWallet::GenerateNewZKey(): AddZKey failed");
  99     return pubaddr;
 100 }
 101
 102 // Add spending key to keystore and persist to disk
 103 bool CWallet::AddZKey(const libzcash::SpendingKey &key)
 104 {
 105     AssertLockHeld(cs_wallet); // mapZKeyMetadata
 106     auto addr = key.address();
 107
 108     if (!CCryptoKeyStore::AddSpendingKey(key))
 109         return false;
 110
 111     // check if we need to remove from viewing keys
 112     if (HaveViewingKey(addr))
 113         RemoveViewingKey(key.viewing_key());
 114
 115     if (!fFileBacked)
 116         return true;
 117
 118     if (!IsCrypted()) {
 119         return CWalletDB(strWalletFile).WriteZKey(addr,
 120                                                   key,
 121                                                   mapZKeyMetadata[addr]);
 122     }
 123     return true;
 124 }
 125
 126 CPubKey CWallet::GenerateNewKey()
 127 {
 128     AssertLockHeld(cs_wallet); // mapKeyMetadata
 129     bool fCompressed = CanSupportFeature(FEATURE_COMPRPUBKEY); // default to compressed public keys if we want 0.6.0 wallets
 130
 131     CKey secret;
 132     secret.MakeNewKey(fCompressed);
 133
 134     // Compressed public keys were introduced in version 0.6.0
 135     if (fCompressed)
 136         SetMinVersion(FEATURE_COMPRPUBKEY);
 137
 138     CPubKey pubkey = secret.GetPubKey();
 139     assert(secret.VerifyPubKey(pubkey));
 140
 141     // Create new metadata
 142     int64_t nCreationTime = GetTime();
 143     mapKeyMetadata[pubkey.GetID()] = CKeyMetadata(nCreationTime);
 144     if (!nTimeFirstKey || nCreationTime < nTimeFirstKey)
 145         nTimeFirstKey = nCreationTime;
 146
 147     if (!AddKeyPubKey(secret, pubkey))
 148         throw std::runtime_error("CWallet::GenerateNewKey(): AddKey failed");
 149     return pubkey;
 150 }
 151
 152 bool CWallet::AddKeyPubKey(const CKey& secret, const CPubKey &pubkey)
 153 {
 154     AssertLockHeld(cs_wallet); // mapKeyMetadata
 155     if (!CCryptoKeyStore::AddKeyPubKey(secret, pubkey))
 156         return false;
 157
 158     // check if we need to remove from watch-only
 159     CScript script;
 160     script = GetScriptForDestination(pubkey.GetID());
 161     if (HaveWatchOnly(script))
 162         RemoveWatchOnly(script);
 163
 164     if (!fFileBacked)
 165         return true;
 166     if (!IsCrypted()) {
 167         return CWalletDB(strWalletFile).WriteKey(pubkey,
 168                                                  secret.GetPrivKey(),
 169                                                  mapKeyMetadata[pubkey.GetID()]);
 170     }
 171     return true;
 172 }
 173
 174 bool CWallet::AddCryptedKey(const CPubKey &vchPubKey,
 175                             const vector<unsigned char> &vchCryptedSecret)
 176 {
 177
 178     if (!CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret))
 179         return false;
 180     if (!fFileBacked)
 181         return true;
 182     {
 183         LOCK(cs_wallet);
 184         if (pwalletdbEncryption)
 185             return pwalletdbEncryption->WriteCryptedKey(vchPubKey,
 186                                                         vchCryptedSecret,
 187                                                         mapKeyMetadata[vchPubKey.GetID()]);
 188         else
 189             return CWalletDB(strWalletFile).WriteCryptedKey(vchPubKey,
 190                                                             vchCryptedSecret,
 191                                                             mapKeyMetadata[vchPubKey.GetID()]);
 192     }
 193     return false;
 194 }
 195
 196
 197 bool CWallet::AddCryptedSpendingKey(const libzcash::PaymentAddress &address,
 198                                     const libzcash::ReceivingKey &rk,
 199                                     const std::vector<unsigned char> &vchCryptedSecret)
 200 {
 201     if (!CCryptoKeyStore::AddCryptedSpendingKey(address, rk, vchCryptedSecret))
 202         return false;
 203     if (!fFileBacked)
 204         return true;
 205     {
 206         LOCK(cs_wallet);
 207         if (pwalletdbEncryption) {
 208             return pwalletdbEncryption->WriteCryptedZKey(address,
 209                                                          rk,
 210                                                          vchCryptedSecret,
 211                                                          mapZKeyMetadata[address]);
 212         } else {
 213             return CWalletDB(strWalletFile).WriteCryptedZKey(address,
 214                                                              rk,
 215                                                              vchCryptedSecret,
 216                                                              mapZKeyMetadata[address]);
 217         }
 218     }
 219     return false;
 220 }
 221
 222 bool CWallet::LoadKeyMetadata(const CPubKey &pubkey, const CKeyMetadata &meta)
 223 {
 224     AssertLockHeld(cs_wallet); // mapKeyMetadata
 225     if (meta.nCreateTime && (!nTimeFirstKey || meta.nCreateTime < nTimeFirstKey))
 226         nTimeFirstKey = meta.nCreateTime;
 227
 228     mapKeyMetadata[pubkey.GetID()] = meta;
 229     return true;
 230 }
 231
 232 bool CWallet::LoadZKeyMetadata(const PaymentAddress &addr, const CKeyMetadata &meta)
 233 {
 234     AssertLockHeld(cs_wallet); // mapZKeyMetadata
 235     mapZKeyMetadata[addr] = meta;
 236     return true;
 237 }
 238
 239 bool CWallet::LoadCryptedKey(const CPubKey &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret)
 240 {
 241     return CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret);
 242 }
 243
 244 bool CWallet::LoadCryptedZKey(const libzcash::PaymentAddress &addr, const libzcash::ReceivingKey &rk, const std::vector<unsigned char> &vchCryptedSecret)
 245 {
 246     return CCryptoKeyStore::AddCryptedSpendingKey(addr, rk, vchCryptedSecret);
 247 }
 248
 249 bool CWallet::LoadZKey(const libzcash::SpendingKey &key)
 250 {
 251     return CCryptoKeyStore::AddSpendingKey(key);
 252 }
 253
 254 bool CWallet::AddViewingKey(const libzcash::ViewingKey &vk)
 255 {
 256     if (!CCryptoKeyStore::AddViewingKey(vk)) {
 257         return false;
 258     }
 259     nTimeFirstKey = 1; // No birthday information for viewing keys.
 260     if (!fFileBacked) {
 261         return true;
 262     }
 263     return CWalletDB(strWalletFile).WriteViewingKey(vk);
 264 }
 265
 266 bool CWallet::RemoveViewingKey(const libzcash::ViewingKey &vk)
 267 {
 268     AssertLockHeld(cs_wallet);
 269     if (!CCryptoKeyStore::RemoveViewingKey(vk)) {
 270         return false;
 271     }
 272     if (fFileBacked) {
 273         if (!CWalletDB(strWalletFile).EraseViewingKey(vk)) {
 274             return false;
 275         }
 276     }
 277
 278     return true;
 279 }
 280
 281 bool CWallet::LoadViewingKey(const libzcash::ViewingKey &vk)
 282 {
 283     return CCryptoKeyStore::AddViewingKey(vk);
 284 }
 285
 286 bool CWallet::AddCScript(const CScript& redeemScript)
 287 {
 288     if (!CCryptoKeyStore::AddCScript(redeemScript))
 289         return false;
 290     if (!fFileBacked)
 291         return true;
 292     return CWalletDB(strWalletFile).WriteCScript(Hash160(redeemScript), redeemScript);
 293 }
 294
 295 bool CWallet::LoadCScript(const CScript& redeemScript)
 296 {
 297     /* A sanity check was added in pull #3843 to avoid adding redeemScripts
 298      * that never can be redeemed. However, old wallets may still contain
 299      * these. Do not add them to the wallet and warn. */
 300     if (redeemScript.size() > MAX_SCRIPT_ELEMENT_SIZE)
 301     {
 302         std::string strAddr = CBitcoinAddress(CScriptID(redeemScript)).ToString();
 303         LogPrintf("%s: Warning: This wallet contains a redeemScript of size %i which exceeds maximum size %i thus can never be redeemed. Do not use address %s.\n",
 304             __func__, redeemScript.size(), MAX_SCRIPT_ELEMENT_SIZE, strAddr);
 305         return true;
 306     }
 307
 308     return CCryptoKeyStore::AddCScript(redeemScript);
 309 }
 310
 311 bool CWallet::AddWatchOnly(const CScript &dest)
 312 {
 313     if (!CCryptoKeyStore::AddWatchOnly(dest))
 314         return false;
 315     nTimeFirstKey = 1; // No birthday information for watch-only keys.
 316     NotifyWatchonlyChanged(true);
 317     if (!fFileBacked)
 318         return true;
 319     return CWalletDB(strWalletFile).WriteWatchOnly(dest);
 320 }
 321
 322 bool CWallet::RemoveWatchOnly(const CScript &dest)
 323 {
 324     AssertLockHeld(cs_wallet);
 325     if (!CCryptoKeyStore::RemoveWatchOnly(dest))
 326         return false;
 327     if (!HaveWatchOnly())
 328         NotifyWatchonlyChanged(false);
 329     if (fFileBacked)
 330         if (!CWalletDB(strWalletFile).EraseWatchOnly(dest))
 331             return false;
 332
 333     return true;
 334 }
 335
 336 bool CWallet::LoadWatchOnly(const CScript &dest)
 337 {
 338     return CCryptoKeyStore::AddWatchOnly(dest);
 339 }
 340
 341 bool CWallet::Unlock(const SecureString& strWalletPassphrase)
 342 {
 343     CCrypter crypter;
 344     CKeyingMaterial vMasterKey;
 345
 346     {
 347         LOCK(cs_wallet);
 348         BOOST_FOREACH(const MasterKeyMap::value_type& pMasterKey, mapMasterKeys)
 349         {
 350             if(!crypter.SetKeyFromPassphrase(strWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
 351                 return false;
 352             if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, vMasterKey))
 353                 continue; // try another master key
 354             if (CCryptoKeyStore::Unlock(vMasterKey))
 355                 return true;
 356         }
 357     }
 358     return false;
 359 }
 360
 361 bool CWallet::ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, const SecureString& strNewWalletPassphrase)
 362 {
 363     bool fWasLocked = IsLocked();
 364
 365     {
 366         LOCK(cs_wallet);
 367         Lock();
 368
 369         CCrypter crypter;
 370         CKeyingMaterial vMasterKey;
 371         BOOST_FOREACH(MasterKeyMap::value_type& pMasterKey, mapMasterKeys)
 372         {
 373             if(!crypter.SetKeyFromPassphrase(strOldWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
 374                 return false;
 375             if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, vMasterKey))
 376                 return false;
 377             if (CCryptoKeyStore::Unlock(vMasterKey))
 378             {
 379                 int64_t nStartTime = GetTimeMillis();
 380                 crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);
 381                 pMasterKey.second.nDeriveIterations = pMasterKey.second.nDeriveIterations * (100 / ((double)(GetTimeMillis() - nStartTime)));
 382
 383                 nStartTime = GetTimeMillis();
 384                 crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);
 385                 pMasterKey.second.nDeriveIterations = (pMasterKey.second.nDeriveIterations + pMasterKey.second.nDeriveIterations * 100 / ((double)(GetTimeMillis() - nStartTime))) / 2;
 386
 387                 if (pMasterKey.second.nDeriveIterations < 25000)
 388                     pMasterKey.second.nDeriveIterations = 25000;
 389
 390                 LogPrintf("Wallet passphrase changed to an nDeriveIterations of %i\n", pMasterKey.second.nDeriveIterations);
 391
 392                 if (!crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
 393                     return false;
 394                 if (!crypter.Encrypt(vMasterKey, pMasterKey.second.vchCryptedKey))
 395                     return false;
 396                 CWalletDB(strWalletFile).WriteMasterKey(pMasterKey.first, pMasterKey.second);
 397                 if (fWasLocked)
 398                     Lock();
 399                 return true;
 400             }
 401         }
 402     }
 403
 404     return false;
 405 }
 406
 407 void CWallet::ChainTip(const CBlockIndex *pindex, const CBlock *pblock,
 408                        ZCIncrementalMerkleTree tree, bool added)
 409 {
 410     if (added) {
 411         IncrementNoteWitnesses(pindex, pblock, tree);
 412     } else {
 413         DecrementNoteWitnesses(pindex);
 414     }
 415 }
 416
 417 void CWallet::SetBestChain(const CBlockLocator& loc)
 418 {
 419     CWalletDB walletdb(strWalletFile);
 420     SetBestChainINTERNAL(walletdb, loc);
 421 }
 422
 423 bool CWallet::SetMinVersion(enum WalletFeature nVersion, CWalletDB* pwalletdbIn, bool fExplicit)
 424 {
 425     LOCK(cs_wallet); // nWalletVersion
 426     if (nWalletVersion >= nVersion)
 427         return true;
 428
 429     // when doing an explicit upgrade, if we pass the max version permitted, upgrade all the way
 430     if (fExplicit && nVersion > nWalletMaxVersion)
 431             nVersion = FEATURE_LATEST;
 432
 433     nWalletVersion = nVersion;
 434
 435     if (nVersion > nWalletMaxVersion)
 436         nWalletMaxVersion = nVersion;
 437
 438     if (fFileBacked)
 439     {
 440         CWalletDB* pwalletdb = pwalletdbIn ? pwalletdbIn : new CWalletDB(strWalletFile);
 441         if (nWalletVersion > 40000)
 442             pwalletdb->WriteMinVersion(nWalletVersion);
 443         if (!pwalletdbIn)
 444             delete pwalletdb;
 445     }
 446
 447     return true;
 448 }
 449
 450 bool CWallet::SetMaxVersion(int nVersion)
 451 {
 452     LOCK(cs_wallet); // nWalletVersion, nWalletMaxVersion
 453     // cannot downgrade below current version
 454     if (nWalletVersion > nVersion)
 455         return false;
 456
 457     nWalletMaxVersion = nVersion;
 458
 459     return true;
 460 }
 461
 462 set<uint256> CWallet::GetConflicts(const uint256& txid) const
 463 {
 464     set<uint256> result;
 465     AssertLockHeld(cs_wallet);
 466
 467     std::map<uint256, CWalletTx>::const_iterator it = mapWallet.find(txid);
 468     if (it == mapWallet.end())
 469         return result;
 470     const CWalletTx& wtx = it->second;
 471
 472     std::pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
 473
 474     BOOST_FOREACH(const CTxIn& txin, wtx.vin)
 475     {
 476         if (mapTxSpends.count(txin.prevout) <= 1)
 477             continue;  // No conflict if zero or one spends
 478         range = mapTxSpends.equal_range(txin.prevout);
 479         for (TxSpends::const_iterator it = range.first; it != range.second; ++it)
 480             result.insert(it->second);
 481     }
 482
 483     std::pair<TxNullifiers::const_iterator, TxNullifiers::const_iterator> range_n;
 484
 485     for (const JSDescription& jsdesc : wtx.vjoinsplit) {
 486         for (const uint256& nullifier : jsdesc.nullifiers) {
 487             if (mapTxNullifiers.count(nullifier) <= 1) {
 488                 continue;  // No conflict if zero or one spends
 489             }
 490             range_n = mapTxNullifiers.equal_range(nullifier);
 491             for (TxNullifiers::const_iterator it = range_n.first; it != range_n.second; ++it) {
 492                 result.insert(it->second);
 493             }
 494         }
 495     }
 496     return result;
 497 }
 498
 499 void CWallet::Flush(bool shutdown)
 500 {
 501     bitdb.Flush(shutdown);
 502 }
 503
 504 bool CWallet::Verify(const string& walletFile, string& warningString, string& errorString)
 505 {
 506     if (!bitdb.Open(GetDataDir()))
 507     {
 508         // try moving the database env out of the way
 509         boost::filesystem::path pathDatabase = GetDataDir() / "database";
 510         boost::filesystem::path pathDatabaseBak = GetDataDir() / strprintf("database.%d.bak", GetTime());
 511         try {
 512             boost::filesystem::rename(pathDatabase, pathDatabaseBak);
 513             LogPrintf("Moved old %s to %s. Retrying.\n", pathDatabase.string(), pathDatabaseBak.string());
 514         } catch (const boost::filesystem::filesystem_error&) {
 515             // failure is ok (well, not really, but it's not worse than what we started with)
 516         }
 517
 518         // try again
 519         if (!bitdb.Open(GetDataDir())) {
 520             // if it still fails, it probably means we can't even create the database env
 521             string msg = strprintf(_("Error initializing wallet database environment %s!"), GetDataDir());
 522             errorString += msg;
 523             return true;
 524         }
 525     }
 526
 527     if (GetBoolArg("-salvagewallet", false))
 528     {
 529         // Recover readable keypairs:
 530         if (!CWalletDB::Recover(bitdb, walletFile, true))
 531             return false;
 532     }
 533
 534     if (boost::filesystem::exists(GetDataDir() / walletFile))
 535     {
 536         CDBEnv::VerifyResult r = bitdb.Verify(walletFile, CWalletDB::Recover);
 537         if (r == CDBEnv::RECOVER_OK)
 538         {
 539             warningString += strprintf(_("Warning: wallet.dat corrupt, data salvaged!"
 540                                      " Original wallet.dat saved as wallet.{timestamp}.bak in %s; if"
 541                                      " your balance or transactions are incorrect you should"
 542                                      " restore from a backup."), GetDataDir());
 543         }
 544         if (r == CDBEnv::RECOVER_FAIL)
 545             errorString += _("wallet.dat corrupt, salvage failed");
 546     }
 547
 548     return true;
 549 }
 550
 551 template <class T>
 552 void CWallet::SyncMetaData(pair<typename TxSpendMap<T>::iterator, typename TxSpendMap<T>::iterator> range)
 553 {
 554     // We want all the wallet transactions in range to have the same metadata as
 555     // the oldest (smallest nOrderPos).
 556     // So: find smallest nOrderPos:
 557
 558     int nMinOrderPos = std::numeric_limits<int>::max();
 559     const CWalletTx* copyFrom = NULL;
 560     for (typename TxSpendMap<T>::iterator it = range.first; it != range.second; ++it)
 561     {
 562         const uint256& hash = it->second;
 563         int n = mapWallet[hash].nOrderPos;
 564         if (n < nMinOrderPos)
 565         {
 566             nMinOrderPos = n;
 567             copyFrom = &mapWallet[hash];
 568         }
 569     }
 570     // Now copy data from copyFrom to rest:
 571     for (typename TxSpendMap<T>::iterator it = range.first; it != range.second; ++it)
 572     {
 573         const uint256& hash = it->second;
 574         CWalletTx* copyTo = &mapWallet[hash];
 575         if (copyFrom == copyTo) continue;
 576         copyTo->mapValue = copyFrom->mapValue;
 577         // mapNoteData not copied on purpose
 578         // (it is always set correctly for each CWalletTx)
 579         copyTo->vOrderForm = copyFrom->vOrderForm;
 580         // fTimeReceivedIsTxTime not copied on purpose
 581         // nTimeReceived not copied on purpose
 582         copyTo->nTimeSmart = copyFrom->nTimeSmart;
 583         copyTo->fFromMe = copyFrom->fFromMe;
 584         copyTo->strFromAccount = copyFrom->strFromAccount;
 585         // nOrderPos not copied on purpose
 586         // cached members not copied on purpose
 587     }
 588 }
 589
 590 /**
 591  * Outpoint is spent if any non-conflicted transaction
 592  * spends it:
 593  */
 594 bool CWallet::IsSpent(const uint256& hash, unsigned int n) const
 595 {
 596     const COutPoint outpoint(hash, n);
 597     pair<TxSpends::const_iterator, TxSpends::const_iterator> range;
 598     range = mapTxSpends.equal_range(outpoint);
 599
 600     for (TxSpends::const_iterator it = range.first; it != range.second; ++it)
 601     {
 602         const uint256& wtxid = it->second;
 603         std::map<uint256, CWalletTx>::const_iterator mit = mapWallet.find(wtxid);
 604         if (mit != mapWallet.end() && mit->second.GetDepthInMainChain() >= 0)
 605             return true; // Spent
 606     }
 607     return false;
 608 }
 609
 610 /**
 611  * Note is spent if any non-conflicted transaction
 612  * spends it:
 613  */
 614 bool CWallet::IsSpent(const uint256& nullifier) const
 615 {
 616     pair<TxNullifiers::const_iterator, TxNullifiers::const_iterator> range;
 617     range = mapTxNullifiers.equal_range(nullifier);
 618
 619     for (TxNullifiers::const_iterator it = range.first; it != range.second; ++it) {
 620         const uint256& wtxid = it->second;
 621         std::map<uint256, CWalletTx>::const_iterator mit = mapWallet.find(wtxid);
 622         if (mit != mapWallet.end() && mit->second.GetDepthInMainChain() >= 0) {
 623             return true; // Spent
 624         }
 625     }
 626     return false;
 627 }
 628
 629 void CWallet::AddToSpends(const COutPoint& outpoint, const uint256& wtxid)
 630 {
 631     mapTxSpends.insert(make_pair(outpoint, wtxid));
 632
 633     pair<TxSpends::iterator, TxSpends::iterator> range;
 634     range = mapTxSpends.equal_range(outpoint);
 635     SyncMetaData<COutPoint>(range);
 636 }
 637
 638 void CWallet::AddToSpends(const uint256& nullifier, const uint256& wtxid)
 639 {
 640     mapTxNullifiers.insert(make_pair(nullifier, wtxid));
 641
 642     pair<TxNullifiers::iterator, TxNullifiers::iterator> range;
 643     range = mapTxNullifiers.equal_range(nullifier);
 644     SyncMetaData<uint256>(range);
 645 }
 646
 647 void CWallet::AddToSpends(const uint256& wtxid)
 648 {
 649     assert(mapWallet.count(wtxid));
 650     CWalletTx& thisTx = mapWallet[wtxid];
 651     if (thisTx.IsCoinBase()) // Coinbases don't spend anything!
 652         return;
 653
 654     for (const CTxIn& txin : thisTx.vin) {
 655         AddToSpends(txin.prevout, wtxid);
 656     }
 657     for (const JSDescription& jsdesc : thisTx.vjoinsplit) {
 658         for (const uint256& nullifier : jsdesc.nullifiers) {
 659             AddToSpends(nullifier, wtxid);
 660         }
 661     }
 662 }
 663
 664 void CWallet::ClearNoteWitnessCache()
 665 {
 666     LOCK(cs_wallet);
 667     for (std::pair<const uint256, CWalletTx>& wtxItem : mapWallet) {
 668         for (mapNoteData_t::value_type& item : wtxItem.second.mapNoteData) {
 669             item.second.witnesses.clear();
 670             item.second.witnessHeight = -1;
 671         }
 672     }
 673     nWitnessCacheSize = 0;
 674 }
 675
 676 void CWallet::IncrementNoteWitnesses(const CBlockIndex* pindex,
 677                                      const CBlock* pblockIn,
 678                                      ZCIncrementalMerkleTree& tree)
 679 {
 680     {
 681         LOCK(cs_wallet);
 682         for (std::pair<const uint256, CWalletTx>& wtxItem : mapWallet) {
 683             for (mapNoteData_t::value_type& item : wtxItem.second.mapNoteData) {
 684                 CNoteData* nd = &(item.second);
 685                 // Only increment witnesses that are behind the current height
 686                 if (nd->witnessHeight < pindex->nHeight) {
 687                     // Check the validity of the cache
 688                     // The only time a note witnessed above the current height
 689                     // would be invalid here is during a reindex when blocks
 690                     // have been decremented, and we are incrementing the blocks
 691                     // immediately after.
 692                     assert(nWitnessCacheSize >= nd->witnesses.size());
 693                     // Witnesses being incremented should always be either -1
 694                     // (never incremented or decremented) or one below pindex
 695                     assert((nd->witnessHeight == -1) ||
 696                            (nd->witnessHeight == pindex->nHeight - 1));
 697                     // Copy the witness for the previous block if we have one
 698                     if (nd->witnesses.size() > 0) {
 699                         nd->witnesses.push_front(nd->witnesses.front());
 700                     }
 701                     if (nd->witnesses.size() > WITNESS_CACHE_SIZE) {
 702                         nd->witnesses.pop_back();
 703                     }
 704                 }
 705             }
 706         }
 707         if (nWitnessCacheSize < WITNESS_CACHE_SIZE) {
 708             nWitnessCacheSize += 1;
 709         }
 710
 711         const CBlock* pblock {pblockIn};
 712         CBlock block;
 713         if (!pblock) {
 714             ReadBlockFromDisk(block, pindex);
 715             pblock = &block;
 716         }
 717
 718         for (const CTransaction& tx : pblock->vtx) {
 719             auto hash = tx.GetHash();
 720             bool txIsOurs = mapWallet.count(hash);
 721             for (size_t i = 0; i < tx.vjoinsplit.size(); i++) {
 722                 const JSDescription& jsdesc = tx.vjoinsplit[i];
 723                 for (uint8_t j = 0; j < jsdesc.commitments.size(); j++) {
 724                     const uint256& note_commitment = jsdesc.commitments[j];
 725                     tree.append(note_commitment);
 726
 727                     // Increment existing witnesses
 728                     for (std::pair<const uint256, CWalletTx>& wtxItem : mapWallet) {
 729                         for (mapNoteData_t::value_type& item : wtxItem.second.mapNoteData) {
 730                             CNoteData* nd = &(item.second);
 731                             if (nd->witnessHeight < pindex->nHeight &&
 732                                     nd->witnesses.size() > 0) {
 733                                 // Check the validity of the cache
 734                                 // See earlier comment about validity.
 735                                 assert(nWitnessCacheSize >= nd->witnesses.size());
 736                                 nd->witnesses.front().append(note_commitment);
 737                             }
 738                         }
 739                     }
 740
 741                     // If this is our note, witness it
 742                     if (txIsOurs) {
 743                         JSOutPoint jsoutpt {hash, i, j};
 744                         if (mapWallet[hash].mapNoteData.count(jsoutpt) &&
 745                                 mapWallet[hash].mapNoteData[jsoutpt].witnessHeight < pindex->nHeight) {
 746                             CNoteData* nd = &(mapWallet[hash].mapNoteData[jsoutpt]);
 747                             if (nd->witnesses.size() > 0) {
 748                                 // We think this can happen because we write out the
 749                                 // witness cache state after every block increment or
 750                                 // decrement, but the block index itself is written in
 751                                 // batches. So if the node crashes in between these two
 752                                 // operations, it is possible for IncrementNoteWitnesses
 753                                 // to be called again on previously-cached blocks. This
 754                                 // doesn't affect existing cached notes because of the
 755                                 // CNoteData::witnessHeight checks. See #1378 for details.
 756                                 LogPrintf("Inconsistent witness cache state found for %s\n- Cache size: %d\n- Top (height %d): %s\n- New (height %d): %s\n",
 757                                           jsoutpt.ToString(), nd->witnesses.size(),
 758                                           nd->witnessHeight,
 759                                           nd->witnesses.front().root().GetHex(),
 760                                           pindex->nHeight,
 761                                           tree.witness().root().GetHex());
 762                                 nd->witnesses.clear();
 763                             }
 764                             nd->witnesses.push_front(tree.witness());
 765                             // Set height to one less than pindex so it gets incremented
 766                             nd->witnessHeight = pindex->nHeight - 1;
 767                             // Check the validity of the cache
 768                             assert(nWitnessCacheSize >= nd->witnesses.size());
 769                         }
 770                     }
 771                 }
 772             }
 773         }
 774
 775         // Update witness heights
 776         for (std::pair<const uint256, CWalletTx>& wtxItem : mapWallet) {
 777             for (mapNoteData_t::value_type& item : wtxItem.second.mapNoteData) {
 778                 CNoteData* nd = &(item.second);
 779                 if (nd->witnessHeight < pindex->nHeight) {
 780                     nd->witnessHeight = pindex->nHeight;
 781                     // Check the validity of the cache
 782                     // See earlier comment about validity.
 783                     assert(nWitnessCacheSize >= nd->witnesses.size());
 784                 }
 785             }
 786         }
 787
 788         // For performance reasons, we write out the witness cache in
 789         // CWallet::SetBestChain() (which also ensures that overall consistency
 790         // of the wallet.dat is maintained).
 791     }
 792 }
 793
 794 void CWallet::DecrementNoteWitnesses(const CBlockIndex* pindex)
 795 {
 796     {
 797         LOCK(cs_wallet);
 798         for (std::pair<const uint256, CWalletTx>& wtxItem : mapWallet) {
 799             for (mapNoteData_t::value_type& item : wtxItem.second.mapNoteData) {
 800                 CNoteData* nd = &(item.second);
 801                 // Only increment witnesses that are not above the current height
 802                 if (nd->witnessHeight <= pindex->nHeight) {
 803                     // Check the validity of the cache
 804                     // See comment below (this would be invalid if there was a
 805                     // prior decrement).
 806                     assert(nWitnessCacheSize >= nd->witnesses.size());
 807                     // Witnesses being decremented should always be either -1
 808                     // (never incremented or decremented) or equal to pindex
 809                     assert((nd->witnessHeight == -1) ||
 810                            (nd->witnessHeight == pindex->nHeight));
 811                     if (nd->witnesses.size() > 0) {
 812                         nd->witnesses.pop_front();
 813                     }
 814                     // pindex is the block being removed, so the new witness cache
 815                     // height is one below it.
 816                     nd->witnessHeight = pindex->nHeight - 1;
 817                 }
 818             }
 819         }
 820         nWitnessCacheSize -= 1;
 821         for (std::pair<const uint256, CWalletTx>& wtxItem : mapWallet) {
 822             for (mapNoteData_t::value_type& item : wtxItem.second.mapNoteData) {
 823                 CNoteData* nd = &(item.second);
 824                 // Check the validity of the cache
 825                 // Technically if there are notes witnessed above the current
 826                 // height, their cache will now be invalid (relative to the new
 827                 // value of nWitnessCacheSize). However, this would only occur
 828                 // during a reindex, and by the time the reindex reaches the tip
 829                 // of the chain again, the existing witness caches will be valid
 830                 // again.
 831                 // We don't set nWitnessCacheSize to zero at the start of the
 832                 // reindex because the on-disk blocks had already resulted in a
 833                 // chain that didn't trigger the assertion below.
 834                 if (nd->witnessHeight < pindex->nHeight) {
 835                     assert(nWitnessCacheSize >= nd->witnesses.size());
 836                 }
 837             }
 838         }
 839         // TODO: If nWitnessCache is zero, we need to regenerate the caches (#1302)
 840         assert(nWitnessCacheSize > 0);
 841
 842         // For performance reasons, we write out the witness cache in
 843         // CWallet::SetBestChain() (which also ensures that overall consistency
 844         // of the wallet.dat is maintained).
 845     }
 846 }
 847
 848 bool CWallet::EncryptWallet(const SecureString& strWalletPassphrase)
 849 {
 850     if (IsCrypted())
 851         return false;
 852
 853     CKeyingMaterial vMasterKey;
 854
 855     vMasterKey.resize(WALLET_CRYPTO_KEY_SIZE);
 856     GetRandBytes(&vMasterKey[0], WALLET_CRYPTO_KEY_SIZE);
 857
 858     CMasterKey kMasterKey;
 859
 860     kMasterKey.vchSalt.resize(WALLET_CRYPTO_SALT_SIZE);
 861     GetRandBytes(&kMasterKey.vchSalt[0], WALLET_CRYPTO_SALT_SIZE);
 862
 863     CCrypter crypter;
 864     int64_t nStartTime = GetTimeMillis();
 865     crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, 25000, kMasterKey.nDerivationMethod);
 866     kMasterKey.nDeriveIterations = 2500000 / ((double)(GetTimeMillis() - nStartTime));
 867
 868     nStartTime = GetTimeMillis();
 869     crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, kMasterKey.nDeriveIterations, kMasterKey.nDerivationMethod);
 870     kMasterKey.nDeriveIterations = (kMasterKey.nDeriveIterations + kMasterKey.nDeriveIterations * 100 / ((double)(GetTimeMillis() - nStartTime))) / 2;
 871
 872     if (kMasterKey.nDeriveIterations < 25000)
 873         kMasterKey.nDeriveIterations = 25000;
 874
 875     LogPrintf("Encrypting Wallet with an nDeriveIterations of %i\n", kMasterKey.nDeriveIterations);
 876
 877     if (!crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, kMasterKey.nDeriveIterations, kMasterKey.nDerivationMethod))
 878         return false;
 879     if (!crypter.Encrypt(vMasterKey, kMasterKey.vchCryptedKey))
 880         return false;
 881
 882     {
 883         LOCK(cs_wallet);
 884         mapMasterKeys[++nMasterKeyMaxID] = kMasterKey;
 885         if (fFileBacked)
 886         {
 887             assert(!pwalletdbEncryption);
 888             pwalletdbEncryption = new CWalletDB(strWalletFile);
 889             if (!pwalletdbEncryption->TxnBegin()) {
 890                 delete pwalletdbEncryption;
 891                 pwalletdbEncryption = NULL;
 892                 return false;
 893             }
 894             pwalletdbEncryption->WriteMasterKey(nMasterKeyMaxID, kMasterKey);
 895         }
 896
 897         if (!EncryptKeys(vMasterKey))
 898         {
 899             if (fFileBacked) {
 900                 pwalletdbEncryption->TxnAbort();
 901                 delete pwalletdbEncryption;
 902             }
 903             // We now probably have half of our keys encrypted in memory, and half not...
 904             // die and let the user reload the unencrypted wallet.
 905             assert(false);
 906         }
 907
 908         // Encryption was introduced in version 0.4.0
 909         SetMinVersion(FEATURE_WALLETCRYPT, pwalletdbEncryption, true);
 910
 911         if (fFileBacked)
 912         {
 913             if (!pwalletdbEncryption->TxnCommit()) {
 914                 delete pwalletdbEncryption;
 915                 // We now have keys encrypted in memory, but not on disk...
 916                 // die to avoid confusion and let the user reload the unencrypted wallet.
 917                 assert(false);
 918             }
 919
 920             delete pwalletdbEncryption;
 921             pwalletdbEncryption = NULL;
 922         }
 923
 924         Lock();
 925         Unlock(strWalletPassphrase);
 926         NewKeyPool();
 927         Lock();
 928
 929         // Need to completely rewrite the wallet file; if we don't, bdb might keep
 930         // bits of the unencrypted private key in slack space in the database file.
 931         CDB::Rewrite(strWalletFile);
 932
 933     }
 934     NotifyStatusChanged(this);
 935
 936     return true;
 937 }
 938
 939 int64_t CWallet::IncOrderPosNext(CWalletDB *pwalletdb)
 940 {
 941     AssertLockHeld(cs_wallet); // nOrderPosNext
 942     int64_t nRet = nOrderPosNext++;
 943     if (pwalletdb) {
 944         pwalletdb->WriteOrderPosNext(nOrderPosNext);
 945     } else {
 946         CWalletDB(strWalletFile).WriteOrderPosNext(nOrderPosNext);
 947     }
 948     return nRet;
 949 }
 950
 951 CWallet::TxItems CWallet::OrderedTxItems(std::list<CAccountingEntry>& acentries, std::string strAccount)
 952 {
 953     AssertLockHeld(cs_wallet); // mapWallet
 954     CWalletDB walletdb(strWalletFile);
 955
 956     // First: get all CWalletTx and CAccountingEntry into a sorted-by-order multimap.
 957     TxItems txOrdered;
 958
 959     // Note: maintaining indices in the database of (account,time) --> txid and (account, time) --> acentry
 960     // would make this much faster for applications that do this a lot.
 961     for (map<uint256, CWalletTx>::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
 962     {
 963         CWalletTx* wtx = &((*it).second);
 964         txOrdered.insert(make_pair(wtx->nOrderPos, TxPair(wtx, (CAccountingEntry*)0)));
 965     }
 966     acentries.clear();
 967     walletdb.ListAccountCreditDebit(strAccount, acentries);
 968     BOOST_FOREACH(CAccountingEntry& entry, acentries)
 969     {
 970         txOrdered.insert(make_pair(entry.nOrderPos, TxPair((CWalletTx*)0, &entry)));
 971     }
 972
 973     return txOrdered;
 974 }
 975
 976 void CWallet::MarkDirty()
 977 {
 978     {
 979         LOCK(cs_wallet);
 980         BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet)
 981             item.second.MarkDirty();
 982     }
 983 }
 984
 985 /**
 986  * Ensure that every note in the wallet (for which we possess a spending key)
 987  * has a cached nullifier.
 988  */
 989 bool CWallet::UpdateNullifierNoteMap()
 990 {
 991     {
 992         LOCK(cs_wallet);
 993
 994         if (IsLocked())
 995             return false;
 996
 997         ZCNoteDecryption dec;
 998         for (std::pair<const uint256, CWalletTx>& wtxItem : mapWallet) {
 999             for (mapNoteData_t::value_type& item : wtxItem.second.mapNoteData) {
1000                 if (!item.second.nullifier) {
1001                     if (GetNoteDecryptor(item.second.address, dec)) {
1002                         auto i = item.first.js;
1003                         auto hSig = wtxItem.second.vjoinsplit[i].h_sig(
1004                             *pzcashParams, wtxItem.second.joinSplitPubKey);
1005                         item.second.nullifier = GetNoteNullifier(
1006                             wtxItem.second.vjoinsplit[i],
1007                             item.second.address,
1008                             dec,
1009                             hSig,
1010                             item.first.n);
1011                     }
1012                 }
1013             }
1014             UpdateNullifierNoteMapWithTx(wtxItem.second);
1015         }
1016     }
1017     return true;
1018 }
1019
1020 /**
1021  * Update mapNullifiersToNotes with the cached nullifiers in this tx.
1022  */
1023 void CWallet::UpdateNullifierNoteMapWithTx(const CWalletTx& wtx)
1024 {
1025     {
1026         LOCK(cs_wallet);
1027         for (const mapNoteData_t::value_type& item : wtx.mapNoteData) {
1028             if (item.second.nullifier) {
1029                 mapNullifiersToNotes[*item.second.nullifier] = item.first;
1030             }
1031         }
1032     }
1033 }
1034
1035 bool CWallet::AddToWallet(const CWalletTx& wtxIn, bool fFromLoadWallet, CWalletDB* pwalletdb)
1036 {
1037     uint256 hash = wtxIn.GetHash();
1038
1039     if (fFromLoadWallet)
1040     {
1041         mapWallet[hash] = wtxIn;
1042         mapWallet[hash].BindWallet(this);
1043         UpdateNullifierNoteMapWithTx(mapWallet[hash]);
1044         AddToSpends(hash);
1045     }
1046     else
1047     {
1048         LOCK(cs_wallet);
1049         // Inserts only if not already there, returns tx inserted or tx found
1050         pair<map<uint256, CWalletTx>::iterator, bool> ret = mapWallet.insert(make_pair(hash, wtxIn));
1051         CWalletTx& wtx = (*ret.first).second;
1052         wtx.BindWallet(this);
1053         UpdateNullifierNoteMapWithTx(wtx);
1054         bool fInsertedNew = ret.second;
1055         if (fInsertedNew)
1056         {
1057             wtx.nTimeReceived = GetAdjustedTime();
1058             wtx.nOrderPos = IncOrderPosNext(pwalletdb);
1059
1060             wtx.nTimeSmart = wtx.nTimeReceived;
1061             if (!wtxIn.hashBlock.IsNull())
1062             {
1063                 if (mapBlockIndex.count(wtxIn.hashBlock))
1064                 {
1065                     int64_t latestNow = wtx.nTimeReceived;
1066                     int64_t latestEntry = 0;
1067                     {
1068                         // Tolerate times up to the last timestamp in the wallet not more than 5 minutes into the future
1069                         int64_t latestTolerated = latestNow + 300;
1070                         std::list<CAccountingEntry> acentries;
1071                         TxItems txOrdered = OrderedTxItems(acentries);
1072                         for (TxItems::reverse_iterator it = txOrdered.rbegin(); it != txOrdered.rend(); ++it)
1073                         {
1074                             CWalletTx *const pwtx = (*it).second.first;
1075                             if (pwtx == &wtx)
1076                                 continue;
1077                             CAccountingEntry *const pacentry = (*it).second.second;
1078                             int64_t nSmartTime;
1079                             if (pwtx)
1080                             {
1081                                 nSmartTime = pwtx->nTimeSmart;
1082                                 if (!nSmartTime)
1083                                     nSmartTime = pwtx->nTimeReceived;
1084                             }
1085                             else
1086                                 nSmartTime = pacentry->nTime;
1087                             if (nSmartTime <= latestTolerated)
1088                             {
1089                                 latestEntry = nSmartTime;
1090                                 if (nSmartTime > latestNow)
1091                                     latestNow = nSmartTime;
1092                                 break;
1093                             }
1094                         }
1095                     }
1096
1097                     int64_t blocktime = mapBlockIndex[wtxIn.hashBlock]->GetBlockTime();
1098                     wtx.nTimeSmart = std::max(latestEntry, std::min(blocktime, latestNow));
1099                 }
1100                 else
1101                     LogPrintf("AddToWallet(): found %s in block %s not in index\n",
1102                              wtxIn.GetHash().ToString(),
1103                              wtxIn.hashBlock.ToString());
1104             }
1105             AddToSpends(hash);
1106         }
1107
1108         bool fUpdated = false;
1109         if (!fInsertedNew)
1110         {
1111             // Merge
1112             if (!wtxIn.hashBlock.IsNull() && wtxIn.hashBlock != wtx.hashBlock)
1113             {
1114                 wtx.hashBlock = wtxIn.hashBlock;
1115                 fUpdated = true;
1116             }
1117             if (wtxIn.nIndex != -1 && (wtxIn.vMerkleBranch != wtx.vMerkleBranch || wtxIn.nIndex != wtx.nIndex))
1118             {
1119                 wtx.vMerkleBranch = wtxIn.vMerkleBranch;
1120                 wtx.nIndex = wtxIn.nIndex;
1121                 fUpdated = true;
1122             }
1123             if (UpdatedNoteData(wtxIn, wtx)) {
1124                 fUpdated = true;
1125             }
1126             if (wtxIn.fFromMe && wtxIn.fFromMe != wtx.fFromMe)
1127             {
1128                 wtx.fFromMe = wtxIn.fFromMe;
1129                 fUpdated = true;
1130             }
1131         }
1132
1133         //// debug print
1134         LogPrintf("AddToWallet %s  %s%s\n", wtxIn.GetHash().ToString(), (fInsertedNew ? "new" : ""), (fUpdated ? "update" : ""));
1135
1136         // Write to disk
1137         if (fInsertedNew || fUpdated)
1138             if (!wtx.WriteToDisk(pwalletdb))
1139                 return false;
1140
1141         // Break debit/credit balance caches:
1142         wtx.MarkDirty();
1143
1144         // Notify UI of new or updated transaction
1145         NotifyTransactionChanged(this, hash, fInsertedNew ? CT_NEW : CT_UPDATED);
1146
1147         // notify an external script when a wallet transaction comes in or is updated
1148         std::string strCmd = GetArg("-walletnotify", "");
1149
1150         if ( !strCmd.empty())
1151         {
1152             boost::replace_all(strCmd, "%s", wtxIn.GetHash().GetHex());
1153             boost::thread t(runCommand, strCmd); // thread runs free
1154         }
1155
1156     }
1157     return true;
1158 }
1159
1160 bool CWallet::UpdatedNoteData(const CWalletTx& wtxIn, CWalletTx& wtx)
1161 {
1162     if (wtxIn.mapNoteData.empty() || wtxIn.mapNoteData == wtx.mapNoteData) {
1163         return false;
1164     }
1165     auto tmp = wtxIn.mapNoteData;
1166     // Ensure we keep any cached witnesses we may already have
1167     for (const std::pair<JSOutPoint, CNoteData> nd : wtx.mapNoteData) {
1168         if (tmp.count(nd.first) && nd.second.witnesses.size() > 0) {
1169             tmp.at(nd.first).witnesses.assign(
1170                 nd.second.witnesses.cbegin(), nd.second.witnesses.cend());
1171         }
1172         tmp.at(nd.first).witnessHeight = nd.second.witnessHeight;
1173     }
1174     // Now copy over the updated note data
1175     wtx.mapNoteData = tmp;
1176     return true;
1177 }
1178
1179 /**
1180  * Add a transaction to the wallet, or update it.
1181  * pblock is optional, but should be provided if the transaction is known to be in a block.
1182  * If fUpdate is true, existing transactions will be updated.
1183  */
1184 bool CWallet::AddToWalletIfInvolvingMe(const CTransaction& tx, const CBlock* pblock, bool fUpdate)
1185 {
1186     {
1187         AssertLockHeld(cs_wallet);
1188         bool fExisted = mapWallet.count(tx.GetHash()) != 0;
1189         if (fExisted && !fUpdate) return false;
1190         auto noteData = FindMyNotes(tx);
1191         if (fExisted || IsMine(tx) || IsFromMe(tx) || noteData.size() > 0)
1192         {
1193             CWalletTx wtx(this,tx);
1194
1195             if (noteData.size() > 0) {
1196                 wtx.SetNoteData(noteData);
1197             }
1198
1199             // Get merkle branch if transaction was found in a block
1200             if (pblock)
1201                 wtx.SetMerkleBranch(*pblock);
1202
1203             // Do not flush the wallet here for performance reasons
1204             // this is safe, as in case of a crash, we rescan the necessary blocks on startup through our SetBestChain-mechanism
1205             CWalletDB walletdb(strWalletFile, "r+", false);
1206
1207             return AddToWallet(wtx, false, &walletdb);
1208         }
1209     }
1210     return false;
1211 }
1212
1213 void CWallet::SyncTransaction(const CTransaction& tx, const CBlock* pblock)
1214 {
1215     LOCK2(cs_main, cs_wallet);
1216     if (!AddToWalletIfInvolvingMe(tx, pblock, true))
1217         return; // Not one of ours
1218
1219     MarkAffectedTransactionsDirty(tx);
1220 }
1221
1222 void CWallet::MarkAffectedTransactionsDirty(const CTransaction& tx)
1223 {
1224     // If a transaction changes 'conflicted' state, that changes the balance
1225     // available of the outputs it spends. So force those to be
1226     // recomputed, also:
1227     BOOST_FOREACH(const CTxIn& txin, tx.vin)
1228     {
1229         if (mapWallet.count(txin.prevout.hash))
1230             mapWallet[txin.prevout.hash].MarkDirty();
1231     }
1232     for (const JSDescription& jsdesc : tx.vjoinsplit) {
1233         for (const uint256& nullifier : jsdesc.nullifiers) {
1234             if (mapNullifiersToNotes.count(nullifier) &&
1235                     mapWallet.count(mapNullifiersToNotes[nullifier].hash)) {
1236                 mapWallet[mapNullifiersToNotes[nullifier].hash].MarkDirty();
1237             }
1238         }
1239     }
1240 }
1241
1242 void CWallet::EraseFromWallet(const uint256 &hash)
1243 {
1244     if (!fFileBacked)
1245         return;
1246     {
1247         LOCK(cs_wallet);
1248         if (mapWallet.erase(hash))
1249             CWalletDB(strWalletFile).EraseTx(hash);
1250     }
1251     return;
1252 }
1253
1254
1255 /**
1256  * Returns a nullifier if the SpendingKey is available
1257  * Throws std::runtime_error if the decryptor doesn't match this note
1258  */
1259 boost::optional<uint256> CWallet::GetNoteNullifier(const JSDescription& jsdesc,
1260                                                    const libzcash::PaymentAddress& address,
1261                                                    const ZCNoteDecryption& dec,
1262                                                    const uint256& hSig,
1263                                                    uint8_t n) const
1264 {
1265     boost::optional<uint256> ret;
1266     auto note_pt = libzcash::NotePlaintext::decrypt(
1267         dec,
1268         jsdesc.ciphertexts[n],
1269         jsdesc.ephemeralKey,
1270         hSig,
1271         (unsigned char) n);
1272     auto note = note_pt.note(address);
1273     // SpendingKeys are only available if:
1274     // - We have them (this isn't a viewing key)
1275     // - The wallet is unlocked
1276     libzcash::SpendingKey key;
1277     if (GetSpendingKey(address, key)) {
1278         ret = note.nullifier(key);
1279     }
1280     return ret;
1281 }
1282
1283 /**
1284  * Finds all output notes in the given transaction that have been sent to
1285  * PaymentAddresses in this wallet.
1286  *
1287  * It should never be necessary to call this method with a CWalletTx, because
1288  * the result of FindMyNotes (for the addresses available at the time) will
1289  * already have been cached in CWalletTx.mapNoteData.
1290  */
1291 mapNoteData_t CWallet::FindMyNotes(const CTransaction& tx) const
1292 {
1293     LOCK(cs_SpendingKeyStore);
1294     uint256 hash = tx.GetHash();
1295
1296     mapNoteData_t noteData;
1297     for (size_t i = 0; i < tx.vjoinsplit.size(); i++) {
1298         auto hSig = tx.vjoinsplit[i].h_sig(*pzcashParams, tx.joinSplitPubKey);
1299         for (uint8_t j = 0; j < tx.vjoinsplit[i].ciphertexts.size(); j++) {
1300             for (const NoteDecryptorMap::value_type& item : mapNoteDecryptors) {
1301                 try {
1302                     auto address = item.first;
1303                     JSOutPoint jsoutpt {hash, i, j};
1304                     auto nullifier = GetNoteNullifier(
1305                         tx.vjoinsplit[i],
1306                         address,
1307                         item.second,
1308                         hSig, j);
1309                     if (nullifier) {
1310                         CNoteData nd {address, *nullifier};
1311                         noteData.insert(std::make_pair(jsoutpt, nd));
1312                     } else {
1313                         CNoteData nd {address};
1314                         noteData.insert(std::make_pair(jsoutpt, nd));
1315                     }
1316                     break;
1317                 } catch (const note_decryption_failed &err) {
1318                     // Couldn't decrypt with this decryptor
1319                 } catch (const std::exception &exc) {
1320                     // Unexpected failure
1321                     LogPrintf("FindMyNotes(): Unexpected error while testing decrypt:\n");
1322                     LogPrintf("%s\n", exc.what());
1323                 }
1324             }
1325         }
1326     }
1327     return noteData;
1328 }
1329
1330 bool CWallet::IsFromMe(const uint256& nullifier) const
1331 {
1332     {
1333         LOCK(cs_wallet);
1334         if (mapNullifiersToNotes.count(nullifier) &&
1335                 mapWallet.count(mapNullifiersToNotes.at(nullifier).hash)) {
1336             return true;
1337         }
1338     }
1339     return false;
1340 }
1341
1342 void CWallet::GetNoteWitnesses(std::vector<JSOutPoint> notes,
1343                                std::vector<boost::optional<ZCIncrementalWitness>>& witnesses,
1344                                uint256 &final_anchor)
1345 {
1346     {
1347         LOCK(cs_wallet);
1348         witnesses.resize(notes.size());
1349         boost::optional<uint256> rt;
1350         int i = 0;
1351         for (JSOutPoint note : notes) {
1352             if (mapWallet.count(note.hash) &&
1353                     mapWallet[note.hash].mapNoteData.count(note) &&
1354                     mapWallet[note.hash].mapNoteData[note].witnesses.size() > 0) {
1355                 witnesses[i] = mapWallet[note.hash].mapNoteData[note].witnesses.front();
1356                 if (!rt) {
1357                     rt = witnesses[i]->root();
1358                 } else {
1359                     assert(*rt == witnesses[i]->root());
1360                 }
1361             }
1362             i++;
1363         }
1364         // All returned witnesses have the same anchor
1365         if (rt) {
1366             final_anchor = *rt;
1367         }
1368     }
1369 }
1370
1371 isminetype CWallet::IsMine(const CTxIn &txin) const
1372 {
1373     {
1374         LOCK(cs_wallet);
1375         map<uint256, CWalletTx>::const_iterator mi = mapWallet.find(txin.prevout.hash);
1376         if (mi != mapWallet.end())
1377         {
1378             const CWalletTx& prev = (*mi).second;
1379             if (txin.prevout.n < prev.vout.size())
1380                 return IsMine(prev.vout[txin.prevout.n]);
1381         }
1382     }
1383     return ISMINE_NO;
1384 }
1385
1386 CAmount CWallet::GetDebit(const CTxIn &txin, const isminefilter& filter) const
1387 {
1388     {
1389         LOCK(cs_wallet);
1390         map<uint256, CWalletTx>::const_iterator mi = mapWallet.find(txin.prevout.hash);
1391         if (mi != mapWallet.end())
1392         {
1393             const CWalletTx& prev = (*mi).second;
1394             if (txin.prevout.n < prev.vout.size())
1395                 if (IsMine(prev.vout[txin.prevout.n]) & filter)
1396                     return prev.vout[txin.prevout.n].nValue;
1397         }
1398     }
1399     return 0;
1400 }
1401
1402 isminetype CWallet::IsMine(const CTxOut& txout) const
1403 {
1404     return ::IsMine(*this, txout.scriptPubKey);
1405 }
1406
1407 CAmount CWallet::GetCredit(const CTxOut& txout, const isminefilter& filter) const
1408 {
1409     if (!MoneyRange(txout.nValue))
1410         throw std::runtime_error("CWallet::GetCredit(): value out of range");
1411     return ((IsMine(txout) & filter) ? txout.nValue : 0);
1412 }
1413
1414 bool CWallet::IsChange(const CTxOut& txout) const
1415 {
1416     // TODO: fix handling of 'change' outputs. The assumption is that any
1417     // payment to a script that is ours, but is not in the address book
1418     // is change. That assumption is likely to break when we implement multisignature
1419     // wallets that return change back into a multi-signature-protected address;
1420     // a better way of identifying which outputs are 'the send' and which are
1421     // 'the change' will need to be implemented (maybe extend CWalletTx to remember
1422     // which output, if any, was change).
1423     if (::IsMine(*this, txout.scriptPubKey))
1424     {
1425         CTxDestination address;
1426         if (!ExtractDestination(txout.scriptPubKey, address))
1427             return true;
1428
1429         LOCK(cs_wallet);
1430         if (!mapAddressBook.count(address))
1431             return true;
1432     }
1433     return false;
1434 }
1435
1436 CAmount CWallet::GetChange(const CTxOut& txout) const
1437 {
1438     if (!MoneyRange(txout.nValue))
1439         throw std::runtime_error("CWallet::GetChange(): value out of range");
1440     return (IsChange(txout) ? txout.nValue : 0);
1441 }
1442
1443 bool CWallet::IsMine(const CTransaction& tx) const
1444 {
1445     BOOST_FOREACH(const CTxOut& txout, tx.vout)
1446         if (IsMine(txout))
1447             return true;
1448     return false;
1449 }
1450
1451 bool CWallet::IsFromMe(const CTransaction& tx) const
1452 {
1453     if (GetDebit(tx, ISMINE_ALL) > 0) {
1454         return true;
1455     }
1456     for (const JSDescription& jsdesc : tx.vjoinsplit) {
1457         for (const uint256& nullifier : jsdesc.nullifiers) {
1458             if (IsFromMe(nullifier)) {
1459                 return true;
1460             }
1461         }
1462     }
1463     return false;
1464 }
1465
1466 CAmount CWallet::GetDebit(const CTransaction& tx, const isminefilter& filter) const
1467 {
1468     CAmount nDebit = 0;
1469     BOOST_FOREACH(const CTxIn& txin, tx.vin)
1470     {
1471         nDebit += GetDebit(txin, filter);
1472         if (!MoneyRange(nDebit))
1473             throw std::runtime_error("CWallet::GetDebit(): value out of range");
1474     }
1475     return nDebit;
1476 }
1477
1478 CAmount CWallet::GetCredit(const CTransaction& tx, const isminefilter& filter) const
1479 {
1480     CAmount nCredit = 0;
1481     BOOST_FOREACH(const CTxOut& txout, tx.vout)
1482     {
1483         nCredit += GetCredit(txout, filter);
1484         if (!MoneyRange(nCredit))
1485             throw std::runtime_error("CWallet::GetCredit(): value out of range");
1486     }
1487     return nCredit;
1488 }
1489
1490 CAmount CWallet::GetChange(const CTransaction& tx) const
1491 {
1492     CAmount nChange = 0;
1493     BOOST_FOREACH(const CTxOut& txout, tx.vout)
1494     {
1495         nChange += GetChange(txout);
1496         if (!MoneyRange(nChange))
1497             throw std::runtime_error("CWallet::GetChange(): value out of range");
1498     }
1499     return nChange;
1500 }
1501
1502 void CWalletTx::SetNoteData(mapNoteData_t &noteData)
1503 {
1504     mapNoteData.clear();
1505     for (const std::pair<JSOutPoint, CNoteData> nd : noteData) {
1506         if (nd.first.js < vjoinsplit.size() &&
1507                 nd.first.n < vjoinsplit[nd.first.js].ciphertexts.size()) {
1508             // Store the address and nullifier for the Note
1509             mapNoteData[nd.first] = nd.second;
1510         } else {
1511             // If FindMyNotes() was used to obtain noteData,
1512             // this should never happen
1513             throw std::logic_error("CWalletTx::SetNoteData(): Invalid note");
1514         }
1515     }
1516 }
1517
1518 int64_t CWalletTx::GetTxTime() const
1519 {
1520     int64_t n = nTimeSmart;
1521     return n ? n : nTimeReceived;
1522 }
1523
1524 int CWalletTx::GetRequestCount() const
1525 {
1526     // Returns -1 if it wasn't being tracked
1527     int nRequests = -1;
1528     {
1529         LOCK(pwallet->cs_wallet);
1530         if (IsCoinBase())
1531         {
1532             // Generated block
1533             if (!hashBlock.IsNull())
1534             {
1535                 map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(hashBlock);
1536                 if (mi != pwallet->mapRequestCount.end())
1537                     nRequests = (*mi).second;
1538             }
1539         }
1540         else
1541         {
1542             // Did anyone request this transaction?
1543             map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(GetHash());
1544             if (mi != pwallet->mapRequestCount.end())
1545             {
1546                 nRequests = (*mi).second;
1547
1548                 // How about the block it's in?
1549                 if (nRequests == 0 && !hashBlock.IsNull())
1550                 {
1551                     map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(hashBlock);
1552                     if (mi != pwallet->mapRequestCount.end())
1553                         nRequests = (*mi).second;
1554                     else
1555                         nRequests = 1; // If it's in someone else's block it must have got out
1556                 }
1557             }
1558         }
1559     }
1560     return nRequests;
1561 }
1562
1563 // GetAmounts will determine the transparent debits and credits for a given wallet tx.
1564 void CWalletTx::GetAmounts(list<COutputEntry>& listReceived,
1565                            list<COutputEntry>& listSent, CAmount& nFee, string& strSentAccount, const isminefilter& filter) const
1566 {
1567     nFee = 0;
1568     listReceived.clear();
1569     listSent.clear();
1570     strSentAccount = strFromAccount;
1571
1572     // Is this tx sent/signed by me?
1573     CAmount nDebit = GetDebit(filter);
1574     bool isFromMyTaddr = nDebit > 0; // debit>0 means we signed/sent this transaction
1575
1576     // Does this tx spend my notes?
1577     bool isFromMyZaddr = false;
1578     for (const JSDescription& js : vjoinsplit) {
1579         for (const uint256& nullifier : js.nullifiers) {
1580             if (pwallet->IsFromMe(nullifier)) {
1581                 isFromMyZaddr = true;
1582                 break;
1583             }
1584         }
1585         if (isFromMyZaddr) {
1586             break;
1587         }
1588     }
1589
1590     // Compute fee if we sent this transaction.
1591     if (isFromMyTaddr) {
1592         CAmount nValueOut = GetValueOut();  // transparent outputs plus all vpub_old
1593         CAmount nValueIn = 0;
1594         for (const JSDescription & js : vjoinsplit) {
1595             nValueIn += js.vpub_new;
1596         }
1597         nFee = nDebit - nValueOut + nValueIn;
1598     }
1599
1600     // Create output entry for vpub_old/new, if we sent utxos from this transaction
1601     if (isFromMyTaddr) {
1602         CAmount myVpubOld = 0;
1603         CAmount myVpubNew = 0;
1604         for (const JSDescription& js : vjoinsplit) {
1605             bool fMyJSDesc = false;
1606
1607             // Check input side
1608             for (const uint256& nullifier : js.nullifiers) {
1609                 if (pwallet->IsFromMe(nullifier)) {
1610                     fMyJSDesc = true;
1611                     break;
1612                 }
1613             }
1614
1615             // Check output side
1616             if (!fMyJSDesc) {
1617                 for (const std::pair<JSOutPoint, CNoteData> nd : this->mapNoteData) {
1618                     if (nd.first.js < vjoinsplit.size() && nd.first.n < vjoinsplit[nd.first.js].ciphertexts.size()) {
1619                         fMyJSDesc = true;
1620                         break;
1621                     }
1622                 }
1623             }
1624
1625             if (fMyJSDesc) {
1626                 myVpubOld += js.vpub_old;
1627                 myVpubNew += js.vpub_new;
1628             }
1629
1630             if (!MoneyRange(js.vpub_old) || !MoneyRange(js.vpub_new) || !MoneyRange(myVpubOld) || !MoneyRange(myVpubNew)) {
1631                  throw std::runtime_error("CWalletTx::GetAmounts: value out of range");
1632             }
1633         }
1634
1635         // Create an output for the value taken from or added to the transparent value pool by JoinSplits
1636         if (myVpubOld > myVpubNew) {
1637             COutputEntry output = {CNoDestination(), myVpubOld - myVpubNew, (int)vout.size()};
1638             listSent.push_back(output);
1639         } else if (myVpubNew > myVpubOld) {
1640             COutputEntry output = {CNoDestination(), myVpubNew - myVpubOld, (int)vout.size()};
1641             listReceived.push_back(output);
1642         }
1643     }
1644
1645     // Sent/received.
1646     for (unsigned int i = 0; i < vout.size(); ++i)
1647     {
1648         const CTxOut& txout = vout[i];
1649         isminetype fIsMine = pwallet->IsMine(txout);
1650         // Only need to handle txouts if AT LEAST one of these is true:
1651         //   1) they debit from us (sent)
1652         //   2) the output is to us (received)
1653         if (nDebit > 0)
1654         {
1655             // Don't report 'change' txouts
1656             if (pwallet->IsChange(txout))
1657                 continue;
1658         }
1659         else if (!(fIsMine & filter))
1660             continue;
1661
1662         // In either case, we need to get the destination address
1663         CTxDestination address;
1664         if (!ExtractDestination(txout.scriptPubKey, address))
1665         {
1666             LogPrintf("CWalletTx::GetAmounts: Unknown transaction type found, txid %s\n",
1667                      this->GetHash().ToString());
1668             address = CNoDestination();
1669         }
1670
1671         COutputEntry output = {address, txout.nValue, (int)i};
1672
1673         // If we are debited by the transaction, add the output as a "sent" entry
1674         if (nDebit > 0)
1675             listSent.push_back(output);
1676
1677         // If we are receiving the output, add it as a "received" entry
1678         if (fIsMine & filter)
1679             listReceived.push_back(output);
1680     }
1681
1682 }
1683
1684 void CWalletTx::GetAccountAmounts(const string& strAccount, CAmount& nReceived,
1685                                   CAmount& nSent, CAmount& nFee, const isminefilter& filter) const
1686 {
1687     nReceived = nSent = nFee = 0;
1688
1689     CAmount allFee;
1690     string strSentAccount;
1691     list<COutputEntry> listReceived;
1692     list<COutputEntry> listSent;
1693     GetAmounts(listReceived, listSent, allFee, strSentAccount, filter);
1694
1695     if (strAccount == strSentAccount)
1696     {
1697         BOOST_FOREACH(const COutputEntry& s, listSent)
1698             nSent += s.amount;
1699         nFee = allFee;
1700     }
1701     {
1702         LOCK(pwallet->cs_wallet);
1703         BOOST_FOREACH(const COutputEntry& r, listReceived)
1704         {
1705             if (pwallet->mapAddressBook.count(r.destination))
1706             {
1707                 map<CTxDestination, CAddressBookData>::const_iterator mi = pwallet->mapAddressBook.find(r.destination);
1708                 if (mi != pwallet->mapAddressBook.end() && (*mi).second.name == strAccount)
1709                     nReceived += r.amount;
1710             }
1711             else if (strAccount.empty())
1712             {
1713                 nReceived += r.amount;
1714             }
1715         }
1716     }
1717 }
1718
1719
1720 bool CWalletTx::WriteToDisk(CWalletDB *pwalletdb)
1721 {
1722     return pwalletdb->WriteTx(GetHash(), *this);
1723 }
1724
1725 void CWallet::WitnessNoteCommitment(std::vector<uint256> commitments,
1726                                     std::vector<boost::optional<ZCIncrementalWitness>>& witnesses,
1727                                     uint256 &final_anchor)
1728 {
1729     witnesses.resize(commitments.size());
1730     CBlockIndex* pindex = chainActive.Genesis();
1731     ZCIncrementalMerkleTree tree;
1732
1733     while (pindex) {
1734         CBlock block;
1735         ReadBlockFromDisk(block, pindex);
1736
1737         BOOST_FOREACH(const CTransaction& tx, block.vtx)
1738         {
1739             BOOST_FOREACH(const JSDescription& jsdesc, tx.vjoinsplit)
1740             {
1741                 BOOST_FOREACH(const uint256 &note_commitment, jsdesc.commitments)
1742                 {
1743                     tree.append(note_commitment);
1744
1745                     BOOST_FOREACH(boost::optional<ZCIncrementalWitness>& wit, witnesses) {
1746                         if (wit) {
1747                             wit->append(note_commitment);
1748                         }
1749                     }
1750
1751                     size_t i = 0;
1752                     BOOST_FOREACH(uint256& commitment, commitments) {
1753                         if (note_commitment == commitment) {
1754                             witnesses.at(i) = tree.witness();
1755                         }
1756                         i++;
1757                     }
1758                 }
1759             }
1760         }
1761
1762         uint256 current_anchor = tree.root();
1763
1764         // Consistency check: we should be able to find the current tree
1765         // in our CCoins view.
1766         ZCIncrementalMerkleTree dummy_tree;
1767         assert(pcoinsTip->GetAnchorAt(current_anchor, dummy_tree));
1768
1769         pindex = chainActive.Next(pindex);
1770     }
1771
1772     // TODO: #93; Select a root via some heuristic.
1773     final_anchor = tree.root();
1774
1775     BOOST_FOREACH(boost::optional<ZCIncrementalWitness>& wit, witnesses) {
1776         if (wit) {
1777             assert(final_anchor == wit->root());
1778         }
1779     }
1780 }
1781
1782 /**
1783  * Scan the block chain (starting in pindexStart) for transactions
1784  * from or to us. If fUpdate is true, found transactions that already
1785  * exist in the wallet will be updated.
1786  */
1787 int CWallet::ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate)
1788 {
1789     int ret = 0;
1790     int64_t nNow = GetTime();
1791     const CChainParams& chainParams = Params();
1792
1793     CBlockIndex* pindex = pindexStart;
1794     {
1795         LOCK2(cs_main, cs_wallet);
1796
1797         // no need to read and scan block, if block was created before
1798         // our wallet birthday (as adjusted for block time variability)
1799         while (pindex && nTimeFirstKey && (pindex->GetBlockTime() < (nTimeFirstKey - 7200)))
1800             pindex = chainActive.Next(pindex);
1801
1802         ShowProgress(_("Rescanning..."), 0); // show rescan progress in GUI as dialog or on splashscreen, if -rescan on startup
1803         double dProgressStart = Checkpoints::GuessVerificationProgress(chainParams.Checkpoints(), pindex, false);
1804         double dProgressTip = Checkpoints::GuessVerificationProgress(chainParams.Checkpoints(), chainActive.Tip(), false);
1805         while (pindex)
1806         {
1807             if (pindex->nHeight % 100 == 0 && dProgressTip - dProgressStart > 0.0)
1808                 ShowProgress(_("Rescanning..."), std::max(1, std::min(99, (int)((Checkpoints::GuessVerificationProgress(chainParams.Checkpoints(), pindex, false) - dProgressStart) / (dProgressTip - dProgressStart) * 100))));
1809
1810             CBlock block;
1811             ReadBlockFromDisk(block, pindex);
1812             BOOST_FOREACH(CTransaction& tx, block.vtx)
1813             {
1814                 if (AddToWalletIfInvolvingMe(tx, &block, fUpdate))
1815                     ret++;
1816             }
1817
1818             ZCIncrementalMerkleTree tree;
1819             // This should never fail: we should always be able to get the tree
1820             // state on the path to the tip of our chain
1821             assert(pcoinsTip->GetAnchorAt(pindex->hashAnchor, tree));
1822             // Increment note witness caches
1823             IncrementNoteWitnesses(pindex, &block, tree);
1824
1825             pindex = chainActive.Next(pindex);
1826             if (GetTime() >= nNow + 60) {
1827                 nNow = GetTime();
1828                 LogPrintf("Still rescanning. At block %d. Progress=%f\n", pindex->nHeight, Checkpoints::GuessVerificationProgress(chainParams.Checkpoints(), pindex));
1829             }
1830         }
1831         ShowProgress(_("Rescanning..."), 100); // hide progress dialog in GUI
1832     }
1833     return ret;
1834 }
1835
1836 void CWallet::ReacceptWalletTransactions()
1837 {
1838     // If transactions aren't being broadcasted, don't let them into local mempool either
1839     if (!fBroadcastTransactions)
1840         return;
1841     LOCK2(cs_main, cs_wallet);
1842     std::map<int64_t, CWalletTx*> mapSorted;
1843
1844     // Sort pending wallet transactions based on their initial wallet insertion order
1845     BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet)
1846     {
1847         const uint256& wtxid = item.first;
1848         CWalletTx& wtx = item.second;
1849         assert(wtx.GetHash() == wtxid);
1850
1851         int nDepth = wtx.GetDepthInMainChain();
1852
1853         if (!wtx.IsCoinBase() && nDepth < 0) {
1854             mapSorted.insert(std::make_pair(wtx.nOrderPos, &wtx));
1855         }
1856     }
1857
1858     // Try to add wallet transactions to memory pool
1859     BOOST_FOREACH(PAIRTYPE(const int64_t, CWalletTx*)& item, mapSorted)
1860     {
1861         CWalletTx& wtx = *(item.second);
1862
1863         LOCK(mempool.cs);
1864         wtx.AcceptToMemoryPool(false);
1865     }
1866 }
1867
1868 bool CWalletTx::RelayWalletTransaction()
1869 {
1870     assert(pwallet->GetBroadcastTransactions());
1871     if (!IsCoinBase())
1872     {
1873         if (GetDepthInMainChain() == 0) {
1874             LogPrintf("Relaying wtx %s\n", GetHash().ToString());
1875             RelayTransaction((CTransaction)*this);
1876             return true;
1877         }
1878     }
1879     return false;
1880 }
1881
1882 set<uint256> CWalletTx::GetConflicts() const
1883 {
1884     set<uint256> result;
1885     if (pwallet != NULL)
1886     {
1887         uint256 myHash = GetHash();
1888         result = pwallet->GetConflicts(myHash);
1889         result.erase(myHash);
1890     }
1891     return result;
1892 }
1893
1894 CAmount CWalletTx::GetDebit(const isminefilter& filter) const
1895 {
1896     if (vin.empty())
1897         return 0;
1898
1899     CAmount debit = 0;
1900     if(filter & ISMINE_SPENDABLE)
1901     {
1902         if (fDebitCached)
1903             debit += nDebitCached;
1904         else
1905         {
1906             nDebitCached = pwallet->GetDebit(*this, ISMINE_SPENDABLE);
1907             fDebitCached = true;
1908             debit += nDebitCached;
1909         }
1910     }
1911     if(filter & ISMINE_WATCH_ONLY)
1912     {
1913         if(fWatchDebitCached)
1914             debit += nWatchDebitCached;
1915         else
1916         {
1917             nWatchDebitCached = pwallet->GetDebit(*this, ISMINE_WATCH_ONLY);
1918             fWatchDebitCached = true;
1919             debit += nWatchDebitCached;
1920         }
1921     }
1922     return debit;
1923 }
1924
1925 CAmount CWalletTx::GetCredit(const isminefilter& filter) const
1926 {
1927     // Must wait until coinbase is safely deep enough in the chain before valuing it
1928     if (IsCoinBase() && GetBlocksToMaturity() > 0)
1929         return 0;
1930
1931     int64_t credit = 0;
1932     if (filter & ISMINE_SPENDABLE)
1933     {
1934         // GetBalance can assume transactions in mapWallet won't change
1935         if (fCreditCached)
1936             credit += nCreditCached;
1937         else
1938         {
1939             nCreditCached = pwallet->GetCredit(*this, ISMINE_SPENDABLE);
1940             fCreditCached = true;
1941             credit += nCreditCached;
1942         }
1943     }
1944     if (filter & ISMINE_WATCH_ONLY)
1945     {
1946         if (fWatchCreditCached)
1947             credit += nWatchCreditCached;
1948         else
1949         {
1950             nWatchCreditCached = pwallet->GetCredit(*this, ISMINE_WATCH_ONLY);
1951             fWatchCreditCached = true;
1952             credit += nWatchCreditCached;
1953         }
1954     }
1955     return credit;
1956 }
1957
1958 CAmount CWalletTx::GetImmatureCredit(bool fUseCache) const
1959 {
1960     if (IsCoinBase() && GetBlocksToMaturity() > 0 && IsInMainChain())
1961     {
1962         if (fUseCache && fImmatureCreditCached)
1963             return nImmatureCreditCached;
1964         nImmatureCreditCached = pwallet->GetCredit(*this, ISMINE_SPENDABLE);
1965         fImmatureCreditCached = true;
1966         return nImmatureCreditCached;
1967     }
1968
1969     return 0;
1970 }
1971
1972 CAmount CWalletTx::GetAvailableCredit(bool fUseCache) const
1973 {
1974     if (pwallet == 0)
1975         return 0;
1976
1977     // Must wait until coinbase is safely deep enough in the chain before valuing it
1978     if (IsCoinBase() && GetBlocksToMaturity() > 0)
1979         return 0;
1980
1981     if (fUseCache && fAvailableCreditCached)
1982         return nAvailableCreditCached;
1983
1984     CAmount nCredit = 0;
1985     uint256 hashTx = GetHash();
1986     for (unsigned int i = 0; i < vout.size(); i++)
1987     {
1988         if (!pwallet->IsSpent(hashTx, i))
1989         {
1990             const CTxOut &txout = vout[i];
1991             nCredit += pwallet->GetCredit(txout, ISMINE_SPENDABLE);
1992             if (!MoneyRange(nCredit))
1993                 throw std::runtime_error("CWalletTx::GetAvailableCredit() : value out of range");
1994         }
1995     }
1996
1997     nAvailableCreditCached = nCredit;
1998     fAvailableCreditCached = true;
1999     return nCredit;
2000 }
2001
2002 CAmount CWalletTx::GetImmatureWatchOnlyCredit(const bool& fUseCache) const
2003 {
2004     if (IsCoinBase() && GetBlocksToMaturity() > 0 && IsInMainChain())
2005     {
2006         if (fUseCache && fImmatureWatchCreditCached)
2007             return nImmatureWatchCreditCached;
2008         nImmatureWatchCreditCached = pwallet->GetCredit(*this, ISMINE_WATCH_ONLY);
2009         fImmatureWatchCreditCached = true;
2010         return nImmatureWatchCreditCached;
2011     }
2012
2013     return 0;
2014 }
2015
2016 CAmount CWalletTx::GetAvailableWatchOnlyCredit(const bool& fUseCache) const
2017 {
2018     if (pwallet == 0)
2019         return 0;
2020
2021     // Must wait until coinbase is safely deep enough in the chain before valuing it
2022     if (IsCoinBase() && GetBlocksToMaturity() > 0)
2023         return 0;
2024
2025     if (fUseCache && fAvailableWatchCreditCached)
2026         return nAvailableWatchCreditCached;
2027
2028     CAmount nCredit = 0;
2029     for (unsigned int i = 0; i < vout.size(); i++)
2030     {
2031         if (!pwallet->IsSpent(GetHash(), i))
2032         {
2033             const CTxOut &txout = vout[i];
2034             nCredit += pwallet->GetCredit(txout, ISMINE_WATCH_ONLY);
2035             if (!MoneyRange(nCredit))
2036                 throw std::runtime_error("CWalletTx::GetAvailableCredit() : value out of range");
2037         }
2038     }
2039
2040     nAvailableWatchCreditCached = nCredit;
2041     fAvailableWatchCreditCached = true;
2042     return nCredit;
2043 }
2044
2045 CAmount CWalletTx::GetChange() const
2046 {
2047     if (fChangeCached)
2048         return nChangeCached;
2049     nChangeCached = pwallet->GetChange(*this);
2050     fChangeCached = true;
2051     return nChangeCached;
2052 }
2053
2054 bool CWalletTx::IsTrusted() const
2055 {
2056     // Quick answer in most cases
2057     if (!CheckFinalTx(*this))
2058         return false;
2059     int nDepth = GetDepthInMainChain();
2060     if (nDepth >= 1)
2061         return true;
2062     if (nDepth < 0)
2063         return false;
2064     if (!bSpendZeroConfChange || !IsFromMe(ISMINE_ALL)) // using wtx's cached debit
2065         return false;
2066
2067     // Trusted if all inputs are from us and are in the mempool:
2068     BOOST_FOREACH(const CTxIn& txin, vin)
2069     {
2070         // Transactions not sent by us: not trusted
2071         const CWalletTx* parent = pwallet->GetWalletTx(txin.prevout.hash);
2072         if (parent == NULL)
2073             return false;
2074         const CTxOut& parentOut = parent->vout[txin.prevout.n];
2075         if (pwallet->IsMine(parentOut) != ISMINE_SPENDABLE)
2076             return false;
2077     }
2078     return true;
2079 }
2080
2081 std::vector<uint256> CWallet::ResendWalletTransactionsBefore(int64_t nTime)
2082 {
2083     std::vector<uint256> result;
2084
2085     LOCK(cs_wallet);
2086     // Sort them in chronological order
2087     multimap<unsigned int, CWalletTx*> mapSorted;
2088     BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet)
2089     {
2090         CWalletTx& wtx = item.second;
2091         // Don't rebroadcast if newer than nTime:
2092         if (wtx.nTimeReceived > nTime)
2093             continue;
2094         mapSorted.insert(make_pair(wtx.nTimeReceived, &wtx));
2095     }
2096     BOOST_FOREACH(PAIRTYPE(const unsigned int, CWalletTx*)& item, mapSorted)
2097     {
2098         CWalletTx& wtx = *item.second;
2099         if (wtx.RelayWalletTransaction())
2100             result.push_back(wtx.GetHash());
2101     }
2102     return result;
2103 }
2104
2105 void CWallet::ResendWalletTransactions(int64_t nBestBlockTime)
2106 {
2107     // Do this infrequently and randomly to avoid giving away
2108     // that these are our transactions.
2109     if (GetTime() < nNextResend || !fBroadcastTransactions)
2110         return;
2111     bool fFirst = (nNextResend == 0);
2112     nNextResend = GetTime() + GetRand(30 * 60);
2113     if (fFirst)
2114         return;
2115
2116     // Only do it if there's been a new block since last time
2117     if (nBestBlockTime < nLastResend)
2118         return;
2119     nLastResend = GetTime();
2120
2121     // Rebroadcast unconfirmed txes older than 5 minutes before the last
2122     // block was found:
2123     std::vector<uint256> relayed = ResendWalletTransactionsBefore(nBestBlockTime-5*60);
2124     if (!relayed.empty())
2125         LogPrintf("%s: rebroadcast %u unconfirmed transactions\n", __func__, relayed.size());
2126 }
2127
2128 /** @} */ // end of mapWallet
2129
2130
2131
2132
2133 /** @defgroup Actions
2134  *
2135  * @{
2136  */
2137
2138
2139 CAmount CWallet::GetBalance() const
2140 {
2141     CAmount nTotal = 0;
2142     {
2143         LOCK2(cs_main, cs_wallet);
2144         for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
2145         {
2146             const CWalletTx* pcoin = &(*it).second;
2147             if (pcoin->IsTrusted())
2148                 nTotal += pcoin->GetAvailableCredit();
2149         }
2150     }
2151
2152     return nTotal;
2153 }
2154
2155 CAmount CWallet::GetUnconfirmedBalance() const
2156 {
2157     CAmount nTotal = 0;
2158     {
2159         LOCK2(cs_main, cs_wallet);
2160         for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
2161         {
2162             const CWalletTx* pcoin = &(*it).second;
2163             if (!CheckFinalTx(*pcoin) || (!pcoin->IsTrusted() && pcoin->GetDepthInMainChain() == 0))
2164                 nTotal += pcoin->GetAvailableCredit();
2165         }
2166     }
2167     return nTotal;
2168 }
2169
2170 CAmount CWallet::GetImmatureBalance() const
2171 {
2172     CAmount nTotal = 0;
2173     {
2174         LOCK2(cs_main, cs_wallet);
2175         for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
2176         {
2177             const CWalletTx* pcoin = &(*it).second;
2178             nTotal += pcoin->GetImmatureCredit();
2179         }
2180     }
2181     return nTotal;
2182 }
2183
2184 CAmount CWallet::GetWatchOnlyBalance() const
2185 {
2186     CAmount nTotal = 0;
2187     {
2188         LOCK2(cs_main, cs_wallet);
2189         for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
2190         {
2191             const CWalletTx* pcoin = &(*it).second;
2192             if (pcoin->IsTrusted())
2193                 nTotal += pcoin->GetAvailableWatchOnlyCredit();
2194         }
2195     }
2196
2197     return nTotal;
2198 }
2199
2200 CAmount CWallet::GetUnconfirmedWatchOnlyBalance() const
2201 {
2202     CAmount nTotal = 0;
2203     {
2204         LOCK2(cs_main, cs_wallet);
2205         for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
2206         {
2207             const CWalletTx* pcoin = &(*it).second;
2208             if (!CheckFinalTx(*pcoin) || (!pcoin->IsTrusted() && pcoin->GetDepthInMainChain() == 0))
2209                 nTotal += pcoin->GetAvailableWatchOnlyCredit();
2210         }
2211     }
2212     return nTotal;
2213 }
2214
2215 CAmount CWallet::GetImmatureWatchOnlyBalance() const
2216 {
2217     CAmount nTotal = 0;
2218     {
2219         LOCK2(cs_main, cs_wallet);
2220         for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
2221         {
2222             const CWalletTx* pcoin = &(*it).second;
2223             nTotal += pcoin->GetImmatureWatchOnlyCredit();
2224         }
2225     }
2226     return nTotal;
2227 }
2228
2229 /**
2230  * populate vCoins with vector of available COutputs.
2231  */
2232 void CWallet::AvailableCoins(vector<COutput>& vCoins, bool fOnlyConfirmed, const CCoinControl *coinControl, bool fIncludeZeroValue, bool fIncludeCoinBase) const
2233 {
2234     vCoins.clear();
2235
2236     {
2237         LOCK2(cs_main, cs_wallet);
2238         for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
2239         {
2240             const uint256& wtxid = it->first;
2241             const CWalletTx* pcoin = &(*it).second;
2242
2243             if (!CheckFinalTx(*pcoin))
2244                 continue;
2245
2246             if (fOnlyConfirmed && !pcoin->IsTrusted())
2247                 continue;
2248
2249             if (pcoin->IsCoinBase() && !fIncludeCoinBase)
2250                 continue;
2251
2252             if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0)
2253                 continue;
2254
2255             int nDepth = pcoin->GetDepthInMainChain();
2256             if (nDepth < 0)
2257                 continue;
2258
2259             for (unsigned int i = 0; i < pcoin->vout.size(); i++) {
2260                 isminetype mine = IsMine(pcoin->vout[i]);
2261                 if (!(IsSpent(wtxid, i)) && mine != ISMINE_NO &&
2262                     !IsLockedCoin((*it).first, i) && (pcoin->vout[i].nValue > 0 || fIncludeZeroValue) &&
2263                     (!coinControl || !coinControl->HasSelected() || coinControl->fAllowOtherInputs || coinControl->IsSelected((*it).first, i)))
2264                         vCoins.push_back(COutput(pcoin, i, nDepth, (mine & ISMINE_SPENDABLE) != ISMINE_NO));
2265             }
2266         }
2267     }
2268 }
2269
2270 static void ApproximateBestSubset(vector<pair<CAmount, pair<const CWalletTx*,unsigned int> > >vValue, const CAmount& nTotalLower, const CAmount& nTargetValue,
2271                                   vector<char>& vfBest, CAmount& nBest, int iterations = 1000)
2272 {
2273     vector<char> vfIncluded;
2274
2275     vfBest.assign(vValue.size(), true);
2276     nBest = nTotalLower;
2277
2278     seed_insecure_rand();
2279
2280     for (int nRep = 0; nRep < iterations && nBest != nTargetValue; nRep++)
2281     {
2282         vfIncluded.assign(vValue.size(), false);
2283         CAmount nTotal = 0;
2284         bool fReachedTarget = false;
2285         for (int nPass = 0; nPass < 2 && !fReachedTarget; nPass++)
2286         {
2287             for (unsigned int i = 0; i < vValue.size(); i++)
2288             {
2289                 //The solver here uses a randomized algorithm,
2290                 //the randomness serves no real security purpose but is just
2291                 //needed to prevent degenerate behavior and it is important
2292                 //that the rng is fast. We do not use a constant random sequence,
2293                 //because there may be some privacy improvement by making
2294                 //the selection random.
2295                 if (nPass == 0 ? insecure_rand()&1 : !vfIncluded[i])
2296                 {
2297                     nTotal += vValue[i].first;
2298                     vfIncluded[i] = true;
2299                     if (nTotal >= nTargetValue)
2300                     {
2301                         fReachedTarget = true;
2302                         if (nTotal < nBest)
2303                         {
2304                             nBest = nTotal;
2305                             vfBest = vfIncluded;
2306                         }
2307                         nTotal -= vValue[i].first;
2308                         vfIncluded[i] = false;
2309                     }
2310                 }
2311             }
2312         }
2313     }
2314 }
2315
2316 bool CWallet::SelectCoinsMinConf(const CAmount& nTargetValue, int nConfMine, int nConfTheirs, vector<COutput> vCoins,
2317                                  set<pair<const CWalletTx*,unsigned int> >& setCoinsRet, CAmount& nValueRet) const
2318 {
2319     setCoinsRet.clear();
2320     nValueRet = 0;
2321
2322     // List of values less than target
2323     pair<CAmount, pair<const CWalletTx*,unsigned int> > coinLowestLarger;
2324     coinLowestLarger.first = std::numeric_limits<CAmount>::max();
2325     coinLowestLarger.second.first = NULL;
2326     vector<pair<CAmount, pair<const CWalletTx*,unsigned int> > > vValue;
2327     CAmount nTotalLower = 0;
2328
2329     random_shuffle(vCoins.begin(), vCoins.end(), GetRandInt);
2330
2331     BOOST_FOREACH(const COutput &output, vCoins)
2332     {
2333         if (!output.fSpendable)
2334             continue;
2335
2336         const CWalletTx *pcoin = output.tx;
2337
2338         if (output.nDepth < (pcoin->IsFromMe(ISMINE_ALL) ? nConfMine : nConfTheirs))
2339             continue;
2340
2341         int i = output.i;
2342         CAmount n = pcoin->vout[i].nValue;
2343
2344         pair<CAmount,pair<const CWalletTx*,unsigned int> > coin = make_pair(n,make_pair(pcoin, i));
2345
2346         if (n == nTargetValue)
2347         {
2348             setCoinsRet.insert(coin.second);
2349             nValueRet += coin.first;
2350             return true;
2351         }
2352         else if (n < nTargetValue + CENT)
2353         {
2354             vValue.push_back(coin);
2355             nTotalLower += n;
2356         }
2357         else if (n < coinLowestLarger.first)
2358         {
2359             coinLowestLarger = coin;
2360         }
2361     }
2362
2363     if (nTotalLower == nTargetValue)
2364     {
2365         for (unsigned int i = 0; i < vValue.size(); ++i)
2366         {
2367             setCoinsRet.insert(vValue[i].second);
2368             nValueRet += vValue[i].first;
2369         }
2370         return true;
2371     }
2372
2373     if (nTotalLower < nTargetValue)
2374     {
2375         if (coinLowestLarger.second.first == NULL)
2376             return false;
2377         setCoinsRet.insert(coinLowestLarger.second);
2378         nValueRet += coinLowestLarger.first;
2379         return true;
2380     }
2381
2382     // Solve subset sum by stochastic approximation
2383     sort(vValue.rbegin(), vValue.rend(), CompareValueOnly());
2384     vector<char> vfBest;
2385     CAmount nBest;
2386
2387     ApproximateBestSubset(vValue, nTotalLower, nTargetValue, vfBest, nBest, 1000);
2388     if (nBest != nTargetValue && nTotalLower >= nTargetValue + CENT)
2389         ApproximateBestSubset(vValue, nTotalLower, nTargetValue + CENT, vfBest, nBest, 1000);
2390
2391     // If we have a bigger coin and (either the stochastic approximation didn't find a good solution,
2392     //                                   or the next bigger coin is closer), return the bigger coin
2393     if (coinLowestLarger.second.first &&
2394         ((nBest != nTargetValue && nBest < nTargetValue + CENT) || coinLowestLarger.first <= nBest))
2395     {
2396         setCoinsRet.insert(coinLowestLarger.second);
2397         nValueRet += coinLowestLarger.first;
2398     }
2399     else {
2400         for (unsigned int i = 0; i < vValue.size(); i++)
2401             if (vfBest[i])
2402             {
2403                 setCoinsRet.insert(vValue[i].second);
2404                 nValueRet += vValue[i].first;
2405             }
2406
2407         LogPrint("selectcoins", "SelectCoins() best subset: ");
2408         for (unsigned int i = 0; i < vValue.size(); i++)
2409             if (vfBest[i])
2410                 LogPrint("selectcoins", "%s ", FormatMoney(vValue[i].first));
2411         LogPrint("selectcoins", "total %s\n", FormatMoney(nBest));
2412     }
2413
2414     return true;
2415 }
2416
2417 bool CWallet::SelectCoins(const CAmount& nTargetValue, set<pair<const CWalletTx*,unsigned int> >& setCoinsRet, CAmount& nValueRet,  bool& fOnlyCoinbaseCoinsRet, bool& fNeedCoinbaseCoinsRet, const CCoinControl* coinControl) const
2418 {
2419     // Output parameter fOnlyCoinbaseCoinsRet is set to true when the only available coins are coinbase utxos.
2420     vector<COutput> vCoinsNoCoinbase, vCoinsWithCoinbase;
2421     AvailableCoins(vCoinsNoCoinbase, true, coinControl, false, false);
2422     AvailableCoins(vCoinsWithCoinbase, true, coinControl, false, true);
2423     fOnlyCoinbaseCoinsRet = vCoinsNoCoinbase.size() == 0 && vCoinsWithCoinbase.size() > 0;
2424
2425     // If coinbase utxos can only be sent to zaddrs, exclude any coinbase utxos from coin selection.
2426     bool fProtectCoinbase = Params().GetConsensus().fCoinbaseMustBeProtected;
2427     vector<COutput> vCoins = (fProtectCoinbase) ? vCoinsNoCoinbase : vCoinsWithCoinbase;
2428
2429     // Output parameter fNeedCoinbaseCoinsRet is set to true if coinbase utxos need to be spent to meet target amount
2430     if (fProtectCoinbase && vCoinsWithCoinbase.size() > vCoinsNoCoinbase.size()) {
2431         CAmount value = 0;
2432         for (const COutput& out : vCoinsNoCoinbase) {
2433             if (!out.fSpendable) {
2434                 continue;
2435             }
2436             value += out.tx->vout[out.i].nValue;
2437         }
2438         if (value <= nTargetValue) {
2439             CAmount valueWithCoinbase = 0;
2440             for (const COutput& out : vCoinsWithCoinbase) {
2441                 if (!out.fSpendable) {
2442                     continue;
2443                 }
2444                 valueWithCoinbase += out.tx->vout[out.i].nValue;
2445             }
2446             fNeedCoinbaseCoinsRet = (valueWithCoinbase >= nTargetValue);
2447         }
2448     }
2449
2450     // coin control -> return all selected outputs (we want all selected to go into the transaction for sure)
2451     if (coinControl && coinControl->HasSelected() && !coinControl->fAllowOtherInputs)
2452     {
2453         BOOST_FOREACH(const COutput& out, vCoins)
2454         {
2455             if (!out.fSpendable)
2456                  continue;
2457             nValueRet += out.tx->vout[out.i].nValue;
2458             setCoinsRet.insert(make_pair(out.tx, out.i));
2459         }
2460         return (nValueRet >= nTargetValue);
2461     }
2462
2463     // calculate value from preset inputs and store them
2464     set<pair<const CWalletTx*, uint32_t> > setPresetCoins;
2465     CAmount nValueFromPresetInputs = 0;
2466
2467     std::vector<COutPoint> vPresetInputs;
2468     if (coinControl)
2469         coinControl->ListSelected(vPresetInputs);
2470     BOOST_FOREACH(const COutPoint& outpoint, vPresetInputs)
2471     {
2472         map<uint256, CWalletTx>::const_iterator it = mapWallet.find(outpoint.hash);
2473         if (it != mapWallet.end())
2474         {
2475             const CWalletTx* pcoin = &it->second;
2476             // Clearly invalid input, fail
2477             if (pcoin->vout.size() <= outpoint.n)
2478                 return false;
2479             nValueFromPresetInputs += pcoin->vout[outpoint.n].nValue;
2480             setPresetCoins.insert(make_pair(pcoin, outpoint.n));
2481         } else
2482             return false; // TODO: Allow non-wallet inputs
2483     }
2484
2485     // remove preset inputs from vCoins
2486     for (vector<COutput>::iterator it = vCoins.begin(); it != vCoins.end() && coinControl && coinControl->HasSelected();)
2487     {
2488         if (setPresetCoins.count(make_pair(it->tx, it->i)))
2489             it = vCoins.erase(it);
2490         else
2491             ++it;
2492     }
2493
2494     bool res = nTargetValue <= nValueFromPresetInputs ||
2495         SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 1, 6, vCoins, setCoinsRet, nValueRet) ||
2496         SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 1, 1, vCoins, setCoinsRet, nValueRet) ||
2497         (bSpendZeroConfChange && SelectCoinsMinConf(nTargetValue - nValueFromPresetInputs, 0, 1, vCoins, setCoinsRet, nValueRet));
2498
2499     // because SelectCoinsMinConf clears the setCoinsRet, we now add the possible inputs to the coinset
2500     setCoinsRet.insert(setPresetCoins.begin(), setPresetCoins.end());
2501
2502     // add preset inputs to the total value selected
2503     nValueRet += nValueFromPresetInputs;
2504
2505     return res;
2506 }
2507
2508 bool CWallet::FundTransaction(CMutableTransaction& tx, CAmount &nFeeRet, int& nChangePosRet, std::string& strFailReason)
2509 {
2510     vector<CRecipient> vecSend;
2511
2512     // Turn the txout set into a CRecipient vector
2513     BOOST_FOREACH(const CTxOut& txOut, tx.vout)
2514     {
2515         CRecipient recipient = {txOut.scriptPubKey, txOut.nValue, false};
2516         vecSend.push_back(recipient);
2517     }
2518
2519     CCoinControl coinControl;
2520     coinControl.fAllowOtherInputs = true;
2521     BOOST_FOREACH(const CTxIn& txin, tx.vin)
2522         coinControl.Select(txin.prevout);
2523
2524     CReserveKey reservekey(this);
2525     CWalletTx wtx;
2526     if (!CreateTransaction(vecSend, wtx, reservekey, nFeeRet, nChangePosRet, strFailReason, &coinControl, false))
2527         return false;
2528
2529     if (nChangePosRet != -1)
2530         tx.vout.insert(tx.vout.begin() + nChangePosRet, wtx.vout[nChangePosRet]);
2531
2532     // Add new txins (keeping original txin scriptSig/order)
2533     BOOST_FOREACH(const CTxIn& txin, wtx.vin)
2534     {
2535         bool found = false;
2536         BOOST_FOREACH(const CTxIn& origTxIn, tx.vin)
2537         {
2538             if (txin.prevout.hash == origTxIn.prevout.hash && txin.prevout.n == origTxIn.prevout.n)
2539             {
2540                 found = true;
2541                 break;
2542             }
2543         }
2544         if (!found)
2545             tx.vin.push_back(txin);
2546     }
2547
2548     return true;
2549 }
2550
2551 bool CWallet::CreateTransaction(const vector<CRecipient>& vecSend, CWalletTx& wtxNew, CReserveKey& reservekey, CAmount& nFeeRet,
2552                                 int& nChangePosRet, std::string& strFailReason, const CCoinControl* coinControl, bool sign)
2553 {
2554     CAmount nValue = 0;
2555     unsigned int nSubtractFeeFromAmount = 0;
2556     BOOST_FOREACH (const CRecipient& recipient, vecSend)
2557     {
2558         if (nValue < 0 || recipient.nAmount < 0)
2559         {
2560             strFailReason = _("Transaction amounts must be positive");
2561             return false;
2562         }
2563         nValue += recipient.nAmount;
2564
2565         if (recipient.fSubtractFeeFromAmount)
2566             nSubtractFeeFromAmount++;
2567     }
2568     if (vecSend.empty() || nValue < 0)
2569     {
2570         strFailReason = _("Transaction amounts must be positive");
2571         return false;
2572     }
2573
2574     wtxNew.fTimeReceivedIsTxTime = true;
2575     wtxNew.BindWallet(this);
2576     CMutableTransaction txNew = CreateNewContextualCMutableTransaction(
2577         Params().GetConsensus(), chainActive.Height() + 1);
2578
2579     // Discourage fee sniping.
2580     //
2581     // However because of a off-by-one-error in previous versions we need to
2582     // neuter it by setting nLockTime to at least one less than nBestHeight.
2583     // Secondly currently propagation of transactions created for block heights
2584     // corresponding to blocks that were just mined may be iffy - transactions
2585     // aren't re-accepted into the mempool - we additionally neuter the code by
2586     // going ten blocks back. Doesn't yet do anything for sniping, but does act
2587     // to shake out wallet bugs like not showing nLockTime'd transactions at
2588     // all.
2589     txNew.nLockTime = std::max(0, chainActive.Height() - 10);
2590
2591     // Secondly occasionally randomly pick a nLockTime even further back, so
2592     // that transactions that are delayed after signing for whatever reason,
2593     // e.g. high-latency mix networks and some CoinJoin implementations, have
2594     // better privacy.
2595     if (GetRandInt(10) == 0)
2596         txNew.nLockTime = std::max(0, (int)txNew.nLockTime - GetRandInt(100));
2597
2598     assert(txNew.nLockTime <= (unsigned int)chainActive.Height());
2599     assert(txNew.nLockTime < LOCKTIME_THRESHOLD);
2600
2601     {
2602         LOCK2(cs_main, cs_wallet);
2603         {
2604             nFeeRet = 0;
2605             while (true)
2606             {
2607                 txNew.vin.clear();
2608                 txNew.vout.clear();
2609                 wtxNew.fFromMe = true;
2610                 nChangePosRet = -1;
2611                 bool fFirst = true;
2612
2613                 CAmount nTotalValue = nValue;
2614                 if (nSubtractFeeFromAmount == 0)
2615                     nTotalValue += nFeeRet;
2616                 double dPriority = 0;
2617                 // vouts to the payees
2618                 BOOST_FOREACH (const CRecipient& recipient, vecSend)
2619                 {
2620                     CTxOut txout(recipient.nAmount, recipient.scriptPubKey);
2621
2622                     if (recipient.fSubtractFeeFromAmount)
2623                     {
2624                         txout.nValue -= nFeeRet / nSubtractFeeFromAmount; // Subtract fee equally from each selected recipient
2625
2626                         if (fFirst) // first receiver pays the remainder not divisible by output count
2627                         {
2628                             fFirst = false;
2629                             txout.nValue -= nFeeRet % nSubtractFeeFromAmount;
2630                         }
2631                     }
2632
2633                     if (txout.IsDust(::minRelayTxFee))
2634                     {
2635                         if (recipient.fSubtractFeeFromAmount && nFeeRet > 0)
2636                         {
2637                             if (txout.nValue < 0)
2638                                 strFailReason = _("The transaction amount is too small to pay the fee");
2639                             else
2640                                 strFailReason = _("The transaction amount is too small to send after the fee has been deducted");
2641                         }
2642                         else
2643                             strFailReason = _("Transaction amount too small");
2644                         return false;
2645                     }
2646                     txNew.vout.push_back(txout);
2647                 }
2648
2649                 // Choose coins to use
2650                 set<pair<const CWalletTx*,unsigned int> > setCoins;
2651                 CAmount nValueIn = 0;
2652                 bool fOnlyCoinbaseCoins = false;
2653                 bool fNeedCoinbaseCoins = false;
2654                 if (!SelectCoins(nTotalValue, setCoins, nValueIn, fOnlyCoinbaseCoins, fNeedCoinbaseCoins, coinControl))
2655                 {
2656                     if (fOnlyCoinbaseCoins && Params().GetConsensus().fCoinbaseMustBeProtected) {
2657                         strFailReason = _("Coinbase funds can only be sent to a zaddr");
2658                     } else if (fNeedCoinbaseCoins) {
2659                         strFailReason = _("Insufficient funds, coinbase funds can only be spent after they have been sent to a zaddr");
2660                     } else {
2661                         strFailReason = _("Insufficient funds");
2662                     }
2663                     return false;
2664                 }
2665                 BOOST_FOREACH(PAIRTYPE(const CWalletTx*, unsigned int) pcoin, setCoins)
2666                 {
2667                     CAmount nCredit = pcoin.first->vout[pcoin.second].nValue;
2668                     //The coin age after the next block (depth+1) is used instead of the current,
2669                     //reflecting an assumption the user would accept a bit more delay for
2670                     //a chance at a free transaction.
2671                     //But mempool inputs might still be in the mempool, so their age stays 0
2672                     int age = pcoin.first->GetDepthInMainChain();
2673                     if (age != 0)
2674                         age += 1;
2675                     dPriority += (double)nCredit * age;
2676                 }
2677
2678                 CAmount nChange = nValueIn - nValue;
2679                 if (nSubtractFeeFromAmount == 0)
2680                     nChange -= nFeeRet;
2681
2682                 if (nChange > 0)
2683                 {
2684                     // Fill a vout to ourself
2685                     // TODO: pass in scriptChange instead of reservekey so
2686                     // change transaction isn't always pay-to-bitcoin-address
2687                     CScript scriptChange;
2688
2689                     // coin control: send change to custom address
2690                     if (coinControl && !boost::get<CNoDestination>(&coinControl->destChange))
2691                         scriptChange = GetScriptForDestination(coinControl->destChange);
2692
2693                     // no coin control: send change to newly generated address
2694                     else
2695                     {
2696                         // Note: We use a new key here to keep it from being obvious which side is the change.
2697                         //  The drawback is that by not reusing a previous key, the change may be lost if a
2698                         //  backup is restored, if the backup doesn't have the new private key for the change.
2699                         //  If we reused the old key, it would be possible to add code to look for and
2700                         //  rediscover unknown transactions that were written with keys of ours to recover
2701                         //  post-backup change.
2702
2703                         // Reserve a new key pair from key pool
2704                         CPubKey vchPubKey;
2705                         bool ret;
2706                         ret = reservekey.GetReservedKey(vchPubKey);
2707                         assert(ret); // should never fail, as we just unlocked
2708
2709                         scriptChange = GetScriptForDestination(vchPubKey.GetID());
2710                     }
2711
2712                     CTxOut newTxOut(nChange, scriptChange);
2713
2714                     // We do not move dust-change to fees, because the sender would end up paying more than requested.
2715                     // This would be against the purpose of the all-inclusive feature.
2716                     // So instead we raise the change and deduct from the recipient.
2717                     if (nSubtractFeeFromAmount > 0 && newTxOut.IsDust(::minRelayTxFee))
2718                     {
2719                         CAmount nDust = newTxOut.GetDustThreshold(::minRelayTxFee) - newTxOut.nValue;
2720                         newTxOut.nValue += nDust; // raise change until no more dust
2721                         for (unsigned int i = 0; i < vecSend.size(); i++) // subtract from first recipient
2722                         {
2723                             if (vecSend[i].fSubtractFeeFromAmount)
2724                             {
2725                                 txNew.vout[i].nValue -= nDust;
2726                                 if (txNew.vout[i].IsDust(::minRelayTxFee))
2727                                 {
2728                                     strFailReason = _("The transaction amount is too small to send after the fee has been deducted");
2729                                     return false;
2730                                 }
2731                                 break;
2732                             }
2733                         }
2734                     }
2735
2736                     // Never create dust outputs; if we would, just
2737                     // add the dust to the fee.
2738                     if (newTxOut.IsDust(::minRelayTxFee))
2739                     {
2740                         nFeeRet += nChange;
2741                         reservekey.ReturnKey();
2742                     }
2743                     else
2744                     {
2745                         // Insert change txn at random position:
2746                         nChangePosRet = GetRandInt(txNew.vout.size()+1);
2747                         vector<CTxOut>::iterator position = txNew.vout.begin()+nChangePosRet;
2748                         txNew.vout.insert(position, newTxOut);
2749                     }
2750                 }
2751                 else
2752                     reservekey.ReturnKey();
2753
2754                 // Fill vin
2755                 //
2756                 // Note how the sequence number is set to max()-1 so that the
2757                 // nLockTime set above actually works.
2758                 BOOST_FOREACH(const PAIRTYPE(const CWalletTx*,unsigned int)& coin, setCoins)
2759                     txNew.vin.push_back(CTxIn(coin.first->GetHash(),coin.second,CScript(),
2760                                               std::numeric_limits<unsigned int>::max()-1));
2761
2762                 // Check mempooltxinputlimit to avoid creating a transaction which the local mempool rejects
2763                 size_t limit = (size_t)GetArg("-mempooltxinputlimit", 0);
2764                 if (limit > 0) {
2765                     size_t n = txNew.vin.size();
2766                     if (n > limit) {
2767                         strFailReason = _(strprintf("Too many transparent inputs %zu > limit %zu", n, limit).c_str());
2768                         return false;
2769                     }
2770                 }
2771
2772                 // Grab the current consensus branch ID
2773                 auto consensusBranchId = CurrentEpochBranchId(chainActive.Height() + 1, Params().GetConsensus());
2774
2775                 // Sign
2776                 int nIn = 0;
2777                 CTransaction txNewConst(txNew);
2778                 BOOST_FOREACH(const PAIRTYPE(const CWalletTx*,unsigned int)& coin, setCoins)
2779                 {
2780                     bool signSuccess;
2781                     const CScript& scriptPubKey = coin.first->vout[coin.second].scriptPubKey;
2782                     SignatureData sigdata;
2783                     if (sign)
2784                         signSuccess = ProduceSignature(TransactionSignatureCreator(this, &txNewConst, nIn, coin.first->vout[coin.second].nValue, SIGHASH_ALL), scriptPubKey, sigdata, consensusBranchId);
2785                     else
2786                         signSuccess = ProduceSignature(DummySignatureCreator(this), scriptPubKey, sigdata, consensusBranchId);
2787
2788                     if (!signSuccess)
2789                     {
2790                         strFailReason = _("Signing transaction failed");
2791                         return false;
2792                     } else {
2793                         UpdateTransaction(txNew, nIn, sigdata);
2794                     }
2795
2796                     nIn++;
2797                 }
2798
2799                 unsigned int nBytes = ::GetSerializeSize(txNew, SER_NETWORK, PROTOCOL_VERSION);
2800
2801                 // Remove scriptSigs if we used dummy signatures for fee calculation
2802                 if (!sign) {
2803                     BOOST_FOREACH (CTxIn& vin, txNew.vin)
2804                         vin.scriptSig = CScript();
2805                 }
2806
2807                 // Embed the constructed transaction data in wtxNew.
2808                 *static_cast<CTransaction*>(&wtxNew) = CTransaction(txNew);
2809
2810                 // Limit size
2811                 if (nBytes >= MAX_TX_SIZE)
2812                 {
2813                     strFailReason = _("Transaction too large");
2814                     return false;
2815                 }
2816
2817                 dPriority = wtxNew.ComputePriority(dPriority, nBytes);
2818
2819                 // Can we complete this as a free transaction?
2820                 if (fSendFreeTransactions && nBytes <= MAX_FREE_TRANSACTION_CREATE_SIZE)
2821                 {
2822                     // Not enough fee: enough priority?
2823                     double dPriorityNeeded = mempool.estimatePriority(nTxConfirmTarget);
2824                     // Not enough mempool history to estimate: use hard-coded AllowFree.
2825                     if (dPriorityNeeded <= 0 && AllowFree(dPriority))
2826                         break;
2827
2828                     // Small enough, and priority high enough, to send for free
2829                     if (dPriorityNeeded > 0 && dPriority >= dPriorityNeeded)
2830                         break;
2831                 }
2832
2833                 CAmount nFeeNeeded = GetMinimumFee(nBytes, nTxConfirmTarget, mempool);
2834
2835                 // If we made it here and we aren't even able to meet the relay fee on the next pass, give up
2836                 // because we must be at the maximum allowed fee.
2837                 if (nFeeNeeded < ::minRelayTxFee.GetFee(nBytes))
2838                 {
2839                     strFailReason = _("Transaction too large for fee policy");
2840                     return false;
2841                 }
2842
2843                 if (nFeeRet >= nFeeNeeded)
2844                     break; // Done, enough fee included.
2845
2846                 // Include more fee and try again.
2847                 nFeeRet = nFeeNeeded;
2848                 continue;
2849             }
2850         }
2851     }
2852
2853     return true;
2854 }
2855
2856 /**
2857  * Call after CreateTransaction unless you want to abort
2858  */
2859 bool CWallet::CommitTransaction(CWalletTx& wtxNew, CReserveKey& reservekey)
2860 {
2861     {
2862         LOCK2(cs_main, cs_wallet);
2863         LogPrintf("CommitTransaction:\n%s", wtxNew.ToString());
2864         {
2865             // This is only to keep the database open to defeat the auto-flush for the
2866             // duration of this scope.  This is the only place where this optimization
2867             // maybe makes sense; please don't do it anywhere else.
2868             CWalletDB* pwalletdb = fFileBacked ? new CWalletDB(strWalletFile,"r+") : NULL;
2869
2870             // Take key pair from key pool so it won't be used again
2871             reservekey.KeepKey();
2872
2873             // Add tx to wallet, because if it has change it's also ours,
2874             // otherwise just for transaction history.
2875             AddToWallet(wtxNew, false, pwalletdb);
2876
2877             // Notify that old coins are spent
2878             set<CWalletTx*> setCoins;
2879             BOOST_FOREACH(const CTxIn& txin, wtxNew.vin)
2880             {
2881                 CWalletTx &coin = mapWallet[txin.prevout.hash];
2882                 coin.BindWallet(this);
2883                 NotifyTransactionChanged(this, coin.GetHash(), CT_UPDATED);
2884             }
2885
2886             if (fFileBacked)
2887                 delete pwalletdb;
2888         }
2889
2890         // Track how many getdata requests our transaction gets
2891         mapRequestCount[wtxNew.GetHash()] = 0;
2892
2893         if (fBroadcastTransactions)
2894         {
2895             // Broadcast
2896             if (!wtxNew.AcceptToMemoryPool(false))
2897             {
2898                 // This must not fail. The transaction has already been signed and recorded.
2899                 LogPrintf("CommitTransaction(): Error: Transaction not valid\n");
2900                 return false;
2901             }
2902             wtxNew.RelayWalletTransaction();
2903         }
2904     }
2905     return true;
2906 }
2907
2908 CAmount CWallet::GetMinimumFee(unsigned int nTxBytes, unsigned int nConfirmTarget, const CTxMemPool& pool)
2909 {
2910     // payTxFee is user-set "I want to pay this much"
2911     CAmount nFeeNeeded = payTxFee.GetFee(nTxBytes);
2912     // user selected total at least (default=true)
2913     if (fPayAtLeastCustomFee && nFeeNeeded > 0 && nFeeNeeded < payTxFee.GetFeePerK())
2914         nFeeNeeded = payTxFee.GetFeePerK();
2915     // User didn't set: use -txconfirmtarget to estimate...
2916     if (nFeeNeeded == 0)
2917         nFeeNeeded = pool.estimateFee(nConfirmTarget).GetFee(nTxBytes);
2918     // ... unless we don't have enough mempool data, in which case fall
2919     // back to a hard-coded fee
2920     if (nFeeNeeded == 0)
2921         nFeeNeeded = minTxFee.GetFee(nTxBytes);
2922     // prevent user from paying a non-sense fee (like 1 satoshi): 0 < fee < minRelayFee
2923     if (nFeeNeeded < ::minRelayTxFee.GetFee(nTxBytes))
2924         nFeeNeeded = ::minRelayTxFee.GetFee(nTxBytes);
2925     // But always obey the maximum
2926     if (nFeeNeeded > maxTxFee)
2927         nFeeNeeded = maxTxFee;
2928     return nFeeNeeded;
2929 }
2930
2931
2932
2933
2934 DBErrors CWallet::LoadWallet(bool& fFirstRunRet)
2935 {
2936     if (!fFileBacked)
2937         return DB_LOAD_OK;
2938     fFirstRunRet = false;
2939     DBErrors nLoadWalletRet = CWalletDB(strWalletFile,"cr+").LoadWallet(this);
2940     if (nLoadWalletRet == DB_NEED_REWRITE)
2941     {
2942         if (CDB::Rewrite(strWalletFile, "\x04pool"))
2943         {
2944             LOCK(cs_wallet);
2945             setKeyPool.clear();
2946             // Note: can't top-up keypool here, because wallet is locked.
2947             // User will be prompted to unlock wallet the next operation
2948             // that requires a new key.
2949         }
2950     }
2951
2952     if (nLoadWalletRet != DB_LOAD_OK)
2953         return nLoadWalletRet;
2954     fFirstRunRet = !vchDefaultKey.IsValid();
2955
2956     uiInterface.LoadWallet(this);
2957
2958     return DB_LOAD_OK;
2959 }
2960
2961
2962 DBErrors CWallet::ZapWalletTx(std::vector<CWalletTx>& vWtx)
2963 {
2964     if (!fFileBacked)
2965         return DB_LOAD_OK;
2966     DBErrors nZapWalletTxRet = CWalletDB(strWalletFile,"cr+").ZapWalletTx(this, vWtx);
2967     if (nZapWalletTxRet == DB_NEED_REWRITE)
2968     {
2969         if (CDB::Rewrite(strWalletFile, "\x04pool"))
2970         {
2971             LOCK(cs_wallet);
2972             setKeyPool.clear();
2973             // Note: can't top-up keypool here, because wallet is locked.
2974             // User will be prompted to unlock wallet the next operation
2975             // that requires a new key.
2976         }
2977     }
2978
2979     if (nZapWalletTxRet != DB_LOAD_OK)
2980         return nZapWalletTxRet;
2981
2982     return DB_LOAD_OK;
2983 }
2984
2985
2986 bool CWallet::SetAddressBook(const CTxDestination& address, const string& strName, const string& strPurpose)
2987 {
2988     bool fUpdated = false;
2989     {
2990         LOCK(cs_wallet); // mapAddressBook
2991         std::map<CTxDestination, CAddressBookData>::iterator mi = mapAddressBook.find(address);
2992         fUpdated = mi != mapAddressBook.end();
2993         mapAddressBook[address].name = strName;
2994         if (!strPurpose.empty()) /* update purpose only if requested */
2995             mapAddressBook[address].purpose = strPurpose;
2996     }
2997     NotifyAddressBookChanged(this, address, strName, ::IsMine(*this, address) != ISMINE_NO,
2998                              strPurpose, (fUpdated ? CT_UPDATED : CT_NEW) );
2999     if (!fFileBacked)
3000         return false;
3001     if (!strPurpose.empty() && !CWalletDB(strWalletFile).WritePurpose(CBitcoinAddress(address).ToString(), strPurpose))
3002         return false;
3003     return CWalletDB(strWalletFile).WriteName(CBitcoinAddress(address).ToString(), strName);
3004 }
3005
3006 bool CWallet::DelAddressBook(const CTxDestination& address)
3007 {
3008     {
3009         LOCK(cs_wallet); // mapAddressBook
3010
3011         if(fFileBacked)
3012         {
3013             // Delete destdata tuples associated with address
3014             std::string strAddress = CBitcoinAddress(address).ToString();
3015             BOOST_FOREACH(const PAIRTYPE(string, string) &item, mapAddressBook[address].destdata)
3016             {
3017                 CWalletDB(strWalletFile).EraseDestData(strAddress, item.first);
3018             }
3019         }
3020         mapAddressBook.erase(address);
3021     }
3022
3023     NotifyAddressBookChanged(this, address, "", ::IsMine(*this, address) != ISMINE_NO, "", CT_DELETED);
3024
3025     if (!fFileBacked)
3026         return false;
3027     CWalletDB(strWalletFile).ErasePurpose(CBitcoinAddress(address).ToString());
3028     return CWalletDB(strWalletFile).EraseName(CBitcoinAddress(address).ToString());
3029 }
3030
3031 bool CWallet::SetDefaultKey(const CPubKey &vchPubKey)
3032 {
3033     if (fFileBacked)
3034     {
3035         if (!CWalletDB(strWalletFile).WriteDefaultKey(vchPubKey))
3036             return false;
3037     }
3038     vchDefaultKey = vchPubKey;
3039     return true;
3040 }
3041
3042 /**
3043  * Mark old keypool keys as used,
3044  * and generate all new keys
3045  */
3046 bool CWallet::NewKeyPool()
3047 {
3048     {
3049         LOCK(cs_wallet);
3050         CWalletDB walletdb(strWalletFile);
3051         BOOST_FOREACH(int64_t nIndex, setKeyPool)
3052             walletdb.ErasePool(nIndex);
3053         setKeyPool.clear();
3054
3055         if (IsLocked())
3056             return false;
3057
3058         int64_t nKeys = max(GetArg("-keypool", 100), (int64_t)0);
3059         for (int i = 0; i < nKeys; i++)
3060         {
3061             int64_t nIndex = i+1;
3062             walletdb.WritePool(nIndex, CKeyPool(GenerateNewKey()));
3063             setKeyPool.insert(nIndex);
3064         }
3065         LogPrintf("CWallet::NewKeyPool wrote %d new keys\n", nKeys);
3066     }
3067     return true;
3068 }
3069
3070 bool CWallet::TopUpKeyPool(unsigned int kpSize)
3071 {
3072     {
3073         LOCK(cs_wallet);
3074
3075         if (IsLocked())
3076             return false;
3077
3078         CWalletDB walletdb(strWalletFile);
3079
3080         // Top up key pool
3081         unsigned int nTargetSize;
3082         if (kpSize > 0)
3083             nTargetSize = kpSize;
3084         else
3085             nTargetSize = max(GetArg("-keypool", 100), (int64_t) 0);
3086
3087         while (setKeyPool.size() < (nTargetSize + 1))
3088         {
3089             int64_t nEnd = 1;
3090             if (!setKeyPool.empty())
3091                 nEnd = *(--setKeyPool.end()) + 1;
3092             if (!walletdb.WritePool(nEnd, CKeyPool(GenerateNewKey())))
3093                 throw runtime_error("TopUpKeyPool(): writing generated key failed");
3094             setKeyPool.insert(nEnd);
3095             LogPrintf("keypool added key %d, size=%u\n", nEnd, setKeyPool.size());
3096         }
3097     }
3098     return true;
3099 }
3100
3101 void CWallet::ReserveKeyFromKeyPool(int64_t& nIndex, CKeyPool& keypool)
3102 {
3103     nIndex = -1;
3104     keypool.vchPubKey = CPubKey();
3105     {
3106         LOCK(cs_wallet);
3107
3108         if (!IsLocked())
3109             TopUpKeyPool();
3110
3111         // Get the oldest key
3112         if(setKeyPool.empty())
3113             return;
3114
3115         CWalletDB walletdb(strWalletFile);
3116
3117         nIndex = *(setKeyPool.begin());
3118         setKeyPool.erase(setKeyPool.begin());
3119         if (!walletdb.ReadPool(nIndex, keypool))
3120             throw runtime_error("ReserveKeyFromKeyPool(): read failed");
3121         if (!HaveKey(keypool.vchPubKey.GetID()))
3122             throw runtime_error("ReserveKeyFromKeyPool(): unknown key in key pool");
3123         assert(keypool.vchPubKey.IsValid());
3124         LogPrintf("keypool reserve %d\n", nIndex);
3125     }
3126 }
3127
3128 void CWallet::KeepKey(int64_t nIndex)
3129 {
3130     // Remove from key pool
3131     if (fFileBacked)
3132     {
3133         CWalletDB walletdb(strWalletFile);
3134         walletdb.ErasePool(nIndex);
3135     }
3136     LogPrintf("keypool keep %d\n", nIndex);
3137 }
3138
3139 void CWallet::ReturnKey(int64_t nIndex)
3140 {
3141     // Return to key pool
3142     {
3143         LOCK(cs_wallet);
3144         setKeyPool.insert(nIndex);
3145     }
3146     LogPrintf("keypool return %d\n", nIndex);
3147 }
3148
3149 bool CWallet::GetKeyFromPool(CPubKey& result)
3150 {
3151     int64_t nIndex = 0;
3152     CKeyPool keypool;
3153     {
3154         LOCK(cs_wallet);
3155         ReserveKeyFromKeyPool(nIndex, keypool);
3156         if (nIndex == -1)
3157         {
3158             if (IsLocked()) return false;
3159             result = GenerateNewKey();
3160             return true;
3161         }
3162         KeepKey(nIndex);
3163         result = keypool.vchPubKey;
3164     }
3165     return true;
3166 }
3167
3168 int64_t CWallet::GetOldestKeyPoolTime()
3169 {
3170     int64_t nIndex = 0;
3171     CKeyPool keypool;
3172     ReserveKeyFromKeyPool(nIndex, keypool);
3173     if (nIndex == -1)
3174         return GetTime();
3175     ReturnKey(nIndex);
3176     return keypool.nTime;
3177 }
3178
3179 std::map<CTxDestination, CAmount> CWallet::GetAddressBalances()
3180 {
3181     map<CTxDestination, CAmount> balances;
3182
3183     {
3184         LOCK(cs_wallet);
3185         BOOST_FOREACH(PAIRTYPE(uint256, CWalletTx) walletEntry, mapWallet)
3186         {
3187             CWalletTx *pcoin = &walletEntry.second;
3188
3189             if (!CheckFinalTx(*pcoin) || !pcoin->IsTrusted())
3190                 continue;
3191
3192             if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0)
3193                 continue;
3194
3195             int nDepth = pcoin->GetDepthInMainChain();
3196             if (nDepth < (pcoin->IsFromMe(ISMINE_ALL) ? 0 : 1))
3197                 continue;
3198
3199             for (unsigned int i = 0; i < pcoin->vout.size(); i++)
3200             {
3201                 CTxDestination addr;
3202                 if (!IsMine(pcoin->vout[i]))
3203                     continue;
3204                 if(!ExtractDestination(pcoin->vout[i].scriptPubKey, addr))
3205                     continue;
3206
3207                 CAmount n = IsSpent(walletEntry.first, i) ? 0 : pcoin->vout[i].nValue;
3208
3209                 if (!balances.count(addr))
3210                     balances[addr] = 0;
3211                 balances[addr] += n;
3212             }
3213         }
3214     }
3215
3216     return balances;
3217 }
3218
3219 set< set<CTxDestination> > CWallet::GetAddressGroupings()
3220 {
3221     AssertLockHeld(cs_wallet); // mapWallet
3222     set< set<CTxDestination> > groupings;
3223     set<CTxDestination> grouping;
3224
3225     BOOST_FOREACH(PAIRTYPE(uint256, CWalletTx) walletEntry, mapWallet)
3226     {
3227         CWalletTx *pcoin = &walletEntry.second;
3228
3229         if (pcoin->vin.size() > 0)
3230         {
3231             bool any_mine = false;
3232             // group all input addresses with each other
3233             BOOST_FOREACH(CTxIn txin, pcoin->vin)
3234             {
3235                 CTxDestination address;
3236                 if(!IsMine(txin)) /* If this input isn't mine, ignore it */
3237                     continue;
3238                 if(!ExtractDestination(mapWallet[txin.prevout.hash].vout[txin.prevout.n].scriptPubKey, address))
3239                     continue;
3240                 grouping.insert(address);
3241                 any_mine = true;
3242             }
3243
3244             // group change with input addresses
3245             if (any_mine)
3246             {
3247                BOOST_FOREACH(CTxOut txout, pcoin->vout)
3248                    if (IsChange(txout))
3249                    {
3250                        CTxDestination txoutAddr;
3251                        if(!ExtractDestination(txout.scriptPubKey, txoutAddr))
3252                            continue;
3253                        grouping.insert(txoutAddr);
3254                    }
3255             }
3256             if (grouping.size() > 0)
3257             {
3258                 groupings.insert(grouping);
3259                 grouping.clear();
3260             }
3261         }
3262
3263         // group lone addrs by themselves
3264         for (unsigned int i = 0; i < pcoin->vout.size(); i++)
3265             if (IsMine(pcoin->vout[i]))
3266             {
3267                 CTxDestination address;
3268                 if(!ExtractDestination(pcoin->vout[i].scriptPubKey, address))
3269                     continue;
3270                 grouping.insert(address);
3271                 groupings.insert(grouping);
3272                 grouping.clear();
3273             }
3274     }
3275
3276     set< set<CTxDestination>* > uniqueGroupings; // a set of pointers to groups of addresses
3277     map< CTxDestination, set<CTxDestination>* > setmap;  // map addresses to the unique group containing it
3278     BOOST_FOREACH(set<CTxDestination> grouping, groupings)
3279     {
3280         // make a set of all the groups hit by this new group
3281         set< set<CTxDestination>* > hits;
3282         map< CTxDestination, set<CTxDestination>* >::iterator it;
3283         BOOST_FOREACH(CTxDestination address, grouping)
3284             if ((it = setmap.find(address)) != setmap.end())
3285                 hits.insert((*it).second);
3286
3287         // merge all hit groups into a new single group and delete old groups
3288         set<CTxDestination>* merged = new set<CTxDestination>(grouping);
3289         BOOST_FOREACH(set<CTxDestination>* hit, hits)
3290         {
3291             merged->insert(hit->begin(), hit->end());
3292             uniqueGroupings.erase(hit);
3293             delete hit;
3294         }
3295         uniqueGroupings.insert(merged);
3296
3297         // update setmap
3298         BOOST_FOREACH(CTxDestination element, *merged)
3299             setmap[element] = merged;
3300     }
3301
3302     set< set<CTxDestination> > ret;
3303     BOOST_FOREACH(set<CTxDestination>* uniqueGrouping, uniqueGroupings)
3304     {
3305         ret.insert(*uniqueGrouping);
3306         delete uniqueGrouping;
3307     }
3308
3309     return ret;
3310 }
3311
3312 std::set<CTxDestination> CWallet::GetAccountAddresses(const std::string& strAccount) const
3313 {
3314     LOCK(cs_wallet);
3315     set<CTxDestination> result;
3316     BOOST_FOREACH(const PAIRTYPE(CTxDestination, CAddressBookData)& item, mapAddressBook)
3317     {
3318         const CTxDestination& address = item.first;
3319         const string& strName = item.second.name;
3320         if (strName == strAccount)
3321             result.insert(address);
3322     }
3323     return result;
3324 }
3325
3326 bool CReserveKey::GetReservedKey(CPubKey& pubkey)
3327 {
3328     if (nIndex == -1)
3329     {
3330         CKeyPool keypool;
3331         pwallet->ReserveKeyFromKeyPool(nIndex, keypool);
3332         if (nIndex != -1)
3333             vchPubKey = keypool.vchPubKey;
3334         else {
3335             return false;
3336         }
3337     }
3338     assert(vchPubKey.IsValid());
3339     pubkey = vchPubKey;
3340     return true;
3341 }
3342
3343 void CReserveKey::KeepKey()
3344 {
3345     if (nIndex != -1)
3346         pwallet->KeepKey(nIndex);
3347     nIndex = -1;
3348     vchPubKey = CPubKey();
3349 }
3350
3351 void CReserveKey::ReturnKey()
3352 {
3353     if (nIndex != -1)
3354         pwallet->ReturnKey(nIndex);
3355     nIndex = -1;
3356     vchPubKey = CPubKey();
3357 }
3358
3359 void CWallet::GetAllReserveKeys(set<CKeyID>& setAddress) const
3360 {
3361     setAddress.clear();
3362
3363     CWalletDB walletdb(strWalletFile);
3364
3365     LOCK2(cs_main, cs_wallet);
3366     BOOST_FOREACH(const int64_t& id, setKeyPool)
3367     {
3368         CKeyPool keypool;
3369         if (!walletdb.ReadPool(id, keypool))
3370             throw runtime_error("GetAllReserveKeyHashes(): read failed");
3371         assert(keypool.vchPubKey.IsValid());
3372         CKeyID keyID = keypool.vchPubKey.GetID();
3373         if (!HaveKey(keyID))
3374             throw runtime_error("GetAllReserveKeyHashes(): unknown key in key pool");
3375         setAddress.insert(keyID);
3376     }
3377 }
3378
3379 void CWallet::UpdatedTransaction(const uint256 &hashTx)
3380 {
3381     {
3382         LOCK(cs_wallet);
3383         // Only notify UI if this transaction is in this wallet
3384         map<uint256, CWalletTx>::const_iterator mi = mapWallet.find(hashTx);
3385         if (mi != mapWallet.end())
3386             NotifyTransactionChanged(this, hashTx, CT_UPDATED);
3387     }
3388 }
3389
3390 void CWallet::LockCoin(COutPoint& output)
3391 {
3392     AssertLockHeld(cs_wallet); // setLockedCoins
3393     setLockedCoins.insert(output);
3394 }
3395
3396 void CWallet::UnlockCoin(COutPoint& output)
3397 {
3398     AssertLockHeld(cs_wallet); // setLockedCoins
3399     setLockedCoins.erase(output);
3400 }
3401
3402 void CWallet::UnlockAllCoins()
3403 {
3404     AssertLockHeld(cs_wallet); // setLockedCoins
3405     setLockedCoins.clear();
3406 }
3407
3408 bool CWallet::IsLockedCoin(uint256 hash, unsigned int n) const
3409 {
3410     AssertLockHeld(cs_wallet); // setLockedCoins
3411     COutPoint outpt(hash, n);
3412
3413     return (setLockedCoins.count(outpt) > 0);
3414 }
3415
3416 void CWallet::ListLockedCoins(std::vector<COutPoint>& vOutpts)
3417 {
3418     AssertLockHeld(cs_wallet); // setLockedCoins
3419     for (std::set<COutPoint>::iterator it = setLockedCoins.begin();
3420          it != setLockedCoins.end(); it++) {
3421         COutPoint outpt = (*it);
3422         vOutpts.push_back(outpt);
3423     }
3424 }
3425
3426 /** @} */ // end of Actions
3427
3428 class CAffectedKeysVisitor : public boost::static_visitor<void> {
3429 private:
3430     const CKeyStore &keystore;
3431     std::vector<CKeyID> &vKeys;
3432
3433 public:
3434     CAffectedKeysVisitor(const CKeyStore &keystoreIn, std::vector<CKeyID> &vKeysIn) : keystore(keystoreIn), vKeys(vKeysIn) {}
3435
3436     void Process(const CScript &script) {
3437         txnouttype type;
3438         std::vector<CTxDestination> vDest;
3439         int nRequired;
3440         if (ExtractDestinations(script, type, vDest, nRequired)) {
3441             BOOST_FOREACH(const CTxDestination &dest, vDest)
3442                 boost::apply_visitor(*this, dest);
3443         }
3444     }
3445
3446     void operator()(const CKeyID &keyId) {
3447         if (keystore.HaveKey(keyId))
3448             vKeys.push_back(keyId);
3449     }
3450
3451     void operator()(const CScriptID &scriptId) {
3452         CScript script;
3453         if (keystore.GetCScript(scriptId, script))
3454             Process(script);
3455     }
3456
3457     void operator()(const CNoDestination &none) {}
3458 };
3459
3460 void CWallet::GetKeyBirthTimes(std::map<CKeyID, int64_t> &mapKeyBirth) const {
3461     AssertLockHeld(cs_wallet); // mapKeyMetadata
3462     mapKeyBirth.clear();
3463
3464     // get birth times for keys with metadata
3465     for (std::map<CKeyID, CKeyMetadata>::const_iterator it = mapKeyMetadata.begin(); it != mapKeyMetadata.end(); it++)
3466         if (it->second.nCreateTime)
3467             mapKeyBirth[it->first] = it->second.nCreateTime;
3468
3469     // map in which we'll infer heights of other keys
3470     CBlockIndex *pindexMax = chainActive[std::max(0, chainActive.Height() - 144)]; // the tip can be reorganised; use a 144-block safety margin
3471     std::map<CKeyID, CBlockIndex*> mapKeyFirstBlock;
3472     std::set<CKeyID> setKeys;
3473     GetKeys(setKeys);
3474     BOOST_FOREACH(const CKeyID &keyid, setKeys) {
3475         if (mapKeyBirth.count(keyid) == 0)
3476             mapKeyFirstBlock[keyid] = pindexMax;
3477     }
3478     setKeys.clear();
3479
3480     // if there are no such keys, we're done
3481     if (mapKeyFirstBlock.empty())
3482         return;
3483
3484     // find first block that affects those keys, if there are any left
3485     std::vector<CKeyID> vAffected;
3486     for (std::map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); it++) {
3487         // iterate over all wallet transactions...
3488         const CWalletTx &wtx = (*it).second;
3489         BlockMap::const_iterator blit = mapBlockIndex.find(wtx.hashBlock);
3490         if (blit != mapBlockIndex.end() && chainActive.Contains(blit->second)) {
3491             // ... which are already in a block
3492             int nHeight = blit->second->nHeight;
3493             BOOST_FOREACH(const CTxOut &txout, wtx.vout) {
3494                 // iterate over all their outputs
3495                 CAffectedKeysVisitor(*this, vAffected).Process(txout.scriptPubKey);
3496                 BOOST_FOREACH(const CKeyID &keyid, vAffected) {
3497                     // ... and all their affected keys
3498                     std::map<CKeyID, CBlockIndex*>::iterator rit = mapKeyFirstBlock.find(keyid);
3499                     if (rit != mapKeyFirstBlock.end() && nHeight < rit->second->nHeight)
3500                         rit->second = blit->second;
3501                 }
3502                 vAffected.clear();
3503             }
3504         }
3505     }
3506
3507     // Extract block timestamps for those keys
3508     for (std::map<CKeyID, CBlockIndex*>::const_iterator it = mapKeyFirstBlock.begin(); it != mapKeyFirstBlock.end(); it++)
3509         mapKeyBirth[it->first] = it->second->GetBlockTime() - 7200; // block times can be 2h off
3510 }
3511
3512 bool CWallet::AddDestData(const CTxDestination &dest, const std::string &key, const std::string &value)
3513 {
3514     if (boost::get<CNoDestination>(&dest))
3515         return false;
3516
3517     mapAddressBook[dest].destdata.insert(std::make_pair(key, value));
3518     if (!fFileBacked)
3519         return true;
3520     return CWalletDB(strWalletFile).WriteDestData(CBitcoinAddress(dest).ToString(), key, value);
3521 }
3522
3523 bool CWallet::EraseDestData(const CTxDestination &dest, const std::string &key)
3524 {
3525     if (!mapAddressBook[dest].destdata.erase(key))
3526         return false;
3527     if (!fFileBacked)
3528         return true;
3529     return CWalletDB(strWalletFile).EraseDestData(CBitcoinAddress(dest).ToString(), key);
3530 }
3531
3532 bool CWallet::LoadDestData(const CTxDestination &dest, const std::string &key, const std::string &value)
3533 {
3534     mapAddressBook[dest].destdata.insert(std::make_pair(key, value));
3535     return true;
3536 }
3537
3538 bool CWallet::GetDestData(const CTxDestination &dest, const std::string &key, std::string *value) const
3539 {
3540     std::map<CTxDestination, CAddressBookData>::const_iterator i = mapAddressBook.find(dest);
3541     if(i != mapAddressBook.end())
3542     {
3543         CAddressBookData::StringMap::const_iterator j = i->second.destdata.find(key);
3544         if(j != i->second.destdata.end())
3545         {
3546             if(value)
3547                 *value = j->second;
3548             return true;
3549         }
3550     }
3551     return false;
3552 }
3553
3554 CKeyPool::CKeyPool()
3555 {
3556     nTime = GetTime();
3557 }
3558
3559 CKeyPool::CKeyPool(const CPubKey& vchPubKeyIn)
3560 {
3561     nTime = GetTime();
3562     vchPubKey = vchPubKeyIn;
3563 }
3564
3565 CWalletKey::CWalletKey(int64_t nExpires)
3566 {
3567     nTimeCreated = (nExpires ? GetTime() : 0);
3568     nTimeExpires = nExpires;
3569 }
3570
3571 int CMerkleTx::SetMerkleBranch(const CBlock& block)
3572 {
3573     AssertLockHeld(cs_main);
3574     CBlock blockTmp;
3575
3576     // Update the tx's hashBlock
3577     hashBlock = block.GetHash();
3578
3579     // Locate the transaction
3580     for (nIndex = 0; nIndex < (int)block.vtx.size(); nIndex++)
3581         if (block.vtx[nIndex] == *(CTransaction*)this)
3582             break;
3583     if (nIndex == (int)block.vtx.size())
3584     {
3585         vMerkleBranch.clear();
3586         nIndex = -1;
3587         LogPrintf("ERROR: SetMerkleBranch(): couldn't find tx in block\n");
3588         return 0;
3589     }
3590
3591     // Fill in merkle branch
3592     vMerkleBranch = block.GetMerkleBranch(nIndex);
3593
3594     // Is the tx in a block that's in the main chain
3595     BlockMap::iterator mi = mapBlockIndex.find(hashBlock);
3596     if (mi == mapBlockIndex.end())
3597         return 0;
3598     const CBlockIndex* pindex = (*mi).second;
3599     if (!pindex || !chainActive.Contains(pindex))
3600         return 0;
3601
3602     return chainActive.Height() - pindex->nHeight + 1;
3603 }
3604
3605 int CMerkleTx::GetDepthInMainChainINTERNAL(const CBlockIndex* &pindexRet) const
3606 {
3607     if (hashBlock.IsNull() || nIndex == -1)
3608         return 0;
3609     AssertLockHeld(cs_main);
3610
3611     // Find the block it claims to be in
3612     BlockMap::iterator mi = mapBlockIndex.find(hashBlock);
3613     if (mi == mapBlockIndex.end())
3614         return 0;
3615     CBlockIndex* pindex = (*mi).second;
3616     if (!pindex || !chainActive.Contains(pindex))
3617         return 0;
3618
3619     // Make sure the merkle branch connects to this block
3620     if (!fMerkleVerified)
3621     {
3622         if (CBlock::CheckMerkleBranch(GetHash(), vMerkleBranch, nIndex) != pindex->hashMerkleRoot)
3623             return 0;
3624         fMerkleVerified = true;
3625     }
3626
3627     pindexRet = pindex;
3628     return chainActive.Height() - pindex->nHeight + 1;
3629 }
3630
3631 int CMerkleTx::GetDepthInMainChain(const CBlockIndex* &pindexRet) const
3632 {
3633     AssertLockHeld(cs_main);
3634     int nResult = GetDepthInMainChainINTERNAL(pindexRet);
3635     if (nResult == 0 && !mempool.exists(GetHash()))
3636         return -1; // Not in chain, not in mempool
3637
3638     return nResult;
3639 }
3640
3641 int CMerkleTx::GetBlocksToMaturity() const
3642 {
3643     if (!IsCoinBase())
3644         return 0;
3645     return max(0, (COINBASE_MATURITY+1) - GetDepthInMainChain());
3646 }
3647
3648
3649 bool CMerkleTx::AcceptToMemoryPool(bool fLimitFree, bool fRejectAbsurdFee)
3650 {
3651     CValidationState state;
3652     return ::AcceptToMemoryPool(mempool, state, *this, fLimitFree, NULL, fRejectAbsurdFee);
3653 }
3654
3655 /**
3656  * Find notes in the wallet filtered by payment address, min depth and ability to spend.
3657  * These notes are decrypted and added to the output parameter vector, outEntries.
3658  */
3659 void CWallet::GetFilteredNotes(std::vector<CNotePlaintextEntry> & outEntries, std::string address, int minDepth, bool ignoreSpent, bool ignoreUnspendable)
3660 {
3661     bool fFilterAddress = false;
3662     libzcash::PaymentAddress filterPaymentAddress;
3663     if (address.length() > 0) {
3664         filterPaymentAddress = CZCPaymentAddress(address).Get();
3665         fFilterAddress = true;
3666     }
3667
3668     LOCK2(cs_main, cs_wallet);
3669
3670     for (auto & p : mapWallet) {
3671         CWalletTx wtx = p.second;
3672
3673         // Filter the transactions before checking for notes
3674         if (!CheckFinalTx(wtx) || wtx.GetBlocksToMaturity() > 0 || wtx.GetDepthInMainChain() < minDepth) {
3675             continue;
3676         }
3677
3678         if (wtx.mapNoteData.size() == 0) {
3679             continue;
3680         }
3681
3682         for (auto & pair : wtx.mapNoteData) {
3683             JSOutPoint jsop = pair.first;
3684             CNoteData nd = pair.second;
3685             PaymentAddress pa = nd.address;
3686
3687             // skip notes which belong to a different payment address in the wallet
3688             if (fFilterAddress && !(pa == filterPaymentAddress)) {
3689                 continue;
3690             }
3691
3692             // skip note which has been spent
3693             if (ignoreSpent && nd.nullifier && IsSpent(*nd.nullifier)) {
3694                 continue;
3695             }
3696
3697             // skip notes which cannot be spent
3698             if (ignoreUnspendable && !HaveSpendingKey(pa)) {
3699                 continue;
3700             }
3701
3702             int i = jsop.js; // Index into CTransaction.vjoinsplit
3703             int j = jsop.n; // Index into JSDescription.ciphertexts
3704
3705             // Get cached decryptor
3706             ZCNoteDecryption decryptor;
3707             if (!GetNoteDecryptor(pa, decryptor)) {
3708                 // Note decryptors are created when the wallet is loaded, so it should always exist
3709                 throw std::runtime_error(strprintf("Could not find note decryptor for payment address %s", CZCPaymentAddress(pa).ToString()));
3710             }
3711
3712             // determine amount of funds in the note
3713             auto hSig = wtx.vjoinsplit[i].h_sig(*pzcashParams, wtx.joinSplitPubKey);
3714             try {
3715                 NotePlaintext plaintext = NotePlaintext::decrypt(
3716                         decryptor,
3717                         wtx.vjoinsplit[i].ciphertexts[j],
3718                         wtx.vjoinsplit[i].ephemeralKey,
3719                         hSig,
3720                         (unsigned char) j);
3721
3722                 outEntries.push_back(CNotePlaintextEntry{jsop, plaintext});
3723
3724             } catch (const note_decryption_failed &err) {
3725                 // Couldn't decrypt with this spending key
3726                 throw std::runtime_error(strprintf("Could not decrypt note for payment address %s", CZCPaymentAddress(pa).ToString()));
3727             } catch (const std::exception &exc) {
3728                 // Unexpected failure
3729                 throw std::runtime_error(strprintf("Error while decrypting note for payment address %s: %s", CZCPaymentAddress(pa).ToString(), exc.what()));
3730             }
3731         }
3732     }
3733 }