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