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