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