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 <limits>
  18 #include <list>
  19 #include <map>
  20
  21 class CWallet;
  22 class CBlock;
  23 class CBlockIndex;
  24 class CKeyItem;
  25 class CReserveKey;
  26 class COutPoint;
  27
  28 class CAddress;
  29 class CInv;
  30 class CRequestTracker;
  31 class CNode;
  32
  33 //
  34 // Global state
  35 //
  36
  37 static const unsigned int MAX_BLOCK_SIZE = 1000000;
  38 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
  39 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
  40 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
  41 static const unsigned int MAX_INV_SZ = 50000;
  42
  43 static const int64_t MIN_TX_FEE = CENT/10;
  44 static const int64_t MIN_RELAY_TX_FEE = CENT/50;
  45
  46 static const int64_t MAX_MONEY = std::numeric_limits<int64_t>::max();
  47 static const int64_t MAX_MINT_PROOF_OF_WORK = 100 * COIN;
  48 static const int64_t MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
  49 static const int64_t MIN_TXOUT_AMOUNT = CENT/100;
  50
  51
  52 inline bool MoneyRange(int64_t nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
  53 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
  54 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov  5 00:53:20 1985 UTC
  55 // Maximum number of script-checking threads allowed
  56 static const int MAX_SCRIPTCHECK_THREADS = 16;
  57
  58 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
  59 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
  60
  61 inline int64_t PastDrift(int64_t nTime)   { return nTime - 2 * nOneHour; } // up to 2 hours from the past
  62 inline int64_t FutureDrift(int64_t nTime) { return nTime + 2 * nOneHour; } // up to 2 hours from the future
  63
  64 extern CScript COINBASE_FLAGS;
  65 extern CCriticalSection cs_main;
  66 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
  67 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
  68 extern CBlockIndex* pindexGenesisBlock;
  69 extern unsigned int nNodeLifespan;
  70 extern unsigned int nStakeMinAge;
  71 extern int nCoinbaseMaturity;
  72 extern int nBestHeight;
  73 extern uint256 nBestChainTrust;
  74 extern uint256 nBestInvalidTrust;
  75 extern uint256 hashBestChain;
  76 extern CBlockIndex* pindexBest;
  77 extern unsigned int nTransactionsUpdated;
  78 extern uint64_t nLastBlockTx;
  79 extern uint64_t nLastBlockSize;
  80 extern uint32_t nLastCoinStakeSearchInterval;
  81 extern const std::string strMessageMagic;
  82 extern int64_t nTimeBestReceived;
  83 extern CCriticalSection cs_setpwalletRegistered;
  84 extern std::set<CWallet*> setpwalletRegistered;
  85 extern unsigned char pchMessageStart[4];
  86 extern std::map<uint256, CBlock*> mapOrphanBlocks;
  87
  88 // Settings
  89 extern int64_t nTransactionFee;
  90 extern int64_t nMinimumInputValue;
  91 extern bool fUseFastIndex;
  92 extern int nScriptCheckThreads;
  93 extern const uint256 entropyStore[38];
  94
  95 // Minimum disk space required - used in CheckDiskSpace()
  96 static const uint64_t nMinDiskSpace = 52428800;
  97
  98 class CReserveKey;
  99 class CTxDB;
 100 class CTxIndex;
 101 class CScriptCheck;
 102
 103 void RegisterWallet(CWallet* pwalletIn);
 104 void UnregisterWallet(CWallet* pwalletIn);
 105 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
 106 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
 107 bool CheckDiskSpace(uint64_t nAdditionalBytes=0);
 108 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
 109 FILE* AppendBlockFile(unsigned int& nFileRet);
 110
 111 void UnloadBlockIndex();
 112 bool LoadBlockIndex(bool fAllowNew=true);
 113 void PrintBlockTree();
 114 CBlockIndex* FindBlockByHeight(int nHeight);
 115 bool ProcessMessages(CNode* pfrom);
 116 bool SendMessages(CNode* pto);
 117 bool LoadExternalBlockFile(FILE* fileIn);
 118
 119 // Run an instance of the script checking thread
 120 void ThreadScriptCheck(void* parg);
 121 // Stop the script checking threads
 122 void ThreadScriptCheckQuit();
 123
 124 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
 125 unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, bool fProofOfStake);
 126 int64_t GetProofOfWorkReward(unsigned int nBits, int64_t nFees=0);
 127 int64_t GetProofOfStakeReward(int64_t nCoinAge, unsigned int nBits, int64_t nTime, bool bCoinYearOnly=false);
 128 unsigned int ComputeMinWork(unsigned int nBase, int64_t nTime);
 129 unsigned int ComputeMinStake(unsigned int nBase, int64_t nTime, unsigned int nBlockTime);
 130 int GetNumBlocksOfPeers();
 131 bool IsInitialBlockDownload();
 132 std::string GetWarnings(std::string strFor);
 133 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
 134 uint256 WantedByOrphan(const CBlock* pblockOrphan);
 135 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
 136 void ResendWalletTransactions(bool fForceResend=false);
 137
 138 bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType);
 139
 140
 141
 142
 143
 144
 145
 146 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
 147
 148 /** Position on disk for a particular transaction. */
 149 class CDiskTxPos
 150 {
 151 public:
 152     uint32_t nFile;
 153     uint32_t nBlockPos;
 154     uint32_t nTxPos;
 155
 156     CDiskTxPos()
 157     {
 158         SetNull();
 159     }
 160
 161     CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
 162     {
 163         nFile = nFileIn;
 164         nBlockPos = nBlockPosIn;
 165         nTxPos = nTxPosIn;
 166     }
 167
 168     IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
 169     void SetNull() { nFile = std::numeric_limits<uint32_t>::max(); nBlockPos = 0; nTxPos = 0; }
 170     bool IsNull() const { return (nFile == std::numeric_limits<uint32_t>::max()); }
 171
 172     friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
 173     {
 174         return (a.nFile     == b.nFile &&
 175                 a.nBlockPos == b.nBlockPos &&
 176                 a.nTxPos    == b.nTxPos);
 177     }
 178
 179     friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
 180     {
 181         return !(a == b);
 182     }
 183
 184
 185     std::string ToString() const
 186     {
 187         if (IsNull())
 188             return "null";
 189         else
 190             return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
 191     }
 192
 193     void print() const
 194     {
 195         printf("%s", ToString().c_str());
 196     }
 197 };
 198
 199
 200
 201 /** An inpoint - a combination of a transaction and an index n into its vin */
 202 class CInPoint
 203 {
 204 public:
 205     CTransaction* ptx;
 206     uint32_t n;
 207
 208     CInPoint() { SetNull(); }
 209     CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
 210     void SetNull() { ptx = NULL; n = std::numeric_limits<uint32_t>::max(); }
 211     bool IsNull() const { return (ptx == NULL && n == std::numeric_limits<uint32_t>::max()); }
 212 };
 213
 214
 215
 216 /** An outpoint - a combination of a transaction hash and an index n into its vout */
 217 class COutPoint
 218 {
 219 public:
 220     uint256 hash;
 221     uint32_t n;
 222
 223     COutPoint() { SetNull(); }
 224     COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
 225     IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
 226     void SetNull() { hash = 0; n = std::numeric_limits<uint32_t>::max(); }
 227     bool IsNull() const { return (hash == 0 && n == std::numeric_limits<uint32_t>::max()); }
 228
 229     friend bool operator<(const COutPoint& a, const COutPoint& b)
 230     {
 231         return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
 232     }
 233
 234     friend bool operator==(const COutPoint& a, const COutPoint& b)
 235     {
 236         return (a.hash == b.hash && a.n == b.n);
 237     }
 238
 239     friend bool operator!=(const COutPoint& a, const COutPoint& b)
 240     {
 241         return !(a == b);
 242     }
 243
 244     std::string ToString() const
 245     {
 246         return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
 247     }
 248
 249     void print() const
 250     {
 251         printf("%s\n", ToString().c_str());
 252     }
 253 };
 254
 255
 256
 257
 258 /** An input of a transaction.  It contains the location of the previous
 259  * transaction's output that it claims and a signature that matches the
 260  * output's public key.
 261  */
 262 class CTxIn
 263 {
 264 public:
 265     COutPoint prevout;
 266     CScript scriptSig;
 267     uint32_t nSequence;
 268
 269     CTxIn()
 270     {
 271         nSequence = std::numeric_limits<unsigned int>::max();
 272     }
 273
 274     explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
 275     {
 276         prevout = prevoutIn;
 277         scriptSig = scriptSigIn;
 278         nSequence = nSequenceIn;
 279     }
 280
 281     CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
 282     {
 283         prevout = COutPoint(hashPrevTx, nOut);
 284         scriptSig = scriptSigIn;
 285         nSequence = nSequenceIn;
 286     }
 287
 288     IMPLEMENT_SERIALIZE
 289     (
 290         READWRITE(prevout);
 291         READWRITE(scriptSig);
 292         READWRITE(nSequence);
 293     )
 294
 295     bool IsFinal() const
 296     {
 297         return (nSequence == std::numeric_limits<unsigned int>::max());
 298     }
 299
 300     friend bool operator==(const CTxIn& a, const CTxIn& b)
 301     {
 302         return (a.prevout   == b.prevout &&
 303                 a.scriptSig == b.scriptSig &&
 304                 a.nSequence == b.nSequence);
 305     }
 306
 307     friend bool operator!=(const CTxIn& a, const CTxIn& b)
 308     {
 309         return !(a == b);
 310     }
 311
 312     std::string ToStringShort() const
 313     {
 314         return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
 315     }
 316
 317     std::string ToString() const
 318     {
 319         std::string str;
 320         str += "CTxIn(";
 321         str += prevout.ToString();
 322         if (prevout.IsNull())
 323             str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
 324         else
 325             str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
 326         if (nSequence != std::numeric_limits<unsigned int>::max())
 327             str += strprintf(", nSequence=%u", nSequence);
 328         str += ")";
 329         return str;
 330     }
 331
 332     void print() const
 333     {
 334         printf("%s\n", ToString().c_str());
 335     }
 336 };
 337
 338
 339
 340
 341 /** An output of a transaction.  It contains the public key that the next input
 342  * must be able to sign with to claim it.
 343  */
 344 class CTxOut
 345 {
 346 public:
 347     int64_t nValue;
 348     CScript scriptPubKey;
 349
 350     CTxOut()
 351     {
 352         SetNull();
 353     }
 354
 355     CTxOut(int64_t nValueIn, CScript scriptPubKeyIn)
 356     {
 357         nValue = nValueIn;
 358         scriptPubKey = scriptPubKeyIn;
 359     }
 360
 361     IMPLEMENT_SERIALIZE
 362     (
 363         READWRITE(nValue);
 364         READWRITE(scriptPubKey);
 365     )
 366
 367     void SetNull()
 368     {
 369         nValue = -1;
 370         scriptPubKey.clear();
 371     }
 372
 373     bool IsNull()
 374     {
 375         return (nValue == -1);
 376     }
 377
 378     void SetEmpty()
 379     {
 380         nValue = 0;
 381         scriptPubKey.clear();
 382     }
 383
 384     bool IsEmpty() const
 385     {
 386         return (nValue == 0 && scriptPubKey.empty());
 387     }
 388
 389     uint256 GetHash() const
 390     {
 391         return SerializeHash(*this);
 392     }
 393
 394     friend bool operator==(const CTxOut& a, const CTxOut& b)
 395     {
 396         return (a.nValue       == b.nValue &&
 397                 a.scriptPubKey == b.scriptPubKey);
 398     }
 399
 400     friend bool operator!=(const CTxOut& a, const CTxOut& b)
 401     {
 402         return !(a == b);
 403     }
 404
 405     std::string ToStringShort() const
 406     {
 407         return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
 408     }
 409
 410     std::string ToString() const
 411     {
 412         if (IsEmpty()) return "CTxOut(empty)";
 413         if (scriptPubKey.size() < 6)
 414             return "CTxOut(error)";
 415         return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
 416     }
 417
 418     void print() const
 419     {
 420         printf("%s\n", ToString().c_str());
 421     }
 422 };
 423
 424
 425
 426
 427 enum GetMinFee_mode
 428 {
 429     GMF_BLOCK,
 430     GMF_RELAY,
 431     GMF_SEND
 432 };
 433
 434 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
 435
 436 /** The basic transaction that is broadcasted on the network and contained in
 437  * blocks.  A transaction can contain multiple inputs and outputs.
 438  */
 439 class CTransaction
 440 {
 441 public:
 442     static const int CURRENT_VERSION=1;
 443     int nVersion;
 444     uint32_t nTime;
 445     std::vector<CTxIn> vin;
 446     std::vector<CTxOut> vout;
 447     uint32_t nLockTime;
 448
 449     // Denial-of-service detection:
 450     mutable int nDoS;
 451     bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
 452
 453     CTransaction()
 454     {
 455         SetNull();
 456     }
 457
 458     IMPLEMENT_SERIALIZE
 459     (
 460         READWRITE(this->nVersion);
 461         nVersion = this->nVersion;
 462         READWRITE(nTime);
 463         READWRITE(vin);
 464         READWRITE(vout);
 465         READWRITE(nLockTime);
 466     )
 467
 468     void SetNull()
 469     {
 470         nVersion = CTransaction::CURRENT_VERSION;
 471         nTime = (uint32_t) GetAdjustedTime();
 472         vin.clear();
 473         vout.clear();
 474         nLockTime = 0;
 475         nDoS = 0;  // Denial-of-service prevention
 476     }
 477
 478     bool IsNull() const
 479     {
 480         return (vin.empty() && vout.empty());
 481     }
 482
 483     uint256 GetHash() const
 484     {
 485         return SerializeHash(*this);
 486     }
 487
 488     bool IsFinal(int nBlockHeight=0, int64_t nBlockTime=0) const
 489     {
 490         // Time based nLockTime implemented in 0.1.6
 491         if (nLockTime == 0)
 492             return true;
 493         if (nBlockHeight == 0)
 494             nBlockHeight = nBestHeight;
 495         if (nBlockTime == 0)
 496             nBlockTime = GetAdjustedTime();
 497         if ((int64_t)nLockTime < ((int64_t)nLockTime < LOCKTIME_THRESHOLD ? (int64_t)nBlockHeight : nBlockTime))
 498             return true;
 499         BOOST_FOREACH(const CTxIn& txin, vin)
 500             if (!txin.IsFinal())
 501                 return false;
 502         return true;
 503     }
 504
 505     bool IsNewerThan(const CTransaction& old) const
 506     {
 507         if (vin.size() != old.vin.size())
 508             return false;
 509         for (unsigned int i = 0; i < vin.size(); i++)
 510             if (vin[i].prevout != old.vin[i].prevout)
 511                 return false;
 512
 513         bool fNewer = false;
 514         unsigned int nLowest = std::numeric_limits<unsigned int>::max();
 515         for (unsigned int i = 0; i < vin.size(); i++)
 516         {
 517             if (vin[i].nSequence != old.vin[i].nSequence)
 518             {
 519                 if (vin[i].nSequence <= nLowest)
 520                 {
 521                     fNewer = false;
 522                     nLowest = vin[i].nSequence;
 523                 }
 524                 if (old.vin[i].nSequence < nLowest)
 525                 {
 526                     fNewer = true;
 527                     nLowest = old.vin[i].nSequence;
 528                 }
 529             }
 530         }
 531         return fNewer;
 532     }
 533
 534     bool IsCoinBase() const
 535     {
 536         return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
 537     }
 538
 539     bool IsCoinStake() const
 540     {
 541         // ppcoin: the coin stake transaction is marked with the first output empty
 542         return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
 543     }
 544
 545     /** Check for standard transaction types
 546         @return True if all outputs (scriptPubKeys) use only standard transaction forms
 547     */
 548     bool IsStandard(std::string& strReason) const;
 549     bool IsStandard() const
 550     {
 551         std::string strReason;
 552         return IsStandard(strReason);
 553     }
 554
 555     /** Check for standard transaction types
 556         @param[in] mapInputs    Map of previous transactions that have outputs we're spending
 557         @return True if all inputs (scriptSigs) use only standard transaction forms
 558         @see CTransaction::FetchInputs
 559     */
 560     bool AreInputsStandard(const MapPrevTx& mapInputs) const;
 561
 562     /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
 563         @return number of sigops this transaction's outputs will produce when spent
 564         @see CTransaction::FetchInputs
 565     */
 566     unsigned int GetLegacySigOpCount() const;
 567
 568     /** Count ECDSA signature operations in pay-to-script-hash inputs.
 569
 570         @param[in] mapInputs    Map of previous transactions that have outputs we're spending
 571         @return maximum number of sigops required to validate this transaction's inputs
 572         @see CTransaction::FetchInputs
 573      */
 574     unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
 575
 576     /** Amount of bitcoins spent by this transaction.
 577         @return sum of all outputs (note: does not include fees)
 578      */
 579     int64_t GetValueOut() const
 580     {
 581         int64_t nValueOut = 0;
 582         BOOST_FOREACH(const CTxOut& txout, vout)
 583         {
 584             nValueOut += txout.nValue;
 585             if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
 586                 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
 587         }
 588         return nValueOut;
 589     }
 590
 591     /** Amount of bitcoins coming in to this transaction
 592         Note that lightweight clients may not know anything besides the hash of previous transactions,
 593         so may not be able to calculate this.
 594
 595         @param[in] mapInputs    Map of previous transactions that have outputs we're spending
 596         @return Sum of value of all inputs (scriptSigs)
 597         @see CTransaction::FetchInputs
 598      */
 599     int64_t GetValueIn(const MapPrevTx& mapInputs) const;
 600
 601     static bool AllowFree(double dPriority)
 602     {
 603         // Large (in bytes) low-priority (new, small-coin) transactions
 604         // need a fee.
 605         return dPriority > COIN * 144 / 250;
 606     }
 607
 608     int64_t GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK, unsigned int nBytes = 0) const;
 609
 610     bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
 611     {
 612         CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
 613         if (!filein)
 614             return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
 615
 616         // Read transaction
 617         if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
 618             return error("CTransaction::ReadFromDisk() : fseek failed");
 619
 620         try {
 621             filein >> *this;
 622         }
 623         catch (std::exception &e) {
 624             (void)e;
 625             return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
 626         }
 627
 628         // Return file pointer
 629         if (pfileRet)
 630         {
 631             if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
 632                 return error("CTransaction::ReadFromDisk() : second fseek failed");
 633             *pfileRet = filein.release();
 634         }
 635         return true;
 636     }
 637
 638     friend bool operator==(const CTransaction& a, const CTransaction& b)
 639     {
 640         return (a.nVersion  == b.nVersion &&
 641                 a.nTime     == b.nTime &&
 642                 a.vin       == b.vin &&
 643                 a.vout      == b.vout &&
 644                 a.nLockTime == b.nLockTime);
 645     }
 646
 647     friend bool operator!=(const CTransaction& a, const CTransaction& b)
 648     {
 649         return !(a == b);
 650     }
 651
 652     std::string ToStringShort() const
 653     {
 654         std::string str;
 655         str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
 656         return str;
 657     }
 658
 659     std::string ToString() const
 660     {
 661         std::string str;
 662         str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
 663         str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%" PRIszu ", vout.size=%" PRIszu ", nLockTime=%d)\n",
 664             GetHash().ToString().substr(0,10).c_str(),
 665             nTime,
 666             nVersion,
 667             vin.size(),
 668             vout.size(),
 669             nLockTime);
 670         for (unsigned int i = 0; i < vin.size(); i++)
 671             str += "    " + vin[i].ToString() + "\n";
 672         for (unsigned int i = 0; i < vout.size(); i++)
 673             str += "    " + vout[i].ToString() + "\n";
 674         return str;
 675     }
 676
 677     void print() const
 678     {
 679         printf("%s", ToString().c_str());
 680     }
 681
 682
 683     bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
 684     bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
 685     bool ReadFromDisk(COutPoint prevout);
 686     bool DisconnectInputs(CTxDB& txdb);
 687
 688     /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
 689
 690      @param[in] txdb    Transaction database
 691      @param[in] mapTestPool     List of pending changes to the transaction index database
 692      @param[in] fBlock  True if being called to add a new best-block to the chain
 693      @param[in] fMiner  True if being called by CreateNewBlock
 694      @param[out] inputsRet      Pointers to this transaction's inputs
 695      @param[out] fInvalid       returns true if transaction is invalid
 696      @return    Returns true if all inputs are in txdb or mapTestPool
 697      */
 698     bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
 699                      bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
 700
 701     /** Sanity check previous transactions, then, if all checks succeed,
 702         mark them as spent by this transaction.
 703
 704         @param[in] inputs       Previous transactions (from FetchInputs)
 705         @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
 706         @param[in] posThisTx    Position of this transaction on disk
 707         @param[in] pindexBlock
 708         @param[in] fBlock       true if called from ConnectBlock
 709         @param[in] fMiner       true if called from CreateNewBlock
 710         @param[in] fScriptChecks        enable scripts validation?
 711         @param[in] flags        STRICT_FLAGS script validation flags
 712         @param[in] pvChecks     NULL If pvChecks is not NULL, script checks are pushed onto it instead of being performed inline.
 713         @return Returns true if all checks succeed
 714      */
 715     bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs, std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx, const CBlockIndex* pindexBlock,
 716                      bool fBlock, bool fMiner, bool fScriptChecks=true,
 717                      unsigned int flags=STRICT_FLAGS, std::vector<CScriptCheck> *pvChecks = NULL);
 718     bool ClientConnectInputs();
 719     bool CheckTransaction() const;
 720     bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
 721     bool GetCoinAge(CTxDB& txdb, uint64_t& nCoinAge) const;  // ppcoin: get transaction coin age
 722
 723 protected:
 724     const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
 725 };
 726
 727 /** Closure representing one script verification
 728  *  Note that this stores references to the spending transaction */
 729 class CScriptCheck
 730 {
 731 private:
 732     CScript scriptPubKey;
 733     const CTransaction *ptxTo;
 734     unsigned int nIn;
 735     unsigned int nFlags;
 736     int nHashType;
 737
 738 public:
 739     CScriptCheck() {}
 740     CScriptCheck(const CTransaction& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, int nHashTypeIn) :
 741         scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey),
 742         ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), nHashType(nHashTypeIn) { }
 743
 744     bool operator()() const;
 745
 746     void swap(CScriptCheck &check) {
 747         scriptPubKey.swap(check.scriptPubKey);
 748         std::swap(ptxTo, check.ptxTo);
 749         std::swap(nIn, check.nIn);
 750         std::swap(nFlags, check.nFlags);
 751         std::swap(nHashType, check.nHashType);
 752     }
 753 };
 754
 755
 756
 757
 758 /** A transaction with a merkle branch linking it to the block chain. */
 759 class CMerkleTx : public CTransaction
 760 {
 761 public:
 762     uint256 hashBlock;
 763     std::vector<uint256> vMerkleBranch;
 764     int32_t nIndex;
 765
 766     // memory only
 767     mutable bool fMerkleVerified;
 768
 769
 770     CMerkleTx()
 771     {
 772         Init();
 773     }
 774
 775     CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
 776     {
 777         Init();
 778     }
 779
 780     void Init()
 781     {
 782         hashBlock = 0;
 783         nIndex = -1;
 784         fMerkleVerified = false;
 785     }
 786
 787
 788     IMPLEMENT_SERIALIZE
 789     (
 790         nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
 791         nVersion = this->nVersion;
 792         READWRITE(hashBlock);
 793         READWRITE(vMerkleBranch);
 794         READWRITE(nIndex);
 795     )
 796
 797
 798     int SetMerkleBranch(const CBlock* pblock=NULL);
 799     int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
 800     int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
 801     bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
 802     int GetBlocksToMaturity() const;
 803     bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
 804     bool AcceptToMemoryPool();
 805 };
 806
 807
 808
 809
 810 /**  A txdb record that contains the disk location of a transaction and the
 811  * locations of transactions that spend its outputs.  vSpent is really only
 812  * used as a flag, but having the location is very helpful for debugging.
 813  */
 814 class CTxIndex
 815 {
 816 public:
 817     CDiskTxPos pos;
 818     std::vector<CDiskTxPos> vSpent;
 819
 820     CTxIndex()
 821     {
 822         SetNull();
 823     }
 824
 825     CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
 826     {
 827         pos = posIn;
 828         vSpent.resize(nOutputs);
 829     }
 830
 831     IMPLEMENT_SERIALIZE
 832     (
 833         if (!(nType & SER_GETHASH))
 834             READWRITE(nVersion);
 835         READWRITE(pos);
 836         READWRITE(vSpent);
 837     )
 838
 839     void SetNull()
 840     {
 841         pos.SetNull();
 842         vSpent.clear();
 843     }
 844
 845     bool IsNull()
 846     {
 847         return pos.IsNull();
 848     }
 849
 850     friend bool operator==(const CTxIndex& a, const CTxIndex& b)
 851     {
 852         return (a.pos    == b.pos &&
 853                 a.vSpent == b.vSpent);
 854     }
 855
 856     friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
 857     {
 858         return !(a == b);
 859     }
 860     int GetDepthInMainChain() const;
 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     int32_t nVersion;
 881     uint256 hashPrevBlock;
 882     uint256 hashMerkleRoot;
 883     uint32_t nTime;
 884     uint32_t nBits;
 885     uint32_t 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((const uint8_t*)&nVersion);
 950     }
 951
 952     int64_t GetBlockTime() const
 953     {
 954         return (int64_t)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 nHeight) const
 961     {
 962         // Protocol switch to support p2pool at novacoin block #9689
 963         if (nHeight >= 9689 || fTestNet)
 964         {
 965             // Take last bit of block hash as entropy bit
 966             unsigned int nEntropyBit = (GetHash().Get64()) & (uint64_t)1;
 967             if (fDebug && GetBoolArg("-printstakemodifier"))
 968                 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
 969             return nEntropyBit;
 970         }
 971
 972         // Before novacoin block #9689 - get from pregenerated table
 973         int nBitNum = nHeight & 0xFF;
 974         int nItemNum = nHeight / 0xFF;
 975
 976         unsigned int nEntropyBit = (unsigned int) ((entropyStore[nItemNum] & (uint256(1) << nBitNum)) >> nBitNum).Get64();
 977         if (fDebug && GetBoolArg("-printstakemodifier"))
 978             printf("GetStakeEntropyBit: from pregenerated table, nHeight=%d nEntropyBit=%u\n", nHeight, nEntropyBit);
 979         return nEntropyBit;
 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_t GetMaxTransactionTime() const
1000     {
1001         int64_t maxTransactionTime = 0;
1002         BOOST_FOREACH(const CTransaction& tx, vtx)
1003             maxTransactionTime = std::max(maxTransactionTime, (int64_t)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 = (int)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 = (int)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             (void)e;
1101             return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
1102         }
1103
1104         // Check the header
1105         if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1106             return error("CBlock::ReadFromDisk() : errors in block header");
1107
1108         return true;
1109     }
1110
1111
1112
1113     void print() const
1114     {
1115         printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%" PRIszu ", vchBlockSig=%s)\n",
1116             GetHash().ToString().c_str(),
1117             nVersion,
1118             hashPrevBlock.ToString().c_str(),
1119             hashMerkleRoot.ToString().c_str(),
1120             nTime, nBits, nNonce,
1121             vtx.size(),
1122             HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1123         for (unsigned int i = 0; i < vtx.size(); i++)
1124         {
1125             printf("  ");
1126             vtx[i].print();
1127         }
1128         printf("  vMerkleTree: ");
1129         for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1130             printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1131         printf("\n");
1132     }
1133
1134
1135     bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1136     bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1137     bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1138     bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1139     bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1140     bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1141     bool AcceptBlock();
1142     bool GetCoinAge(uint64_t& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1143     bool CheckBlockSignature() 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     uint32_t nFile;
1168     uint32_t nBlockPos;
1169     uint256 nChainTrust; // ppcoin: trust score of block chain
1170     int32_t nHeight;
1171
1172     int64_t nMint;
1173     int64_t nMoneySupply;
1174
1175     uint32_t 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_t nStakeModifier; // hash modifier for proof-of-stake
1184     uint32_t nStakeModifierChecksum; // checksum of index; in-memeory only
1185
1186     // proof-of-stake specific fields
1187     COutPoint prevoutStake;
1188     uint32_t nStakeTime;
1189     uint256 hashProofOfStake;
1190
1191     // block header
1192     int32_t  nVersion;
1193     uint256  hashMerkleRoot;
1194     uint32_t nTime;
1195     uint32_t nBits;
1196     uint32_t 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_t GetBlockTime() const
1276     {
1277         return (int64_t)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_t GetMedianTimePast() const
1295     {
1296         int64_t pmedian[nMedianTimeSpan];
1297         int64_t* pbegin = &pmedian[nMedianTimeSpan];
1298         int64_t* 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_t 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) != 0;
1359     }
1360
1361     void SetStakeModifier(uint64_t 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" PRIx64 ", nStakeModifierChecksum=%08x, hashProofOfStake=%s, prevoutStake=(%s), nStakeTime=%d merkle=%s, hashBlock=%s)",
1371             (const void*)pprev, (const void*)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() - nOneDay) && 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     size_t 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