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 "bignum.h"
   9 #include "sync.h"
  10 #include "net.h"
  11 #include "script.h"
  12 #include "scrypt_mine.h"
  13
  14 #include <list>
  15
  16 class CWallet;
  17 class CBlock;
  18 class CBlockIndex;
  19 class CKeyItem;
  20 class CReserveKey;
  21 class COutPoint;
  22
  23 class CAddress;
  24 class CInv;
  25 class CRequestTracker;
  26 class CNode;
  27
  28 static const unsigned int MAX_BLOCK_SIZE = 1000000;
  29 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
  30 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
  31 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
  32 static const unsigned int MAX_INV_SZ = 50000;
  33 static const int64 MIN_TX_FEE = CENT;
  34 static const int64 MIN_RELAY_TX_FEE = CENT;
  35 static const int64 MAX_MONEY = 2000000000 * COIN;
  36 static const int64 MAX_MINT_PROOF_OF_WORK = 100 * COIN;
  37 static const int64 MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
  38 static const int64 MIN_TXOUT_AMOUNT = MIN_TX_FEE;
  39
  40 static const unsigned int ENTROPY_SWITCH_TIME = 1362791041; // Sat, 09 Mar 2013 01:04:01 GMT
  41 static const unsigned int STAKE_SWITCH_TIME = 1371686400; // Thu, 20 Jun 2013 00:00:00 GMT
  42 static const unsigned int TARGETS_SWITCH_TIME = 1374278400; // Sat, 20 Jul 2013 00:00:00 GMT
  43 static const unsigned int CHAINCHECKS_SWITCH_TIME = 1379635200; // Fri, 20 Sep 2013 00:00:00 GMT
  44 static const unsigned int STAKECURVE_SWITCH_TIME = 1382227200; // Sun, 20 Oct 2013 00:00:00 GMT
  45 static const unsigned int STAKEWEIGHT_SWITCH_TIME = 1388534400; // Wed, 01 Jan 2014 00:00:00 GMT
  46
  47
  48 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
  49 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
  50 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov  5 00:53:20 1985 UTC
  51
  52 #ifdef USE_UPNP
  53 static const int fHaveUPnP = true;
  54 #else
  55 static const int fHaveUPnP = false;
  56 #endif
  57
  58 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
  59 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
  60
  61 static const int64 nMaxClockDrift = 2 * 60 * 60;        // two hours
  62
  63 extern CScript COINBASE_FLAGS;
  64
  65
  66 extern CCriticalSection cs_main;
  67 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
  68 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
  69 extern CBlockIndex* pindexGenesisBlock;
  70 extern unsigned int nStakeMinAge;
  71 extern unsigned int nNodeLifespan;
  72 extern int nCoinbaseMaturity;
  73 extern int nBestHeight;
  74 extern uint256 nBestChainTrust;
  75 extern uint256 nBestInvalidTrust;
  76 extern uint256 hashBestChain;
  77 extern CBlockIndex* pindexBest;
  78 extern unsigned int nTransactionsUpdated;
  79 extern uint64 nLastBlockTx;
  80 extern uint64 nLastBlockSize;
  81 extern int64 nLastCoinStakeSearchInterval;
  82 extern const std::string strMessageMagic;
  83 extern double dHashesPerSec;
  84 extern int64 nHPSTimerStart;
  85 extern int64 nTimeBestReceived;
  86 extern CCriticalSection cs_setpwalletRegistered;
  87 extern std::set<CWallet*> setpwalletRegistered;
  88 extern unsigned char pchMessageStart[4];
  89 extern std::map<uint256, CBlock*> mapOrphanBlocks;
  90
  91 // Settings
  92 extern int64 nTransactionFee;
  93 extern bool fStakeUsePooledKeys;
  94
  95 // Minimum disk space required - used in CheckDiskSpace()
  96 static const uint64 nMinDiskSpace = 52428800;
  97
  98
  99 class CReserveKey;
 100 class CTxDB;
 101 class CTxIndex;
 102
 103 void RegisterWallet(CWallet* pwalletIn);
 104 void UnregisterWallet(CWallet* pwalletIn);
 105 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
 106 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
 107 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
 108 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
 109 FILE* AppendBlockFile(unsigned int& nFileRet);
 110 bool LoadBlockIndex(bool fAllowNew=true);
 111 void PrintBlockTree();
 112 CBlockIndex* FindBlockByHeight(int nHeight);
 113 bool ProcessMessages(CNode* pfrom);
 114 bool SendMessages(CNode* pto, bool fSendTrickle);
 115 bool LoadExternalBlockFile(FILE* fileIn);
 116 CBlock* CreateNewBlock(CWallet* pwallet, bool fProofOfStake=false);
 117 void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
 118 void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
 119 bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
 120 bool CheckStake(CBlock* pblock, CWallet& wallet);
 121 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
 122 int64 GetProofOfWorkReward(unsigned int nBits);
 123 int64 GetProofOfStakeReward(int64 nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly=false);
 124 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
 125 unsigned int ComputeMinStake(unsigned int nBase, int64 nTime, unsigned int nBlockTime);
 126 int GetNumBlocksOfPeers();
 127 bool IsInitialBlockDownload();
 128 std::string GetWarnings(std::string strFor);
 129 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
 130 uint256 WantedByOrphan(const CBlock* pblockOrphan);
 131 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
 132 void BitcoinMiner(CWallet *pwallet, bool fProofOfStake);
 133 void ResendWalletTransactions();
 134
 135
 136
 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) 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] fStrictPayToScriptHash       true if fully validating p2sh transactions
 703         @return Returns true if all checks succeed
 704      */
 705     bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs,
 706                        std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
 707                        const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash=true);
 708     bool ClientConnectInputs();
 709     bool CheckTransaction() const;
 710     bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
 711     bool GetCoinAge(CTxDB& txdb, uint64& nCoinAge) const;  // ppcoin: get transaction coin age
 712
 713 protected:
 714     const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
 715 };
 716
 717
 718
 719
 720
 721 /** A transaction with a merkle branch linking it to the block chain. */
 722 class CMerkleTx : public CTransaction
 723 {
 724 public:
 725     uint256 hashBlock;
 726     std::vector<uint256> vMerkleBranch;
 727     int nIndex;
 728
 729     // memory only
 730     mutable bool fMerkleVerified;
 731
 732
 733     CMerkleTx()
 734     {
 735         Init();
 736     }
 737
 738     CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
 739     {
 740         Init();
 741     }
 742
 743     void Init()
 744     {
 745         hashBlock = 0;
 746         nIndex = -1;
 747         fMerkleVerified = false;
 748     }
 749
 750
 751     IMPLEMENT_SERIALIZE
 752     (
 753         nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
 754         nVersion = this->nVersion;
 755         READWRITE(hashBlock);
 756         READWRITE(vMerkleBranch);
 757         READWRITE(nIndex);
 758     )
 759
 760
 761     int SetMerkleBranch(const CBlock* pblock=NULL);
 762     int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
 763     int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
 764     bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
 765     int GetBlocksToMaturity() const;
 766     bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
 767     bool AcceptToMemoryPool();
 768 };
 769
 770
 771
 772
 773 /**  A txdb record that contains the disk location of a transaction and the
 774  * locations of transactions that spend its outputs.  vSpent is really only
 775  * used as a flag, but having the location is very helpful for debugging.
 776  */
 777 class CTxIndex
 778 {
 779 public:
 780     CDiskTxPos pos;
 781     std::vector<CDiskTxPos> vSpent;
 782
 783     CTxIndex()
 784     {
 785         SetNull();
 786     }
 787
 788     CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
 789     {
 790         pos = posIn;
 791         vSpent.resize(nOutputs);
 792     }
 793
 794     IMPLEMENT_SERIALIZE
 795     (
 796         if (!(nType & SER_GETHASH))
 797             READWRITE(nVersion);
 798         READWRITE(pos);
 799         READWRITE(vSpent);
 800     )
 801
 802     void SetNull()
 803     {
 804         pos.SetNull();
 805         vSpent.clear();
 806     }
 807
 808     bool IsNull()
 809     {
 810         return pos.IsNull();
 811     }
 812
 813     friend bool operator==(const CTxIndex& a, const CTxIndex& b)
 814     {
 815         return (a.pos    == b.pos &&
 816                 a.vSpent == b.vSpent);
 817     }
 818
 819     friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
 820     {
 821         return !(a == b);
 822     }
 823     int GetDepthInMainChain() const;
 824
 825 };
 826
 827
 828
 829
 830
 831 /** Nodes collect new transactions into a block, hash them into a hash tree,
 832  * and scan through nonce values to make the block's hash satisfy proof-of-work
 833  * requirements.  When they solve the proof-of-work, they broadcast the block
 834  * to everyone and the block is added to the block chain.  The first transaction
 835  * in the block is a special one that creates a new coin owned by the creator
 836  * of the block.
 837  *
 838  * Blocks are appended to blk0001.dat files on disk.  Their location on disk
 839  * is indexed by CBlockIndex objects in memory.
 840  */
 841 class CBlock
 842 {
 843 public:
 844     // header
 845     static const int CURRENT_VERSION=6;
 846     int nVersion;
 847     uint256 hashPrevBlock;
 848     uint256 hashMerkleRoot;
 849     unsigned int nTime;
 850     unsigned int nBits;
 851     unsigned int nNonce;
 852
 853     // network and disk
 854     std::vector<CTransaction> vtx;
 855
 856     // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
 857     std::vector<unsigned char> vchBlockSig;
 858
 859     // memory only
 860     mutable std::vector<uint256> vMerkleTree;
 861
 862     // Denial-of-service detection:
 863     mutable int nDoS;
 864     bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
 865
 866     CBlock()
 867     {
 868         SetNull();
 869     }
 870
 871     IMPLEMENT_SERIALIZE
 872     (
 873         READWRITE(this->nVersion);
 874         nVersion = this->nVersion;
 875         READWRITE(hashPrevBlock);
 876         READWRITE(hashMerkleRoot);
 877         READWRITE(nTime);
 878         READWRITE(nBits);
 879         READWRITE(nNonce);
 880
 881         // ConnectBlock depends on vtx following header to generate CDiskTxPos
 882         if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
 883         {
 884             READWRITE(vtx);
 885             READWRITE(vchBlockSig);
 886         }
 887         else if (fRead)
 888         {
 889             const_cast<CBlock*>(this)->vtx.clear();
 890             const_cast<CBlock*>(this)->vchBlockSig.clear();
 891         }
 892     )
 893
 894     void SetNull()
 895     {
 896         nVersion = CBlock::CURRENT_VERSION;
 897         hashPrevBlock = 0;
 898         hashMerkleRoot = 0;
 899         nTime = 0;
 900         nBits = 0;
 901         nNonce = 0;
 902         vtx.clear();
 903         vchBlockSig.clear();
 904         vMerkleTree.clear();
 905         nDoS = 0;
 906     }
 907
 908     bool IsNull() const
 909     {
 910         return (nBits == 0);
 911     }
 912
 913     uint256 GetHash() const
 914     {
 915         uint256 thash;
 916         void * scratchbuff = scrypt_buffer_alloc();
 917
 918         scrypt_hash(CVOIDBEGIN(nVersion), sizeof(block_header), UINTBEGIN(thash), scratchbuff);
 919
 920         scrypt_buffer_free(scratchbuff);
 921
 922         return thash;
 923     }
 924
 925     int64 GetBlockTime() const
 926     {
 927         return (int64)nTime;
 928     }
 929
 930     void UpdateTime(const CBlockIndex* pindexPrev);
 931
 932     // ppcoin: entropy bit for stake modifier if chosen by modifier
 933     unsigned int GetStakeEntropyBit(unsigned int nTime) const
 934     {
 935         // Protocol switch to support p2pool at novacoin block #9689
 936         if (nTime >= ENTROPY_SWITCH_TIME || fTestNet)
 937         {
 938             // Take last bit of block hash as entropy bit
 939             unsigned int nEntropyBit = ((GetHash().Get64()) & 1llu);
 940             if (fDebug && GetBoolArg("-printstakemodifier"))
 941                 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
 942             return nEntropyBit;
 943         }
 944         // Before novacoin block #9689 - old protocol
 945         uint160 hashSig = Hash160(vchBlockSig);
 946         if (fDebug && GetBoolArg("-printstakemodifier"))
 947             printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
 948         hashSig >>= 159; // take the first bit of the hash
 949         if (fDebug && GetBoolArg("-printstakemodifier"))
 950             printf(" entropybit=%"PRI64d"\n", hashSig.Get64());
 951         return hashSig.Get64();
 952     }
 953
 954     // ppcoin: two types of block: proof-of-work or proof-of-stake
 955     bool IsProofOfStake() const
 956     {
 957         return (vtx.size() > 1 && vtx[1].IsCoinStake());
 958     }
 959
 960     bool IsProofOfWork() const
 961     {
 962         return !IsProofOfStake();
 963     }
 964
 965     std::pair<COutPoint, unsigned int> GetProofOfStake() const
 966     {
 967         return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
 968     }
 969
 970     // ppcoin: get max transaction timestamp
 971     int64 GetMaxTransactionTime() const
 972     {
 973         int64 maxTransactionTime = 0;
 974         BOOST_FOREACH(const CTransaction& tx, vtx)
 975             maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
 976         return maxTransactionTime;
 977     }
 978
 979     uint256 BuildMerkleTree() const
 980     {
 981         vMerkleTree.clear();
 982         BOOST_FOREACH(const CTransaction& tx, vtx)
 983             vMerkleTree.push_back(tx.GetHash());
 984         int j = 0;
 985         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
 986         {
 987             for (int i = 0; i < nSize; i += 2)
 988             {
 989                 int i2 = std::min(i+1, nSize-1);
 990                 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]),  END(vMerkleTree[j+i]),
 991                                            BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
 992             }
 993             j += nSize;
 994         }
 995         return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
 996     }
 997
 998     std::vector<uint256> GetMerkleBranch(int nIndex) const
 999     {
1000         if (vMerkleTree.empty())
1001             BuildMerkleTree();
1002         std::vector<uint256> vMerkleBranch;
1003         int j = 0;
1004         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1005         {
1006             int i = std::min(nIndex^1, nSize-1);
1007             vMerkleBranch.push_back(vMerkleTree[j+i]);
1008             nIndex >>= 1;
1009             j += nSize;
1010         }
1011         return vMerkleBranch;
1012     }
1013
1014     static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1015     {
1016         if (nIndex == -1)
1017             return 0;
1018         BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1019         {
1020             if (nIndex & 1)
1021                 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1022             else
1023                 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1024             nIndex >>= 1;
1025         }
1026         return hash;
1027     }
1028
1029
1030     bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1031     {
1032         // Open history file to append
1033         CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1034         if (!fileout)
1035             return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1036
1037         // Write index header
1038         unsigned int nSize = fileout.GetSerializeSize(*this);
1039         fileout << FLATDATA(pchMessageStart) << nSize;
1040
1041         // Write block
1042         long fileOutPos = ftell(fileout);
1043         if (fileOutPos < 0)
1044             return error("CBlock::WriteToDisk() : ftell failed");
1045         nBlockPosRet = fileOutPos;
1046         fileout << *this;
1047
1048         // Flush stdio buffers and commit to disk before returning
1049         fflush(fileout);
1050         if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1051             FileCommit(fileout);
1052
1053         return true;
1054     }
1055
1056     bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1057     {
1058         SetNull();
1059
1060         // Open history file to read
1061         CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1062         if (!filein)
1063             return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1064         if (!fReadTransactions)
1065             filein.nType |= SER_BLOCKHEADERONLY;
1066
1067         // Read block
1068         try {
1069             filein >> *this;
1070         }
1071         catch (std::exception &e) {
1072             return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1073         }
1074
1075         // Check the header
1076         if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1077             return error("CBlock::ReadFromDisk() : errors in block header");
1078
1079         return true;
1080     }
1081
1082
1083
1084     void print() const
1085     {
1086         printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu", vchBlockSig=%s)\n",
1087             GetHash().ToString().c_str(),
1088             nVersion,
1089             hashPrevBlock.ToString().c_str(),
1090             hashMerkleRoot.ToString().c_str(),
1091             nTime, nBits, nNonce,
1092             vtx.size(),
1093             HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1094         for (unsigned int i = 0; i < vtx.size(); i++)
1095         {
1096             printf("  ");
1097             vtx[i].print();
1098         }
1099         printf("  vMerkleTree: ");
1100         for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1101             printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1102         printf("\n");
1103     }
1104
1105
1106     bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1107     bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1108     bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1109     bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1110     bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1111     bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1112     bool AcceptBlock();
1113     bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1114     bool SignBlock(const CKeyStore& keystore);
1115     bool CheckBlockSignature(bool fProofOfStake) const;
1116
1117 private:
1118     bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1119 };
1120
1121
1122
1123
1124
1125
1126 /** The block chain is a tree shaped structure starting with the
1127  * genesis block at the root, with each block potentially having multiple
1128  * candidates to be the next block.  pprev and pnext link a path through the
1129  * main/longest chain.  A blockindex may have multiple pprev pointing back
1130  * to it, but pnext will only point forward to the longest branch, or will
1131  * be null if the block is not part of the longest chain.
1132  */
1133 class CBlockIndex
1134 {
1135 public:
1136     const uint256* phashBlock;
1137     CBlockIndex* pprev;
1138     CBlockIndex* pnext;
1139     unsigned int nFile;
1140     unsigned int nBlockPos;
1141     uint256 nChainTrust; // ppcoin: trust score of block chain
1142     int nHeight;
1143
1144     int64 nMint;
1145     int64 nMoneySupply;
1146
1147     unsigned int nFlags;  // ppcoin: block index flags
1148     enum
1149     {
1150         BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1151         BLOCK_STAKE_ENTROPY  = (1 << 1), // entropy bit for stake modifier
1152         BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1153     };
1154
1155     uint64 nStakeModifier; // hash modifier for proof-of-stake
1156     unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1157
1158     // proof-of-stake specific fields
1159     COutPoint prevoutStake;
1160     unsigned int nStakeTime;
1161     uint256 hashProofOfStake;
1162
1163     // block header
1164     int nVersion;
1165     uint256 hashMerkleRoot;
1166     unsigned int nTime;
1167     unsigned int nBits;
1168     unsigned int nNonce;
1169
1170     CBlockIndex()
1171     {
1172         phashBlock = NULL;
1173         pprev = NULL;
1174         pnext = NULL;
1175         nFile = 0;
1176         nBlockPos = 0;
1177         nHeight = 0;
1178         nChainTrust = 0;
1179         nMint = 0;
1180         nMoneySupply = 0;
1181         nFlags = 0;
1182         nStakeModifier = 0;
1183         nStakeModifierChecksum = 0;
1184         hashProofOfStake = 0;
1185         prevoutStake.SetNull();
1186         nStakeTime = 0;
1187
1188         nVersion       = 0;
1189         hashMerkleRoot = 0;
1190         nTime          = 0;
1191         nBits          = 0;
1192         nNonce         = 0;
1193     }
1194
1195     CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1196     {
1197         phashBlock = NULL;
1198         pprev = NULL;
1199         pnext = NULL;
1200         nFile = nFileIn;
1201         nBlockPos = nBlockPosIn;
1202         nHeight = 0;
1203         nChainTrust = 0;
1204         nMint = 0;
1205         nMoneySupply = 0;
1206         nFlags = 0;
1207         nStakeModifier = 0;
1208         nStakeModifierChecksum = 0;
1209         hashProofOfStake = 0;
1210         if (block.IsProofOfStake())
1211         {
1212             SetProofOfStake();
1213             prevoutStake = block.vtx[1].vin[0].prevout;
1214             nStakeTime = block.vtx[1].nTime;
1215         }
1216         else
1217         {
1218             prevoutStake.SetNull();
1219             nStakeTime = 0;
1220         }
1221
1222         nVersion       = block.nVersion;
1223         hashMerkleRoot = block.hashMerkleRoot;
1224         nTime          = block.nTime;
1225         nBits          = block.nBits;
1226         nNonce         = block.nNonce;
1227     }
1228
1229     CBlock GetBlockHeader() const
1230     {
1231         CBlock block;
1232         block.nVersion       = nVersion;
1233         if (pprev)
1234             block.hashPrevBlock = pprev->GetBlockHash();
1235         block.hashMerkleRoot = hashMerkleRoot;
1236         block.nTime          = nTime;
1237         block.nBits          = nBits;
1238         block.nNonce         = nNonce;
1239         return block;
1240     }
1241
1242     uint256 GetBlockHash() const
1243     {
1244         return *phashBlock;
1245     }
1246
1247     int64 GetBlockTime() const
1248     {
1249         return (int64)nTime;
1250     }
1251
1252     uint256 GetBlockTrust() const;
1253
1254     bool IsInMainChain() const
1255     {
1256         return (pnext || this == pindexBest);
1257     }
1258
1259     bool CheckIndex() const
1260     {
1261         return true;
1262     }
1263
1264     enum { nMedianTimeSpan=11 };
1265
1266     int64 GetMedianTimePast() const
1267     {
1268         int64 pmedian[nMedianTimeSpan];
1269         int64* pbegin = &pmedian[nMedianTimeSpan];
1270         int64* pend = &pmedian[nMedianTimeSpan];
1271
1272         const CBlockIndex* pindex = this;
1273         for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1274             *(--pbegin) = pindex->GetBlockTime();
1275
1276         std::sort(pbegin, pend);
1277         return pbegin[(pend - pbegin)/2];
1278     }
1279
1280     int64 GetMedianTime() const
1281     {
1282         const CBlockIndex* pindex = this;
1283         for (int i = 0; i < nMedianTimeSpan/2; i++)
1284         {
1285             if (!pindex->pnext)
1286                 return GetBlockTime();
1287             pindex = pindex->pnext;
1288         }
1289         return pindex->GetMedianTimePast();
1290     }
1291
1292     /**
1293      * Returns true if there are nRequired or more blocks of minVersion or above
1294      * in the last nToCheck blocks, starting at pstart and going backwards.
1295      */
1296     static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1297                                 unsigned int nRequired, unsigned int nToCheck);
1298
1299
1300     bool IsProofOfWork() const
1301     {
1302         return !(nFlags & BLOCK_PROOF_OF_STAKE);
1303     }
1304
1305     bool IsProofOfStake() const
1306     {
1307         return (nFlags & BLOCK_PROOF_OF_STAKE);
1308     }
1309
1310     void SetProofOfStake()
1311     {
1312         nFlags |= BLOCK_PROOF_OF_STAKE;
1313     }
1314
1315     unsigned int GetStakeEntropyBit() const
1316     {
1317         return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1318     }
1319
1320     bool SetStakeEntropyBit(unsigned int nEntropyBit)
1321     {
1322         if (nEntropyBit > 1)
1323             return false;
1324         nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1325         return true;
1326     }
1327
1328     bool GeneratedStakeModifier() const
1329     {
1330         return (nFlags & BLOCK_STAKE_MODIFIER);
1331     }
1332
1333     void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1334     {
1335         nStakeModifier = nModifier;
1336         if (fGeneratedStakeModifier)
1337             nFlags |= BLOCK_STAKE_MODIFIER;
1338     }
1339
1340     std::string ToString() const
1341     {
1342         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)",
1343             pprev, pnext, nFile, nBlockPos, nHeight,
1344             FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1345             GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1346             nStakeModifier, nStakeModifierChecksum,
1347             hashProofOfStake.ToString().c_str(),
1348             prevoutStake.ToString().c_str(), nStakeTime,
1349             hashMerkleRoot.ToString().c_str(),
1350             GetBlockHash().ToString().c_str());
1351     }
1352
1353     void print() const
1354     {
1355         printf("%s\n", ToString().c_str());
1356     }
1357 };
1358
1359
1360
1361 /** Used to marshal pointers into hashes for db storage. */
1362 class CDiskBlockIndex : public CBlockIndex
1363 {
1364 public:
1365     uint256 hashPrev;
1366     uint256 hashNext;
1367
1368     CDiskBlockIndex()
1369     {
1370         hashPrev = 0;
1371         hashNext = 0;
1372     }
1373
1374     explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1375     {
1376         hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1377         hashNext = (pnext ? pnext->GetBlockHash() : 0);
1378     }
1379
1380     IMPLEMENT_SERIALIZE
1381     (
1382         if (!(nType & SER_GETHASH))
1383             READWRITE(nVersion);
1384
1385         READWRITE(hashNext);
1386         READWRITE(nFile);
1387         READWRITE(nBlockPos);
1388         READWRITE(nHeight);
1389         READWRITE(nMint);
1390         READWRITE(nMoneySupply);
1391         READWRITE(nFlags);
1392         READWRITE(nStakeModifier);
1393         if (IsProofOfStake())
1394         {
1395             READWRITE(prevoutStake);
1396             READWRITE(nStakeTime);
1397             READWRITE(hashProofOfStake);
1398         }
1399         else if (fRead)
1400         {
1401             const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1402             const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1403             const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1404         }
1405
1406         // block header
1407         READWRITE(this->nVersion);
1408         READWRITE(hashPrev);
1409         READWRITE(hashMerkleRoot);
1410         READWRITE(nTime);
1411         READWRITE(nBits);
1412         READWRITE(nNonce);
1413     )
1414
1415     uint256 GetBlockHash() const
1416     {
1417         CBlock block;
1418         block.nVersion        = nVersion;
1419         block.hashPrevBlock   = hashPrev;
1420         block.hashMerkleRoot  = hashMerkleRoot;
1421         block.nTime           = nTime;
1422         block.nBits           = nBits;
1423         block.nNonce          = nNonce;
1424         return block.GetHash();
1425     }
1426
1427
1428     std::string ToString() const
1429     {
1430         std::string str = "CDiskBlockIndex(";
1431         str += CBlockIndex::ToString();
1432         str += strprintf("\n                hashBlock=%s, hashPrev=%s, hashNext=%s)",
1433             GetBlockHash().ToString().c_str(),
1434             hashPrev.ToString().c_str(),
1435             hashNext.ToString().c_str());
1436         return str;
1437     }
1438
1439     void print() const
1440     {
1441         printf("%s\n", ToString().c_str());
1442     }
1443 };
1444
1445
1446
1447
1448
1449
1450
1451
1452 /** Describes a place in the block chain to another node such that if the
1453  * other node doesn't have the same branch, it can find a recent common trunk.
1454  * The further back it is, the further before the fork it may be.
1455  */
1456 class CBlockLocator
1457 {
1458 protected:
1459     std::vector<uint256> vHave;
1460 public:
1461
1462     CBlockLocator()
1463     {
1464     }
1465
1466     explicit CBlockLocator(const CBlockIndex* pindex)
1467     {
1468         Set(pindex);
1469     }
1470
1471     explicit CBlockLocator(uint256 hashBlock)
1472     {
1473         std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1474         if (mi != mapBlockIndex.end())
1475             Set((*mi).second);
1476     }
1477
1478     CBlockLocator(const std::vector<uint256>& vHaveIn)
1479     {
1480         vHave = vHaveIn;
1481     }
1482
1483     IMPLEMENT_SERIALIZE
1484     (
1485         if (!(nType & SER_GETHASH))
1486             READWRITE(nVersion);
1487         READWRITE(vHave);
1488     )
1489
1490     void SetNull()
1491     {
1492         vHave.clear();
1493     }
1494
1495     bool IsNull()
1496     {
1497         return vHave.empty();
1498     }
1499
1500     void Set(const CBlockIndex* pindex)
1501     {
1502         vHave.clear();
1503         int nStep = 1;
1504         while (pindex)
1505         {
1506             vHave.push_back(pindex->GetBlockHash());
1507
1508             // Exponentially larger steps back
1509             for (int i = 0; pindex && i < nStep; i++)
1510                 pindex = pindex->pprev;
1511             if (vHave.size() > 10)
1512                 nStep *= 2;
1513         }
1514         vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1515     }
1516
1517     int GetDistanceBack()
1518     {
1519         // Retrace how far back it was in the sender's branch
1520         int nDistance = 0;
1521         int nStep = 1;
1522         BOOST_FOREACH(const uint256& hash, vHave)
1523         {
1524             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1525             if (mi != mapBlockIndex.end())
1526             {
1527                 CBlockIndex* pindex = (*mi).second;
1528                 if (pindex->IsInMainChain())
1529                     return nDistance;
1530             }
1531             nDistance += nStep;
1532             if (nDistance > 10)
1533                 nStep *= 2;
1534         }
1535         return nDistance;
1536     }
1537
1538     CBlockIndex* GetBlockIndex()
1539     {
1540         // Find the first block the caller has in the main chain
1541         BOOST_FOREACH(const uint256& hash, vHave)
1542         {
1543             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1544             if (mi != mapBlockIndex.end())
1545             {
1546                 CBlockIndex* pindex = (*mi).second;
1547                 if (pindex->IsInMainChain())
1548                     return pindex;
1549             }
1550         }
1551         return pindexGenesisBlock;
1552     }
1553
1554     uint256 GetBlockHash()
1555     {
1556         // Find the first block the caller has in the main chain
1557         BOOST_FOREACH(const uint256& hash, vHave)
1558         {
1559             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1560             if (mi != mapBlockIndex.end())
1561             {
1562                 CBlockIndex* pindex = (*mi).second;
1563                 if (pindex->IsInMainChain())
1564                     return hash;
1565             }
1566         }
1567         return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1568     }
1569
1570     int GetHeight()
1571     {
1572         CBlockIndex* pindex = GetBlockIndex();
1573         if (!pindex)
1574             return 0;
1575         return pindex->nHeight;
1576     }
1577 };
1578
1579
1580
1581
1582
1583
1584
1585
1586 class CTxMemPool
1587 {
1588 public:
1589     mutable CCriticalSection cs;
1590     std::map<uint256, CTransaction> mapTx;
1591     std::map<COutPoint, CInPoint> mapNextTx;
1592
1593     bool accept(CTxDB& txdb, CTransaction &tx,
1594                 bool fCheckInputs, bool* pfMissingInputs);
1595     bool addUnchecked(const uint256& hash, CTransaction &tx);
1596     bool remove(CTransaction &tx);
1597     void clear();
1598     void queryHashes(std::vector<uint256>& vtxid);
1599
1600     unsigned long size()
1601     {
1602         LOCK(cs);
1603         return mapTx.size();
1604     }
1605
1606     bool exists(uint256 hash)
1607     {
1608         return (mapTx.count(hash) != 0);
1609     }
1610
1611     CTransaction& lookup(uint256 hash)
1612     {
1613         return mapTx[hash];
1614     }
1615 };
1616
1617 extern CTxMemPool mempool;
1618
1619 #endif