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 "bignum.h"
   9 #include "sync.h"
  10 #include "net.h"
  11 #include "script.h"
  12 #include "scrypt.h"
  13 #include "zerocoin/Zerocoin.h"
  14
  15 #include <list>
  16
  17 class CWallet;
  18 class CBlock;
  19 class CBlockIndex;
  20 class CKeyItem;
  21 class CReserveKey;
  22 class COutPoint;
  23
  24 class CAddress;
  25 class CInv;
  26 class CRequestTracker;
  27 class CNode;
  28 class CBlockIndexTrustComparator;
  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 unsigned int MAX_BLOCKFILE_SIZE = 0x8000000; // 128 MiB
  37 static const unsigned int BLOCKFILE_CHUNK_SIZE = 0x1000000; // 16 MiB
  38 static const unsigned int UNDOFILE_CHUNK_SIZE = 0x100000; // 1 MiB
  39 static const unsigned int MEMPOOL_HEIGHT = 0x7FFFFFFF;
  40
  41 static const int64 MIN_TX_FEE = CENT;
  42 static const int64 MIN_RELAY_TX_FEE = CENT;
  43 static const int64 MAX_MONEY = 2000000000 * COIN;
  44 static const int64 MAX_MINT_PROOF_OF_WORK = 100 * COIN;
  45 static const int64 MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
  46 static const int64 MIN_TXOUT_AMOUNT = MIN_TX_FEE;
  47
  48 static const unsigned int ENTROPY_SWITCH_TIME = 1362791041; // Sat, 09 Mar 2013 01:04:01 GMT
  49 static const unsigned int STAKE_SWITCH_TIME = 1371686400; // Thu, 20 Jun 2013 00:00:00 GMT
  50 static const unsigned int TARGETS_SWITCH_TIME = 1374278400; // Sat, 20 Jul 2013 00:00:00 GMT
  51 static const unsigned int CHAINCHECKS_SWITCH_TIME = 1379635200; // Fri, 20 Sep 2013 00:00:00 GMT
  52 static const unsigned int STAKECURVE_SWITCH_TIME = 1382227200; // Sun, 20 Oct 2013 00:00:00 GMT
  53 static const unsigned int OUTPUT_SWITCH_TIME = 1398916800; // Thu, 01 May 2014 04:00:00 GMT
  54
  55
  56 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
  57 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
  58 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov  5 00:53:20 1985 UTC
  59
  60 #ifdef USE_UPNP
  61 static const int fHaveUPnP = true;
  62 #else
  63 static const int fHaveUPnP = false;
  64 #endif
  65
  66 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
  67 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
  68
  69 inline int64 PastDrift(int64 nTime)   { return nTime - 2 * 60 * 60; } // up to 2 hours from the past
  70 inline int64 FutureDrift(int64 nTime) { return nTime + 2 * 60 * 60; } // up to 2 hours from the future
  71
  72 extern libzerocoin::Params* ZCParams;
  73 extern CScript COINBASE_FLAGS;
  74 extern CCriticalSection cs_main;
  75 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
  76 extern std::set<CBlockIndex*, CBlockIndexTrustComparator> setBlockIndexValid;
  77 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
  78 extern CBlockIndex* pindexGenesisBlock;
  79 extern unsigned int nStakeMinAge;
  80 extern unsigned int nNodeLifespan;
  81 extern int nCoinbaseMaturity;
  82 extern int nBestHeight;
  83 extern uint256 nBestChainTrust;
  84 extern uint256 nBestInvalidTrust;
  85 extern uint256 hashBestChain;
  86 extern CBlockIndex* pindexBest;
  87 extern unsigned int nTransactionsUpdated;
  88 extern uint64 nLastBlockTx;
  89 extern uint64 nLastBlockSize;
  90 extern int64 nLastCoinStakeSearchInterval;
  91 extern const std::string strMessageMagic;
  92 extern int64 nTimeBestReceived;
  93 extern CCriticalSection cs_setpwalletRegistered;
  94 extern std::set<CWallet*> setpwalletRegistered;
  95 extern unsigned char pchMessageStart[4];
  96 extern std::map<uint256, CBlock*> mapOrphanBlocks;
  97
  98 // Settings
  99 extern int64 nTransactionFee;
 100 extern int64 nMinimumInputValue;
 101 extern bool fUseFastIndex;
 102 extern unsigned int nDerivationMethodIndex;
 103
 104 // Minimum disk space required - used in CheckDiskSpace()
 105 static const uint64 nMinDiskSpace = 52428800;
 106
 107 class CReserveKey;
 108 class CCoinsDB;
 109 class CBlockTreeDB;
 110 class CDiskBlockPos;
 111 class CCoins;
 112 class CTxUndo;
 113 class CCoinsView;
 114 class CCoinsViewCache;
 115
 116 void RegisterWallet(CWallet* pwalletIn);
 117 void UnregisterWallet(CWallet* pwalletIn);
 118 void SyncWithWallets(const uint256 &hash, const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
 119 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
 120 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
 121 FILE* OpenBlockFile(const CDiskBlockPos &pos, bool fReadOnly = false);
 122 FILE* OpenUndoFile(const CDiskBlockPos &pos, bool fReadOnly = false);
 123 bool LoadBlockIndex(bool fAllowNew=true);
 124 void PrintBlockTree();
 125 CBlockIndex* FindBlockByHeight(int nHeight);
 126 bool ProcessMessages(CNode* pfrom);
 127 bool SendMessages(CNode* pto, bool fSendTrickle);
 128 bool LoadExternalBlockFile(FILE* fileIn);
 129
 130 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
 131 unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, bool fProofOfStake);
 132 int64 GetProofOfWorkReward(unsigned int nBits);
 133 int64 GetProofOfStakeReward(int64 nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly=false);
 134 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
 135 unsigned int ComputeMinStake(unsigned int nBase, int64 nTime, unsigned int nBlockTime);
 136 int GetNumBlocksOfPeers();
 137 bool IsInitialBlockDownload();
 138 std::string GetWarnings(std::string strFor);
 139 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock, bool fAllowSlow);
 140 bool SetBestChain(CBlockIndex* pindexNew);
 141 bool ConnectBestBlock();
 142 CBlockIndex * InsertBlockIndex(uint256 hash);
 143 uint256 WantedByOrphan(const CBlock* pblockOrphan);
 144 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
 145 void StakeMiner(CWallet *pwallet);
 146 void ResendWalletTransactions(bool fForce=false);
 147
 148 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
 149
 150 class CDiskBlockPos
 151 {
 152 public:
 153     int nFile;
 154     unsigned int nPos;
 155
 156     IMPLEMENT_SERIALIZE(
 157         READWRITE(VARINT(nFile));
 158         READWRITE(VARINT(nPos));
 159     )
 160
 161     friend bool operator==(const CDiskBlockPos &a, const CDiskBlockPos &b) {
 162         return (a.nFile == b.nFile && a.nPos == b.nPos);
 163     }
 164
 165     friend bool operator!=(const CDiskBlockPos &a, const CDiskBlockPos &b) {
 166         return !(a == b);
 167     }
 168
 169     void SetNull() { nFile = -1; nPos = 0; }
 170     bool IsNull() const { return (nFile == -1); }
 171 };
 172
 173
 174 /** An inpoint - a combination of a transaction and an index n into its vin */
 175 class CInPoint
 176 {
 177 public:
 178     CTransaction* ptx;
 179     unsigned int n;
 180
 181     CInPoint() { SetNull(); }
 182     CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
 183     void SetNull() { ptx = NULL; n = (unsigned int) -1; }
 184     bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
 185 };
 186
 187
 188
 189 /** An outpoint - a combination of a transaction hash and an index n into its vout */
 190 class COutPoint
 191 {
 192 public:
 193     uint256 hash;
 194     unsigned int n;
 195
 196     COutPoint() { SetNull(); }
 197     COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
 198     IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
 199     void SetNull() { hash = 0; n = (unsigned int) -1; }
 200     bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
 201
 202     friend bool operator<(const COutPoint& a, const COutPoint& b)
 203     {
 204         return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
 205     }
 206
 207     friend bool operator==(const COutPoint& a, const COutPoint& b)
 208     {
 209         return (a.hash == b.hash && a.n == b.n);
 210     }
 211
 212     friend bool operator!=(const COutPoint& a, const COutPoint& b)
 213     {
 214         return !(a == b);
 215     }
 216
 217     std::string ToString() const
 218     {
 219         return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
 220     }
 221
 222     void print() const
 223     {
 224         printf("%s\n", ToString().c_str());
 225     }
 226 };
 227
 228
 229
 230
 231 /** An input of a transaction.  It contains the location of the previous
 232  * transaction's output that it claims and a signature that matches the
 233  * output's public key.
 234  */
 235 class CTxIn
 236 {
 237 public:
 238     COutPoint prevout;
 239     CScript scriptSig;
 240     unsigned int nSequence;
 241
 242     CTxIn()
 243     {
 244         nSequence = std::numeric_limits<unsigned int>::max();
 245     }
 246
 247     explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
 248     {
 249         prevout = prevoutIn;
 250         scriptSig = scriptSigIn;
 251         nSequence = nSequenceIn;
 252     }
 253
 254     CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
 255     {
 256         prevout = COutPoint(hashPrevTx, nOut);
 257         scriptSig = scriptSigIn;
 258         nSequence = nSequenceIn;
 259     }
 260
 261     IMPLEMENT_SERIALIZE
 262     (
 263         READWRITE(prevout);
 264         READWRITE(scriptSig);
 265         READWRITE(nSequence);
 266     )
 267
 268     bool IsFinal() const
 269     {
 270         return (nSequence == std::numeric_limits<unsigned int>::max());
 271     }
 272
 273     friend bool operator==(const CTxIn& a, const CTxIn& b)
 274     {
 275         return (a.prevout   == b.prevout &&
 276                 a.scriptSig == b.scriptSig &&
 277                 a.nSequence == b.nSequence);
 278     }
 279
 280     friend bool operator!=(const CTxIn& a, const CTxIn& b)
 281     {
 282         return !(a == b);
 283     }
 284
 285     std::string ToStringShort() const
 286     {
 287         return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
 288     }
 289
 290     std::string ToString() const
 291     {
 292         std::string str;
 293         str += "CTxIn(";
 294         str += prevout.ToString();
 295         if (prevout.IsNull())
 296             str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
 297         else
 298             str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
 299         if (nSequence != std::numeric_limits<unsigned int>::max())
 300             str += strprintf(", nSequence=%u", nSequence);
 301         str += ")";
 302         return str;
 303     }
 304
 305     void print() const
 306     {
 307         printf("%s\n", ToString().c_str());
 308     }
 309 };
 310
 311
 312
 313
 314 /** An output of a transaction.  It contains the public key that the next input
 315  * must be able to sign with to claim it.
 316  */
 317 class CTxOut
 318 {
 319 public:
 320     int64 nValue;
 321     CScript scriptPubKey;
 322
 323     CTxOut()
 324     {
 325         SetNull();
 326     }
 327
 328     CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
 329     {
 330         nValue = nValueIn;
 331         scriptPubKey = scriptPubKeyIn;
 332     }
 333
 334     IMPLEMENT_SERIALIZE
 335     (
 336         READWRITE(nValue);
 337         READWRITE(scriptPubKey);
 338     )
 339
 340     void SetNull()
 341     {
 342         nValue = -1;
 343         scriptPubKey.clear();
 344     }
 345
 346     bool IsNull() const
 347     {
 348         return (nValue == -1);
 349     }
 350
 351     void SetEmpty()
 352     {
 353         nValue = 0;
 354         scriptPubKey.clear();
 355     }
 356
 357     bool IsEmpty() const
 358     {
 359         return (nValue == 0 && scriptPubKey.empty());
 360     }
 361
 362     uint256 GetHash() const
 363     {
 364         return SerializeHash(*this);
 365     }
 366
 367     friend bool operator==(const CTxOut& a, const CTxOut& b)
 368     {
 369         return (a.nValue       == b.nValue &&
 370                 a.scriptPubKey == b.scriptPubKey);
 371     }
 372
 373     friend bool operator!=(const CTxOut& a, const CTxOut& b)
 374     {
 375         return !(a == b);
 376     }
 377
 378     std::string ToStringShort() const
 379     {
 380         return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString().substr(0, 10).c_str());
 381     }
 382
 383     std::string ToString() const
 384     {
 385         if (IsEmpty()) return "CTxOut(empty)";
 386         if (scriptPubKey.size() < 6)
 387             return "CTxOut(error)";
 388         return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
 389     }
 390
 391     void print() const
 392     {
 393         printf("%s\n", ToString().c_str());
 394     }
 395 };
 396
 397
 398
 399
 400 enum GetMinFee_mode
 401 {
 402     GMF_BLOCK,
 403     GMF_RELAY,
 404     GMF_SEND,
 405 };
 406
 407 // Modes for script/signature checking
 408 enum CheckSig_mode
 409 {
 410     CS_NEVER,             // never validate scripts
 411     CS_AFTER_CHECKPOINT,  // validate scripts after the last checkpoint
 412     CS_ALWAYS             // always validate scripts
 413 };
 414
 415 /** The basic transaction that is broadcasted on the network and contained in
 416  * blocks.  A transaction can contain multiple inputs and outputs.
 417  */
 418 class CTransaction
 419 {
 420 public:
 421     static const int CURRENT_VERSION=1;
 422     int nVersion;
 423     unsigned int nTime;
 424     std::vector<CTxIn> vin;
 425     std::vector<CTxOut> vout;
 426     unsigned int nLockTime;
 427
 428     // Denial-of-service detection:
 429     mutable int nDoS;
 430     bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
 431
 432     CTransaction()
 433     {
 434         SetNull();
 435     }
 436
 437     IMPLEMENT_SERIALIZE
 438     (
 439         READWRITE(this->nVersion);
 440         nVersion = this->nVersion;
 441         READWRITE(nTime);
 442         READWRITE(vin);
 443         READWRITE(vout);
 444         READWRITE(nLockTime);
 445     )
 446
 447     void SetNull()
 448     {
 449         nVersion = CTransaction::CURRENT_VERSION;
 450         nTime = GetAdjustedTime();
 451         vin.clear();
 452         vout.clear();
 453         nLockTime = 0;
 454         nDoS = 0;  // Denial-of-service prevention
 455     }
 456
 457     bool IsNull() const
 458     {
 459         return (vin.empty() && vout.empty());
 460     }
 461
 462     uint256 GetHash() const
 463     {
 464         return SerializeHash(*this);
 465     }
 466
 467     bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
 468     {
 469         // Time based nLockTime implemented in 0.1.6
 470         if (nLockTime == 0)
 471             return true;
 472         if (nBlockHeight == 0)
 473             nBlockHeight = nBestHeight;
 474         if (nBlockTime == 0)
 475             nBlockTime = GetAdjustedTime();
 476         if ((int64)nLockTime < ((int64)nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
 477             return true;
 478         BOOST_FOREACH(const CTxIn& txin, vin)
 479             if (!txin.IsFinal())
 480                 return false;
 481         return true;
 482     }
 483
 484     bool IsNewerThan(const CTransaction& old) const
 485     {
 486         if (vin.size() != old.vin.size())
 487             return false;
 488         for (unsigned int i = 0; i < vin.size(); i++)
 489             if (vin[i].prevout != old.vin[i].prevout)
 490                 return false;
 491
 492         bool fNewer = false;
 493         unsigned int nLowest = std::numeric_limits<unsigned int>::max();
 494         for (unsigned int i = 0; i < vin.size(); i++)
 495         {
 496             if (vin[i].nSequence != old.vin[i].nSequence)
 497             {
 498                 if (vin[i].nSequence <= nLowest)
 499                 {
 500                     fNewer = false;
 501                     nLowest = vin[i].nSequence;
 502                 }
 503                 if (old.vin[i].nSequence < nLowest)
 504                 {
 505                     fNewer = true;
 506                     nLowest = old.vin[i].nSequence;
 507                 }
 508             }
 509         }
 510         return fNewer;
 511     }
 512
 513     bool IsCoinBase() const
 514     {
 515         return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
 516     }
 517
 518     bool IsCoinStake() const
 519     {
 520         // ppcoin: the coin stake transaction is marked with the first output empty
 521         return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
 522     }
 523
 524     /** Check for standard transaction types
 525         @return True if all outputs (scriptPubKeys) use only standard transaction forms
 526     */
 527     bool IsStandard() const;
 528
 529     /** Check for standard transaction types
 530         @param[in] mapInputs    Map of previous transactions that have outputs we're spending
 531         @return True if all inputs (scriptSigs) use only standard transaction forms
 532         @see CTransaction::FetchInputs
 533     */
 534     bool AreInputsStandard(CCoinsViewCache& mapInputs) const;
 535
 536     /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
 537         @return number of sigops this transaction's outputs will produce when spent
 538         @see CTransaction::FetchInputs
 539     */
 540     unsigned int GetLegacySigOpCount() const;
 541
 542     /** Count ECDSA signature operations in pay-to-script-hash inputs.
 543
 544         @param[in] mapInputs    Map of previous transactions that have outputs we're spending
 545         @return maximum number of sigops required to validate this transaction's inputs
 546         @see CTransaction::FetchInputs
 547      */
 548     unsigned int GetP2SHSigOpCount(CCoinsViewCache& mapInputs) const;
 549
 550     /** Amount of bitcoins spent by this transaction.
 551         @return sum of all outputs (note: does not include fees)
 552      */
 553     int64 GetValueOut() const
 554     {
 555         int64 nValueOut = 0;
 556         BOOST_FOREACH(const CTxOut& txout, vout)
 557         {
 558             nValueOut += txout.nValue;
 559             if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
 560                 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
 561         }
 562         return nValueOut;
 563     }
 564
 565     /** Amount of bitcoins coming in to this transaction
 566         Note that lightweight clients may not know anything besides the hash of previous transactions,
 567         so may not be able to calculate this.
 568
 569         @param[in] mapInputs    Map of previous transactions that have outputs we're spending
 570         @return Sum of value of all inputs (scriptSigs)
 571         @see CTransaction::FetchInputs
 572      */
 573     int64 GetValueIn(CCoinsViewCache& mapInputs) const;
 574
 575     static bool AllowFree(double dPriority)
 576     {
 577         // Large (in bytes) low-priority (new, small-coin) transactions
 578         // need a fee.
 579         return dPriority > COIN * 144 / 250;
 580     }
 581
 582     int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK, unsigned int nBytes = 0) const;
 583
 584     friend bool operator==(const CTransaction& a, const CTransaction& b)
 585     {
 586         return (a.nVersion  == b.nVersion &&
 587                 a.nTime     == b.nTime &&
 588                 a.vin       == b.vin &&
 589                 a.vout      == b.vout &&
 590                 a.nLockTime == b.nLockTime);
 591     }
 592
 593     friend bool operator!=(const CTransaction& a, const CTransaction& b)
 594     {
 595         return !(a == b);
 596     }
 597
 598     std::string ToStringShort() const
 599     {
 600         std::string str;
 601         str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
 602         return str;
 603     }
 604
 605     std::string ToString() const
 606     {
 607         std::string str;
 608         str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
 609         str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%"PRIszu", vout.size=%"PRIszu", nLockTime=%d)\n",
 610             GetHash().ToString().substr(0,10).c_str(),
 611             nTime,
 612             nVersion,
 613             vin.size(),
 614             vout.size(),
 615             nLockTime);
 616         for (unsigned int i = 0; i < vin.size(); i++)
 617             str += "    " + vin[i].ToString() + "\n";
 618         for (unsigned int i = 0; i < vout.size(); i++)
 619             str += "    " + vout[i].ToString() + "\n";
 620         return str;
 621     }
 622
 623     void print() const
 624     {
 625         printf("%s", ToString().c_str());
 626     }
 627
 628
 629     // Do all possible client-mode checks
 630     bool ClientCheckInputs() const;
 631
 632     // Check whether all prevouts of this transaction are present in the UTXO set represented by view
 633     bool HaveInputs(CCoinsViewCache &view) const;
 634
 635     // Check whether all inputs of this transaction are valid (no double spends, scripts & sigs, amounts)
 636     // This does not modify the UTXO set
 637     bool CheckInputs(CCoinsViewCache &view, enum CheckSig_mode csmode, bool fStrictPayToScriptHash=true, bool fStrictEncodings=true, CBlock *pblock=NULL) const;
 638
 639     // Apply the effects of this transaction on the UTXO set represented by view
 640     bool UpdateCoins(CCoinsViewCache &view, CTxUndo &txundo, int nHeight, unsigned int nBlockTime, const uint256 &txhash) const;
 641
 642     // Context-independent validity checks
 643     bool CheckTransaction() const;
 644
 645     // Try to accept this transaction into the memory pool
 646     bool AcceptToMemoryPool(bool fCheckInputs=true, bool* pfMissingInputs=NULL);
 647     bool GetCoinAge(uint64& nCoinAge) const;  // Get transaction coin age
 648 protected:
 649     static const CTxOut &GetOutputFor(const CTxIn& input, CCoinsViewCache& mapInputs);
 650 };
 651
 652
 653 /** wrapper for CTxOut that provides a more compact serialization */
 654 class CTxOutCompressor
 655 {
 656 private:
 657     CTxOut &txout;
 658
 659 public:
 660     static uint64 CompressAmount(uint64 nAmount);
 661     static uint64 DecompressAmount(uint64 nAmount);
 662
 663     CTxOutCompressor(CTxOut &txoutIn) : txout(txoutIn) { }
 664
 665     IMPLEMENT_SERIALIZE(({
 666         if (!fRead) {
 667             uint64 nVal = CompressAmount(txout.nValue);
 668             READWRITE(VARINT(nVal));
 669         } else {
 670             uint64 nVal = 0;
 671             READWRITE(VARINT(nVal));
 672             txout.nValue = DecompressAmount(nVal);
 673         }
 674         CScriptCompressor cscript(REF(txout.scriptPubKey));
 675         READWRITE(cscript);
 676     });)
 677 };
 678
 679 /** Undo information for a CTxIn
 680  *
 681  *  Contains the prevout's CTxOut being spent, and if this was the
 682  *  last output of the affected transaction, its metadata as well
 683  *  (coinbase or not, height, transaction version)
 684  */
 685 class CTxInUndo
 686 {
 687 public:
 688     CTxOut txout;              // the txout data before being spent
 689     bool fCoinBase;            // if the outpoint was the last unspent: whether it belonged to a coinbase
 690     bool fCoinStake;           // if the outpoint was the last unspent: whether it belonged to a coinstake
 691     unsigned int nHeight;      // if the outpoint was the last unspent: its height
 692     int nVersion;              // if the outpoint was the last unspent: its version
 693     unsigned int nTime;        // if the outpoint was the last unspent: its timestamp
 694     unsigned int nBlockTime;   // if the outpoint was the last unspent: its block timestamp
 695
 696     CTxInUndo() : txout(), fCoinBase(false), fCoinStake(false), nHeight(0), nVersion(0), nTime(0), nBlockTime(0) {}
 697     CTxInUndo(const CTxOut &txoutIn, bool fCoinBaseIn = false, bool fCoinStakeIn = false, unsigned int nHeightIn = 0, int nVersionIn = 0, int nTimeIn = 0, int nBlockTimeIn = 0) : txout(txoutIn), fCoinBase(fCoinBaseIn), fCoinStake(fCoinStakeIn), nHeight(nHeightIn), nVersion(nVersionIn), nTime(nTimeIn), nBlockTime(nBlockTimeIn) { }
 698
 699     unsigned int GetSerializeSize(int nType, int nVersion) const {
 700         return ::GetSerializeSize(VARINT(nHeight*2+(fCoinBase ? 1 : 0)), nType, nVersion) +
 701                ::GetSerializeSize(VARINT(nTime*2+(fCoinStake ? 1 : 0)), nType, nVersion) +
 702                ::GetSerializeSize(VARINT(nBlockTime), nType, nVersion) +
 703                (nHeight > 0 ? ::GetSerializeSize(VARINT(this->nVersion), nType, nVersion) : 0) +
 704                ::GetSerializeSize(CTxOutCompressor(REF(txout)), nType, nVersion);
 705     }
 706
 707     template<typename Stream>
 708     void Serialize(Stream &s, int nType, int nVersion) const {
 709         ::Serialize(s, VARINT(nHeight*2+(fCoinBase ? 1 : 0)), nType, nVersion);
 710         ::Serialize(s, VARINT(nTime*2+(fCoinStake ? 1 : 0)), nType, nVersion);
 711         ::Serialize(s, VARINT(nBlockTime), nType, nVersion);
 712         if (nHeight > 0)
 713             ::Serialize(s, VARINT(this->nVersion), nType, nVersion);
 714         ::Serialize(s, CTxOutCompressor(REF(txout)), nType, nVersion);
 715     }
 716
 717     template<typename Stream>
 718     void Unserialize(Stream &s, int nType, int nVersion) {
 719         unsigned int nCodeHeight = 0, nCodeTime = 0;
 720         ::Unserialize(s, VARINT(nCodeHeight), nType, nVersion);
 721         nHeight = nCodeHeight / 2;
 722         fCoinBase = nCodeHeight & 1;
 723         ::Unserialize(s, VARINT(nCodeTime), nType, nVersion);
 724         nTime = nCodeTime / 2;
 725         fCoinStake = nCodeTime & 1;
 726         ::Unserialize(s, VARINT(nBlockTime), nType, nVersion);
 727         if (nHeight > 0)
 728             ::Unserialize(s, VARINT(this->nVersion), nType, nVersion);
 729         ::Unserialize(s, REF(CTxOutCompressor(REF(txout))), nType, nVersion);
 730     }
 731 };
 732
 733 /** Undo information for a CTransaction */
 734 class CTxUndo
 735 {
 736 public:
 737     // undo information for all txins
 738     std::vector<CTxInUndo> vprevout;
 739
 740     IMPLEMENT_SERIALIZE(
 741         READWRITE(vprevout);
 742     )
 743 };
 744
 745 /** Undo information for a CBlock */
 746 class CBlockUndo
 747 {
 748 public:
 749     std::vector<CTxUndo> vtxundo; // for all but the coinbase
 750
 751     IMPLEMENT_SERIALIZE(
 752         READWRITE(vtxundo);
 753     )
 754
 755     bool WriteToDisk(CDiskBlockPos &pos)
 756     {
 757         // Open history file to append
 758         CAutoFile fileout = CAutoFile(OpenUndoFile(pos), SER_DISK, CLIENT_VERSION);
 759         if (!fileout)
 760             return error("CBlockUndo::WriteToDisk() : OpenUndoFile failed");
 761
 762         // Write index header
 763         unsigned int nSize = fileout.GetSerializeSize(*this);
 764         fileout << FLATDATA(pchMessageStart) << nSize;
 765
 766         // Write undo data
 767         long fileOutPos = ftell(fileout);
 768         if (fileOutPos < 0)
 769             return error("CBlockUndo::WriteToDisk() : ftell failed");
 770         pos.nPos = (unsigned int)fileOutPos;
 771         fileout << *this;
 772
 773         // Flush stdio buffers and commit to disk before returning
 774         fflush(fileout);
 775         if (!IsInitialBlockDownload())
 776             FileCommit(fileout);
 777
 778         return true;
 779     }
 780
 781 };
 782
 783 /** pruned version of CTransaction: only retains metadata and unspent transaction outputs
 784  *
 785  * Serialized format:
 786  * - VARINT(nVersion)
 787  * - VARINT(nFlags)
 788  * - VARINT(nCode)
 789  * - unspentness bitvector, for vout[2] and further; least significant byte first
 790  * - the non-spent CTxOuts (via CTxOutCompressor)
 791  * - VARINT(nHeight)
 792  * - VARINT(nTime + is_coinstake)
 793  * - VARINT(nBlockTime)
 794  *
 795  * The nFlag value consists of:
 796  * - bit 1: is coinbase
 797  * - bit 2: is coinstake
 798  * - bit 3: is pruned
 799  *
 800  * The nCode value consists of:
 801  * - bit 2: vout[0] is not spent
 802  * - bit 4: vout[1] is not spent
 803  * - The higher bits encode N, the number of non-zero bytes in the following bitvector.
 804  *   - In case both bit 2 and bit 4 are unset, they encode N-1, as there must be at
 805  *     least one non-spent output).
 806  *
 807  * Example: 010004835800816115944e077fe7c803cfa57f29b36bf87c1d358bb85e40f1d75240f1d752
 808  *          <><><><--------------------------------------------><----><------><------>
 809  *          |  | \                  |                            /      /       /
 810  *     version |  code            vout[1]                     height timestamp block timestamp
 811  *           flags
 812  *
 813  *    - version = 1
 814  *    - flags = 4
 815  *    - code = 4 (vout[1] is not spent, and 0 non-zero bytes of bitvector follow)
 816  *    - unspentness bitvector: as 0 non-zero bytes follow, it has length 0
 817  *    - vout[1]: 835800816115944e077fe7c803cfa57f29b36bf87c1d35
 818  *               * 8358: compact amount representation for 60000000000 (600 BTC)
 819  *               * 00: special txout type pay-to-pubkey-hash
 820  *               * 816115944e077fe7c803cfa57f29b36bf87c1d35: address uint160
 821  *    - height = 203998
 822  *    - time   = 1389883712
 823  *    - is_coinbase = 0
 824  *    - is_coinstake = 0
 825  *    - block time   = 1389883712
 826  *
 827  *
 828  * Example: 010508044086ef97d5790061b01caab50f1b8e9c50a5057eb43c2d9563a4eebbd123008c988f1a4a4de2161e0f50aac7f17e7f9555caa486af3b40f1d75240f1d752
 829  *          <><><><--><--------------------------------------------------><----------------------------------------------><----><------><------>
 830  *          /  | \   \                     |                                                           |                     /      /       /
 831  *     version | code unspentness       vout[4]                                                     vout[16]              height timestamp block timestamp
 832  *           flags
 833  *
 834  *  - version = 1
 835  *  - flags = 5
 836  *  - code = 8 (neither vout[0] or vout[1] are unspent,
 837  *                2 (1, +1 because both bit 2 and bit 4 are unset) non-zero bitvector bytes follow)
 838  *  - unspentness bitvector: bits 2 (0x04) and 14 (0x4000) are set, so vout[2+2] and vout[14+2] are unspent
 839  *  - vout[4]: 86ef97d5790061b01caab50f1b8e9c50a5057eb43c2d9563a4ee
 840  *             * 86ef97d579: compact amount representation for 234925952 (2.35 BTC)
 841  *             * 00: special txout type pay-to-pubkey-hash
 842  *             * 61b01caab50f1b8e9c50a5057eb43c2d9563a4ee: address uint160
 843  *  - vout[16]: bbd123008c988f1a4a4de2161e0f50aac7f17e7f9555caa4
 844  *              * bbd123: compact amount representation for 110397 (0.001 BTC)
 845  *              * 00: special txout type pay-to-pubkey-hash
 846  *              * 8c988f1a4a4de2161e0f50aac7f17e7f9555caa4: address uint160
 847  *  - height = 120891
 848  *  - time   = 1389883712
 849  *  - is_coinbase = 1
 850  *  - is_coinstake = 0
 851  *  - block time   = 1389883712
 852  *
 853  * Example: 010686af3b40f1d75240f1d752
 854  *          <><><----><------><------>
 855  *          /  |    \      |        \
 856  *   version flags height timestamp block timestamp
 857  *
 858  *  - version = 1
 859  *  - flags = 6 (00000110)
 860  *  - height = 120891
 861  *  - time   = 1389883712
 862  *  - is_coinbase = 0
 863  *  - is_coinstake = 1
 864  *  - block time   = 1389883712
 865  */
 866 class CCoins
 867 {
 868 public:
 869     // whether transaction is a coinbase
 870     bool fCoinBase;
 871
 872     // whether transaction is a coinstake
 873     bool fCoinStake;
 874
 875     // unspent transaction outputs; spent outputs are .IsNull(); spent outputs at the end of the array are dropped
 876     std::vector<CTxOut> vout;
 877
 878     // at which height this transaction was included in the active blockchain
 879     int nHeight;
 880
 881     // version of the CTransaction; accesses to this value should probably check for nHeight as well,
 882     // as new tx version will probably only be introduced at certain heights
 883     int nVersion;
 884
 885     // transaction timestamp + coinstake flag
 886     unsigned int nTime;
 887
 888     // block timestamp
 889     unsigned int nBlockTime;
 890
 891     // construct a CCoins from a CTransaction, at a given height/timestamp
 892     CCoins(const CTransaction &tx, int nHeightIn, int nBlockTimeIn) : fCoinBase(tx.IsCoinBase()), fCoinStake(tx.IsCoinStake()), vout(tx.vout), nHeight(nHeightIn), nVersion(tx.nVersion), nTime(tx.nTime), nBlockTime(nBlockTimeIn) { }
 893
 894     // empty constructor
 895     CCoins() : fCoinBase(false), fCoinStake(false), vout(0), nHeight(0), nVersion(0), nTime(0), nBlockTime(0) { }
 896
 897     // remove spent outputs at the end of vout
 898     void Cleanup() {
 899         while (vout.size() > 0 && (vout.back().IsNull() || vout.back().IsEmpty()))
 900             vout.pop_back();
 901     }
 902
 903     // equality test
 904     friend bool operator==(const CCoins &a, const CCoins &b) {
 905          return a.fCoinBase == b.fCoinBase &&
 906                 a.fCoinStake == b.fCoinStake &&
 907                 a.nHeight == b.nHeight &&
 908                 a.nVersion == b.nVersion &&
 909                 a.nTime == b.nTime &&
 910                 a.nBlockTime == b.nBlockTime &&
 911                 a.vout == b.vout;
 912     }
 913     friend bool operator!=(const CCoins &a, const CCoins &b) {
 914         return !(a == b);
 915     }
 916
 917     // calculate number of bytes for the bitmask, and its number of non-zero bytes
 918     // each bit in the bitmask represents the availability of one output, but the
 919     // availabilities of the first two outputs are encoded separately
 920     void CalcMaskSize(unsigned int &nBytes, unsigned int &nNonzeroBytes) const {
 921         unsigned int nLastUsedByte = 0;
 922         for (unsigned int b = 0; 2+b*8 < vout.size(); b++) {
 923             bool fZero = true;
 924             for (unsigned int i = 0; i < 8 && 2+b*8+i < vout.size(); i++) {
 925                 if (!vout[2+b*8+i].IsNull()) {
 926                     fZero = false;
 927                     continue;
 928                 }
 929             }
 930             if (!fZero) {
 931                 nLastUsedByte = b + 1;
 932                 nNonzeroBytes++;
 933             }
 934         }
 935         nBytes += nLastUsedByte;
 936     }
 937
 938     bool IsCoinBase() const {
 939         return fCoinBase;
 940     }
 941
 942     bool IsCoinStake() const {
 943         return fCoinStake;
 944     }
 945
 946     unsigned int GetSerializeSize(int nType, int nVersion) const {
 947         unsigned int nSize = 0;
 948         bool fPruned = IsPruned();
 949
 950         // version
 951         nSize += ::GetSerializeSize(VARINT(this->nVersion), nType, nVersion);
 952         unsigned char nFlags = 0;
 953         // coinbase, coinstake and prune flags
 954         nFlags = (fCoinBase ? 1 : 0)<<0 | (fCoinStake ? 1 : 0)<<1 | (fPruned ? 1 : 0)<<2;
 955         // size of flags
 956         nSize += ::GetSerializeSize(VARINT(nFlags), nType, nVersion);
 957
 958         if (!IsPruned()) {
 959             unsigned int nMaskSize = 0, nMaskCode = 0;
 960             CalcMaskSize(nMaskSize, nMaskCode);
 961             bool fFirst = vout.size() > 0 && !vout[0].IsNull();
 962             bool fSecond = vout.size() > 1 && !vout[1].IsNull();
 963
 964             assert(fFirst || fSecond || nMaskCode);
 965             unsigned int nCode = 8*(nMaskCode - (fFirst || fSecond ? 0 : 1)) + (fFirst ? 2 : 0) + (fSecond ? 4 : 0);
 966             // size of header code
 967             nSize += ::GetSerializeSize(VARINT(nCode), nType, nVersion);
 968             // spentness bitmask
 969             nSize += nMaskSize;
 970             // txouts themself
 971             for (unsigned int i = 0; i < vout.size(); i++)
 972                 if (!vout[i].IsNull())
 973                     nSize += ::GetSerializeSize(CTxOutCompressor(REF(vout[i])), nType, nVersion);
 974             // height
 975             nSize += ::GetSerializeSize(VARINT(nHeight), nType, nVersion);
 976             // timestamp and coinstake flag
 977             nSize += ::GetSerializeSize(VARINT(nTime), nType, nVersion);
 978             // block timestamp
 979             nSize += ::GetSerializeSize(VARINT(nBlockTime), nType, nVersion);
 980         }
 981         else {
 982             // size of height
 983             nSize += ::GetSerializeSize(VARINT(nHeight), nType, nVersion);
 984             // size of timestamp
 985             nSize += ::GetSerializeSize(VARINT(nTime), nType, nVersion);
 986             // size of block timestamp
 987             nSize += ::GetSerializeSize(VARINT(nBlockTime), nType, nVersion);
 988         }
 989
 990         return nSize;
 991     }
 992
 993     template<typename Stream>
 994     void Serialize(Stream &s, int nType, int nVersion) const {
 995         bool fPruned = IsPruned();
 996         unsigned char nFlags = 0;
 997         nFlags = (fCoinBase ? 1 : 0)<<0 | (fCoinStake ? 1 : 0)<<1 | (fPruned ? 1 : 0)<<2;
 998
 999         // version
1000         ::Serialize(s, VARINT(this->nVersion), nType, nVersion);
1001         // flags
1002         ::Serialize(s, VARINT(nFlags), nType, nVersion);
1003
1004         if (!fPruned) {
1005             unsigned int nMaskSize = 0, nMaskCode = 0;
1006             CalcMaskSize(nMaskSize, nMaskCode);
1007             bool fFirst = vout.size() > 0 && !vout[0].IsNull();
1008             bool fSecond = vout.size() > 1 && !vout[1].IsNull();
1009
1010             assert(fFirst || fSecond || nMaskCode);
1011
1012             unsigned int nCode = 8*(nMaskCode - (fFirst || fSecond ? 0 : 1)) + (fFirst ? 2 : 0) + (fSecond ? 4 : 0);
1013
1014             // header code
1015             ::Serialize(s, VARINT(nCode), nType, nVersion);
1016             // spentness bitmask
1017             for (unsigned int b = 0; b<nMaskSize; b++) {
1018                 unsigned char chAvail = 0;
1019                 for (unsigned int i = 0; i < 8 && 2+b*8+i < vout.size(); i++)
1020                     if (!vout[2+b*8+i].IsNull())
1021                         chAvail |= (1 << i);
1022                 ::Serialize(s, chAvail, nType, nVersion);
1023             }
1024             // txouts themself
1025             for (unsigned int i = 0; i < vout.size(); i++) {
1026                 if (!vout[i].IsNull())
1027                     ::Serialize(s, CTxOutCompressor(REF(vout[i])), nType, nVersion);
1028             }
1029             // coinbase height
1030             ::Serialize(s, VARINT(nHeight), nType, nVersion);
1031             // transaction timestamp and coinstake flag
1032             ::Serialize(s, VARINT(nTime), nType, nVersion);
1033             // block timestamp
1034             ::Serialize(s, VARINT(nBlockTime), nType, nVersion);
1035         }
1036         else {
1037             // coinbase height
1038             ::Serialize(s, VARINT(nHeight), nType, nVersion);
1039             // transaction timestamp
1040             ::Serialize(s, VARINT(nTime), nType, nVersion);
1041             // block timestamp
1042             ::Serialize(s, VARINT(nBlockTime), nType, nVersion);
1043         }
1044     }
1045
1046     template<typename Stream>
1047     void Unserialize(Stream &s, int nType, int nVersion) {
1048         unsigned char nFlags = 0;
1049
1050         // version
1051         ::Unserialize(s, VARINT(this->nVersion), nType, nVersion);
1052         // coinbase and coinstake flags
1053         ::Unserialize(s, VARINT(nFlags), nType, nVersion);
1054
1055         fCoinBase = nFlags & (1<<0);
1056         fCoinStake = nFlags & (1<<1);
1057         bool fPruned = nFlags & (1<<2);
1058
1059         if (!fPruned) {
1060             unsigned int nCode = 0;
1061             // header code
1062             ::Unserialize(s, VARINT(nCode), nType, nVersion);
1063             std::vector<bool> vAvail(2, false);
1064             vAvail[0] = nCode & 2;
1065             vAvail[1] = nCode & 4;
1066             unsigned int nMaskCode = (nCode / 8) + ((nCode & 6) != 0 ? 0 : 1);
1067             // spentness bitmask
1068             while (nMaskCode > 0) {
1069                 unsigned char chAvail = 0;
1070                 ::Unserialize(s, chAvail, nType, nVersion);
1071                 for (unsigned int p = 0; p < 8; p++) {
1072                     bool f = (chAvail & (1 << p)) != 0;
1073                     vAvail.push_back(f);
1074                 }
1075                 if (chAvail != 0)
1076                     nMaskCode--;
1077             }
1078             // txouts themself
1079             vout.assign(vAvail.size(), CTxOut());
1080             for (unsigned int i = 0; i < vAvail.size(); i++) {
1081                 if (vAvail[i])
1082                     ::Unserialize(s, REF(CTxOutCompressor(vout[i])), nType, nVersion);
1083             }
1084             // coinbase height
1085             ::Unserialize(s, VARINT(nHeight), nType, nVersion);
1086             // transaction timestamp
1087             ::Unserialize(s, VARINT(nTime), nType, nVersion);
1088             nTime = nTime;
1089             // block timestamp
1090             ::Unserialize(s, VARINT(nBlockTime), nType, nVersion);
1091         }
1092         else {
1093             // coinbase height
1094             ::Unserialize(s, VARINT(nHeight), nType, nVersion);
1095             // transaction timestamp
1096             ::Unserialize(s, VARINT(nTime), nType, nVersion);
1097             // block timestamp
1098             ::Unserialize(s, VARINT(nBlockTime), nType, nVersion);
1099         }
1100         Cleanup();
1101     }
1102
1103     // mark an outpoint spent, and construct undo information
1104     bool Spend(const COutPoint &out, CTxInUndo &undo) {
1105         if (out.n >= vout.size())
1106             return false;
1107         if (vout[out.n].IsNull())
1108             return false;
1109         undo = CTxInUndo(vout[out.n]);
1110         vout[out.n].SetNull();
1111         Cleanup();
1112         if (vout.size() == 0) {
1113             undo.nHeight = nHeight;
1114             undo.nTime = nTime;
1115             undo.nBlockTime = nBlockTime;
1116             undo.fCoinBase = fCoinBase;
1117             undo.fCoinStake = fCoinStake;
1118             undo.nVersion = this->nVersion;
1119         }
1120         return true;
1121     }
1122
1123     // mark a vout spent
1124     bool Spend(int nPos) {
1125         CTxInUndo undo;
1126         COutPoint out(0, nPos);
1127         return Spend(out, undo);
1128     }
1129
1130     // check whether a particular output is still available
1131     bool IsAvailable(unsigned int nPos) const {
1132         return (nPos < vout.size() && !vout[nPos].IsNull());
1133     }
1134
1135     // check whether the entire CCoins is spent
1136     // note that only !IsPruned() CCoins can be serialized
1137     bool IsPruned() const {
1138         if (vout.size() == 0)
1139             return true;
1140
1141         BOOST_FOREACH(const CTxOut &out, vout)
1142             if (!out.IsNull())
1143                 return false;
1144
1145         return true;
1146     }
1147 };
1148
1149
1150
1151
1152 /** A transaction with a merkle branch linking it to the block chain. */
1153 class CMerkleTx : public CTransaction
1154 {
1155 public:
1156     uint256 hashBlock;
1157     std::vector<uint256> vMerkleBranch;
1158     int nIndex;
1159
1160     // memory only
1161     mutable bool fMerkleVerified;
1162
1163
1164     CMerkleTx()
1165     {
1166         Init();
1167     }
1168
1169     CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
1170     {
1171         Init();
1172     }
1173
1174     void Init()
1175     {
1176         hashBlock = 0;
1177         nIndex = -1;
1178         fMerkleVerified = false;
1179     }
1180
1181
1182     IMPLEMENT_SERIALIZE
1183     (
1184         nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
1185         nVersion = this->nVersion;
1186         READWRITE(hashBlock);
1187         READWRITE(vMerkleBranch);
1188         READWRITE(nIndex);
1189     )
1190
1191
1192     int SetMerkleBranch(const CBlock* pblock=NULL);
1193     int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
1194     int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
1195     bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
1196     int GetBlocksToMaturity() const;
1197     bool AcceptToMemoryPool(bool fCheckInputs=true);
1198 };
1199
1200
1201
1202 /** Nodes collect new transactions into a block, hash them into a hash tree,
1203  * and scan through nonce values to make the block's hash satisfy proof-of-work
1204  * requirements.  When they solve the proof-of-work, they broadcast the block
1205  * to everyone and the block is added to the block chain.  The first transaction
1206  * in the block is a special one that creates a new coin owned by the creator
1207  * of the block.
1208  */
1209 class CBlock
1210 {
1211 public:
1212     // header
1213     static const int CURRENT_VERSION=6;
1214     int nVersion;
1215     uint256 hashPrevBlock;
1216     uint256 hashMerkleRoot;
1217     unsigned int nTime;
1218     unsigned int nBits;
1219     unsigned int nNonce;
1220
1221     // network and disk
1222     std::vector<CTransaction> vtx;
1223
1224     // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
1225     std::vector<unsigned char> vchBlockSig;
1226
1227     // memory only
1228     mutable std::vector<uint256> vMerkleTree;
1229
1230     // Denial-of-service detection:
1231     mutable int nDoS;
1232     bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
1233
1234     CBlock()
1235     {
1236         SetNull();
1237     }
1238
1239     IMPLEMENT_SERIALIZE
1240     (
1241         READWRITE(this->nVersion);
1242         nVersion = this->nVersion;
1243         READWRITE(hashPrevBlock);
1244         READWRITE(hashMerkleRoot);
1245         READWRITE(nTime);
1246         READWRITE(nBits);
1247         READWRITE(nNonce);
1248
1249         // ConnectBlock depends on vtx following header to generate CDiskTxPos
1250         if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
1251         {
1252             READWRITE(vtx);
1253             READWRITE(vchBlockSig);
1254         }
1255         else if (fRead)
1256         {
1257             const_cast<CBlock*>(this)->vtx.clear();
1258             const_cast<CBlock*>(this)->vchBlockSig.clear();
1259         }
1260     )
1261
1262     void SetNull()
1263     {
1264         nVersion = CBlock::CURRENT_VERSION;
1265         hashPrevBlock = 0;
1266         hashMerkleRoot = 0;
1267         nTime = 0;
1268         nBits = 0;
1269         nNonce = 0;
1270         vtx.clear();
1271         vchBlockSig.clear();
1272         vMerkleTree.clear();
1273         nDoS = 0;
1274     }
1275
1276     bool IsNull() const
1277     {
1278         return (nBits == 0);
1279     }
1280
1281     uint256 GetHash() const
1282     {
1283         return scrypt_blockhash(CVOIDBEGIN(nVersion));
1284     }
1285
1286     int64 GetBlockTime() const
1287     {
1288         return (int64)nTime;
1289     }
1290
1291     void UpdateTime(const CBlockIndex* pindexPrev);
1292
1293     // ppcoin: entropy bit for stake modifier if chosen by modifier
1294     unsigned int GetStakeEntropyBit(unsigned int nTime) const
1295     {
1296         // Protocol switch to support p2pool at novacoin block #9689
1297         if (nTime >= ENTROPY_SWITCH_TIME || fTestNet)
1298         {
1299             // Take last bit of block hash as entropy bit
1300             unsigned int nEntropyBit = ((GetHash().Get64()) & 1llu);
1301             if (fDebug && GetBoolArg("-printstakemodifier"))
1302                 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
1303             return nEntropyBit;
1304         }
1305         // Before novacoin block #9689 - old protocol
1306         uint160 hashSig = Hash160(vchBlockSig);
1307         if (fDebug && GetBoolArg("-printstakemodifier"))
1308             printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
1309         hashSig >>= 159; // take the first bit of the hash
1310         if (fDebug && GetBoolArg("-printstakemodifier"))
1311             printf(" entropybit=%"PRI64d"\n", hashSig.Get64());
1312         return hashSig.Get64();
1313     }
1314
1315     // ppcoin: two types of block: proof-of-work or proof-of-stake
1316     bool IsProofOfStake() const
1317     {
1318         return (vtx.size() > 1 && vtx[1].IsCoinStake());
1319     }
1320
1321     bool IsProofOfWork() const
1322     {
1323         return !IsProofOfStake();
1324     }
1325
1326     std::pair<COutPoint, unsigned int> GetProofOfStake() const
1327     {
1328         return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
1329     }
1330
1331     // ppcoin: get max transaction timestamp
1332     int64 GetMaxTransactionTime() const
1333     {
1334         int64 maxTransactionTime = 0;
1335         BOOST_FOREACH(const CTransaction& tx, vtx)
1336             maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
1337         return maxTransactionTime;
1338     }
1339
1340     uint256 BuildMerkleTree() const
1341     {
1342         vMerkleTree.clear();
1343         BOOST_FOREACH(const CTransaction& tx, vtx)
1344             vMerkleTree.push_back(tx.GetHash());
1345         int j = 0;
1346         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1347         {
1348             for (int i = 0; i < nSize; i += 2)
1349             {
1350                 int i2 = std::min(i+1, nSize-1);
1351                 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]),  END(vMerkleTree[j+i]),
1352                                            BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
1353             }
1354             j += nSize;
1355         }
1356         return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
1357     }
1358
1359     const uint256 &GetTxHash(unsigned int nIndex) const {
1360         assert(vMerkleTree.size() > 0); // BuildMerkleTree must have been called first
1361         assert(nIndex < vtx.size());
1362         return vMerkleTree[nIndex];
1363     }
1364
1365     std::vector<uint256> GetMerkleBranch(int nIndex) const
1366     {
1367         if (vMerkleTree.empty())
1368             BuildMerkleTree();
1369         std::vector<uint256> vMerkleBranch;
1370         int j = 0;
1371         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1372         {
1373             int i = std::min(nIndex^1, nSize-1);
1374             vMerkleBranch.push_back(vMerkleTree[j+i]);
1375             nIndex >>= 1;
1376             j += nSize;
1377         }
1378         return vMerkleBranch;
1379     }
1380
1381     static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1382     {
1383         if (nIndex == -1)
1384             return 0;
1385         BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1386         {
1387             if (nIndex & 1)
1388                 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1389             else
1390                 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1391             nIndex >>= 1;
1392         }
1393         return hash;
1394     }
1395
1396     bool WriteToDisk(CDiskBlockPos &pos)
1397     {
1398         // Open history file to append
1399         CAutoFile fileout = CAutoFile(OpenBlockFile(pos), SER_DISK, CLIENT_VERSION);
1400         if (!fileout)
1401             return error("CBlock::WriteToDisk() : OpenBlockFile failed");
1402
1403         // Write index header
1404         unsigned int nSize = fileout.GetSerializeSize(*this);
1405         fileout << FLATDATA(pchMessageStart) << nSize;
1406
1407         // Write block
1408         long fileOutPos = ftell(fileout);
1409         if (fileOutPos < 0)
1410             return error("CBlock::WriteToDisk() : ftell failed");
1411         pos.nPos = (unsigned int)fileOutPos;
1412         fileout << *this;
1413
1414         // Flush stdio buffers and commit to disk before returning
1415         fflush(fileout);
1416         if (!IsInitialBlockDownload())
1417             FileCommit(fileout);
1418
1419         return true;
1420     }
1421
1422     bool ReadFromDisk(const CDiskBlockPos &pos, bool fReadTransactions = true)
1423     {
1424         SetNull();
1425
1426         // Open history file to read
1427         CAutoFile filein = CAutoFile(OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION);
1428         if (!filein)
1429             return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1430         if (!fReadTransactions)
1431             filein.nType |= SER_BLOCKHEADERONLY;
1432
1433         // Read block
1434         try {
1435             filein >> *this;
1436         }
1437         catch (std::exception &e) {
1438             return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1439         }
1440
1441         // Check the header
1442         if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1443             return error("CBlock::ReadFromDisk() : errors in block header");
1444
1445         return true;
1446     }
1447
1448     void print() const
1449     {
1450         printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu", vchBlockSig=%s)\n",
1451             GetHash().ToString().c_str(),
1452             nVersion,
1453             hashPrevBlock.ToString().c_str(),
1454             hashMerkleRoot.ToString().c_str(),
1455             nTime, nBits, nNonce,
1456             vtx.size(),
1457             HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1458         for (unsigned int i = 0; i < vtx.size(); i++)
1459         {
1460             printf("  ");
1461             vtx[i].print();
1462         }
1463         printf("  vMerkleTree: ");
1464         for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1465             printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1466         printf("\n");
1467     }
1468
1469     // Undo the effects of this block (with given index) on the UTXO set represented by coins
1470     bool DisconnectBlock(CBlockIndex *pindex, CCoinsViewCache &coins);
1471
1472     // Apply the effects of this block (with given index) on the UTXO set represented by coins
1473     bool ConnectBlock(CBlockIndex *pindex, CCoinsViewCache &coins, bool fJustCheck=false);
1474
1475     // Read a block from disk
1476     bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1477
1478     // Add this block to the block index, and if necessary, switch the active block chain to this
1479     bool AddToBlockIndex(const CDiskBlockPos &pos);
1480
1481     // Context-independent validity checks
1482     bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=false) const;
1483
1484     // Store block on disk
1485     bool AcceptBlock();
1486
1487     // Get total coinage consumed
1488     bool GetCoinAge(uint64& nCoinAge) const;
1489
1490     // Generate proof-of-stake block signature
1491     bool SignBlock(CWallet& keystore);
1492
1493     // Get generator key
1494     bool GetGenerator(CKey& GeneratorKey) const;
1495
1496     // Validate proof-of-stake block signature
1497     bool CheckSignature(bool& fFatal, uint256& hashProofOfStake) const;
1498
1499     // Legacy proof-of-work signature
1500     bool CheckLegacySignature() const;
1501 };
1502
1503
1504 class CBlockFileInfo
1505 {
1506 public:
1507     unsigned int nBlocks;      // number of blocks stored in file
1508     unsigned int nSize;        // number of used bytes of block file
1509     unsigned int nUndoSize;    // number of used bytes in the undo file
1510     unsigned int nHeightFirst; // lowest height of block in file
1511     unsigned int nHeightLast;  // highest height of block in file
1512     uint64 nTimeFirst;         // earliest time of block in file
1513     uint64 nTimeLast;          // latest time of block in file
1514
1515     IMPLEMENT_SERIALIZE(
1516         READWRITE(VARINT(nBlocks));
1517         READWRITE(VARINT(nSize));
1518         READWRITE(VARINT(nUndoSize));
1519         READWRITE(VARINT(nHeightFirst));
1520         READWRITE(VARINT(nHeightLast));
1521         READWRITE(VARINT(nTimeFirst));
1522         READWRITE(VARINT(nTimeLast));
1523      )
1524
1525      void SetNull() {
1526          nBlocks = 0;
1527          nSize = 0;
1528          nUndoSize = 0;
1529          nHeightFirst = 0;
1530          nHeightLast = 0;
1531          nTimeFirst = 0;
1532          nTimeLast = 0;
1533      }
1534
1535      CBlockFileInfo() {
1536          SetNull();
1537      }
1538
1539      std::string ToString() const {
1540          return strprintf("CBlockFileInfo(blocks=%u, size=%u, heights=%u..%u, time=%s..%s)", nBlocks, nSize, nHeightFirst, nHeightLast, DateTimeStrFormat("%Y-%m-%d", nTimeFirst).c_str(), DateTimeStrFormat("%Y-%m-%d", nTimeLast).c_str());
1541      }
1542
1543      // update statistics (does not update nSize)
1544      void AddBlock(unsigned int nHeightIn, uint64 nTimeIn) {
1545          if (nBlocks==0 || nHeightFirst > nHeightIn)
1546              nHeightFirst = nHeightIn;
1547          if (nBlocks==0 || nTimeFirst > nTimeIn)
1548              nTimeFirst = nTimeIn;
1549          nBlocks++;
1550          if (nHeightIn > nHeightFirst)
1551              nHeightLast = nHeightIn;
1552          if (nTimeIn > nTimeLast)
1553              nTimeLast = nTimeIn;
1554      }
1555 };
1556
1557
1558 extern CCriticalSection cs_LastBlockFile;
1559 extern CBlockFileInfo infoLastBlockFile;
1560 extern int nLastBlockFile;
1561
1562 enum BlockStatus {
1563     BLOCK_VALID_UNKNOWN      =    0,
1564     BLOCK_VALID_HEADER       =    1, // parsed, version ok, hash satisfies claimed PoW, 1 <= vtx count <= max, timestamp not in future
1565     BLOCK_VALID_TREE         =    2, // parent found, difficulty matches, timestamp >= median previous, checkpoint
1566     BLOCK_VALID_TRANSACTIONS =    3, // only first tx is coinbase, 2 <= coinbase input script length <= 100, transactions valid, no duplicate txids, sigops, size, merkle root
1567     BLOCK_VALID_CHAIN        =    4, // outputs do not overspend inputs, no double spends, coinbase output ok, immature coinbase spends, BIP30
1568     BLOCK_VALID_SCRIPTS      =    5, // scripts/signatures ok
1569     BLOCK_VALID_MASK         =    7,
1570
1571     BLOCK_HAVE_DATA          =    8, // full block available in blk*.dat
1572     BLOCK_HAVE_UNDO          =   16, // undo data available in rev*.dat
1573     BLOCK_HAVE_MASK          =   24,
1574
1575     BLOCK_FAILED_VALID       =   32, // stage after last reached validness failed
1576     BLOCK_FAILED_CHILD       =   64, // descends from failed block
1577     BLOCK_FAILED_MASK        =   96
1578 };
1579
1580 /** The block chain is a tree shaped structure starting with the
1581  * genesis block at the root, with each block potentially having multiple
1582  * candidates to be the next block.  pprev and pnext link a path through the
1583  * main/longest chain.  A blockindex may have multiple pprev pointing back
1584  * to it, but pnext will only point forward to the longest branch, or will
1585  * be null if the block is not part of the longest chain.
1586  */
1587 class CBlockIndex
1588 {
1589 public:
1590     // pointer to the hash of the block, if any. memory is owned by this CBlockIndex
1591     const uint256* phashBlock;
1592
1593     // pointer to the index of the predecessor of this block
1594     CBlockIndex* pprev;
1595
1596     // (memory only) pointer to the index of the *active* successor of this block
1597     CBlockIndex* pnext;
1598
1599     // height of the entry in the chain. The genesis block has height 0
1600     int nHeight;
1601
1602     // Which # file this block is stored in (blk?????.dat)
1603     int nFile;
1604
1605     // Byte offset within blk?????.dat where this block's data is stored
1606     unsigned int nDataPos;
1607
1608     // Byte offset within rev?????.dat where this block's undo data is stored
1609     unsigned int nUndoPos;
1610
1611     // (memory only) Trust score of block chain up to and including this block
1612     uint256 nChainTrust;
1613
1614     // Number of transactions in this block.
1615     unsigned int nTx;
1616
1617     // (memory only) Number of transactions in the chain up to and including this block
1618     unsigned int nChainTx;
1619
1620     // Verification status of this block. See enum BlockStatus for detailed info
1621     unsigned int nStatus;
1622
1623     // Coins amount created by this block
1624     int64 nMint;
1625
1626     // Total coins created in this block chain up to and including this block
1627     int64 nMoneySupply;
1628
1629     // Block flags
1630     unsigned int nFlags;
1631     enum
1632     {
1633         // is proof-of-stake block
1634         BLOCK_PROOF_OF_STAKE = (1 << 0),
1635         // entropy bit for stake modifier
1636         BLOCK_STAKE_ENTROPY  = (1 << 1),
1637         // regenerated stake modifier
1638         BLOCK_STAKE_MODIFIER = (1 << 2),
1639     };
1640
1641     // Hash modifier for proof-of-stake kernel
1642     uint64 nStakeModifier;
1643
1644     // Checksum of index in-memory only
1645     unsigned int nStakeModifierChecksum;
1646
1647     // Predecessor of coinstake transaction
1648     COutPoint prevoutStake;
1649
1650     // Timestamp of coinstake transaction
1651     unsigned int nStakeTime;
1652
1653     // Kernel hash
1654     uint256 hashProofOfStake;
1655
1656     // Block header
1657     int nVersion;
1658     uint256 hashMerkleRoot;
1659     unsigned int nTime;
1660     unsigned int nBits;
1661     unsigned int nNonce;
1662
1663     CBlockIndex()
1664     {
1665         phashBlock = NULL;
1666         pprev = NULL;
1667         pnext = NULL;
1668         nHeight = 0;
1669         nFile = 0;
1670         nDataPos = 0;
1671         nUndoPos = 0;
1672         nChainTrust = 0;
1673         nTx = 0;
1674         nChainTx = 0;
1675         nStatus = 0;
1676         nMint = 0;
1677         nMoneySupply = 0;
1678         nFlags = 0;
1679         nStakeModifier = 0;
1680         nStakeModifierChecksum = 0;
1681         hashProofOfStake = 0;
1682         prevoutStake.SetNull();
1683         nStakeTime = 0;
1684
1685         nVersion       = 0;
1686         hashMerkleRoot = 0;
1687         nTime          = 0;
1688         nBits          = 0;
1689         nNonce         = 0;
1690     }
1691
1692     CBlockIndex(CBlock& block)
1693     {
1694         phashBlock = NULL;
1695         pprev = NULL;
1696         pnext = NULL;
1697         nHeight = 0;
1698         nFile = 0;
1699         nDataPos = 0;
1700         nUndoPos = 0;
1701         nChainTrust = 0;
1702         nTx = 0;
1703         nChainTx = 0;
1704         nStatus = 0;
1705         nMint = 0;
1706         nMoneySupply = 0;
1707         nFlags = 0;
1708         nStakeModifier = 0;
1709         nStakeModifierChecksum = 0;
1710         hashProofOfStake = 0;
1711         if (block.IsProofOfStake())
1712         {
1713             SetProofOfStake();
1714             prevoutStake = block.vtx[1].vin[0].prevout;
1715             nStakeTime = block.vtx[1].nTime;
1716         }
1717         else
1718         {
1719             prevoutStake.SetNull();
1720             nStakeTime = 0;
1721         }
1722
1723         nVersion       = block.nVersion;
1724         hashMerkleRoot = block.hashMerkleRoot;
1725         nTime          = block.nTime;
1726         nBits          = block.nBits;
1727         nNonce         = block.nNonce;
1728     }
1729
1730     CDiskBlockPos GetBlockPos() const {
1731         CDiskBlockPos ret;
1732         if (nStatus & BLOCK_HAVE_DATA) {
1733             ret.nFile = nFile;
1734             ret.nPos  = nDataPos;
1735         } else
1736             ret.SetNull();
1737         return ret;
1738     }
1739
1740     CDiskBlockPos GetUndoPos() const {
1741         CDiskBlockPos ret;
1742         if (nStatus & BLOCK_HAVE_UNDO) {
1743             ret.nFile = nFile;
1744             ret.nPos  = nUndoPos;
1745         } else
1746             ret.SetNull();
1747         return ret;
1748     }
1749
1750     CBlock GetBlockHeader() const
1751     {
1752         CBlock block;
1753         block.nVersion       = nVersion;
1754         if (pprev)
1755             block.hashPrevBlock = pprev->GetBlockHash();
1756         block.hashMerkleRoot = hashMerkleRoot;
1757         block.nTime          = nTime;
1758         block.nBits          = nBits;
1759         block.nNonce         = nNonce;
1760         return block;
1761     }
1762
1763     uint256 GetBlockHash() const
1764     {
1765         return *phashBlock;
1766     }
1767
1768     int64 GetBlockTime() const
1769     {
1770         return (int64)nTime;
1771     }
1772
1773     uint256 GetBlockTrust() const;
1774
1775     bool IsInMainChain() const
1776     {
1777         return (pnext || this == pindexBest);
1778     }
1779
1780     bool CheckIndex() const
1781     {
1782         return true;
1783     }
1784
1785     enum { nMedianTimeSpan=11 };
1786
1787     int64 GetMedianTimePast() const
1788     {
1789         int64 pmedian[nMedianTimeSpan];
1790         int64* pbegin = &pmedian[nMedianTimeSpan];
1791         int64* pend = &pmedian[nMedianTimeSpan];
1792
1793         const CBlockIndex* pindex = this;
1794         for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1795             *(--pbegin) = pindex->GetBlockTime();
1796
1797         std::sort(pbegin, pend);
1798         return pbegin[(pend - pbegin)/2];
1799     }
1800
1801     int64 GetMedianTime() const
1802     {
1803         const CBlockIndex* pindex = this;
1804         for (int i = 0; i < nMedianTimeSpan/2; i++)
1805         {
1806             if (!pindex->pnext)
1807                 return GetBlockTime();
1808             pindex = pindex->pnext;
1809         }
1810         return pindex->GetMedianTimePast();
1811     }
1812
1813     /**
1814      * Returns true if there are nRequired or more blocks of minVersion or above
1815      * in the last nToCheck blocks, starting at pstart and going backwards.
1816      */
1817     static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1818                                 unsigned int nRequired, unsigned int nToCheck);
1819
1820     bool IsProofOfWork() const
1821     {
1822         return !(nFlags & BLOCK_PROOF_OF_STAKE);
1823     }
1824
1825     bool IsProofOfStake() const
1826     {
1827         return (nFlags & BLOCK_PROOF_OF_STAKE);
1828     }
1829
1830     void SetProofOfStake()
1831     {
1832         nFlags |= BLOCK_PROOF_OF_STAKE;
1833     }
1834
1835     unsigned int GetStakeEntropyBit() const
1836     {
1837         return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1838     }
1839
1840     bool SetStakeEntropyBit(unsigned int nEntropyBit)
1841     {
1842         if (nEntropyBit > 1)
1843             return false;
1844         nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1845         return true;
1846     }
1847
1848     bool GeneratedStakeModifier() const
1849     {
1850         return (nFlags & BLOCK_STAKE_MODIFIER);
1851     }
1852
1853     void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1854     {
1855         nStakeModifier = nModifier;
1856         if (fGeneratedStakeModifier)
1857             nFlags |= BLOCK_STAKE_MODIFIER;
1858     }
1859
1860     std::string ToString() const
1861     {
1862         return strprintf("CBlockIndex(nprev=%p, pnext=%p 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)",
1863             pprev, pnext, nHeight,
1864             FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1865             GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1866             nStakeModifier, nStakeModifierChecksum,
1867             hashProofOfStake.ToString().c_str(),
1868             prevoutStake.ToString().c_str(), nStakeTime,
1869             hashMerkleRoot.ToString().c_str(),
1870             GetBlockHash().ToString().c_str());
1871     }
1872
1873
1874     void print() const
1875     {
1876         printf("%s\n", ToString().c_str());
1877     }
1878 };
1879
1880 struct CBlockIndexTrustComparator
1881 {
1882     bool operator()(CBlockIndex *pa, CBlockIndex *pb) {
1883         if (pa->nChainTrust > pb->nChainTrust) return false;
1884         if (pa->nChainTrust < pb->nChainTrust) return true;
1885
1886         return false; // identical blocks
1887     }
1888 };
1889
1890 /** Used to marshal pointers into hashes for db storage. */
1891 class CDiskBlockIndex : public CBlockIndex
1892 {
1893 private:
1894     uint256 blockHash;
1895 public:
1896     uint256 hashPrev;
1897
1898     CDiskBlockIndex() {
1899         hashPrev = 0;
1900         blockHash = 0;
1901     }
1902
1903     explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex) {
1904         hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1905     }
1906
1907     IMPLEMENT_SERIALIZE
1908     (
1909         if (!(nType & SER_GETHASH))
1910             READWRITE(VARINT(nVersion));
1911
1912         READWRITE(VARINT(nHeight));
1913         READWRITE(VARINT(nStatus));
1914         READWRITE(VARINT(nTx));
1915         if (nStatus & (BLOCK_HAVE_DATA | BLOCK_HAVE_UNDO))
1916             READWRITE(VARINT(nFile));
1917         if (nStatus & BLOCK_HAVE_DATA)
1918             READWRITE(VARINT(nDataPos));
1919         if (nStatus & BLOCK_HAVE_UNDO)
1920             READWRITE(VARINT(nUndoPos));
1921         READWRITE(nMint);
1922         READWRITE(nMoneySupply);
1923         READWRITE(nFlags);
1924         READWRITE(nStakeModifier);
1925         if (IsProofOfStake())
1926         {
1927             READWRITE(prevoutStake);
1928             READWRITE(nStakeTime);
1929             READWRITE(hashProofOfStake);
1930         }
1931         else if (fRead)
1932         {
1933             const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1934             const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1935             const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1936         }
1937         READWRITE(blockHash);
1938
1939         // block header
1940         READWRITE(this->nVersion);
1941         READWRITE(hashPrev);
1942         READWRITE(hashMerkleRoot);
1943         READWRITE(nTime);
1944         READWRITE(nBits);
1945         READWRITE(nNonce);
1946     )
1947
1948     uint256 GetBlockHash() const
1949     {
1950         if (fUseFastIndex && (nTime < GetAdjustedTime() - 24 * 60 * 60) && blockHash != 0)
1951             return blockHash;
1952
1953         CBlock block;
1954         block.nVersion        = nVersion;
1955         block.hashPrevBlock   = hashPrev;
1956         block.hashMerkleRoot  = hashMerkleRoot;
1957         block.nTime           = nTime;
1958         block.nBits           = nBits;
1959         block.nNonce          = nNonce;
1960
1961         const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1962
1963         return blockHash;
1964     }
1965
1966
1967     std::string ToString() const
1968     {
1969         std::string str = "CDiskBlockIndex(";
1970         str += CBlockIndex::ToString();
1971         str += strprintf("\n                hashBlock=%s, hashPrev=%s)",
1972             GetBlockHash().ToString().c_str(),
1973             hashPrev.ToString().substr(0,20).c_str());
1974         return str;
1975     }
1976
1977     void print() const
1978     {
1979         printf("%s\n", ToString().c_str());
1980     }
1981 };
1982
1983
1984 /** Describes a place in the block chain to another node such that if the
1985  * other node doesn't have the same branch, it can find a recent common trunk.
1986  * The further back it is, the further before the fork it may be.
1987  */
1988 class CBlockLocator
1989 {
1990 protected:
1991     std::vector<uint256> vHave;
1992 public:
1993
1994     CBlockLocator()
1995     {
1996     }
1997
1998     explicit CBlockLocator(const CBlockIndex* pindex)
1999     {
2000         Set(pindex);
2001     }
2002
2003     explicit CBlockLocator(uint256 hashBlock)
2004     {
2005         std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
2006         if (mi != mapBlockIndex.end())
2007             Set((*mi).second);
2008     }
2009
2010     CBlockLocator(const std::vector<uint256>& vHaveIn)
2011     {
2012         vHave = vHaveIn;
2013     }
2014
2015     IMPLEMENT_SERIALIZE
2016     (
2017         if (!(nType & SER_GETHASH))
2018             READWRITE(nVersion);
2019         READWRITE(vHave);
2020     )
2021
2022     void SetNull()
2023     {
2024         vHave.clear();
2025     }
2026
2027     bool IsNull()
2028     {
2029         return vHave.empty();
2030     }
2031
2032     void Set(const CBlockIndex* pindex)
2033     {
2034         vHave.clear();
2035         int nStep = 1;
2036         while (pindex)
2037         {
2038             vHave.push_back(pindex->GetBlockHash());
2039
2040             // Exponentially larger steps back
2041             for (int i = 0; pindex && i < nStep; i++)
2042                 pindex = pindex->pprev;
2043             if (vHave.size() > 10)
2044                 nStep *= 2;
2045         }
2046         vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
2047     }
2048
2049     int GetDistanceBack()
2050     {
2051         // Retrace how far back it was in the sender's branch
2052         int nDistance = 0;
2053         int nStep = 1;
2054         BOOST_FOREACH(const uint256& hash, vHave)
2055         {
2056             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
2057             if (mi != mapBlockIndex.end())
2058             {
2059                 CBlockIndex* pindex = (*mi).second;
2060                 if (pindex->IsInMainChain())
2061                     return nDistance;
2062             }
2063             nDistance += nStep;
2064             if (nDistance > 10)
2065                 nStep *= 2;
2066         }
2067         return nDistance;
2068     }
2069
2070     CBlockIndex* GetBlockIndex()
2071     {
2072         // Find the first block the caller has in the main chain
2073         BOOST_FOREACH(const uint256& hash, vHave)
2074         {
2075             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
2076             if (mi != mapBlockIndex.end())
2077             {
2078                 CBlockIndex* pindex = (*mi).second;
2079                 if (pindex->IsInMainChain())
2080                     return pindex;
2081             }
2082         }
2083         return pindexGenesisBlock;
2084     }
2085
2086     uint256 GetBlockHash()
2087     {
2088         // Find the first block the caller has in the main chain
2089         BOOST_FOREACH(const uint256& hash, vHave)
2090         {
2091             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
2092             if (mi != mapBlockIndex.end())
2093             {
2094                 CBlockIndex* pindex = (*mi).second;
2095                 if (pindex->IsInMainChain())
2096                     return hash;
2097             }
2098         }
2099         return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
2100     }
2101
2102     int GetHeight()
2103     {
2104         CBlockIndex* pindex = GetBlockIndex();
2105         if (!pindex)
2106             return 0;
2107         return pindex->nHeight;
2108     }
2109 };
2110
2111
2112
2113
2114
2115 class CTxMemPool
2116 {
2117 public:
2118     mutable CCriticalSection cs;
2119     std::map<uint256, CTransaction> mapTx;
2120     std::map<COutPoint, CInPoint> mapNextTx;
2121
2122     bool accept(CTransaction &tx, bool fCheckInputs, bool* pfMissingInputs);
2123     bool addUnchecked(const uint256& hash, CTransaction &tx);
2124     bool remove(CTransaction &tx);
2125     void clear();
2126     void queryHashes(std::vector<uint256>& vtxid);
2127     void pruneSpent(const uint256& hash, CCoins &coins);
2128
2129     unsigned long size()
2130     {
2131         LOCK(cs);
2132         return mapTx.size();
2133     }
2134
2135     bool exists(uint256 hash)
2136     {
2137         return (mapTx.count(hash) != 0);
2138     }
2139
2140     CTransaction& lookup(uint256 hash)
2141     {
2142         return mapTx[hash];
2143     }
2144 };
2145
2146 extern CTxMemPool mempool;
2147
2148 struct CCoinsStats
2149 {
2150     int nHeight;
2151     uint64 nTransactions;
2152     uint64 nPrunedTransactions;
2153     uint64 nTransactionOutputs;
2154     uint64 nSerializedSize;
2155
2156     CCoinsStats() : nHeight(0), nTransactions(0), nPrunedTransactions(0), nTransactionOutputs(0), nSerializedSize(0) {}
2157 };
2158
2159 /** Abstract view on the open txout dataset. */
2160 class CCoinsView
2161 {
2162 public:
2163     // Retrieve the CCoins (unspent transaction outputs) for a given txid
2164     virtual bool GetCoins(uint256 txid, CCoins &coins);
2165
2166     // Modify the CCoins for a given txid
2167     virtual bool SetCoins(uint256 txid, const CCoins &coins);
2168
2169     // Just check whether we have data for a given txid.
2170     // This may (but cannot always) return true for fully spent transactions
2171     virtual bool HaveCoins(uint256 txid);
2172
2173     // Retrieve the block index whose state this CCoinsView currently represents
2174     virtual CBlockIndex *GetBestBlock();
2175
2176     // Modify the currently active block index
2177     virtual bool SetBestBlock(CBlockIndex *pindex);
2178     virtual bool BatchWrite(const std::map<uint256, CCoins> &mapCoins, CBlockIndex *pindex);
2179     virtual bool GetStats(CCoinsStats &stats);
2180 };
2181
2182 /** CCoinsView backed by another CCoinsView */
2183 class CCoinsViewBacked : public CCoinsView
2184 {
2185 protected:
2186     CCoinsView *base;
2187
2188 public:
2189     CCoinsViewBacked(CCoinsView &viewIn);
2190     bool GetCoins(uint256 txid, CCoins &coins);
2191     bool SetCoins(uint256 txid, const CCoins &coins);
2192     bool HaveCoins(uint256 txid);
2193     CBlockIndex *GetBestBlock();
2194     bool SetBestBlock(CBlockIndex *pindex);
2195     void SetBackend(CCoinsView &viewIn);
2196     bool BatchWrite(const std::map<uint256, CCoins> &mapCoins, CBlockIndex *pindex);
2197     bool GetStats(CCoinsStats &stats);
2198 };
2199
2200 /** CCoinsView that adds a memory cache for transactions to another CCoinsView */
2201 class CCoinsViewCache : public CCoinsViewBacked
2202 {
2203 protected:
2204     CBlockIndex *pindexTip;
2205     std::map<uint256,CCoins> cacheCoins;
2206     std::map<uint256,CCoins> cacheCoinsReadOnly;
2207
2208 public:
2209     CCoinsViewCache(CCoinsView &baseIn, bool fDummy = false);
2210     bool GetCoins(uint256 txid, CCoins &coins);
2211     bool GetCoinsReadOnly(uint256 txid, CCoins &coins);
2212     bool SetCoins(uint256 txid, const CCoins &coins);
2213     bool HaveCoins(uint256 txid);
2214     CCoins &GetCoins(uint256 txid);
2215     CBlockIndex *GetBestBlock();
2216     bool SetBestBlock(CBlockIndex *pindex);
2217     bool BatchWrite(const std::map<uint256, CCoins> &mapCoins, CBlockIndex *pindex);
2218     bool Flush();
2219     unsigned int GetCacheSize();
2220 private:
2221     std::map<uint256,CCoins>::iterator FetchCoins(uint256 txid);
2222 };
2223
2224 /** CCoinsView that brings transactions from a memorypool into view.
2225     It does not check for spendings by memory pool transactions. */
2226 class CCoinsViewMemPool : public CCoinsViewBacked
2227 {
2228 protected:
2229     CTxMemPool &mempool;
2230
2231 public:
2232     CCoinsViewMemPool(CCoinsView &baseIn, CTxMemPool &mempoolIn);
2233     bool GetCoins(uint256 txid, CCoins &coins);
2234     bool HaveCoins(uint256 txid);
2235 };
2236
2237 /** Global variable that points to the active CCoinsView (protected by cs_main) */
2238 extern CCoinsViewCache *pcoinsTip;
2239
2240 /** Global variable that points to the active block tree (protected by cs_main) */
2241 extern CBlockTreeDB *pblocktree;
2242
2243 #endif