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