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