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