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