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_mine.h"
  13
  14 #include <list>
  15
  16 class CWallet;
  17 class CBlock;
  18 class CBlockIndex;
  19 class CKeyItem;
  20 class CReserveKey;
  21 class COutPoint;
  22
  23 class CAddress;
  24 class CInv;
  25 class CRequestTracker;
  26 class CNode;
  27
  28 static const unsigned int MAX_BLOCK_SIZE = 1000000;
  29 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
  30 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
  31 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
  32 static const unsigned int MAX_INV_SZ = 50000;
  33 static const int64 MIN_TX_FEE = CENT;
  34 static const int64 MIN_RELAY_TX_FEE = CENT;
  35 static const int64 MAX_MONEY = 2000000000 * COIN;
  36 static const int64 MAX_MINT_PROOF_OF_WORK = 100 * COIN;
  37 static const int64 MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
  38 static const int64 MIN_TXOUT_AMOUNT = MIN_TX_FEE;
  39
  40 static const unsigned int ENTROPY_SWITCH_TIME = 1362791041; // Sat, 09 Mar 2013 01:04:01 GMT
  41 static const unsigned int STAKE_SWITCH_TIME = 1371686400; // Thu, 20 Jun 2013 00:00:00 GMT
  42 static const unsigned int TARGETS_SWITCH_TIME = 1374278400; // Sat, 20 Jul 2013 00:00:00 GMT
  43 static const unsigned int LOCKS_SWITCH_TIME = 1376956800; // Tue, 20 Aug 2013 00:00:00 GMT
  44 static const unsigned int CHAINCHECKS_SWITCH_TIME = 1379635200; // Fri, 20 Sep 2013 00:00:00 GMT
  45 static const unsigned int STAKECURVE_SWITCH_TIME = 1382227200; // Sun, 20 Oct 2013 00:00:00 GMT
  46 static const unsigned int STAKEWEIGHT_SWITCH_TIME = 1388534400; // Wed, 01 Jan 2014 00:00:00 GMT
  47
  48
  49 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
  50 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
  51 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov  5 00:53:20 1985 UTC
  52
  53 #ifdef USE_UPNP
  54 static const int fHaveUPnP = true;
  55 #else
  56 static const int fHaveUPnP = false;
  57 #endif
  58
  59 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
  60 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
  61
  62 static const int64 nMaxClockDrift = 2 * 60 * 60;        // two hours
  63
  64 extern CScript COINBASE_FLAGS;
  65
  66
  67 extern CCriticalSection cs_main;
  68 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
  69 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
  70 extern CBlockIndex* pindexGenesisBlock;
  71 extern unsigned int nStakeMinAge;
  72 extern unsigned int nNodeLifespan;
  73 extern int nCoinbaseMaturity;
  74 extern int nBestHeight;
  75 extern uint256 nBestChainTrust;
  76 extern uint256 nBestInvalidTrust;
  77 extern uint256 hashBestChain;
  78 extern CBlockIndex* pindexBest;
  79 extern unsigned int nTransactionsUpdated;
  80 extern uint64 nLastBlockTx;
  81 extern uint64 nLastBlockSize;
  82 extern int64 nLastCoinStakeSearchInterval;
  83 extern const std::string strMessageMagic;
  84 extern double dHashesPerSec;
  85 extern int64 nHPSTimerStart;
  86 extern int64 nTimeBestReceived;
  87 extern CCriticalSection cs_setpwalletRegistered;
  88 extern std::set<CWallet*> setpwalletRegistered;
  89 extern unsigned char pchMessageStart[4];
  90 extern std::map<uint256, CBlock*> mapOrphanBlocks;
  91
  92 // Settings
  93 extern int64 nTransactionFee;
  94
  95 // Minimum disk space required - used in CheckDiskSpace()
  96 static const uint64 nMinDiskSpace = 52428800;
  97
  98
  99 class CReserveKey;
 100 class CTxDB;
 101 class CTxIndex;
 102
 103 void RegisterWallet(CWallet* pwalletIn);
 104 void UnregisterWallet(CWallet* pwalletIn);
 105 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
 106 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
 107 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
 108 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
 109 FILE* AppendBlockFile(unsigned int& nFileRet);
 110 bool LoadBlockIndex(bool fAllowNew=true);
 111 void PrintBlockTree();
 112 CBlockIndex* FindBlockByHeight(int nHeight);
 113 bool ProcessMessages(CNode* pfrom);
 114 bool SendMessages(CNode* pto, bool fSendTrickle);
 115 bool LoadExternalBlockFile(FILE* fileIn);
 116 CBlock* CreateNewBlock(CWallet* pwallet, bool fProofOfStake=false);
 117 void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
 118 void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
 119 bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
 120 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
 121 int64 GetProofOfWorkReward(unsigned int nBits);
 122 int64 GetProofOfStakeReward(int64 nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly=false);
 123 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
 124 unsigned int ComputeMinStake(unsigned int nBase, int64 nTime, unsigned int nBlockTime);
 125 int GetNumBlocksOfPeers();
 126 bool IsInitialBlockDownload();
 127 std::string GetWarnings(std::string strFor);
 128 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
 129 uint256 WantedByOrphan(const CBlock* pblockOrphan);
 130 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
 131 void BitcoinMiner(CWallet *pwallet, bool fProofOfStake);
 132 void ResendWalletTransactions();
 133
 134
 135
 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) 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] fStrictPayToScriptHash       true if fully validating p2sh transactions
 702         @return Returns true if all checks succeed
 703      */
 704     bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs,
 705                        std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
 706                        const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash=true);
 707     bool ClientConnectInputs();
 708     bool CheckTransaction() const;
 709     bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
 710     bool GetCoinAge(CTxDB& txdb, uint64& nCoinAge) const;  // ppcoin: get transaction coin age
 711
 712 protected:
 713     const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
 714 };
 715
 716
 717
 718
 719
 720 /** A transaction with a merkle branch linking it to the block chain. */
 721 class CMerkleTx : public CTransaction
 722 {
 723 public:
 724     uint256 hashBlock;
 725     std::vector<uint256> vMerkleBranch;
 726     int nIndex;
 727
 728     // memory only
 729     mutable bool fMerkleVerified;
 730
 731
 732     CMerkleTx()
 733     {
 734         Init();
 735     }
 736
 737     CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
 738     {
 739         Init();
 740     }
 741
 742     void Init()
 743     {
 744         hashBlock = 0;
 745         nIndex = -1;
 746         fMerkleVerified = false;
 747     }
 748
 749
 750     IMPLEMENT_SERIALIZE
 751     (
 752         nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
 753         nVersion = this->nVersion;
 754         READWRITE(hashBlock);
 755         READWRITE(vMerkleBranch);
 756         READWRITE(nIndex);
 757     )
 758
 759
 760     int SetMerkleBranch(const CBlock* pblock=NULL);
 761     int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
 762     int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
 763     bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
 764     int GetBlocksToMaturity() const;
 765     bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
 766     bool AcceptToMemoryPool();
 767 };
 768
 769
 770
 771
 772 /**  A txdb record that contains the disk location of a transaction and the
 773  * locations of transactions that spend its outputs.  vSpent is really only
 774  * used as a flag, but having the location is very helpful for debugging.
 775  */
 776 class CTxIndex
 777 {
 778 public:
 779     CDiskTxPos pos;
 780     std::vector<CDiskTxPos> vSpent;
 781
 782     CTxIndex()
 783     {
 784         SetNull();
 785     }
 786
 787     CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
 788     {
 789         pos = posIn;
 790         vSpent.resize(nOutputs);
 791     }
 792
 793     IMPLEMENT_SERIALIZE
 794     (
 795         if (!(nType & SER_GETHASH))
 796             READWRITE(nVersion);
 797         READWRITE(pos);
 798         READWRITE(vSpent);
 799     )
 800
 801     void SetNull()
 802     {
 803         pos.SetNull();
 804         vSpent.clear();
 805     }
 806
 807     bool IsNull()
 808     {
 809         return pos.IsNull();
 810     }
 811
 812     friend bool operator==(const CTxIndex& a, const CTxIndex& b)
 813     {
 814         return (a.pos    == b.pos &&
 815                 a.vSpent == b.vSpent);
 816     }
 817
 818     friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
 819     {
 820         return !(a == b);
 821     }
 822     int GetDepthInMainChain() const;
 823
 824 };
 825
 826
 827
 828
 829
 830 /** Nodes collect new transactions into a block, hash them into a hash tree,
 831  * and scan through nonce values to make the block's hash satisfy proof-of-work
 832  * requirements.  When they solve the proof-of-work, they broadcast the block
 833  * to everyone and the block is added to the block chain.  The first transaction
 834  * in the block is a special one that creates a new coin owned by the creator
 835  * of the block.
 836  *
 837  * Blocks are appended to blk0001.dat files on disk.  Their location on disk
 838  * is indexed by CBlockIndex objects in memory.
 839  */
 840 class CBlock
 841 {
 842 public:
 843     // header
 844     static const int CURRENT_VERSION=6;
 845     int nVersion;
 846     uint256 hashPrevBlock;
 847     uint256 hashMerkleRoot;
 848     unsigned int nTime;
 849     unsigned int nBits;
 850     unsigned int nNonce;
 851
 852     // network and disk
 853     std::vector<CTransaction> vtx;
 854
 855     // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
 856     std::vector<unsigned char> vchBlockSig;
 857
 858     // memory only
 859     mutable std::vector<uint256> vMerkleTree;
 860
 861     // Denial-of-service detection:
 862     mutable int nDoS;
 863     bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
 864
 865     CBlock()
 866     {
 867         SetNull();
 868     }
 869
 870     IMPLEMENT_SERIALIZE
 871     (
 872         READWRITE(this->nVersion);
 873         nVersion = this->nVersion;
 874         READWRITE(hashPrevBlock);
 875         READWRITE(hashMerkleRoot);
 876         READWRITE(nTime);
 877         READWRITE(nBits);
 878         READWRITE(nNonce);
 879
 880         // ConnectBlock depends on vtx following header to generate CDiskTxPos
 881         if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
 882         {
 883             READWRITE(vtx);
 884             READWRITE(vchBlockSig);
 885         }
 886         else if (fRead)
 887         {
 888             const_cast<CBlock*>(this)->vtx.clear();
 889             const_cast<CBlock*>(this)->vchBlockSig.clear();
 890         }
 891     )
 892
 893     void SetNull()
 894     {
 895         nVersion = CBlock::CURRENT_VERSION;
 896         hashPrevBlock = 0;
 897         hashMerkleRoot = 0;
 898         nTime = 0;
 899         nBits = 0;
 900         nNonce = 0;
 901         vtx.clear();
 902         vchBlockSig.clear();
 903         vMerkleTree.clear();
 904         nDoS = 0;
 905     }
 906
 907     bool IsNull() const
 908     {
 909         return (nBits == 0);
 910     }
 911
 912     uint256 GetHash() const
 913     {
 914         uint256 thash;
 915         void * scratchbuff = scrypt_buffer_alloc();
 916
 917         scrypt_hash(CVOIDBEGIN(nVersion), sizeof(block_header), UINTBEGIN(thash), scratchbuff);
 918
 919         scrypt_buffer_free(scratchbuff);
 920
 921         return thash;
 922     }
 923
 924     int64 GetBlockTime() const
 925     {
 926         return (int64)nTime;
 927     }
 928
 929     void UpdateTime(const CBlockIndex* pindexPrev);
 930
 931     // ppcoin: entropy bit for stake modifier if chosen by modifier
 932     unsigned int GetStakeEntropyBit(unsigned int nTime) const
 933     {
 934         // Protocol switch to support p2pool at novacoin block #9689
 935         if (nTime >= ENTROPY_SWITCH_TIME || fTestNet)
 936         {
 937             // Take last bit of block hash as entropy bit
 938             unsigned int nEntropyBit = ((GetHash().Get64()) & 1llu);
 939             if (fDebug && GetBoolArg("-printstakemodifier"))
 940                 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
 941             return nEntropyBit;
 942         }
 943         // Before novacoin block #9689 - old protocol
 944         uint160 hashSig = Hash160(vchBlockSig);
 945         if (fDebug && GetBoolArg("-printstakemodifier"))
 946             printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
 947         hashSig >>= 159; // take the first bit of the hash
 948         if (fDebug && GetBoolArg("-printstakemodifier"))
 949             printf(" entropybit=%"PRI64d"\n", hashSig.Get64());
 950         return hashSig.Get64();
 951     }
 952
 953     // ppcoin: two types of block: proof-of-work or proof-of-stake
 954     bool IsProofOfStake() const
 955     {
 956         return (vtx.size() > 1 && vtx[1].IsCoinStake());
 957     }
 958
 959     bool IsProofOfWork() const
 960     {
 961         return !IsProofOfStake();
 962     }
 963
 964     std::pair<COutPoint, unsigned int> GetProofOfStake() const
 965     {
 966         return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
 967     }
 968
 969     // ppcoin: get max transaction timestamp
 970     int64 GetMaxTransactionTime() const
 971     {
 972         int64 maxTransactionTime = 0;
 973         BOOST_FOREACH(const CTransaction& tx, vtx)
 974             maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
 975         return maxTransactionTime;
 976     }
 977
 978     uint256 BuildMerkleTree() const
 979     {
 980         vMerkleTree.clear();
 981         BOOST_FOREACH(const CTransaction& tx, vtx)
 982             vMerkleTree.push_back(tx.GetHash());
 983         int j = 0;
 984         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
 985         {
 986             for (int i = 0; i < nSize; i += 2)
 987             {
 988                 int i2 = std::min(i+1, nSize-1);
 989                 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]),  END(vMerkleTree[j+i]),
 990                                            BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
 991             }
 992             j += nSize;
 993         }
 994         return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
 995     }
 996
 997     std::vector<uint256> GetMerkleBranch(int nIndex) const
 998     {
 999         if (vMerkleTree.empty())
1000             BuildMerkleTree();
1001         std::vector<uint256> vMerkleBranch;
1002         int j = 0;
1003         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1004         {
1005             int i = std::min(nIndex^1, nSize-1);
1006             vMerkleBranch.push_back(vMerkleTree[j+i]);
1007             nIndex >>= 1;
1008             j += nSize;
1009         }
1010         return vMerkleBranch;
1011     }
1012
1013     static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1014     {
1015         if (nIndex == -1)
1016             return 0;
1017         BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1018         {
1019             if (nIndex & 1)
1020                 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1021             else
1022                 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1023             nIndex >>= 1;
1024         }
1025         return hash;
1026     }
1027
1028
1029     bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1030     {
1031         // Open history file to append
1032         CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1033         if (!fileout)
1034             return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1035
1036         // Write index header
1037         unsigned int nSize = fileout.GetSerializeSize(*this);
1038         fileout << FLATDATA(pchMessageStart) << nSize;
1039
1040         // Write block
1041         long fileOutPos = ftell(fileout);
1042         if (fileOutPos < 0)
1043             return error("CBlock::WriteToDisk() : ftell failed");
1044         nBlockPosRet = fileOutPos;
1045         fileout << *this;
1046
1047         // Flush stdio buffers and commit to disk before returning
1048         fflush(fileout);
1049         if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1050             FileCommit(fileout);
1051
1052         return true;
1053     }
1054
1055     bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1056     {
1057         SetNull();
1058
1059         // Open history file to read
1060         CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1061         if (!filein)
1062             return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1063         if (!fReadTransactions)
1064             filein.nType |= SER_BLOCKHEADERONLY;
1065
1066         // Read block
1067         try {
1068             filein >> *this;
1069         }
1070         catch (std::exception &e) {
1071             return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1072         }
1073
1074         // Check the header
1075         if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1076             return error("CBlock::ReadFromDisk() : errors in block header");
1077
1078         return true;
1079     }
1080
1081
1082
1083     void print() const
1084     {
1085         printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu", vchBlockSig=%s)\n",
1086             GetHash().ToString().c_str(),
1087             nVersion,
1088             hashPrevBlock.ToString().c_str(),
1089             hashMerkleRoot.ToString().c_str(),
1090             nTime, nBits, nNonce,
1091             vtx.size(),
1092             HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1093         for (unsigned int i = 0; i < vtx.size(); i++)
1094         {
1095             printf("  ");
1096             vtx[i].print();
1097         }
1098         printf("  vMerkleTree: ");
1099         for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1100             printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1101         printf("\n");
1102     }
1103
1104
1105     bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1106     bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1107     bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1108     bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1109     bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1110     bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1111     bool AcceptBlock();
1112     bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1113     bool SignBlock(const CKeyStore& keystore);
1114     bool CheckBlockSignature(bool fProofOfStake) const;
1115
1116 private:
1117     bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1118 };
1119
1120
1121
1122
1123
1124
1125 /** The block chain is a tree shaped structure starting with the
1126  * genesis block at the root, with each block potentially having multiple
1127  * candidates to be the next block.  pprev and pnext link a path through the
1128  * main/longest chain.  A blockindex may have multiple pprev pointing back
1129  * to it, but pnext will only point forward to the longest branch, or will
1130  * be null if the block is not part of the longest chain.
1131  */
1132 class CBlockIndex
1133 {
1134 public:
1135     const uint256* phashBlock;
1136     CBlockIndex* pprev;
1137     CBlockIndex* pnext;
1138     unsigned int nFile;
1139     unsigned int nBlockPos;
1140     uint256 nChainTrust; // ppcoin: trust score of block chain
1141     int nHeight;
1142
1143     int64 nMint;
1144     int64 nMoneySupply;
1145
1146     unsigned int nFlags;  // ppcoin: block index flags
1147     enum
1148     {
1149         BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1150         BLOCK_STAKE_ENTROPY  = (1 << 1), // entropy bit for stake modifier
1151         BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1152     };
1153
1154     uint64 nStakeModifier; // hash modifier for proof-of-stake
1155     unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1156
1157     // proof-of-stake specific fields
1158     COutPoint prevoutStake;
1159     unsigned int nStakeTime;
1160     uint256 hashProofOfStake;
1161
1162     // block header
1163     int nVersion;
1164     uint256 hashMerkleRoot;
1165     unsigned int nTime;
1166     unsigned int nBits;
1167     unsigned int nNonce;
1168
1169     CBlockIndex()
1170     {
1171         phashBlock = NULL;
1172         pprev = NULL;
1173         pnext = NULL;
1174         nFile = 0;
1175         nBlockPos = 0;
1176         nHeight = 0;
1177         nChainTrust = 0;
1178         nMint = 0;
1179         nMoneySupply = 0;
1180         nFlags = 0;
1181         nStakeModifier = 0;
1182         nStakeModifierChecksum = 0;
1183         hashProofOfStake = 0;
1184         prevoutStake.SetNull();
1185         nStakeTime = 0;
1186
1187         nVersion       = 0;
1188         hashMerkleRoot = 0;
1189         nTime          = 0;
1190         nBits          = 0;
1191         nNonce         = 0;
1192     }
1193
1194     CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1195     {
1196         phashBlock = NULL;
1197         pprev = NULL;
1198         pnext = NULL;
1199         nFile = nFileIn;
1200         nBlockPos = nBlockPosIn;
1201         nHeight = 0;
1202         nChainTrust = 0;
1203         nMint = 0;
1204         nMoneySupply = 0;
1205         nFlags = 0;
1206         nStakeModifier = 0;
1207         nStakeModifierChecksum = 0;
1208         hashProofOfStake = 0;
1209         if (block.IsProofOfStake())
1210         {
1211             SetProofOfStake();
1212             prevoutStake = block.vtx[1].vin[0].prevout;
1213             nStakeTime = block.vtx[1].nTime;
1214         }
1215         else
1216         {
1217             prevoutStake.SetNull();
1218             nStakeTime = 0;
1219         }
1220
1221         nVersion       = block.nVersion;
1222         hashMerkleRoot = block.hashMerkleRoot;
1223         nTime          = block.nTime;
1224         nBits          = block.nBits;
1225         nNonce         = block.nNonce;
1226     }
1227
1228     CBlock GetBlockHeader() const
1229     {
1230         CBlock block;
1231         block.nVersion       = nVersion;
1232         if (pprev)
1233             block.hashPrevBlock = pprev->GetBlockHash();
1234         block.hashMerkleRoot = hashMerkleRoot;
1235         block.nTime          = nTime;
1236         block.nBits          = nBits;
1237         block.nNonce         = nNonce;
1238         return block;
1239     }
1240
1241     uint256 GetBlockHash() const
1242     {
1243         return *phashBlock;
1244     }
1245
1246     int64 GetBlockTime() const
1247     {
1248         return (int64)nTime;
1249     }
1250
1251     uint256 GetBlockTrust() const;
1252
1253     bool IsInMainChain() const
1254     {
1255         return (pnext || this == pindexBest);
1256     }
1257
1258     bool CheckIndex() const
1259     {
1260         return true;
1261     }
1262
1263     enum { nMedianTimeSpan=11 };
1264
1265     int64 GetMedianTimePast() const
1266     {
1267         int64 pmedian[nMedianTimeSpan];
1268         int64* pbegin = &pmedian[nMedianTimeSpan];
1269         int64* pend = &pmedian[nMedianTimeSpan];
1270
1271         const CBlockIndex* pindex = this;
1272         for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1273             *(--pbegin) = pindex->GetBlockTime();
1274
1275         std::sort(pbegin, pend);
1276         return pbegin[(pend - pbegin)/2];
1277     }
1278
1279     int64 GetMedianTime() const
1280     {
1281         const CBlockIndex* pindex = this;
1282         for (int i = 0; i < nMedianTimeSpan/2; i++)
1283         {
1284             if (!pindex->pnext)
1285                 return GetBlockTime();
1286             pindex = pindex->pnext;
1287         }
1288         return pindex->GetMedianTimePast();
1289     }
1290
1291     /**
1292      * Returns true if there are nRequired or more blocks of minVersion or above
1293      * in the last nToCheck blocks, starting at pstart and going backwards.
1294      */
1295     static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1296                                 unsigned int nRequired, unsigned int nToCheck);
1297
1298
1299     bool IsProofOfWork() const
1300     {
1301         return !(nFlags & BLOCK_PROOF_OF_STAKE);
1302     }
1303
1304     bool IsProofOfStake() const
1305     {
1306         return (nFlags & BLOCK_PROOF_OF_STAKE);
1307     }
1308
1309     void SetProofOfStake()
1310     {
1311         nFlags |= BLOCK_PROOF_OF_STAKE;
1312     }
1313
1314     unsigned int GetStakeEntropyBit() const
1315     {
1316         return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1317     }
1318
1319     bool SetStakeEntropyBit(unsigned int nEntropyBit)
1320     {
1321         if (nEntropyBit > 1)
1322             return false;
1323         nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1324         return true;
1325     }
1326
1327     bool GeneratedStakeModifier() const
1328     {
1329         return (nFlags & BLOCK_STAKE_MODIFIER);
1330     }
1331
1332     void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1333     {
1334         nStakeModifier = nModifier;
1335         if (fGeneratedStakeModifier)
1336             nFlags |= BLOCK_STAKE_MODIFIER;
1337     }
1338
1339     std::string ToString() const
1340     {
1341         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)",
1342             pprev, pnext, nFile, nBlockPos, nHeight,
1343             FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1344             GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1345             nStakeModifier, nStakeModifierChecksum,
1346             hashProofOfStake.ToString().c_str(),
1347             prevoutStake.ToString().c_str(), nStakeTime,
1348             hashMerkleRoot.ToString().c_str(),
1349             GetBlockHash().ToString().c_str());
1350     }
1351
1352     void print() const
1353     {
1354         printf("%s\n", ToString().c_str());
1355     }
1356 };
1357
1358
1359
1360 /** Used to marshal pointers into hashes for db storage. */
1361 class CDiskBlockIndex : public CBlockIndex
1362 {
1363 public:
1364     uint256 hashPrev;
1365     uint256 hashNext;
1366
1367     CDiskBlockIndex()
1368     {
1369         hashPrev = 0;
1370         hashNext = 0;
1371     }
1372
1373     explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1374     {
1375         hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1376         hashNext = (pnext ? pnext->GetBlockHash() : 0);
1377     }
1378
1379     IMPLEMENT_SERIALIZE
1380     (
1381         if (!(nType & SER_GETHASH))
1382             READWRITE(nVersion);
1383
1384         READWRITE(hashNext);
1385         READWRITE(nFile);
1386         READWRITE(nBlockPos);
1387         READWRITE(nHeight);
1388         READWRITE(nMint);
1389         READWRITE(nMoneySupply);
1390         READWRITE(nFlags);
1391         READWRITE(nStakeModifier);
1392         if (IsProofOfStake())
1393         {
1394             READWRITE(prevoutStake);
1395             READWRITE(nStakeTime);
1396             READWRITE(hashProofOfStake);
1397         }
1398         else if (fRead)
1399         {
1400             const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1401             const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1402             const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1403         }
1404
1405         // block header
1406         READWRITE(this->nVersion);
1407         READWRITE(hashPrev);
1408         READWRITE(hashMerkleRoot);
1409         READWRITE(nTime);
1410         READWRITE(nBits);
1411         READWRITE(nNonce);
1412     )
1413
1414     uint256 GetBlockHash() const
1415     {
1416         CBlock block;
1417         block.nVersion        = nVersion;
1418         block.hashPrevBlock   = hashPrev;
1419         block.hashMerkleRoot  = hashMerkleRoot;
1420         block.nTime           = nTime;
1421         block.nBits           = nBits;
1422         block.nNonce          = nNonce;
1423         return block.GetHash();
1424     }
1425
1426
1427     std::string ToString() const
1428     {
1429         std::string str = "CDiskBlockIndex(";
1430         str += CBlockIndex::ToString();
1431         str += strprintf("\n                hashBlock=%s, hashPrev=%s, hashNext=%s)",
1432             GetBlockHash().ToString().c_str(),
1433             hashPrev.ToString().c_str(),
1434             hashNext.ToString().c_str());
1435         return str;
1436     }
1437
1438     void print() const
1439     {
1440         printf("%s\n", ToString().c_str());
1441     }
1442 };
1443
1444
1445
1446
1447
1448
1449
1450
1451 /** Describes a place in the block chain to another node such that if the
1452  * other node doesn't have the same branch, it can find a recent common trunk.
1453  * The further back it is, the further before the fork it may be.
1454  */
1455 class CBlockLocator
1456 {
1457 protected:
1458     std::vector<uint256> vHave;
1459 public:
1460
1461     CBlockLocator()
1462     {
1463     }
1464
1465     explicit CBlockLocator(const CBlockIndex* pindex)
1466     {
1467         Set(pindex);
1468     }
1469
1470     explicit CBlockLocator(uint256 hashBlock)
1471     {
1472         std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1473         if (mi != mapBlockIndex.end())
1474             Set((*mi).second);
1475     }
1476
1477     CBlockLocator(const std::vector<uint256>& vHaveIn)
1478     {
1479         vHave = vHaveIn;
1480     }
1481
1482     IMPLEMENT_SERIALIZE
1483     (
1484         if (!(nType & SER_GETHASH))
1485             READWRITE(nVersion);
1486         READWRITE(vHave);
1487     )
1488
1489     void SetNull()
1490     {
1491         vHave.clear();
1492     }
1493
1494     bool IsNull()
1495     {
1496         return vHave.empty();
1497     }
1498
1499     void Set(const CBlockIndex* pindex)
1500     {
1501         vHave.clear();
1502         int nStep = 1;
1503         while (pindex)
1504         {
1505             vHave.push_back(pindex->GetBlockHash());
1506
1507             // Exponentially larger steps back
1508             for (int i = 0; pindex && i < nStep; i++)
1509                 pindex = pindex->pprev;
1510             if (vHave.size() > 10)
1511                 nStep *= 2;
1512         }
1513         vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1514     }
1515
1516     int GetDistanceBack()
1517     {
1518         // Retrace how far back it was in the sender's branch
1519         int nDistance = 0;
1520         int nStep = 1;
1521         BOOST_FOREACH(const uint256& hash, vHave)
1522         {
1523             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1524             if (mi != mapBlockIndex.end())
1525             {
1526                 CBlockIndex* pindex = (*mi).second;
1527                 if (pindex->IsInMainChain())
1528                     return nDistance;
1529             }
1530             nDistance += nStep;
1531             if (nDistance > 10)
1532                 nStep *= 2;
1533         }
1534         return nDistance;
1535     }
1536
1537     CBlockIndex* GetBlockIndex()
1538     {
1539         // Find the first block the caller has in the main chain
1540         BOOST_FOREACH(const uint256& hash, vHave)
1541         {
1542             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1543             if (mi != mapBlockIndex.end())
1544             {
1545                 CBlockIndex* pindex = (*mi).second;
1546                 if (pindex->IsInMainChain())
1547                     return pindex;
1548             }
1549         }
1550         return pindexGenesisBlock;
1551     }
1552
1553     uint256 GetBlockHash()
1554     {
1555         // Find the first block the caller has in the main chain
1556         BOOST_FOREACH(const uint256& hash, vHave)
1557         {
1558             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1559             if (mi != mapBlockIndex.end())
1560             {
1561                 CBlockIndex* pindex = (*mi).second;
1562                 if (pindex->IsInMainChain())
1563                     return hash;
1564             }
1565         }
1566         return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1567     }
1568
1569     int GetHeight()
1570     {
1571         CBlockIndex* pindex = GetBlockIndex();
1572         if (!pindex)
1573             return 0;
1574         return pindex->nHeight;
1575     }
1576 };
1577
1578
1579
1580
1581
1582
1583
1584
1585 class CTxMemPool
1586 {
1587 public:
1588     mutable CCriticalSection cs;
1589     std::map<uint256, CTransaction> mapTx;
1590     std::map<COutPoint, CInPoint> mapNextTx;
1591
1592     bool accept(CTxDB& txdb, CTransaction &tx,
1593                 bool fCheckInputs, bool* pfMissingInputs);
1594     bool addUnchecked(const uint256& hash, CTransaction &tx);
1595     bool remove(CTransaction &tx);
1596     void clear();
1597     void queryHashes(std::vector<uint256>& vtxid);
1598
1599     unsigned long size()
1600     {
1601         LOCK(cs);
1602         return mapTx.size();
1603     }
1604
1605     bool exists(uint256 hash)
1606     {
1607         return (mapTx.count(hash) != 0);
1608     }
1609
1610     CTransaction& lookup(uint256 hash)
1611     {
1612         return mapTx[hash];
1613     }
1614 };
1615
1616 extern CTxMemPool mempool;
1617
1618 #endif