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