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 <list>
  18 #include <map>
  19
  20 class CWallet;
  21 class CBlock;
  22 class CBlockIndex;
  23 class CKeyItem;
  24 class CReserveKey;
  25 class COutPoint;
  26
  27 class CAddress;
  28 class CInv;
  29 class CRequestTracker;
  30 class CNode;
  31
  32 //
  33 // Global state
  34 //
  35
  36 static const unsigned int MAX_BLOCK_SIZE = 1000000;
  37 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
  38 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
  39 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
  40 static const unsigned int MAX_INV_SZ = 50000;
  41
  42 static const int64_t MIN_TX_FEE = CENT/10;
  43 static const int64_t MIN_RELAY_TX_FEE = CENT/50;
  44
  45 static const int64_t MAX_MONEY = 2000000000 * COIN;
  46 static const int64_t MAX_MINT_PROOF_OF_WORK = 100 * COIN;
  47 static const int64_t MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
  48 static const int64_t MIN_TXOUT_AMOUNT = CENT/100;
  49
  50
  51 inline bool MoneyRange(int64_t nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
  52 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
  53 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov  5 00:53:20 1985 UTC
  54 // Maximum number of script-checking threads allowed
  55 static const int MAX_SCRIPTCHECK_THREADS = 16;
  56
  57 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
  58 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
  59
  60 inline int64_t PastDrift(int64_t nTime)   { return nTime - 2 * nOneHour; } // up to 2 hours from the past
  61 inline int64_t FutureDrift(int64_t nTime) { return nTime + 2 * nOneHour; } // up to 2 hours from the future
  62
  63 extern CScript COINBASE_FLAGS;
  64 extern CCriticalSection cs_main;
  65 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
  66 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
  67 extern CBlockIndex* pindexGenesisBlock;
  68 extern unsigned int nNodeLifespan;
  69 extern unsigned int nStakeMinAge;
  70 extern int nCoinbaseMaturity;
  71 extern int nBestHeight;
  72 extern uint256 nBestChainTrust;
  73 extern uint256 nBestInvalidTrust;
  74 extern uint256 hashBestChain;
  75 extern CBlockIndex* pindexBest;
  76 extern unsigned int nTransactionsUpdated;
  77 extern uint64_t nLastBlockTx;
  78 extern uint64_t nLastBlockSize;
  79 extern uint32_t nLastCoinStakeSearchInterval;
  80 extern const std::string strMessageMagic;
  81 extern int64_t nTimeBestReceived;
  82 extern CCriticalSection cs_setpwalletRegistered;
  83 extern std::set<CWallet*> setpwalletRegistered;
  84 extern unsigned char pchMessageStart[4];
  85 extern std::map<uint256, CBlock*> mapOrphanBlocks;
  86
  87 // Settings
  88 extern int64_t nTransactionFee;
  89 extern int64_t nMinimumInputValue;
  90 extern bool fUseFastIndex;
  91 extern int nScriptCheckThreads;
  92 extern const uint256 entropyStore[38];
  93
  94 // Minimum disk space required - used in CheckDiskSpace()
  95 static const uint64_t nMinDiskSpace = 52428800;
  96
  97 class CReserveKey;
  98 class CTxDB;
  99 class CTxIndex;
 100 class CScriptCheck;
 101
 102 void RegisterWallet(CWallet* pwalletIn);
 103 void UnregisterWallet(CWallet* pwalletIn);
 104 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
 105 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
 106 bool CheckDiskSpace(uint64_t nAdditionalBytes=0);
 107 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
 108 FILE* AppendBlockFile(unsigned int& nFileRet);
 109
 110 void UnloadBlockIndex();
 111 bool LoadBlockIndex(bool fAllowNew=true);
 112 void PrintBlockTree();
 113 CBlockIndex* FindBlockByHeight(int nHeight);
 114 bool ProcessMessages(CNode* pfrom);
 115 bool SendMessages(CNode* pto, bool fSendTrickle);
 116 bool LoadExternalBlockFile(FILE* fileIn);
 117
 118 // Run an instance of the script checking thread
 119 void ThreadScriptCheck(void* parg);
 120 // Stop the script checking threads
 121 void ThreadScriptCheckQuit();
 122
 123 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
 124 unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, bool fProofOfStake);
 125 int64_t GetProofOfWorkReward(unsigned int nBits, int64_t nFees=0);
 126 int64_t GetProofOfStakeReward(int64_t nCoinAge, unsigned int nBits, int64_t nTime, bool bCoinYearOnly=false);
 127 unsigned int ComputeMinWork(unsigned int nBase, int64_t nTime);
 128 unsigned int ComputeMinStake(unsigned int nBase, int64_t nTime, unsigned int nBlockTime);
 129 int GetNumBlocksOfPeers();
 130 bool IsInitialBlockDownload();
 131 std::string GetWarnings(std::string strFor);
 132 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
 133 uint256 WantedByOrphan(const CBlock* pblockOrphan);
 134 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
 135 void ResendWalletTransactions();
 136
 137 bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType);
 138
 139
 140
 141
 142
 143
 144
 145 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
 146
 147 /** Position on disk for a particular transaction. */
 148 class CDiskTxPos
 149 {
 150 public:
 151     uint32_t nFile;
 152     uint32_t nBlockPos;
 153     uint32_t nTxPos;
 154
 155     CDiskTxPos()
 156     {
 157         SetNull();
 158     }
 159
 160     CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
 161     {
 162         nFile = nFileIn;
 163         nBlockPos = nBlockPosIn;
 164         nTxPos = nTxPosIn;
 165     }
 166
 167     IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
 168     void SetNull() { nFile = (unsigned int) -1; nBlockPos = 0; nTxPos = 0; }
 169     bool IsNull() const { return (nFile == (unsigned int) -1); }
 170
 171     friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
 172     {
 173         return (a.nFile     == b.nFile &&
 174                 a.nBlockPos == b.nBlockPos &&
 175                 a.nTxPos    == b.nTxPos);
 176     }
 177
 178     friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
 179     {
 180         return !(a == b);
 181     }
 182
 183
 184     std::string ToString() const
 185     {
 186         if (IsNull())
 187             return "null";
 188         else
 189             return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
 190     }
 191
 192     void print() const
 193     {
 194         printf("%s", ToString().c_str());
 195     }
 196 };
 197
 198
 199
 200 /** An inpoint - a combination of a transaction and an index n into its vin */
 201 class CInPoint
 202 {
 203 public:
 204     CTransaction* ptx;
 205     uint32_t n;
 206
 207     CInPoint() { SetNull(); }
 208     CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
 209     void SetNull() { ptx = NULL; n = (unsigned int) -1; }
 210     bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
 211 };
 212
 213
 214
 215 /** An outpoint - a combination of a transaction hash and an index n into its vout */
 216 class COutPoint
 217 {
 218 public:
 219     uint256 hash;
 220     uint32_t n;
 221
 222     COutPoint() { SetNull(); }
 223     COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
 224     IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
 225     void SetNull() { hash = 0; n = (unsigned int) -1; }
 226     bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
 227
 228     friend bool operator<(const COutPoint& a, const COutPoint& b)
 229     {
 230         return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
 231     }
 232
 233     friend bool operator==(const COutPoint& a, const COutPoint& b)
 234     {
 235         return (a.hash == b.hash && a.n == b.n);
 236     }
 237
 238     friend bool operator!=(const COutPoint& a, const COutPoint& b)
 239     {
 240         return !(a == b);
 241     }
 242
 243     std::string ToString() const
 244     {
 245         return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
 246     }
 247
 248     void print() const
 249     {
 250         printf("%s\n", ToString().c_str());
 251     }
 252 };
 253
 254
 255
 256
 257 /** An input of a transaction.  It contains the location of the previous
 258  * transaction's output that it claims and a signature that matches the
 259  * output's public key.
 260  */
 261 class CTxIn
 262 {
 263 public:
 264     COutPoint prevout;
 265     CScript scriptSig;
 266     uint32_t nSequence;
 267
 268     CTxIn()
 269     {
 270         nSequence = std::numeric_limits<unsigned int>::max();
 271     }
 272
 273     explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
 274     {
 275         prevout = prevoutIn;
 276         scriptSig = scriptSigIn;
 277         nSequence = nSequenceIn;
 278     }
 279
 280     CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
 281     {
 282         prevout = COutPoint(hashPrevTx, nOut);
 283         scriptSig = scriptSigIn;
 284         nSequence = nSequenceIn;
 285     }
 286
 287     IMPLEMENT_SERIALIZE
 288     (
 289         READWRITE(prevout);
 290         READWRITE(scriptSig);
 291         READWRITE(nSequence);
 292     )
 293
 294     bool IsFinal() const
 295     {
 296         return (nSequence == std::numeric_limits<unsigned int>::max());
 297     }
 298
 299     friend bool operator==(const CTxIn& a, const CTxIn& b)
 300     {
 301         return (a.prevout   == b.prevout &&
 302                 a.scriptSig == b.scriptSig &&
 303                 a.nSequence == b.nSequence);
 304     }
 305
 306     friend bool operator!=(const CTxIn& a, const CTxIn& b)
 307     {
 308         return !(a == b);
 309     }
 310
 311     std::string ToStringShort() const
 312     {
 313         return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
 314     }
 315
 316     std::string ToString() const
 317     {
 318         std::string str;
 319         str += "CTxIn(";
 320         str += prevout.ToString();
 321         if (prevout.IsNull())
 322             str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
 323         else
 324             str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
 325         if (nSequence != std::numeric_limits<unsigned int>::max())
 326             str += strprintf(", nSequence=%u", nSequence);
 327         str += ")";
 328         return str;
 329     }
 330
 331     void print() const
 332     {
 333         printf("%s\n", ToString().c_str());
 334     }
 335 };
 336
 337
 338
 339
 340 /** An output of a transaction.  It contains the public key that the next input
 341  * must be able to sign with to claim it.
 342  */
 343 class CTxOut
 344 {
 345 public:
 346     int64_t nValue;
 347     CScript scriptPubKey;
 348
 349     CTxOut()
 350     {
 351         SetNull();
 352     }
 353
 354     CTxOut(int64_t nValueIn, CScript scriptPubKeyIn)
 355     {
 356         nValue = nValueIn;
 357         scriptPubKey = scriptPubKeyIn;
 358     }
 359
 360     IMPLEMENT_SERIALIZE
 361     (
 362         READWRITE(nValue);
 363         READWRITE(scriptPubKey);
 364     )
 365
 366     void SetNull()
 367     {
 368         nValue = -1;
 369         scriptPubKey.clear();
 370     }
 371
 372     bool IsNull()
 373     {
 374         return (nValue == -1);
 375     }
 376
 377     void SetEmpty()
 378     {
 379         nValue = 0;
 380         scriptPubKey.clear();
 381     }
 382
 383     bool IsEmpty() const
 384     {
 385         return (nValue == 0 && scriptPubKey.empty());
 386     }
 387
 388     uint256 GetHash() const
 389     {
 390         return SerializeHash(*this);
 391     }
 392
 393     friend bool operator==(const CTxOut& a, const CTxOut& b)
 394     {
 395         return (a.nValue       == b.nValue &&
 396                 a.scriptPubKey == b.scriptPubKey);
 397     }
 398
 399     friend bool operator!=(const CTxOut& a, const CTxOut& b)
 400     {
 401         return !(a == b);
 402     }
 403
 404     std::string ToStringShort() const
 405     {
 406         return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
 407     }
 408
 409     std::string ToString() const
 410     {
 411         if (IsEmpty()) return "CTxOut(empty)";
 412         if (scriptPubKey.size() < 6)
 413             return "CTxOut(error)";
 414         return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
 415     }
 416
 417     void print() const
 418     {
 419         printf("%s\n", ToString().c_str());
 420     }
 421 };
 422
 423
 424
 425
 426 enum GetMinFee_mode
 427 {
 428     GMF_BLOCK,
 429     GMF_RELAY,
 430     GMF_SEND,
 431 };
 432
 433 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
 434
 435 /** The basic transaction that is broadcasted on the network and contained in
 436  * blocks.  A transaction can contain multiple inputs and outputs.
 437  */
 438 class CTransaction
 439 {
 440 public:
 441     static const int CURRENT_VERSION=1;
 442     int nVersion;
 443     uint32_t nTime;
 444     std::vector<CTxIn> vin;
 445     std::vector<CTxOut> vout;
 446     uint32_t nLockTime;
 447
 448     // Denial-of-service detection:
 449     mutable int nDoS;
 450     bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
 451
 452     CTransaction()
 453     {
 454         SetNull();
 455     }
 456
 457     IMPLEMENT_SERIALIZE
 458     (
 459         READWRITE(this->nVersion);
 460         nVersion = this->nVersion;
 461         READWRITE(nTime);
 462         READWRITE(vin);
 463         READWRITE(vout);
 464         READWRITE(nLockTime);
 465     )
 466
 467     void SetNull()
 468     {
 469         nVersion = CTransaction::CURRENT_VERSION;
 470         nTime = (uint32_t) GetAdjustedTime();
 471         vin.clear();
 472         vout.clear();
 473         nLockTime = 0;
 474         nDoS = 0;  // Denial-of-service prevention
 475     }
 476
 477     bool IsNull() const
 478     {
 479         return (vin.empty() && vout.empty());
 480     }
 481
 482     uint256 GetHash() const
 483     {
 484         return SerializeHash(*this);
 485     }
 486
 487     bool IsFinal(int nBlockHeight=0, int64_t nBlockTime=0) const
 488     {
 489         // Time based nLockTime implemented in 0.1.6
 490         if (nLockTime == 0)
 491             return true;
 492         if (nBlockHeight == 0)
 493             nBlockHeight = nBestHeight;
 494         if (nBlockTime == 0)
 495             nBlockTime = GetAdjustedTime();
 496         if ((int64_t)nLockTime < ((int64_t)nLockTime < LOCKTIME_THRESHOLD ? (int64_t)nBlockHeight : nBlockTime))
 497             return true;
 498         BOOST_FOREACH(const CTxIn& txin, vin)
 499             if (!txin.IsFinal())
 500                 return false;
 501         return true;
 502     }
 503
 504     bool IsNewerThan(const CTransaction& old) const
 505     {
 506         if (vin.size() != old.vin.size())
 507             return false;
 508         for (unsigned int i = 0; i < vin.size(); i++)
 509             if (vin[i].prevout != old.vin[i].prevout)
 510                 return false;
 511
 512         bool fNewer = false;
 513         unsigned int nLowest = std::numeric_limits<unsigned int>::max();
 514         for (unsigned int i = 0; i < vin.size(); i++)
 515         {
 516             if (vin[i].nSequence != old.vin[i].nSequence)
 517             {
 518                 if (vin[i].nSequence <= nLowest)
 519                 {
 520                     fNewer = false;
 521                     nLowest = vin[i].nSequence;
 522                 }
 523                 if (old.vin[i].nSequence < nLowest)
 524                 {
 525                     fNewer = true;
 526                     nLowest = old.vin[i].nSequence;
 527                 }
 528             }
 529         }
 530         return fNewer;
 531     }
 532
 533     bool IsCoinBase() const
 534     {
 535         return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
 536     }
 537
 538     bool IsCoinStake() const
 539     {
 540         // ppcoin: the coin stake transaction is marked with the first output empty
 541         return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
 542     }
 543
 544     /** Check for standard transaction types
 545         @return True if all outputs (scriptPubKeys) use only standard transaction forms
 546     */
 547     bool IsStandard(std::string& strReason) const;
 548     bool IsStandard() const
 549     {
 550         std::string strReason;
 551         return IsStandard(strReason);
 552     }
 553
 554     /** Check for standard transaction types
 555         @param[in] mapInputs    Map of previous transactions that have outputs we're spending
 556         @return True if all inputs (scriptSigs) use only standard transaction forms
 557         @see CTransaction::FetchInputs
 558     */
 559     bool AreInputsStandard(const MapPrevTx& mapInputs) const;
 560
 561     /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
 562         @return number of sigops this transaction's outputs will produce when spent
 563         @see CTransaction::FetchInputs
 564     */
 565     unsigned int GetLegacySigOpCount() const;
 566
 567     /** Count ECDSA signature operations in pay-to-script-hash inputs.
 568
 569         @param[in] mapInputs    Map of previous transactions that have outputs we're spending
 570         @return maximum number of sigops required to validate this transaction's inputs
 571         @see CTransaction::FetchInputs
 572      */
 573     unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
 574
 575     /** Amount of bitcoins spent by this transaction.
 576         @return sum of all outputs (note: does not include fees)
 577      */
 578     int64_t GetValueOut() const
 579     {
 580         int64_t nValueOut = 0;
 581         BOOST_FOREACH(const CTxOut& txout, vout)
 582         {
 583             nValueOut += txout.nValue;
 584             if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
 585                 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
 586         }
 587         return nValueOut;
 588     }
 589
 590     /** Amount of bitcoins coming in to this transaction
 591         Note that lightweight clients may not know anything besides the hash of previous transactions,
 592         so may not be able to calculate this.
 593
 594         @param[in] mapInputs    Map of previous transactions that have outputs we're spending
 595         @return Sum of value of all inputs (scriptSigs)
 596         @see CTransaction::FetchInputs
 597      */
 598     int64_t GetValueIn(const MapPrevTx& mapInputs) const;
 599
 600     static bool AllowFree(double dPriority)
 601     {
 602         // Large (in bytes) low-priority (new, small-coin) transactions
 603         // need a fee.
 604         return dPriority > COIN * 144 / 250;
 605     }
 606
 607     int64_t GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK, unsigned int nBytes = 0) const;
 608
 609     bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
 610     {
 611         CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
 612         if (!filein)
 613             return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
 614
 615         // Read transaction
 616         if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
 617             return error("CTransaction::ReadFromDisk() : fseek failed");
 618
 619         try {
 620             filein >> *this;
 621         }
 622         catch (std::exception &e) {
 623             (void)e;
 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()) & 1ULL);
 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 (std::exception &e) {
1099             (void)e;
1100             return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
1101         }
1102
1103         // Check the header
1104         if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1105             return error("CBlock::ReadFromDisk() : errors in block header");
1106
1107         return true;
1108     }
1109
1110
1111
1112     void print() const
1113     {
1114         printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%" PRIszu ", vchBlockSig=%s)\n",
1115             GetHash().ToString().c_str(),
1116             nVersion,
1117             hashPrevBlock.ToString().c_str(),
1118             hashMerkleRoot.ToString().c_str(),
1119             nTime, nBits, nNonce,
1120             vtx.size(),
1121             HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1122         for (unsigned int i = 0; i < vtx.size(); i++)
1123         {
1124             printf("  ");
1125             vtx[i].print();
1126         }
1127         printf("  vMerkleTree: ");
1128         for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1129             printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1130         printf("\n");
1131     }
1132
1133
1134     bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1135     bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1136     bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1137     bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1138     bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1139     bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1140     bool AcceptBlock();
1141     bool GetCoinAge(uint64_t& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1142     bool CheckBlockSignature() const;
1143
1144 private:
1145     bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1146 };
1147
1148
1149
1150
1151
1152
1153 /** The block chain is a tree shaped structure starting with the
1154  * genesis block at the root, with each block potentially having multiple
1155  * candidates to be the next block.  pprev and pnext link a path through the
1156  * main/longest chain.  A blockindex may have multiple pprev pointing back
1157  * to it, but pnext will only point forward to the longest branch, or will
1158  * be null if the block is not part of the longest chain.
1159  */
1160 class CBlockIndex
1161 {
1162 public:
1163     const uint256* phashBlock;
1164     CBlockIndex* pprev;
1165     CBlockIndex* pnext;
1166     uint32_t nFile;
1167     uint32_t nBlockPos;
1168     uint256 nChainTrust; // ppcoin: trust score of block chain
1169     int32_t nHeight;
1170
1171     int64_t nMint;
1172     int64_t nMoneySupply;
1173
1174     uint32_t nFlags;  // ppcoin: block index flags
1175     enum
1176     {
1177         BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1178         BLOCK_STAKE_ENTROPY  = (1 << 1), // entropy bit for stake modifier
1179         BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1180     };
1181
1182     uint64_t nStakeModifier; // hash modifier for proof-of-stake
1183     uint32_t nStakeModifierChecksum; // checksum of index; in-memeory only
1184
1185     // proof-of-stake specific fields
1186     COutPoint prevoutStake;
1187     uint32_t nStakeTime;
1188     uint256 hashProofOfStake;
1189
1190     // block header
1191     int32_t  nVersion;
1192     uint256  hashMerkleRoot;
1193     uint32_t nTime;
1194     uint32_t nBits;
1195     uint32_t nNonce;
1196
1197     CBlockIndex()
1198     {
1199         phashBlock = NULL;
1200         pprev = NULL;
1201         pnext = NULL;
1202         nFile = 0;
1203         nBlockPos = 0;
1204         nHeight = 0;
1205         nChainTrust = 0;
1206         nMint = 0;
1207         nMoneySupply = 0;
1208         nFlags = 0;
1209         nStakeModifier = 0;
1210         nStakeModifierChecksum = 0;
1211         hashProofOfStake = 0;
1212         prevoutStake.SetNull();
1213         nStakeTime = 0;
1214
1215         nVersion       = 0;
1216         hashMerkleRoot = 0;
1217         nTime          = 0;
1218         nBits          = 0;
1219         nNonce         = 0;
1220     }
1221
1222     CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1223     {
1224         phashBlock = NULL;
1225         pprev = NULL;
1226         pnext = NULL;
1227         nFile = nFileIn;
1228         nBlockPos = nBlockPosIn;
1229         nHeight = 0;
1230         nChainTrust = 0;
1231         nMint = 0;
1232         nMoneySupply = 0;
1233         nFlags = 0;
1234         nStakeModifier = 0;
1235         nStakeModifierChecksum = 0;
1236         hashProofOfStake = 0;
1237         if (block.IsProofOfStake())
1238         {
1239             SetProofOfStake();
1240             prevoutStake = block.vtx[1].vin[0].prevout;
1241             nStakeTime = block.vtx[1].nTime;
1242         }
1243         else
1244         {
1245             prevoutStake.SetNull();
1246             nStakeTime = 0;
1247         }
1248
1249         nVersion       = block.nVersion;
1250         hashMerkleRoot = block.hashMerkleRoot;
1251         nTime          = block.nTime;
1252         nBits          = block.nBits;
1253         nNonce         = block.nNonce;
1254     }
1255
1256     CBlock GetBlockHeader() const
1257     {
1258         CBlock block;
1259         block.nVersion       = nVersion;
1260         if (pprev)
1261             block.hashPrevBlock = pprev->GetBlockHash();
1262         block.hashMerkleRoot = hashMerkleRoot;
1263         block.nTime          = nTime;
1264         block.nBits          = nBits;
1265         block.nNonce         = nNonce;
1266         return block;
1267     }
1268
1269     uint256 GetBlockHash() const
1270     {
1271         return *phashBlock;
1272     }
1273
1274     int64_t GetBlockTime() const
1275     {
1276         return (int64_t)nTime;
1277     }
1278
1279     uint256 GetBlockTrust() const;
1280
1281     bool IsInMainChain() const
1282     {
1283         return (pnext || this == pindexBest);
1284     }
1285
1286     bool CheckIndex() const
1287     {
1288         return true;
1289     }
1290
1291     enum { nMedianTimeSpan=11 };
1292
1293     int64_t GetMedianTimePast() const
1294     {
1295         int64_t pmedian[nMedianTimeSpan];
1296         int64_t* pbegin = &pmedian[nMedianTimeSpan];
1297         int64_t* pend = &pmedian[nMedianTimeSpan];
1298
1299         const CBlockIndex* pindex = this;
1300         for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1301             *(--pbegin) = pindex->GetBlockTime();
1302
1303         std::sort(pbegin, pend);
1304         return pbegin[(pend - pbegin)/2];
1305     }
1306
1307     int64_t GetMedianTime() const
1308     {
1309         const CBlockIndex* pindex = this;
1310         for (int i = 0; i < nMedianTimeSpan/2; i++)
1311         {
1312             if (!pindex->pnext)
1313                 return GetBlockTime();
1314             pindex = pindex->pnext;
1315         }
1316         return pindex->GetMedianTimePast();
1317     }
1318
1319     /**
1320      * Returns true if there are nRequired or more blocks of minVersion or above
1321      * in the last nToCheck blocks, starting at pstart and going backwards.
1322      */
1323     static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1324                                 unsigned int nRequired, unsigned int nToCheck);
1325
1326
1327     bool IsProofOfWork() const
1328     {
1329         return !(nFlags & BLOCK_PROOF_OF_STAKE);
1330     }
1331
1332     bool IsProofOfStake() const
1333     {
1334         return (nFlags & BLOCK_PROOF_OF_STAKE);
1335     }
1336
1337     void SetProofOfStake()
1338     {
1339         nFlags |= BLOCK_PROOF_OF_STAKE;
1340     }
1341
1342     unsigned int GetStakeEntropyBit() const
1343     {
1344         return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1345     }
1346
1347     bool SetStakeEntropyBit(unsigned int nEntropyBit)
1348     {
1349         if (nEntropyBit > 1)
1350             return false;
1351         nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1352         return true;
1353     }
1354
1355     bool GeneratedStakeModifier() const
1356     {
1357         return (nFlags & BLOCK_STAKE_MODIFIER) != 0;
1358     }
1359
1360     void SetStakeModifier(uint64_t nModifier, bool fGeneratedStakeModifier)
1361     {
1362         nStakeModifier = nModifier;
1363         if (fGeneratedStakeModifier)
1364             nFlags |= BLOCK_STAKE_MODIFIER;
1365     }
1366
1367     std::string ToString() const
1368     {
1369         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)",
1370             pprev, pnext, nFile, nBlockPos, nHeight,
1371             FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1372             GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1373             nStakeModifier, nStakeModifierChecksum,
1374             hashProofOfStake.ToString().c_str(),
1375             prevoutStake.ToString().c_str(), nStakeTime,
1376             hashMerkleRoot.ToString().c_str(),
1377             GetBlockHash().ToString().c_str());
1378     }
1379
1380     void print() const
1381     {
1382         printf("%s\n", ToString().c_str());
1383     }
1384 };
1385
1386
1387
1388 /** Used to marshal pointers into hashes for db storage. */
1389 class CDiskBlockIndex : public CBlockIndex
1390 {
1391 private:
1392     uint256 blockHash;
1393
1394 public:
1395     uint256 hashPrev;
1396     uint256 hashNext;
1397
1398     CDiskBlockIndex()
1399     {
1400         hashPrev = 0;
1401         hashNext = 0;
1402         blockHash = 0;
1403     }
1404
1405     explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1406     {
1407         hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1408         hashNext = (pnext ? pnext->GetBlockHash() : 0);
1409     }
1410
1411     IMPLEMENT_SERIALIZE
1412     (
1413         if (!(nType & SER_GETHASH))
1414             READWRITE(nVersion);
1415
1416         READWRITE(hashNext);
1417         READWRITE(nFile);
1418         READWRITE(nBlockPos);
1419         READWRITE(nHeight);
1420         READWRITE(nMint);
1421         READWRITE(nMoneySupply);
1422         READWRITE(nFlags);
1423         READWRITE(nStakeModifier);
1424         if (IsProofOfStake())
1425         {
1426             READWRITE(prevoutStake);
1427             READWRITE(nStakeTime);
1428             READWRITE(hashProofOfStake);
1429         }
1430         else if (fRead)
1431         {
1432             const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1433             const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1434             const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1435         }
1436
1437         // block header
1438         READWRITE(this->nVersion);
1439         READWRITE(hashPrev);
1440         READWRITE(hashMerkleRoot);
1441         READWRITE(nTime);
1442         READWRITE(nBits);
1443         READWRITE(nNonce);
1444         READWRITE(blockHash);
1445     )
1446
1447     uint256 GetBlockHash() const
1448     {
1449         if (fUseFastIndex && (nTime < GetAdjustedTime() - nOneDay) && blockHash != 0)
1450             return blockHash;
1451
1452         CBlock block;
1453         block.nVersion        = nVersion;
1454         block.hashPrevBlock   = hashPrev;
1455         block.hashMerkleRoot  = hashMerkleRoot;
1456         block.nTime           = nTime;
1457         block.nBits           = nBits;
1458         block.nNonce          = nNonce;
1459
1460         const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1461
1462         return blockHash;
1463     }
1464
1465     std::string ToString() const
1466     {
1467         std::string str = "CDiskBlockIndex(";
1468         str += CBlockIndex::ToString();
1469         str += strprintf("\n                hashBlock=%s, hashPrev=%s, hashNext=%s)",
1470             GetBlockHash().ToString().c_str(),
1471             hashPrev.ToString().c_str(),
1472             hashNext.ToString().c_str());
1473         return str;
1474     }
1475
1476     void print() const
1477     {
1478         printf("%s\n", ToString().c_str());
1479     }
1480 };
1481
1482
1483
1484
1485
1486
1487
1488
1489 /** Describes a place in the block chain to another node such that if the
1490  * other node doesn't have the same branch, it can find a recent common trunk.
1491  * The further back it is, the further before the fork it may be.
1492  */
1493 class CBlockLocator
1494 {
1495 protected:
1496     std::vector<uint256> vHave;
1497 public:
1498
1499     CBlockLocator()
1500     {
1501     }
1502
1503     explicit CBlockLocator(const CBlockIndex* pindex)
1504     {
1505         Set(pindex);
1506     }
1507
1508     explicit CBlockLocator(uint256 hashBlock)
1509     {
1510         std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1511         if (mi != mapBlockIndex.end())
1512             Set((*mi).second);
1513     }
1514
1515     CBlockLocator(const std::vector<uint256>& vHaveIn)
1516     {
1517         vHave = vHaveIn;
1518     }
1519
1520     IMPLEMENT_SERIALIZE
1521     (
1522         if (!(nType & SER_GETHASH))
1523             READWRITE(nVersion);
1524         READWRITE(vHave);
1525     )
1526
1527     void SetNull()
1528     {
1529         vHave.clear();
1530     }
1531
1532     bool IsNull()
1533     {
1534         return vHave.empty();
1535     }
1536
1537     void Set(const CBlockIndex* pindex)
1538     {
1539         vHave.clear();
1540         int nStep = 1;
1541         while (pindex)
1542         {
1543             vHave.push_back(pindex->GetBlockHash());
1544
1545             // Exponentially larger steps back
1546             for (int i = 0; pindex && i < nStep; i++)
1547                 pindex = pindex->pprev;
1548             if (vHave.size() > 10)
1549                 nStep *= 2;
1550         }
1551         vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1552     }
1553
1554     int GetDistanceBack()
1555     {
1556         // Retrace how far back it was in the sender's branch
1557         int nDistance = 0;
1558         int nStep = 1;
1559         BOOST_FOREACH(const uint256& hash, vHave)
1560         {
1561             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1562             if (mi != mapBlockIndex.end())
1563             {
1564                 CBlockIndex* pindex = (*mi).second;
1565                 if (pindex->IsInMainChain())
1566                     return nDistance;
1567             }
1568             nDistance += nStep;
1569             if (nDistance > 10)
1570                 nStep *= 2;
1571         }
1572         return nDistance;
1573     }
1574
1575     CBlockIndex* GetBlockIndex()
1576     {
1577         // Find the first block the caller has in the main chain
1578         BOOST_FOREACH(const uint256& hash, vHave)
1579         {
1580             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1581             if (mi != mapBlockIndex.end())
1582             {
1583                 CBlockIndex* pindex = (*mi).second;
1584                 if (pindex->IsInMainChain())
1585                     return pindex;
1586             }
1587         }
1588         return pindexGenesisBlock;
1589     }
1590
1591     uint256 GetBlockHash()
1592     {
1593         // Find the first block the caller has in the main chain
1594         BOOST_FOREACH(const uint256& hash, vHave)
1595         {
1596             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1597             if (mi != mapBlockIndex.end())
1598             {
1599                 CBlockIndex* pindex = (*mi).second;
1600                 if (pindex->IsInMainChain())
1601                     return hash;
1602             }
1603         }
1604         return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1605     }
1606
1607     int GetHeight()
1608     {
1609         CBlockIndex* pindex = GetBlockIndex();
1610         if (!pindex)
1611             return 0;
1612         return pindex->nHeight;
1613     }
1614 };
1615
1616
1617
1618
1619
1620
1621
1622
1623 class CTxMemPool
1624 {
1625 public:
1626     mutable CCriticalSection cs;
1627     std::map<uint256, CTransaction> mapTx;
1628     std::map<COutPoint, CInPoint> mapNextTx;
1629
1630     bool accept(CTxDB& txdb, CTransaction &tx,
1631                 bool fCheckInputs, bool* pfMissingInputs);
1632     bool addUnchecked(const uint256& hash, CTransaction &tx);
1633     bool remove(CTransaction &tx);
1634     void clear();
1635     void queryHashes(std::vector<uint256>& vtxid);
1636
1637     size_t size()
1638     {
1639         LOCK(cs);
1640         return mapTx.size();
1641     }
1642
1643     bool exists(uint256 hash)
1644     {
1645         return (mapTx.count(hash) != 0);
1646     }
1647
1648     CTransaction& lookup(uint256 hash)
1649     {
1650         return mapTx[hash];
1651     }
1652 };
1653
1654 extern CTxMemPool mempool;
1655
1656 #endif