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