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