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