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