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