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