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