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 #include "ui_interface.h"
  17
  18 #include <limits>
  19 #include <list>
  20 #include <map>
  21
  22 using namespace std;
  23
  24 class CWallet;
  25 class CBlock;
  26 class CBlockIndex;
  27 class CKeyItem;
  28 class CReserveKey;
  29 class COutPoint;
  30
  31 class CAddress;
  32 class CInv;
  33 class CRequestTracker;
  34 class CNode;
  35
  36 //
  37 // Global state
  38 //
  39
  40 static const unsigned int MAX_BLOCK_SIZE = 1000000;
  41 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
  42 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
  43 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
  44 static const unsigned int MAX_INV_SZ = 50000;
  45
  46 static const int64_t MIN_TX_FEE = CENT/10;
  47 static const int64_t MIN_RELAY_TX_FEE = CENT/50;
  48
  49 static const int64_t MAX_MONEY = numeric_limits<int64_t>::max();
  50 static const int64_t MAX_MINT_PROOF_OF_WORK = 100 * COIN;
  51 static const int64_t MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
  52 static const int64_t MIN_TXOUT_AMOUNT = CENT/100;
  53
  54
  55 inline bool MoneyRange(int64_t nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
  56 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
  57 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov  5 00:53:20 1985 UTC
  58 // Maximum number of script-checking threads allowed
  59 static const int MAX_SCRIPTCHECK_THREADS = 16;
  60
  61 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
  62 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
  63
  64 inline int64_t PastDrift(int64_t nTime)   { return nTime - 2 * nOneHour; } // up to 2 hours from the past
  65 inline int64_t FutureDrift(int64_t nTime) { return nTime + 2 * nOneHour; } // up to 2 hours from the future
  66
  67 extern CScript COINBASE_FLAGS;
  68 extern CCriticalSection cs_main;
  69 extern map<uint256, CBlockIndex*> mapBlockIndex;
  70 extern set<pair<COutPoint, unsigned int> > setStakeSeen;
  71 extern CBlockIndex* pindexGenesisBlock;
  72 extern unsigned int nNodeLifespan;
  73 extern unsigned int nStakeMinAge;
  74 extern int nCoinbaseMaturity;
  75 extern int nBestHeight;
  76 extern uint256 nBestChainTrust;
  77 extern uint256 nBestInvalidTrust;
  78 extern uint256 hashBestChain;
  79 extern CBlockIndex* pindexBest;
  80 extern unsigned int nTransactionsUpdated;
  81 extern uint64_t nLastBlockTx;
  82 extern uint64_t nLastBlockSize;
  83 extern uint32_t nLastCoinStakeSearchInterval;
  84 extern const string strMessageMagic;
  85 extern int64_t nTimeBestReceived;
  86 extern CCriticalSection cs_setpwalletRegistered;
  87 extern set<CWallet*> setpwalletRegistered;
  88 extern uint32_t nNetworkID;
  89 extern map<uint256, CBlock*> mapOrphanBlocks;
  90
  91 // Settings
  92 extern int64_t nTransactionFee;
  93 extern int64_t nMinimumInputValue;
  94 extern bool fUseFastIndex;
  95 extern int nScriptCheckThreads;
  96 extern const uint256 entropyStore[38];
  97
  98 // Minimum disk space required - used in CheckDiskSpace()
  99 static const uint64_t nMinDiskSpace = 52428800;
 100
 101 class CReserveKey;
 102 class CTxDB;
 103 class CTxIndex;
 104 class CScriptCheck;
 105
 106 void RegisterWallet(CWallet* pwalletIn);
 107 void UnregisterWallet(CWallet* pwalletIn);
 108 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
 109 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
 110 bool CheckDiskSpace(uint64_t nAdditionalBytes=0);
 111 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
 112 FILE* AppendBlockFile(unsigned int& nFileRet);
 113
 114 void UnloadBlockIndex();
 115 bool LoadBlockIndex(bool fAllowNew=true);
 116 void PrintBlockTree();
 117 CBlockIndex* FindBlockByHeight(int nHeight);
 118 bool ProcessMessages(CNode* pfrom);
 119 bool SendMessages(CNode* pto);
 120 bool LoadExternalBlockFile(FILE* fileIn, CClientUIInterface& uiInterface);
 121
 122 // Run an instance of the script checking thread
 123 void ThreadScriptCheck(void* parg);
 124 // Stop the script checking threads
 125 void ThreadScriptCheckQuit();
 126
 127 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
 128 unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, bool fProofOfStake);
 129 int64_t GetProofOfWorkReward(unsigned int nBits, int64_t nFees=0);
 130 int64_t GetProofOfStakeReward(int64_t nCoinAge, unsigned int nBits, int64_t nTime, bool bCoinYearOnly=false);
 131 unsigned int ComputeMinWork(unsigned int nBase, int64_t nTime);
 132 unsigned int ComputeMinStake(unsigned int nBase, int64_t nTime, unsigned int nBlockTime);
 133 int GetNumBlocksOfPeers();
 134 bool IsInitialBlockDownload();
 135 string GetWarnings(string strFor);
 136 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
 137 uint256 WantedByOrphan(const CBlock* pblockOrphan);
 138 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
 139 void ResendWalletTransactions(bool fForceResend=false);
 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, 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 = numeric_limits<uint32_t>::max(); nBlockPos = 0; nTxPos = 0; }
 173     bool IsNull() const { return (nFile == numeric_limits<uint32_t>::max()); }
 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     string ToString() const
 189     {
 190         if (IsNull())
 191             return "null";
 192         else
 193             return strprintf("(nFile=%" PRIu32 ", nBlockPos=%" PRIu32 ", nTxPos=%" PRIu32 ")", 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 = numeric_limits<uint32_t>::max(); }
 214     bool IsNull() const { return (ptx == NULL && n == numeric_limits<uint32_t>::max()); }
 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 = numeric_limits<uint32_t>::max(); }
 230     bool IsNull() const { return (hash == 0 && n == numeric_limits<uint32_t>::max()); }
 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     string ToString() const
 248     {
 249         return strprintf("COutPoint(%s, %" PRIu32 ")", 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 = numeric_limits<unsigned int>::max();
 275     }
 276
 277     explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=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=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 == 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     string ToStringShort() const
 316     {
 317         return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
 318     }
 319
 320     string ToString() const
 321     {
 322         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 != numeric_limits<unsigned int>::max())
 330             str += strprintf(", nSequence=%" PRIu32, 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     string ToStringShort() const
 409     {
 410         return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
 411     }
 412
 413     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 map<uint256, 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     vector<CTxIn> vin;
 449     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         for(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 = 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(string& strReason) const;
 552     bool IsStandard() const
 553     {
 554         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         for(const CTxOut& txout :  vout)
 586         {
 587             nValueOut += txout.nValue;
 588             if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
 589                 throw 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         auto 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 (const exception&) {
 627             return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
 628         }
 629
 630         // Return file pointer
 631         if (pfileRet)
 632         {
 633             if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
 634                 return error("CTransaction::ReadFromDisk() : second fseek failed");
 635             *pfileRet = filein.release();
 636         }
 637         return true;
 638     }
 639
 640     friend bool operator==(const CTransaction& a, const CTransaction& b)
 641     {
 642         return (a.nVersion  == b.nVersion &&
 643                 a.nTime     == b.nTime &&
 644                 a.vin       == b.vin &&
 645                 a.vout      == b.vout &&
 646                 a.nLockTime == b.nLockTime);
 647     }
 648
 649     friend bool operator!=(const CTransaction& a, const CTransaction& b)
 650     {
 651         return !(a == b);
 652     }
 653
 654     string ToStringShort() const
 655     {
 656         string str;
 657         str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
 658         return str;
 659     }
 660
 661     string ToString() const
 662     {
 663         string str;
 664         str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
 665         str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%" PRIszu ", vout.size=%" PRIszu ", nLockTime=%d)\n",
 666             GetHash().ToString().substr(0,10).c_str(),
 667             nTime,
 668             nVersion,
 669             vin.size(),
 670             vout.size(),
 671             nLockTime);
 672         for (unsigned int i = 0; i < vin.size(); i++)
 673             str += "    " + vin[i].ToString() + "\n";
 674         for (unsigned int i = 0; i < vout.size(); i++)
 675             str += "    " + vout[i].ToString() + "\n";
 676         return str;
 677     }
 678
 679     void print() const
 680     {
 681         printf("%s", ToString().c_str());
 682     }
 683
 684
 685     bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
 686     bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
 687     bool ReadFromDisk(COutPoint prevout);
 688     bool DisconnectInputs(CTxDB& txdb);
 689
 690     /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
 691
 692      @param[in] txdb    Transaction database
 693      @param[in] mapTestPool     List of pending changes to the transaction index database
 694      @param[in] fBlock  True if being called to add a new best-block to the chain
 695      @param[in] fMiner  True if being called by CreateNewBlock
 696      @param[out] inputsRet      Pointers to this transaction's inputs
 697      @param[out] fInvalid       returns true if transaction is invalid
 698      @return    Returns true if all inputs are in txdb or mapTestPool
 699      */
 700     bool FetchInputs(CTxDB& txdb, const map<uint256, CTxIndex>& mapTestPool,
 701                      bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
 702
 703     /** Sanity check previous transactions, then, if all checks succeed,
 704         mark them as spent by this transaction.
 705
 706         @param[in] inputs       Previous transactions (from FetchInputs)
 707         @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
 708         @param[in] posThisTx    Position of this transaction on disk
 709         @param[in] pindexBlock
 710         @param[in] fBlock       true if called from ConnectBlock
 711         @param[in] fMiner       true if called from CreateNewBlock
 712         @param[in] fScriptChecks        enable scripts validation?
 713         @param[in] flags        STRICT_FLAGS script validation flags
 714         @param[in] pvChecks     NULL If pvChecks is not NULL, script checks are pushed onto it instead of being performed inline.
 715         @return Returns true if all checks succeed
 716      */
 717     bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs, map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx, const CBlockIndex* pindexBlock,
 718                      bool fBlock, bool fMiner, bool fScriptChecks=true,
 719                      unsigned int flags=STRICT_FLAGS, vector<CScriptCheck> *pvChecks = NULL);
 720     bool ClientConnectInputs();
 721     bool CheckTransaction() const;
 722     bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
 723     bool GetCoinAge(CTxDB& txdb, uint64_t& nCoinAge) const;  // ppcoin: get transaction coin age
 724
 725 protected:
 726     const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
 727 };
 728
 729 /** Closure representing one script verification
 730  *  Note that this stores references to the spending transaction */
 731 class CScriptCheck
 732 {
 733 private:
 734     CScript scriptPubKey;
 735     const CTransaction *ptxTo = nullptr;
 736     unsigned int nIn = 0;
 737     unsigned int nFlags = 0;
 738     int nHashType = 0;
 739
 740 public:
 741     CScriptCheck() {}
 742     CScriptCheck(const CTransaction& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, int nHashTypeIn) :
 743         scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey),
 744         ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), nHashType(nHashTypeIn) { }
 745
 746     bool operator()() const;
 747
 748     void swap(CScriptCheck &check) {
 749         scriptPubKey.swap(check.scriptPubKey);
 750         std::swap(ptxTo, check.ptxTo);
 751         std::swap(nIn, check.nIn);
 752         std::swap(nFlags, check.nFlags);
 753         std::swap(nHashType, check.nHashType);
 754     }
 755 };
 756
 757
 758
 759
 760 /** A transaction with a merkle branch linking it to the block chain. */
 761 class CMerkleTx : public CTransaction
 762 {
 763 public:
 764     uint256 hashBlock;
 765     vector<uint256> vMerkleBranch;
 766     int32_t nIndex;
 767
 768     // memory only
 769     mutable bool fMerkleVerified;
 770
 771
 772     CMerkleTx()
 773     {
 774         Init();
 775     }
 776
 777     CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
 778     {
 779         Init();
 780     }
 781
 782     void Init()
 783     {
 784         hashBlock = 0;
 785         nIndex = -1;
 786         fMerkleVerified = false;
 787     }
 788
 789
 790     IMPLEMENT_SERIALIZE
 791     (
 792         nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
 793         nVersion = this->nVersion;
 794         READWRITE(hashBlock);
 795         READWRITE(vMerkleBranch);
 796         READWRITE(nIndex);
 797     )
 798
 799
 800     int SetMerkleBranch(const CBlock* pblock=NULL);
 801     int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
 802     int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
 803     bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
 804     int GetBlocksToMaturity() const;
 805     bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
 806     bool AcceptToMemoryPool();
 807 };
 808
 809
 810
 811
 812 /**  A txdb record that contains the disk location of a transaction and the
 813  * locations of transactions that spend its outputs.  vSpent is really only
 814  * used as a flag, but having the location is very helpful for debugging.
 815  */
 816 class CTxIndex
 817 {
 818 public:
 819     CDiskTxPos pos;
 820     vector<CDiskTxPos> vSpent;
 821
 822     CTxIndex()
 823     {
 824         SetNull();
 825     }
 826
 827     CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
 828     {
 829         pos = posIn;
 830         vSpent.resize(nOutputs);
 831     }
 832
 833     IMPLEMENT_SERIALIZE
 834     (
 835         if (!(nType & SER_GETHASH))
 836             READWRITE(nVersion);
 837         READWRITE(pos);
 838         READWRITE(vSpent);
 839     )
 840
 841     void SetNull()
 842     {
 843         pos.SetNull();
 844         vSpent.clear();
 845     }
 846
 847     bool IsNull()
 848     {
 849         return pos.IsNull();
 850     }
 851
 852     friend bool operator==(const CTxIndex& a, const CTxIndex& b)
 853     {
 854         return (a.pos    == b.pos &&
 855                 a.vSpent == b.vSpent);
 856     }
 857
 858     friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
 859     {
 860         return !(a == b);
 861     }
 862     int GetDepthInMainChain() const;
 863
 864 };
 865
 866
 867 /** Nodes collect new transactions into a block, hash them into a hash tree,
 868  * and scan through nonce values to make the block's hash satisfy proof-of-work
 869  * requirements.  When they solve the proof-of-work, they broadcast the block
 870  * to everyone and the block is added to the block chain.  The first transaction
 871  * in the block is a special one that creates a new coin owned by the creator
 872  * of the block.
 873  *
 874  * Blocks are appended to blk0001.dat files on disk.  Their location on disk
 875  * is indexed by CBlockIndex objects in memory.
 876  */
 877 class CBlock
 878 {
 879 public:
 880     // header
 881     static const int CURRENT_VERSION=6;
 882     int32_t nVersion;
 883     uint256 hashPrevBlock;
 884     uint256 hashMerkleRoot;
 885     uint32_t nTime;
 886     uint32_t nBits;
 887     uint32_t nNonce;
 888
 889     // network and disk
 890     vector<CTransaction> vtx;
 891
 892     // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
 893     vector<unsigned char> vchBlockSig;
 894
 895     // memory only
 896     mutable vector<uint256> vMerkleTree;
 897
 898     // Denial-of-service detection:
 899     mutable int nDoS;
 900     bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
 901
 902     CBlock()
 903     {
 904         SetNull();
 905     }
 906
 907     IMPLEMENT_SERIALIZE
 908     (
 909         READWRITE(this->nVersion);
 910         nVersion = this->nVersion;
 911         READWRITE(hashPrevBlock);
 912         READWRITE(hashMerkleRoot);
 913         READWRITE(nTime);
 914         READWRITE(nBits);
 915         READWRITE(nNonce);
 916
 917         // ConnectBlock depends on vtx following header to generate CDiskTxPos
 918         if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
 919         {
 920             READWRITE(vtx);
 921             READWRITE(vchBlockSig);
 922         }
 923         else if (fRead)
 924         {
 925             const_cast<CBlock*>(this)->vtx.clear();
 926             const_cast<CBlock*>(this)->vchBlockSig.clear();
 927         }
 928     )
 929
 930     void SetNull()
 931     {
 932         nVersion = CBlock::CURRENT_VERSION;
 933         hashPrevBlock = 0;
 934         hashMerkleRoot = 0;
 935         nTime = 0;
 936         nBits = 0;
 937         nNonce = 0;
 938         vtx.clear();
 939         vchBlockSig.clear();
 940         vMerkleTree.clear();
 941         nDoS = 0;
 942     }
 943
 944     bool IsNull() const
 945     {
 946         return (nBits == 0);
 947     }
 948
 949     uint256 GetHash() const
 950     {
 951         return scrypt_blockhash((const uint8_t*)&nVersion);
 952     }
 953
 954     int64_t GetBlockTime() const
 955     {
 956         return (int64_t)nTime;
 957     }
 958
 959     void UpdateTime(const CBlockIndex* pindexPrev);
 960
 961     // ppcoin: entropy bit for stake modifier if chosen by modifier
 962     unsigned int GetStakeEntropyBit(unsigned int nHeight) const
 963     {
 964         // Protocol switch to support p2pool at novacoin block #9689
 965         if (nHeight >= 9689 || fTestNet)
 966         {
 967             // Take last bit of block hash as entropy bit
 968             auto nEntropyBit = (GetHash().Get32()) & (uint32_t)1;
 969             if (fDebug && GetBoolArg("-printstakemodifier"))
 970                 printf("GetStakeEntropyBit: nTime=%" PRIu32 " hashBlock=%s nEntropyBit=%" PRIu32 "\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
 971             return nEntropyBit;
 972         }
 973
 974         // Before novacoin block #9689 - get from pregenerated table
 975         int nBitNum = nHeight & 0xFF;
 976         int nItemNum = nHeight / 0xFF;
 977
 978         auto nEntropyBit = ((entropyStore[nItemNum] & (uint256(1) << nBitNum)) >> nBitNum).Get32();
 979         if (fDebug && GetBoolArg("-printstakemodifier"))
 980             printf("GetStakeEntropyBit: from pregenerated table, nHeight=%" PRIu32 " nEntropyBit=%" PRIu32 "\n", nHeight, nEntropyBit);
 981         return nEntropyBit;
 982     }
 983
 984     // ppcoin: two types of block: proof-of-work or proof-of-stake
 985     bool IsProofOfStake() const
 986     {
 987         return (vtx.size() > 1 && vtx[1].IsCoinStake());
 988     }
 989
 990     bool IsProofOfWork() const
 991     {
 992         return !IsProofOfStake();
 993     }
 994
 995     pair<COutPoint, unsigned int> GetProofOfStake() const
 996     {
 997         if (IsProofOfStake())
 998             return { vtx[1].vin[0].prevout, vtx[1].nTime };
 999         return { COutPoint(), (unsigned int)0 };
1000     }
1001
1002     // ppcoin: get max transaction timestamp
1003     int64_t GetMaxTransactionTime() const
1004     {
1005         int64_t maxTransactionTime = 0;
1006         for(const auto& tx : vtx)
1007             maxTransactionTime = max(maxTransactionTime, (int64_t)tx.nTime);
1008         return maxTransactionTime;
1009     }
1010
1011     uint256 BuildMerkleTree() const
1012     {
1013         vMerkleTree.clear();
1014         for(const auto& tx :  vtx)
1015             vMerkleTree.push_back(tx.GetHash());
1016         int j = 0;
1017         for (int nSize = (int)vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1018         {
1019             for (int i = 0; i < nSize; i += 2)
1020             {
1021                 int i2 = min(i+1, nSize-1);
1022                 vMerkleTree.push_back(Hash(vMerkleTree[j+i].begin(),  vMerkleTree[j+i].end(),
1023                                            vMerkleTree[j+i2].begin(), vMerkleTree[j+i2].end()));
1024             }
1025             j += nSize;
1026         }
1027         return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
1028     }
1029
1030     vector<uint256> GetMerkleBranch(int nIndex) const
1031     {
1032         if (vMerkleTree.empty())
1033             BuildMerkleTree();
1034         vector<uint256> vMerkleBranch;
1035         int j = 0;
1036         for (int nSize = (int)vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1037         {
1038             int i = min(nIndex^1, nSize-1);
1039             vMerkleBranch.push_back(vMerkleTree[j+i]);
1040             nIndex >>= 1;
1041             j += nSize;
1042         }
1043         return vMerkleBranch;
1044     }
1045
1046     static uint256 CheckMerkleBranch(uint256 hash, const vector<uint256>& vMerkleBranch, int nIndex)
1047     {
1048         if (nIndex == -1)
1049             return 0;
1050         for(const uint256& otherside :  vMerkleBranch)
1051         {
1052             if (nIndex & 1)
1053                 hash = Hash(otherside.begin(), otherside.end(), hash.begin(), hash.end());
1054             else
1055                 hash = Hash(hash.begin(), hash.end(), otherside.begin(), otherside.end());
1056             nIndex >>= 1;
1057         }
1058         return hash;
1059     }
1060
1061
1062     bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1063     {
1064         // Open history file to append
1065         auto fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1066         if (!fileout)
1067             return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1068
1069         // Write index header
1070         unsigned int nSize = fileout.GetSerializeSize(*this);
1071         fileout << nNetworkID << nSize;
1072
1073         // Write block
1074         long fileOutPos = ftell(fileout);
1075         if (fileOutPos < 0)
1076             return error("CBlock::WriteToDisk() : ftell failed");
1077         nBlockPosRet = fileOutPos;
1078         fileout << *this;
1079
1080         // Flush stdio buffers and commit to disk before returning
1081         fflush(fileout);
1082         if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1083             FileCommit(fileout);
1084
1085         return true;
1086     }
1087
1088     bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1089     {
1090         SetNull();
1091
1092         // Open history file to read
1093         auto filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1094         if (!filein)
1095             return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1096         if (!fReadTransactions)
1097             filein.nType |= SER_BLOCKHEADERONLY;
1098
1099         // Read block
1100         try {
1101             filein >> *this;
1102         }
1103         catch (const exception&) {
1104             return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
1105         }
1106
1107         // Check the header
1108         if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1109             return error("CBlock::ReadFromDisk() : errors in block header");
1110
1111         return true;
1112     }
1113
1114
1115
1116     void print() const
1117     {
1118         printf("CBlock(hash=%s, ver=%" PRId32 ", hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%" PRIu32 ", nBits=%08x, nNonce=%" PRIu32 ", vtx=%" PRIszu ", vchBlockSig=%s)\n",
1119             GetHash().ToString().c_str(),
1120             nVersion,
1121             hashPrevBlock.ToString().c_str(),
1122             hashMerkleRoot.ToString().c_str(),
1123             nTime, nBits, nNonce,
1124             vtx.size(),
1125             HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1126         for (unsigned int i = 0; i < vtx.size(); i++)
1127         {
1128             printf("  ");
1129             vtx[i].print();
1130         }
1131         printf("  vMerkleTree: ");
1132         for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1133             printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1134         printf("\n");
1135     }
1136
1137
1138     bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1139     bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1140     bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1141     bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1142     bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1143     bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1144     bool AcceptBlock();
1145     bool GetCoinAge(uint64_t& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1146     bool CheckBlockSignature() const;
1147
1148 private:
1149     bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1150 };
1151
1152
1153
1154
1155
1156
1157 /** The block chain is a tree shaped structure starting with the
1158  * genesis block at the root, with each block potentially having multiple
1159  * candidates to be the next block.  pprev and pnext link a path through the
1160  * main/longest chain.  A blockindex may have multiple pprev pointing back
1161  * to it, but pnext will only point forward to the longest branch, or will
1162  * be null if the block is not part of the longest chain.
1163  */
1164 class CBlockIndex
1165 {
1166 public:
1167     const uint256* phashBlock;
1168     CBlockIndex* pprev;
1169     CBlockIndex* pnext;
1170     uint32_t nFile;
1171     uint32_t nBlockPos;
1172     uint256 nChainTrust; // ppcoin: trust score of block chain
1173     int32_t nHeight;
1174
1175     int64_t nMint;
1176     int64_t nMoneySupply;
1177
1178     uint32_t nFlags;  // ppcoin: block index flags
1179     enum
1180     {
1181         BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1182         BLOCK_STAKE_ENTROPY  = (1 << 1), // entropy bit for stake modifier
1183         BLOCK_STAKE_MODIFIER = (1 << 2)  // regenerated stake modifier
1184     };
1185
1186     uint64_t nStakeModifier; // hash modifier for proof-of-stake
1187     uint32_t nStakeModifierChecksum; // checksum of index; in-memeory only
1188
1189     // proof-of-stake specific fields
1190     COutPoint prevoutStake;
1191     uint32_t nStakeTime;
1192     uint256 hashProofOfStake;
1193
1194     // block header
1195     int32_t  nVersion;
1196     uint256  hashMerkleRoot;
1197     uint32_t nTime;
1198     uint32_t nBits;
1199     uint32_t nNonce;
1200
1201     CBlockIndex()
1202     {
1203         phashBlock = NULL;
1204         pprev = NULL;
1205         pnext = NULL;
1206         nFile = 0;
1207         nBlockPos = 0;
1208         nHeight = 0;
1209         nChainTrust = 0;
1210         nMint = 0;
1211         nMoneySupply = 0;
1212         nFlags = 0;
1213         nStakeModifier = 0;
1214         nStakeModifierChecksum = 0;
1215         hashProofOfStake = 0;
1216         prevoutStake.SetNull();
1217         nStakeTime = 0;
1218
1219         nVersion       = 0;
1220         hashMerkleRoot = 0;
1221         nTime          = 0;
1222         nBits          = 0;
1223         nNonce         = 0;
1224     }
1225
1226     CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1227     {
1228         phashBlock = NULL;
1229         pprev = NULL;
1230         pnext = NULL;
1231         nFile = nFileIn;
1232         nBlockPos = nBlockPosIn;
1233         nHeight = 0;
1234         nChainTrust = 0;
1235         nMint = 0;
1236         nMoneySupply = 0;
1237         nFlags = 0;
1238         nStakeModifier = 0;
1239         nStakeModifierChecksum = 0;
1240         hashProofOfStake = 0;
1241         if (block.IsProofOfStake())
1242         {
1243             SetProofOfStake();
1244             prevoutStake = block.vtx[1].vin[0].prevout;
1245             nStakeTime = block.vtx[1].nTime;
1246         }
1247         else
1248         {
1249             prevoutStake.SetNull();
1250             nStakeTime = 0;
1251         }
1252
1253         nVersion       = block.nVersion;
1254         hashMerkleRoot = block.hashMerkleRoot;
1255         nTime          = block.nTime;
1256         nBits          = block.nBits;
1257         nNonce         = block.nNonce;
1258     }
1259
1260     CBlock GetBlockHeader() const
1261     {
1262         CBlock block;
1263         block.nVersion       = nVersion;
1264         if (pprev)
1265             block.hashPrevBlock = pprev->GetBlockHash();
1266         block.hashMerkleRoot = hashMerkleRoot;
1267         block.nTime          = nTime;
1268         block.nBits          = nBits;
1269         block.nNonce         = nNonce;
1270         return block;
1271     }
1272
1273     uint256 GetBlockHash() const
1274     {
1275         return *phashBlock;
1276     }
1277
1278     int64_t GetBlockTime() const
1279     {
1280         return (int64_t)nTime;
1281     }
1282
1283     uint256 GetBlockTrust() const;
1284
1285     bool IsInMainChain() const
1286     {
1287         return (pnext || this == pindexBest);
1288     }
1289
1290     bool CheckIndex() const
1291     {
1292         return true;
1293     }
1294
1295     enum { nMedianTimeSpan=11 };
1296
1297     int64_t GetMedianTimePast() const
1298     {
1299         int64_t pmedian[nMedianTimeSpan];
1300         int64_t* pbegin = &pmedian[nMedianTimeSpan];
1301         int64_t* pend = &pmedian[nMedianTimeSpan];
1302
1303         const CBlockIndex* pindex = this;
1304         for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1305             *(--pbegin) = pindex->GetBlockTime();
1306
1307         sort(pbegin, pend);
1308         return pbegin[(pend - pbegin)/2];
1309     }
1310
1311     int64_t GetMedianTime() const
1312     {
1313         const CBlockIndex* pindex = this;
1314         for (int i = 0; i < nMedianTimeSpan/2; i++)
1315         {
1316             if (!pindex->pnext)
1317                 return GetBlockTime();
1318             pindex = pindex->pnext;
1319         }
1320         return pindex->GetMedianTimePast();
1321     }
1322
1323     /**
1324      * Returns true if there are nRequired or more blocks of minVersion or above
1325      * in the last nToCheck blocks, starting at pstart and going backwards.
1326      */
1327     static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1328                                 unsigned int nRequired, unsigned int nToCheck);
1329
1330
1331     bool IsProofOfWork() const
1332     {
1333         return !(nFlags & BLOCK_PROOF_OF_STAKE);
1334     }
1335
1336     bool IsProofOfStake() const
1337     {
1338         return (nFlags & BLOCK_PROOF_OF_STAKE);
1339     }
1340
1341     void SetProofOfStake()
1342     {
1343         nFlags |= BLOCK_PROOF_OF_STAKE;
1344     }
1345
1346     unsigned int GetStakeEntropyBit() const
1347     {
1348         return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1349     }
1350
1351     bool SetStakeEntropyBit(unsigned int nEntropyBit)
1352     {
1353         if (nEntropyBit > 1)
1354             return false;
1355         nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1356         return true;
1357     }
1358
1359     bool GeneratedStakeModifier() const
1360     {
1361         return (nFlags & BLOCK_STAKE_MODIFIER) != 0;
1362     }
1363
1364     void SetStakeModifier(uint64_t nModifier, bool fGeneratedStakeModifier)
1365     {
1366         nStakeModifier = nModifier;
1367         if (fGeneratedStakeModifier)
1368             nFlags |= BLOCK_STAKE_MODIFIER;
1369     }
1370
1371     string ToString() const
1372     {
1373         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)",
1374             (const void*)pprev, (const void*)pnext, nFile, nBlockPos, nHeight,
1375             FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1376             GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1377             nStakeModifier, nStakeModifierChecksum,
1378             hashProofOfStake.ToString().c_str(),
1379             prevoutStake.ToString().c_str(), nStakeTime,
1380             hashMerkleRoot.ToString().c_str(),
1381             GetBlockHash().ToString().c_str());
1382     }
1383
1384     void print() const
1385     {
1386         printf("%s\n", ToString().c_str());
1387     }
1388 };
1389
1390
1391
1392 /** Used to marshal pointers into hashes for db storage. */
1393 class CDiskBlockIndex : public CBlockIndex
1394 {
1395 private:
1396     uint256 blockHash;
1397
1398 public:
1399     uint256 hashPrev;
1400     uint256 hashNext;
1401
1402     CDiskBlockIndex()
1403     {
1404         hashPrev = 0;
1405         hashNext = 0;
1406         blockHash = 0;
1407     }
1408
1409     explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1410     {
1411         hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1412         hashNext = (pnext ? pnext->GetBlockHash() : 0);
1413     }
1414
1415     IMPLEMENT_SERIALIZE
1416     (
1417         if (!(nType & SER_GETHASH))
1418             READWRITE(nVersion);
1419
1420         READWRITE(hashNext);
1421         READWRITE(nFile);
1422         READWRITE(nBlockPos);
1423         READWRITE(nHeight);
1424         READWRITE(nMint);
1425         READWRITE(nMoneySupply);
1426         READWRITE(nFlags);
1427         READWRITE(nStakeModifier);
1428         if (IsProofOfStake())
1429         {
1430             READWRITE(prevoutStake);
1431             READWRITE(nStakeTime);
1432             READWRITE(hashProofOfStake);
1433         }
1434         else if (fRead)
1435         {
1436             const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1437             const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1438             const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1439         }
1440
1441         // block header
1442         READWRITE(this->nVersion);
1443         READWRITE(hashPrev);
1444         READWRITE(hashMerkleRoot);
1445         READWRITE(nTime);
1446         READWRITE(nBits);
1447         READWRITE(nNonce);
1448         READWRITE(blockHash);
1449     )
1450
1451     uint256 GetBlockHash() const
1452     {
1453         if (fUseFastIndex && blockHash != 0)
1454             return blockHash;
1455
1456         CBlock block;
1457         block.nVersion        = nVersion;
1458         block.hashPrevBlock   = hashPrev;
1459         block.hashMerkleRoot  = hashMerkleRoot;
1460         block.nTime           = nTime;
1461         block.nBits           = nBits;
1462         block.nNonce          = nNonce;
1463
1464         const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1465
1466         return blockHash;
1467     }
1468
1469     string ToString() const
1470     {
1471         string str = "CDiskBlockIndex(";
1472         str += CBlockIndex::ToString();
1473         str += strprintf("\n                hashBlock=%s, hashPrev=%s, hashNext=%s)",
1474             GetBlockHash().ToString().c_str(),
1475             hashPrev.ToString().c_str(),
1476             hashNext.ToString().c_str());
1477         return str;
1478     }
1479
1480     void print() const
1481     {
1482         printf("%s\n", ToString().c_str());
1483     }
1484 };
1485
1486
1487
1488
1489
1490
1491
1492
1493 /** Describes a place in the block chain to another node such that if the
1494  * other node doesn't have the same branch, it can find a recent common trunk.
1495  * The further back it is, the further before the fork it may be.
1496  */
1497 class CBlockLocator
1498 {
1499 protected:
1500     vector<uint256> vHave;
1501 public:
1502
1503     CBlockLocator()
1504     {
1505     }
1506
1507     explicit CBlockLocator(const CBlockIndex* pindex)
1508     {
1509         Set(pindex);
1510     }
1511
1512     explicit CBlockLocator(uint256 hashBlock)
1513     {
1514         auto mi = mapBlockIndex.find(hashBlock);
1515         if (mi != mapBlockIndex.end())
1516             Set((*mi).second);
1517     }
1518
1519     CBlockLocator(const vector<uint256>& vHaveIn)
1520     {
1521         vHave = vHaveIn;
1522     }
1523
1524     IMPLEMENT_SERIALIZE
1525     (
1526         if (!(nType & SER_GETHASH))
1527             READWRITE(nVersion);
1528         READWRITE(vHave);
1529     )
1530
1531     void SetNull()
1532     {
1533         vHave.clear();
1534     }
1535
1536     bool IsNull()
1537     {
1538         return vHave.empty();
1539     }
1540
1541     void Set(const CBlockIndex* pindex)
1542     {
1543         vHave.clear();
1544         int nStep = 1;
1545         while (pindex)
1546         {
1547             vHave.push_back(pindex->GetBlockHash());
1548
1549             // Exponentially larger steps back
1550             for (int i = 0; pindex && i < nStep; i++)
1551                 pindex = pindex->pprev;
1552             if (vHave.size() > 10)
1553                 nStep *= 2;
1554         }
1555         vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1556     }
1557
1558     int GetDistanceBack()
1559     {
1560         // Retrace how far back it was in the sender's branch
1561         int nDistance = 0;
1562         int nStep = 1;
1563         for(const auto& hash :  vHave)
1564         {
1565             auto mi = mapBlockIndex.find(hash);
1566             if (mi != mapBlockIndex.end())
1567             {
1568                 auto pindex = (*mi).second;
1569                 if (pindex->IsInMainChain())
1570                     return nDistance;
1571             }
1572             nDistance += nStep;
1573             if (nDistance > 10)
1574                 nStep *= 2;
1575         }
1576         return nDistance;
1577     }
1578
1579     CBlockIndex* GetBlockIndex()
1580     {
1581         // Find the first block the caller has in the main chain
1582         for(const auto& hash :  vHave)
1583         {
1584             auto mi = mapBlockIndex.find(hash);
1585             if (mi != mapBlockIndex.end())
1586             {
1587                 auto pindex = (*mi).second;
1588                 if (pindex->IsInMainChain())
1589                     return pindex;
1590             }
1591         }
1592         return pindexGenesisBlock;
1593     }
1594
1595     uint256 GetBlockHash()
1596     {
1597         // Find the first block the caller has in the main chain
1598         for(const uint256& hash :  vHave)
1599         {
1600             auto mi = mapBlockIndex.find(hash);
1601             if (mi != mapBlockIndex.end())
1602             {
1603                 auto pindex = (*mi).second;
1604                 if (pindex->IsInMainChain())
1605                     return hash;
1606             }
1607         }
1608         return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1609     }
1610
1611     int GetHeight()
1612     {
1613         CBlockIndex* pindex = GetBlockIndex();
1614         if (!pindex)
1615             return 0;
1616         return pindex->nHeight;
1617     }
1618 };
1619
1620
1621
1622
1623
1624
1625
1626
1627 class CTxMemPool
1628 {
1629 public:
1630     mutable CCriticalSection cs;
1631     map<uint256, CTransaction> mapTx;
1632     map<COutPoint, CInPoint> mapNextTx;
1633
1634     bool accept(CTxDB& txdb, CTransaction &tx,
1635                 bool fCheckInputs, bool* pfMissingInputs);
1636     bool addUnchecked(const uint256& hash, CTransaction &tx);
1637     bool remove(CTransaction &tx);
1638     void clear();
1639     void queryHashes(vector<uint256>& vtxid);
1640
1641     size_t size()
1642     {
1643         LOCK(cs);
1644         return mapTx.size();
1645     }
1646
1647     bool exists(const uint256 &hash)
1648     {
1649         return (mapTx.count(hash) != 0);
1650     }
1651
1652     CTransaction& lookup(const uint256 &hash)
1653     {
1654         return mapTx[hash];
1655     }
1656 };
1657
1658 extern CTxMemPool mempool;
1659
1660 #endif