src/wallet.cpp

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