src/wallet.cpp

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2011 The Bitcoin developers
   3 // Distributed under the MIT/X11 software license, see the accompanying
   4 // file license.txt or http://www.opensource.org/licenses/mit-license.php.
   5
   6 #include "headers.h"
   7 #include "db.h"
   8 #include "cryptopp/sha.h"
   9 #include "crypter.h"
  10
  11 using namespace std;
  12
  13
  14 //////////////////////////////////////////////////////////////////////////////
  15 //
  16 // mapWallet
  17 //
  18
  19 bool CWallet::AddKey(const CKey& key)
  20 {
  21     if (!CCryptoKeyStore::AddKey(key))
  22         return false;
  23     if (!fFileBacked)
  24         return true;
  25     if (!IsCrypted())
  26         return CWalletDB(strWalletFile).WriteKey(key.GetPubKey(), key.GetPrivKey());
  27     return true;
  28 }
  29
  30 bool CWallet::AddCryptedKey(const vector<unsigned char> &vchPubKey, const vector<unsigned char> &vchCryptedSecret)
  31 {
  32     if (!CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret))
  33         return false;
  34     if (!fFileBacked)
  35         return true;
  36     CRITICAL_BLOCK(cs_wallet)
  37     {
  38         if (pwalletdbEncryption)
  39             return pwalletdbEncryption->WriteCryptedKey(vchPubKey, vchCryptedSecret);
  40         else
  41             return CWalletDB(strWalletFile).WriteCryptedKey(vchPubKey, vchCryptedSecret);
  42     }
  43     return false;
  44 }
  45
  46 bool CWallet::Unlock(const string& strWalletPassphrase)
  47 {
  48     if (!IsLocked())
  49         return false;
  50
  51     CCrypter crypter;
  52     CKeyingMaterial vMasterKey;
  53
  54     CRITICAL_BLOCK(cs_wallet)
  55         BOOST_FOREACH(const MasterKeyMap::value_type& pMasterKey, mapMasterKeys)
  56         {
  57             if(!crypter.SetKeyFromPassphrase(strWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
  58                 return false;
  59             if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, vMasterKey))
  60                 return false;
  61             if (CCryptoKeyStore::Unlock(vMasterKey))
  62                 return true;
  63         }
  64     return false;
  65 }
  66
  67 bool CWallet::ChangeWalletPassphrase(const string& strOldWalletPassphrase, const string& strNewWalletPassphrase)
  68 {
  69     bool fWasLocked = IsLocked();
  70
  71     CRITICAL_BLOCK(cs_wallet)
  72     {
  73         Lock();
  74
  75         CCrypter crypter;
  76         CKeyingMaterial vMasterKey;
  77         BOOST_FOREACH(MasterKeyMap::value_type& pMasterKey, mapMasterKeys)
  78         {
  79             if(!crypter.SetKeyFromPassphrase(strOldWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
  80                 return false;
  81             if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, vMasterKey))
  82                 return false;
  83             if (CCryptoKeyStore::Unlock(vMasterKey))
  84             {
  85                 int64 nStartTime = GetTimeMillis();
  86                 crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);
  87                 pMasterKey.second.nDeriveIterations = pMasterKey.second.nDeriveIterations * (100 / ((double)(GetTimeMillis() - nStartTime)));
  88
  89                 nStartTime = GetTimeMillis();
  90                 crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);
  91                 pMasterKey.second.nDeriveIterations = (pMasterKey.second.nDeriveIterations + pMasterKey.second.nDeriveIterations * 100 / ((double)(GetTimeMillis() - nStartTime))) / 2;
  92
  93                 if (pMasterKey.second.nDeriveIterations < 25000)
  94                     pMasterKey.second.nDeriveIterations = 25000;
  95
  96                 printf("Wallet passphrase changed to an nDeriveIterations of %i\n", pMasterKey.second.nDeriveIterations);
  97
  98                 if (!crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
  99                     return false;
 100                 if (!crypter.Encrypt(vMasterKey, pMasterKey.second.vchCryptedKey))
 101                     return false;
 102                 CWalletDB(strWalletFile).WriteMasterKey(pMasterKey.first, pMasterKey.second);
 103                 if (fWasLocked)
 104                     Lock();
 105                 return true;
 106             }
 107         }
 108     }
 109
 110     return false;
 111 }
 112
 113
 114 // This class implements an addrIncoming entry that causes pre-0.4
 115 // clients to crash on startup if reading a private-key-encrypted wallet.
 116 class CCorruptAddress
 117 {
 118 public:
 119     IMPLEMENT_SERIALIZE
 120     (
 121         if (nType & SER_DISK)
 122             READWRITE(nVersion);
 123     )
 124 };
 125
 126 bool CWallet::EncryptWallet(const string& strWalletPassphrase)
 127 {
 128     if (IsCrypted())
 129         return false;
 130
 131     CKeyingMaterial vMasterKey;
 132     RandAddSeedPerfmon();
 133
 134     vMasterKey.resize(WALLET_CRYPTO_KEY_SIZE);
 135     RAND_bytes(&vMasterKey[0], WALLET_CRYPTO_KEY_SIZE);
 136
 137     CMasterKey kMasterKey;
 138
 139     RandAddSeedPerfmon();
 140     kMasterKey.vchSalt.resize(WALLET_CRYPTO_SALT_SIZE);
 141     RAND_bytes(&kMasterKey.vchSalt[0], WALLET_CRYPTO_SALT_SIZE);
 142
 143     CCrypter crypter;
 144     int64 nStartTime = GetTimeMillis();
 145     crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, 25000, kMasterKey.nDerivationMethod);
 146     kMasterKey.nDeriveIterations = 2500000 / ((double)(GetTimeMillis() - nStartTime));
 147
 148     nStartTime = GetTimeMillis();
 149     crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, kMasterKey.nDeriveIterations, kMasterKey.nDerivationMethod);
 150     kMasterKey.nDeriveIterations = (kMasterKey.nDeriveIterations + kMasterKey.nDeriveIterations * 100 / ((double)(GetTimeMillis() - nStartTime))) / 2;
 151
 152     if (kMasterKey.nDeriveIterations < 25000)
 153         kMasterKey.nDeriveIterations = 25000;
 154
 155     printf("Encrypting Wallet with an nDeriveIterations of %i\n", kMasterKey.nDeriveIterations);
 156
 157     if (!crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, kMasterKey.nDeriveIterations, kMasterKey.nDerivationMethod))
 158         return false;
 159     if (!crypter.Encrypt(vMasterKey, kMasterKey.vchCryptedKey))
 160         return false;
 161
 162     CRITICAL_BLOCK(cs_wallet)
 163     {
 164         mapMasterKeys[++nMasterKeyMaxID] = kMasterKey;
 165         if (fFileBacked)
 166         {
 167             pwalletdbEncryption = new CWalletDB(strWalletFile);
 168             pwalletdbEncryption->TxnBegin();
 169             pwalletdbEncryption->WriteMasterKey(nMasterKeyMaxID, kMasterKey);
 170         }
 171
 172         if (!EncryptKeys(vMasterKey))
 173         {
 174             if (fFileBacked)
 175                 pwalletdbEncryption->TxnAbort();
 176             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.
 177         }
 178
 179         if (fFileBacked)
 180         {
 181             CCorruptAddress corruptAddress;
 182             pwalletdbEncryption->WriteSetting("addrIncoming", corruptAddress);
 183             if (!pwalletdbEncryption->TxnCommit())
 184                 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.
 185
 186             delete pwalletdbEncryption;
 187             pwalletdbEncryption = NULL;
 188         }
 189
 190         Lock();
 191         Unlock(strWalletPassphrase);
 192         NewKeyPool();
 193         Lock();
 194
 195         // Need to completely rewrite the wallet file; if we don't, bdb might keep
 196         // bits of the unencrypted private key in slack space in the database file.
 197         CDB::Rewrite(strWalletFile);
 198     }
 199
 200     return true;
 201 }
 202
 203 void CWallet::WalletUpdateSpent(const CTransaction &tx)
 204 {
 205     // Anytime a signature is successfully verified, it's proof the outpoint is spent.
 206     // Update the wallet spent flag if it doesn't know due to wallet.dat being
 207     // restored from backup or the user making copies of wallet.dat.
 208     CRITICAL_BLOCK(cs_wallet)
 209     {
 210         BOOST_FOREACH(const CTxIn& txin, tx.vin)
 211         {
 212             map<uint256, CWalletTx>::iterator mi = mapWallet.find(txin.prevout.hash);
 213             if (mi != mapWallet.end())
 214             {
 215                 CWalletTx& wtx = (*mi).second;
 216                 if (!wtx.IsSpent(txin.prevout.n) && IsMine(wtx.vout[txin.prevout.n]))
 217                 {
 218                     printf("WalletUpdateSpent found spent coin %sbc %s\n", FormatMoney(wtx.GetCredit()).c_str(), wtx.GetHash().ToString().c_str());
 219                     wtx.MarkSpent(txin.prevout.n);
 220                     wtx.WriteToDisk();
 221                     vWalletUpdated.push_back(txin.prevout.hash);
 222                 }
 223             }
 224         }
 225     }
 226 }
 227
 228 bool CWallet::AddToWallet(const CWalletTx& wtxIn)
 229 {
 230     uint256 hash = wtxIn.GetHash();
 231     CRITICAL_BLOCK(cs_wallet)
 232     {
 233         // Inserts only if not already there, returns tx inserted or tx found
 234         pair<map<uint256, CWalletTx>::iterator, bool> ret = mapWallet.insert(make_pair(hash, wtxIn));
 235         CWalletTx& wtx = (*ret.first).second;
 236         wtx.pwallet = this;
 237         bool fInsertedNew = ret.second;
 238         if (fInsertedNew)
 239             wtx.nTimeReceived = GetAdjustedTime();
 240
 241         bool fUpdated = false;
 242         if (!fInsertedNew)
 243         {
 244             // Merge
 245             if (wtxIn.hashBlock != 0 && wtxIn.hashBlock != wtx.hashBlock)
 246             {
 247                 wtx.hashBlock = wtxIn.hashBlock;
 248                 fUpdated = true;
 249             }
 250             if (wtxIn.nIndex != -1 && (wtxIn.vMerkleBranch != wtx.vMerkleBranch || wtxIn.nIndex != wtx.nIndex))
 251             {
 252                 wtx.vMerkleBranch = wtxIn.vMerkleBranch;
 253                 wtx.nIndex = wtxIn.nIndex;
 254                 fUpdated = true;
 255             }
 256             if (wtxIn.fFromMe && wtxIn.fFromMe != wtx.fFromMe)
 257             {
 258                 wtx.fFromMe = wtxIn.fFromMe;
 259                 fUpdated = true;
 260             }
 261             fUpdated |= wtx.UpdateSpent(wtxIn.vfSpent);
 262         }
 263
 264         //// debug print
 265         printf("AddToWallet %s  %s%s\n", wtxIn.GetHash().ToString().substr(0,10).c_str(), (fInsertedNew ? "new" : ""), (fUpdated ? "update" : ""));
 266
 267         // Write to disk
 268         if (fInsertedNew || fUpdated)
 269             if (!wtx.WriteToDisk())
 270                 return false;
 271
 272         // If default receiving address gets used, replace it with a new one
 273         CScript scriptDefaultKey;
 274         scriptDefaultKey.SetBitcoinAddress(vchDefaultKey);
 275         BOOST_FOREACH(const CTxOut& txout, wtx.vout)
 276         {
 277             if (txout.scriptPubKey == scriptDefaultKey)
 278             {
 279                 std::vector<unsigned char> newDefaultKey;
 280                 if (GetKeyFromPool(newDefaultKey, false))
 281                 {
 282                     SetDefaultKey(newDefaultKey);
 283                     SetAddressBookName(CBitcoinAddress(vchDefaultKey), "");
 284                 }
 285             }
 286         }
 287
 288         // Notify UI
 289         vWalletUpdated.push_back(hash);
 290
 291         // since AddToWallet is called directly for self-originating transactions, check for consumption of own coins
 292         WalletUpdateSpent(wtx);
 293     }
 294
 295     // Refresh UI
 296     MainFrameRepaint();
 297     return true;
 298 }
 299
 300 bool CWallet::AddToWalletIfInvolvingMe(const CTransaction& tx, const CBlock* pblock, bool fUpdate)
 301 {
 302     uint256 hash = tx.GetHash();
 303     CRITICAL_BLOCK(cs_wallet)
 304     {
 305         bool fExisted = mapWallet.count(hash);
 306         if (fExisted && !fUpdate) return false;
 307         if (fExisted || IsMine(tx) || IsFromMe(tx))
 308         {
 309             CWalletTx wtx(this,tx);
 310             // Get merkle branch if transaction was found in a block
 311             if (pblock)
 312                 wtx.SetMerkleBranch(pblock);
 313             return AddToWallet(wtx);
 314         }
 315         else
 316             WalletUpdateSpent(tx);
 317     }
 318     return false;
 319 }
 320
 321 bool CWallet::EraseFromWallet(uint256 hash)
 322 {
 323     if (!fFileBacked)
 324         return false;
 325     CRITICAL_BLOCK(cs_wallet)
 326     {
 327         if (mapWallet.erase(hash))
 328             CWalletDB(strWalletFile).EraseTx(hash);
 329     }
 330     return true;
 331 }
 332
 333
 334 bool CWallet::IsMine(const CTxIn &txin) const
 335 {
 336     CRITICAL_BLOCK(cs_wallet)
 337     {
 338         map<uint256, CWalletTx>::const_iterator mi = mapWallet.find(txin.prevout.hash);
 339         if (mi != mapWallet.end())
 340         {
 341             const CWalletTx& prev = (*mi).second;
 342             if (txin.prevout.n < prev.vout.size())
 343                 if (IsMine(prev.vout[txin.prevout.n]))
 344                     return true;
 345         }
 346     }
 347     return false;
 348 }
 349
 350 int64 CWallet::GetDebit(const CTxIn &txin) const
 351 {
 352     CRITICAL_BLOCK(cs_wallet)
 353     {
 354         map<uint256, CWalletTx>::const_iterator mi = mapWallet.find(txin.prevout.hash);
 355         if (mi != mapWallet.end())
 356         {
 357             const CWalletTx& prev = (*mi).second;
 358             if (txin.prevout.n < prev.vout.size())
 359                 if (IsMine(prev.vout[txin.prevout.n]))
 360                     return prev.vout[txin.prevout.n].nValue;
 361         }
 362     }
 363     return 0;
 364 }
 365
 366 int64 CWalletTx::GetTxTime() const
 367 {
 368     return nTimeReceived;
 369 }
 370
 371 int CWalletTx::GetRequestCount() const
 372 {
 373     // Returns -1 if it wasn't being tracked
 374     int nRequests = -1;
 375     CRITICAL_BLOCK(pwallet->cs_wallet)
 376     {
 377         if (IsCoinBase())
 378         {
 379             // Generated block
 380             if (hashBlock != 0)
 381             {
 382                 map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(hashBlock);
 383                 if (mi != pwallet->mapRequestCount.end())
 384                     nRequests = (*mi).second;
 385             }
 386         }
 387         else
 388         {
 389             // Did anyone request this transaction?
 390             map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(GetHash());
 391             if (mi != pwallet->mapRequestCount.end())
 392             {
 393                 nRequests = (*mi).second;
 394
 395                 // How about the block it's in?
 396                 if (nRequests == 0 && hashBlock != 0)
 397                 {
 398                     map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(hashBlock);
 399                     if (mi != pwallet->mapRequestCount.end())
 400                         nRequests = (*mi).second;
 401                     else
 402                         nRequests = 1; // If it's in someone else's block it must have got out
 403                 }
 404             }
 405         }
 406     }
 407     return nRequests;
 408 }
 409
 410 void CWalletTx::GetAmounts(int64& nGeneratedImmature, int64& nGeneratedMature, list<pair<CBitcoinAddress, int64> >& listReceived,
 411                            list<pair<CBitcoinAddress, int64> >& listSent, int64& nFee, string& strSentAccount) const
 412 {
 413     nGeneratedImmature = nGeneratedMature = nFee = 0;
 414     listReceived.clear();
 415     listSent.clear();
 416     strSentAccount = strFromAccount;
 417
 418     if (IsCoinBase())
 419     {
 420         if (GetBlocksToMaturity() > 0)
 421             nGeneratedImmature = pwallet->GetCredit(*this);
 422         else
 423             nGeneratedMature = GetCredit();
 424         return;
 425     }
 426
 427     // Compute fee:
 428     int64 nDebit = GetDebit();
 429     if (nDebit > 0) // debit>0 means we signed/sent this transaction
 430     {
 431         int64 nValueOut = GetValueOut();
 432         nFee = nDebit - nValueOut;
 433     }
 434
 435     // Sent/received.  Standard client will never generate a send-to-multiple-recipients,
 436     // but non-standard clients might (so return a list of address/amount pairs)
 437     BOOST_FOREACH(const CTxOut& txout, vout)
 438     {
 439         CBitcoinAddress address;
 440         vector<unsigned char> vchPubKey;
 441         if (!ExtractAddress(txout.scriptPubKey, NULL, address))
 442         {
 443             printf("CWalletTx::GetAmounts: Unknown transaction type found, txid %s\n",
 444                    this->GetHash().ToString().c_str());
 445             address = " unknown ";
 446         }
 447
 448         // Don't report 'change' txouts
 449         if (nDebit > 0 && pwallet->IsChange(txout))
 450             continue;
 451
 452         if (nDebit > 0)
 453             listSent.push_back(make_pair(address, txout.nValue));
 454
 455         if (pwallet->IsMine(txout))
 456             listReceived.push_back(make_pair(address, txout.nValue));
 457     }
 458
 459 }
 460
 461 void CWalletTx::GetAccountAmounts(const string& strAccount, int64& nGenerated, int64& nReceived,
 462                                   int64& nSent, int64& nFee) const
 463 {
 464     nGenerated = nReceived = nSent = nFee = 0;
 465
 466     int64 allGeneratedImmature, allGeneratedMature, allFee;
 467     allGeneratedImmature = allGeneratedMature = allFee = 0;
 468     string strSentAccount;
 469     list<pair<CBitcoinAddress, int64> > listReceived;
 470     list<pair<CBitcoinAddress, int64> > listSent;
 471     GetAmounts(allGeneratedImmature, allGeneratedMature, listReceived, listSent, allFee, strSentAccount);
 472
 473     if (strAccount == "")
 474         nGenerated = allGeneratedMature;
 475     if (strAccount == strSentAccount)
 476     {
 477         BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress,int64)& s, listSent)
 478             nSent += s.second;
 479         nFee = allFee;
 480     }
 481     CRITICAL_BLOCK(pwallet->cs_wallet)
 482     {
 483         BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress,int64)& r, listReceived)
 484         {
 485             if (pwallet->mapAddressBook.count(r.first))
 486             {
 487                 map<CBitcoinAddress, string>::const_iterator mi = pwallet->mapAddressBook.find(r.first);
 488                 if (mi != pwallet->mapAddressBook.end() && (*mi).second == strAccount)
 489                     nReceived += r.second;
 490             }
 491             else if (strAccount.empty())
 492             {
 493                 nReceived += r.second;
 494             }
 495         }
 496     }
 497 }
 498
 499 void CWalletTx::AddSupportingTransactions(CTxDB& txdb)
 500 {
 501     vtxPrev.clear();
 502
 503     const int COPY_DEPTH = 3;
 504     if (SetMerkleBranch() < COPY_DEPTH)
 505     {
 506         vector<uint256> vWorkQueue;
 507         BOOST_FOREACH(const CTxIn& txin, vin)
 508             vWorkQueue.push_back(txin.prevout.hash);
 509
 510         // This critsect is OK because txdb is already open
 511         CRITICAL_BLOCK(pwallet->cs_wallet)
 512         {
 513             map<uint256, const CMerkleTx*> mapWalletPrev;
 514             set<uint256> setAlreadyDone;
 515             for (unsigned int i = 0; i < vWorkQueue.size(); i++)
 516             {
 517                 uint256 hash = vWorkQueue[i];
 518                 if (setAlreadyDone.count(hash))
 519                     continue;
 520                 setAlreadyDone.insert(hash);
 521
 522                 CMerkleTx tx;
 523                 map<uint256, CWalletTx>::const_iterator mi = pwallet->mapWallet.find(hash);
 524                 if (mi != pwallet->mapWallet.end())
 525                 {
 526                     tx = (*mi).second;
 527                     BOOST_FOREACH(const CMerkleTx& txWalletPrev, (*mi).second.vtxPrev)
 528                         mapWalletPrev[txWalletPrev.GetHash()] = &txWalletPrev;
 529                 }
 530                 else if (mapWalletPrev.count(hash))
 531                 {
 532                     tx = *mapWalletPrev[hash];
 533                 }
 534                 else if (!fClient && txdb.ReadDiskTx(hash, tx))
 535                 {
 536                     ;
 537                 }
 538                 else
 539                 {
 540                     printf("ERROR: AddSupportingTransactions() : unsupported transaction\n");
 541                     continue;
 542                 }
 543
 544                 int nDepth = tx.SetMerkleBranch();
 545                 vtxPrev.push_back(tx);
 546
 547                 if (nDepth < COPY_DEPTH)
 548                 {
 549                     BOOST_FOREACH(const CTxIn& txin, tx.vin)
 550                         vWorkQueue.push_back(txin.prevout.hash);
 551                 }
 552             }
 553         }
 554     }
 555
 556     reverse(vtxPrev.begin(), vtxPrev.end());
 557 }
 558
 559 bool CWalletTx::WriteToDisk()
 560 {
 561     return CWalletDB(pwallet->strWalletFile).WriteTx(GetHash(), *this);
 562 }
 563
 564 int CWallet::ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate)
 565 {
 566     int ret = 0;
 567
 568     CBlockIndex* pindex = pindexStart;
 569     CRITICAL_BLOCK(cs_wallet)
 570     {
 571         while (pindex)
 572         {
 573             CBlock block;
 574             block.ReadFromDisk(pindex, true);
 575             BOOST_FOREACH(CTransaction& tx, block.vtx)
 576             {
 577                 if (AddToWalletIfInvolvingMe(tx, &block, fUpdate))
 578                     ret++;
 579             }
 580             pindex = pindex->pnext;
 581         }
 582     }
 583     return ret;
 584 }
 585
 586 void CWallet::ReacceptWalletTransactions()
 587 {
 588     CTxDB txdb("r");
 589     bool fRepeat = true;
 590     while (fRepeat) CRITICAL_BLOCK(cs_wallet)
 591     {
 592         fRepeat = false;
 593         vector<CDiskTxPos> vMissingTx;
 594         BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet)
 595         {
 596             CWalletTx& wtx = item.second;
 597             if (wtx.IsCoinBase() && wtx.IsSpent(0))
 598                 continue;
 599
 600             CTxIndex txindex;
 601             bool fUpdated = false;
 602             if (txdb.ReadTxIndex(wtx.GetHash(), txindex))
 603             {
 604                 // Update fSpent if a tx got spent somewhere else by a copy of wallet.dat
 605                 if (txindex.vSpent.size() != wtx.vout.size())
 606                 {
 607                     printf("ERROR: ReacceptWalletTransactions() : txindex.vSpent.size() %d != wtx.vout.size() %d\n", txindex.vSpent.size(), wtx.vout.size());
 608                     continue;
 609                 }
 610                 for (unsigned int i = 0; i < txindex.vSpent.size(); i++)
 611                 {
 612                     if (wtx.IsSpent(i))
 613                         continue;
 614                     if (!txindex.vSpent[i].IsNull() && IsMine(wtx.vout[i]))
 615                     {
 616                         wtx.MarkSpent(i);
 617                         fUpdated = true;
 618                         vMissingTx.push_back(txindex.vSpent[i]);
 619                     }
 620                 }
 621                 if (fUpdated)
 622                 {
 623                     printf("ReacceptWalletTransactions found spent coin %sbc %s\n", FormatMoney(wtx.GetCredit()).c_str(), wtx.GetHash().ToString().c_str());
 624                     wtx.MarkDirty();
 625                     wtx.WriteToDisk();
 626                 }
 627             }
 628             else
 629             {
 630                 // Reaccept any txes of ours that aren't already in a block
 631                 if (!wtx.IsCoinBase())
 632                     wtx.AcceptWalletTransaction(txdb, false);
 633             }
 634         }
 635         if (!vMissingTx.empty())
 636         {
 637             // TODO: optimize this to scan just part of the block chain?
 638             if (ScanForWalletTransactions(pindexGenesisBlock))
 639                 fRepeat = true;  // Found missing transactions: re-do Reaccept.
 640         }
 641     }
 642 }
 643
 644 void CWalletTx::RelayWalletTransaction(CTxDB& txdb)
 645 {
 646     BOOST_FOREACH(const CMerkleTx& tx, vtxPrev)
 647     {
 648         if (!tx.IsCoinBase())
 649         {
 650             uint256 hash = tx.GetHash();
 651             if (!txdb.ContainsTx(hash))
 652                 RelayMessage(CInv(MSG_TX, hash), (CTransaction)tx);
 653         }
 654     }
 655     if (!IsCoinBase())
 656     {
 657         uint256 hash = GetHash();
 658         if (!txdb.ContainsTx(hash))
 659         {
 660             printf("Relaying wtx %s\n", hash.ToString().substr(0,10).c_str());
 661             RelayMessage(CInv(MSG_TX, hash), (CTransaction)*this);
 662         }
 663     }
 664 }
 665
 666 void CWalletTx::RelayWalletTransaction()
 667 {
 668    CTxDB txdb("r");
 669    RelayWalletTransaction(txdb);
 670 }
 671
 672 void CWallet::ResendWalletTransactions()
 673 {
 674     // Do this infrequently and randomly to avoid giving away
 675     // that these are our transactions.
 676     static int64 nNextTime;
 677     if (GetTime() < nNextTime)
 678         return;
 679     bool fFirst = (nNextTime == 0);
 680     nNextTime = GetTime() + GetRand(30 * 60);
 681     if (fFirst)
 682         return;
 683
 684     // Only do it if there's been a new block since last time
 685     static int64 nLastTime;
 686     if (nTimeBestReceived < nLastTime)
 687         return;
 688     nLastTime = GetTime();
 689
 690     // Rebroadcast any of our txes that aren't in a block yet
 691     printf("ResendWalletTransactions()\n");
 692     CTxDB txdb("r");
 693     CRITICAL_BLOCK(cs_wallet)
 694     {
 695         // Sort them in chronological order
 696         multimap<unsigned int, CWalletTx*> mapSorted;
 697         BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet)
 698         {
 699             CWalletTx& wtx = item.second;
 700             // Don't rebroadcast until it's had plenty of time that
 701             // it should have gotten in already by now.
 702             if (nTimeBestReceived - (int64)wtx.nTimeReceived > 5 * 60)
 703                 mapSorted.insert(make_pair(wtx.nTimeReceived, &wtx));
 704         }
 705         BOOST_FOREACH(PAIRTYPE(const unsigned int, CWalletTx*)& item, mapSorted)
 706         {
 707             CWalletTx& wtx = *item.second;
 708             wtx.RelayWalletTransaction(txdb);
 709         }
 710     }
 711 }
 712
 713
 714
 715
 716
 717
 718 //////////////////////////////////////////////////////////////////////////////
 719 //
 720 // Actions
 721 //
 722
 723
 724 int64 CWallet::GetBalance() const
 725 {
 726     int64 nTotal = 0;
 727     CRITICAL_BLOCK(cs_wallet)
 728     {
 729         for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
 730         {
 731             const CWalletTx* pcoin = &(*it).second;
 732             if (!pcoin->IsFinal() || !pcoin->IsConfirmed())
 733                 continue;
 734             nTotal += pcoin->GetAvailableCredit();
 735         }
 736     }
 737
 738     return nTotal;
 739 }
 740
 741
 742 bool CWallet::SelectCoinsMinConf(int64 nTargetValue, int nConfMine, int nConfTheirs, set<pair<const CWalletTx*,unsigned int> >& setCoinsRet, int64& nValueRet) const
 743 {
 744     setCoinsRet.clear();
 745     nValueRet = 0;
 746
 747     // List of values less than target
 748     pair<int64, pair<const CWalletTx*,unsigned int> > coinLowestLarger;
 749     coinLowestLarger.first = INT64_MAX;
 750     coinLowestLarger.second.first = NULL;
 751     vector<pair<int64, pair<const CWalletTx*,unsigned int> > > vValue;
 752     int64 nTotalLower = 0;
 753
 754     CRITICAL_BLOCK(cs_wallet)
 755     {
 756        vector<const CWalletTx*> vCoins;
 757        vCoins.reserve(mapWallet.size());
 758        for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
 759            vCoins.push_back(&(*it).second);
 760        random_shuffle(vCoins.begin(), vCoins.end(), GetRandInt);
 761
 762        BOOST_FOREACH(const CWalletTx* pcoin, vCoins)
 763        {
 764             if (!pcoin->IsFinal() || !pcoin->IsConfirmed())
 765                 continue;
 766
 767             if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0)
 768                 continue;
 769
 770             int nDepth = pcoin->GetDepthInMainChain();
 771             if (nDepth < (pcoin->IsFromMe() ? nConfMine : nConfTheirs))
 772                 continue;
 773
 774             for (unsigned int i = 0; i < pcoin->vout.size(); i++)
 775             {
 776                 if (pcoin->IsSpent(i) || !IsMine(pcoin->vout[i]))
 777                     continue;
 778
 779                 int64 n = pcoin->vout[i].nValue;
 780
 781                 if (n <= 0)
 782                     continue;
 783
 784                 pair<int64,pair<const CWalletTx*,unsigned int> > coin = make_pair(n,make_pair(pcoin,i));
 785
 786                 if (n == nTargetValue)
 787                 {
 788                     setCoinsRet.insert(coin.second);
 789                     nValueRet += coin.first;
 790                     return true;
 791                 }
 792                 else if (n < nTargetValue + CENT)
 793                 {
 794                     vValue.push_back(coin);
 795                     nTotalLower += n;
 796                 }
 797                 else if (n < coinLowestLarger.first)
 798                 {
 799                     coinLowestLarger = coin;
 800                 }
 801             }
 802         }
 803     }
 804
 805     if (nTotalLower == nTargetValue || nTotalLower == nTargetValue + CENT)
 806     {
 807         for (unsigned int i = 0; i < vValue.size(); ++i)
 808         {
 809             setCoinsRet.insert(vValue[i].second);
 810             nValueRet += vValue[i].first;
 811         }
 812         return true;
 813     }
 814
 815     if (nTotalLower < nTargetValue + (coinLowestLarger.second.first ? CENT : 0))
 816     {
 817         if (coinLowestLarger.second.first == NULL)
 818             return false;
 819         setCoinsRet.insert(coinLowestLarger.second);
 820         nValueRet += coinLowestLarger.first;
 821         return true;
 822     }
 823
 824     if (nTotalLower >= nTargetValue + CENT)
 825         nTargetValue += CENT;
 826
 827     // Solve subset sum by stochastic approximation
 828     sort(vValue.rbegin(), vValue.rend());
 829     vector<char> vfIncluded;
 830     vector<char> vfBest(vValue.size(), true);
 831     int64 nBest = nTotalLower;
 832
 833     for (int nRep = 0; nRep < 1000 && nBest != nTargetValue; nRep++)
 834     {
 835         vfIncluded.assign(vValue.size(), false);
 836         int64 nTotal = 0;
 837         bool fReachedTarget = false;
 838         for (int nPass = 0; nPass < 2 && !fReachedTarget; nPass++)
 839         {
 840             for (unsigned int i = 0; i < vValue.size(); i++)
 841             {
 842                 if (nPass == 0 ? rand() % 2 : !vfIncluded[i])
 843                 {
 844                     nTotal += vValue[i].first;
 845                     vfIncluded[i] = true;
 846                     if (nTotal >= nTargetValue)
 847                     {
 848                         fReachedTarget = true;
 849                         if (nTotal < nBest)
 850                         {
 851                             nBest = nTotal;
 852                             vfBest = vfIncluded;
 853                         }
 854                         nTotal -= vValue[i].first;
 855                         vfIncluded[i] = false;
 856                     }
 857                 }
 858             }
 859         }
 860     }
 861
 862     // If the next larger is still closer, return it
 863     if (coinLowestLarger.second.first && coinLowestLarger.first - nTargetValue <= nBest - nTargetValue)
 864     {
 865         setCoinsRet.insert(coinLowestLarger.second);
 866         nValueRet += coinLowestLarger.first;
 867     }
 868     else {
 869         for (unsigned int i = 0; i < vValue.size(); i++)
 870             if (vfBest[i])
 871             {
 872                 setCoinsRet.insert(vValue[i].second);
 873                 nValueRet += vValue[i].first;
 874             }
 875
 876         //// debug print
 877         printf("SelectCoins() best subset: ");
 878         for (unsigned int i = 0; i < vValue.size(); i++)
 879             if (vfBest[i])
 880                 printf("%s ", FormatMoney(vValue[i].first).c_str());
 881         printf("total %s\n", FormatMoney(nBest).c_str());
 882     }
 883
 884     return true;
 885 }
 886
 887 bool CWallet::SelectCoins(int64 nTargetValue, set<pair<const CWalletTx*,unsigned int> >& setCoinsRet, int64& nValueRet) const
 888 {
 889     return (SelectCoinsMinConf(nTargetValue, 1, 6, setCoinsRet, nValueRet) ||
 890             SelectCoinsMinConf(nTargetValue, 1, 1, setCoinsRet, nValueRet) ||
 891             SelectCoinsMinConf(nTargetValue, 0, 1, setCoinsRet, nValueRet));
 892 }
 893
 894
 895
 896
 897 bool CWallet::CreateTransaction(const vector<pair<CScript, int64> >& vecSend, CWalletTx& wtxNew, CReserveKey& reservekey, int64& nFeeRet)
 898 {
 899     int64 nValue = 0;
 900     BOOST_FOREACH (const PAIRTYPE(CScript, int64)& s, vecSend)
 901     {
 902         if (nValue < 0)
 903             return false;
 904         nValue += s.second;
 905     }
 906     if (vecSend.empty() || nValue < 0)
 907         return false;
 908
 909     wtxNew.pwallet = this;
 910
 911     CRITICAL_BLOCK(cs_main)
 912     CRITICAL_BLOCK(cs_wallet)
 913     {
 914         // txdb must be opened before the mapWallet lock
 915         CTxDB txdb("r");
 916         {
 917             nFeeRet = nTransactionFee;
 918             loop
 919             {
 920                 wtxNew.vin.clear();
 921                 wtxNew.vout.clear();
 922                 wtxNew.fFromMe = true;
 923
 924                 int64 nTotalValue = nValue + nFeeRet;
 925                 double dPriority = 0;
 926                 // vouts to the payees
 927                 BOOST_FOREACH (const PAIRTYPE(CScript, int64)& s, vecSend)
 928                     wtxNew.vout.push_back(CTxOut(s.second, s.first));
 929
 930                 // Choose coins to use
 931                 set<pair<const CWalletTx*,unsigned int> > setCoins;
 932                 int64 nValueIn = 0;
 933                 if (!SelectCoins(nTotalValue, setCoins, nValueIn))
 934                     return false;
 935                 BOOST_FOREACH(PAIRTYPE(const CWalletTx*, unsigned int) pcoin, setCoins)
 936                 {
 937                     int64 nCredit = pcoin.first->vout[pcoin.second].nValue;
 938                     dPriority += (double)nCredit * pcoin.first->GetDepthInMainChain();
 939                 }
 940
 941                 int64 nChange = nValueIn - nValue - nFeeRet;
 942                 // if sub-cent change is required, the fee must be raised to at least MIN_TX_FEE
 943                 // or until nChange becomes zero
 944                 if (nFeeRet < MIN_TX_FEE && nChange > 0 && nChange < CENT)
 945                 {
 946                     int64 nMoveToFee = min(nChange, MIN_TX_FEE - nFeeRet);
 947                     nChange -= nMoveToFee;
 948                     nFeeRet += nMoveToFee;
 949                 }
 950
 951                 if (nChange > 0)
 952                 {
 953                     // Note: We use a new key here to keep it from being obvious which side is the change.
 954                     //  The drawback is that by not reusing a previous key, the change may be lost if a
 955                     //  backup is restored, if the backup doesn't have the new private key for the change.
 956                     //  If we reused the old key, it would be possible to add code to look for and
 957                     //  rediscover unknown transactions that were written with keys of ours to recover
 958                     //  post-backup change.
 959
 960                     // Reserve a new key pair from key pool
 961                     vector<unsigned char> vchPubKey = reservekey.GetReservedKey();
 962                     // assert(mapKeys.count(vchPubKey));
 963
 964                     // Fill a vout to ourself, using same address type as the payment
 965                     CScript scriptChange;
 966                     if (vecSend[0].first.GetBitcoinAddress().IsValid())
 967                         scriptChange.SetBitcoinAddress(vchPubKey);
 968                     else
 969                         scriptChange << vchPubKey << OP_CHECKSIG;
 970
 971                     // Insert change txn at random position:
 972                     vector<CTxOut>::iterator position = wtxNew.vout.begin()+GetRandInt(wtxNew.vout.size());
 973                     wtxNew.vout.insert(position, CTxOut(nChange, scriptChange));
 974                 }
 975                 else
 976                     reservekey.ReturnKey();
 977
 978                 // Fill vin
 979                 BOOST_FOREACH(const PAIRTYPE(const CWalletTx*,unsigned int)& coin, setCoins)
 980                     wtxNew.vin.push_back(CTxIn(coin.first->GetHash(),coin.second));
 981
 982                 // Sign
 983                 int nIn = 0;
 984                 BOOST_FOREACH(const PAIRTYPE(const CWalletTx*,unsigned int)& coin, setCoins)
 985                     if (!SignSignature(*this, *coin.first, wtxNew, nIn++))
 986                         return false;
 987
 988                 // Limit size
 989                 unsigned int nBytes = ::GetSerializeSize(*(CTransaction*)&wtxNew, SER_NETWORK);
 990                 if (nBytes >= MAX_BLOCK_SIZE_GEN/5)
 991                     return false;
 992                 dPriority /= nBytes;
 993
 994                 // Check that enough fee is included
 995                 int64 nPayFee = nTransactionFee * (1 + (int64)nBytes / 1000);
 996                 bool fAllowFree = CTransaction::AllowFree(dPriority);
 997                 int64 nMinFee = wtxNew.GetMinFee(1, fAllowFree);
 998                 if (nFeeRet < max(nPayFee, nMinFee))
 999                 {
1000                     nFeeRet = max(nPayFee, nMinFee);
1001                     continue;
1002                 }
1003
1004                 // Fill vtxPrev by copying from previous transactions vtxPrev
1005                 wtxNew.AddSupportingTransactions(txdb);
1006                 wtxNew.fTimeReceivedIsTxTime = true;
1007
1008                 break;
1009             }
1010         }
1011     }
1012     return true;
1013 }
1014
1015 bool CWallet::CreateTransaction(CScript scriptPubKey, int64 nValue, CWalletTx& wtxNew, CReserveKey& reservekey, int64& nFeeRet)
1016 {
1017     vector< pair<CScript, int64> > vecSend;
1018     vecSend.push_back(make_pair(scriptPubKey, nValue));
1019     return CreateTransaction(vecSend, wtxNew, reservekey, nFeeRet);
1020 }
1021
1022 // Call after CreateTransaction unless you want to abort
1023 bool CWallet::CommitTransaction(CWalletTx& wtxNew, CReserveKey& reservekey)
1024 {
1025     CRITICAL_BLOCK(cs_main)
1026     CRITICAL_BLOCK(cs_wallet)
1027     {
1028         printf("CommitTransaction:\n%s", wtxNew.ToString().c_str());
1029         {
1030             // This is only to keep the database open to defeat the auto-flush for the
1031             // duration of this scope.  This is the only place where this optimization
1032             // maybe makes sense; please don't do it anywhere else.
1033             CWalletDB* pwalletdb = fFileBacked ? new CWalletDB(strWalletFile,"r") : NULL;
1034
1035             // Take key pair from key pool so it won't be used again
1036             reservekey.KeepKey();
1037
1038             // Add tx to wallet, because if it has change it's also ours,
1039             // otherwise just for transaction history.
1040             AddToWallet(wtxNew);
1041
1042             // Mark old coins as spent
1043             set<CWalletTx*> setCoins;
1044             BOOST_FOREACH(const CTxIn& txin, wtxNew.vin)
1045             {
1046                 CWalletTx &coin = mapWallet[txin.prevout.hash];
1047                 coin.pwallet = this;
1048                 coin.MarkSpent(txin.prevout.n);
1049                 coin.WriteToDisk();
1050                 vWalletUpdated.push_back(coin.GetHash());
1051             }
1052
1053             if (fFileBacked)
1054                 delete pwalletdb;
1055         }
1056
1057         // Track how many getdata requests our transaction gets
1058         mapRequestCount[wtxNew.GetHash()] = 0;
1059
1060         // Broadcast
1061         if (!wtxNew.AcceptToMemoryPool())
1062         {
1063             // This must not fail. The transaction has already been signed and recorded.
1064             printf("CommitTransaction() : Error: Transaction not valid");
1065             return false;
1066         }
1067         wtxNew.RelayWalletTransaction();
1068     }
1069     MainFrameRepaint();
1070     return true;
1071 }
1072
1073
1074
1075
1076 string CWallet::SendMoney(CScript scriptPubKey, int64 nValue, CWalletTx& wtxNew, bool fAskFee)
1077 {
1078     CReserveKey reservekey(this);
1079     int64 nFeeRequired;
1080
1081     if (IsLocked())
1082     {
1083         string strError = _("Error: Wallet locked, unable to create transaction  ");
1084         printf("SendMoney() : %s", strError.c_str());
1085         return strError;
1086     }
1087     if (!CreateTransaction(scriptPubKey, nValue, wtxNew, reservekey, nFeeRequired))
1088     {
1089         string strError;
1090         if (nValue + nFeeRequired > GetBalance())
1091             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());
1092         else
1093             strError = _("Error: Transaction creation failed  ");
1094         printf("SendMoney() : %s", strError.c_str());
1095         return strError;
1096     }
1097
1098     if (fAskFee && !ThreadSafeAskFee(nFeeRequired, _("Sending..."), NULL))
1099         return "ABORTED";
1100
1101     if (!CommitTransaction(wtxNew, reservekey))
1102         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.");
1103
1104     MainFrameRepaint();
1105     return "";
1106 }
1107
1108
1109
1110 string CWallet::SendMoneyToBitcoinAddress(const CBitcoinAddress& address, int64 nValue, CWalletTx& wtxNew, bool fAskFee)
1111 {
1112     // Check amount
1113     if (nValue <= 0)
1114         return _("Invalid amount");
1115     if (nValue + nTransactionFee > GetBalance())
1116         return _("Insufficient funds");
1117
1118     // Parse bitcoin address
1119     CScript scriptPubKey;
1120     scriptPubKey.SetBitcoinAddress(address);
1121
1122     return SendMoney(scriptPubKey, nValue, wtxNew, fAskFee);
1123 }
1124
1125
1126
1127
1128 int CWallet::LoadWallet(bool& fFirstRunRet)
1129 {
1130     if (!fFileBacked)
1131         return false;
1132     fFirstRunRet = false;
1133     int nLoadWalletRet = CWalletDB(strWalletFile,"cr+").LoadWallet(this);
1134     if (nLoadWalletRet == DB_NEED_REWRITE)
1135     {
1136         if (CDB::Rewrite(strWalletFile, "\x04pool"))
1137         {
1138             setKeyPool.clear();
1139             // Note: can't top-up keypool here, because wallet is locked.
1140             // User will be prompted to unlock wallet the next operation
1141             // the requires a new key.
1142         }
1143         nLoadWalletRet = DB_NEED_REWRITE;
1144     }
1145
1146     if (nLoadWalletRet != DB_LOAD_OK)
1147         return nLoadWalletRet;
1148     fFirstRunRet = vchDefaultKey.empty();
1149
1150     if (!HaveKey(Hash160(vchDefaultKey)))
1151     {
1152         // Create new keyUser and set as default key
1153         RandAddSeedPerfmon();
1154
1155         std::vector<unsigned char> newDefaultKey;
1156         if (!GetKeyFromPool(newDefaultKey, false))
1157             return DB_LOAD_FAIL;
1158         SetDefaultKey(newDefaultKey);
1159         if (!SetAddressBookName(CBitcoinAddress(vchDefaultKey), ""))
1160             return DB_LOAD_FAIL;
1161     }
1162
1163     CreateThread(ThreadFlushWalletDB, &strWalletFile);
1164     return DB_LOAD_OK;
1165 }
1166
1167
1168 bool CWallet::SetAddressBookName(const CBitcoinAddress& address, const string& strName)
1169 {
1170     mapAddressBook[address] = strName;
1171     if (!fFileBacked)
1172         return false;
1173     return CWalletDB(strWalletFile).WriteName(address.ToString(), strName);
1174 }
1175
1176 bool CWallet::DelAddressBookName(const CBitcoinAddress& address)
1177 {
1178     mapAddressBook.erase(address);
1179     if (!fFileBacked)
1180         return false;
1181     return CWalletDB(strWalletFile).EraseName(address.ToString());
1182 }
1183
1184
1185 void CWallet::PrintWallet(const CBlock& block)
1186 {
1187     CRITICAL_BLOCK(cs_wallet)
1188     {
1189         if (mapWallet.count(block.vtx[0].GetHash()))
1190         {
1191             CWalletTx& wtx = mapWallet[block.vtx[0].GetHash()];
1192             printf("    mine:  %d  %d  %d", wtx.GetDepthInMainChain(), wtx.GetBlocksToMaturity(), wtx.GetCredit());
1193         }
1194     }
1195     printf("\n");
1196 }
1197
1198 bool CWallet::GetTransaction(const uint256 &hashTx, CWalletTx& wtx)
1199 {
1200     CRITICAL_BLOCK(cs_wallet)
1201     {
1202         map<uint256, CWalletTx>::iterator mi = mapWallet.find(hashTx);
1203         if (mi != mapWallet.end())
1204         {
1205             wtx = (*mi).second;
1206             return true;
1207         }
1208     }
1209     return false;
1210 }
1211
1212 bool CWallet::SetDefaultKey(const std::vector<unsigned char> &vchPubKey)
1213 {
1214     if (fFileBacked)
1215     {
1216         if (!CWalletDB(strWalletFile).WriteDefaultKey(vchPubKey))
1217             return false;
1218     }
1219     vchDefaultKey = vchPubKey;
1220     return true;
1221 }
1222
1223 bool GetWalletFile(CWallet* pwallet, string &strWalletFileOut)
1224 {
1225     if (!pwallet->fFileBacked)
1226         return false;
1227     strWalletFileOut = pwallet->strWalletFile;
1228     return true;
1229 }
1230
1231 //
1232 // Mark old keypool keys as used,
1233 // and generate all new keys
1234 //
1235 bool CWallet::NewKeyPool()
1236 {
1237     CRITICAL_BLOCK(cs_wallet)
1238     {
1239         CWalletDB walletdb(strWalletFile);
1240         BOOST_FOREACH(int64 nIndex, setKeyPool)
1241             walletdb.ErasePool(nIndex);
1242         setKeyPool.clear();
1243
1244         if (IsLocked())
1245             return false;
1246
1247         int64 nKeys = max(GetArg("-keypool", 100), (int64)0);
1248         for (int i = 0; i < nKeys; i++)
1249         {
1250             int64 nIndex = i+1;
1251             walletdb.WritePool(nIndex, CKeyPool(GenerateNewKey()));
1252             setKeyPool.insert(nIndex);
1253         }
1254         printf("CWallet::NewKeyPool wrote %"PRI64d" new keys\n", nKeys);
1255     }
1256     return true;
1257 }
1258
1259 bool CWallet::TopUpKeyPool()
1260 {
1261     CRITICAL_BLOCK(cs_wallet)
1262     {
1263         if (IsLocked())
1264             return false;
1265
1266         CWalletDB walletdb(strWalletFile);
1267
1268         // Top up key pool
1269         int64 nTargetSize = max(GetArg("-keypool", 100), (int64)0);
1270         while (setKeyPool.size() < nTargetSize+1)
1271         {
1272             int64 nEnd = 1;
1273             if (!setKeyPool.empty())
1274                 nEnd = *(--setKeyPool.end()) + 1;
1275             if (!walletdb.WritePool(nEnd, CKeyPool(GenerateNewKey())))
1276                 throw runtime_error("TopUpKeyPool() : writing generated key failed");
1277             setKeyPool.insert(nEnd);
1278             printf("keypool added key %"PRI64d", size=%d\n", nEnd, setKeyPool.size());
1279         }
1280     }
1281     return true;
1282 }
1283
1284 void CWallet::ReserveKeyFromKeyPool(int64& nIndex, CKeyPool& keypool)
1285 {
1286     nIndex = -1;
1287     keypool.vchPubKey.clear();
1288     CRITICAL_BLOCK(cs_wallet)
1289     {
1290         if (!IsLocked())
1291             TopUpKeyPool();
1292
1293         // Get the oldest key
1294         if(setKeyPool.empty())
1295             return;
1296
1297         CWalletDB walletdb(strWalletFile);
1298
1299         nIndex = *(setKeyPool.begin());
1300         setKeyPool.erase(setKeyPool.begin());
1301         if (!walletdb.ReadPool(nIndex, keypool))
1302             throw runtime_error("ReserveKeyFromKeyPool() : read failed");
1303         if (!HaveKey(Hash160(keypool.vchPubKey)))
1304             throw runtime_error("ReserveKeyFromKeyPool() : unknown key in key pool");
1305         assert(!keypool.vchPubKey.empty());
1306         printf("keypool reserve %"PRI64d"\n", nIndex);
1307     }
1308 }
1309
1310 void CWallet::KeepKey(int64 nIndex)
1311 {
1312     // Remove from key pool
1313     if (fFileBacked)
1314     {
1315         CWalletDB walletdb(strWalletFile);
1316         walletdb.ErasePool(nIndex);
1317     }
1318     printf("keypool keep %"PRI64d"\n", nIndex);
1319 }
1320
1321 void CWallet::ReturnKey(int64 nIndex)
1322 {
1323     // Return to key pool
1324     CRITICAL_BLOCK(cs_wallet)
1325         setKeyPool.insert(nIndex);
1326     printf("keypool return %"PRI64d"\n", nIndex);
1327 }
1328
1329 bool CWallet::GetKeyFromPool(vector<unsigned char>& result, bool fAllowReuse)
1330 {
1331     int64 nIndex = 0;
1332     CKeyPool keypool;
1333     CRITICAL_BLOCK(cs_wallet)
1334     {
1335         ReserveKeyFromKeyPool(nIndex, keypool);
1336         if (nIndex == -1)
1337         {
1338             if (fAllowReuse && !vchDefaultKey.empty())
1339             {
1340                 result = vchDefaultKey;
1341                 return true;
1342             }
1343             if (IsLocked()) return false;
1344             result = GenerateNewKey();
1345             return true;
1346         }
1347         KeepKey(nIndex);
1348         result = keypool.vchPubKey;
1349     }
1350     return true;
1351 }
1352
1353 int64 CWallet::GetOldestKeyPoolTime()
1354 {
1355     int64 nIndex = 0;
1356     CKeyPool keypool;
1357     ReserveKeyFromKeyPool(nIndex, keypool);
1358     if (nIndex == -1)
1359         return GetTime();
1360     ReturnKey(nIndex);
1361     return keypool.nTime;
1362 }
1363
1364 vector<unsigned char> CReserveKey::GetReservedKey()
1365 {
1366     if (nIndex == -1)
1367     {
1368         CKeyPool keypool;
1369         pwallet->ReserveKeyFromKeyPool(nIndex, keypool);
1370         if (nIndex != -1)
1371             vchPubKey = keypool.vchPubKey;
1372         else
1373         {
1374             printf("CReserveKey::GetReservedKey(): Warning: using default key instead of a new key, top up your keypool.");
1375             vchPubKey = pwallet->vchDefaultKey;
1376         }
1377     }
1378     assert(!vchPubKey.empty());
1379     return vchPubKey;
1380 }
1381
1382 void CReserveKey::KeepKey()
1383 {
1384     if (nIndex != -1)
1385         pwallet->KeepKey(nIndex);
1386     nIndex = -1;
1387     vchPubKey.clear();
1388 }
1389
1390 void CReserveKey::ReturnKey()
1391 {
1392     if (nIndex != -1)
1393         pwallet->ReturnKey(nIndex);
1394     nIndex = -1;
1395     vchPubKey.clear();
1396 }
1397