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