src/main.h

   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 #ifndef BITCOIN_MAIN_H
   6 #define BITCOIN_MAIN_H
   7
   8 #include "timestamps.h"
   9 #include "bignum.h"
  10 #include "sync.h"
  11 #include "net.h"
  12 #include "script.h"
  13 #include "scrypt.h"
  14 #include "zerocoin/Zerocoin.h"
  15
  16 #include <list>
  17
  18 class CWallet;
  19 class CBlock;
  20 class CBlockIndex;
  21 class CKeyItem;
  22 class CReserveKey;
  23 class COutPoint;
  24
  25 class CAddress;
  26 class CInv;
  27 class CRequestTracker;
  28 class CNode;
  29
  30 static const unsigned int MAX_BLOCK_SIZE = 1000000;
  31 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
  32 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
  33 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
  34 static const unsigned int MAX_INV_SZ = 50000;
  35
  36 static const int64 MIN_TX_FEE = CENT/10;
  37 static const int64 MIN_RELAY_TX_FEE = CENT/50;
  38
  39 static const int64 MAX_MONEY = 2000000000 * COIN;
  40 static const int64 MAX_MINT_PROOF_OF_WORK = 100 * COIN;
  41 static const int64 MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
  42 static const int64 MIN_TXOUT_AMOUNT = CENT/100;
  43
  44 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
  45 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
  46 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov  5 00:53:20 1985 UTC
  47 // Maximum number of script-checking threads allowed
  48 static const int MAX_SCRIPTCHECK_THREADS = 16;
  49
  50 #ifdef USE_UPNP
  51 static const int fHaveUPnP = true;
  52 #else
  53 static const int fHaveUPnP = false;
  54 #endif
  55
  56 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
  57 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
  58
  59 inline int64 PastDrift(int64 nTime)   { return nTime - 2 * 60 * 60; } // up to 2 hours from the past
  60 inline int64 FutureDrift(int64 nTime) { return nTime + 2 * 60 * 60; } // up to 2 hours from the future
  61
  62 extern libzerocoin::Params* ZCParams;
  63 extern CScript COINBASE_FLAGS;
  64 extern CCriticalSection cs_main;
  65 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
  66 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
  67 extern CBlockIndex* pindexGenesisBlock;
  68 extern unsigned int nStakeMinAge;
  69 extern unsigned int nNodeLifespan;
  70 extern int nCoinbaseMaturity;
  71 extern int nBestHeight;
  72 extern uint256 nBestChainTrust;
  73 extern uint256 nBestInvalidTrust;
  74 extern uint256 hashBestChain;
  75 extern CBlockIndex* pindexBest;
  76 extern unsigned int nTransactionsUpdated;
  77 extern uint64 nLastBlockTx;
  78 extern uint64 nLastBlockSize;
  79 extern int64 nLastCoinStakeSearchInterval;
  80 extern const std::string strMessageMagic;
  81 extern int64 nTimeBestReceived;
  82 extern CCriticalSection cs_setpwalletRegistered;
  83 extern std::set<CWallet*> setpwalletRegistered;
  84 extern unsigned char pchMessageStart[4];
  85 extern std::map<uint256, CBlock*> mapOrphanBlocks;
  86
  87 // Settings
  88 extern int64 nTransactionFee;
  89 extern int64 nMinimumInputValue;
  90 extern bool fUseFastIndex;
  91 extern unsigned int nDerivationMethodIndex;
  92 extern int nScriptCheckThreads;
  93
  94 // Minimum disk space required - used in CheckDiskSpace()
  95 static const uint64 nMinDiskSpace = 52428800;
  96
  97 class CReserveKey;
  98 class CTxDB;
  99 class CTxIndex;
 100 class CScriptCheck;
 101
 102 void RegisterWallet(CWallet* pwalletIn);
 103 void UnregisterWallet(CWallet* pwalletIn);
 104 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
 105 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
 106 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
 107 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
 108 FILE* AppendBlockFile(unsigned int& nFileRet);
 109 bool LoadBlockIndex(bool fAllowNew=true);
 110 void PrintBlockTree();
 111 CBlockIndex* FindBlockByHeight(int nHeight);
 112 bool ProcessMessages(CNode* pfrom);
 113 bool SendMessages(CNode* pto, bool fSendTrickle);
 114 bool LoadExternalBlockFile(FILE* fileIn);
 115
 116 // Run an instance of the script checking thread
 117 void ThreadScriptCheck(void* parg);
 118 // Stop the script checking threads
 119 void ThreadScriptCheckQuit();
 120
 121 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
 122 unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, bool fProofOfStake);
 123 int64 GetProofOfWorkReward(unsigned int nBits, int64 nFees=0);
 124 int64 GetProofOfStakeReward(int64 nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly=false);
 125 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
 126 unsigned int ComputeMinStake(unsigned int nBase, int64 nTime, unsigned int nBlockTime);
 127 int GetNumBlocksOfPeers();
 128 bool IsInitialBlockDownload();
 129 std::string GetWarnings(std::string strFor);
 130 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
 131 uint256 WantedByOrphan(const CBlock* pblockOrphan);
 132 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
 133 void StakeMiner(CWallet *pwallet);
 134 void ResendWalletTransactions();
 135
 136 bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType);
 137
 138
 139
 140
 141
 142
 143
 144 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
 145
 146 /** Position on disk for a particular transaction. */
 147 class CDiskTxPos
 148 {
 149 public:
 150     unsigned int nFile;
 151     unsigned int nBlockPos;
 152     unsigned int nTxPos;
 153
 154     CDiskTxPos()
 155     {
 156         SetNull();
 157     }
 158
 159     CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
 160     {
 161         nFile = nFileIn;
 162         nBlockPos = nBlockPosIn;
 163         nTxPos = nTxPosIn;
 164     }
 165
 166     IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
 167     void SetNull() { nFile = (unsigned int) -1; nBlockPos = 0; nTxPos = 0; }
 168     bool IsNull() const { return (nFile == (unsigned int) -1); }
 169
 170     friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
 171     {
 172         return (a.nFile     == b.nFile &&
 173                 a.nBlockPos == b.nBlockPos &&
 174                 a.nTxPos    == b.nTxPos);
 175     }
 176
 177     friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
 178     {
 179         return !(a == b);
 180     }
 181
 182
 183     std::string ToString() const
 184     {
 185         if (IsNull())
 186             return "null";
 187         else
 188             return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
 189     }
 190
 191     void print() const
 192     {
 193         printf("%s", ToString().c_str());
 194     }
 195 };
 196
 197
 198
 199 /** An inpoint - a combination of a transaction and an index n into its vin */
 200 class CInPoint
 201 {
 202 public:
 203     CTransaction* ptx;
 204     unsigned int n;
 205
 206     CInPoint() { SetNull(); }
 207     CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
 208     void SetNull() { ptx = NULL; n = (unsigned int) -1; }
 209     bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
 210 };
 211
 212
 213
 214 /** An outpoint - a combination of a transaction hash and an index n into its vout */
 215 class COutPoint
 216 {
 217 public:
 218     uint256 hash;
 219     unsigned int n;
 220
 221     COutPoint() { SetNull(); }
 222     COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
 223     IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
 224     void SetNull() { hash = 0; n = (unsigned int) -1; }
 225     bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
 226
 227     friend bool operator<(const COutPoint& a, const COutPoint& b)
 228     {
 229         return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
 230     }
 231
 232     friend bool operator==(const COutPoint& a, const COutPoint& b)
 233     {
 234         return (a.hash == b.hash && a.n == b.n);
 235     }
 236
 237     friend bool operator!=(const COutPoint& a, const COutPoint& b)
 238     {
 239         return !(a == b);
 240     }
 241
 242     std::string ToString() const
 243     {
 244         return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
 245     }
 246
 247     void print() const
 248     {
 249         printf("%s\n", ToString().c_str());
 250     }
 251 };
 252
 253
 254
 255
 256 /** An input of a transaction.  It contains the location of the previous
 257  * transaction's output that it claims and a signature that matches the
 258  * output's public key.
 259  */
 260 class CTxIn
 261 {
 262 public:
 263     COutPoint prevout;
 264     CScript scriptSig;
 265     unsigned int nSequence;
 266
 267     CTxIn()
 268     {
 269         nSequence = std::numeric_limits<unsigned int>::max();
 270     }
 271
 272     explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
 273     {
 274         prevout = prevoutIn;
 275         scriptSig = scriptSigIn;
 276         nSequence = nSequenceIn;
 277     }
 278
 279     CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
 280     {
 281         prevout = COutPoint(hashPrevTx, nOut);
 282         scriptSig = scriptSigIn;
 283         nSequence = nSequenceIn;
 284     }
 285
 286     IMPLEMENT_SERIALIZE
 287     (
 288         READWRITE(prevout);
 289         READWRITE(scriptSig);
 290         READWRITE(nSequence);
 291     )
 292
 293     bool IsFinal() const
 294     {
 295         return (nSequence == std::numeric_limits<unsigned int>::max());
 296     }
 297
 298     friend bool operator==(const CTxIn& a, const CTxIn& b)
 299     {
 300         return (a.prevout   == b.prevout &&
 301                 a.scriptSig == b.scriptSig &&
 302                 a.nSequence == b.nSequence);
 303     }
 304
 305     friend bool operator!=(const CTxIn& a, const CTxIn& b)
 306     {
 307         return !(a == b);
 308     }
 309
 310     std::string ToStringShort() const
 311     {
 312         return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
 313     }
 314
 315     std::string ToString() const
 316     {
 317         std::string str;
 318         str += "CTxIn(";
 319         str += prevout.ToString();
 320         if (prevout.IsNull())
 321             str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
 322         else
 323             str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
 324         if (nSequence != std::numeric_limits<unsigned int>::max())
 325             str += strprintf(", nSequence=%u", nSequence);
 326         str += ")";
 327         return str;
 328     }
 329
 330     void print() const
 331     {
 332         printf("%s\n", ToString().c_str());
 333     }
 334 };
 335
 336
 337
 338
 339 /** An output of a transaction.  It contains the public key that the next input
 340  * must be able to sign with to claim it.
 341  */
 342 class CTxOut
 343 {
 344 public:
 345     int64 nValue;
 346     CScript scriptPubKey;
 347
 348     CTxOut()
 349     {
 350         SetNull();
 351     }
 352
 353     CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
 354     {
 355         nValue = nValueIn;
 356         scriptPubKey = scriptPubKeyIn;
 357     }
 358
 359     IMPLEMENT_SERIALIZE
 360     (
 361         READWRITE(nValue);
 362         READWRITE(scriptPubKey);
 363     )
 364
 365     void SetNull()
 366     {
 367         nValue = -1;
 368         scriptPubKey.clear();
 369     }
 370
 371     bool IsNull()
 372     {
 373         return (nValue == -1);
 374     }
 375
 376     void SetEmpty()
 377     {
 378         nValue = 0;
 379         scriptPubKey.clear();
 380     }
 381
 382     bool IsEmpty() const
 383     {
 384         return (nValue == 0 && scriptPubKey.empty());
 385     }
 386
 387     uint256 GetHash() const
 388     {
 389         return SerializeHash(*this);
 390     }
 391
 392     friend bool operator==(const CTxOut& a, const CTxOut& b)
 393     {
 394         return (a.nValue       == b.nValue &&
 395                 a.scriptPubKey == b.scriptPubKey);
 396     }
 397
 398     friend bool operator!=(const CTxOut& a, const CTxOut& b)
 399     {
 400         return !(a == b);
 401     }
 402
 403     std::string ToStringShort() const
 404     {
 405         return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
 406     }
 407
 408     std::string ToString() const
 409     {
 410         if (IsEmpty()) return "CTxOut(empty)";
 411         if (scriptPubKey.size() < 6)
 412             return "CTxOut(error)";
 413         return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
 414     }
 415
 416     void print() const
 417     {
 418         printf("%s\n", ToString().c_str());
 419     }
 420 };
 421
 422
 423
 424
 425 enum GetMinFee_mode
 426 {
 427     GMF_BLOCK,
 428     GMF_RELAY,
 429     GMF_SEND,
 430 };
 431
 432 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
 433
 434 /** The basic transaction that is broadcasted on the network and contained in
 435  * blocks.  A transaction can contain multiple inputs and outputs.
 436  */
 437 class CTransaction
 438 {
 439 public:
 440     static const int CURRENT_VERSION=1;
 441     int nVersion;
 442     unsigned int nTime;
 443     std::vector<CTxIn> vin;
 444     std::vector<CTxOut> vout;
 445     unsigned int nLockTime;
 446
 447     // Denial-of-service detection:
 448     mutable int nDoS;
 449     bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
 450
 451     CTransaction()
 452     {
 453         SetNull();
 454     }
 455
 456     IMPLEMENT_SERIALIZE
 457     (
 458         READWRITE(this->nVersion);
 459         nVersion = this->nVersion;
 460         READWRITE(nTime);
 461         READWRITE(vin);
 462         READWRITE(vout);
 463         READWRITE(nLockTime);
 464     )
 465
 466     void SetNull()
 467     {
 468         nVersion = CTransaction::CURRENT_VERSION;
 469         nTime = GetAdjustedTime();
 470         vin.clear();
 471         vout.clear();
 472         nLockTime = 0;
 473         nDoS = 0;  // Denial-of-service prevention
 474     }
 475
 476     bool IsNull() const
 477     {
 478         return (vin.empty() && vout.empty());
 479     }
 480
 481     uint256 GetHash() const
 482     {
 483         return SerializeHash(*this);
 484     }
 485
 486     bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
 487     {
 488         // Time based nLockTime implemented in 0.1.6
 489         if (nLockTime == 0)
 490             return true;
 491         if (nBlockHeight == 0)
 492             nBlockHeight = nBestHeight;
 493         if (nBlockTime == 0)
 494             nBlockTime = GetAdjustedTime();
 495         if ((int64)nLockTime < ((int64)nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
 496             return true;
 497         BOOST_FOREACH(const CTxIn& txin, vin)
 498             if (!txin.IsFinal())
 499                 return false;
 500         return true;
 501     }
 502
 503     bool IsNewerThan(const CTransaction& old) const
 504     {
 505         if (vin.size() != old.vin.size())
 506             return false;
 507         for (unsigned int i = 0; i < vin.size(); i++)
 508             if (vin[i].prevout != old.vin[i].prevout)
 509                 return false;
 510
 511         bool fNewer = false;
 512         unsigned int nLowest = std::numeric_limits<unsigned int>::max();
 513         for (unsigned int i = 0; i < vin.size(); i++)
 514         {
 515             if (vin[i].nSequence != old.vin[i].nSequence)
 516             {
 517                 if (vin[i].nSequence <= nLowest)
 518                 {
 519                     fNewer = false;
 520                     nLowest = vin[i].nSequence;
 521                 }
 522                 if (old.vin[i].nSequence < nLowest)
 523                 {
 524                     fNewer = true;
 525                     nLowest = old.vin[i].nSequence;
 526                 }
 527             }
 528         }
 529         return fNewer;
 530     }
 531
 532     bool IsCoinBase() const
 533     {
 534         return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
 535     }
 536
 537     bool IsCoinStake() const
 538     {
 539         // ppcoin: the coin stake transaction is marked with the first output empty
 540         return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
 541     }
 542
 543     /** Check for standard transaction types
 544         @return True if all outputs (scriptPubKeys) use only standard transaction forms
 545     */
 546     bool IsStandard() const;
 547
 548     /** Check for standard transaction types
 549         @param[in] mapInputs    Map of previous transactions that have outputs we're spending
 550         @return True if all inputs (scriptSigs) use only standard transaction forms
 551         @see CTransaction::FetchInputs
 552     */
 553     bool AreInputsStandard(const MapPrevTx& mapInputs) const;
 554
 555     /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
 556         @return number of sigops this transaction's outputs will produce when spent
 557         @see CTransaction::FetchInputs
 558     */
 559     unsigned int GetLegacySigOpCount() const;
 560
 561     /** Count ECDSA signature operations in pay-to-script-hash inputs.
 562
 563         @param[in] mapInputs    Map of previous transactions that have outputs we're spending
 564         @return maximum number of sigops required to validate this transaction's inputs
 565         @see CTransaction::FetchInputs
 566      */
 567     unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
 568
 569     /** Amount of bitcoins spent by this transaction.
 570         @return sum of all outputs (note: does not include fees)
 571      */
 572     int64 GetValueOut() const
 573     {
 574         int64 nValueOut = 0;
 575         BOOST_FOREACH(const CTxOut& txout, vout)
 576         {
 577             nValueOut += txout.nValue;
 578             if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
 579                 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
 580         }
 581         return nValueOut;
 582     }
 583
 584     /** Amount of bitcoins coming in to this transaction
 585         Note that lightweight clients may not know anything besides the hash of previous transactions,
 586         so may not be able to calculate this.
 587
 588         @param[in] mapInputs    Map of previous transactions that have outputs we're spending
 589         @return Sum of value of all inputs (scriptSigs)
 590         @see CTransaction::FetchInputs
 591      */
 592     int64 GetValueIn(const MapPrevTx& mapInputs) const;
 593
 594     static bool AllowFree(double dPriority)
 595     {
 596         // Large (in bytes) low-priority (new, small-coin) transactions
 597         // need a fee.
 598         return dPriority > COIN * 144 / 250;
 599     }
 600
 601     int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK, unsigned int nBytes = 0) const;
 602
 603     bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
 604     {
 605         CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
 606         if (!filein)
 607             return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
 608
 609         // Read transaction
 610         if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
 611             return error("CTransaction::ReadFromDisk() : fseek failed");
 612
 613         try {
 614             filein >> *this;
 615         }
 616         catch (std::exception &e) {
 617             return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
 618         }
 619
 620         // Return file pointer
 621         if (pfileRet)
 622         {
 623             if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
 624                 return error("CTransaction::ReadFromDisk() : second fseek failed");
 625             *pfileRet = filein.release();
 626         }
 627         return true;
 628     }
 629
 630     friend bool operator==(const CTransaction& a, const CTransaction& b)
 631     {
 632         return (a.nVersion  == b.nVersion &&
 633                 a.nTime     == b.nTime &&
 634                 a.vin       == b.vin &&
 635                 a.vout      == b.vout &&
 636                 a.nLockTime == b.nLockTime);
 637     }
 638
 639     friend bool operator!=(const CTransaction& a, const CTransaction& b)
 640     {
 641         return !(a == b);
 642     }
 643
 644     std::string ToStringShort() const
 645     {
 646         std::string str;
 647         str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
 648         return str;
 649     }
 650
 651     std::string ToString() const
 652     {
 653         std::string str;
 654         str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
 655         str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%"PRIszu", vout.size=%"PRIszu", nLockTime=%d)\n",
 656             GetHash().ToString().substr(0,10).c_str(),
 657             nTime,
 658             nVersion,
 659             vin.size(),
 660             vout.size(),
 661             nLockTime);
 662         for (unsigned int i = 0; i < vin.size(); i++)
 663             str += "    " + vin[i].ToString() + "\n";
 664         for (unsigned int i = 0; i < vout.size(); i++)
 665             str += "    " + vout[i].ToString() + "\n";
 666         return str;
 667     }
 668
 669     void print() const
 670     {
 671         printf("%s", ToString().c_str());
 672     }
 673
 674
 675     bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
 676     bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
 677     bool ReadFromDisk(COutPoint prevout);
 678     bool DisconnectInputs(CTxDB& txdb);
 679
 680     /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
 681
 682      @param[in] txdb    Transaction database
 683      @param[in] mapTestPool     List of pending changes to the transaction index database
 684      @param[in] fBlock  True if being called to add a new best-block to the chain
 685      @param[in] fMiner  True if being called by CreateNewBlock
 686      @param[out] inputsRet      Pointers to this transaction's inputs
 687      @param[out] fInvalid       returns true if transaction is invalid
 688      @return    Returns true if all inputs are in txdb or mapTestPool
 689      */
 690     bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
 691                      bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
 692
 693     /** Sanity check previous transactions, then, if all checks succeed,
 694         mark them as spent by this transaction.
 695
 696         @param[in] inputs       Previous transactions (from FetchInputs)
 697         @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
 698         @param[in] posThisTx    Position of this transaction on disk
 699         @param[in] pindexBlock
 700         @param[in] fBlock       true if called from ConnectBlock
 701         @param[in] fMiner       true if called from CreateNewBlock
 702         @param[in] fStrictPayToScriptHash       true if fully validating p2sh transactions
 703         @return Returns true if all checks succeed
 704      */
 705     bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs,
 706                        std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
 707                        const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fScriptChecks=true, unsigned int flags=STANDARD_SCRIPT_VERIFY_FLAGS, std::vector<CScriptCheck> *pvChecks = NULL);
 708     bool ClientConnectInputs();
 709     bool CheckTransaction() const;
 710     bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
 711     bool GetCoinAge(CTxDB& txdb, uint64& nCoinAge) const;  // ppcoin: get transaction coin age
 712
 713 protected:
 714     const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
 715 };
 716
 717 /** Closure representing one script verification
 718  *  Note that this stores references to the spending transaction */
 719 class CScriptCheck
 720 {
 721 private:
 722     CScript scriptPubKey;
 723     const CTransaction *ptxTo;
 724     unsigned int nIn;
 725     unsigned int nFlags;
 726     int nHashType;
 727
 728 public:
 729     CScriptCheck() {}
 730     CScriptCheck(const CTransaction& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, int nHashTypeIn) :
 731         scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey),
 732         ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), nHashType(nHashTypeIn) { }
 733
 734     bool operator()() const;
 735
 736     void swap(CScriptCheck &check) {
 737         scriptPubKey.swap(check.scriptPubKey);
 738         std::swap(ptxTo, check.ptxTo);
 739         std::swap(nIn, check.nIn);
 740         std::swap(nFlags, check.nFlags);
 741         std::swap(nHashType, check.nHashType);
 742     }
 743 };
 744
 745
 746
 747
 748 /** A transaction with a merkle branch linking it to the block chain. */
 749 class CMerkleTx : public CTransaction
 750 {
 751 public:
 752     uint256 hashBlock;
 753     std::vector<uint256> vMerkleBranch;
 754     int nIndex;
 755
 756     // memory only
 757     mutable bool fMerkleVerified;
 758
 759
 760     CMerkleTx()
 761     {
 762         Init();
 763     }
 764
 765     CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
 766     {
 767         Init();
 768     }
 769
 770     void Init()
 771     {
 772         hashBlock = 0;
 773         nIndex = -1;
 774         fMerkleVerified = false;
 775     }
 776
 777
 778     IMPLEMENT_SERIALIZE
 779     (
 780         nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
 781         nVersion = this->nVersion;
 782         READWRITE(hashBlock);
 783         READWRITE(vMerkleBranch);
 784         READWRITE(nIndex);
 785     )
 786
 787
 788     int SetMerkleBranch(const CBlock* pblock=NULL);
 789     int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
 790     int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
 791     bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
 792     int GetBlocksToMaturity() const;
 793     bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
 794     bool AcceptToMemoryPool();
 795 };
 796
 797
 798
 799
 800 /**  A txdb record that contains the disk location of a transaction and the
 801  * locations of transactions that spend its outputs.  vSpent is really only
 802  * used as a flag, but having the location is very helpful for debugging.
 803  */
 804 class CTxIndex
 805 {
 806 public:
 807     CDiskTxPos pos;
 808     std::vector<CDiskTxPos> vSpent;
 809
 810     CTxIndex()
 811     {
 812         SetNull();
 813     }
 814
 815     CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
 816     {
 817         pos = posIn;
 818         vSpent.resize(nOutputs);
 819     }
 820
 821     IMPLEMENT_SERIALIZE
 822     (
 823         if (!(nType & SER_GETHASH))
 824             READWRITE(nVersion);
 825         READWRITE(pos);
 826         READWRITE(vSpent);
 827     )
 828
 829     void SetNull()
 830     {
 831         pos.SetNull();
 832         vSpent.clear();
 833     }
 834
 835     bool IsNull()
 836     {
 837         return pos.IsNull();
 838     }
 839
 840     friend bool operator==(const CTxIndex& a, const CTxIndex& b)
 841     {
 842         return (a.pos    == b.pos &&
 843                 a.vSpent == b.vSpent);
 844     }
 845
 846     friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
 847     {
 848         return !(a == b);
 849     }
 850     int GetDepthInMainChain() const;
 851
 852 };
 853
 854
 855
 856
 857
 858 /** Nodes collect new transactions into a block, hash them into a hash tree,
 859  * and scan through nonce values to make the block's hash satisfy proof-of-work
 860  * requirements.  When they solve the proof-of-work, they broadcast the block
 861  * to everyone and the block is added to the block chain.  The first transaction
 862  * in the block is a special one that creates a new coin owned by the creator
 863  * of the block.
 864  *
 865  * Blocks are appended to blk0001.dat files on disk.  Their location on disk
 866  * is indexed by CBlockIndex objects in memory.
 867  */
 868 class CBlock
 869 {
 870 public:
 871     // header
 872     static const int CURRENT_VERSION=6;
 873     int nVersion;
 874     uint256 hashPrevBlock;
 875     uint256 hashMerkleRoot;
 876     unsigned int nTime;
 877     unsigned int nBits;
 878     unsigned int nNonce;
 879
 880     // network and disk
 881     std::vector<CTransaction> vtx;
 882
 883     // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
 884     std::vector<unsigned char> vchBlockSig;
 885
 886     // memory only
 887     mutable std::vector<uint256> vMerkleTree;
 888
 889     // Denial-of-service detection:
 890     mutable int nDoS;
 891     bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
 892
 893     CBlock()
 894     {
 895         SetNull();
 896     }
 897
 898     IMPLEMENT_SERIALIZE
 899     (
 900         READWRITE(this->nVersion);
 901         nVersion = this->nVersion;
 902         READWRITE(hashPrevBlock);
 903         READWRITE(hashMerkleRoot);
 904         READWRITE(nTime);
 905         READWRITE(nBits);
 906         READWRITE(nNonce);
 907
 908         // ConnectBlock depends on vtx following header to generate CDiskTxPos
 909         if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
 910         {
 911             READWRITE(vtx);
 912             READWRITE(vchBlockSig);
 913         }
 914         else if (fRead)
 915         {
 916             const_cast<CBlock*>(this)->vtx.clear();
 917             const_cast<CBlock*>(this)->vchBlockSig.clear();
 918         }
 919     )
 920
 921     void SetNull()
 922     {
 923         nVersion = CBlock::CURRENT_VERSION;
 924         hashPrevBlock = 0;
 925         hashMerkleRoot = 0;
 926         nTime = 0;
 927         nBits = 0;
 928         nNonce = 0;
 929         vtx.clear();
 930         vchBlockSig.clear();
 931         vMerkleTree.clear();
 932         nDoS = 0;
 933     }
 934
 935     bool IsNull() const
 936     {
 937         return (nBits == 0);
 938     }
 939
 940     uint256 GetHash() const
 941     {
 942         return scrypt_blockhash(CVOIDBEGIN(nVersion));
 943     }
 944
 945     int64 GetBlockTime() const
 946     {
 947         return (int64)nTime;
 948     }
 949
 950     void UpdateTime(const CBlockIndex* pindexPrev);
 951
 952     // ppcoin: entropy bit for stake modifier if chosen by modifier
 953     unsigned int GetStakeEntropyBit(unsigned int nTime) const
 954     {
 955         // Protocol switch to support p2pool at novacoin block #9689
 956         if (nTime >= ENTROPY_SWITCH_TIME || fTestNet)
 957         {
 958             // Take last bit of block hash as entropy bit
 959             unsigned int nEntropyBit = ((GetHash().Get64()) & 1llu);
 960             if (fDebug && GetBoolArg("-printstakemodifier"))
 961                 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
 962             return nEntropyBit;
 963         }
 964         // Before novacoin block #9689 - old protocol
 965         uint160 hashSig = Hash160(vchBlockSig);
 966         if (fDebug && GetBoolArg("-printstakemodifier"))
 967             printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
 968         hashSig >>= 159; // take the first bit of the hash
 969         if (fDebug && GetBoolArg("-printstakemodifier"))
 970             printf(" entropybit=%"PRI64d"\n", hashSig.Get64());
 971         return hashSig.Get64();
 972     }
 973
 974     // ppcoin: two types of block: proof-of-work or proof-of-stake
 975     bool IsProofOfStake() const
 976     {
 977         return (vtx.size() > 1 && vtx[1].IsCoinStake());
 978     }
 979
 980     bool IsProofOfWork() const
 981     {
 982         return !IsProofOfStake();
 983     }
 984
 985     std::pair<COutPoint, unsigned int> GetProofOfStake() const
 986     {
 987         return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
 988     }
 989
 990     // ppcoin: get max transaction timestamp
 991     int64 GetMaxTransactionTime() const
 992     {
 993         int64 maxTransactionTime = 0;
 994         BOOST_FOREACH(const CTransaction& tx, vtx)
 995             maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
 996         return maxTransactionTime;
 997     }
 998
 999     uint256 BuildMerkleTree() const
1000     {
1001         vMerkleTree.clear();
1002         BOOST_FOREACH(const CTransaction& tx, vtx)
1003             vMerkleTree.push_back(tx.GetHash());
1004         int j = 0;
1005         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1006         {
1007             for (int i = 0; i < nSize; i += 2)
1008             {
1009                 int i2 = std::min(i+1, nSize-1);
1010                 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]),  END(vMerkleTree[j+i]),
1011                                            BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
1012             }
1013             j += nSize;
1014         }
1015         return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
1016     }
1017
1018     std::vector<uint256> GetMerkleBranch(int nIndex) const
1019     {
1020         if (vMerkleTree.empty())
1021             BuildMerkleTree();
1022         std::vector<uint256> vMerkleBranch;
1023         int j = 0;
1024         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1025         {
1026             int i = std::min(nIndex^1, nSize-1);
1027             vMerkleBranch.push_back(vMerkleTree[j+i]);
1028             nIndex >>= 1;
1029             j += nSize;
1030         }
1031         return vMerkleBranch;
1032     }
1033
1034     static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1035     {
1036         if (nIndex == -1)
1037             return 0;
1038         BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1039         {
1040             if (nIndex & 1)
1041                 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1042             else
1043                 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1044             nIndex >>= 1;
1045         }
1046         return hash;
1047     }
1048
1049
1050     bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1051     {
1052         // Open history file to append
1053         CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1054         if (!fileout)
1055             return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1056
1057         // Write index header
1058         unsigned int nSize = fileout.GetSerializeSize(*this);
1059         fileout << FLATDATA(pchMessageStart) << nSize;
1060
1061         // Write block
1062         long fileOutPos = ftell(fileout);
1063         if (fileOutPos < 0)
1064             return error("CBlock::WriteToDisk() : ftell failed");
1065         nBlockPosRet = fileOutPos;
1066         fileout << *this;
1067
1068         // Flush stdio buffers and commit to disk before returning
1069         fflush(fileout);
1070         if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1071             FileCommit(fileout);
1072
1073         return true;
1074     }
1075
1076     bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1077     {
1078         SetNull();
1079
1080         // Open history file to read
1081         CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1082         if (!filein)
1083             return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1084         if (!fReadTransactions)
1085             filein.nType |= SER_BLOCKHEADERONLY;
1086
1087         // Read block
1088         try {
1089             filein >> *this;
1090         }
1091         catch (std::exception &e) {
1092             return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1093         }
1094
1095         // Check the header
1096         if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1097             return error("CBlock::ReadFromDisk() : errors in block header");
1098
1099         return true;
1100     }
1101
1102
1103
1104     void print() const
1105     {
1106         printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu", vchBlockSig=%s)\n",
1107             GetHash().ToString().c_str(),
1108             nVersion,
1109             hashPrevBlock.ToString().c_str(),
1110             hashMerkleRoot.ToString().c_str(),
1111             nTime, nBits, nNonce,
1112             vtx.size(),
1113             HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1114         for (unsigned int i = 0; i < vtx.size(); i++)
1115         {
1116             printf("  ");
1117             vtx[i].print();
1118         }
1119         printf("  vMerkleTree: ");
1120         for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1121             printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1122         printf("\n");
1123     }
1124
1125
1126     bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1127     bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1128     bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1129     bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1130     bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1131     bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1132     bool AcceptBlock();
1133     bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1134     bool SignBlock(CWallet& keystore);
1135     bool CheckBlockSignature(bool fProofOfStake) const;
1136
1137 private:
1138     bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1139 };
1140
1141
1142
1143
1144
1145
1146 /** The block chain is a tree shaped structure starting with the
1147  * genesis block at the root, with each block potentially having multiple
1148  * candidates to be the next block.  pprev and pnext link a path through the
1149  * main/longest chain.  A blockindex may have multiple pprev pointing back
1150  * to it, but pnext will only point forward to the longest branch, or will
1151  * be null if the block is not part of the longest chain.
1152  */
1153 class CBlockIndex
1154 {
1155 public:
1156     const uint256* phashBlock;
1157     CBlockIndex* pprev;
1158     CBlockIndex* pnext;
1159     unsigned int nFile;
1160     unsigned int nBlockPos;
1161     uint256 nChainTrust; // ppcoin: trust score of block chain
1162     int nHeight;
1163
1164     int64 nMint;
1165     int64 nMoneySupply;
1166
1167     unsigned int nFlags;  // ppcoin: block index flags
1168     enum
1169     {
1170         BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1171         BLOCK_STAKE_ENTROPY  = (1 << 1), // entropy bit for stake modifier
1172         BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1173     };
1174
1175     uint64 nStakeModifier; // hash modifier for proof-of-stake
1176     unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1177
1178     // proof-of-stake specific fields
1179     COutPoint prevoutStake;
1180     unsigned int nStakeTime;
1181     uint256 hashProofOfStake;
1182
1183     // block header
1184     int nVersion;
1185     uint256 hashMerkleRoot;
1186     unsigned int nTime;
1187     unsigned int nBits;
1188     unsigned int nNonce;
1189
1190     CBlockIndex()
1191     {
1192         phashBlock = NULL;
1193         pprev = NULL;
1194         pnext = NULL;
1195         nFile = 0;
1196         nBlockPos = 0;
1197         nHeight = 0;
1198         nChainTrust = 0;
1199         nMint = 0;
1200         nMoneySupply = 0;
1201         nFlags = 0;
1202         nStakeModifier = 0;
1203         nStakeModifierChecksum = 0;
1204         hashProofOfStake = 0;
1205         prevoutStake.SetNull();
1206         nStakeTime = 0;
1207
1208         nVersion       = 0;
1209         hashMerkleRoot = 0;
1210         nTime          = 0;
1211         nBits          = 0;
1212         nNonce         = 0;
1213     }
1214
1215     CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1216     {
1217         phashBlock = NULL;
1218         pprev = NULL;
1219         pnext = NULL;
1220         nFile = nFileIn;
1221         nBlockPos = nBlockPosIn;
1222         nHeight = 0;
1223         nChainTrust = 0;
1224         nMint = 0;
1225         nMoneySupply = 0;
1226         nFlags = 0;
1227         nStakeModifier = 0;
1228         nStakeModifierChecksum = 0;
1229         hashProofOfStake = 0;
1230         if (block.IsProofOfStake())
1231         {
1232             SetProofOfStake();
1233             prevoutStake = block.vtx[1].vin[0].prevout;
1234             nStakeTime = block.vtx[1].nTime;
1235         }
1236         else
1237         {
1238             prevoutStake.SetNull();
1239             nStakeTime = 0;
1240         }
1241
1242         nVersion       = block.nVersion;
1243         hashMerkleRoot = block.hashMerkleRoot;
1244         nTime          = block.nTime;
1245         nBits          = block.nBits;
1246         nNonce         = block.nNonce;
1247     }
1248
1249     CBlock GetBlockHeader() const
1250     {
1251         CBlock block;
1252         block.nVersion       = nVersion;
1253         if (pprev)
1254             block.hashPrevBlock = pprev->GetBlockHash();
1255         block.hashMerkleRoot = hashMerkleRoot;
1256         block.nTime          = nTime;
1257         block.nBits          = nBits;
1258         block.nNonce         = nNonce;
1259         return block;
1260     }
1261
1262     uint256 GetBlockHash() const
1263     {
1264         return *phashBlock;
1265     }
1266
1267     int64 GetBlockTime() const
1268     {
1269         return (int64)nTime;
1270     }
1271
1272     uint256 GetBlockTrust() const;
1273
1274     bool IsInMainChain() const
1275     {
1276         return (pnext || this == pindexBest);
1277     }
1278
1279     bool CheckIndex() const
1280     {
1281         return true;
1282     }
1283
1284     enum { nMedianTimeSpan=11 };
1285
1286     int64 GetMedianTimePast() const
1287     {
1288         int64 pmedian[nMedianTimeSpan];
1289         int64* pbegin = &pmedian[nMedianTimeSpan];
1290         int64* pend = &pmedian[nMedianTimeSpan];
1291
1292         const CBlockIndex* pindex = this;
1293         for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1294             *(--pbegin) = pindex->GetBlockTime();
1295
1296         std::sort(pbegin, pend);
1297         return pbegin[(pend - pbegin)/2];
1298     }
1299
1300     int64 GetMedianTime() const
1301     {
1302         const CBlockIndex* pindex = this;
1303         for (int i = 0; i < nMedianTimeSpan/2; i++)
1304         {
1305             if (!pindex->pnext)
1306                 return GetBlockTime();
1307             pindex = pindex->pnext;
1308         }
1309         return pindex->GetMedianTimePast();
1310     }
1311
1312     /**
1313      * Returns true if there are nRequired or more blocks of minVersion or above
1314      * in the last nToCheck blocks, starting at pstart and going backwards.
1315      */
1316     static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1317                                 unsigned int nRequired, unsigned int nToCheck);
1318
1319
1320     bool IsProofOfWork() const
1321     {
1322         return !(nFlags & BLOCK_PROOF_OF_STAKE);
1323     }
1324
1325     bool IsProofOfStake() const
1326     {
1327         return (nFlags & BLOCK_PROOF_OF_STAKE);
1328     }
1329
1330     void SetProofOfStake()
1331     {
1332         nFlags |= BLOCK_PROOF_OF_STAKE;
1333     }
1334
1335     unsigned int GetStakeEntropyBit() const
1336     {
1337         return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1338     }
1339
1340     bool SetStakeEntropyBit(unsigned int nEntropyBit)
1341     {
1342         if (nEntropyBit > 1)
1343             return false;
1344         nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1345         return true;
1346     }
1347
1348     bool GeneratedStakeModifier() const
1349     {
1350         return (nFlags & BLOCK_STAKE_MODIFIER);
1351     }
1352
1353     void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1354     {
1355         nStakeModifier = nModifier;
1356         if (fGeneratedStakeModifier)
1357             nFlags |= BLOCK_STAKE_MODIFIER;
1358     }
1359
1360     std::string ToString() const
1361     {
1362         return strprintf("CBlockIndex(nprev=%p, pnext=%p, nFile=%u, nBlockPos=%-6d nHeight=%d, nMint=%s, nMoneySupply=%s, nFlags=(%s)(%d)(%s), nStakeModifier=%016"PRI64x", nStakeModifierChecksum=%08x, hashProofOfStake=%s, prevoutStake=(%s), nStakeTime=%d merkle=%s, hashBlock=%s)",
1363             pprev, pnext, nFile, nBlockPos, nHeight,
1364             FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1365             GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1366             nStakeModifier, nStakeModifierChecksum,
1367             hashProofOfStake.ToString().c_str(),
1368             prevoutStake.ToString().c_str(), nStakeTime,
1369             hashMerkleRoot.ToString().c_str(),
1370             GetBlockHash().ToString().c_str());
1371     }
1372
1373     void print() const
1374     {
1375         printf("%s\n", ToString().c_str());
1376     }
1377 };
1378
1379
1380
1381 /** Used to marshal pointers into hashes for db storage. */
1382 class CDiskBlockIndex : public CBlockIndex
1383 {
1384 private:
1385     uint256 blockHash;
1386
1387 public:
1388     uint256 hashPrev;
1389     uint256 hashNext;
1390
1391     CDiskBlockIndex()
1392     {
1393         hashPrev = 0;
1394         hashNext = 0;
1395         blockHash = 0;
1396     }
1397
1398     explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1399     {
1400         hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1401         hashNext = (pnext ? pnext->GetBlockHash() : 0);
1402     }
1403
1404     IMPLEMENT_SERIALIZE
1405     (
1406         if (!(nType & SER_GETHASH))
1407             READWRITE(nVersion);
1408
1409         READWRITE(hashNext);
1410         READWRITE(nFile);
1411         READWRITE(nBlockPos);
1412         READWRITE(nHeight);
1413         READWRITE(nMint);
1414         READWRITE(nMoneySupply);
1415         READWRITE(nFlags);
1416         READWRITE(nStakeModifier);
1417         if (IsProofOfStake())
1418         {
1419             READWRITE(prevoutStake);
1420             READWRITE(nStakeTime);
1421             READWRITE(hashProofOfStake);
1422         }
1423         else if (fRead)
1424         {
1425             const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1426             const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1427             const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1428         }
1429
1430         // block header
1431         READWRITE(this->nVersion);
1432         READWRITE(hashPrev);
1433         READWRITE(hashMerkleRoot);
1434         READWRITE(nTime);
1435         READWRITE(nBits);
1436         READWRITE(nNonce);
1437         READWRITE(blockHash);
1438     )
1439
1440     uint256 GetBlockHash() const
1441     {
1442         if (fUseFastIndex && (nTime < GetAdjustedTime() - 24 * 60 * 60) && blockHash != 0)
1443             return blockHash;
1444
1445         CBlock block;
1446         block.nVersion        = nVersion;
1447         block.hashPrevBlock   = hashPrev;
1448         block.hashMerkleRoot  = hashMerkleRoot;
1449         block.nTime           = nTime;
1450         block.nBits           = nBits;
1451         block.nNonce          = nNonce;
1452
1453         const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1454
1455         return blockHash;
1456     }
1457
1458     std::string ToString() const
1459     {
1460         std::string str = "CDiskBlockIndex(";
1461         str += CBlockIndex::ToString();
1462         str += strprintf("\n                hashBlock=%s, hashPrev=%s, hashNext=%s)",
1463             GetBlockHash().ToString().c_str(),
1464             hashPrev.ToString().c_str(),
1465             hashNext.ToString().c_str());
1466         return str;
1467     }
1468
1469     void print() const
1470     {
1471         printf("%s\n", ToString().c_str());
1472     }
1473 };
1474
1475
1476
1477
1478
1479
1480
1481
1482 /** Describes a place in the block chain to another node such that if the
1483  * other node doesn't have the same branch, it can find a recent common trunk.
1484  * The further back it is, the further before the fork it may be.
1485  */
1486 class CBlockLocator
1487 {
1488 protected:
1489     std::vector<uint256> vHave;
1490 public:
1491
1492     CBlockLocator()
1493     {
1494     }
1495
1496     explicit CBlockLocator(const CBlockIndex* pindex)
1497     {
1498         Set(pindex);
1499     }
1500
1501     explicit CBlockLocator(uint256 hashBlock)
1502     {
1503         std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1504         if (mi != mapBlockIndex.end())
1505             Set((*mi).second);
1506     }
1507
1508     CBlockLocator(const std::vector<uint256>& vHaveIn)
1509     {
1510         vHave = vHaveIn;
1511     }
1512
1513     IMPLEMENT_SERIALIZE
1514     (
1515         if (!(nType & SER_GETHASH))
1516             READWRITE(nVersion);
1517         READWRITE(vHave);
1518     )
1519
1520     void SetNull()
1521     {
1522         vHave.clear();
1523     }
1524
1525     bool IsNull()
1526     {
1527         return vHave.empty();
1528     }
1529
1530     void Set(const CBlockIndex* pindex)
1531     {
1532         vHave.clear();
1533         int nStep = 1;
1534         while (pindex)
1535         {
1536             vHave.push_back(pindex->GetBlockHash());
1537
1538             // Exponentially larger steps back
1539             for (int i = 0; pindex && i < nStep; i++)
1540                 pindex = pindex->pprev;
1541             if (vHave.size() > 10)
1542                 nStep *= 2;
1543         }
1544         vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1545     }
1546
1547     int GetDistanceBack()
1548     {
1549         // Retrace how far back it was in the sender's branch
1550         int nDistance = 0;
1551         int nStep = 1;
1552         BOOST_FOREACH(const uint256& hash, vHave)
1553         {
1554             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1555             if (mi != mapBlockIndex.end())
1556             {
1557                 CBlockIndex* pindex = (*mi).second;
1558                 if (pindex->IsInMainChain())
1559                     return nDistance;
1560             }
1561             nDistance += nStep;
1562             if (nDistance > 10)
1563                 nStep *= 2;
1564         }
1565         return nDistance;
1566     }
1567
1568     CBlockIndex* GetBlockIndex()
1569     {
1570         // Find the first block the caller has in the main chain
1571         BOOST_FOREACH(const uint256& hash, vHave)
1572         {
1573             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1574             if (mi != mapBlockIndex.end())
1575             {
1576                 CBlockIndex* pindex = (*mi).second;
1577                 if (pindex->IsInMainChain())
1578                     return pindex;
1579             }
1580         }
1581         return pindexGenesisBlock;
1582     }
1583
1584     uint256 GetBlockHash()
1585     {
1586         // Find the first block the caller has in the main chain
1587         BOOST_FOREACH(const uint256& hash, vHave)
1588         {
1589             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1590             if (mi != mapBlockIndex.end())
1591             {
1592                 CBlockIndex* pindex = (*mi).second;
1593                 if (pindex->IsInMainChain())
1594                     return hash;
1595             }
1596         }
1597         return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1598     }
1599
1600     int GetHeight()
1601     {
1602         CBlockIndex* pindex = GetBlockIndex();
1603         if (!pindex)
1604             return 0;
1605         return pindex->nHeight;
1606     }
1607 };
1608
1609
1610
1611
1612
1613
1614
1615
1616 class CTxMemPool
1617 {
1618 public:
1619     mutable CCriticalSection cs;
1620     std::map<uint256, CTransaction> mapTx;
1621     std::map<COutPoint, CInPoint> mapNextTx;
1622
1623     bool accept(CTxDB& txdb, CTransaction &tx,
1624                 bool fCheckInputs, bool* pfMissingInputs);
1625     bool addUnchecked(const uint256& hash, CTransaction &tx);
1626     bool remove(CTransaction &tx);
1627     void clear();
1628     void queryHashes(std::vector<uint256>& vtxid);
1629
1630     unsigned long size()
1631     {
1632         LOCK(cs);
1633         return mapTx.size();
1634     }
1635
1636     bool exists(uint256 hash)
1637     {
1638         return (mapTx.count(hash) != 0);
1639     }
1640
1641     CTransaction& lookup(uint256 hash)
1642     {
1643         return mapTx[hash];
1644     }
1645 };
1646
1647 extern CTxMemPool mempool;
1648
1649 #endif