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