src/main.h

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