src/wallet.cpp

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2012 The Bitcoin developers
   3 // Distributed under the MIT/X11 software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5
   6 #include "db.h"
   7 #include "wallet.h"
   8 #include "walletdb.h"
   9 #include "crypter.h"
  10 #include "ui_interface.h"
  11 #include "base58.h"
  12 #include "kernel.h"
  13 #include "coincontrol.h"
  14 #include <boost/algorithm/string/replace.hpp>
  15
  16 using namespace std;
  17 extern int nStakeMaxAge;
  18
  19 //////////////////////////////////////////////////////////////////////////////
  20 //
  21 // mapWallet
  22 //
  23
  24 struct CompareValueOnly
  25 {
  26     bool operator()(const pair<int64, pair<const CWalletTx*, unsigned int> >& t1,
  27                     const pair<int64, pair<const CWalletTx*, unsigned int> >& t2) const
  28     {
  29         return t1.first < t2.first;
  30     }
  31 };
  32
  33 CPubKey CWallet::GenerateNewKey()
  34 {
  35     bool fCompressed = CanSupportFeature(FEATURE_COMPRPUBKEY); // default to compressed public keys if we want 0.6.0 wallets
  36
  37     RandAddSeedPerfmon();
  38     CKey key;
  39     key.MakeNewKey(fCompressed);
  40
  41     // Compressed public keys were introduced in version 0.6.0
  42     if (fCompressed)
  43         SetMinVersion(FEATURE_COMPRPUBKEY);
  44
  45     CPubKey pubkey = key.GetPubKey();
  46
  47     // Create new metadata
  48     int64 nCreationTime = GetTime();
  49     mapKeyMetadata[pubkey.GetID()] = CKeyMetadata(nCreationTime);
  50     if (!nTimeFirstKey || nCreationTime < nTimeFirstKey)
  51         nTimeFirstKey = nCreationTime;
  52
  53     if (!AddKey(key))
  54         throw std::runtime_error("CWallet::GenerateNewKey() : AddKey failed");
  55     return key.GetPubKey();
  56 }
  57
  58 bool CWallet::AddKey(const CKey& key)
  59 {
  60     CPubKey pubkey = key.GetPubKey();
  61
  62     if (!CCryptoKeyStore::AddKey(key))
  63         return false;
  64     if (!fFileBacked)
  65         return true;
  66     if (!IsCrypted())
  67         return CWalletDB(strWalletFile).WriteKey(pubkey, key.GetPrivKey(), mapKeyMetadata[pubkey.GetID()]);
  68     return true;
  69 }
  70
  71 bool CWallet::AddCryptedKey(const CPubKey &vchPubKey, const vector<unsigned char> &vchCryptedSecret)
  72 {
  73     if (!CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret))
  74         return false;
  75     if (!fFileBacked)
  76         return true;
  77     {
  78         LOCK(cs_wallet);
  79         if (pwalletdbEncryption)
  80             return pwalletdbEncryption->WriteCryptedKey(vchPubKey, vchCryptedSecret, mapKeyMetadata[vchPubKey.GetID()]);
  81         else
  82             return CWalletDB(strWalletFile).WriteCryptedKey(vchPubKey, vchCryptedSecret, mapKeyMetadata[vchPubKey.GetID()]);
  83     }
  84     return false;
  85 }
  86
  87 bool CWallet::LoadKeyMetadata(const CPubKey &pubkey, const CKeyMetadata &meta)
  88 {
  89     if (meta.nCreateTime && (!nTimeFirstKey || meta.nCreateTime < nTimeFirstKey))
  90         nTimeFirstKey = meta.nCreateTime;
  91
  92     mapKeyMetadata[pubkey.GetID()] = meta;
  93     return true;
  94 }
  95
  96 bool CWallet::AddCScript(const CScript& redeemScript)
  97 {
  98     if (!CCryptoKeyStore::AddCScript(redeemScript))
  99         return false;
 100     if (!fFileBacked)
 101         return true;
 102     return CWalletDB(strWalletFile).WriteCScript(Hash160(redeemScript), redeemScript);
 103 }
 104
 105 // ppcoin: optional setting to unlock wallet for block minting only;
 106 //         serves to disable the trivial sendmoney when OS account compromised
 107 bool fWalletUnlockMintOnly = false;
 108
 109 bool CWallet::Unlock(const SecureString& strWalletPassphrase)
 110 {
 111     if (!IsLocked())
 112         return false;
 113
 114     CCrypter crypter;
 115     CKeyingMaterial vMasterKey;
 116
 117     {
 118         LOCK(cs_wallet);
 119         BOOST_FOREACH(const MasterKeyMap::value_type& pMasterKey, mapMasterKeys)
 120         {
 121             if(!crypter.SetKeyFromPassphrase(strWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
 122                 return false;
 123             if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, vMasterKey))
 124                 return false;
 125             if (CCryptoKeyStore::Unlock(vMasterKey))
 126                 return true;
 127         }
 128     }
 129     return false;
 130 }
 131
 132 bool CWallet::ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, const SecureString& strNewWalletPassphrase)
 133 {
 134     bool fWasLocked = IsLocked();
 135
 136     {
 137         LOCK(cs_wallet);
 138         Lock();
 139
 140         CCrypter crypter;
 141         CKeyingMaterial vMasterKey;
 142         BOOST_FOREACH(MasterKeyMap::value_type& pMasterKey, mapMasterKeys)
 143         {
 144             if(!crypter.SetKeyFromPassphrase(strOldWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
 145                 return false;
 146             if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, vMasterKey))
 147                 return false;
 148             if (CCryptoKeyStore::Unlock(vMasterKey))
 149             {
 150                 int64 nStartTime = GetTimeMillis();
 151                 crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);
 152                 pMasterKey.second.nDeriveIterations = pMasterKey.second.nDeriveIterations * (100 / ((double)(GetTimeMillis() - nStartTime)));
 153
 154                 nStartTime = GetTimeMillis();
 155                 crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);
 156                 pMasterKey.second.nDeriveIterations = (pMasterKey.second.nDeriveIterations + pMasterKey.second.nDeriveIterations * 100 / ((double)(GetTimeMillis() - nStartTime))) / 2;
 157
 158                 if (pMasterKey.second.nDeriveIterations < 25000)
 159                     pMasterKey.second.nDeriveIterations = 25000;
 160
 161                 printf("Wallet passphrase changed to an nDeriveIterations of %i\n", pMasterKey.second.nDeriveIterations);
 162
 163                 if (!crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
 164                     return false;
 165                 if (!crypter.Encrypt(vMasterKey, pMasterKey.second.vchCryptedKey))
 166                     return false;
 167                 CWalletDB(strWalletFile).WriteMasterKey(pMasterKey.first, pMasterKey.second);
 168                 if (fWasLocked)
 169                     Lock();
 170                 return true;
 171             }
 172         }
 173     }
 174
 175     return false;
 176 }
 177
 178 void CWallet::SetBestChain(const CBlockLocator& loc)
 179 {
 180     CWalletDB walletdb(strWalletFile);
 181     walletdb.WriteBestBlock(loc);
 182 }
 183
 184 // This class implements an addrIncoming entry that causes pre-0.4
 185 // clients to crash on startup if reading a private-key-encrypted wallet.
 186 class CCorruptAddress
 187 {
 188 public:
 189     IMPLEMENT_SERIALIZE
 190     (
 191         if (nType & SER_DISK)
 192             READWRITE(nVersion);
 193     )
 194 };
 195
 196 bool CWallet::SetMinVersion(enum WalletFeature nVersion, CWalletDB* pwalletdbIn, bool fExplicit)
 197 {
 198     if (nWalletVersion >= nVersion)
 199         return true;
 200
 201     // when doing an explicit upgrade, if we pass the max version permitted, upgrade all the way
 202     if (fExplicit && nVersion > nWalletMaxVersion)
 203             nVersion = FEATURE_LATEST;
 204
 205     nWalletVersion = nVersion;
 206
 207     if (nVersion > nWalletMaxVersion)
 208         nWalletMaxVersion = nVersion;
 209
 210     if (fFileBacked)
 211     {
 212         CWalletDB* pwalletdb = pwalletdbIn ? pwalletdbIn : new CWalletDB(strWalletFile);
 213         if (nWalletVersion >= 40000)
 214         {
 215             // Versions prior to 0.4.0 did not support the "minversion" record.
 216             // Use a CCorruptAddress to make them crash instead.
 217             CCorruptAddress corruptAddress;
 218             pwalletdb->WriteSetting("addrIncoming", corruptAddress);
 219         }
 220         if (nWalletVersion > 40000)
 221             pwalletdb->WriteMinVersion(nWalletVersion);
 222         if (!pwalletdbIn)
 223             delete pwalletdb;
 224     }
 225
 226     return true;
 227 }
 228
 229 bool CWallet::SetMaxVersion(int nVersion)
 230 {
 231     // cannot downgrade below current version
 232     if (nWalletVersion > nVersion)
 233         return false;
 234
 235     nWalletMaxVersion = nVersion;
 236
 237     return true;
 238 }
 239
 240 bool CWallet::EncryptWallet(const SecureString& strWalletPassphrase)
 241 {
 242     if (IsCrypted())
 243         return false;
 244
 245     CKeyingMaterial vMasterKey;
 246     RandAddSeedPerfmon();
 247
 248     vMasterKey.resize(WALLET_CRYPTO_KEY_SIZE);
 249     RAND_bytes(&vMasterKey[0], WALLET_CRYPTO_KEY_SIZE);
 250
 251     CMasterKey kMasterKey(nDerivationMethodIndex);
 252
 253     RandAddSeedPerfmon();
 254     kMasterKey.vchSalt.resize(WALLET_CRYPTO_SALT_SIZE);
 255     RAND_bytes(&kMasterKey.vchSalt[0], WALLET_CRYPTO_SALT_SIZE);
 256
 257     CCrypter crypter;
 258     int64 nStartTime = GetTimeMillis();
 259     crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, 25000, kMasterKey.nDerivationMethod);
 260     kMasterKey.nDeriveIterations = 2500000 / ((double)(GetTimeMillis() - nStartTime));
 261
 262     nStartTime = GetTimeMillis();
 263     crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, kMasterKey.nDeriveIterations, kMasterKey.nDerivationMethod);
 264     kMasterKey.nDeriveIterations = (kMasterKey.nDeriveIterations + kMasterKey.nDeriveIterations * 100 / ((double)(GetTimeMillis() - nStartTime))) / 2;
 265
 266     if (kMasterKey.nDeriveIterations < 25000)
 267         kMasterKey.nDeriveIterations = 25000;
 268
 269     printf("Encrypting Wallet with an nDeriveIterations of %i\n", kMasterKey.nDeriveIterations);
 270
 271     if (!crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, kMasterKey.nDeriveIterations, kMasterKey.nDerivationMethod))
 272         return false;
 273     if (!crypter.Encrypt(vMasterKey, kMasterKey.vchCryptedKey))
 274         return false;
 275
 276     {
 277         LOCK(cs_wallet);
 278         mapMasterKeys[++nMasterKeyMaxID] = kMasterKey;
 279         if (fFileBacked)
 280         {
 281             pwalletdbEncryption = new CWalletDB(strWalletFile);
 282             if (!pwalletdbEncryption->TxnBegin())
 283                 return false;
 284             pwalletdbEncryption->WriteMasterKey(nMasterKeyMaxID, kMasterKey);
 285         }
 286
 287         if (!EncryptKeys(vMasterKey))
 288         {
 289             if (fFileBacked)
 290                 pwalletdbEncryption->TxnAbort();
 291             exit(1); //We now probably have half of our keys encrypted in memory, and half not...die and let the user reload their unencrypted wallet.
 292         }
 293
 294         // Encryption was introduced in version 0.4.0
 295         SetMinVersion(FEATURE_WALLETCRYPT, pwalletdbEncryption, true);
 296
 297         if (fFileBacked)
 298         {
 299             if (!pwalletdbEncryption->TxnCommit())
 300                 exit(1); //We now have keys encrypted in memory, but no on disk...die to avoid confusion and let the user reload their unencrypted wallet.
 301
 302             delete pwalletdbEncryption;
 303             pwalletdbEncryption = NULL;
 304         }
 305
 306         Lock();
 307         Unlock(strWalletPassphrase);
 308         NewKeyPool();
 309         Lock();
 310
 311         // Need to completely rewrite the wallet file; if we don't, bdb might keep
 312         // bits of the unencrypted private key in slack space in the database file.
 313         CDB::Rewrite(strWalletFile);
 314
 315     }
 316     NotifyStatusChanged(this);
 317
 318     return true;
 319 }
 320
 321 int64 CWallet::IncOrderPosNext(CWalletDB *pwalletdb)
 322 {
 323     int64 nRet = nOrderPosNext++;
 324     if (pwalletdb) {
 325         pwalletdb->WriteOrderPosNext(nOrderPosNext);
 326     } else {
 327         CWalletDB(strWalletFile).WriteOrderPosNext(nOrderPosNext);
 328     }
 329     return nRet;
 330 }
 331
 332 CWallet::TxItems CWallet::OrderedTxItems(std::list<CAccountingEntry>& acentries, std::string strAccount)
 333 {
 334     CWalletDB walletdb(strWalletFile);
 335
 336     // First: get all CWalletTx and CAccountingEntry into a sorted-by-order multimap.
 337     TxItems txOrdered;
 338
 339     // Note: maintaining indices in the database of (account,time) --> txid and (account, time) --> acentry
 340     // would make this much faster for applications that do this a lot.
 341     for (map<uint256, CWalletTx>::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
 342     {
 343         CWalletTx* wtx = &((*it).second);
 344         txOrdered.insert(make_pair(wtx->nOrderPos, TxPair(wtx, (CAccountingEntry*)0)));
 345     }
 346     acentries.clear();
 347     walletdb.ListAccountCreditDebit(strAccount, acentries);
 348     BOOST_FOREACH(CAccountingEntry& entry, acentries)
 349     {
 350         txOrdered.insert(make_pair(entry.nOrderPos, TxPair((CWalletTx*)0, &entry)));
 351     }
 352
 353     return txOrdered;
 354 }
 355
 356 void CWallet::WalletUpdateSpent(const CTransaction &tx, bool fBlock)
 357 {
 358     // Anytime a signature is successfully verified, it's proof the outpoint is spent.
 359     // Update the wallet spent flag if it doesn't know due to wallet.dat being
 360     // restored from backup or the user making copies of wallet.dat.
 361     {
 362         LOCK(cs_wallet);
 363         BOOST_FOREACH(const CTxIn& txin, tx.vin)
 364         {
 365             map<uint256, CWalletTx>::iterator mi = mapWallet.find(txin.prevout.hash);
 366             if (mi != mapWallet.end())
 367             {
 368                 CWalletTx& wtx = (*mi).second;
 369                 if (txin.prevout.n >= wtx.vout.size())
 370                     printf("WalletUpdateSpent: bad wtx %s\n", wtx.GetHash().ToString().c_str());
 371                 else if (!wtx.IsSpent(txin.prevout.n) && IsMine(wtx.vout[txin.prevout.n]))
 372                 {
 373                     printf("WalletUpdateSpent found spent coin %snvc %s\n", FormatMoney(wtx.GetCredit()).c_str(), wtx.GetHash().ToString().c_str());
 374                     wtx.MarkSpent(txin.prevout.n);
 375                     wtx.WriteToDisk();
 376                     NotifyTransactionChanged(this, txin.prevout.hash, CT_UPDATED);
 377                 }
 378             }
 379         }
 380
 381         if (fBlock)
 382         {
 383             uint256 hash = tx.GetHash();
 384             map<uint256, CWalletTx>::iterator mi = mapWallet.find(hash);
 385             CWalletTx& wtx = (*mi).second;
 386
 387             BOOST_FOREACH(const CTxOut& txout, tx.vout)
 388             {
 389                 if (IsMine(txout))
 390                 {
 391                     wtx.MarkUnspent(&txout - &tx.vout[0]);
 392                     wtx.WriteToDisk();
 393                     NotifyTransactionChanged(this, hash, CT_UPDATED);
 394                 }
 395             }
 396         }
 397     }
 398 }
 399
 400 void CWallet::MarkDirty()
 401 {
 402     {
 403         LOCK(cs_wallet);
 404         BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet)
 405             item.second.MarkDirty();
 406     }
 407 }
 408
 409 bool CWallet::AddToWallet(const CWalletTx& wtxIn)
 410 {
 411     uint256 hash = wtxIn.GetHash();
 412     {
 413         LOCK(cs_wallet);
 414         // Inserts only if not already there, returns tx inserted or tx found
 415         pair<map<uint256, CWalletTx>::iterator, bool> ret = mapWallet.insert(make_pair(hash, wtxIn));
 416         CWalletTx& wtx = (*ret.first).second;
 417         wtx.BindWallet(this);
 418         bool fInsertedNew = ret.second;
 419         if (fInsertedNew)
 420         {
 421             wtx.nTimeReceived = GetAdjustedTime();
 422             wtx.nOrderPos = IncOrderPosNext();
 423
 424             wtx.nTimeSmart = wtx.nTimeReceived;
 425             if (wtxIn.hashBlock != 0)
 426             {
 427                 if (mapBlockIndex.count(wtxIn.hashBlock))
 428                 {
 429                     unsigned int latestNow = wtx.nTimeReceived;
 430                     unsigned int latestEntry = 0;
 431                     {
 432                         // Tolerate times up to the last timestamp in the wallet not more than 5 minutes into the future
 433                         int64 latestTolerated = latestNow + 300;
 434                         std::list<CAccountingEntry> acentries;
 435                         TxItems txOrdered = OrderedTxItems(acentries);
 436                         for (TxItems::reverse_iterator it = txOrdered.rbegin(); it != txOrdered.rend(); ++it)
 437                         {
 438                             CWalletTx *const pwtx = (*it).second.first;
 439                             if (pwtx == &wtx)
 440                                 continue;
 441                             CAccountingEntry *const pacentry = (*it).second.second;
 442                             int64 nSmartTime;
 443                             if (pwtx)
 444                             {
 445                                 nSmartTime = pwtx->nTimeSmart;
 446                                 if (!nSmartTime)
 447                                     nSmartTime = pwtx->nTimeReceived;
 448                             }
 449                             else
 450                                 nSmartTime = pacentry->nTime;
 451                             if (nSmartTime <= latestTolerated)
 452                             {
 453                                 latestEntry = nSmartTime;
 454                                 if (nSmartTime > latestNow)
 455                                     latestNow = nSmartTime;
 456                                 break;
 457                             }
 458                         }
 459                     }
 460
 461                     unsigned int& blocktime = mapBlockIndex[wtxIn.hashBlock]->nTime;
 462                     wtx.nTimeSmart = std::max(latestEntry, std::min(blocktime, latestNow));
 463                 }
 464                 else
 465                     printf("AddToWallet() : found %s in block %s not in index\n",
 466                            hash.ToString().substr(0,10).c_str(),
 467                            wtxIn.hashBlock.ToString().c_str());
 468             }
 469         }
 470
 471         bool fUpdated = false;
 472         if (!fInsertedNew)
 473         {
 474             // Merge
 475             if (wtxIn.hashBlock != 0 && wtxIn.hashBlock != wtx.hashBlock)
 476             {
 477                 wtx.hashBlock = wtxIn.hashBlock;
 478                 fUpdated = true;
 479             }
 480             if (wtxIn.nIndex != -1 && (wtxIn.vMerkleBranch != wtx.vMerkleBranch || wtxIn.nIndex != wtx.nIndex))
 481             {
 482                 wtx.vMerkleBranch = wtxIn.vMerkleBranch;
 483                 wtx.nIndex = wtxIn.nIndex;
 484                 fUpdated = true;
 485             }
 486             if (wtxIn.fFromMe && wtxIn.fFromMe != wtx.fFromMe)
 487             {
 488                 wtx.fFromMe = wtxIn.fFromMe;
 489                 fUpdated = true;
 490             }
 491             fUpdated |= wtx.UpdateSpent(wtxIn.vfSpent);
 492         }
 493
 494         //// debug print
 495         printf("AddToWallet %s  %s%s\n", hash.ToString().substr(0,10).c_str(), (fInsertedNew ? "new" : ""), (fUpdated ? "update" : ""));
 496
 497         // Write to disk
 498         if (fInsertedNew || fUpdated)
 499             if (!wtx.WriteToDisk())
 500                 return false;
 501 #ifndef QT_GUI
 502         // If default receiving address gets used, replace it with a new one
 503         CScript scriptDefaultKey;
 504         scriptDefaultKey.SetDestination(vchDefaultKey.GetID());
 505         BOOST_FOREACH(const CTxOut& txout, wtx.vout)
 506         {
 507             if (txout.scriptPubKey == scriptDefaultKey)
 508             {
 509                 CPubKey newDefaultKey;
 510                 if (GetKeyFromPool(newDefaultKey, false))
 511                 {
 512                     SetDefaultKey(newDefaultKey);
 513                     SetAddressBookName(vchDefaultKey.GetID(), "");
 514                 }
 515             }
 516         }
 517 #endif
 518         // since AddToWallet is called directly for self-originating transactions, check for consumption of own coins
 519         WalletUpdateSpent(wtx, (wtxIn.hashBlock != 0));
 520
 521         // Notify UI of new or updated transaction
 522         NotifyTransactionChanged(this, hash, fInsertedNew ? CT_NEW : CT_UPDATED);
 523
 524         // notify an external script when a wallet transaction comes in or is updated
 525         std::string strCmd = GetArg("-walletnotify", "");
 526
 527         if ( !strCmd.empty())
 528         {
 529             boost::replace_all(strCmd, "%s", hash.GetHex());
 530             boost::thread t(runCommand, strCmd); // thread runs free
 531         }
 532
 533     }
 534     return true;
 535 }
 536
 537 // Add a transaction to the wallet, or update it.
 538 // pblock is optional, but should be provided if the transaction is known to be in a block.
 539 // If fUpdate is true, existing transactions will be updated.
 540 bool CWallet::AddToWalletIfInvolvingMe(const uint256 &hash, const CTransaction& tx, const CBlock* pblock, bool fUpdate, bool fFindBlock)
 541 {
 542     {
 543         LOCK(cs_wallet);
 544         bool fExisted = mapWallet.count(hash);
 545         if (fExisted && !fUpdate) return false;
 546         if (fExisted || IsMine(tx) || IsFromMe(tx))
 547         {
 548             CWalletTx wtx(this,tx);
 549             // Get merkle branch if transaction was found in a block
 550             if (pblock)
 551                 wtx.SetMerkleBranch(pblock);
 552             return AddToWallet(wtx);
 553         }
 554         else
 555             WalletUpdateSpent(tx);
 556     }
 557     return false;
 558 }
 559
 560 bool CWallet::EraseFromWallet(uint256 hash)
 561 {
 562     if (!fFileBacked)
 563         return false;
 564     {
 565         LOCK(cs_wallet);
 566         if (mapWallet.erase(hash))
 567             CWalletDB(strWalletFile).EraseTx(hash);
 568     }
 569     return true;
 570 }
 571
 572
 573 bool CWallet::IsMine(const CTxIn &txin) const
 574 {
 575     {
 576         LOCK(cs_wallet);
 577         map<uint256, CWalletTx>::const_iterator mi = mapWallet.find(txin.prevout.hash);
 578         if (mi != mapWallet.end())
 579         {
 580             const CWalletTx& prev = (*mi).second;
 581             if (txin.prevout.n < prev.vout.size())
 582                 if (IsMine(prev.vout[txin.prevout.n]))
 583                     return true;
 584         }
 585     }
 586     return false;
 587 }
 588
 589 int64 CWallet::GetDebit(const CTxIn &txin) const
 590 {
 591     {
 592         LOCK(cs_wallet);
 593         map<uint256, CWalletTx>::const_iterator mi = mapWallet.find(txin.prevout.hash);
 594         if (mi != mapWallet.end())
 595         {
 596             const CWalletTx& prev = (*mi).second;
 597             if (txin.prevout.n < prev.vout.size())
 598                 if (IsMine(prev.vout[txin.prevout.n]))
 599                     return prev.vout[txin.prevout.n].nValue;
 600         }
 601     }
 602     return 0;
 603 }
 604
 605 bool CWallet::IsChange(const CTxOut& txout) const
 606 {
 607     CTxDestination address;
 608
 609     // TODO: fix handling of 'change' outputs. The assumption is that any
 610     // payment to a TX_PUBKEYHASH that is mine but isn't in the address book
 611     // is change. That assumption is likely to break when we implement multisignature
 612     // wallets that return change back into a multi-signature-protected address;
 613     // a better way of identifying which outputs are 'the send' and which are
 614     // 'the change' will need to be implemented (maybe extend CWalletTx to remember
 615     // which output, if any, was change).
 616     if (ExtractDestination(txout.scriptPubKey, address) && ::IsMine(*this, address))
 617     {
 618         LOCK(cs_wallet);
 619         if (!mapAddressBook.count(address))
 620             return true;
 621     }
 622     return false;
 623 }
 624
 625 int64 CWalletTx::GetTxTime() const
 626 {
 627     int64 n = nTimeSmart;
 628     return n ? n : nTimeReceived;
 629 }
 630
 631 int CWalletTx::GetRequestCount() const
 632 {
 633     // Returns -1 if it wasn't being tracked
 634     int nRequests = -1;
 635     {
 636         LOCK(pwallet->cs_wallet);
 637         if (IsCoinBase() || IsCoinStake())
 638         {
 639             // Generated block
 640             if (hashBlock != 0)
 641             {
 642                 map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(hashBlock);
 643                 if (mi != pwallet->mapRequestCount.end())
 644                     nRequests = (*mi).second;
 645             }
 646         }
 647         else
 648         {
 649             // Did anyone request this transaction?
 650             map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(GetHash());
 651             if (mi != pwallet->mapRequestCount.end())
 652             {
 653                 nRequests = (*mi).second;
 654
 655                 // How about the block it's in?
 656                 if (nRequests == 0 && hashBlock != 0)
 657                 {
 658                     map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(hashBlock);
 659                     if (mi != pwallet->mapRequestCount.end())
 660                         nRequests = (*mi).second;
 661                     else
 662                         nRequests = 1; // If it's in someone else's block it must have got out
 663                 }
 664             }
 665         }
 666     }
 667     return nRequests;
 668 }
 669
 670 void CWalletTx::GetAmounts(int64& nGeneratedImmature, int64& nGeneratedMature, list<pair<CTxDestination, int64> >& listReceived,
 671                            list<pair<CTxDestination, int64> >& listSent, int64& nFee, string& strSentAccount) const
 672 {
 673     nGeneratedImmature = nGeneratedMature = nFee = 0;
 674     listReceived.clear();
 675     listSent.clear();
 676     strSentAccount = strFromAccount;
 677
 678     if (IsCoinBase() || IsCoinStake())
 679     {
 680         if (GetBlocksToMaturity() > 0)
 681             nGeneratedImmature = pwallet->GetCredit(*this);
 682         else
 683             nGeneratedMature = GetCredit();
 684         return;
 685     }
 686
 687     // Compute fee:
 688     int64 nDebit = GetDebit();
 689     if (nDebit > 0) // debit>0 means we signed/sent this transaction
 690     {
 691         int64 nValueOut = GetValueOut();
 692         nFee = nDebit - nValueOut;
 693     }
 694
 695     // Sent/received.
 696     BOOST_FOREACH(const CTxOut& txout, vout)
 697     {
 698         CTxDestination address;
 699         vector<unsigned char> vchPubKey;
 700         if (!ExtractDestination(txout.scriptPubKey, address))
 701         {
 702             printf("CWalletTx::GetAmounts: Unknown transaction type found, txid %s\n",
 703                    this->GetHash().ToString().c_str());
 704         }
 705
 706         // Don't report 'change' txouts
 707         if (nDebit > 0 && pwallet->IsChange(txout))
 708             continue;
 709
 710         if (nDebit > 0)
 711             listSent.push_back(make_pair(address, txout.nValue));
 712
 713         if (pwallet->IsMine(txout))
 714             listReceived.push_back(make_pair(address, txout.nValue));
 715     }
 716
 717 }
 718
 719 void CWalletTx::GetAccountAmounts(const string& strAccount, int64& nGenerated, int64& nReceived,
 720                                   int64& nSent, int64& nFee) const
 721 {
 722     nGenerated = nReceived = nSent = nFee = 0;
 723
 724     int64 allGeneratedImmature, allGeneratedMature, allFee;
 725     allGeneratedImmature = allGeneratedMature = allFee = 0;
 726     string strSentAccount;
 727     list<pair<CTxDestination, int64> > listReceived;
 728     list<pair<CTxDestination, int64> > listSent;
 729     GetAmounts(allGeneratedImmature, allGeneratedMature, listReceived, listSent, allFee, strSentAccount);
 730
 731     if (strAccount == "")
 732         nGenerated = allGeneratedMature;
 733     if (strAccount == strSentAccount)
 734     {
 735         BOOST_FOREACH(const PAIRTYPE(CTxDestination,int64)& s, listSent)
 736             nSent += s.second;
 737         nFee = allFee;
 738     }
 739     {
 740         LOCK(pwallet->cs_wallet);
 741         BOOST_FOREACH(const PAIRTYPE(CTxDestination,int64)& r, listReceived)
 742         {
 743             if (pwallet->mapAddressBook.count(r.first))
 744             {
 745                 map<CTxDestination, string>::const_iterator mi = pwallet->mapAddressBook.find(r.first);
 746                 if (mi != pwallet->mapAddressBook.end() && (*mi).second == strAccount)
 747                     nReceived += r.second;
 748             }
 749             else if (strAccount.empty())
 750             {
 751                 nReceived += r.second;
 752             }
 753         }
 754     }
 755 }
 756
 757 void CWalletTx::AddSupportingTransactions()
 758 {
 759     vtxPrev.clear();
 760
 761     const int COPY_DEPTH = 3;
 762     if (SetMerkleBranch() < COPY_DEPTH)
 763     {
 764         vector<uint256> vWorkQueue;
 765         BOOST_FOREACH(const CTxIn& txin, vin)
 766             vWorkQueue.push_back(txin.prevout.hash);
 767
 768         {
 769             LOCK(pwallet->cs_wallet);
 770             map<uint256, const CMerkleTx*> mapWalletPrev;
 771             set<uint256> setAlreadyDone;
 772             for (unsigned int i = 0; i < vWorkQueue.size(); i++)
 773             {
 774                 uint256 hash = vWorkQueue[i];
 775                 if (setAlreadyDone.count(hash))
 776                     continue;
 777                 setAlreadyDone.insert(hash);
 778
 779                 CMerkleTx tx;
 780                 map<uint256, CWalletTx>::const_iterator mi = pwallet->mapWallet.find(hash);
 781                 if (mi != pwallet->mapWallet.end())
 782                 {
 783                     tx = (*mi).second;
 784                     BOOST_FOREACH(const CMerkleTx& txWalletPrev, (*mi).second.vtxPrev)
 785                         mapWalletPrev[txWalletPrev.GetHash()] = &txWalletPrev;
 786                 }
 787                 else if (mapWalletPrev.count(hash))
 788                 {
 789                     tx = *mapWalletPrev[hash];
 790                 }
 791
 792                 int nDepth = tx.SetMerkleBranch();
 793                 vtxPrev.push_back(tx);
 794
 795                 if (nDepth < COPY_DEPTH)
 796                 {
 797                     BOOST_FOREACH(const CTxIn& txin, tx.vin)
 798                         vWorkQueue.push_back(txin.prevout.hash);
 799                 }
 800             }
 801         }
 802     }
 803
 804     reverse(vtxPrev.begin(), vtxPrev.end());
 805 }
 806
 807 bool CWalletTx::WriteToDisk()
 808 {
 809     return CWalletDB(pwallet->strWalletFile).WriteTx(GetHash(), *this);
 810 }
 811
 812 // Scan the block chain (starting in pindexStart) for transactions
 813 // from or to us. If fUpdate is true, found transactions that already
 814 // exist in the wallet will be updated.
 815 int CWallet::ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate)
 816 {
 817     int ret = 0;
 818
 819     CBlockIndex* pindex = pindexStart;
 820     {
 821         LOCK(cs_wallet);
 822         while (pindex)
 823         {
 824             CBlock block;
 825             block.ReadFromDisk(pindex, true);
 826             BOOST_FOREACH(CTransaction& tx, block.vtx)
 827             {
 828                 if (AddToWalletIfInvolvingMe(tx.GetHash(), tx, &block, fUpdate))
 829                     ret++;
 830             }
 831             pindex = pindex->pnext;
 832         }
 833     }
 834     return ret;
 835 }
 836
 837 void CWallet::ReacceptWalletTransactions()
 838 {
 839     bool fRepeat = true;
 840     while (fRepeat)
 841     {
 842         LOCK(cs_wallet);
 843         fRepeat = false;
 844         bool fMissing = false;
 845         BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet)
 846         {
 847             CWalletTx& wtx = item.second;
 848             if ((wtx.IsCoinBase() && wtx.IsSpent(0)) || (wtx.IsCoinStake() && wtx.IsSpent(1)))
 849                 continue;
 850
 851             CCoins coins;
 852             bool fUpdated = false;
 853             bool fNotFound = pcoinsTip->GetCoins(wtx.GetHash(), coins);
 854             if (!fNotFound || wtx.GetDepthInMainChain() > 0)
 855             {
 856                 // Update fSpent if a tx got spent somewhere else by a copy of wallet.dat
 857                 for (unsigned int i = 0; i < wtx.vout.size(); i++)
 858                 {
 859                     if (wtx.IsSpent(i))
 860                         continue;
 861                     if ((i >= coins.vout.size() || coins.vout[i].IsNull()) && IsMine(wtx.vout[i]))
 862                     {
 863                         wtx.MarkSpent(i);
 864                         fUpdated = true;
 865                         fMissing = true;
 866                     }
 867                 }
 868                 if (fUpdated)
 869                 {
 870                     printf("ReacceptWalletTransactions found spent coin %snvc %s\n", FormatMoney(wtx.GetCredit()).c_str(), wtx.GetHash().ToString().c_str());
 871                     wtx.MarkDirty();
 872                     wtx.WriteToDisk();
 873                 }
 874             }
 875             else
 876             {
 877                 // Re-accept any txes of ours that aren't already in a block
 878                 if (!(wtx.IsCoinBase() || wtx.IsCoinStake()))
 879                     wtx.AcceptWalletTransaction(false);
 880             }
 881         }
 882         if (fMissing)
 883         {
 884             // TODO: optimize this to scan just part of the block chain?
 885             if (ScanForWalletTransactions(pindexGenesisBlock))
 886                 fRepeat = true;  // Found missing transactions: re-do re-accept.
 887         }
 888     }
 889 }
 890
 891 void CWalletTx::RelayWalletTransaction()
 892 {
 893     CCoinsViewCache& coins = *pcoinsTip;
 894     BOOST_FOREACH(const CMerkleTx& tx, vtxPrev)
 895     {
 896         if (!(tx.IsCoinBase() || tx.IsCoinStake()))
 897         {
 898             uint256 hash = tx.GetHash();
 899             if (!coins.HaveCoins(hash))
 900                 RelayTransaction((CTransaction)tx, hash);
 901         }
 902     }
 903     if (!(IsCoinBase() || IsCoinStake()))
 904     {
 905         uint256 hash = GetHash();
 906         if (!coins.HaveCoins(hash))
 907         {
 908             printf("Relaying wtx %s\n", hash.ToString().substr(0,10).c_str());
 909             RelayTransaction((CTransaction)*this, hash);
 910         }
 911     }
 912 }
 913
 914 void CWallet::ResendWalletTransactions()
 915 {
 916     // Do this infrequently and randomly to avoid giving away
 917     // that these are our transactions.
 918     static int64 nNextTime;
 919     if (GetTime() < nNextTime)
 920         return;
 921     bool fFirst = (nNextTime == 0);
 922     nNextTime = GetTime() + GetRand(30 * 60);
 923     if (fFirst)
 924         return;
 925
 926     // Only do it if there's been a new block since last time
 927     static int64 nLastTime;
 928     if (nTimeBestReceived < nLastTime)
 929         return;
 930     nLastTime = GetTime();
 931
 932     // Rebroadcast any of our txes that aren't in a block yet
 933     printf("ResendWalletTransactions()\n");
 934     {
 935         LOCK(cs_wallet);
 936         // Sort them in chronological order
 937         multimap<unsigned int, CWalletTx*> mapSorted;
 938         BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet)
 939         {
 940             CWalletTx& wtx = item.second;
 941             // Don't rebroadcast until it's had plenty of time that
 942             // it should have gotten in already by now.
 943             if (nTimeBestReceived - (int64)wtx.nTimeReceived > 5 * 60)
 944                 mapSorted.insert(make_pair(wtx.nTimeReceived, &wtx));
 945         }
 946         BOOST_FOREACH(PAIRTYPE(const unsigned int, CWalletTx*)& item, mapSorted)
 947         {
 948             CWalletTx& wtx = *item.second;
 949             wtx.RelayWalletTransaction();
 950         }
 951     }
 952 }
 953
 954
 955
 956
 957
 958
 959 //////////////////////////////////////////////////////////////////////////////
 960 //
 961 // Actions
 962 //
 963
 964
 965 int64 CWallet::GetBalance() const
 966 {
 967     int64 nTotal = 0;
 968     {
 969         LOCK(cs_wallet);
 970         for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
 971         {
 972             const CWalletTx* pcoin = &(*it).second;
 973             if (pcoin->IsConfirmed())
 974                 nTotal += pcoin->GetAvailableCredit();
 975         }
 976     }
 977
 978     return nTotal;
 979 }
 980
 981 int64 CWallet::GetUnconfirmedBalance() const
 982 {
 983     int64 nTotal = 0;
 984     {
 985         LOCK(cs_wallet);
 986         for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
 987         {
 988             const CWalletTx* pcoin = &(*it).second;
 989             if (!pcoin->IsFinal() || !pcoin->IsConfirmed())
 990                 nTotal += pcoin->GetAvailableCredit();
 991         }
 992     }
 993     return nTotal;
 994 }
 995
 996 int64 CWallet::GetImmatureBalance() const
 997 {
 998     int64 nTotal = 0;
 999     {
1000         LOCK(cs_wallet);
1001         for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
1002         {
1003             const CWalletTx& pcoin = (*it).second;
1004             if (pcoin.IsCoinBase() && pcoin.GetBlocksToMaturity() > 0 && pcoin.IsInMainChain())
1005                 nTotal += GetCredit(pcoin);
1006         }
1007     }
1008     return nTotal;
1009 }
1010
1011 // populate vCoins with vector of spendable COutputs
1012 void CWallet::AvailableCoins(vector<COutput>& vCoins, bool fOnlyConfirmed, const CCoinControl *coinControl) const
1013 {
1014     vCoins.clear();
1015
1016     {
1017         LOCK(cs_wallet);
1018         for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
1019         {
1020             const CWalletTx* pcoin = &(*it).second;
1021
1022             if (!pcoin->IsFinal())
1023                 continue;
1024
1025             if (fOnlyConfirmed && !pcoin->IsConfirmed())
1026                 continue;
1027
1028             if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0)
1029                 continue;
1030
1031             if(pcoin->IsCoinStake() && pcoin->GetBlocksToMaturity() > 0)
1032                 continue;
1033
1034             for (unsigned int i = 0; i < pcoin->vout.size(); i++)
1035                 if (!(pcoin->IsSpent(i)) && IsMine(pcoin->vout[i]) && pcoin->vout[i].nValue >= nMinimumInputValue &&
1036                 (!coinControl || !coinControl->HasSelected() || coinControl->IsSelected((*it).first, i)))
1037                     vCoins.push_back(COutput(pcoin, i, pcoin->GetDepthInMainChain()));
1038
1039         }
1040     }
1041 }
1042
1043 void CWallet::AvailableCoinsMinConf(vector<COutput>& vCoins, int nConf) const
1044 {
1045     vCoins.clear();
1046
1047     {
1048         LOCK(cs_wallet);
1049         for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
1050         {
1051             const CWalletTx* pcoin = &(*it).second;
1052
1053             if (!pcoin->IsFinal())
1054                 continue;
1055
1056             if(pcoin->GetDepthInMainChain() < nConf)
1057                 continue;
1058
1059             for (unsigned int i = 0; i < pcoin->vout.size(); i++)
1060                 if (!(pcoin->IsSpent(i)) && IsMine(pcoin->vout[i]) && pcoin->vout[i].nValue >= nMinimumInputValue)
1061                     vCoins.push_back(COutput(pcoin, i, pcoin->GetDepthInMainChain()));
1062         }
1063     }
1064 }
1065
1066 static void ApproximateBestSubset(vector<pair<int64, pair<const CWalletTx*,unsigned int> > >vValue, int64 nTotalLower, int64 nTargetValue,
1067                                   vector<char>& vfBest, int64& nBest, int iterations = 1000)
1068 {
1069     vector<char> vfIncluded;
1070
1071     vfBest.assign(vValue.size(), true);
1072     nBest = nTotalLower;
1073
1074     for (int nRep = 0; nRep < iterations && nBest != nTargetValue; nRep++)
1075     {
1076         vfIncluded.assign(vValue.size(), false);
1077         int64 nTotal = 0;
1078         bool fReachedTarget = false;
1079         for (int nPass = 0; nPass < 2 && !fReachedTarget; nPass++)
1080         {
1081             for (unsigned int i = 0; i < vValue.size(); i++)
1082             {
1083                 if (nPass == 0 ? rand() % 2 : !vfIncluded[i])
1084                 {
1085                     nTotal += vValue[i].first;
1086                     vfIncluded[i] = true;
1087                     if (nTotal >= nTargetValue)
1088                     {
1089                         fReachedTarget = true;
1090                         if (nTotal < nBest)
1091                         {
1092                             nBest = nTotal;
1093                             vfBest = vfIncluded;
1094                         }
1095                         nTotal -= vValue[i].first;
1096                         vfIncluded[i] = false;
1097                     }
1098                 }
1099             }
1100         }
1101     }
1102 }
1103
1104 // ppcoin: total coins staked (non-spendable until maturity)
1105 int64 CWallet::GetStake() const
1106 {
1107     int64 nTotal = 0;
1108     LOCK(cs_wallet);
1109     for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
1110     {
1111         const CWalletTx* pcoin = &(*it).second;
1112         if (pcoin->IsCoinStake() && pcoin->GetBlocksToMaturity() > 0 && pcoin->GetDepthInMainChain() > 0)
1113             nTotal += CWallet::GetCredit(*pcoin);
1114     }
1115     return nTotal;
1116 }
1117
1118 int64 CWallet::GetNewMint() const
1119 {
1120     int64 nTotal = 0;
1121     LOCK(cs_wallet);
1122     for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
1123     {
1124         const CWalletTx* pcoin = &(*it).second;
1125         if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0 && pcoin->GetDepthInMainChain() > 0)
1126             nTotal += CWallet::GetCredit(*pcoin);
1127     }
1128     return nTotal;
1129 }
1130
1131 bool CWallet::SelectCoinsMinConf(int64 nTargetValue, unsigned int nSpendTime, int nConfMine, int nConfTheirs, vector<COutput> vCoins, set<pair<const CWalletTx*,unsigned int> >& setCoinsRet, int64& nValueRet) const
1132 {
1133     setCoinsRet.clear();
1134     nValueRet = 0;
1135
1136     // List of values less than target
1137     pair<int64, pair<const CWalletTx*,unsigned int> > coinLowestLarger;
1138     coinLowestLarger.first = std::numeric_limits<int64>::max();
1139     coinLowestLarger.second.first = NULL;
1140     vector<pair<int64, pair<const CWalletTx*,unsigned int> > > vValue;
1141     int64 nTotalLower = 0;
1142
1143     random_shuffle(vCoins.begin(), vCoins.end(), GetRandInt);
1144
1145     BOOST_FOREACH(COutput output, vCoins)
1146     {
1147         const CWalletTx *pcoin = output.tx;
1148
1149         if (output.nDepth < (pcoin->IsFromMe() ? nConfMine : nConfTheirs))
1150             continue;
1151
1152         int i = output.i;
1153
1154         // Follow the timestamp rules
1155         if (pcoin->nTime > nSpendTime)
1156             continue;
1157
1158         int64 n = pcoin->vout[i].nValue;
1159
1160         pair<int64,pair<const CWalletTx*,unsigned int> > coin = make_pair(n,make_pair(pcoin, i));
1161
1162         if (n == nTargetValue)
1163         {
1164             setCoinsRet.insert(coin.second);
1165             nValueRet += coin.first;
1166             return true;
1167         }
1168         else if (n < nTargetValue + CENT)
1169         {
1170             vValue.push_back(coin);
1171             nTotalLower += n;
1172         }
1173         else if (n < coinLowestLarger.first)
1174         {
1175             coinLowestLarger = coin;
1176         }
1177     }
1178
1179     if (nTotalLower == nTargetValue)
1180     {
1181         for (unsigned int i = 0; i < vValue.size(); ++i)
1182         {
1183             setCoinsRet.insert(vValue[i].second);
1184             nValueRet += vValue[i].first;
1185         }
1186         return true;
1187     }
1188
1189     if (nTotalLower < nTargetValue)
1190     {
1191         if (coinLowestLarger.second.first == NULL)
1192             return false;
1193         setCoinsRet.insert(coinLowestLarger.second);
1194         nValueRet += coinLowestLarger.first;
1195         return true;
1196     }
1197
1198     // Solve subset sum by stochastic approximation
1199     sort(vValue.rbegin(), vValue.rend(), CompareValueOnly());
1200     vector<char> vfBest;
1201     int64 nBest;
1202
1203     ApproximateBestSubset(vValue, nTotalLower, nTargetValue, vfBest, nBest, 1000);
1204     if (nBest != nTargetValue && nTotalLower >= nTargetValue + CENT)
1205         ApproximateBestSubset(vValue, nTotalLower, nTargetValue + CENT, vfBest, nBest, 1000);
1206
1207     // If we have a bigger coin and (either the stochastic approximation didn't find a good solution,
1208     //                                   or the next bigger coin is closer), return the bigger coin
1209     if (coinLowestLarger.second.first &&
1210         ((nBest != nTargetValue && nBest < nTargetValue + CENT) || coinLowestLarger.first <= nBest))
1211     {
1212         setCoinsRet.insert(coinLowestLarger.second);
1213         nValueRet += coinLowestLarger.first;
1214     }
1215     else {
1216         for (unsigned int i = 0; i < vValue.size(); i++)
1217             if (vfBest[i])
1218             {
1219                 setCoinsRet.insert(vValue[i].second);
1220                 nValueRet += vValue[i].first;
1221             }
1222
1223         if (fDebug && GetBoolArg("-printpriority"))
1224         {
1225             //// debug print
1226             printf("SelectCoins() best subset: ");
1227             for (unsigned int i = 0; i < vValue.size(); i++)
1228                 if (vfBest[i])
1229                     printf("%s ", FormatMoney(vValue[i].first).c_str());
1230             printf("total %s\n", FormatMoney(nBest).c_str());
1231         }
1232     }
1233
1234     return true;
1235 }
1236
1237 bool CWallet::SelectCoins(int64 nTargetValue, unsigned int nSpendTime, set<pair<const CWalletTx*,unsigned int> >& setCoinsRet, int64& nValueRet, const CCoinControl* coinControl) const
1238 {
1239     vector<COutput> vCoins;
1240     AvailableCoins(vCoins, true, coinControl);
1241
1242     // coin control -> return all selected outputs (we want all selected to go into the transaction for sure)
1243     if (coinControl && coinControl->HasSelected())
1244     {
1245         BOOST_FOREACH(const COutput& out, vCoins)
1246         {
1247             nValueRet += out.tx->vout[out.i].nValue;
1248             setCoinsRet.insert(make_pair(out.tx, out.i));
1249         }
1250         return (nValueRet >= nTargetValue);
1251     }
1252
1253     return (SelectCoinsMinConf(nTargetValue, nSpendTime, 1, 6, vCoins, setCoinsRet, nValueRet) ||
1254             SelectCoinsMinConf(nTargetValue, nSpendTime, 1, 1, vCoins, setCoinsRet, nValueRet) ||
1255             SelectCoinsMinConf(nTargetValue, nSpendTime, 0, 1, vCoins, setCoinsRet, nValueRet));
1256 }
1257
1258 // Select some coins without random shuffle or best subset approximation
1259 bool CWallet::SelectCoinsSimple(int64 nTargetValue, unsigned int nSpendTime, int nMinConf, set<pair<const CWalletTx*,unsigned int> >& setCoinsRet, int64& nValueRet) const
1260 {
1261     vector<COutput> vCoins;
1262     AvailableCoinsMinConf(vCoins, nMinConf);
1263
1264     setCoinsRet.clear();
1265     nValueRet = 0;
1266
1267     BOOST_FOREACH(COutput output, vCoins)
1268     {
1269         const CWalletTx *pcoin = output.tx;
1270         int i = output.i;
1271
1272         // Stop if we've chosen enough inputs
1273         if (nValueRet >= nTargetValue)
1274             break;
1275
1276         // Follow the timestamp rules
1277         if (pcoin->nTime > nSpendTime)
1278             continue;
1279
1280         int64 n = pcoin->vout[i].nValue;
1281
1282         pair<int64,pair<const CWalletTx*,unsigned int> > coin = make_pair(n,make_pair(pcoin, i));
1283
1284         if (n >= nTargetValue)
1285         {
1286             // If input value is greater or equal to target then simply insert
1287             //    it into the current subset and exit
1288             setCoinsRet.insert(coin.second);
1289             nValueRet += coin.first;
1290             break;
1291         }
1292         else if (n < nTargetValue + CENT)
1293         {
1294             setCoinsRet.insert(coin.second);
1295             nValueRet += coin.first;
1296         }
1297     }
1298
1299     return true;
1300 }
1301
1302 bool CWallet::CreateTransaction(const vector<pair<CScript, int64> >& vecSend, CWalletTx& wtxNew, CReserveKey& reservekey, int64& nFeeRet, const CCoinControl* coinControl)
1303 {
1304     int64 nValue = 0;
1305     BOOST_FOREACH (const PAIRTYPE(CScript, int64)& s, vecSend)
1306     {
1307         if (nValue < 0)
1308             return false;
1309         nValue += s.second;
1310     }
1311     if (vecSend.empty() || nValue < 0)
1312         return false;
1313
1314     wtxNew.BindWallet(this);
1315
1316     {
1317         LOCK2(cs_main, cs_wallet);
1318         {
1319             nFeeRet = nTransactionFee;
1320             while (true)
1321             {
1322                 wtxNew.vin.clear();
1323                 wtxNew.vout.clear();
1324                 wtxNew.fFromMe = true;
1325
1326                 int64 nTotalValue = nValue + nFeeRet;
1327                 double dPriority = 0;
1328                 // vouts to the payees
1329                 BOOST_FOREACH (const PAIRTYPE(CScript, int64)& s, vecSend)
1330                     wtxNew.vout.push_back(CTxOut(s.second, s.first));
1331
1332                 // Choose coins to use
1333                 set<pair<const CWalletTx*,unsigned int> > setCoins;
1334                 int64 nValueIn = 0;
1335                 if (!SelectCoins(nTotalValue, wtxNew.nTime, setCoins, nValueIn, coinControl))
1336                     return false;
1337                 BOOST_FOREACH(PAIRTYPE(const CWalletTx*, unsigned int) pcoin, setCoins)
1338                 {
1339                     int64 nCredit = pcoin.first->vout[pcoin.second].nValue;
1340                     dPriority += (double)nCredit * pcoin.first->GetDepthInMainChain();
1341                 }
1342
1343                 int64 nChange = nValueIn - nValue - nFeeRet;
1344                 // if sub-cent change is required, the fee must be raised to at least MIN_TX_FEE
1345                 // or until nChange becomes zero
1346                 // NOTE: this depends on the exact behaviour of GetMinFee
1347                 if (nFeeRet < MIN_TX_FEE && nChange > 0 && nChange < CENT)
1348                 {
1349                     int64 nMoveToFee = min(nChange, MIN_TX_FEE - nFeeRet);
1350                     nChange -= nMoveToFee;
1351                     nFeeRet += nMoveToFee;
1352                 }
1353
1354                 // sub-cent change is moved to fee
1355                 if (nChange > 0 && nChange < MIN_TXOUT_AMOUNT)
1356                 {
1357                     nFeeRet += nChange;
1358                     nChange = 0;
1359                 }
1360
1361                 if (nChange > 0)
1362                 {
1363                     // Fill a vout to ourself
1364                     // TODO: pass in scriptChange instead of reservekey so
1365                     // change transaction isn't always pay-to-bitcoin-address
1366                     CScript scriptChange;
1367
1368                     // coin control: send change to custom address
1369                     if (coinControl && !boost::get<CNoDestination>(&coinControl->destChange))
1370                         scriptChange.SetDestination(coinControl->destChange);
1371
1372                     // no coin control: send change to newly generated address
1373                     else
1374                     {
1375                         // Note: We use a new key here to keep it from being obvious which side is the change.
1376                         //  The drawback is that by not reusing a previous key, the change may be lost if a
1377                         //  backup is restored, if the backup doesn't have the new private key for the change.
1378                         //  If we reused the old key, it would be possible to add code to look for and
1379                         //  rediscover unknown transactions that were written with keys of ours to recover
1380                         //  post-backup change.
1381
1382                         // Reserve a new key pair from key pool
1383                         CPubKey vchPubKey = reservekey.GetReservedKey();
1384
1385                         scriptChange.SetDestination(vchPubKey.GetID());
1386                     }
1387
1388                     // Insert change txn at random position:
1389                     vector<CTxOut>::iterator position = wtxNew.vout.begin()+GetRandInt(wtxNew.vout.size());
1390                     wtxNew.vout.insert(position, CTxOut(nChange, scriptChange));
1391                 }
1392                 else
1393                     reservekey.ReturnKey();
1394
1395                 // Fill vin
1396                 BOOST_FOREACH(const PAIRTYPE(const CWalletTx*,unsigned int)& coin, setCoins)
1397                     wtxNew.vin.push_back(CTxIn(coin.first->GetHash(),coin.second));
1398
1399                 // Sign
1400                 int nIn = 0;
1401                 BOOST_FOREACH(const PAIRTYPE(const CWalletTx*,unsigned int)& coin, setCoins)
1402                     if (!SignSignature(*this, *coin.first, wtxNew, nIn++))
1403                         return false;
1404
1405                 // Limit size
1406                 unsigned int nBytes = ::GetSerializeSize(*(CTransaction*)&wtxNew, SER_NETWORK, PROTOCOL_VERSION);
1407                 if (nBytes >= MAX_BLOCK_SIZE_GEN/5)
1408                     return false;
1409                 dPriority /= nBytes;
1410
1411                 // Check that enough fee is included
1412                 int64 nPayFee = nTransactionFee * (1 + (int64)nBytes / 1000);
1413                 bool fAllowFree = CTransaction::AllowFree(dPriority);
1414                 int64 nMinFee = wtxNew.GetMinFee(1, fAllowFree, GMF_SEND);
1415                 if (nFeeRet < max(nPayFee, nMinFee))
1416                 {
1417                     nFeeRet = max(nPayFee, nMinFee);
1418                     continue;
1419                 }
1420
1421                 // Fill vtxPrev by copying from previous transactions vtxPrev
1422                 wtxNew.AddSupportingTransactions();
1423                 wtxNew.fTimeReceivedIsTxTime = true;
1424
1425                 break;
1426             }
1427         }
1428     }
1429     return true;
1430 }
1431
1432 bool CWallet::CreateTransaction(CScript scriptPubKey, int64 nValue, CWalletTx& wtxNew, CReserveKey& reservekey, int64& nFeeRet, const CCoinControl* coinControl)
1433 {
1434     vector< pair<CScript, int64> > vecSend;
1435     vecSend.push_back(make_pair(scriptPubKey, nValue));
1436     return CreateTransaction(vecSend, wtxNew, reservekey, nFeeRet, coinControl);
1437 }
1438
1439 // NovaCoin: get current stake weight
1440 bool CWallet::GetStakeWeight(const CKeyStore& keystore, uint64& nMinWeight, uint64& nMaxWeight, uint64& nWeight)
1441 {
1442     // Choose coins to use
1443     int64 nBalance = GetBalance();
1444     int64 nReserveBalance = 0;
1445
1446     if (mapArgs.count("-reservebalance") && !ParseMoney(mapArgs["-reservebalance"], nReserveBalance))
1447     {
1448         error("GetStakeWeight : invalid reserve balance amount");
1449         return false;
1450     }
1451
1452     if (nBalance <= nReserveBalance)
1453         return false;
1454
1455     vector<const CWalletTx*> vwtxPrev;
1456     set<pair<const CWalletTx*,unsigned int> > setCoins;
1457     int64 nValueIn = 0;
1458
1459     if (!SelectCoinsSimple(nBalance - nReserveBalance, GetTime(), nCoinbaseMaturity * 10, setCoins, nValueIn))
1460         return false;
1461
1462     if (setCoins.empty())
1463         return false;
1464
1465     CCoinsViewCache &view = *pcoinsTip;
1466     BOOST_FOREACH(PAIRTYPE(const CWalletTx*, unsigned int) pcoin, setCoins)
1467     {
1468         CCoins coins;
1469         {
1470             LOCK2(cs_main, cs_wallet);
1471             if (!view.GetCoinsReadOnly(pcoin.first->GetHash(), coins))
1472                 continue;
1473         }
1474
1475         int64 nTimeWeight = GetWeight((int64)pcoin.first->nTime, (int64)GetTime());
1476         CBigNum bnCoinDayWeight = CBigNum(pcoin.first->vout[pcoin.second].nValue) * nTimeWeight / COIN / (24 * 60 * 60);
1477
1478         // Weight is greater than zero
1479         if (nTimeWeight > 0)
1480         {
1481             nWeight += bnCoinDayWeight.getuint64();
1482         }
1483
1484         // Weight is greater than zero, but the maximum value isn't reached yet
1485         if (nTimeWeight > 0 && nTimeWeight < nStakeMaxAge)
1486         {
1487             nMinWeight += bnCoinDayWeight.getuint64();
1488         }
1489
1490         // Maximum weight was reached
1491         if (nTimeWeight == nStakeMaxAge)
1492         {
1493             nMaxWeight += bnCoinDayWeight.getuint64();
1494         }
1495     }
1496
1497     return true;
1498 }
1499
1500 bool CWallet::CreateCoinStake(const CKeyStore& keystore, unsigned int nBits, int64 nSearchInterval, CTransaction& txNew, CKey& key)
1501 {
1502     // The following combine threshold is important to security
1503     // Should not be adjusted if you don't understand the consequences
1504     int64 nCombineThreshold = GetProofOfWorkReward(GetLastBlockIndex(pindexBest, false)->nBits) / 3;
1505     CBlockIndex* pindexPrev = pindexBest;
1506     CBigNum bnTargetPerCoinDay;
1507     bnTargetPerCoinDay.SetCompact(nBits);
1508
1509     txNew.vin.clear();
1510     txNew.vout.clear();
1511
1512     // Mark coin stake transaction
1513     CScript scriptEmpty;
1514     scriptEmpty.clear();
1515     txNew.vout.push_back(CTxOut(0, scriptEmpty));
1516
1517     // Choose coins to use
1518     int64 nBalance = GetBalance();
1519     int64 nReserveBalance = 0;
1520
1521     if (mapArgs.count("-reservebalance") && !ParseMoney(mapArgs["-reservebalance"], nReserveBalance))
1522         return error("CreateCoinStake : invalid reserve balance amount");
1523
1524     if (nBalance <= nReserveBalance)
1525         return false;
1526
1527     vector<const CWalletTx*> vwtxPrev;
1528     set<pair<const CWalletTx*,unsigned int> > setCoins;
1529     int64 nValueIn = 0;
1530
1531     // Select coins with suitable depth
1532     if (!SelectCoinsSimple(nBalance - nReserveBalance, txNew.nTime, nCoinbaseMaturity * 10, setCoins, nValueIn))
1533         return false;
1534
1535     if (setCoins.empty())
1536         return false;
1537
1538     int64 nCredit = 0;
1539     CScript scriptPubKeyKernel;
1540
1541     CCoinsViewCache &view = *pcoinsTip;
1542     BOOST_FOREACH(PAIRTYPE(const CWalletTx*, unsigned int) pcoin, setCoins)
1543     {
1544         CCoins coins;
1545         {
1546             LOCK2(cs_main, cs_wallet);
1547             if (!view.GetCoinsReadOnly(pcoin.first->GetHash(), coins))
1548                 continue;
1549         }
1550
1551         static int nMaxStakeSearchInterval = 60;
1552         if (coins.nBlockTime + nStakeMinAge > txNew.nTime - nMaxStakeSearchInterval)
1553             continue; // only count coins meeting min age requirement
1554
1555         // Read block header
1556         CBlock block;
1557         unsigned int nTxPos = 0;
1558         {
1559             LOCK2(cs_main, cs_wallet);
1560             CBlockIndex *pindex = FindBlockByHeight(coins.nHeight);
1561
1562             if (!block.ReadFromDisk(pindex))
1563                 continue;
1564
1565             BOOST_FOREACH(const CTransaction &tx, block.vtx) {
1566                 if (tx.GetHash() == pcoin.first->GetHash()) {
1567                     break;
1568                 }
1569                 nTxPos += tx.GetSerializeSize(SER_DISK, CLIENT_VERSION);
1570             }
1571             nTxPos += GetSerializeSize(CBlock(), SER_DISK, CLIENT_VERSION) - (2 * GetSizeOfCompactSize(0)) + GetSizeOfCompactSize(block.vtx.size());
1572         }
1573
1574
1575         bool fFatal = false;
1576         bool fKernelFound = false;
1577         for (unsigned int n=0; n<min(nSearchInterval,(int64)nMaxStakeSearchInterval) && !fKernelFound && !fShutdown && pindexPrev == pindexBest; n++)
1578         {
1579             // Search backward in time from the given txNew timestamp
1580             // Search nSearchInterval seconds back up to nMaxStakeSearchInterval
1581             uint256 hashProofOfStake = 0, targetProofOfStake = 0;
1582             COutPoint prevoutStake = COutPoint(pcoin.first->GetHash(), pcoin.second);
1583             if (CheckStakeKernelHash(nBits, block, nTxPos, *pcoin.first, prevoutStake, txNew.nTime - n, hashProofOfStake, targetProofOfStake, fFatal, true))
1584             {
1585                 // Found a kernel
1586                 if (fDebug && GetBoolArg("-printcoinstake"))
1587                     printf("CreateCoinStake : kernel found\n");
1588                 vector<valtype> vSolutions;
1589                 txnouttype whichType;
1590                 CScript scriptPubKeyOut;
1591                 scriptPubKeyKernel = pcoin.first->vout[pcoin.second].scriptPubKey;
1592                 if (!Solver(scriptPubKeyKernel, whichType, vSolutions))
1593                 {
1594                     if (fDebug && GetBoolArg("-printcoinstake"))
1595                         printf("CreateCoinStake : failed to parse kernel\n");
1596                     break;
1597                 }
1598                 if (fDebug && GetBoolArg("-printcoinstake"))
1599                     printf("CreateCoinStake : parsed kernel type=%d\n", whichType);
1600                 if (whichType != TX_PUBKEY && whichType != TX_PUBKEYHASH)
1601                 {
1602                     if (fDebug && GetBoolArg("-printcoinstake"))
1603                         printf("CreateCoinStake : no support for kernel type=%d\n", whichType);
1604                     break;  // only support pay to public key and pay to address
1605                 }
1606                 if (whichType == TX_PUBKEYHASH) // pay to address type
1607                 {
1608                     // convert to pay to public key type
1609                     if (!keystore.GetKey(uint160(vSolutions[0]), key))
1610                     {
1611                         if (fDebug && GetBoolArg("-printcoinstake"))
1612                             printf("CreateCoinStake : failed to get key for kernel type=%d\n", whichType);
1613                         break;  // unable to find corresponding public key
1614                     }
1615                     scriptPubKeyOut << key.GetPubKey() << OP_CHECKSIG;
1616                 }
1617                 if (whichType == TX_PUBKEY)
1618                 {
1619                     valtype& vchPubKey = vSolutions[0];
1620                     if (!keystore.GetKey(Hash160(vchPubKey), key))
1621                     {
1622                         if (fDebug && GetBoolArg("-printcoinstake"))
1623                             printf("CreateCoinStake : failed to get key for kernel type=%d\n", whichType);
1624                         break;  // unable to find corresponding public key
1625                     }
1626
1627                 if (key.GetPubKey() != vchPubKey)
1628                 {
1629                     if (fDebug && GetBoolArg("-printcoinstake"))
1630                         printf("CreateCoinStake : invalid key for kernel type=%d\n", whichType);
1631                         break; // keys mismatch
1632                     }
1633
1634                     scriptPubKeyOut = scriptPubKeyKernel;
1635                 }
1636
1637                 txNew.nTime -= n;
1638                 txNew.vin.push_back(CTxIn(pcoin.first->GetHash(), pcoin.second));
1639                 nCredit += pcoin.first->vout[pcoin.second].nValue;
1640                 vwtxPrev.push_back(pcoin.first);
1641                 txNew.vout.push_back(CTxOut(0, scriptPubKeyOut));
1642
1643                 if (GetWeight(block.GetBlockTime(), (int64)txNew.nTime) < nStakeMaxAge)
1644                     txNew.vout.push_back(CTxOut(0, scriptPubKeyOut)); //split stake
1645                 if (fDebug && GetBoolArg("-printcoinstake"))
1646                     printf("CreateCoinStake : added kernel type=%d\n", whichType);
1647                 fKernelFound = true;
1648                 break;
1649             }
1650         }
1651
1652         if (fKernelFound || fShutdown)
1653             break; // if kernel is found stop searching
1654     }
1655
1656     if (nCredit == 0 || nCredit > nBalance - nReserveBalance)
1657         return false;
1658
1659     BOOST_FOREACH(PAIRTYPE(const CWalletTx*, unsigned int) pcoin, setCoins)
1660     {
1661         // Attempt to add more inputs
1662         // Only add coins of the same key/address as kernel
1663         if (txNew.vout.size() == 2 && ((pcoin.first->vout[pcoin.second].scriptPubKey == scriptPubKeyKernel || pcoin.first->vout[pcoin.second].scriptPubKey == txNew.vout[1].scriptPubKey))
1664             && pcoin.first->GetHash() != txNew.vin[0].prevout.hash)
1665         {
1666             int64 nTimeWeight = GetWeight((int64)pcoin.first->nTime, (int64)txNew.nTime);
1667
1668             // Stop adding more inputs if already too many inputs
1669             if (txNew.vin.size() >= 100)
1670                 break;
1671             // Stop adding more inputs if value is already pretty significant
1672             if (nCredit > nCombineThreshold)
1673                 break;
1674             // Stop adding inputs if reached reserve limit
1675             if (nCredit + pcoin.first->vout[pcoin.second].nValue > nBalance - nReserveBalance)
1676                 break;
1677             // Do not add additional significant input
1678             if (pcoin.first->vout[pcoin.second].nValue > nCombineThreshold)
1679                 continue;
1680             // Do not add input that is still too young
1681             if (nTimeWeight < nStakeMaxAge)
1682                 continue;
1683
1684             txNew.vin.push_back(CTxIn(pcoin.first->GetHash(), pcoin.second));
1685             nCredit += pcoin.first->vout[pcoin.second].nValue;
1686             vwtxPrev.push_back(pcoin.first);
1687         }
1688     }
1689
1690     // Calculate coin age reward
1691     {
1692         uint64 nCoinAge;
1693
1694         if (!txNew.GetCoinAge(nCoinAge))
1695             return error("CreateCoinStake : failed to calculate coin age");
1696         nCredit += GetProofOfStakeReward(nCoinAge, nBits, txNew.nTime);
1697     }
1698
1699     int64 nMinFee = 0;
1700     while (true)
1701     {
1702         // Set output amount
1703         if (txNew.vout.size() == 3)
1704         {
1705             txNew.vout[1].nValue = ((nCredit - nMinFee) / 2 / CENT) * CENT;
1706             txNew.vout[2].nValue = nCredit - nMinFee - txNew.vout[1].nValue;
1707         }
1708         else
1709             txNew.vout[1].nValue = nCredit - nMinFee;
1710
1711         // Sign
1712         int nIn = 0;
1713         BOOST_FOREACH(const CWalletTx* pcoin, vwtxPrev)
1714         {
1715             if (!SignSignature(*this, *pcoin, txNew, nIn++))
1716                 return error("CreateCoinStake : failed to sign coinstake");
1717         }
1718
1719         // Limit size
1720         unsigned int nBytes = ::GetSerializeSize(txNew, SER_NETWORK, PROTOCOL_VERSION);
1721         if (nBytes >= MAX_BLOCK_SIZE_GEN/5)
1722             return error("CreateCoinStake : exceeded coinstake size limit");
1723
1724         // Check enough fee is paid
1725         if (nMinFee < txNew.GetMinFee() - MIN_TX_FEE)
1726         {
1727             nMinFee = txNew.GetMinFee() - MIN_TX_FEE;
1728             continue; // try signing again
1729         }
1730         else
1731         {
1732             if (fDebug && GetBoolArg("-printfee"))
1733                 printf("CreateCoinStake : fee for coinstake %s\n", FormatMoney(nMinFee).c_str());
1734             break;
1735         }
1736     }
1737
1738     // Successfully generated coinstake
1739     return true;
1740 }
1741
1742
1743 // Call after CreateTransaction unless you want to abort
1744 bool CWallet::CommitTransaction(CWalletTx& wtxNew, CReserveKey& reservekey)
1745 {
1746     {
1747         LOCK2(cs_main, cs_wallet);
1748         printf("CommitTransaction:\n%s", wtxNew.ToString().c_str());
1749         {
1750             // This is only to keep the database open to defeat the auto-flush for the
1751             // duration of this scope.  This is the only place where this optimization
1752             // maybe makes sense; please don't do it anywhere else.
1753             CWalletDB* pwalletdb = fFileBacked ? new CWalletDB(strWalletFile,"r") : NULL;
1754
1755             // Take key pair from key pool so it won't be used again
1756             reservekey.KeepKey();
1757
1758             // Add tx to wallet, because if it has change it's also ours,
1759             // otherwise just for transaction history.
1760             AddToWallet(wtxNew);
1761
1762             // Mark old coins as spent
1763             set<CWalletTx*> setCoins;
1764             BOOST_FOREACH(const CTxIn& txin, wtxNew.vin)
1765             {
1766                 CWalletTx &coin = mapWallet[txin.prevout.hash];
1767                 coin.BindWallet(this);
1768                 coin.MarkSpent(txin.prevout.n);
1769                 coin.WriteToDisk();
1770                 NotifyTransactionChanged(this, coin.GetHash(), CT_UPDATED);
1771             }
1772
1773             if (fFileBacked)
1774                 delete pwalletdb;
1775         }
1776
1777         // Track how many getdata requests our transaction gets
1778         mapRequestCount[wtxNew.GetHash()] = 0;
1779
1780         // Broadcast
1781         if (!wtxNew.AcceptToMemoryPool())
1782         {
1783             // This must not fail. The transaction has already been signed and recorded.
1784             printf("CommitTransaction() : Error: Transaction not valid");
1785             return false;
1786         }
1787         wtxNew.RelayWalletTransaction();
1788     }
1789     return true;
1790 }
1791
1792
1793
1794
1795 string CWallet::SendMoney(CScript scriptPubKey, int64 nValue, CWalletTx& wtxNew, bool fAskFee)
1796 {
1797     CReserveKey reservekey(this);
1798     int64 nFeeRequired;
1799
1800     if (IsLocked())
1801     {
1802         string strError = _("Error: Wallet locked, unable to create transaction  ");
1803         printf("SendMoney() : %s", strError.c_str());
1804         return strError;
1805     }
1806     if (fWalletUnlockMintOnly)
1807     {
1808         string strError = _("Error: Wallet unlocked for block minting only, unable to create transaction.");
1809         printf("SendMoney() : %s", strError.c_str());
1810         return strError;
1811     }
1812     if (!CreateTransaction(scriptPubKey, nValue, wtxNew, reservekey, nFeeRequired))
1813     {
1814         string strError;
1815         if (nValue + nFeeRequired > GetBalance())
1816             strError = strprintf(_("Error: This transaction requires a transaction fee of at least %s because of its amount, complexity, or use of recently received funds  "), FormatMoney(nFeeRequired).c_str());
1817         else
1818             strError = _("Error: Transaction creation failed  ");
1819         printf("SendMoney() : %s", strError.c_str());
1820         return strError;
1821     }
1822
1823     if (fAskFee && !uiInterface.ThreadSafeAskFee(nFeeRequired, _("Sending...")))
1824         return "ABORTED";
1825
1826     if (!CommitTransaction(wtxNew, reservekey))
1827         return _("Error: The transaction was rejected.  This might happen if some of the coins in your wallet were already spent, such as if you used a copy of wallet.dat and coins were spent in the copy but not marked as spent here.");
1828
1829     return "";
1830 }
1831
1832
1833
1834 string CWallet::SendMoneyToDestination(const CTxDestination& address, int64 nValue, CWalletTx& wtxNew, bool fAskFee)
1835 {
1836     // Check amount
1837     if (nValue <= 0)
1838         return _("Invalid amount");
1839     if (nValue + nTransactionFee > GetBalance())
1840         return _("Insufficient funds");
1841
1842     // Parse Bitcoin address
1843     CScript scriptPubKey;
1844     scriptPubKey.SetDestination(address);
1845
1846     return SendMoney(scriptPubKey, nValue, wtxNew, fAskFee);
1847 }
1848
1849
1850
1851
1852 DBErrors CWallet::LoadWallet(bool& fFirstRunRet)
1853 {
1854     if (!fFileBacked)
1855         return DB_LOAD_OK;
1856     fFirstRunRet = false;
1857     DBErrors nLoadWalletRet = CWalletDB(strWalletFile,"cr+").LoadWallet(this);
1858     if (nLoadWalletRet == DB_NEED_REWRITE)
1859     {
1860         if (CDB::Rewrite(strWalletFile, "\x04pool"))
1861         {
1862             setKeyPool.clear();
1863             // Note: can't top-up keypool here, because wallet is locked.
1864             // User will be prompted to unlock wallet the next operation
1865             // the requires a new key.
1866         }
1867     }
1868
1869     if (nLoadWalletRet != DB_LOAD_OK)
1870         return nLoadWalletRet;
1871     fFirstRunRet = !vchDefaultKey.IsValid();
1872
1873     NewThread(ThreadFlushWalletDB, &strWalletFile);
1874     return DB_LOAD_OK;
1875 }
1876
1877
1878 bool CWallet::SetAddressBookName(const CTxDestination& address, const string& strName)
1879 {
1880     std::map<CTxDestination, std::string>::iterator mi = mapAddressBook.find(address);
1881     mapAddressBook[address] = strName;
1882     NotifyAddressBookChanged(this, address, strName, ::IsMine(*this, address), (mi == mapAddressBook.end()) ? CT_NEW : CT_UPDATED);
1883     if (!fFileBacked)
1884         return false;
1885     return CWalletDB(strWalletFile).WriteName(CBitcoinAddress(address).ToString(), strName);
1886 }
1887
1888 bool CWallet::DelAddressBookName(const CTxDestination& address)
1889 {
1890     mapAddressBook.erase(address);
1891     NotifyAddressBookChanged(this, address, "", ::IsMine(*this, address), CT_DELETED);
1892     if (!fFileBacked)
1893         return false;
1894     return CWalletDB(strWalletFile).EraseName(CBitcoinAddress(address).ToString());
1895 }
1896
1897
1898 void CWallet::PrintWallet(const CBlock& block)
1899 {
1900     {
1901         LOCK(cs_wallet);
1902         if (block.IsProofOfWork() && mapWallet.count(block.vtx[0].GetHash()))
1903         {
1904             CWalletTx& wtx = mapWallet[block.vtx[0].GetHash()];
1905             printf("    mine:  %d  %d  %"PRI64d"", wtx.GetDepthInMainChain(), wtx.GetBlocksToMaturity(), wtx.GetCredit());
1906         }
1907         if (block.IsProofOfStake() && mapWallet.count(block.vtx[1].GetHash()))
1908         {
1909             CWalletTx& wtx = mapWallet[block.vtx[1].GetHash()];
1910             printf("    stake: %d  %d  %"PRI64d"", wtx.GetDepthInMainChain(), wtx.GetBlocksToMaturity(), wtx.GetCredit());
1911          }
1912
1913     }
1914     printf("\n");
1915 }
1916
1917 bool CWallet::GetTransaction(const uint256 &hashTx, CWalletTx& wtx)
1918 {
1919     {
1920         LOCK(cs_wallet);
1921         map<uint256, CWalletTx>::iterator mi = mapWallet.find(hashTx);
1922         if (mi != mapWallet.end())
1923         {
1924             wtx = (*mi).second;
1925             return true;
1926         }
1927     }
1928     return false;
1929 }
1930
1931 bool CWallet::SetDefaultKey(const CPubKey &vchPubKey)
1932 {
1933     if (fFileBacked)
1934     {
1935         if (!CWalletDB(strWalletFile).WriteDefaultKey(vchPubKey))
1936             return false;
1937     }
1938     vchDefaultKey = vchPubKey;
1939     return true;
1940 }
1941
1942 bool GetWalletFile(CWallet* pwallet, string &strWalletFileOut)
1943 {
1944     if (!pwallet->fFileBacked)
1945         return false;
1946     strWalletFileOut = pwallet->strWalletFile;
1947     return true;
1948 }
1949
1950 //
1951 // Mark old keypool keys as used,
1952 // and generate all new keys
1953 //
1954 bool CWallet::NewKeyPool()
1955 {
1956     {
1957         LOCK(cs_wallet);
1958         CWalletDB walletdb(strWalletFile);
1959         BOOST_FOREACH(int64 nIndex, setKeyPool)
1960             walletdb.ErasePool(nIndex);
1961         setKeyPool.clear();
1962
1963         if (IsLocked())
1964             return false;
1965
1966         int64 nKeys = max(GetArg("-keypool", 100), (int64)0);
1967         for (int i = 0; i < nKeys; i++)
1968         {
1969             int64 nIndex = i+1;
1970             walletdb.WritePool(nIndex, CKeyPool(GenerateNewKey()));
1971             setKeyPool.insert(nIndex);
1972         }
1973         printf("CWallet::NewKeyPool wrote %"PRI64d" new keys\n", nKeys);
1974     }
1975     return true;
1976 }
1977
1978 bool CWallet::TopUpKeyPool(unsigned int nSize)
1979 {
1980     {
1981         LOCK(cs_wallet);
1982
1983         if (IsLocked())
1984             return false;
1985
1986         CWalletDB walletdb(strWalletFile);
1987
1988         // Top up key pool
1989         unsigned int nTargetSize;
1990         if (nSize > 0)
1991             nTargetSize = nSize;
1992         else
1993             nTargetSize = max(GetArg("-keypool", 100), 0LL);
1994
1995         while (setKeyPool.size() < (nTargetSize + 1))
1996         {
1997             int64 nEnd = 1;
1998             if (!setKeyPool.empty())
1999                 nEnd = *(--setKeyPool.end()) + 1;
2000             if (!walletdb.WritePool(nEnd, CKeyPool(GenerateNewKey())))
2001                 throw runtime_error("TopUpKeyPool() : writing generated key failed");
2002             setKeyPool.insert(nEnd);
2003             printf("keypool added key %"PRI64d", size=%"PRIszu"\n", nEnd, setKeyPool.size());
2004         }
2005     }
2006     return true;
2007 }
2008
2009 void CWallet::ReserveKeyFromKeyPool(int64& nIndex, CKeyPool& keypool)
2010 {
2011     nIndex = -1;
2012     keypool.vchPubKey = CPubKey();
2013     {
2014         LOCK(cs_wallet);
2015
2016         if (!IsLocked())
2017             TopUpKeyPool();
2018
2019         // Get the oldest key
2020         if(setKeyPool.empty())
2021             return;
2022
2023         CWalletDB walletdb(strWalletFile);
2024
2025         nIndex = *(setKeyPool.begin());
2026         setKeyPool.erase(setKeyPool.begin());
2027         if (!walletdb.ReadPool(nIndex, keypool))
2028             throw runtime_error("ReserveKeyFromKeyPool() : read failed");
2029         if (!HaveKey(keypool.vchPubKey.GetID()))
2030             throw runtime_error("ReserveKeyFromKeyPool() : unknown key in key pool");
2031         assert(keypool.vchPubKey.IsValid());
2032         if (fDebug && GetBoolArg("-printkeypool"))
2033             printf("keypool reserve %"PRI64d"\n", nIndex);
2034     }
2035 }
2036
2037 int64 CWallet::AddReserveKey(const CKeyPool& keypool)
2038 {
2039     {
2040         LOCK2(cs_main, cs_wallet);
2041         CWalletDB walletdb(strWalletFile);
2042
2043         int64 nIndex = 1 + *(--setKeyPool.end());
2044         if (!walletdb.WritePool(nIndex, keypool))
2045             throw runtime_error("AddReserveKey() : writing added key failed");
2046         setKeyPool.insert(nIndex);
2047         return nIndex;
2048     }
2049     return -1;
2050 }
2051
2052 void CWallet::KeepKey(int64 nIndex)
2053 {
2054     // Remove from key pool
2055     if (fFileBacked)
2056     {
2057         CWalletDB walletdb(strWalletFile);
2058         walletdb.ErasePool(nIndex);
2059     }
2060     if(fDebug)
2061         printf("keypool keep %"PRI64d"\n", nIndex);
2062 }
2063
2064 void CWallet::ReturnKey(int64 nIndex)
2065 {
2066     // Return to key pool
2067     {
2068         LOCK(cs_wallet);
2069         setKeyPool.insert(nIndex);
2070     }
2071     if(fDebug)
2072         printf("keypool return %"PRI64d"\n", nIndex);
2073 }
2074
2075 bool CWallet::GetKeyFromPool(CPubKey& result, bool fAllowReuse)
2076 {
2077     int64 nIndex = 0;
2078     CKeyPool keypool;
2079     {
2080         LOCK(cs_wallet);
2081         ReserveKeyFromKeyPool(nIndex, keypool);
2082         if (nIndex == -1)
2083         {
2084             if (fAllowReuse && vchDefaultKey.IsValid())
2085             {
2086                 result = vchDefaultKey;
2087                 return true;
2088             }
2089             if (IsLocked()) return false;
2090             result = GenerateNewKey();
2091             return true;
2092         }
2093         KeepKey(nIndex);
2094         result = keypool.vchPubKey;
2095     }
2096     return true;
2097 }
2098
2099 int64 CWallet::GetOldestKeyPoolTime()
2100 {
2101     int64 nIndex = 0;
2102     CKeyPool keypool;
2103     ReserveKeyFromKeyPool(nIndex, keypool);
2104     if (nIndex == -1)
2105         return GetTime();
2106     ReturnKey(nIndex);
2107     return keypool.nTime;
2108 }
2109
2110 std::map<CTxDestination, int64> CWallet::GetAddressBalances()
2111 {
2112     map<CTxDestination, int64> balances;
2113
2114     {
2115         LOCK(cs_wallet);
2116         BOOST_FOREACH(PAIRTYPE(uint256, CWalletTx) walletEntry, mapWallet)
2117         {
2118             CWalletTx *pcoin = &walletEntry.second;
2119
2120             if (!pcoin->IsFinal() || !pcoin->IsConfirmed())
2121                 continue;
2122
2123             if ((pcoin->IsCoinBase() || pcoin->IsCoinStake()) && pcoin->GetBlocksToMaturity() > 0)
2124                 continue;
2125
2126             int nDepth = pcoin->GetDepthInMainChain();
2127             if (nDepth < (pcoin->IsFromMe() ? 0 : 1))
2128                 continue;
2129
2130             for (unsigned int i = 0; i < pcoin->vout.size(); i++)
2131             {
2132                 CTxDestination addr;
2133                 if (!IsMine(pcoin->vout[i]))
2134                     continue;
2135                 if(!ExtractDestination(pcoin->vout[i].scriptPubKey, addr))
2136                     continue;
2137
2138                 int64 n = pcoin->IsSpent(i) ? 0 : pcoin->vout[i].nValue;
2139
2140                 if (!balances.count(addr))
2141                     balances[addr] = 0;
2142                 balances[addr] += n;
2143             }
2144         }
2145     }
2146
2147     return balances;
2148 }
2149
2150 set< set<CTxDestination> > CWallet::GetAddressGroupings()
2151 {
2152     set< set<CTxDestination> > groupings;
2153     set<CTxDestination> grouping;
2154
2155     BOOST_FOREACH(PAIRTYPE(uint256, CWalletTx) walletEntry, mapWallet)
2156     {
2157         CWalletTx *pcoin = &walletEntry.second;
2158
2159         if (pcoin->vin.size() > 0 && IsMine(pcoin->vin[0]))
2160         {
2161             // group all input addresses with each other
2162             BOOST_FOREACH(CTxIn txin, pcoin->vin)
2163             {
2164                 CTxDestination address;
2165                 if(!ExtractDestination(mapWallet[txin.prevout.hash].vout[txin.prevout.n].scriptPubKey, address))
2166                     continue;
2167                 grouping.insert(address);
2168             }
2169
2170             // group change with input addresses
2171             BOOST_FOREACH(CTxOut txout, pcoin->vout)
2172                 if (IsChange(txout))
2173                 {
2174                     CWalletTx tx = mapWallet[pcoin->vin[0].prevout.hash];
2175                     CTxDestination txoutAddr;
2176                     if(!ExtractDestination(txout.scriptPubKey, txoutAddr))
2177                         continue;
2178                     grouping.insert(txoutAddr);
2179                 }
2180             groupings.insert(grouping);
2181             grouping.clear();
2182         }
2183
2184         // group lone addrs by themselves
2185         for (unsigned int i = 0; i < pcoin->vout.size(); i++)
2186             if (IsMine(pcoin->vout[i]))
2187             {
2188                 CTxDestination address;
2189                 if(!ExtractDestination(pcoin->vout[i].scriptPubKey, address))
2190                     continue;
2191                 grouping.insert(address);
2192                 groupings.insert(grouping);
2193                 grouping.clear();
2194             }
2195     }
2196
2197     set< set<CTxDestination>* > uniqueGroupings; // a set of pointers to groups of addresses
2198     map< CTxDestination, set<CTxDestination>* > setmap;  // map addresses to the unique group containing it
2199     BOOST_FOREACH(set<CTxDestination> grouping, groupings)
2200     {
2201         // make a set of all the groups hit by this new group
2202         set< set<CTxDestination>* > hits;
2203         map< CTxDestination, set<CTxDestination>* >::iterator it;
2204         BOOST_FOREACH(CTxDestination address, grouping)
2205             if ((it = setmap.find(address)) != setmap.end())
2206                 hits.insert((*it).second);
2207
2208         // merge all hit groups into a new single group and delete old groups
2209         set<CTxDestination>* merged = new set<CTxDestination>(grouping);
2210         BOOST_FOREACH(set<CTxDestination>* hit, hits)
2211         {
2212             merged->insert(hit->begin(), hit->end());
2213             uniqueGroupings.erase(hit);
2214             delete hit;
2215         }
2216         uniqueGroupings.insert(merged);
2217
2218         // update setmap
2219         BOOST_FOREACH(CTxDestination element, *merged)
2220             setmap[element] = merged;
2221     }
2222
2223     set< set<CTxDestination> > ret;
2224     BOOST_FOREACH(set<CTxDestination>* uniqueGrouping, uniqueGroupings)
2225     {
2226         ret.insert(*uniqueGrouping);
2227         delete uniqueGrouping;
2228     }
2229
2230     return ret;
2231 }
2232
2233 // 1. check 'spent' consistency between wallet and coins database
2234 // 2. fix wallet spent state according to coins database
2235 // 3. remove orphaned coinstakes and coinbases from wallet
2236 void CWallet::FixSpentCoins(int& nMismatchFound, int64& nBalanceInQuestion, bool fCheckOnly)
2237 {
2238     nMismatchFound = 0;
2239     nBalanceInQuestion = 0;
2240
2241     LOCK(cs_wallet);
2242     vector<CWalletTx*> vCoins;
2243     vCoins.reserve(mapWallet.size());
2244     for (map<uint256, CWalletTx>::iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
2245         vCoins.push_back(&(*it).second);
2246
2247     CCoinsViewCache &view = *pcoinsTip;
2248     BOOST_FOREACH(CWalletTx* pcoin, vCoins)
2249     {
2250         uint256 hash = pcoin->GetHash();
2251         if(!view.HaveCoins(hash))
2252             continue;
2253
2254         // Find the corresponding transaction index
2255         CCoins &coins = view.GetCoins(hash);
2256
2257         for (unsigned int n=0; n < pcoin->vout.size(); n++)
2258         {
2259             bool fUpdated = false;
2260             if (IsMine(pcoin->vout[n]))
2261             {
2262                 if (pcoin->IsSpent(n) && coins.IsAvailable(n))
2263                 {
2264                     printf("FixSpentCoins found lost coin %snvc %s[%d], %s\n",
2265                         FormatMoney(pcoin->vout[n].nValue).c_str(), hash.ToString().c_str(), n, fCheckOnly? "repair not attempted" : "repairing");
2266                     nMismatchFound++;
2267                     nBalanceInQuestion += pcoin->vout[n].nValue;
2268                     if (!fCheckOnly)
2269                     {
2270                         fUpdated = true;
2271                         pcoin->MarkUnspent(n);
2272                         pcoin->WriteToDisk();
2273                     }
2274                 }
2275                 else if (!pcoin->IsSpent(n) && !coins.IsAvailable(n))
2276                 {
2277                     printf("FixSpentCoins found spent coin %snvc %s[%d], %s\n",
2278                         FormatMoney(pcoin->vout[n].nValue).c_str(), hash.ToString().c_str(), n, fCheckOnly? "repair not attempted" : "repairing");
2279                     nMismatchFound++;
2280                     nBalanceInQuestion += pcoin->vout[n].nValue;
2281                     if (!fCheckOnly)
2282                     {
2283                         fUpdated = true;
2284                         pcoin->MarkSpent(n);
2285                         pcoin->WriteToDisk();
2286                     }
2287                 }
2288
2289                 if (fUpdated)
2290                     NotifyTransactionChanged(this, hash, CT_UPDATED);
2291             }
2292         }
2293
2294         if((pcoin->IsCoinBase() || pcoin->IsCoinStake()) && pcoin->GetDepthInMainChain() == 0)
2295         {
2296             if (!fCheckOnly)
2297             {
2298                 EraseFromWallet(hash);
2299                 NotifyTransactionChanged(this, hash, CT_DELETED);
2300             }
2301
2302             printf("FixSpentCoins %s orphaned generation tx %s\n", fCheckOnly ? "found" : "removed", hash.ToString().c_str());
2303         }
2304     }
2305 }
2306
2307 // ppcoin: disable transaction (only for coinstake)
2308 void CWallet::DisableTransaction(const CTransaction &tx)
2309 {
2310     if (!tx.IsCoinStake() || !IsFromMe(tx))
2311         return; // only disconnecting coinstake requires marking input unspent
2312
2313     LOCK(cs_wallet);
2314     BOOST_FOREACH(const CTxIn& txin, tx.vin)
2315     {
2316         map<uint256, CWalletTx>::iterator mi = mapWallet.find(txin.prevout.hash);
2317         if (mi != mapWallet.end())
2318         {
2319             CWalletTx& prev = (*mi).second;
2320             if (txin.prevout.n < prev.vout.size() && IsMine(prev.vout[txin.prevout.n]))
2321             {
2322                 prev.MarkUnspent(txin.prevout.n);
2323                 prev.WriteToDisk();
2324             }
2325         }
2326     }
2327 }
2328
2329 CPubKey CReserveKey::GetReservedKey()
2330 {
2331     if (nIndex == -1)
2332     {
2333         CKeyPool keypool;
2334         pwallet->ReserveKeyFromKeyPool(nIndex, keypool);
2335         if (nIndex != -1)
2336             vchPubKey = keypool.vchPubKey;
2337         else
2338         {
2339             printf("CReserveKey::GetReservedKey(): Warning: Using default key instead of a new key, top up your keypool!");
2340             vchPubKey = pwallet->vchDefaultKey;
2341         }
2342     }
2343     assert(vchPubKey.IsValid());
2344     return vchPubKey;
2345 }
2346
2347 void CReserveKey::KeepKey()
2348 {
2349     if (nIndex != -1)
2350         pwallet->KeepKey(nIndex);
2351     nIndex = -1;
2352     vchPubKey = CPubKey();
2353 }
2354
2355 void CReserveKey::ReturnKey()
2356 {
2357     if (nIndex != -1)
2358         pwallet->ReturnKey(nIndex);
2359     nIndex = -1;
2360     vchPubKey = CPubKey();
2361 }
2362
2363 void CWallet::GetAllReserveKeys(set<CKeyID>& setAddress) const
2364 {
2365     setAddress.clear();
2366
2367     CWalletDB walletdb(strWalletFile);
2368
2369     LOCK2(cs_main, cs_wallet);
2370     BOOST_FOREACH(const int64& id, setKeyPool)
2371     {
2372         CKeyPool keypool;
2373         if (!walletdb.ReadPool(id, keypool))
2374             throw runtime_error("GetAllReserveKeyHashes() : read failed");
2375         assert(keypool.vchPubKey.IsValid());
2376         CKeyID keyID = keypool.vchPubKey.GetID();
2377         if (!HaveKey(keyID))
2378             throw runtime_error("GetAllReserveKeyHashes() : unknown key in key pool");
2379         setAddress.insert(keyID);
2380     }
2381 }
2382
2383 void CWallet::UpdatedTransaction(const uint256 &hashTx)
2384 {
2385     {
2386         LOCK(cs_wallet);
2387         // Only notify UI if this transaction is in this wallet
2388         map<uint256, CWalletTx>::const_iterator mi = mapWallet.find(hashTx);
2389         if (mi != mapWallet.end())
2390             NotifyTransactionChanged(this, hashTx, CT_UPDATED);
2391     }
2392 }
2393
2394 void CWallet::GetKeyBirthTimes(std::map<CKeyID, int64> &mapKeyBirth) const {
2395     mapKeyBirth.clear();
2396
2397     // get birth times for keys with metadata
2398     for (std::map<CKeyID, CKeyMetadata>::const_iterator it = mapKeyMetadata.begin(); it != mapKeyMetadata.end(); it++)
2399         if (it->second.nCreateTime)
2400             mapKeyBirth[it->first] = it->second.nCreateTime;
2401
2402     // map in which we'll infer heights of other keys
2403     CBlockIndex *pindexMax = FindBlockByHeight(std::max(0, nBestHeight - 144)); // the tip can be reorganised; use a 144-block safety margin
2404     std::map<CKeyID, CBlockIndex*> mapKeyFirstBlock;
2405     std::set<CKeyID> setKeys;
2406     GetKeys(setKeys);
2407     BOOST_FOREACH(const CKeyID &keyid, setKeys) {
2408         if (mapKeyBirth.count(keyid) == 0)
2409             mapKeyFirstBlock[keyid] = pindexMax;
2410     }
2411     setKeys.clear();
2412
2413     // if there are no such keys, we're done
2414     if (mapKeyFirstBlock.empty())
2415         return;
2416
2417     // find first block that affects those keys, if there are any left
2418     std::vector<CKeyID> vAffected;
2419     for (std::map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); it++) {
2420         // iterate over all wallet transactions...
2421         const CWalletTx &wtx = (*it).second;
2422         std::map<uint256, CBlockIndex*>::const_iterator blit = mapBlockIndex.find(wtx.hashBlock);
2423         if (blit != mapBlockIndex.end() && blit->second->IsInMainChain()) {
2424             // ... which are already in a block
2425             int nHeight = blit->second->nHeight;
2426             BOOST_FOREACH(const CTxOut &txout, wtx.vout) {
2427                 // iterate over all their outputs
2428                 ::ExtractAffectedKeys(*this, txout.scriptPubKey, vAffected);
2429                 BOOST_FOREACH(const CKeyID &keyid, vAffected) {
2430                     // ... and all their affected keys
2431                     std::map<CKeyID, CBlockIndex*>::iterator rit = mapKeyFirstBlock.find(keyid);
2432                     if (rit != mapKeyFirstBlock.end() && nHeight < rit->second->nHeight)
2433                         rit->second = blit->second;
2434                 }
2435                 vAffected.clear();
2436             }
2437         }
2438     }
2439
2440     // Extract block timestamps for those keys
2441     for (std::map<CKeyID, CBlockIndex*>::const_iterator it = mapKeyFirstBlock.begin(); it != mapKeyFirstBlock.end(); it++)
2442         mapKeyBirth[it->first] = it->second->nTime - 7200; // block times can be 2h off
2443 }