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, uint32_t 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, uint32_t 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, uint32_t 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
 731
 732
 733 /** A transaction with a merkle branch linking it to the block chain. */
 734 class CMerkleTx : public CTransaction
 735 {
 736 public:
 737     uint256 hashBlock;
 738     vector<uint256> vMerkleBranch;
 739     int32_t nIndex;
 740
 741     // memory only
 742     mutable bool fMerkleVerified;
 743
 744
 745     CMerkleTx()
 746     {
 747         Init();
 748     }
 749
 750     CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
 751     {
 752         Init();
 753     }
 754
 755     void Init()
 756     {
 757         hashBlock = 0;
 758         nIndex = -1;
 759         fMerkleVerified = false;
 760     }
 761
 762
 763     IMPLEMENT_SERIALIZE
 764     (
 765         nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
 766         nVersion = this->nVersion;
 767         READWRITE(hashBlock);
 768         READWRITE(vMerkleBranch);
 769         READWRITE(nIndex);
 770     )
 771
 772
 773     int SetMerkleBranch(const CBlock* pblock=NULL);
 774     int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
 775     int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
 776     bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
 777     int GetBlocksToMaturity() const;
 778     bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
 779     bool AcceptToMemoryPool();
 780 };
 781
 782
 783
 784
 785 /**  A txdb record that contains the disk location of a transaction and the
 786  * locations of transactions that spend its outputs.  vSpent is really only
 787  * used as a flag, but having the location is very helpful for debugging.
 788  */
 789 class CTxIndex
 790 {
 791 public:
 792     CDiskTxPos pos;
 793     vector<CDiskTxPos> vSpent;
 794
 795     CTxIndex()
 796     {
 797         SetNull();
 798     }
 799
 800     CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
 801     {
 802         pos = posIn;
 803         vSpent.resize(nOutputs);
 804     }
 805
 806     IMPLEMENT_SERIALIZE
 807     (
 808         if (!(nType & SER_GETHASH))
 809             READWRITE(nVersion);
 810         READWRITE(pos);
 811         READWRITE(vSpent);
 812     )
 813
 814     void SetNull()
 815     {
 816         pos.SetNull();
 817         vSpent.clear();
 818     }
 819
 820     bool IsNull()
 821     {
 822         return pos.IsNull();
 823     }
 824
 825     friend bool operator==(const CTxIndex& a, const CTxIndex& b)
 826     {
 827         return (a.pos    == b.pos &&
 828                 a.vSpent == b.vSpent);
 829     }
 830
 831     friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
 832     {
 833         return !(a == b);
 834     }
 835     int GetDepthInMainChain() const;
 836
 837 };
 838
 839
 840 /** Nodes collect new transactions into a block, hash them into a hash tree,
 841  * and scan through nonce values to make the block's hash satisfy proof-of-work
 842  * requirements.  When they solve the proof-of-work, they broadcast the block
 843  * to everyone and the block is added to the block chain.  The first transaction
 844  * in the block is a special one that creates a new coin owned by the creator
 845  * of the block.
 846  *
 847  * Blocks are appended to blk0001.dat files on disk.  Their location on disk
 848  * is indexed by CBlockIndex objects in memory.
 849  */
 850 class CBlock
 851 {
 852 public:
 853     // header
 854     static const int CURRENT_VERSION=6;
 855     int32_t nVersion;
 856     uint256 hashPrevBlock;
 857     uint256 hashMerkleRoot;
 858     uint32_t nTime;
 859     uint32_t nBits;
 860     uint32_t nNonce;
 861
 862     // network and disk
 863     vector<CTransaction> vtx;
 864
 865     // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
 866     vector<unsigned char> vchBlockSig;
 867
 868     // memory only
 869     mutable vector<uint256> vMerkleTree;
 870
 871     // Denial-of-service detection:
 872     mutable int nDoS;
 873     bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
 874
 875     CBlock()
 876     {
 877         SetNull();
 878     }
 879
 880     IMPLEMENT_SERIALIZE
 881     (
 882         READWRITE(this->nVersion);
 883         nVersion = this->nVersion;
 884         READWRITE(hashPrevBlock);
 885         READWRITE(hashMerkleRoot);
 886         READWRITE(nTime);
 887         READWRITE(nBits);
 888         READWRITE(nNonce);
 889
 890         // ConnectBlock depends on vtx following header to generate CDiskTxPos
 891         if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
 892         {
 893             READWRITE(vtx);
 894             READWRITE(vchBlockSig);
 895         }
 896         else if (fRead)
 897         {
 898             const_cast<CBlock*>(this)->vtx.clear();
 899             const_cast<CBlock*>(this)->vchBlockSig.clear();
 900         }
 901     )
 902
 903     void SetNull()
 904     {
 905         nVersion = CBlock::CURRENT_VERSION;
 906         hashPrevBlock = 0;
 907         hashMerkleRoot = 0;
 908         nTime = 0;
 909         nBits = 0;
 910         nNonce = 0;
 911         vtx.clear();
 912         vchBlockSig.clear();
 913         vMerkleTree.clear();
 914         nDoS = 0;
 915     }
 916
 917     bool IsNull() const
 918     {
 919         return (nBits == 0);
 920     }
 921
 922     uint256 GetHash() const
 923     {
 924         return scrypt_blockhash((const uint8_t*)&nVersion);
 925     }
 926
 927     int64_t GetBlockTime() const
 928     {
 929         return (int64_t)nTime;
 930     }
 931
 932     void UpdateTime(const CBlockIndex* pindexPrev);
 933
 934     // ppcoin: entropy bit for stake modifier if chosen by modifier
 935     unsigned int GetStakeEntropyBit(unsigned int nHeight) const
 936     {
 937         // Protocol switch to support p2pool at novacoin block #9689
 938         if (nHeight >= 9689 || fTestNet)
 939         {
 940             // Take last bit of block hash as entropy bit
 941             auto nEntropyBit = (GetHash().Get32()) & (uint32_t)1;
 942             if (fDebug && GetBoolArg("-printstakemodifier"))
 943                 printf("GetStakeEntropyBit: nTime=%" PRIu32 " hashBlock=%s nEntropyBit=%" PRIu32 "\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
 944             return nEntropyBit;
 945         }
 946
 947         // Before novacoin block #9689 - get from pregenerated table
 948         int nBitNum = nHeight & 0xFF;
 949         int nItemNum = nHeight / 0xFF;
 950
 951         auto nEntropyBit = ((entropyStore[nItemNum] & (uint256(1) << nBitNum)) >> nBitNum).Get32();
 952         if (fDebug && GetBoolArg("-printstakemodifier"))
 953             printf("GetStakeEntropyBit: from pregenerated table, nHeight=%" PRIu32 " nEntropyBit=%" PRIu32 "\n", nHeight, nEntropyBit);
 954         return nEntropyBit;
 955     }
 956
 957     // ppcoin: two types of block: proof-of-work or proof-of-stake
 958     bool IsProofOfStake() const
 959     {
 960         return (vtx.size() > 1 && vtx[1].IsCoinStake());
 961     }
 962
 963     bool IsProofOfWork() const
 964     {
 965         return !IsProofOfStake();
 966     }
 967
 968     pair<COutPoint, unsigned int> GetProofOfStake() const
 969     {
 970         if (IsProofOfStake())
 971             return { vtx[1].vin[0].prevout, vtx[1].nTime };
 972         return { COutPoint(), (unsigned int)0 };
 973     }
 974
 975     // ppcoin: get max transaction timestamp
 976     int64_t GetMaxTransactionTime() const
 977     {
 978         int64_t maxTransactionTime = 0;
 979         for(const auto& tx : vtx)
 980             maxTransactionTime = max(maxTransactionTime, (int64_t)tx.nTime);
 981         return maxTransactionTime;
 982     }
 983
 984     uint256 BuildMerkleTree() const
 985     {
 986         vMerkleTree.clear();
 987         for(const auto& tx :  vtx)
 988             vMerkleTree.push_back(tx.GetHash());
 989         int j = 0;
 990         for (int nSize = (int)vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
 991         {
 992             for (int i = 0; i < nSize; i += 2)
 993             {
 994                 int i2 = min(i+1, nSize-1);
 995                 vMerkleTree.push_back(Hash(vMerkleTree[j+i].begin(),  vMerkleTree[j+i].end(),
 996                                            vMerkleTree[j+i2].begin(), vMerkleTree[j+i2].end()));
 997             }
 998             j += nSize;
 999         }
1000         return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
1001     }
1002
1003     vector<uint256> GetMerkleBranch(int nIndex) const
1004     {
1005         if (vMerkleTree.empty())
1006             BuildMerkleTree();
1007         vector<uint256> vMerkleBranch;
1008         int j = 0;
1009         for (int nSize = (int)vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1010         {
1011             int i = min(nIndex^1, nSize-1);
1012             vMerkleBranch.push_back(vMerkleTree[j+i]);
1013             nIndex >>= 1;
1014             j += nSize;
1015         }
1016         return vMerkleBranch;
1017     }
1018
1019     static uint256 CheckMerkleBranch(uint256 hash, const vector<uint256>& vMerkleBranch, int nIndex)
1020     {
1021         if (nIndex == -1)
1022             return 0;
1023         for(const uint256& otherside :  vMerkleBranch)
1024         {
1025             if (nIndex & 1)
1026                 hash = Hash(otherside.begin(), otherside.end(), hash.begin(), hash.end());
1027             else
1028                 hash = Hash(hash.begin(), hash.end(), otherside.begin(), otherside.end());
1029             nIndex >>= 1;
1030         }
1031         return hash;
1032     }
1033
1034
1035     bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1036     {
1037         // Open history file to append
1038         auto fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1039         if (!fileout)
1040             return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1041
1042         // Write index header
1043         unsigned int nSize = fileout.GetSerializeSize(*this);
1044         fileout << nNetworkID << nSize;
1045
1046         // Write block
1047         long fileOutPos = ftell(fileout);
1048         if (fileOutPos < 0)
1049             return error("CBlock::WriteToDisk() : ftell failed");
1050         nBlockPosRet = fileOutPos;
1051         fileout << *this;
1052
1053         // Flush stdio buffers and commit to disk before returning
1054         fflush(fileout);
1055         if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1056             FileCommit(fileout);
1057
1058         return true;
1059     }
1060
1061     bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1062     {
1063         SetNull();
1064
1065         // Open history file to read
1066         auto filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1067         if (!filein)
1068             return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1069         if (!fReadTransactions)
1070             filein.nType |= SER_BLOCKHEADERONLY;
1071
1072         // Read block
1073         try {
1074             filein >> *this;
1075         }
1076         catch (const exception&) {
1077             return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
1078         }
1079
1080         // Check the header
1081         if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1082             return error("CBlock::ReadFromDisk() : errors in block header");
1083
1084         return true;
1085     }
1086
1087
1088
1089     void print() const
1090     {
1091         printf("CBlock(hash=%s, ver=%" PRId32 ", hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%" PRIu32 ", nBits=%08x, nNonce=%" PRIu32 ", vtx=%" PRIszu ", vchBlockSig=%s)\n",
1092             GetHash().ToString().c_str(),
1093             nVersion,
1094             hashPrevBlock.ToString().c_str(),
1095             hashMerkleRoot.ToString().c_str(),
1096             nTime, nBits, nNonce,
1097             vtx.size(),
1098             HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1099         for (unsigned int i = 0; i < vtx.size(); i++)
1100         {
1101             printf("  ");
1102             vtx[i].print();
1103         }
1104         printf("  vMerkleTree: ");
1105         for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1106             printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1107         printf("\n");
1108     }
1109
1110
1111     bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1112     bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1113     bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1114     bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1115     bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1116     bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1117     bool AcceptBlock();
1118     bool GetCoinAge(uint64_t& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1119     bool CheckBlockSignature() const;
1120
1121 private:
1122     bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1123 };
1124
1125
1126
1127
1128
1129
1130 /** The block chain is a tree shaped structure starting with the
1131  * genesis block at the root, with each block potentially having multiple
1132  * candidates to be the next block.  pprev and pnext link a path through the
1133  * main/longest chain.  A blockindex may have multiple pprev pointing back
1134  * to it, but pnext will only point forward to the longest branch, or will
1135  * be null if the block is not part of the longest chain.
1136  */
1137 class CBlockIndex
1138 {
1139 public:
1140     const uint256* phashBlock;
1141     CBlockIndex* pprev;
1142     CBlockIndex* pnext;
1143     uint32_t nFile;
1144     uint32_t nBlockPos;
1145     uint256 nChainTrust; // ppcoin: trust score of block chain
1146     int32_t nHeight;
1147
1148     int64_t nMint;
1149     int64_t nMoneySupply;
1150
1151     uint32_t nFlags;  // ppcoin: block index flags
1152     enum
1153     {
1154         BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1155         BLOCK_STAKE_ENTROPY  = (1 << 1), // entropy bit for stake modifier
1156         BLOCK_STAKE_MODIFIER = (1 << 2)  // regenerated stake modifier
1157     };
1158
1159     uint64_t nStakeModifier; // hash modifier for proof-of-stake
1160     uint32_t nStakeModifierChecksum; // checksum of index; in-memeory only
1161
1162     // proof-of-stake specific fields
1163     COutPoint prevoutStake;
1164     uint32_t nStakeTime;
1165     uint256 hashProofOfStake;
1166
1167     // block header
1168     int32_t  nVersion;
1169     uint256  hashMerkleRoot;
1170     uint32_t nTime;
1171     uint32_t nBits;
1172     uint32_t nNonce;
1173
1174     CBlockIndex()
1175     {
1176         phashBlock = NULL;
1177         pprev = NULL;
1178         pnext = NULL;
1179         nFile = 0;
1180         nBlockPos = 0;
1181         nHeight = 0;
1182         nChainTrust = 0;
1183         nMint = 0;
1184         nMoneySupply = 0;
1185         nFlags = 0;
1186         nStakeModifier = 0;
1187         nStakeModifierChecksum = 0;
1188         hashProofOfStake = 0;
1189         prevoutStake.SetNull();
1190         nStakeTime = 0;
1191
1192         nVersion       = 0;
1193         hashMerkleRoot = 0;
1194         nTime          = 0;
1195         nBits          = 0;
1196         nNonce         = 0;
1197     }
1198
1199     CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1200     {
1201         phashBlock = NULL;
1202         pprev = NULL;
1203         pnext = NULL;
1204         nFile = nFileIn;
1205         nBlockPos = nBlockPosIn;
1206         nHeight = 0;
1207         nChainTrust = 0;
1208         nMint = 0;
1209         nMoneySupply = 0;
1210         nFlags = 0;
1211         nStakeModifier = 0;
1212         nStakeModifierChecksum = 0;
1213         hashProofOfStake = 0;
1214         if (block.IsProofOfStake())
1215         {
1216             SetProofOfStake();
1217             prevoutStake = block.vtx[1].vin[0].prevout;
1218             nStakeTime = block.vtx[1].nTime;
1219         }
1220         else
1221         {
1222             prevoutStake.SetNull();
1223             nStakeTime = 0;
1224         }
1225
1226         nVersion       = block.nVersion;
1227         hashMerkleRoot = block.hashMerkleRoot;
1228         nTime          = block.nTime;
1229         nBits          = block.nBits;
1230         nNonce         = block.nNonce;
1231     }
1232
1233     CBlock GetBlockHeader() const
1234     {
1235         CBlock block;
1236         block.nVersion       = nVersion;
1237         if (pprev)
1238             block.hashPrevBlock = pprev->GetBlockHash();
1239         block.hashMerkleRoot = hashMerkleRoot;
1240         block.nTime          = nTime;
1241         block.nBits          = nBits;
1242         block.nNonce         = nNonce;
1243         return block;
1244     }
1245
1246     uint256 GetBlockHash() const
1247     {
1248         return *phashBlock;
1249     }
1250
1251     int64_t GetBlockTime() const
1252     {
1253         return (int64_t)nTime;
1254     }
1255
1256     uint256 GetBlockTrust() const;
1257
1258     bool IsInMainChain() const
1259     {
1260         return (pnext || this == pindexBest);
1261     }
1262
1263     bool CheckIndex() const
1264     {
1265         return true;
1266     }
1267
1268     enum { nMedianTimeSpan=11 };
1269
1270     int64_t GetMedianTimePast() const
1271     {
1272         int64_t pmedian[nMedianTimeSpan];
1273         int64_t* pbegin = &pmedian[nMedianTimeSpan];
1274         int64_t* pend = &pmedian[nMedianTimeSpan];
1275
1276         const CBlockIndex* pindex = this;
1277         for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1278             *(--pbegin) = pindex->GetBlockTime();
1279
1280         sort(pbegin, pend);
1281         return pbegin[(pend - pbegin)/2];
1282     }
1283
1284     int64_t GetMedianTime() const
1285     {
1286         const CBlockIndex* pindex = this;
1287         for (int i = 0; i < nMedianTimeSpan/2; i++)
1288         {
1289             if (!pindex->pnext)
1290                 return GetBlockTime();
1291             pindex = pindex->pnext;
1292         }
1293         return pindex->GetMedianTimePast();
1294     }
1295
1296     /**
1297      * Returns true if there are nRequired or more blocks of minVersion or above
1298      * in the last nToCheck blocks, starting at pstart and going backwards.
1299      */
1300     static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1301                                 unsigned int nRequired, unsigned int nToCheck);
1302
1303
1304     bool IsProofOfWork() const
1305     {
1306         return !(nFlags & BLOCK_PROOF_OF_STAKE);
1307     }
1308
1309     bool IsProofOfStake() const
1310     {
1311         return (nFlags & BLOCK_PROOF_OF_STAKE);
1312     }
1313
1314     void SetProofOfStake()
1315     {
1316         nFlags |= BLOCK_PROOF_OF_STAKE;
1317     }
1318
1319     unsigned int GetStakeEntropyBit() const
1320     {
1321         return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1322     }
1323
1324     bool SetStakeEntropyBit(unsigned int nEntropyBit)
1325     {
1326         if (nEntropyBit > 1)
1327             return false;
1328         nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1329         return true;
1330     }
1331
1332     bool GeneratedStakeModifier() const
1333     {
1334         return (nFlags & BLOCK_STAKE_MODIFIER) != 0;
1335     }
1336
1337     void SetStakeModifier(uint64_t nModifier, bool fGeneratedStakeModifier)
1338     {
1339         nStakeModifier = nModifier;
1340         if (fGeneratedStakeModifier)
1341             nFlags |= BLOCK_STAKE_MODIFIER;
1342     }
1343
1344     string ToString() const
1345     {
1346         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)",
1347             (const void*)pprev, (const void*)pnext, nFile, nBlockPos, nHeight,
1348             FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1349             GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1350             nStakeModifier, nStakeModifierChecksum,
1351             hashProofOfStake.ToString().c_str(),
1352             prevoutStake.ToString().c_str(), nStakeTime,
1353             hashMerkleRoot.ToString().c_str(),
1354             GetBlockHash().ToString().c_str());
1355     }
1356
1357     void print() const
1358     {
1359         printf("%s\n", ToString().c_str());
1360     }
1361 };
1362
1363
1364
1365 /** Used to marshal pointers into hashes for db storage. */
1366 class CDiskBlockIndex : public CBlockIndex
1367 {
1368 private:
1369     uint256 blockHash;
1370
1371 public:
1372     uint256 hashPrev;
1373     uint256 hashNext;
1374
1375     CDiskBlockIndex()
1376     {
1377         hashPrev = 0;
1378         hashNext = 0;
1379         blockHash = 0;
1380     }
1381
1382     explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1383     {
1384         hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1385         hashNext = (pnext ? pnext->GetBlockHash() : 0);
1386     }
1387
1388     IMPLEMENT_SERIALIZE
1389     (
1390         if (!(nType & SER_GETHASH))
1391             READWRITE(nVersion);
1392
1393         READWRITE(hashNext);
1394         READWRITE(nFile);
1395         READWRITE(nBlockPos);
1396         READWRITE(nHeight);
1397         READWRITE(nMint);
1398         READWRITE(nMoneySupply);
1399         READWRITE(nFlags);
1400         READWRITE(nStakeModifier);
1401         if (IsProofOfStake())
1402         {
1403             READWRITE(prevoutStake);
1404             READWRITE(nStakeTime);
1405             READWRITE(hashProofOfStake);
1406         }
1407         else if (fRead)
1408         {
1409             const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1410             const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1411             const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1412         }
1413
1414         // block header
1415         READWRITE(this->nVersion);
1416         READWRITE(hashPrev);
1417         READWRITE(hashMerkleRoot);
1418         READWRITE(nTime);
1419         READWRITE(nBits);
1420         READWRITE(nNonce);
1421         READWRITE(blockHash);
1422     )
1423
1424     uint256 GetBlockHash() const
1425     {
1426         if (fUseFastIndex && blockHash != 0)
1427             return blockHash;
1428
1429         CBlock block;
1430         block.nVersion        = nVersion;
1431         block.hashPrevBlock   = hashPrev;
1432         block.hashMerkleRoot  = hashMerkleRoot;
1433         block.nTime           = nTime;
1434         block.nBits           = nBits;
1435         block.nNonce          = nNonce;
1436
1437         const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1438
1439         return blockHash;
1440     }
1441
1442     string ToString() const
1443     {
1444         string str = "CDiskBlockIndex(";
1445         str += CBlockIndex::ToString();
1446         str += strprintf("\n                hashBlock=%s, hashPrev=%s, hashNext=%s)",
1447             GetBlockHash().ToString().c_str(),
1448             hashPrev.ToString().c_str(),
1449             hashNext.ToString().c_str());
1450         return str;
1451     }
1452
1453     void print() const
1454     {
1455         printf("%s\n", ToString().c_str());
1456     }
1457 };
1458
1459
1460
1461
1462
1463
1464
1465
1466 /** Describes a place in the block chain to another node such that if the
1467  * other node doesn't have the same branch, it can find a recent common trunk.
1468  * The further back it is, the further before the fork it may be.
1469  */
1470 class CBlockLocator
1471 {
1472 protected:
1473     vector<uint256> vHave;
1474 public:
1475
1476     CBlockLocator()
1477     {
1478     }
1479
1480     explicit CBlockLocator(const CBlockIndex* pindex)
1481     {
1482         Set(pindex);
1483     }
1484
1485     explicit CBlockLocator(uint256 hashBlock)
1486     {
1487         auto mi = mapBlockIndex.find(hashBlock);
1488         if (mi != mapBlockIndex.end())
1489             Set((*mi).second);
1490     }
1491
1492     CBlockLocator(const vector<uint256>& vHaveIn)
1493     {
1494         vHave = vHaveIn;
1495     }
1496
1497     IMPLEMENT_SERIALIZE
1498     (
1499         if (!(nType & SER_GETHASH))
1500             READWRITE(nVersion);
1501         READWRITE(vHave);
1502     )
1503
1504     void SetNull()
1505     {
1506         vHave.clear();
1507     }
1508
1509     bool IsNull()
1510     {
1511         return vHave.empty();
1512     }
1513
1514     void Set(const CBlockIndex* pindex)
1515     {
1516         vHave.clear();
1517         int nStep = 1;
1518         while (pindex)
1519         {
1520             vHave.push_back(pindex->GetBlockHash());
1521
1522             // Exponentially larger steps back
1523             for (int i = 0; pindex && i < nStep; i++)
1524                 pindex = pindex->pprev;
1525             if (vHave.size() > 10)
1526                 nStep *= 2;
1527         }
1528         vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1529     }
1530
1531     int GetDistanceBack()
1532     {
1533         // Retrace how far back it was in the sender's branch
1534         int nDistance = 0;
1535         int nStep = 1;
1536         for(const auto& hash :  vHave)
1537         {
1538             auto mi = mapBlockIndex.find(hash);
1539             if (mi != mapBlockIndex.end())
1540             {
1541                 auto pindex = (*mi).second;
1542                 if (pindex->IsInMainChain())
1543                     return nDistance;
1544             }
1545             nDistance += nStep;
1546             if (nDistance > 10)
1547                 nStep *= 2;
1548         }
1549         return nDistance;
1550     }
1551
1552     CBlockIndex* GetBlockIndex()
1553     {
1554         // Find the first block the caller has in the main chain
1555         for(const auto& hash :  vHave)
1556         {
1557             auto mi = mapBlockIndex.find(hash);
1558             if (mi != mapBlockIndex.end())
1559             {
1560                 auto pindex = (*mi).second;
1561                 if (pindex->IsInMainChain())
1562                     return pindex;
1563             }
1564         }
1565         return pindexGenesisBlock;
1566     }
1567
1568     uint256 GetBlockHash()
1569     {
1570         // Find the first block the caller has in the main chain
1571         for(const uint256& hash :  vHave)
1572         {
1573             auto mi = mapBlockIndex.find(hash);
1574             if (mi != mapBlockIndex.end())
1575             {
1576                 auto pindex = (*mi).second;
1577                 if (pindex->IsInMainChain())
1578                     return hash;
1579             }
1580         }
1581         return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1582     }
1583
1584     int GetHeight()
1585     {
1586         CBlockIndex* pindex = GetBlockIndex();
1587         if (!pindex)
1588             return 0;
1589         return pindex->nHeight;
1590     }
1591 };
1592
1593
1594
1595
1596
1597
1598
1599
1600 class CTxMemPool
1601 {
1602 public:
1603     mutable CCriticalSection cs;
1604     map<uint256, CTransaction> mapTx;
1605     map<COutPoint, CInPoint> mapNextTx;
1606
1607     bool accept(CTxDB& txdb, CTransaction &tx,
1608                 bool fCheckInputs, bool* pfMissingInputs);
1609     bool addUnchecked(const uint256& hash, CTransaction &tx);
1610     bool remove(CTransaction &tx);
1611     void clear();
1612     void queryHashes(vector<uint256>& vtxid);
1613
1614     size_t size()
1615     {
1616         LOCK(cs);
1617         return mapTx.size();
1618     }
1619
1620     bool exists(const uint256 &hash)
1621     {
1622         return (mapTx.count(hash) != 0);
1623     }
1624
1625     CTransaction& lookup(const uint256 &hash)
1626     {
1627         return mapTx[hash];
1628     }
1629 };
1630
1631 extern CTxMemPool mempool;
1632
1633 #endif