src/main.h

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