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             pwalletdbEncryption->Close();
 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         if (CDB::Rewrite(strWalletFile))
 198             RemoveLogFilesOnShutdown(true);
 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 (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                     BOOST_FOREACH(const CTxIn& txin, tx.vin)
 550                         vWorkQueue.push_back(txin.prevout.hash);
 551             }
 552         }
 553     }
 554
 555     reverse(vtxPrev.begin(), vtxPrev.end());
 556 }
 557
 558 bool CWalletTx::WriteToDisk()
 559 {
 560     return CWalletDB(pwallet->strWalletFile).WriteTx(GetHash(), *this);
 561 }
 562
 563 int CWallet::ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate)
 564 {
 565     int ret = 0;
 566
 567     CBlockIndex* pindex = pindexStart;
 568     CRITICAL_BLOCK(cs_wallet)
 569     {
 570         while (pindex)
 571         {
 572             CBlock block;
 573             block.ReadFromDisk(pindex, true);
 574             BOOST_FOREACH(CTransaction& tx, block.vtx)
 575             {
 576                 if (AddToWalletIfInvolvingMe(tx, &block, fUpdate))
 577                     ret++;
 578             }
 579             pindex = pindex->pnext;
 580         }
 581     }
 582     return ret;
 583 }
 584
 585 void CWallet::ReacceptWalletTransactions()
 586 {
 587     CTxDB txdb("r");
 588     bool fRepeat = true;
 589     while (fRepeat) CRITICAL_BLOCK(cs_wallet)
 590     {
 591         fRepeat = false;
 592         vector<CDiskTxPos> vMissingTx;
 593         BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet)
 594         {
 595             CWalletTx& wtx = item.second;
 596             if (wtx.IsCoinBase() && wtx.IsSpent(0))
 597                 continue;
 598
 599             CTxIndex txindex;
 600             bool fUpdated = false;
 601             if (txdb.ReadTxIndex(wtx.GetHash(), txindex))
 602             {
 603                 // Update fSpent if a tx got spent somewhere else by a copy of wallet.dat
 604                 if (txindex.vSpent.size() != wtx.vout.size())
 605                 {
 606                     printf("ERROR: ReacceptWalletTransactions() : txindex.vSpent.size() %d != wtx.vout.size() %d\n", txindex.vSpent.size(), wtx.vout.size());
 607                     continue;
 608                 }
 609                 for (int i = 0; i < txindex.vSpent.size(); i++)
 610                 {
 611                     if (wtx.IsSpent(i))
 612                         continue;
 613                     if (!txindex.vSpent[i].IsNull() && IsMine(wtx.vout[i]))
 614                     {
 615                         wtx.MarkSpent(i);
 616                         fUpdated = true;
 617                         vMissingTx.push_back(txindex.vSpent[i]);
 618                     }
 619                 }
 620                 if (fUpdated)
 621                 {
 622                     printf("ReacceptWalletTransactions found spent coin %sbc %s\n", FormatMoney(wtx.GetCredit()).c_str(), wtx.GetHash().ToString().c_str());
 623                     wtx.MarkDirty();
 624                     wtx.WriteToDisk();
 625                 }
 626             }
 627             else
 628             {
 629                 // Reaccept any txes of ours that aren't already in a block
 630                 if (!wtx.IsCoinBase())
 631                     wtx.AcceptWalletTransaction(txdb, false);
 632             }
 633         }
 634         if (!vMissingTx.empty())
 635         {
 636             // TODO: optimize this to scan just part of the block chain?
 637             if (ScanForWalletTransactions(pindexGenesisBlock))
 638                 fRepeat = true;  // Found missing transactions: re-do Reaccept.
 639         }
 640     }
 641 }
 642
 643 void CWalletTx::RelayWalletTransaction(CTxDB& txdb)
 644 {
 645     BOOST_FOREACH(const CMerkleTx& tx, vtxPrev)
 646     {
 647         if (!tx.IsCoinBase())
 648         {
 649             uint256 hash = tx.GetHash();
 650             if (!txdb.ContainsTx(hash))
 651                 RelayMessage(CInv(MSG_TX, hash), (CTransaction)tx);
 652         }
 653     }
 654     if (!IsCoinBase())
 655     {
 656         uint256 hash = GetHash();
 657         if (!txdb.ContainsTx(hash))
 658         {
 659             printf("Relaying wtx %s\n", hash.ToString().substr(0,10).c_str());
 660             RelayMessage(CInv(MSG_TX, hash), (CTransaction)*this);
 661         }
 662     }
 663 }
 664
 665 void CWalletTx::RelayWalletTransaction()
 666 {
 667    CTxDB txdb("r");
 668    RelayWalletTransaction(txdb);
 669 }
 670
 671 void CWallet::ResendWalletTransactions()
 672 {
 673     // Do this infrequently and randomly to avoid giving away
 674     // that these are our transactions.
 675     static int64 nNextTime;
 676     if (GetTime() < nNextTime)
 677         return;
 678     bool fFirst = (nNextTime == 0);
 679     nNextTime = GetTime() + GetRand(30 * 60);
 680     if (fFirst)
 681         return;
 682
 683     // Only do it if there's been a new block since last time
 684     static int64 nLastTime;
 685     if (nTimeBestReceived < nLastTime)
 686         return;
 687     nLastTime = GetTime();
 688
 689     // Rebroadcast any of our txes that aren't in a block yet
 690     printf("ResendWalletTransactions()\n");
 691     CTxDB txdb("r");
 692     CRITICAL_BLOCK(cs_wallet)
 693     {
 694         // Sort them in chronological order
 695         multimap<unsigned int, CWalletTx*> mapSorted;
 696         BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet)
 697         {
 698             CWalletTx& wtx = item.second;
 699             // Don't rebroadcast until it's had plenty of time that
 700             // it should have gotten in already by now.
 701             if (nTimeBestReceived - (int64)wtx.nTimeReceived > 5 * 60)
 702                 mapSorted.insert(make_pair(wtx.nTimeReceived, &wtx));
 703         }
 704         BOOST_FOREACH(PAIRTYPE(const unsigned int, CWalletTx*)& item, mapSorted)
 705         {
 706             CWalletTx& wtx = *item.second;
 707             wtx.RelayWalletTransaction(txdb);
 708         }
 709     }
 710 }
 711
 712
 713
 714
 715
 716
 717 //////////////////////////////////////////////////////////////////////////////
 718 //
 719 // Actions
 720 //
 721
 722
 723 int64 CWallet::GetBalance() const
 724 {
 725     int64 nTotal = 0;
 726     CRITICAL_BLOCK(cs_wallet)
 727     {
 728         for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
 729         {
 730             const CWalletTx* pcoin = &(*it).second;
 731             if (!pcoin->IsFinal() || !pcoin->IsConfirmed())
 732                 continue;
 733             nTotal += pcoin->GetAvailableCredit();
 734         }
 735     }
 736
 737     return nTotal;
 738 }
 739
 740
 741 bool CWallet::SelectCoinsMinConf(int64 nTargetValue, int nConfMine, int nConfTheirs, set<pair<const CWalletTx*,unsigned int> >& setCoinsRet, int64& nValueRet) const
 742 {
 743     setCoinsRet.clear();
 744     nValueRet = 0;
 745
 746     // List of values less than target
 747     pair<int64, pair<const CWalletTx*,unsigned int> > coinLowestLarger;
 748     coinLowestLarger.first = INT64_MAX;
 749     coinLowestLarger.second.first = NULL;
 750     vector<pair<int64, pair<const CWalletTx*,unsigned int> > > vValue;
 751     int64 nTotalLower = 0;
 752
 753     CRITICAL_BLOCK(cs_wallet)
 754     {
 755        vector<const CWalletTx*> vCoins;
 756        vCoins.reserve(mapWallet.size());
 757        for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
 758            vCoins.push_back(&(*it).second);
 759        random_shuffle(vCoins.begin(), vCoins.end(), GetRandInt);
 760
 761        BOOST_FOREACH(const CWalletTx* pcoin, vCoins)
 762        {
 763             if (!pcoin->IsFinal() || !pcoin->IsConfirmed())
 764                 continue;
 765
 766             if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0)
 767                 continue;
 768
 769             int nDepth = pcoin->GetDepthInMainChain();
 770             if (nDepth < (pcoin->IsFromMe() ? nConfMine : nConfTheirs))
 771                 continue;
 772
 773             for (int i = 0; i < pcoin->vout.size(); i++)
 774             {
 775                 if (pcoin->IsSpent(i) || !IsMine(pcoin->vout[i]))
 776                     continue;
 777
 778                 int64 n = pcoin->vout[i].nValue;
 779
 780                 if (n <= 0)
 781                     continue;
 782
 783                 pair<int64,pair<const CWalletTx*,unsigned int> > coin = make_pair(n,make_pair(pcoin,i));
 784
 785                 if (n == nTargetValue)
 786                 {
 787                     setCoinsRet.insert(coin.second);
 788                     nValueRet += coin.first;
 789                     return true;
 790                 }
 791                 else if (n < nTargetValue + CENT)
 792                 {
 793                     vValue.push_back(coin);
 794                     nTotalLower += n;
 795                 }
 796                 else if (n < coinLowestLarger.first)
 797                 {
 798                     coinLowestLarger = coin;
 799                 }
 800             }
 801         }
 802     }
 803
 804     if (nTotalLower == nTargetValue || nTotalLower == nTargetValue + CENT)
 805     {
 806         for (int i = 0; i < vValue.size(); ++i)
 807         {
 808             setCoinsRet.insert(vValue[i].second);
 809             nValueRet += vValue[i].first;
 810         }
 811         return true;
 812     }
 813
 814     if (nTotalLower < nTargetValue + (coinLowestLarger.second.first ? CENT : 0))
 815     {
 816         if (coinLowestLarger.second.first == NULL)
 817             return false;
 818         setCoinsRet.insert(coinLowestLarger.second);
 819         nValueRet += coinLowestLarger.first;
 820         return true;
 821     }
 822
 823     if (nTotalLower >= nTargetValue + CENT)
 824         nTargetValue += CENT;
 825
 826     // Solve subset sum by stochastic approximation
 827     sort(vValue.rbegin(), vValue.rend());
 828     vector<char> vfIncluded;
 829     vector<char> vfBest(vValue.size(), true);
 830     int64 nBest = nTotalLower;
 831
 832     for (int nRep = 0; nRep < 1000 && nBest != nTargetValue; nRep++)
 833     {
 834         vfIncluded.assign(vValue.size(), false);
 835         int64 nTotal = 0;
 836         bool fReachedTarget = false;
 837         for (int nPass = 0; nPass < 2 && !fReachedTarget; nPass++)
 838         {
 839             for (int i = 0; i < vValue.size(); i++)
 840             {
 841                 if (nPass == 0 ? rand() % 2 : !vfIncluded[i])
 842                 {
 843                     nTotal += vValue[i].first;
 844                     vfIncluded[i] = true;
 845                     if (nTotal >= nTargetValue)
 846                     {
 847                         fReachedTarget = true;
 848                         if (nTotal < nBest)
 849                         {
 850                             nBest = nTotal;
 851                             vfBest = vfIncluded;
 852                         }
 853                         nTotal -= vValue[i].first;
 854                         vfIncluded[i] = false;
 855                     }
 856                 }
 857             }
 858         }
 859     }
 860
 861     // If the next larger is still closer, return it
 862     if (coinLowestLarger.second.first && coinLowestLarger.first - nTargetValue <= nBest - nTargetValue)
 863     {
 864         setCoinsRet.insert(coinLowestLarger.second);
 865         nValueRet += coinLowestLarger.first;
 866     }
 867     else {
 868         for (int i = 0; i < vValue.size(); i++)
 869             if (vfBest[i])
 870             {
 871                 setCoinsRet.insert(vValue[i].second);
 872                 nValueRet += vValue[i].first;
 873             }
 874
 875         //// debug print
 876         printf("SelectCoins() best subset: ");
 877         for (int i = 0; i < vValue.size(); i++)
 878             if (vfBest[i])
 879                 printf("%s ", FormatMoney(vValue[i].first).c_str());
 880         printf("total %s\n", FormatMoney(nBest).c_str());
 881     }
 882
 883     return true;
 884 }
 885
 886 bool CWallet::SelectCoins(int64 nTargetValue, set<pair<const CWalletTx*,unsigned int> >& setCoinsRet, int64& nValueRet) const
 887 {
 888     return (SelectCoinsMinConf(nTargetValue, 1, 6, setCoinsRet, nValueRet) ||
 889             SelectCoinsMinConf(nTargetValue, 1, 1, setCoinsRet, nValueRet) ||
 890             SelectCoinsMinConf(nTargetValue, 0, 1, setCoinsRet, nValueRet));
 891 }
 892
 893
 894
 895
 896 bool CWallet::CreateTransaction(const vector<pair<CScript, int64> >& vecSend, CWalletTx& wtxNew, CReserveKey& reservekey, int64& nFeeRet)
 897 {
 898     int64 nValue = 0;
 899     BOOST_FOREACH (const PAIRTYPE(CScript, int64)& s, vecSend)
 900     {
 901         if (nValue < 0)
 902             return false;
 903         nValue += s.second;
 904     }
 905     if (vecSend.empty() || nValue < 0)
 906         return false;
 907
 908     wtxNew.pwallet = this;
 909
 910     CRITICAL_BLOCK(cs_main)
 911     CRITICAL_BLOCK(cs_wallet)
 912     {
 913         // txdb must be opened before the mapWallet lock
 914         CTxDB txdb("r");
 915         {
 916             nFeeRet = nTransactionFee;
 917             loop
 918             {
 919                 wtxNew.vin.clear();
 920                 wtxNew.vout.clear();
 921                 wtxNew.fFromMe = true;
 922
 923                 int64 nTotalValue = nValue + nFeeRet;
 924                 double dPriority = 0;
 925                 // vouts to the payees
 926                 BOOST_FOREACH (const PAIRTYPE(CScript, int64)& s, vecSend)
 927                     wtxNew.vout.push_back(CTxOut(s.second, s.first));
 928
 929                 // Choose coins to use
 930                 set<pair<const CWalletTx*,unsigned int> > setCoins;
 931                 int64 nValueIn = 0;
 932                 if (!SelectCoins(nTotalValue, setCoins, nValueIn))
 933                     return false;
 934                 BOOST_FOREACH(PAIRTYPE(const CWalletTx*, unsigned int) pcoin, setCoins)
 935                 {
 936                     int64 nCredit = pcoin.first->vout[pcoin.second].nValue;
 937                     dPriority += (double)nCredit * pcoin.first->GetDepthInMainChain();
 938                 }
 939
 940                 int64 nChange = nValueIn - nValue - nFeeRet;
 941                 // if sub-cent change is required, the fee must be raised to at least MIN_TX_FEE
 942                 // or until nChange becomes zero
 943                 if (nFeeRet < MIN_TX_FEE && nChange > 0 && nChange < CENT)
 944                 {
 945                     int64 nMoveToFee = min(nChange, MIN_TX_FEE - nFeeRet);
 946                     nChange -= nMoveToFee;
 947                     nFeeRet += nMoveToFee;
 948                 }
 949
 950                 if (nChange > 0)
 951                 {
 952                     // Note: We use a new key here to keep it from being obvious which side is the change.
 953                     //  The drawback is that by not reusing a previous key, the change may be lost if a
 954                     //  backup is restored, if the backup doesn't have the new private key for the change.
 955                     //  If we reused the old key, it would be possible to add code to look for and
 956                     //  rediscover unknown transactions that were written with keys of ours to recover
 957                     //  post-backup change.
 958
 959                     // Reserve a new key pair from key pool
 960                     vector<unsigned char> vchPubKey = reservekey.GetReservedKey();
 961                     // assert(mapKeys.count(vchPubKey));
 962
 963                     // Fill a vout to ourself, using same address type as the payment
 964                     CScript scriptChange;
 965                     if (vecSend[0].first.GetBitcoinAddress().IsValid())
 966                         scriptChange.SetBitcoinAddress(vchPubKey);
 967                     else
 968                         scriptChange << vchPubKey << OP_CHECKSIG;
 969
 970                     // Insert change txn at random position:
 971                     vector<CTxOut>::iterator position = wtxNew.vout.begin()+GetRandInt(wtxNew.vout.size());
 972                     wtxNew.vout.insert(position, CTxOut(nChange, scriptChange));
 973                 }
 974                 else
 975                     reservekey.ReturnKey();
 976
 977                 // Fill vin
 978                 BOOST_FOREACH(const PAIRTYPE(const CWalletTx*,unsigned int)& coin, setCoins)
 979                     wtxNew.vin.push_back(CTxIn(coin.first->GetHash(),coin.second));
 980
 981                 // Sign
 982                 int nIn = 0;
 983                 BOOST_FOREACH(const PAIRTYPE(const CWalletTx*,unsigned int)& coin, setCoins)
 984                     if (!SignSignature(*this, *coin.first, wtxNew, nIn++))
 985                         return false;
 986
 987                 // Limit size
 988                 unsigned int nBytes = ::GetSerializeSize(*(CTransaction*)&wtxNew, SER_NETWORK);
 989                 if (nBytes >= MAX_BLOCK_SIZE_GEN/5)
 990                     return false;
 991                 dPriority /= nBytes;
 992
 993                 // Check that enough fee is included
 994                 int64 nPayFee = nTransactionFee * (1 + (int64)nBytes / 1000);
 995                 bool fAllowFree = CTransaction::AllowFree(dPriority);
 996                 int64 nMinFee = wtxNew.GetMinFee(1, fAllowFree);
 997                 if (nFeeRet < max(nPayFee, nMinFee))
 998                 {
 999                     nFeeRet = max(nPayFee, nMinFee);
1000                     continue;
1001                 }
1002
1003                 // Fill vtxPrev by copying from previous transactions vtxPrev
1004                 wtxNew.AddSupportingTransactions(txdb);
1005                 wtxNew.fTimeReceivedIsTxTime = true;
1006
1007                 break;
1008             }
1009         }
1010     }
1011     return true;
1012 }
1013
1014 bool CWallet::CreateTransaction(CScript scriptPubKey, int64 nValue, CWalletTx& wtxNew, CReserveKey& reservekey, int64& nFeeRet)
1015 {
1016     vector< pair<CScript, int64> > vecSend;
1017     vecSend.push_back(make_pair(scriptPubKey, nValue));
1018     return CreateTransaction(vecSend, wtxNew, reservekey, nFeeRet);
1019 }
1020
1021 // Call after CreateTransaction unless you want to abort
1022 bool CWallet::CommitTransaction(CWalletTx& wtxNew, CReserveKey& reservekey)
1023 {
1024     CRITICAL_BLOCK(cs_main)
1025     CRITICAL_BLOCK(cs_wallet)
1026     {
1027         printf("CommitTransaction:\n%s", wtxNew.ToString().c_str());
1028         {
1029             // This is only to keep the database open to defeat the auto-flush for the
1030             // duration of this scope.  This is the only place where this optimization
1031             // maybe makes sense; please don't do it anywhere else.
1032             CWalletDB* pwalletdb = fFileBacked ? new CWalletDB(strWalletFile,"r") : NULL;
1033
1034             // Take key pair from key pool so it won't be used again
1035             reservekey.KeepKey();
1036
1037             // Add tx to wallet, because if it has change it's also ours,
1038             // otherwise just for transaction history.
1039             AddToWallet(wtxNew);
1040
1041             // Mark old coins as spent
1042             set<CWalletTx*> setCoins;
1043             BOOST_FOREACH(const CTxIn& txin, wtxNew.vin)
1044             {
1045                 CWalletTx &coin = mapWallet[txin.prevout.hash];
1046                 coin.pwallet = this;
1047                 coin.MarkSpent(txin.prevout.n);
1048                 coin.WriteToDisk();
1049                 vWalletUpdated.push_back(coin.GetHash());
1050             }
1051
1052             if (fFileBacked)
1053                 delete pwalletdb;
1054         }
1055
1056         // Track how many getdata requests our transaction gets
1057         mapRequestCount[wtxNew.GetHash()] = 0;
1058
1059         // Broadcast
1060         if (!wtxNew.AcceptToMemoryPool())
1061         {
1062             // This must not fail. The transaction has already been signed and recorded.
1063             printf("CommitTransaction() : Error: Transaction not valid");
1064             return false;
1065         }
1066         wtxNew.RelayWalletTransaction();
1067     }
1068     MainFrameRepaint();
1069     return true;
1070 }
1071
1072
1073
1074
1075 string CWallet::SendMoney(CScript scriptPubKey, int64 nValue, CWalletTx& wtxNew, bool fAskFee)
1076 {
1077     CReserveKey reservekey(this);
1078     int64 nFeeRequired;
1079
1080     if (IsLocked())
1081     {
1082         string strError = _("Error: Wallet locked, unable to create transaction  ");
1083         printf("SendMoney() : %s", strError.c_str());
1084         return strError;
1085     }
1086     if (!CreateTransaction(scriptPubKey, nValue, wtxNew, reservekey, nFeeRequired))
1087     {
1088         string strError;
1089         if (nValue + nFeeRequired > GetBalance())
1090             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());
1091         else
1092             strError = _("Error: Transaction creation failed  ");
1093         printf("SendMoney() : %s", strError.c_str());
1094         return strError;
1095     }
1096
1097     if (fAskFee && !ThreadSafeAskFee(nFeeRequired, _("Sending..."), NULL))
1098         return "ABORTED";
1099
1100     if (!CommitTransaction(wtxNew, reservekey))
1101         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.");
1102
1103     MainFrameRepaint();
1104     return "";
1105 }
1106
1107
1108
1109 string CWallet::SendMoneyToBitcoinAddress(const CBitcoinAddress& address, int64 nValue, CWalletTx& wtxNew, bool fAskFee)
1110 {
1111     // Check amount
1112     if (nValue <= 0)
1113         return _("Invalid amount");
1114     if (nValue + nTransactionFee > GetBalance())
1115         return _("Insufficient funds");
1116
1117     // Parse bitcoin address
1118     CScript scriptPubKey;
1119     scriptPubKey.SetBitcoinAddress(address);
1120
1121     return SendMoney(scriptPubKey, nValue, wtxNew, fAskFee);
1122 }
1123
1124
1125
1126
1127 int CWallet::LoadWallet(bool& fFirstRunRet)
1128 {
1129     if (!fFileBacked)
1130         return false;
1131     fFirstRunRet = false;
1132     int nLoadWalletRet = CWalletDB(strWalletFile,"cr+").LoadWallet(this);
1133     if (nLoadWalletRet == DB_NEED_REWRITE)
1134     {
1135         if (CDB::Rewrite(strWalletFile, "\x04pool"))
1136         {
1137             RemoveLogFilesOnShutdown(true);
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