src/main.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2012 The Bitcoin developers
   3 // Distributed under the MIT/X11 software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5 #ifndef BITCOIN_MAIN_H
   6 #define BITCOIN_MAIN_H
   7
   8 #include <algorithm>
   9
  10 #include "timestamps.h"
  11 #include "bignum.h"
  12 #include "sync.h"
  13 #include "net.h"
  14 #include "script.h"
  15 #include "scrypt.h"
  16
  17 #include <list>
  18 #include <map>
  19
  20 class CWallet;
  21 class CBlock;
  22 class CBlockIndex;
  23 class CKeyItem;
  24 class CReserveKey;
  25 class COutPoint;
  26
  27 class CAddress;
  28 class CInv;
  29 class CRequestTracker;
  30 class CNode;
  31
  32 //
  33 // Global state
  34 //
  35
  36 static const unsigned int MAX_BLOCK_SIZE = 1000000;
  37 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
  38 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
  39 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
  40 static const unsigned int MAX_INV_SZ = 50000;
  41
  42 static const int64_t MIN_TX_FEE = CENT/10;
  43 static const int64_t MIN_RELAY_TX_FEE = CENT/50;
  44
  45 static const int64_t MAX_MONEY = 2000000000 * COIN;
  46 static const int64_t MAX_MINT_PROOF_OF_WORK = 100 * COIN;
  47 static const int64_t MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
  48 static const int64_t MIN_TXOUT_AMOUNT = CENT/100;
  49
  50 inline bool MoneyRange(int64_t nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
  51 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
  52 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov  5 00:53:20 1985 UTC
  53 // Maximum number of script-checking threads allowed
  54 static const int MAX_SCRIPTCHECK_THREADS = 16;
  55
  56 #ifdef USE_UPNP
  57 static const int fHaveUPnP = true;
  58 #else
  59 static const int fHaveUPnP = false;
  60 #endif
  61
  62 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
  63 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
  64
  65 inline int64_t PastDrift(int64_t nTime)   { return nTime - 2 * 60 * 60; } // up to 2 hours from the past
  66 inline int64_t FutureDrift(int64_t nTime) { return nTime + 2 * 60 * 60; } // up to 2 hours from the future
  67
  68 extern CScript COINBASE_FLAGS;
  69 extern CCriticalSection cs_main;
  70 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
  71 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
  72 extern CBlockIndex* pindexGenesisBlock;
  73 extern unsigned int nNodeLifespan;
  74 extern unsigned int nStakeMinAge;
  75 extern int nCoinbaseMaturity;
  76 extern int nBestHeight;
  77 extern uint256 nBestChainTrust;
  78 extern uint256 nBestInvalidTrust;
  79 extern uint256 hashBestChain;
  80 extern CBlockIndex* pindexBest;
  81 extern unsigned int nTransactionsUpdated;
  82 extern uint64_t nLastBlockTx;
  83 extern uint64_t nLastBlockSize;
  84 extern uint32_t nLastCoinStakeSearchInterval;
  85 extern const std::string strMessageMagic;
  86 extern int64_t nTimeBestReceived;
  87 extern CCriticalSection cs_setpwalletRegistered;
  88 extern std::set<CWallet*> setpwalletRegistered;
  89 extern unsigned char pchMessageStart[4];
  90 extern std::map<uint256, CBlock*> mapOrphanBlocks;
  91
  92 // Settings
  93 extern int64_t nTransactionFee;
  94 extern int64_t nMinimumInputValue;
  95 extern bool fUseFastIndex;
  96 extern unsigned int nDerivationMethodIndex;
  97 extern int nScriptCheckThreads;
  98 extern const uint256 entropyStore[38];
  99
 100 // Minimum disk space required - used in CheckDiskSpace()
 101 static const uint64_t nMinDiskSpace = 52428800;
 102
 103 class CReserveKey;
 104 class CTxDB;
 105 class CTxIndex;
 106 class CScriptCheck;
 107
 108 void RegisterWallet(CWallet* pwalletIn);
 109 void UnregisterWallet(CWallet* pwalletIn);
 110 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
 111 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
 112 bool CheckDiskSpace(uint64_t nAdditionalBytes=0);
 113 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
 114 FILE* AppendBlockFile(unsigned int& nFileRet);
 115 bool LoadBlockIndex(bool fAllowNew=true);
 116 void PrintBlockTree();
 117 CBlockIndex* FindBlockByHeight(int nHeight);
 118 bool ProcessMessages(CNode* pfrom);
 119 bool SendMessages(CNode* pto, bool fSendTrickle);
 120 bool LoadExternalBlockFile(FILE* fileIn);
 121
 122 // Run an instance of the script checking thread
 123 void ThreadScriptCheck(void* parg);
 124 // Stop the script checking threads
 125 void ThreadScriptCheckQuit();
 126
 127 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
 128 unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, bool fProofOfStake);
 129 int64_t GetProofOfWorkReward(unsigned int nBits, int64_t nFees=0);
 130 int64_t GetProofOfStakeReward(int64_t nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly=false);
 131 unsigned int ComputeMinWork(unsigned int nBase, int64_t nTime);
 132 unsigned int ComputeMinStake(unsigned int nBase, int64_t nTime, unsigned int nBlockTime);
 133 int GetNumBlocksOfPeers();
 134 bool IsInitialBlockDownload();
 135 std::string GetWarnings(std::string strFor);
 136 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
 137 uint256 WantedByOrphan(const CBlock* pblockOrphan);
 138 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
 139 void StakeMiner(CWallet *pwallet);
 140 void ResendWalletTransactions();
 141
 142 bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType);
 143
 144
 145
 146
 147
 148
 149
 150 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
 151
 152 /** Position on disk for a particular transaction. */
 153 class CDiskTxPos
 154 {
 155 public:
 156     uint32_t nFile;
 157     uint32_t nBlockPos;
 158     uint32_t nTxPos;
 159
 160     CDiskTxPos()
 161     {
 162         SetNull();
 163     }
 164
 165     CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
 166     {
 167         nFile = nFileIn;
 168         nBlockPos = nBlockPosIn;
 169         nTxPos = nTxPosIn;
 170     }
 171
 172     IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
 173     void SetNull() { nFile = (unsigned int) -1; nBlockPos = 0; nTxPos = 0; }
 174     bool IsNull() const { return (nFile == (unsigned int) -1); }
 175
 176     friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
 177     {
 178         return (a.nFile     == b.nFile &&
 179                 a.nBlockPos == b.nBlockPos &&
 180                 a.nTxPos    == b.nTxPos);
 181     }
 182
 183     friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
 184     {
 185         return !(a == b);
 186     }
 187
 188
 189     std::string ToString() const
 190     {
 191         if (IsNull())
 192             return "null";
 193         else
 194             return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
 195     }
 196
 197     void print() const
 198     {
 199         printf("%s", ToString().c_str());
 200     }
 201 };
 202
 203
 204
 205 /** An inpoint - a combination of a transaction and an index n into its vin */
 206 class CInPoint
 207 {
 208 public:
 209     CTransaction* ptx;
 210     uint32_t n;
 211
 212     CInPoint() { SetNull(); }
 213     CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
 214     void SetNull() { ptx = NULL; n = (unsigned int) -1; }
 215     bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
 216 };
 217
 218
 219
 220 /** An outpoint - a combination of a transaction hash and an index n into its vout */
 221 class COutPoint
 222 {
 223 public:
 224     uint256 hash;
 225     uint32_t n;
 226
 227     COutPoint() { SetNull(); }
 228     COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
 229     IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
 230     void SetNull() { hash = 0; n = (unsigned int) -1; }
 231     bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
 232
 233     friend bool operator<(const COutPoint& a, const COutPoint& b)
 234     {
 235         return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
 236     }
 237
 238     friend bool operator==(const COutPoint& a, const COutPoint& b)
 239     {
 240         return (a.hash == b.hash && a.n == b.n);
 241     }
 242
 243     friend bool operator!=(const COutPoint& a, const COutPoint& b)
 244     {
 245         return !(a == b);
 246     }
 247
 248     std::string ToString() const
 249     {
 250         return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
 251     }
 252
 253     void print() const
 254     {
 255         printf("%s\n", ToString().c_str());
 256     }
 257 };
 258
 259
 260
 261
 262 /** An input of a transaction.  It contains the location of the previous
 263  * transaction's output that it claims and a signature that matches the
 264  * output's public key.
 265  */
 266 class CTxIn
 267 {
 268 public:
 269     COutPoint prevout;
 270     CScript scriptSig;
 271     uint32_t nSequence;
 272
 273     CTxIn()
 274     {
 275         nSequence = std::numeric_limits<unsigned int>::max();
 276     }
 277
 278     explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
 279     {
 280         prevout = prevoutIn;
 281         scriptSig = scriptSigIn;
 282         nSequence = nSequenceIn;
 283     }
 284
 285     CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
 286     {
 287         prevout = COutPoint(hashPrevTx, nOut);
 288         scriptSig = scriptSigIn;
 289         nSequence = nSequenceIn;
 290     }
 291
 292     IMPLEMENT_SERIALIZE
 293     (
 294         READWRITE(prevout);
 295         READWRITE(scriptSig);
 296         READWRITE(nSequence);
 297     )
 298
 299     bool IsFinal() const
 300     {
 301         return (nSequence == std::numeric_limits<unsigned int>::max());
 302     }
 303
 304     friend bool operator==(const CTxIn& a, const CTxIn& b)
 305     {
 306         return (a.prevout   == b.prevout &&
 307                 a.scriptSig == b.scriptSig &&
 308                 a.nSequence == b.nSequence);
 309     }
 310
 311     friend bool operator!=(const CTxIn& a, const CTxIn& b)
 312     {
 313         return !(a == b);
 314     }
 315
 316     std::string ToStringShort() const
 317     {
 318         return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
 319     }
 320
 321     std::string ToString() const
 322     {
 323         std::string str;
 324         str += "CTxIn(";
 325         str += prevout.ToString();
 326         if (prevout.IsNull())
 327             str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
 328         else
 329             str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
 330         if (nSequence != std::numeric_limits<unsigned int>::max())
 331             str += strprintf(", nSequence=%u", nSequence);
 332         str += ")";
 333         return str;
 334     }
 335
 336     void print() const
 337     {
 338         printf("%s\n", ToString().c_str());
 339     }
 340 };
 341
 342
 343
 344
 345 /** An output of a transaction.  It contains the public key that the next input
 346  * must be able to sign with to claim it.
 347  */
 348 class CTxOut
 349 {
 350 public:
 351     int64_t nValue;
 352     CScript scriptPubKey;
 353
 354     CTxOut()
 355     {
 356         SetNull();
 357     }
 358
 359     CTxOut(int64_t nValueIn, CScript scriptPubKeyIn)
 360     {
 361         nValue = nValueIn;
 362         scriptPubKey = scriptPubKeyIn;
 363     }
 364
 365     IMPLEMENT_SERIALIZE
 366     (
 367         READWRITE(nValue);
 368         READWRITE(scriptPubKey);
 369     )
 370
 371     void SetNull()
 372     {
 373         nValue = -1;
 374         scriptPubKey.clear();
 375     }
 376
 377     bool IsNull()
 378     {
 379         return (nValue == -1);
 380     }
 381
 382     void SetEmpty()
 383     {
 384         nValue = 0;
 385         scriptPubKey.clear();
 386     }
 387
 388     bool IsEmpty() const
 389     {
 390         return (nValue == 0 && scriptPubKey.empty());
 391     }
 392
 393     uint256 GetHash() const
 394     {
 395         return SerializeHash(*this);
 396     }
 397
 398     friend bool operator==(const CTxOut& a, const CTxOut& b)
 399     {
 400         return (a.nValue       == b.nValue &&
 401                 a.scriptPubKey == b.scriptPubKey);
 402     }
 403
 404     friend bool operator!=(const CTxOut& a, const CTxOut& b)
 405     {
 406         return !(a == b);
 407     }
 408
 409     std::string ToStringShort() const
 410     {
 411         return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
 412     }
 413
 414     std::string ToString() const
 415     {
 416         if (IsEmpty()) return "CTxOut(empty)";
 417         if (scriptPubKey.size() < 6)
 418             return "CTxOut(error)";
 419         return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
 420     }
 421
 422     void print() const
 423     {
 424         printf("%s\n", ToString().c_str());
 425     }
 426 };
 427
 428
 429
 430
 431 enum GetMinFee_mode
 432 {
 433     GMF_BLOCK,
 434     GMF_RELAY,
 435     GMF_SEND,
 436 };
 437
 438 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
 439
 440 /** The basic transaction that is broadcasted on the network and contained in
 441  * blocks.  A transaction can contain multiple inputs and outputs.
 442  */
 443 class CTransaction
 444 {
 445 public:
 446     static const int CURRENT_VERSION=1;
 447     int nVersion;
 448     uint32_t nTime;
 449     std::vector<CTxIn> vin;
 450     std::vector<CTxOut> vout;
 451     uint32_t nLockTime;
 452
 453     // Denial-of-service detection:
 454     mutable int nDoS;
 455     bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
 456
 457     CTransaction()
 458     {
 459         SetNull();
 460     }
 461
 462     IMPLEMENT_SERIALIZE
 463     (
 464         READWRITE(this->nVersion);
 465         nVersion = this->nVersion;
 466         READWRITE(nTime);
 467         READWRITE(vin);
 468         READWRITE(vout);
 469         READWRITE(nLockTime);
 470     )
 471
 472     void SetNull()
 473     {
 474         nVersion = CTransaction::CURRENT_VERSION;
 475         nTime = (uint32_t) GetAdjustedTime();
 476         vin.clear();
 477         vout.clear();
 478         nLockTime = 0;
 479         nDoS = 0;  // Denial-of-service prevention
 480     }
 481
 482     bool IsNull() const
 483     {
 484         return (vin.empty() && vout.empty());
 485     }
 486
 487     uint256 GetHash() const
 488     {
 489         return SerializeHash(*this);
 490     }
 491
 492     bool IsFinal(int nBlockHeight=0, int64_t nBlockTime=0) const
 493     {
 494         // Time based nLockTime implemented in 0.1.6
 495         if (nLockTime == 0)
 496             return true;
 497         if (nBlockHeight == 0)
 498             nBlockHeight = nBestHeight;
 499         if (nBlockTime == 0)
 500             nBlockTime = GetAdjustedTime();
 501         if ((int64_t)nLockTime < ((int64_t)nLockTime < LOCKTIME_THRESHOLD ? (int64_t)nBlockHeight : nBlockTime))
 502             return true;
 503         BOOST_FOREACH(const CTxIn& txin, vin)
 504             if (!txin.IsFinal())
 505                 return false;
 506         return true;
 507     }
 508
 509     bool IsNewerThan(const CTransaction& old) const
 510     {
 511         if (vin.size() != old.vin.size())
 512             return false;
 513         for (unsigned int i = 0; i < vin.size(); i++)
 514             if (vin[i].prevout != old.vin[i].prevout)
 515                 return false;
 516
 517         bool fNewer = false;
 518         unsigned int nLowest = std::numeric_limits<unsigned int>::max();
 519         for (unsigned int i = 0; i < vin.size(); i++)
 520         {
 521             if (vin[i].nSequence != old.vin[i].nSequence)
 522             {
 523                 if (vin[i].nSequence <= nLowest)
 524                 {
 525                     fNewer = false;
 526                     nLowest = vin[i].nSequence;
 527                 }
 528                 if (old.vin[i].nSequence < nLowest)
 529                 {
 530                     fNewer = true;
 531                     nLowest = old.vin[i].nSequence;
 532                 }
 533             }
 534         }
 535         return fNewer;
 536     }
 537
 538     bool IsCoinBase() const
 539     {
 540         return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
 541     }
 542
 543     bool IsCoinStake() const
 544     {
 545         // ppcoin: the coin stake transaction is marked with the first output empty
 546         return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
 547     }
 548
 549     /** Check for standard transaction types
 550         @return True if all outputs (scriptPubKeys) use only standard transaction forms
 551     */
 552     bool IsStandard(std::string& strReason) const;
 553     bool IsStandard() const
 554     {
 555         std::string strReason;
 556         return IsStandard(strReason);
 557     }
 558
 559     /** Check for standard transaction types
 560         @param[in] mapInputs    Map of previous transactions that have outputs we're spending
 561         @return True if all inputs (scriptSigs) use only standard transaction forms
 562         @see CTransaction::FetchInputs
 563     */
 564     bool AreInputsStandard(const MapPrevTx& mapInputs) const;
 565
 566     /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
 567         @return number of sigops this transaction's outputs will produce when spent
 568         @see CTransaction::FetchInputs
 569     */
 570     unsigned int GetLegacySigOpCount() const;
 571
 572     /** Count ECDSA signature operations in pay-to-script-hash inputs.
 573
 574         @param[in] mapInputs    Map of previous transactions that have outputs we're spending
 575         @return maximum number of sigops required to validate this transaction's inputs
 576         @see CTransaction::FetchInputs
 577      */
 578     unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
 579
 580     /** Amount of bitcoins spent by this transaction.
 581         @return sum of all outputs (note: does not include fees)
 582      */
 583     int64_t GetValueOut() const
 584     {
 585         int64_t nValueOut = 0;
 586         BOOST_FOREACH(const CTxOut& txout, vout)
 587         {
 588             nValueOut += txout.nValue;
 589             if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
 590                 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
 591         }
 592         return nValueOut;
 593     }
 594
 595     /** Amount of bitcoins coming in to this transaction
 596         Note that lightweight clients may not know anything besides the hash of previous transactions,
 597         so may not be able to calculate this.
 598
 599         @param[in] mapInputs    Map of previous transactions that have outputs we're spending
 600         @return Sum of value of all inputs (scriptSigs)
 601         @see CTransaction::FetchInputs
 602      */
 603     int64_t GetValueIn(const MapPrevTx& mapInputs) const;
 604
 605     static bool AllowFree(double dPriority)
 606     {
 607         // Large (in bytes) low-priority (new, small-coin) transactions
 608         // need a fee.
 609         return dPriority > COIN * 144 / 250;
 610     }
 611
 612     int64_t GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK, unsigned int nBytes = 0) const;
 613
 614     bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
 615     {
 616         CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
 617         if (!filein)
 618             return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
 619
 620         // Read transaction
 621         if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
 622             return error("CTransaction::ReadFromDisk() : fseek failed");
 623
 624         try {
 625             filein >> *this;
 626         }
 627         catch (std::exception &e) {
 628             (void)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_t& 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     int32_t 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 /** Nodes collect new transactions into a block, hash them into a hash tree,
 870  * and scan through nonce values to make the block's hash satisfy proof-of-work
 871  * requirements.  When they solve the proof-of-work, they broadcast the block
 872  * to everyone and the block is added to the block chain.  The first transaction
 873  * in the block is a special one that creates a new coin owned by the creator
 874  * of the block.
 875  *
 876  * Blocks are appended to blk0001.dat files on disk.  Their location on disk
 877  * is indexed by CBlockIndex objects in memory.
 878  */
 879 class CBlock
 880 {
 881 public:
 882     // header
 883     static const int CURRENT_VERSION=6;
 884     int32_t nVersion;
 885     uint256 hashPrevBlock;
 886     uint256 hashMerkleRoot;
 887     uint32_t nTime;
 888     uint32_t nBits;
 889     uint32_t nNonce;
 890
 891     // network and disk
 892     std::vector<CTransaction> vtx;
 893
 894     // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
 895     std::vector<unsigned char> vchBlockSig;
 896
 897     // memory only
 898     mutable std::vector<uint256> vMerkleTree;
 899
 900     // Denial-of-service detection:
 901     mutable int nDoS;
 902     bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
 903
 904     CBlock()
 905     {
 906         SetNull();
 907     }
 908
 909     IMPLEMENT_SERIALIZE
 910     (
 911         READWRITE(this->nVersion);
 912         nVersion = this->nVersion;
 913         READWRITE(hashPrevBlock);
 914         READWRITE(hashMerkleRoot);
 915         READWRITE(nTime);
 916         READWRITE(nBits);
 917         READWRITE(nNonce);
 918
 919         // ConnectBlock depends on vtx following header to generate CDiskTxPos
 920         if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
 921         {
 922             READWRITE(vtx);
 923             READWRITE(vchBlockSig);
 924         }
 925         else if (fRead)
 926         {
 927             const_cast<CBlock*>(this)->vtx.clear();
 928             const_cast<CBlock*>(this)->vchBlockSig.clear();
 929         }
 930     )
 931
 932     void SetNull()
 933     {
 934         nVersion = CBlock::CURRENT_VERSION;
 935         hashPrevBlock = 0;
 936         hashMerkleRoot = 0;
 937         nTime = 0;
 938         nBits = 0;
 939         nNonce = 0;
 940         vtx.clear();
 941         vchBlockSig.clear();
 942         vMerkleTree.clear();
 943         nDoS = 0;
 944     }
 945
 946     bool IsNull() const
 947     {
 948         return (nBits == 0);
 949     }
 950
 951     uint256 GetHash() const
 952     {
 953         return scrypt_blockhash((const uint8_t*)&nVersion);
 954     }
 955
 956     int64_t GetBlockTime() const
 957     {
 958         return (int64_t)nTime;
 959     }
 960
 961     void UpdateTime(const CBlockIndex* pindexPrev);
 962
 963     // ppcoin: entropy bit for stake modifier if chosen by modifier
 964     unsigned int GetStakeEntropyBit(unsigned int nHeight) const
 965     {
 966         // Protocol switch to support p2pool at novacoin block #9689
 967         if (nHeight >= 9689 || fTestNet)
 968         {
 969             // Take last bit of block hash as entropy bit
 970             unsigned int nEntropyBit = ((GetHash().Get64()) & 1ULL);
 971             if (fDebug && GetBoolArg("-printstakemodifier"))
 972                 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
 973             return nEntropyBit;
 974         }
 975
 976         // Before novacoin block #9689 - get from pregenerated table
 977         int nBitNum = nHeight & 0xFF;
 978         int nItemNum = nHeight / 0xFF;
 979
 980         unsigned int nEntropyBit = (unsigned int) ((entropyStore[nItemNum] & (uint256(1) << nBitNum)) >> nBitNum).Get64();
 981         if (fDebug && GetBoolArg("-printstakemodifier"))
 982             printf("GetStakeEntropyBit: from pregenerated table, nHeight=%d nEntropyBit=%u\n", nHeight, nEntropyBit);
 983         return nEntropyBit;
 984     }
 985
 986     // ppcoin: two types of block: proof-of-work or proof-of-stake
 987     bool IsProofOfStake() const
 988     {
 989         return (vtx.size() > 1 && vtx[1].IsCoinStake());
 990     }
 991
 992     bool IsProofOfWork() const
 993     {
 994         return !IsProofOfStake();
 995     }
 996
 997     std::pair<COutPoint, unsigned int> GetProofOfStake() const
 998     {
 999         return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
1000     }
1001
1002     // ppcoin: get max transaction timestamp
1003     int64_t GetMaxTransactionTime() const
1004     {
1005         int64_t maxTransactionTime = 0;
1006         BOOST_FOREACH(const CTransaction& tx, vtx)
1007             maxTransactionTime = std::max(maxTransactionTime, (int64_t)tx.nTime);
1008         return maxTransactionTime;
1009     }
1010
1011     uint256 BuildMerkleTree() const
1012     {
1013         vMerkleTree.clear();
1014         BOOST_FOREACH(const CTransaction& tx, vtx)
1015             vMerkleTree.push_back(tx.GetHash());
1016         int j = 0;
1017         for (int nSize = (int)vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1018         {
1019             for (int i = 0; i < nSize; i += 2)
1020             {
1021                 int i2 = std::min(i+1, nSize-1);
1022                 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]),  END(vMerkleTree[j+i]),
1023                                            BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
1024             }
1025             j += nSize;
1026         }
1027         return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
1028     }
1029
1030     std::vector<uint256> GetMerkleBranch(int nIndex) const
1031     {
1032         if (vMerkleTree.empty())
1033             BuildMerkleTree();
1034         std::vector<uint256> vMerkleBranch;
1035         int j = 0;
1036         for (int nSize = (int)vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1037         {
1038             int i = std::min(nIndex^1, nSize-1);
1039             vMerkleBranch.push_back(vMerkleTree[j+i]);
1040             nIndex >>= 1;
1041             j += nSize;
1042         }
1043         return vMerkleBranch;
1044     }
1045
1046     static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1047     {
1048         if (nIndex == -1)
1049             return 0;
1050         BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1051         {
1052             if (nIndex & 1)
1053                 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1054             else
1055                 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1056             nIndex >>= 1;
1057         }
1058         return hash;
1059     }
1060
1061
1062     bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1063     {
1064         // Open history file to append
1065         CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1066         if (!fileout)
1067             return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1068
1069         // Write index header
1070         unsigned int nSize = fileout.GetSerializeSize(*this);
1071         fileout << FLATDATA(pchMessageStart) << nSize;
1072
1073         // Write block
1074         long fileOutPos = ftell(fileout);
1075         if (fileOutPos < 0)
1076             return error("CBlock::WriteToDisk() : ftell failed");
1077         nBlockPosRet = fileOutPos;
1078         fileout << *this;
1079
1080         // Flush stdio buffers and commit to disk before returning
1081         fflush(fileout);
1082         if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1083             FileCommit(fileout);
1084
1085         return true;
1086     }
1087
1088     bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1089     {
1090         SetNull();
1091
1092         // Open history file to read
1093         CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1094         if (!filein)
1095             return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1096         if (!fReadTransactions)
1097             filein.nType |= SER_BLOCKHEADERONLY;
1098
1099         // Read block
1100         try {
1101             filein >> *this;
1102         }
1103         catch (std::exception &e) {
1104             (void)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_t& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1147     bool SignBlock(CWallet& keystore);
1148     bool CheckBlockSignature() 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     uint32_t nFile;
1173     uint32_t nBlockPos;
1174     uint256 nChainTrust; // ppcoin: trust score of block chain
1175     int32_t nHeight;
1176
1177     int64_t nMint;
1178     int64_t nMoneySupply;
1179
1180     uint32_t 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_t nStakeModifier; // hash modifier for proof-of-stake
1189     uint32_t nStakeModifierChecksum; // checksum of index; in-memeory only
1190
1191     // proof-of-stake specific fields
1192     COutPoint prevoutStake;
1193     uint32_t nStakeTime;
1194     uint256 hashProofOfStake;
1195
1196     // block header
1197     int32_t  nVersion;
1198     uint256  hashMerkleRoot;
1199     uint32_t nTime;
1200     uint32_t nBits;
1201     uint32_t 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_t GetBlockTime() const
1281     {
1282         return (int64_t)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_t GetMedianTimePast() const
1300     {
1301         int64_t pmedian[nMedianTimeSpan];
1302         int64_t* pbegin = &pmedian[nMedianTimeSpan];
1303         int64_t* 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_t 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) != 0;
1364     }
1365
1366     void SetStakeModifier(uint64_t 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" PRIx64 ", 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     size_t 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