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