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