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 double dHashesPerSec;
  84 extern int64 nHPSTimerStart;
  85 extern int64 nTimeBestReceived;
  86 extern CCriticalSection cs_setpwalletRegistered;
  87 extern std::set<CWallet*> setpwalletRegistered;
  88 extern unsigned char pchMessageStart[4];
  89 extern std::map<uint256, CBlock*> mapOrphanBlocks;
  90
  91 // Settings
  92 extern int64 nTransactionFee;
  93
  94 // Minimum disk space required - used in CheckDiskSpace()
  95 static const uint64 nMinDiskSpace = 52428800;
  96
  97
  98 class CReserveKey;
  99 class CTxDB;
 100 class CTxIndex;
 101
 102 void RegisterWallet(CWallet* pwalletIn);
 103 void UnregisterWallet(CWallet* pwalletIn);
 104 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
 105 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
 106 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
 107 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
 108 FILE* AppendBlockFile(unsigned int& nFileRet);
 109 bool LoadBlockIndex(bool fAllowNew=true);
 110 void PrintBlockTree();
 111 CBlockIndex* FindBlockByHeight(int nHeight);
 112 bool ProcessMessages(CNode* pfrom);
 113 bool SendMessages(CNode* pto, bool fSendTrickle);
 114 bool LoadExternalBlockFile(FILE* fileIn);
 115 CBlock* CreateNewBlock(CWallet* pwallet, bool fProofOfStake=false);
 116 void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
 117 void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
 118 bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
 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 BitcoinMiner(CWallet *pwallet, bool fProofOfStake);
 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         uint256 thash;
 914         void * scratchbuff = scrypt_buffer_alloc();
 915
 916         scrypt_hash(CVOIDBEGIN(nVersion), sizeof(block_header), UINTBEGIN(thash), scratchbuff);
 917
 918         scrypt_buffer_free(scratchbuff);
 919
 920         return thash;
 921     }
 922
 923     int64 GetBlockTime() const
 924     {
 925         return (int64)nTime;
 926     }
 927
 928     void UpdateTime(const CBlockIndex* pindexPrev);
 929
 930     // ppcoin: entropy bit for stake modifier if chosen by modifier
 931     unsigned int GetStakeEntropyBit(unsigned int nTime) const
 932     {
 933         // Protocol switch to support p2pool at novacoin block #9689
 934         if (nTime >= ENTROPY_SWITCH_TIME || fTestNet)
 935         {
 936             // Take last bit of block hash as entropy bit
 937             unsigned int nEntropyBit = ((GetHash().Get64()) & 1llu);
 938             if (fDebug && GetBoolArg("-printstakemodifier"))
 939                 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
 940             return nEntropyBit;
 941         }
 942         // Before novacoin block #9689 - old protocol
 943         uint160 hashSig = Hash160(vchBlockSig);
 944         if (fDebug && GetBoolArg("-printstakemodifier"))
 945             printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
 946         hashSig >>= 159; // take the first bit of the hash
 947         if (fDebug && GetBoolArg("-printstakemodifier"))
 948             printf(" entropybit=%"PRI64d"\n", hashSig.Get64());
 949         return hashSig.Get64();
 950     }
 951
 952     // ppcoin: two types of block: proof-of-work or proof-of-stake
 953     bool IsProofOfStake() const
 954     {
 955         return (vtx.size() > 1 && vtx[1].IsCoinStake());
 956     }
 957
 958     bool IsProofOfWork() const
 959     {
 960         return !IsProofOfStake();
 961     }
 962
 963     std::pair<COutPoint, unsigned int> GetProofOfStake() const
 964     {
 965         return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
 966     }
 967
 968     // ppcoin: get max transaction timestamp
 969     int64 GetMaxTransactionTime() const
 970     {
 971         int64 maxTransactionTime = 0;
 972         BOOST_FOREACH(const CTransaction& tx, vtx)
 973             maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
 974         return maxTransactionTime;
 975     }
 976
 977     uint256 BuildMerkleTree() const
 978     {
 979         vMerkleTree.clear();
 980         BOOST_FOREACH(const CTransaction& tx, vtx)
 981             vMerkleTree.push_back(tx.GetHash());
 982         int j = 0;
 983         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
 984         {
 985             for (int i = 0; i < nSize; i += 2)
 986             {
 987                 int i2 = std::min(i+1, nSize-1);
 988                 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]),  END(vMerkleTree[j+i]),
 989                                            BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
 990             }
 991             j += nSize;
 992         }
 993         return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
 994     }
 995
 996     std::vector<uint256> GetMerkleBranch(int nIndex) const
 997     {
 998         if (vMerkleTree.empty())
 999             BuildMerkleTree();
1000         std::vector<uint256> vMerkleBranch;
1001         int j = 0;
1002         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1003         {
1004             int i = std::min(nIndex^1, nSize-1);
1005             vMerkleBranch.push_back(vMerkleTree[j+i]);
1006             nIndex >>= 1;
1007             j += nSize;
1008         }
1009         return vMerkleBranch;
1010     }
1011
1012     static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1013     {
1014         if (nIndex == -1)
1015             return 0;
1016         BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1017         {
1018             if (nIndex & 1)
1019                 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1020             else
1021                 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1022             nIndex >>= 1;
1023         }
1024         return hash;
1025     }
1026
1027
1028     bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1029     {
1030         // Open history file to append
1031         CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1032         if (!fileout)
1033             return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1034
1035         // Write index header
1036         unsigned int nSize = fileout.GetSerializeSize(*this);
1037         fileout << FLATDATA(pchMessageStart) << nSize;
1038
1039         // Write block
1040         long fileOutPos = ftell(fileout);
1041         if (fileOutPos < 0)
1042             return error("CBlock::WriteToDisk() : ftell failed");
1043         nBlockPosRet = fileOutPos;
1044         fileout << *this;
1045
1046         // Flush stdio buffers and commit to disk before returning
1047         fflush(fileout);
1048         if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1049             FileCommit(fileout);
1050
1051         return true;
1052     }
1053
1054     bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1055     {
1056         SetNull();
1057
1058         // Open history file to read
1059         CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1060         if (!filein)
1061             return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1062         if (!fReadTransactions)
1063             filein.nType |= SER_BLOCKHEADERONLY;
1064
1065         // Read block
1066         try {
1067             filein >> *this;
1068         }
1069         catch (std::exception &e) {
1070             return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1071         }
1072
1073         // Check the header
1074         if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1075             return error("CBlock::ReadFromDisk() : errors in block header");
1076
1077         return true;
1078     }
1079
1080
1081
1082     void print() const
1083     {
1084         printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu", vchBlockSig=%s)\n",
1085             GetHash().ToString().c_str(),
1086             nVersion,
1087             hashPrevBlock.ToString().c_str(),
1088             hashMerkleRoot.ToString().c_str(),
1089             nTime, nBits, nNonce,
1090             vtx.size(),
1091             HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1092         for (unsigned int i = 0; i < vtx.size(); i++)
1093         {
1094             printf("  ");
1095             vtx[i].print();
1096         }
1097         printf("  vMerkleTree: ");
1098         for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1099             printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1100         printf("\n");
1101     }
1102
1103
1104     bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1105     bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1106     bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1107     bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1108     bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1109     bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1110     bool AcceptBlock();
1111     bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1112     bool SignBlock(const CKeyStore& keystore);
1113     bool CheckBlockSignature(bool fProofOfStake) const;
1114
1115 private:
1116     bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1117 };
1118
1119
1120
1121
1122
1123
1124 /** The block chain is a tree shaped structure starting with the
1125  * genesis block at the root, with each block potentially having multiple
1126  * candidates to be the next block.  pprev and pnext link a path through the
1127  * main/longest chain.  A blockindex may have multiple pprev pointing back
1128  * to it, but pnext will only point forward to the longest branch, or will
1129  * be null if the block is not part of the longest chain.
1130  */
1131 class CBlockIndex
1132 {
1133 public:
1134     const uint256* phashBlock;
1135     CBlockIndex* pprev;
1136     CBlockIndex* pnext;
1137     unsigned int nFile;
1138     unsigned int nBlockPos;
1139     uint256 nChainTrust; // ppcoin: trust score of block chain
1140     int nHeight;
1141
1142     int64 nMint;
1143     int64 nMoneySupply;
1144
1145     unsigned int nFlags;  // ppcoin: block index flags
1146     enum
1147     {
1148         BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1149         BLOCK_STAKE_ENTROPY  = (1 << 1), // entropy bit for stake modifier
1150         BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1151     };
1152
1153     uint64 nStakeModifier; // hash modifier for proof-of-stake
1154     unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1155
1156     // proof-of-stake specific fields
1157     COutPoint prevoutStake;
1158     unsigned int nStakeTime;
1159     uint256 hashProofOfStake;
1160
1161     // block header
1162     int nVersion;
1163     uint256 hashMerkleRoot;
1164     unsigned int nTime;
1165     unsigned int nBits;
1166     unsigned int nNonce;
1167
1168     CBlockIndex()
1169     {
1170         phashBlock = NULL;
1171         pprev = NULL;
1172         pnext = NULL;
1173         nFile = 0;
1174         nBlockPos = 0;
1175         nHeight = 0;
1176         nChainTrust = 0;
1177         nMint = 0;
1178         nMoneySupply = 0;
1179         nFlags = 0;
1180         nStakeModifier = 0;
1181         nStakeModifierChecksum = 0;
1182         hashProofOfStake = 0;
1183         prevoutStake.SetNull();
1184         nStakeTime = 0;
1185
1186         nVersion       = 0;
1187         hashMerkleRoot = 0;
1188         nTime          = 0;
1189         nBits          = 0;
1190         nNonce         = 0;
1191     }
1192
1193     CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1194     {
1195         phashBlock = NULL;
1196         pprev = NULL;
1197         pnext = NULL;
1198         nFile = nFileIn;
1199         nBlockPos = nBlockPosIn;
1200         nHeight = 0;
1201         nChainTrust = 0;
1202         nMint = 0;
1203         nMoneySupply = 0;
1204         nFlags = 0;
1205         nStakeModifier = 0;
1206         nStakeModifierChecksum = 0;
1207         hashProofOfStake = 0;
1208         if (block.IsProofOfStake())
1209         {
1210             SetProofOfStake();
1211             prevoutStake = block.vtx[1].vin[0].prevout;
1212             nStakeTime = block.vtx[1].nTime;
1213         }
1214         else
1215         {
1216             prevoutStake.SetNull();
1217             nStakeTime = 0;
1218         }
1219
1220         nVersion       = block.nVersion;
1221         hashMerkleRoot = block.hashMerkleRoot;
1222         nTime          = block.nTime;
1223         nBits          = block.nBits;
1224         nNonce         = block.nNonce;
1225     }
1226
1227     CBlock GetBlockHeader() const
1228     {
1229         CBlock block;
1230         block.nVersion       = nVersion;
1231         if (pprev)
1232             block.hashPrevBlock = pprev->GetBlockHash();
1233         block.hashMerkleRoot = hashMerkleRoot;
1234         block.nTime          = nTime;
1235         block.nBits          = nBits;
1236         block.nNonce         = nNonce;
1237         return block;
1238     }
1239
1240     uint256 GetBlockHash() const
1241     {
1242         return *phashBlock;
1243     }
1244
1245     int64 GetBlockTime() const
1246     {
1247         return (int64)nTime;
1248     }
1249
1250     uint256 GetBlockTrust() const;
1251
1252     bool IsInMainChain() const
1253     {
1254         return (pnext || this == pindexBest);
1255     }
1256
1257     bool CheckIndex() const
1258     {
1259         return true;
1260     }
1261
1262     enum { nMedianTimeSpan=11 };
1263
1264     int64 GetMedianTimePast() const
1265     {
1266         int64 pmedian[nMedianTimeSpan];
1267         int64* pbegin = &pmedian[nMedianTimeSpan];
1268         int64* pend = &pmedian[nMedianTimeSpan];
1269
1270         const CBlockIndex* pindex = this;
1271         for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1272             *(--pbegin) = pindex->GetBlockTime();
1273
1274         std::sort(pbegin, pend);
1275         return pbegin[(pend - pbegin)/2];
1276     }
1277
1278     int64 GetMedianTime() const
1279     {
1280         const CBlockIndex* pindex = this;
1281         for (int i = 0; i < nMedianTimeSpan/2; i++)
1282         {
1283             if (!pindex->pnext)
1284                 return GetBlockTime();
1285             pindex = pindex->pnext;
1286         }
1287         return pindex->GetMedianTimePast();
1288     }
1289
1290     /**
1291      * Returns true if there are nRequired or more blocks of minVersion or above
1292      * in the last nToCheck blocks, starting at pstart and going backwards.
1293      */
1294     static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1295                                 unsigned int nRequired, unsigned int nToCheck);
1296
1297
1298     bool IsProofOfWork() const
1299     {
1300         return !(nFlags & BLOCK_PROOF_OF_STAKE);
1301     }
1302
1303     bool IsProofOfStake() const
1304     {
1305         return (nFlags & BLOCK_PROOF_OF_STAKE);
1306     }
1307
1308     void SetProofOfStake()
1309     {
1310         nFlags |= BLOCK_PROOF_OF_STAKE;
1311     }
1312
1313     unsigned int GetStakeEntropyBit() const
1314     {
1315         return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1316     }
1317
1318     bool SetStakeEntropyBit(unsigned int nEntropyBit)
1319     {
1320         if (nEntropyBit > 1)
1321             return false;
1322         nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1323         return true;
1324     }
1325
1326     bool GeneratedStakeModifier() const
1327     {
1328         return (nFlags & BLOCK_STAKE_MODIFIER);
1329     }
1330
1331     void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1332     {
1333         nStakeModifier = nModifier;
1334         if (fGeneratedStakeModifier)
1335             nFlags |= BLOCK_STAKE_MODIFIER;
1336     }
1337
1338     std::string ToString() const
1339     {
1340         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)",
1341             pprev, pnext, nFile, nBlockPos, nHeight,
1342             FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1343             GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1344             nStakeModifier, nStakeModifierChecksum,
1345             hashProofOfStake.ToString().c_str(),
1346             prevoutStake.ToString().c_str(), nStakeTime,
1347             hashMerkleRoot.ToString().c_str(),
1348             GetBlockHash().ToString().c_str());
1349     }
1350
1351     void print() const
1352     {
1353         printf("%s\n", ToString().c_str());
1354     }
1355 };
1356
1357
1358
1359 /** Used to marshal pointers into hashes for db storage. */
1360 class CDiskBlockIndex : public CBlockIndex
1361 {
1362 public:
1363     uint256 hashPrev;
1364     uint256 hashNext;
1365
1366     CDiskBlockIndex()
1367     {
1368         hashPrev = 0;
1369         hashNext = 0;
1370     }
1371
1372     explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1373     {
1374         hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1375         hashNext = (pnext ? pnext->GetBlockHash() : 0);
1376     }
1377
1378     IMPLEMENT_SERIALIZE
1379     (
1380         if (!(nType & SER_GETHASH))
1381             READWRITE(nVersion);
1382
1383         READWRITE(hashNext);
1384         READWRITE(nFile);
1385         READWRITE(nBlockPos);
1386         READWRITE(nHeight);
1387         READWRITE(nMint);
1388         READWRITE(nMoneySupply);
1389         READWRITE(nFlags);
1390         READWRITE(nStakeModifier);
1391         if (IsProofOfStake())
1392         {
1393             READWRITE(prevoutStake);
1394             READWRITE(nStakeTime);
1395             READWRITE(hashProofOfStake);
1396         }
1397         else if (fRead)
1398         {
1399             const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1400             const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1401             const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1402         }
1403
1404         // block header
1405         READWRITE(this->nVersion);
1406         READWRITE(hashPrev);
1407         READWRITE(hashMerkleRoot);
1408         READWRITE(nTime);
1409         READWRITE(nBits);
1410         READWRITE(nNonce);
1411     )
1412
1413     uint256 GetBlockHash() const
1414     {
1415         CBlock block;
1416         block.nVersion        = nVersion;
1417         block.hashPrevBlock   = hashPrev;
1418         block.hashMerkleRoot  = hashMerkleRoot;
1419         block.nTime           = nTime;
1420         block.nBits           = nBits;
1421         block.nNonce          = nNonce;
1422         return block.GetHash();
1423     }
1424
1425
1426     std::string ToString() const
1427     {
1428         std::string str = "CDiskBlockIndex(";
1429         str += CBlockIndex::ToString();
1430         str += strprintf("\n                hashBlock=%s, hashPrev=%s, hashNext=%s)",
1431             GetBlockHash().ToString().c_str(),
1432             hashPrev.ToString().c_str(),
1433             hashNext.ToString().c_str());
1434         return str;
1435     }
1436
1437     void print() const
1438     {
1439         printf("%s\n", ToString().c_str());
1440     }
1441 };
1442
1443
1444
1445
1446
1447
1448
1449
1450 /** Describes a place in the block chain to another node such that if the
1451  * other node doesn't have the same branch, it can find a recent common trunk.
1452  * The further back it is, the further before the fork it may be.
1453  */
1454 class CBlockLocator
1455 {
1456 protected:
1457     std::vector<uint256> vHave;
1458 public:
1459
1460     CBlockLocator()
1461     {
1462     }
1463
1464     explicit CBlockLocator(const CBlockIndex* pindex)
1465     {
1466         Set(pindex);
1467     }
1468
1469     explicit CBlockLocator(uint256 hashBlock)
1470     {
1471         std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1472         if (mi != mapBlockIndex.end())
1473             Set((*mi).second);
1474     }
1475
1476     CBlockLocator(const std::vector<uint256>& vHaveIn)
1477     {
1478         vHave = vHaveIn;
1479     }
1480
1481     IMPLEMENT_SERIALIZE
1482     (
1483         if (!(nType & SER_GETHASH))
1484             READWRITE(nVersion);
1485         READWRITE(vHave);
1486     )
1487
1488     void SetNull()
1489     {
1490         vHave.clear();
1491     }
1492
1493     bool IsNull()
1494     {
1495         return vHave.empty();
1496     }
1497
1498     void Set(const CBlockIndex* pindex)
1499     {
1500         vHave.clear();
1501         int nStep = 1;
1502         while (pindex)
1503         {
1504             vHave.push_back(pindex->GetBlockHash());
1505
1506             // Exponentially larger steps back
1507             for (int i = 0; pindex && i < nStep; i++)
1508                 pindex = pindex->pprev;
1509             if (vHave.size() > 10)
1510                 nStep *= 2;
1511         }
1512         vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1513     }
1514
1515     int GetDistanceBack()
1516     {
1517         // Retrace how far back it was in the sender's branch
1518         int nDistance = 0;
1519         int nStep = 1;
1520         BOOST_FOREACH(const uint256& hash, vHave)
1521         {
1522             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1523             if (mi != mapBlockIndex.end())
1524             {
1525                 CBlockIndex* pindex = (*mi).second;
1526                 if (pindex->IsInMainChain())
1527                     return nDistance;
1528             }
1529             nDistance += nStep;
1530             if (nDistance > 10)
1531                 nStep *= 2;
1532         }
1533         return nDistance;
1534     }
1535
1536     CBlockIndex* GetBlockIndex()
1537     {
1538         // Find the first block the caller has in the main chain
1539         BOOST_FOREACH(const uint256& hash, vHave)
1540         {
1541             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1542             if (mi != mapBlockIndex.end())
1543             {
1544                 CBlockIndex* pindex = (*mi).second;
1545                 if (pindex->IsInMainChain())
1546                     return pindex;
1547             }
1548         }
1549         return pindexGenesisBlock;
1550     }
1551
1552     uint256 GetBlockHash()
1553     {
1554         // Find the first block the caller has in the main chain
1555         BOOST_FOREACH(const uint256& hash, vHave)
1556         {
1557             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1558             if (mi != mapBlockIndex.end())
1559             {
1560                 CBlockIndex* pindex = (*mi).second;
1561                 if (pindex->IsInMainChain())
1562                     return hash;
1563             }
1564         }
1565         return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1566     }
1567
1568     int GetHeight()
1569     {
1570         CBlockIndex* pindex = GetBlockIndex();
1571         if (!pindex)
1572             return 0;
1573         return pindex->nHeight;
1574     }
1575 };
1576
1577
1578
1579
1580
1581
1582
1583
1584 class CTxMemPool
1585 {
1586 public:
1587     mutable CCriticalSection cs;
1588     std::map<uint256, CTransaction> mapTx;
1589     std::map<COutPoint, CInPoint> mapNextTx;
1590
1591     bool accept(CTxDB& txdb, CTransaction &tx,
1592                 bool fCheckInputs, bool* pfMissingInputs);
1593     bool addUnchecked(const uint256& hash, CTransaction &tx);
1594     bool remove(CTransaction &tx);
1595     void clear();
1596     void queryHashes(std::vector<uint256>& vtxid);
1597
1598     unsigned long size()
1599     {
1600         LOCK(cs);
1601         return mapTx.size();
1602     }
1603
1604     bool exists(uint256 hash)
1605     {
1606         return (mapTx.count(hash) != 0);
1607     }
1608
1609     CTransaction& lookup(uint256 hash)
1610     {
1611         return mapTx[hash];
1612     }
1613 };
1614
1615 extern CTxMemPool mempool;
1616
1617 #endif