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() const;
 552
 553     /** Check for standard transaction types
 554         @param[in] mapInputs    Map of previous transactions that have outputs we're spending
 555         @return True if all inputs (scriptSigs) use only standard transaction forms
 556         @see CTransaction::FetchInputs
 557     */
 558     bool AreInputsStandard(const MapPrevTx& mapInputs) const;
 559
 560     /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
 561         @return number of sigops this transaction's outputs will produce when spent
 562         @see CTransaction::FetchInputs
 563     */
 564     unsigned int GetLegacySigOpCount() const;
 565
 566     /** Count ECDSA signature operations in pay-to-script-hash inputs.
 567
 568         @param[in] mapInputs    Map of previous transactions that have outputs we're spending
 569         @return maximum number of sigops required to validate this transaction's inputs
 570         @see CTransaction::FetchInputs
 571      */
 572     unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
 573
 574     /** Amount of bitcoins spent by this transaction.
 575         @return sum of all outputs (note: does not include fees)
 576      */
 577     int64_t GetValueOut() const
 578     {
 579         int64_t nValueOut = 0;
 580         BOOST_FOREACH(const CTxOut& txout, vout)
 581         {
 582             nValueOut += txout.nValue;
 583             if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
 584                 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
 585         }
 586         return nValueOut;
 587     }
 588
 589     /** Amount of bitcoins coming in to this transaction
 590         Note that lightweight clients may not know anything besides the hash of previous transactions,
 591         so may not be able to calculate this.
 592
 593         @param[in] mapInputs    Map of previous transactions that have outputs we're spending
 594         @return Sum of value of all inputs (scriptSigs)
 595         @see CTransaction::FetchInputs
 596      */
 597     int64_t GetValueIn(const MapPrevTx& mapInputs) const;
 598
 599     static bool AllowFree(double dPriority)
 600     {
 601         // Large (in bytes) low-priority (new, small-coin) transactions
 602         // need a fee.
 603         return dPriority > COIN * 144 / 250;
 604     }
 605
 606     int64_t GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK, unsigned int nBytes = 0) const;
 607
 608     bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
 609     {
 610         CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
 611         if (!filein)
 612             return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
 613
 614         // Read transaction
 615         if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
 616             return error("CTransaction::ReadFromDisk() : fseek failed");
 617
 618         try {
 619             filein >> *this;
 620         }
 621         catch (std::exception &e) {
 622             (void)e;
 623             return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
 624         }
 625
 626         // Return file pointer
 627         if (pfileRet)
 628         {
 629             if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
 630                 return error("CTransaction::ReadFromDisk() : second fseek failed");
 631             *pfileRet = filein.release();
 632         }
 633         return true;
 634     }
 635
 636     friend bool operator==(const CTransaction& a, const CTransaction& b)
 637     {
 638         return (a.nVersion  == b.nVersion &&
 639                 a.nTime     == b.nTime &&
 640                 a.vin       == b.vin &&
 641                 a.vout      == b.vout &&
 642                 a.nLockTime == b.nLockTime);
 643     }
 644
 645     friend bool operator!=(const CTransaction& a, const CTransaction& b)
 646     {
 647         return !(a == b);
 648     }
 649
 650     std::string ToStringShort() const
 651     {
 652         std::string str;
 653         str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
 654         return str;
 655     }
 656
 657     std::string ToString() const
 658     {
 659         std::string str;
 660         str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
 661         str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%" PRIszu ", vout.size=%" PRIszu ", nLockTime=%d)\n",
 662             GetHash().ToString().substr(0,10).c_str(),
 663             nTime,
 664             nVersion,
 665             vin.size(),
 666             vout.size(),
 667             nLockTime);
 668         for (unsigned int i = 0; i < vin.size(); i++)
 669             str += "    " + vin[i].ToString() + "\n";
 670         for (unsigned int i = 0; i < vout.size(); i++)
 671             str += "    " + vout[i].ToString() + "\n";
 672         return str;
 673     }
 674
 675     void print() const
 676     {
 677         printf("%s", ToString().c_str());
 678     }
 679
 680
 681     bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
 682     bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
 683     bool ReadFromDisk(COutPoint prevout);
 684     bool DisconnectInputs(CTxDB& txdb);
 685
 686     /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
 687
 688      @param[in] txdb    Transaction database
 689      @param[in] mapTestPool     List of pending changes to the transaction index database
 690      @param[in] fBlock  True if being called to add a new best-block to the chain
 691      @param[in] fMiner  True if being called by CreateNewBlock
 692      @param[out] inputsRet      Pointers to this transaction's inputs
 693      @param[out] fInvalid       returns true if transaction is invalid
 694      @return    Returns true if all inputs are in txdb or mapTestPool
 695      */
 696     bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
 697                      bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
 698
 699     /** Sanity check previous transactions, then, if all checks succeed,
 700         mark them as spent by this transaction.
 701
 702         @param[in] inputs       Previous transactions (from FetchInputs)
 703         @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
 704         @param[in] posThisTx    Position of this transaction on disk
 705         @param[in] pindexBlock
 706         @param[in] fBlock       true if called from ConnectBlock
 707         @param[in] fMiner       true if called from CreateNewBlock
 708         @param[in] fScriptChecks        enable scripts validation?
 709         @param[in] flags        STRICT_FLAGS script validation flags
 710         @param[in] pvChecks     NULL If pvChecks is not NULL, script checks are pushed onto it instead of being performed inline.
 711         @return Returns true if all checks succeed
 712      */
 713     bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs, std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx, const CBlockIndex* pindexBlock,
 714                      bool fBlock, bool fMiner, bool fScriptChecks=true,
 715                      unsigned int flags=STRICT_FLAGS, std::vector<CScriptCheck> *pvChecks = NULL);
 716     bool ClientConnectInputs();
 717     bool CheckTransaction() const;
 718     bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
 719     bool GetCoinAge(CTxDB& txdb, uint64_t& nCoinAge) const;  // ppcoin: get transaction coin age
 720
 721 protected:
 722     const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
 723 };
 724
 725 /** Closure representing one script verification
 726  *  Note that this stores references to the spending transaction */
 727 class CScriptCheck
 728 {
 729 private:
 730     CScript scriptPubKey;
 731     const CTransaction *ptxTo;
 732     unsigned int nIn;
 733     unsigned int nFlags;
 734     int nHashType;
 735
 736 public:
 737     CScriptCheck() {}
 738     CScriptCheck(const CTransaction& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, int nHashTypeIn) :
 739         scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey),
 740         ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), nHashType(nHashTypeIn) { }
 741
 742     bool operator()() const;
 743
 744     void swap(CScriptCheck &check) {
 745         scriptPubKey.swap(check.scriptPubKey);
 746         std::swap(ptxTo, check.ptxTo);
 747         std::swap(nIn, check.nIn);
 748         std::swap(nFlags, check.nFlags);
 749         std::swap(nHashType, check.nHashType);
 750     }
 751 };
 752
 753
 754
 755
 756 /** A transaction with a merkle branch linking it to the block chain. */
 757 class CMerkleTx : public CTransaction
 758 {
 759 public:
 760     uint256 hashBlock;
 761     std::vector<uint256> vMerkleBranch;
 762     int32_t nIndex;
 763
 764     // memory only
 765     mutable bool fMerkleVerified;
 766
 767
 768     CMerkleTx()
 769     {
 770         Init();
 771     }
 772
 773     CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
 774     {
 775         Init();
 776     }
 777
 778     void Init()
 779     {
 780         hashBlock = 0;
 781         nIndex = -1;
 782         fMerkleVerified = false;
 783     }
 784
 785
 786     IMPLEMENT_SERIALIZE
 787     (
 788         nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
 789         nVersion = this->nVersion;
 790         READWRITE(hashBlock);
 791         READWRITE(vMerkleBranch);
 792         READWRITE(nIndex);
 793     )
 794
 795
 796     int SetMerkleBranch(const CBlock* pblock=NULL);
 797     int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
 798     int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
 799     bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
 800     int GetBlocksToMaturity() const;
 801     bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
 802     bool AcceptToMemoryPool();
 803 };
 804
 805
 806
 807
 808 /**  A txdb record that contains the disk location of a transaction and the
 809  * locations of transactions that spend its outputs.  vSpent is really only
 810  * used as a flag, but having the location is very helpful for debugging.
 811  */
 812 class CTxIndex
 813 {
 814 public:
 815     CDiskTxPos pos;
 816     std::vector<CDiskTxPos> vSpent;
 817
 818     CTxIndex()
 819     {
 820         SetNull();
 821     }
 822
 823     CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
 824     {
 825         pos = posIn;
 826         vSpent.resize(nOutputs);
 827     }
 828
 829     IMPLEMENT_SERIALIZE
 830     (
 831         if (!(nType & SER_GETHASH))
 832             READWRITE(nVersion);
 833         READWRITE(pos);
 834         READWRITE(vSpent);
 835     )
 836
 837     void SetNull()
 838     {
 839         pos.SetNull();
 840         vSpent.clear();
 841     }
 842
 843     bool IsNull()
 844     {
 845         return pos.IsNull();
 846     }
 847
 848     friend bool operator==(const CTxIndex& a, const CTxIndex& b)
 849     {
 850         return (a.pos    == b.pos &&
 851                 a.vSpent == b.vSpent);
 852     }
 853
 854     friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
 855     {
 856         return !(a == b);
 857     }
 858     int GetDepthInMainChain() const;
 859
 860 };
 861
 862
 863
 864
 865
 866 /** Nodes collect new transactions into a block, hash them into a hash tree,
 867  * and scan through nonce values to make the block's hash satisfy proof-of-work
 868  * requirements.  When they solve the proof-of-work, they broadcast the block
 869  * to everyone and the block is added to the block chain.  The first transaction
 870  * in the block is a special one that creates a new coin owned by the creator
 871  * of the block.
 872  *
 873  * Blocks are appended to blk0001.dat files on disk.  Their location on disk
 874  * is indexed by CBlockIndex objects in memory.
 875  */
 876 class CBlock
 877 {
 878 public:
 879     // header
 880     static const int CURRENT_VERSION=6;
 881     int32_t nVersion;
 882     uint256 hashPrevBlock;
 883     uint256 hashMerkleRoot;
 884     uint32_t nTime;
 885     uint32_t nBits;
 886     uint32_t nNonce;
 887
 888     // network and disk
 889     std::vector<CTransaction> vtx;
 890
 891     // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
 892     std::vector<unsigned char> vchBlockSig;
 893
 894     // memory only
 895     mutable std::vector<uint256> vMerkleTree;
 896
 897     // Denial-of-service detection:
 898     mutable int nDoS;
 899     bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
 900
 901     CBlock()
 902     {
 903         SetNull();
 904     }
 905
 906     IMPLEMENT_SERIALIZE
 907     (
 908         READWRITE(this->nVersion);
 909         nVersion = this->nVersion;
 910         READWRITE(hashPrevBlock);
 911         READWRITE(hashMerkleRoot);
 912         READWRITE(nTime);
 913         READWRITE(nBits);
 914         READWRITE(nNonce);
 915
 916         // ConnectBlock depends on vtx following header to generate CDiskTxPos
 917         if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
 918         {
 919             READWRITE(vtx);
 920             READWRITE(vchBlockSig);
 921         }
 922         else if (fRead)
 923         {
 924             const_cast<CBlock*>(this)->vtx.clear();
 925             const_cast<CBlock*>(this)->vchBlockSig.clear();
 926         }
 927     )
 928
 929     void SetNull()
 930     {
 931         nVersion = CBlock::CURRENT_VERSION;
 932         hashPrevBlock = 0;
 933         hashMerkleRoot = 0;
 934         nTime = 0;
 935         nBits = 0;
 936         nNonce = 0;
 937         vtx.clear();
 938         vchBlockSig.clear();
 939         vMerkleTree.clear();
 940         nDoS = 0;
 941     }
 942
 943     bool IsNull() const
 944     {
 945         return (nBits == 0);
 946     }
 947
 948     uint256 GetHash() const
 949     {
 950         return scrypt_blockhash(CVOIDBEGIN(nVersion));
 951     }
 952
 953     int64_t GetBlockTime() const
 954     {
 955         return (int64_t)nTime;
 956     }
 957
 958     void UpdateTime(const CBlockIndex* pindexPrev);
 959
 960     // ppcoin: entropy bit for stake modifier if chosen by modifier
 961     unsigned int GetStakeEntropyBit(unsigned int nTime) const
 962     {
 963         // Protocol switch to support p2pool at novacoin block #9689
 964         if (nTime >= ENTROPY_SWITCH_TIME || fTestNet)
 965         {
 966             // Take last bit of block hash as entropy bit
 967             unsigned int nEntropyBit = ((GetHash().Get64()) & 1ULL);
 968             if (fDebug && GetBoolArg("-printstakemodifier"))
 969                 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
 970             return nEntropyBit;
 971         }
 972         // Before novacoin block #9689 - old protocol
 973         uint160 hashSig = Hash160(vchBlockSig);
 974         if (fDebug && GetBoolArg("-printstakemodifier"))
 975             printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
 976         hashSig >>= 159; // take the first bit of the hash
 977         if (fDebug && GetBoolArg("-printstakemodifier"))
 978             printf(" entropybit=%" PRId64 "\n", hashSig.Get64());
 979         return (unsigned int)hashSig.Get64();
 980     }
 981
 982     // ppcoin: two types of block: proof-of-work or proof-of-stake
 983     bool IsProofOfStake() const
 984     {
 985         return (vtx.size() > 1 && vtx[1].IsCoinStake());
 986     }
 987
 988     bool IsProofOfWork() const
 989     {
 990         return !IsProofOfStake();
 991     }
 992
 993     std::pair<COutPoint, unsigned int> GetProofOfStake() const
 994     {
 995         return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
 996     }
 997
 998     // ppcoin: get max transaction timestamp
 999     int64_t GetMaxTransactionTime() const
1000     {
1001         int64_t maxTransactionTime = 0;
1002         BOOST_FOREACH(const CTransaction& tx, vtx)
1003             maxTransactionTime = std::max(maxTransactionTime, (int64_t)tx.nTime);
1004         return maxTransactionTime;
1005     }
1006
1007     uint256 BuildMerkleTree() const
1008     {
1009         vMerkleTree.clear();
1010         BOOST_FOREACH(const CTransaction& tx, vtx)
1011             vMerkleTree.push_back(tx.GetHash());
1012         int j = 0;
1013         for (int nSize = (int)vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1014         {
1015             for (int i = 0; i < nSize; i += 2)
1016             {
1017                 int i2 = std::min(i+1, nSize-1);
1018                 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]),  END(vMerkleTree[j+i]),
1019                                            BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
1020             }
1021             j += nSize;
1022         }
1023         return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
1024     }
1025
1026     std::vector<uint256> GetMerkleBranch(int nIndex) const
1027     {
1028         if (vMerkleTree.empty())
1029             BuildMerkleTree();
1030         std::vector<uint256> vMerkleBranch;
1031         int j = 0;
1032         for (int nSize = (int)vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1033         {
1034             int i = std::min(nIndex^1, nSize-1);
1035             vMerkleBranch.push_back(vMerkleTree[j+i]);
1036             nIndex >>= 1;
1037             j += nSize;
1038         }
1039         return vMerkleBranch;
1040     }
1041
1042     static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1043     {
1044         if (nIndex == -1)
1045             return 0;
1046         BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1047         {
1048             if (nIndex & 1)
1049                 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1050             else
1051                 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1052             nIndex >>= 1;
1053         }
1054         return hash;
1055     }
1056
1057
1058     bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1059     {
1060         // Open history file to append
1061         CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1062         if (!fileout)
1063             return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1064
1065         // Write index header
1066         unsigned int nSize = fileout.GetSerializeSize(*this);
1067         fileout << FLATDATA(pchMessageStart) << nSize;
1068
1069         // Write block
1070         long fileOutPos = ftell(fileout);
1071         if (fileOutPos < 0)
1072             return error("CBlock::WriteToDisk() : ftell failed");
1073         nBlockPosRet = fileOutPos;
1074         fileout << *this;
1075
1076         // Flush stdio buffers and commit to disk before returning
1077         fflush(fileout);
1078         if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1079             FileCommit(fileout);
1080
1081         return true;
1082     }
1083
1084     bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1085     {
1086         SetNull();
1087
1088         // Open history file to read
1089         CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1090         if (!filein)
1091             return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1092         if (!fReadTransactions)
1093             filein.nType |= SER_BLOCKHEADERONLY;
1094
1095         // Read block
1096         try {
1097             filein >> *this;
1098         }
1099         catch (std::exception &e) {
1100             (void)e;
1101             return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
1102         }
1103
1104         // Check the header
1105         if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1106             return error("CBlock::ReadFromDisk() : errors in block header");
1107
1108         return true;
1109     }
1110
1111
1112
1113     void print() const
1114     {
1115         printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%" PRIszu ", vchBlockSig=%s)\n",
1116             GetHash().ToString().c_str(),
1117             nVersion,
1118             hashPrevBlock.ToString().c_str(),
1119             hashMerkleRoot.ToString().c_str(),
1120             nTime, nBits, nNonce,
1121             vtx.size(),
1122             HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1123         for (unsigned int i = 0; i < vtx.size(); i++)
1124         {
1125             printf("  ");
1126             vtx[i].print();
1127         }
1128         printf("  vMerkleTree: ");
1129         for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1130             printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1131         printf("\n");
1132     }
1133
1134
1135     bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1136     bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1137     bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1138     bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1139     bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1140     bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1141     bool AcceptBlock();
1142     bool GetCoinAge(uint64_t& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1143     bool SignBlock(CWallet& keystore);
1144     bool CheckBlockSignature(bool fProofOfStake) const;
1145
1146 private:
1147     bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1148 };
1149
1150
1151
1152
1153
1154
1155 /** The block chain is a tree shaped structure starting with the
1156  * genesis block at the root, with each block potentially having multiple
1157  * candidates to be the next block.  pprev and pnext link a path through the
1158  * main/longest chain.  A blockindex may have multiple pprev pointing back
1159  * to it, but pnext will only point forward to the longest branch, or will
1160  * be null if the block is not part of the longest chain.
1161  */
1162 class CBlockIndex
1163 {
1164 public:
1165     const uint256* phashBlock;
1166     CBlockIndex* pprev;
1167     CBlockIndex* pnext;
1168     uint32_t nFile;
1169     uint32_t nBlockPos;
1170     uint256 nChainTrust; // ppcoin: trust score of block chain
1171     int32_t nHeight;
1172
1173     int64_t nMint;
1174     int64_t nMoneySupply;
1175
1176     uint32_t nFlags;  // ppcoin: block index flags
1177     enum
1178     {
1179         BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1180         BLOCK_STAKE_ENTROPY  = (1 << 1), // entropy bit for stake modifier
1181         BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1182     };
1183
1184     uint64_t nStakeModifier; // hash modifier for proof-of-stake
1185     uint32_t nStakeModifierChecksum; // checksum of index; in-memeory only
1186
1187     // proof-of-stake specific fields
1188     COutPoint prevoutStake;
1189     uint32_t nStakeTime;
1190     uint256 hashProofOfStake;
1191
1192     // block header
1193     int32_t  nVersion;
1194     uint256  hashMerkleRoot;
1195     uint32_t nTime;
1196     uint32_t nBits;
1197     uint32_t nNonce;
1198
1199     CBlockIndex()
1200     {
1201         phashBlock = NULL;
1202         pprev = NULL;
1203         pnext = NULL;
1204         nFile = 0;
1205         nBlockPos = 0;
1206         nHeight = 0;
1207         nChainTrust = 0;
1208         nMint = 0;
1209         nMoneySupply = 0;
1210         nFlags = 0;
1211         nStakeModifier = 0;
1212         nStakeModifierChecksum = 0;
1213         hashProofOfStake = 0;
1214         prevoutStake.SetNull();
1215         nStakeTime = 0;
1216
1217         nVersion       = 0;
1218         hashMerkleRoot = 0;
1219         nTime          = 0;
1220         nBits          = 0;
1221         nNonce         = 0;
1222     }
1223
1224     CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1225     {
1226         phashBlock = NULL;
1227         pprev = NULL;
1228         pnext = NULL;
1229         nFile = nFileIn;
1230         nBlockPos = nBlockPosIn;
1231         nHeight = 0;
1232         nChainTrust = 0;
1233         nMint = 0;
1234         nMoneySupply = 0;
1235         nFlags = 0;
1236         nStakeModifier = 0;
1237         nStakeModifierChecksum = 0;
1238         hashProofOfStake = 0;
1239         if (block.IsProofOfStake())
1240         {
1241             SetProofOfStake();
1242             prevoutStake = block.vtx[1].vin[0].prevout;
1243             nStakeTime = block.vtx[1].nTime;
1244         }
1245         else
1246         {
1247             prevoutStake.SetNull();
1248             nStakeTime = 0;
1249         }
1250
1251         nVersion       = block.nVersion;
1252         hashMerkleRoot = block.hashMerkleRoot;
1253         nTime          = block.nTime;
1254         nBits          = block.nBits;
1255         nNonce         = block.nNonce;
1256     }
1257
1258     CBlock GetBlockHeader() const
1259     {
1260         CBlock block;
1261         block.nVersion       = nVersion;
1262         if (pprev)
1263             block.hashPrevBlock = pprev->GetBlockHash();
1264         block.hashMerkleRoot = hashMerkleRoot;
1265         block.nTime          = nTime;
1266         block.nBits          = nBits;
1267         block.nNonce         = nNonce;
1268         return block;
1269     }
1270
1271     uint256 GetBlockHash() const
1272     {
1273         return *phashBlock;
1274     }
1275
1276     int64_t GetBlockTime() const
1277     {
1278         return (int64_t)nTime;
1279     }
1280
1281     uint256 GetBlockTrust() const;
1282
1283     bool IsInMainChain() const
1284     {
1285         return (pnext || this == pindexBest);
1286     }
1287
1288     bool CheckIndex() const
1289     {
1290         return true;
1291     }
1292
1293     enum { nMedianTimeSpan=11 };
1294
1295     int64_t GetMedianTimePast() const
1296     {
1297         int64_t pmedian[nMedianTimeSpan];
1298         int64_t* pbegin = &pmedian[nMedianTimeSpan];
1299         int64_t* pend = &pmedian[nMedianTimeSpan];
1300
1301         const CBlockIndex* pindex = this;
1302         for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1303             *(--pbegin) = pindex->GetBlockTime();
1304
1305         std::sort(pbegin, pend);
1306         return pbegin[(pend - pbegin)/2];
1307     }
1308
1309     int64_t GetMedianTime() const
1310     {
1311         const CBlockIndex* pindex = this;
1312         for (int i = 0; i < nMedianTimeSpan/2; i++)
1313         {
1314             if (!pindex->pnext)
1315                 return GetBlockTime();
1316             pindex = pindex->pnext;
1317         }
1318         return pindex->GetMedianTimePast();
1319     }
1320
1321     /**
1322      * Returns true if there are nRequired or more blocks of minVersion or above
1323      * in the last nToCheck blocks, starting at pstart and going backwards.
1324      */
1325     static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1326                                 unsigned int nRequired, unsigned int nToCheck);
1327
1328
1329     bool IsProofOfWork() const
1330     {
1331         return !(nFlags & BLOCK_PROOF_OF_STAKE);
1332     }
1333
1334     bool IsProofOfStake() const
1335     {
1336         return (nFlags & BLOCK_PROOF_OF_STAKE);
1337     }
1338
1339     void SetProofOfStake()
1340     {
1341         nFlags |= BLOCK_PROOF_OF_STAKE;
1342     }
1343
1344     unsigned int GetStakeEntropyBit() const
1345     {
1346         return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1347     }
1348
1349     bool SetStakeEntropyBit(unsigned int nEntropyBit)
1350     {
1351         if (nEntropyBit > 1)
1352             return false;
1353         nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1354         return true;
1355     }
1356
1357     bool GeneratedStakeModifier() const
1358     {
1359         return (nFlags & BLOCK_STAKE_MODIFIER) != 0;
1360     }
1361
1362     void SetStakeModifier(uint64_t nModifier, bool fGeneratedStakeModifier)
1363     {
1364         nStakeModifier = nModifier;
1365         if (fGeneratedStakeModifier)
1366             nFlags |= BLOCK_STAKE_MODIFIER;
1367     }
1368
1369     std::string ToString() const
1370     {
1371         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)",
1372             pprev, pnext, nFile, nBlockPos, nHeight,
1373             FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1374             GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1375             nStakeModifier, nStakeModifierChecksum,
1376             hashProofOfStake.ToString().c_str(),
1377             prevoutStake.ToString().c_str(), nStakeTime,
1378             hashMerkleRoot.ToString().c_str(),
1379             GetBlockHash().ToString().c_str());
1380     }
1381
1382     void print() const
1383     {
1384         printf("%s\n", ToString().c_str());
1385     }
1386 };
1387
1388
1389
1390 /** Used to marshal pointers into hashes for db storage. */
1391 class CDiskBlockIndex : public CBlockIndex
1392 {
1393 private:
1394     uint256 blockHash;
1395
1396 public:
1397     uint256 hashPrev;
1398     uint256 hashNext;
1399
1400     CDiskBlockIndex()
1401     {
1402         hashPrev = 0;
1403         hashNext = 0;
1404         blockHash = 0;
1405     }
1406
1407     explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1408     {
1409         hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1410         hashNext = (pnext ? pnext->GetBlockHash() : 0);
1411     }
1412
1413     IMPLEMENT_SERIALIZE
1414     (
1415         if (!(nType & SER_GETHASH))
1416             READWRITE(nVersion);
1417
1418         READWRITE(hashNext);
1419         READWRITE(nFile);
1420         READWRITE(nBlockPos);
1421         READWRITE(nHeight);
1422         READWRITE(nMint);
1423         READWRITE(nMoneySupply);
1424         READWRITE(nFlags);
1425         READWRITE(nStakeModifier);
1426         if (IsProofOfStake())
1427         {
1428             READWRITE(prevoutStake);
1429             READWRITE(nStakeTime);
1430             READWRITE(hashProofOfStake);
1431         }
1432         else if (fRead)
1433         {
1434             const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1435             const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1436             const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1437         }
1438
1439         // block header
1440         READWRITE(this->nVersion);
1441         READWRITE(hashPrev);
1442         READWRITE(hashMerkleRoot);
1443         READWRITE(nTime);
1444         READWRITE(nBits);
1445         READWRITE(nNonce);
1446         READWRITE(blockHash);
1447     )
1448
1449     uint256 GetBlockHash() const
1450     {
1451         if (fUseFastIndex && (nTime < GetAdjustedTime() - 24 * 60 * 60) && blockHash != 0)
1452             return blockHash;
1453
1454         CBlock block;
1455         block.nVersion        = nVersion;
1456         block.hashPrevBlock   = hashPrev;
1457         block.hashMerkleRoot  = hashMerkleRoot;
1458         block.nTime           = nTime;
1459         block.nBits           = nBits;
1460         block.nNonce          = nNonce;
1461
1462         const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1463
1464         return blockHash;
1465     }
1466
1467     std::string ToString() const
1468     {
1469         std::string str = "CDiskBlockIndex(";
1470         str += CBlockIndex::ToString();
1471         str += strprintf("\n                hashBlock=%s, hashPrev=%s, hashNext=%s)",
1472             GetBlockHash().ToString().c_str(),
1473             hashPrev.ToString().c_str(),
1474             hashNext.ToString().c_str());
1475         return str;
1476     }
1477
1478     void print() const
1479     {
1480         printf("%s\n", ToString().c_str());
1481     }
1482 };
1483
1484
1485
1486
1487
1488
1489
1490
1491 /** Describes a place in the block chain to another node such that if the
1492  * other node doesn't have the same branch, it can find a recent common trunk.
1493  * The further back it is, the further before the fork it may be.
1494  */
1495 class CBlockLocator
1496 {
1497 protected:
1498     std::vector<uint256> vHave;
1499 public:
1500
1501     CBlockLocator()
1502     {
1503     }
1504
1505     explicit CBlockLocator(const CBlockIndex* pindex)
1506     {
1507         Set(pindex);
1508     }
1509
1510     explicit CBlockLocator(uint256 hashBlock)
1511     {
1512         std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1513         if (mi != mapBlockIndex.end())
1514             Set((*mi).second);
1515     }
1516
1517     CBlockLocator(const std::vector<uint256>& vHaveIn)
1518     {
1519         vHave = vHaveIn;
1520     }
1521
1522     IMPLEMENT_SERIALIZE
1523     (
1524         if (!(nType & SER_GETHASH))
1525             READWRITE(nVersion);
1526         READWRITE(vHave);
1527     )
1528
1529     void SetNull()
1530     {
1531         vHave.clear();
1532     }
1533
1534     bool IsNull()
1535     {
1536         return vHave.empty();
1537     }
1538
1539     void Set(const CBlockIndex* pindex)
1540     {
1541         vHave.clear();
1542         int nStep = 1;
1543         while (pindex)
1544         {
1545             vHave.push_back(pindex->GetBlockHash());
1546
1547             // Exponentially larger steps back
1548             for (int i = 0; pindex && i < nStep; i++)
1549                 pindex = pindex->pprev;
1550             if (vHave.size() > 10)
1551                 nStep *= 2;
1552         }
1553         vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1554     }
1555
1556     int GetDistanceBack()
1557     {
1558         // Retrace how far back it was in the sender's branch
1559         int nDistance = 0;
1560         int nStep = 1;
1561         BOOST_FOREACH(const uint256& hash, vHave)
1562         {
1563             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1564             if (mi != mapBlockIndex.end())
1565             {
1566                 CBlockIndex* pindex = (*mi).second;
1567                 if (pindex->IsInMainChain())
1568                     return nDistance;
1569             }
1570             nDistance += nStep;
1571             if (nDistance > 10)
1572                 nStep *= 2;
1573         }
1574         return nDistance;
1575     }
1576
1577     CBlockIndex* GetBlockIndex()
1578     {
1579         // Find the first block the caller has in the main chain
1580         BOOST_FOREACH(const uint256& hash, vHave)
1581         {
1582             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1583             if (mi != mapBlockIndex.end())
1584             {
1585                 CBlockIndex* pindex = (*mi).second;
1586                 if (pindex->IsInMainChain())
1587                     return pindex;
1588             }
1589         }
1590         return pindexGenesisBlock;
1591     }
1592
1593     uint256 GetBlockHash()
1594     {
1595         // Find the first block the caller has in the main chain
1596         BOOST_FOREACH(const uint256& hash, vHave)
1597         {
1598             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1599             if (mi != mapBlockIndex.end())
1600             {
1601                 CBlockIndex* pindex = (*mi).second;
1602                 if (pindex->IsInMainChain())
1603                     return hash;
1604             }
1605         }
1606         return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1607     }
1608
1609     int GetHeight()
1610     {
1611         CBlockIndex* pindex = GetBlockIndex();
1612         if (!pindex)
1613             return 0;
1614         return pindex->nHeight;
1615     }
1616 };
1617
1618
1619
1620
1621
1622
1623
1624
1625 class CTxMemPool
1626 {
1627 public:
1628     mutable CCriticalSection cs;
1629     std::map<uint256, CTransaction> mapTx;
1630     std::map<COutPoint, CInPoint> mapNextTx;
1631
1632     bool accept(CTxDB& txdb, CTransaction &tx,
1633                 bool fCheckInputs, bool* pfMissingInputs);
1634     bool addUnchecked(const uint256& hash, CTransaction &tx);
1635     bool remove(CTransaction &tx);
1636     void clear();
1637     void queryHashes(std::vector<uint256>& vtxid);
1638
1639     size_t size()
1640     {
1641         LOCK(cs);
1642         return mapTx.size();
1643     }
1644
1645     bool exists(uint256 hash)
1646     {
1647         return (mapTx.count(hash) != 0);
1648     }
1649
1650     CTransaction& lookup(uint256 hash)
1651     {
1652         return mapTx[hash];
1653     }
1654 };
1655
1656 extern CTxMemPool mempool;
1657
1658 #endif