src/main.h

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