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