src/main.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2012 The Bitcoin developers
   3 // Distributed under the MIT/X11 software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5 #ifndef BITCOIN_MAIN_H
   6 #define BITCOIN_MAIN_H
   7
   8 #include "bignum.h"
   9 #include "sync.h"
  10 #include "net.h"
  11 #include "script.h"
  12 #include "scrypt.h"
  13 #include "zerocoin/Zerocoin.h"
  14
  15 #include <list>
  16
  17 class CWallet;
  18 class CBlock;
  19 class CBlockIndex;
  20 class CKeyItem;
  21 class CReserveKey;
  22 class COutPoint;
  23
  24 class CAddress;
  25 class CInv;
  26 class CRequestTracker;
  27 class CNode;
  28
  29 static const unsigned int MAX_BLOCK_SIZE = 1000000;
  30 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
  31 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
  32 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
  33 static const unsigned int MAX_INV_SZ = 50000;
  34 static const int64 MIN_TX_FEE = CENT;
  35 static const int64 MIN_RELAY_TX_FEE = CENT;
  36 static const int64 MAX_MONEY = 2000000000 * COIN;
  37 static const int64 MAX_MINT_PROOF_OF_WORK = 100 * COIN;
  38 static const int64 MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
  39 static const int64 MIN_TXOUT_AMOUNT = MIN_TX_FEE;
  40
  41 static const unsigned int ENTROPY_SWITCH_TIME = 1362791041; // Sat, 09 Mar 2013 01:04:01 GMT
  42 static const unsigned int STAKE_SWITCH_TIME = 1371686400; // Thu, 20 Jun 2013 00:00:00 GMT
  43 static const unsigned int TARGETS_SWITCH_TIME = 1374278400; // Sat, 20 Jul 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 OUTPUT_SWITCH_TIME = 1398916800; // Thu, 01 May 2014 04: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 inline int64 PastDrift(int64 nTime)   { return nTime - 2 * 60 * 60; } // up to 2 hours from the past
  63 inline int64 FutureDrift(int64 nTime) { return nTime + 2 * 60 * 60; } // up to 2 hours from the future
  64
  65 extern libzerocoin::Params* ZCParams;
  66 extern CScript COINBASE_FLAGS;
  67 extern CCriticalSection cs_main;
  68 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
  69 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
  70 extern CBlockIndex* pindexGenesisBlock;
  71 extern unsigned int nStakeMinAge;
  72 extern unsigned int nNodeLifespan;
  73 extern int nCoinbaseMaturity;
  74 extern int nBestHeight;
  75 extern uint256 nBestChainTrust;
  76 extern uint256 nBestInvalidTrust;
  77 extern uint256 hashBestChain;
  78 extern CBlockIndex* pindexBest;
  79 extern unsigned int nTransactionsUpdated;
  80 extern uint64 nLastBlockTx;
  81 extern uint64 nLastBlockSize;
  82 extern int64 nLastCoinStakeSearchInterval;
  83 extern const std::string strMessageMagic;
  84 extern int64 nTimeBestReceived;
  85 extern CCriticalSection cs_setpwalletRegistered;
  86 extern std::set<CWallet*> setpwalletRegistered;
  87 extern unsigned char pchMessageStart[4];
  88 extern std::map<uint256, CBlock*> mapOrphanBlocks;
  89
  90 // Settings
  91 extern int64 nTransactionFee;
  92 extern int64 nMinimumInputValue;
  93 extern bool fUseFastIndex;
  94 extern unsigned int nDerivationMethodIndex;
  95
  96 // Minimum disk space required - used in CheckDiskSpace()
  97 static const uint64 nMinDiskSpace = 52428800;
  98
  99 class CReserveKey;
 100 class CTxDB;
 101 class CTxIndex;
 102
 103 void RegisterWallet(CWallet* pwalletIn);
 104 void UnregisterWallet(CWallet* pwalletIn);
 105 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
 106 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
 107 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
 108 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
 109 FILE* AppendBlockFile(unsigned int& nFileRet);
 110 bool LoadBlockIndex(bool fAllowNew=true);
 111 void PrintBlockTree();
 112 CBlockIndex* FindBlockByHeight(int nHeight);
 113 bool ProcessMessages(CNode* pfrom);
 114 bool SendMessages(CNode* pto, bool fSendTrickle);
 115 bool LoadExternalBlockFile(FILE* fileIn);
 116
 117 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
 118 unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, bool fProofOfStake);
 119 int64 GetProofOfWorkReward(unsigned int nBits);
 120 int64 GetProofOfStakeReward(int64 nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly=false);
 121 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
 122 unsigned int ComputeMinStake(unsigned int nBase, int64 nTime, unsigned int nBlockTime);
 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 StakeMiner(CWallet *pwallet);
 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, unsigned int nBytes = 0) 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         return scrypt_blockhash(CVOIDBEGIN(nVersion));
 913     }
 914
 915     int64 GetBlockTime() const
 916     {
 917         return (int64)nTime;
 918     }
 919
 920     void UpdateTime(const CBlockIndex* pindexPrev);
 921
 922     // ppcoin: entropy bit for stake modifier if chosen by modifier
 923     unsigned int GetStakeEntropyBit(unsigned int nTime) const
 924     {
 925         // Protocol switch to support p2pool at novacoin block #9689
 926         if (nTime >= ENTROPY_SWITCH_TIME || fTestNet)
 927         {
 928             // Take last bit of block hash as entropy bit
 929             unsigned int nEntropyBit = ((GetHash().Get64()) & 1llu);
 930             if (fDebug && GetBoolArg("-printstakemodifier"))
 931                 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
 932             return nEntropyBit;
 933         }
 934         // Before novacoin block #9689 - old protocol
 935         uint160 hashSig = Hash160(vchBlockSig);
 936         if (fDebug && GetBoolArg("-printstakemodifier"))
 937             printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
 938         hashSig >>= 159; // take the first bit of the hash
 939         if (fDebug && GetBoolArg("-printstakemodifier"))
 940             printf(" entropybit=%"PRI64d"\n", hashSig.Get64());
 941         return hashSig.Get64();
 942     }
 943
 944     // ppcoin: two types of block: proof-of-work or proof-of-stake
 945     bool IsProofOfStake() const
 946     {
 947         return (vtx.size() > 1 && vtx[1].IsCoinStake());
 948     }
 949
 950     bool IsProofOfWork() const
 951     {
 952         return !IsProofOfStake();
 953     }
 954
 955     std::pair<COutPoint, unsigned int> GetProofOfStake() const
 956     {
 957         return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
 958     }
 959
 960     // ppcoin: get max transaction timestamp
 961     int64 GetMaxTransactionTime() const
 962     {
 963         int64 maxTransactionTime = 0;
 964         BOOST_FOREACH(const CTransaction& tx, vtx)
 965             maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
 966         return maxTransactionTime;
 967     }
 968
 969     uint256 BuildMerkleTree() const
 970     {
 971         vMerkleTree.clear();
 972         BOOST_FOREACH(const CTransaction& tx, vtx)
 973             vMerkleTree.push_back(tx.GetHash());
 974         int j = 0;
 975         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
 976         {
 977             for (int i = 0; i < nSize; i += 2)
 978             {
 979                 int i2 = std::min(i+1, nSize-1);
 980                 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]),  END(vMerkleTree[j+i]),
 981                                            BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
 982             }
 983             j += nSize;
 984         }
 985         return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
 986     }
 987
 988     std::vector<uint256> GetMerkleBranch(int nIndex) const
 989     {
 990         if (vMerkleTree.empty())
 991             BuildMerkleTree();
 992         std::vector<uint256> vMerkleBranch;
 993         int j = 0;
 994         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
 995         {
 996             int i = std::min(nIndex^1, nSize-1);
 997             vMerkleBranch.push_back(vMerkleTree[j+i]);
 998             nIndex >>= 1;
 999             j += nSize;
1000         }
1001         return vMerkleBranch;
1002     }
1003
1004     static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1005     {
1006         if (nIndex == -1)
1007             return 0;
1008         BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1009         {
1010             if (nIndex & 1)
1011                 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1012             else
1013                 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1014             nIndex >>= 1;
1015         }
1016         return hash;
1017     }
1018
1019
1020     bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1021     {
1022         // Open history file to append
1023         CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1024         if (!fileout)
1025             return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1026
1027         // Write index header
1028         unsigned int nSize = fileout.GetSerializeSize(*this);
1029         fileout << FLATDATA(pchMessageStart) << nSize;
1030
1031         // Write block
1032         long fileOutPos = ftell(fileout);
1033         if (fileOutPos < 0)
1034             return error("CBlock::WriteToDisk() : ftell failed");
1035         nBlockPosRet = fileOutPos;
1036         fileout << *this;
1037
1038         // Flush stdio buffers and commit to disk before returning
1039         fflush(fileout);
1040         if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1041             FileCommit(fileout);
1042
1043         return true;
1044     }
1045
1046     bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1047     {
1048         SetNull();
1049
1050         // Open history file to read
1051         CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1052         if (!filein)
1053             return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1054         if (!fReadTransactions)
1055             filein.nType |= SER_BLOCKHEADERONLY;
1056
1057         // Read block
1058         try {
1059             filein >> *this;
1060         }
1061         catch (std::exception &e) {
1062             return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1063         }
1064
1065         // Check the header
1066         if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1067             return error("CBlock::ReadFromDisk() : errors in block header");
1068
1069         return true;
1070     }
1071
1072
1073
1074     void print() const
1075     {
1076         printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu", vchBlockSig=%s)\n",
1077             GetHash().ToString().c_str(),
1078             nVersion,
1079             hashPrevBlock.ToString().c_str(),
1080             hashMerkleRoot.ToString().c_str(),
1081             nTime, nBits, nNonce,
1082             vtx.size(),
1083             HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1084         for (unsigned int i = 0; i < vtx.size(); i++)
1085         {
1086             printf("  ");
1087             vtx[i].print();
1088         }
1089         printf("  vMerkleTree: ");
1090         for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1091             printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1092         printf("\n");
1093     }
1094
1095
1096     bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1097     bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1098     bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1099     bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1100     bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1101     bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1102     bool AcceptBlock();
1103     bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1104     bool SignBlock(CWallet& keystore);
1105     bool CheckBlockSignature(bool fProofOfStake) const;
1106
1107 private:
1108     bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1109 };
1110
1111
1112
1113
1114
1115
1116 /** The block chain is a tree shaped structure starting with the
1117  * genesis block at the root, with each block potentially having multiple
1118  * candidates to be the next block.  pprev and pnext link a path through the
1119  * main/longest chain.  A blockindex may have multiple pprev pointing back
1120  * to it, but pnext will only point forward to the longest branch, or will
1121  * be null if the block is not part of the longest chain.
1122  */
1123 class CBlockIndex
1124 {
1125 public:
1126     const uint256* phashBlock;
1127     CBlockIndex* pprev;
1128     CBlockIndex* pnext;
1129     unsigned int nFile;
1130     unsigned int nBlockPos;
1131     uint256 nChainTrust; // ppcoin: trust score of block chain
1132     int nHeight;
1133
1134     int64 nMint;
1135     int64 nMoneySupply;
1136
1137     unsigned int nFlags;  // ppcoin: block index flags
1138     enum
1139     {
1140         BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1141         BLOCK_STAKE_ENTROPY  = (1 << 1), // entropy bit for stake modifier
1142         BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1143     };
1144
1145     uint64 nStakeModifier; // hash modifier for proof-of-stake
1146     unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1147
1148     // proof-of-stake specific fields
1149     COutPoint prevoutStake;
1150     unsigned int nStakeTime;
1151     uint256 hashProofOfStake;
1152
1153     // block header
1154     int nVersion;
1155     uint256 hashMerkleRoot;
1156     unsigned int nTime;
1157     unsigned int nBits;
1158     unsigned int nNonce;
1159
1160     CBlockIndex()
1161     {
1162         phashBlock = NULL;
1163         pprev = NULL;
1164         pnext = NULL;
1165         nFile = 0;
1166         nBlockPos = 0;
1167         nHeight = 0;
1168         nChainTrust = 0;
1169         nMint = 0;
1170         nMoneySupply = 0;
1171         nFlags = 0;
1172         nStakeModifier = 0;
1173         nStakeModifierChecksum = 0;
1174         hashProofOfStake = 0;
1175         prevoutStake.SetNull();
1176         nStakeTime = 0;
1177
1178         nVersion       = 0;
1179         hashMerkleRoot = 0;
1180         nTime          = 0;
1181         nBits          = 0;
1182         nNonce         = 0;
1183     }
1184
1185     CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1186     {
1187         phashBlock = NULL;
1188         pprev = NULL;
1189         pnext = NULL;
1190         nFile = nFileIn;
1191         nBlockPos = nBlockPosIn;
1192         nHeight = 0;
1193         nChainTrust = 0;
1194         nMint = 0;
1195         nMoneySupply = 0;
1196         nFlags = 0;
1197         nStakeModifier = 0;
1198         nStakeModifierChecksum = 0;
1199         hashProofOfStake = 0;
1200         if (block.IsProofOfStake())
1201         {
1202             SetProofOfStake();
1203             prevoutStake = block.vtx[1].vin[0].prevout;
1204             nStakeTime = block.vtx[1].nTime;
1205         }
1206         else
1207         {
1208             prevoutStake.SetNull();
1209             nStakeTime = 0;
1210         }
1211
1212         nVersion       = block.nVersion;
1213         hashMerkleRoot = block.hashMerkleRoot;
1214         nTime          = block.nTime;
1215         nBits          = block.nBits;
1216         nNonce         = block.nNonce;
1217     }
1218
1219     CBlock GetBlockHeader() const
1220     {
1221         CBlock block;
1222         block.nVersion       = nVersion;
1223         if (pprev)
1224             block.hashPrevBlock = pprev->GetBlockHash();
1225         block.hashMerkleRoot = hashMerkleRoot;
1226         block.nTime          = nTime;
1227         block.nBits          = nBits;
1228         block.nNonce         = nNonce;
1229         return block;
1230     }
1231
1232     uint256 GetBlockHash() const
1233     {
1234         return *phashBlock;
1235     }
1236
1237     int64 GetBlockTime() const
1238     {
1239         return (int64)nTime;
1240     }
1241
1242     uint256 GetBlockTrust() const;
1243
1244     bool IsInMainChain() const
1245     {
1246         return (pnext || this == pindexBest);
1247     }
1248
1249     bool CheckIndex() const
1250     {
1251         return true;
1252     }
1253
1254     enum { nMedianTimeSpan=11 };
1255
1256     int64 GetMedianTimePast() const
1257     {
1258         int64 pmedian[nMedianTimeSpan];
1259         int64* pbegin = &pmedian[nMedianTimeSpan];
1260         int64* pend = &pmedian[nMedianTimeSpan];
1261
1262         const CBlockIndex* pindex = this;
1263         for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1264             *(--pbegin) = pindex->GetBlockTime();
1265
1266         std::sort(pbegin, pend);
1267         return pbegin[(pend - pbegin)/2];
1268     }
1269
1270     int64 GetMedianTime() const
1271     {
1272         const CBlockIndex* pindex = this;
1273         for (int i = 0; i < nMedianTimeSpan/2; i++)
1274         {
1275             if (!pindex->pnext)
1276                 return GetBlockTime();
1277             pindex = pindex->pnext;
1278         }
1279         return pindex->GetMedianTimePast();
1280     }
1281
1282     /**
1283      * Returns true if there are nRequired or more blocks of minVersion or above
1284      * in the last nToCheck blocks, starting at pstart and going backwards.
1285      */
1286     static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1287                                 unsigned int nRequired, unsigned int nToCheck);
1288
1289
1290     bool IsProofOfWork() const
1291     {
1292         return !(nFlags & BLOCK_PROOF_OF_STAKE);
1293     }
1294
1295     bool IsProofOfStake() const
1296     {
1297         return (nFlags & BLOCK_PROOF_OF_STAKE);
1298     }
1299
1300     void SetProofOfStake()
1301     {
1302         nFlags |= BLOCK_PROOF_OF_STAKE;
1303     }
1304
1305     unsigned int GetStakeEntropyBit() const
1306     {
1307         return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1308     }
1309
1310     bool SetStakeEntropyBit(unsigned int nEntropyBit)
1311     {
1312         if (nEntropyBit > 1)
1313             return false;
1314         nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1315         return true;
1316     }
1317
1318     bool GeneratedStakeModifier() const
1319     {
1320         return (nFlags & BLOCK_STAKE_MODIFIER);
1321     }
1322
1323     void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1324     {
1325         nStakeModifier = nModifier;
1326         if (fGeneratedStakeModifier)
1327             nFlags |= BLOCK_STAKE_MODIFIER;
1328     }
1329
1330     std::string ToString() const
1331     {
1332         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)",
1333             pprev, pnext, nFile, nBlockPos, nHeight,
1334             FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1335             GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1336             nStakeModifier, nStakeModifierChecksum,
1337             hashProofOfStake.ToString().c_str(),
1338             prevoutStake.ToString().c_str(), nStakeTime,
1339             hashMerkleRoot.ToString().c_str(),
1340             GetBlockHash().ToString().c_str());
1341     }
1342
1343     void print() const
1344     {
1345         printf("%s\n", ToString().c_str());
1346     }
1347 };
1348
1349
1350
1351 /** Used to marshal pointers into hashes for db storage. */
1352 class CDiskBlockIndex : public CBlockIndex
1353 {
1354 private:
1355     uint256 blockHash;
1356
1357 public:
1358     uint256 hashPrev;
1359     uint256 hashNext;
1360
1361     CDiskBlockIndex()
1362     {
1363         hashPrev = 0;
1364         hashNext = 0;
1365         blockHash = 0;
1366     }
1367
1368     explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1369     {
1370         hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1371         hashNext = (pnext ? pnext->GetBlockHash() : 0);
1372     }
1373
1374     IMPLEMENT_SERIALIZE
1375     (
1376         if (!(nType & SER_GETHASH))
1377             READWRITE(nVersion);
1378
1379         READWRITE(hashNext);
1380         READWRITE(nFile);
1381         READWRITE(nBlockPos);
1382         READWRITE(nHeight);
1383         READWRITE(nMint);
1384         READWRITE(nMoneySupply);
1385         READWRITE(nFlags);
1386         READWRITE(nStakeModifier);
1387         if (IsProofOfStake())
1388         {
1389             READWRITE(prevoutStake);
1390             READWRITE(nStakeTime);
1391             READWRITE(hashProofOfStake);
1392         }
1393         else if (fRead)
1394         {
1395             const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1396             const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1397             const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1398         }
1399
1400         // block header
1401         READWRITE(this->nVersion);
1402         READWRITE(hashPrev);
1403         READWRITE(hashMerkleRoot);
1404         READWRITE(nTime);
1405         READWRITE(nBits);
1406         READWRITE(nNonce);
1407         READWRITE(blockHash);
1408     )
1409
1410     uint256 GetBlockHash() const
1411     {
1412         if (fUseFastIndex && (nTime < GetAdjustedTime() - 24 * 60 * 60) && blockHash != 0)
1413             return blockHash;
1414
1415         CBlock block;
1416         block.nVersion        = nVersion;
1417         block.hashPrevBlock   = hashPrev;
1418         block.hashMerkleRoot  = hashMerkleRoot;
1419         block.nTime           = nTime;
1420         block.nBits           = nBits;
1421         block.nNonce          = nNonce;
1422
1423         const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1424
1425         return blockHash;
1426     }
1427
1428     std::string ToString() const
1429     {
1430         std::string str = "CDiskBlockIndex(";
1431         str += CBlockIndex::ToString();
1432         str += strprintf("\n                hashBlock=%s, hashPrev=%s, hashNext=%s)",
1433             GetBlockHash().ToString().c_str(),
1434             hashPrev.ToString().c_str(),
1435             hashNext.ToString().c_str());
1436         return str;
1437     }
1438
1439     void print() const
1440     {
1441         printf("%s\n", ToString().c_str());
1442     }
1443 };
1444
1445
1446
1447
1448
1449
1450
1451
1452 /** Describes a place in the block chain to another node such that if the
1453  * other node doesn't have the same branch, it can find a recent common trunk.
1454  * The further back it is, the further before the fork it may be.
1455  */
1456 class CBlockLocator
1457 {
1458 protected:
1459     std::vector<uint256> vHave;
1460 public:
1461
1462     CBlockLocator()
1463     {
1464     }
1465
1466     explicit CBlockLocator(const CBlockIndex* pindex)
1467     {
1468         Set(pindex);
1469     }
1470
1471     explicit CBlockLocator(uint256 hashBlock)
1472     {
1473         std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1474         if (mi != mapBlockIndex.end())
1475             Set((*mi).second);
1476     }
1477
1478     CBlockLocator(const std::vector<uint256>& vHaveIn)
1479     {
1480         vHave = vHaveIn;
1481     }
1482
1483     IMPLEMENT_SERIALIZE
1484     (
1485         if (!(nType & SER_GETHASH))
1486             READWRITE(nVersion);
1487         READWRITE(vHave);
1488     )
1489
1490     void SetNull()
1491     {
1492         vHave.clear();
1493     }
1494
1495     bool IsNull()
1496     {
1497         return vHave.empty();
1498     }
1499
1500     void Set(const CBlockIndex* pindex)
1501     {
1502         vHave.clear();
1503         int nStep = 1;
1504         while (pindex)
1505         {
1506             vHave.push_back(pindex->GetBlockHash());
1507
1508             // Exponentially larger steps back
1509             for (int i = 0; pindex && i < nStep; i++)
1510                 pindex = pindex->pprev;
1511             if (vHave.size() > 10)
1512                 nStep *= 2;
1513         }
1514         vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1515     }
1516
1517     int GetDistanceBack()
1518     {
1519         // Retrace how far back it was in the sender's branch
1520         int nDistance = 0;
1521         int nStep = 1;
1522         BOOST_FOREACH(const uint256& hash, vHave)
1523         {
1524             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1525             if (mi != mapBlockIndex.end())
1526             {
1527                 CBlockIndex* pindex = (*mi).second;
1528                 if (pindex->IsInMainChain())
1529                     return nDistance;
1530             }
1531             nDistance += nStep;
1532             if (nDistance > 10)
1533                 nStep *= 2;
1534         }
1535         return nDistance;
1536     }
1537
1538     CBlockIndex* GetBlockIndex()
1539     {
1540         // Find the first block the caller has in the main chain
1541         BOOST_FOREACH(const uint256& hash, vHave)
1542         {
1543             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1544             if (mi != mapBlockIndex.end())
1545             {
1546                 CBlockIndex* pindex = (*mi).second;
1547                 if (pindex->IsInMainChain())
1548                     return pindex;
1549             }
1550         }
1551         return pindexGenesisBlock;
1552     }
1553
1554     uint256 GetBlockHash()
1555     {
1556         // Find the first block the caller has in the main chain
1557         BOOST_FOREACH(const uint256& hash, vHave)
1558         {
1559             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1560             if (mi != mapBlockIndex.end())
1561             {
1562                 CBlockIndex* pindex = (*mi).second;
1563                 if (pindex->IsInMainChain())
1564                     return hash;
1565             }
1566         }
1567         return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1568     }
1569
1570     int GetHeight()
1571     {
1572         CBlockIndex* pindex = GetBlockIndex();
1573         if (!pindex)
1574             return 0;
1575         return pindex->nHeight;
1576     }
1577 };
1578
1579
1580
1581
1582
1583
1584
1585
1586 class CTxMemPool
1587 {
1588 public:
1589     mutable CCriticalSection cs;
1590     std::map<uint256, CTransaction> mapTx;
1591     std::map<COutPoint, CInPoint> mapNextTx;
1592
1593     bool accept(CTxDB& txdb, CTransaction &tx,
1594                 bool fCheckInputs, bool* pfMissingInputs);
1595     bool addUnchecked(const uint256& hash, CTransaction &tx);
1596     bool remove(CTransaction &tx);
1597     void clear();
1598     void queryHashes(std::vector<uint256>& vtxid);
1599
1600     unsigned long size()
1601     {
1602         LOCK(cs);
1603         return mapTx.size();
1604     }
1605
1606     bool exists(uint256 hash)
1607     {
1608         return (mapTx.count(hash) != 0);
1609     }
1610
1611     CTransaction& lookup(uint256 hash)
1612     {
1613         return mapTx[hash];
1614     }
1615 };
1616
1617 extern CTxMemPool mempool;
1618
1619 #endif