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