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