raw
genesis                 1 // Copyright (c) 2009-2010 Satoshi Nakamoto
genesis                 2 // Copyright (c) 2009-2012 The Bitcoin developers
genesis                 3 // Distributed under the MIT/X11 software license, see the accompanying
genesis                 4 // file license.txt or http://www.opensource.org/licenses/mit-license.php.
genesis                 5 #ifndef BITCOIN_MAIN_H
genesis                 6 #define BITCOIN_MAIN_H
genesis                 7 
genesis                 8 #include "bignum.h"
genesis                 9 #include "net.h"
genesis                10 #include "key.h"
genesis                11 #include "script.h"
genesis                12 #include "db.h"
genesis                13 
genesis                14 #include <list>
genesis                15 
genesis                16 class CBlock;
genesis                17 class CBlockIndex;
genesis                18 class CWalletTx;
genesis                19 class CWallet;
genesis                20 class CKeyItem;
genesis                21 class CReserveKey;
genesis                22 class CWalletDB;
genesis                23 
genesis                24 class CAddress;
genesis                25 class CInv;
genesis                26 class CRequestTracker;
genesis                27 class CNode;
genesis                28 class CBlockIndex;
genesis                29 
genesis                30 static const unsigned int MAX_BLOCK_SIZE = 1000000;
genesis                31 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
genesis                32 static const int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
genesis                33 static const int64 COIN = 100000000;
genesis                34 static const int64 CENT = 1000000;
genesis                35 static const int64 MIN_TX_FEE = 50000;
genesis                36 static const int64 MIN_RELAY_TX_FEE = 10000;
genesis                37 static const int64 MAX_MONEY = 21000000 * COIN;
genesis                38 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
genesis                39 static const int COINBASE_MATURITY = 100;
genesis                40 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
genesis                41 static const int LOCKTIME_THRESHOLD = 500000000; // Tue Nov  5 00:53:20 1985 UTC
genesis                42 
genesis                43 
genesis                44 
genesis                45 
genesis                46 
genesis                47 
genesis                48 extern CCriticalSection cs_main;
genesis                49 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
genesis                50 extern uint256 hashGenesisBlock;
genesis                51 extern CBlockIndex* pindexGenesisBlock;
genesis                52 extern int nBestHeight;
genesis                53 extern CBigNum bnBestChainWork;
genesis                54 extern CBigNum bnBestInvalidWork;
genesis                55 extern uint256 hashBestChain;
genesis                56 extern CBlockIndex* pindexBest;
genesis                57 extern unsigned int nTransactionsUpdated;
genesis                58 extern double dHashesPerSec;
genesis                59 extern int64 nHPSTimerStart;
genesis                60 extern int64 nTimeBestReceived;
genesis                61 extern CCriticalSection cs_setpwalletRegistered;
genesis                62 extern std::set<CWallet*> setpwalletRegistered;
genesis                63 
genesis                64 // Settings
genesis                65 extern int fGenerateBitcoins;
genesis                66 extern int64 nTransactionFee;
genesis                67 extern int fLimitProcessors;
genesis                68 extern int nLimitProcessors;
genesis                69 extern int fMinimizeToTray;
genesis                70 extern int fMinimizeOnClose;
genesis                71 
genesis                72 
genesis                73 
genesis                74 
genesis                75 
genesis                76 class CReserveKey;
genesis                77 class CTxDB;
genesis                78 class CTxIndex;
genesis                79 
genesis                80 void RegisterWallet(CWallet* pwalletIn);
genesis                81 void UnregisterWallet(CWallet* pwalletIn);
genesis                82 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
genesis                83 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
genesis                84 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
genesis                85 FILE* AppendBlockFile(unsigned int& nFileRet);
genesis                86 bool LoadBlockIndex(bool fAllowNew=true);
genesis                87 void PrintBlockTree();
genesis                88 bool ProcessMessages(CNode* pfrom);
genesis                89 bool SendMessages(CNode* pto, bool fSendTrickle);
genesis                90 void GenerateBitcoins(bool fGenerate, CWallet* pwallet);
genesis                91 CBlock* CreateNewBlock(CReserveKey& reservekey);
genesis                92 void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
genesis                93 void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
genesis                94 bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
genesis                95 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
genesis                96 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
genesis                97 int GetNumBlocksOfPeers();
genesis                98 bool IsInitialBlockDownload();
genesis                99 std::string GetWarnings(std::string strFor);
genesis               100 
genesis               101 
genesis               102 
genesis               103 
genesis               104 
genesis               105 
genesis               106 
genesis               107 
genesis               108 
genesis               109 
genesis               110 
genesis               111 
genesis               112 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
genesis               113 
genesis               114 template<typename T>
genesis               115 bool WriteSetting(const std::string& strKey, const T& value)
genesis               116 {
genesis               117     bool fOk = false;
genesis               118     BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
genesis               119     {
genesis               120         std::string strWalletFile;
genesis               121         if (!GetWalletFile(pwallet, strWalletFile))
genesis               122             continue;
genesis               123         fOk |= CWalletDB(strWalletFile).WriteSetting(strKey, value);
genesis               124     }
genesis               125     return fOk;
genesis               126 }
genesis               127 
genesis               128 
genesis               129 class CDiskTxPos
genesis               130 {
genesis               131 public:
genesis               132     unsigned int nFile;
genesis               133     unsigned int nBlockPos;
genesis               134     unsigned int nTxPos;
genesis               135 
genesis               136     CDiskTxPos()
genesis               137     {
genesis               138         SetNull();
genesis               139     }
genesis               140 
genesis               141     CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
genesis               142     {
genesis               143         nFile = nFileIn;
genesis               144         nBlockPos = nBlockPosIn;
genesis               145         nTxPos = nTxPosIn;
genesis               146     }
genesis               147 
genesis               148     IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
genesis               149     void SetNull() { nFile = -1; nBlockPos = 0; nTxPos = 0; }
genesis               150     bool IsNull() const { return (nFile == -1); }
genesis               151 
genesis               152     friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
genesis               153     {
genesis               154         return (a.nFile     == b.nFile &&
genesis               155                 a.nBlockPos == b.nBlockPos &&
genesis               156                 a.nTxPos    == b.nTxPos);
genesis               157     }
genesis               158 
genesis               159     friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
genesis               160     {
genesis               161         return !(a == b);
genesis               162     }
genesis               163 
genesis               164     std::string ToString() const
genesis               165     {
genesis               166         if (IsNull())
genesis               167             return strprintf("null");
genesis               168         else
genesis               169             return strprintf("(nFile=%d, nBlockPos=%d, nTxPos=%d)", nFile, nBlockPos, nTxPos);
genesis               170     }
genesis               171 
genesis               172     void print() const
genesis               173     {
genesis               174         printf("%s", ToString().c_str());
genesis               175     }
genesis               176 };
genesis               177 
genesis               178 
genesis               179 
genesis               180 
genesis               181 class CInPoint
genesis               182 {
genesis               183 public:
genesis               184     CTransaction* ptx;
genesis               185     unsigned int n;
genesis               186 
genesis               187     CInPoint() { SetNull(); }
genesis               188     CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
genesis               189     void SetNull() { ptx = NULL; n = -1; }
genesis               190     bool IsNull() const { return (ptx == NULL && n == -1); }
genesis               191 };
genesis               192 
genesis               193 
genesis               194 
genesis               195 
genesis               196 class COutPoint
genesis               197 {
genesis               198 public:
genesis               199     uint256 hash;
genesis               200     unsigned int n;
genesis               201 
genesis               202     COutPoint() { SetNull(); }
genesis               203     COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
genesis               204     IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
genesis               205     void SetNull() { hash = 0; n = -1; }
genesis               206     bool IsNull() const { return (hash == 0 && n == -1); }
genesis               207 
genesis               208     friend bool operator<(const COutPoint& a, const COutPoint& b)
genesis               209     {
genesis               210         return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
genesis               211     }
genesis               212 
genesis               213     friend bool operator==(const COutPoint& a, const COutPoint& b)
genesis               214     {
genesis               215         return (a.hash == b.hash && a.n == b.n);
genesis               216     }
genesis               217 
genesis               218     friend bool operator!=(const COutPoint& a, const COutPoint& b)
genesis               219     {
genesis               220         return !(a == b);
genesis               221     }
genesis               222 
genesis               223     std::string ToString() const
genesis               224     {
ben_vulpes_excise...  225         return strprintf("COutPoint(%s, %d)", hash.ToString().c_str(), n);
genesis               226     }
genesis               227 
genesis               228     void print() const
genesis               229     {
genesis               230         printf("%s\n", ToString().c_str());
genesis               231     }
genesis               232 };
genesis               233 
genesis               234 
genesis               235 
genesis               236 
genesis               237 //
genesis               238 // An input of a transaction.  It contains the location of the previous
genesis               239 // transaction's output that it claims and a signature that matches the
genesis               240 // output's public key.
genesis               241 //
genesis               242 class CTxIn
genesis               243 {
genesis               244 public:
genesis               245     COutPoint prevout;
genesis               246     CScript scriptSig;
genesis               247     unsigned int nSequence;
genesis               248 
genesis               249     CTxIn()
genesis               250     {
genesis               251         nSequence = UINT_MAX;
genesis               252     }
genesis               253 
genesis               254     explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=UINT_MAX)
genesis               255     {
genesis               256         prevout = prevoutIn;
genesis               257         scriptSig = scriptSigIn;
genesis               258         nSequence = nSequenceIn;
genesis               259     }
genesis               260 
genesis               261     CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=UINT_MAX)
genesis               262     {
genesis               263         prevout = COutPoint(hashPrevTx, nOut);
genesis               264         scriptSig = scriptSigIn;
genesis               265         nSequence = nSequenceIn;
genesis               266     }
genesis               267 
genesis               268     IMPLEMENT_SERIALIZE
genesis               269     (
genesis               270         READWRITE(prevout);
genesis               271         READWRITE(scriptSig);
genesis               272         READWRITE(nSequence);
genesis               273     )
genesis               274 
genesis               275     bool IsFinal() const
genesis               276     {
genesis               277         return (nSequence == UINT_MAX);
genesis               278     }
genesis               279 
genesis               280     friend bool operator==(const CTxIn& a, const CTxIn& b)
genesis               281     {
genesis               282         return (a.prevout   == b.prevout &&
genesis               283                 a.scriptSig == b.scriptSig &&
genesis               284                 a.nSequence == b.nSequence);
genesis               285     }
genesis               286 
genesis               287     friend bool operator!=(const CTxIn& a, const CTxIn& b)
genesis               288     {
genesis               289         return !(a == b);
genesis               290     }
genesis               291 
genesis               292     std::string ToString() const
genesis               293     {
genesis               294         std::string str;
genesis               295         str += strprintf("CTxIn(");
genesis               296         str += prevout.ToString();
genesis               297         if (prevout.IsNull())
genesis               298             str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
genesis               299         else
ben_vulpes_excise...  300             str += strprintf(", scriptSig=%s", scriptSig.ToString().c_str());
genesis               301         if (nSequence != UINT_MAX)
genesis               302             str += strprintf(", nSequence=%u", nSequence);
genesis               303         str += ")";
genesis               304         return str;
genesis               305     }
genesis               306 
genesis               307     void print() const
genesis               308     {
genesis               309         printf("%s\n", ToString().c_str());
genesis               310     }
genesis               311 };
genesis               312 
genesis               313 
genesis               314 
genesis               315 
genesis               316 //
genesis               317 // An output of a transaction.  It contains the public key that the next input
genesis               318 // must be able to sign with to claim it.
genesis               319 //
genesis               320 class CTxOut
genesis               321 {
genesis               322 public:
genesis               323     int64 nValue;
genesis               324     CScript scriptPubKey;
genesis               325 
genesis               326     CTxOut()
genesis               327     {
genesis               328         SetNull();
genesis               329     }
genesis               330 
genesis               331     CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
genesis               332     {
genesis               333         nValue = nValueIn;
genesis               334         scriptPubKey = scriptPubKeyIn;
genesis               335     }
genesis               336 
genesis               337     IMPLEMENT_SERIALIZE
genesis               338     (
genesis               339         READWRITE(nValue);
genesis               340         READWRITE(scriptPubKey);
genesis               341     )
genesis               342 
genesis               343     void SetNull()
genesis               344     {
genesis               345         nValue = -1;
genesis               346         scriptPubKey.clear();
genesis               347     }
genesis               348 
genesis               349     bool IsNull()
genesis               350     {
genesis               351         return (nValue == -1);
genesis               352     }
genesis               353 
genesis               354     uint256 GetHash() const
genesis               355     {
genesis               356         return SerializeHash(*this);
genesis               357     }
genesis               358 
genesis               359     friend bool operator==(const CTxOut& a, const CTxOut& b)
genesis               360     {
genesis               361         return (a.nValue       == b.nValue &&
genesis               362                 a.scriptPubKey == b.scriptPubKey);
genesis               363     }
genesis               364 
genesis               365     friend bool operator!=(const CTxOut& a, const CTxOut& b)
genesis               366     {
genesis               367         return !(a == b);
genesis               368     }
genesis               369 
genesis               370     std::string ToString() const
genesis               371     {
genesis               372         if (scriptPubKey.size() < 6)
genesis               373             return "CTxOut(error)";
ben_vulpes_excise...  374         return strprintf("CTxOut(nValue=%"PRI64d".%08"PRI64d", scriptPubKey=%s)", nValue / COIN, nValue % COIN, scriptPubKey.ToString().c_str());
genesis               375     }
genesis               376 
genesis               377     void print() const
genesis               378     {
genesis               379         printf("%s\n", ToString().c_str());
genesis               380     }
genesis               381 };
genesis               382 
genesis               383 
genesis               384 
genesis               385 
genesis               386 //
genesis               387 // The basic transaction that is broadcasted on the network and contained in
genesis               388 // blocks.  A transaction can contain multiple inputs and outputs.
genesis               389 //
genesis               390 class CTransaction
genesis               391 {
genesis               392 public:
genesis               393     int nVersion;
genesis               394     std::vector<CTxIn> vin;
genesis               395     std::vector<CTxOut> vout;
genesis               396     unsigned int nLockTime;
genesis               397 
genesis               398     // Denial-of-service detection:
genesis               399     mutable int nDoS;
genesis               400     bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
genesis               401 
genesis               402     CTransaction()
genesis               403     {
genesis               404         SetNull();
genesis               405     }
genesis               406 
genesis               407     IMPLEMENT_SERIALIZE
genesis               408     (
genesis               409         READWRITE(this->nVersion);
genesis               410         nVersion = this->nVersion;
genesis               411         READWRITE(vin);
genesis               412         READWRITE(vout);
genesis               413         READWRITE(nLockTime);
genesis               414     )
genesis               415 
genesis               416     void SetNull()
genesis               417     {
genesis               418         nVersion = 1;
genesis               419         vin.clear();
genesis               420         vout.clear();
genesis               421         nLockTime = 0;
genesis               422         nDoS = 0;  // Denial-of-service prevention
genesis               423     }
genesis               424 
genesis               425     bool IsNull() const
genesis               426     {
genesis               427         return (vin.empty() && vout.empty());
genesis               428     }
genesis               429 
genesis               430     uint256 GetHash() const
genesis               431     {
genesis               432         return SerializeHash(*this);
genesis               433     }
genesis               434 
genesis               435     bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
genesis               436     {
genesis               437         // Time based nLockTime implemented in 0.1.6
genesis               438         if (nLockTime == 0)
genesis               439             return true;
genesis               440         if (nBlockHeight == 0)
genesis               441             nBlockHeight = nBestHeight;
genesis               442         if (nBlockTime == 0)
genesis               443             nBlockTime = GetAdjustedTime();
genesis               444         if ((int64)nLockTime < (nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
genesis               445             return true;
genesis               446         BOOST_FOREACH(const CTxIn& txin, vin)
genesis               447             if (!txin.IsFinal())
genesis               448                 return false;
genesis               449         return true;
genesis               450     }
genesis               451 
genesis               452     bool IsNewerThan(const CTransaction& old) const
genesis               453     {
genesis               454         if (vin.size() != old.vin.size())
genesis               455             return false;
genesis               456         for (int i = 0; i < vin.size(); i++)
genesis               457             if (vin[i].prevout != old.vin[i].prevout)
genesis               458                 return false;
genesis               459 
genesis               460         bool fNewer = false;
genesis               461         unsigned int nLowest = UINT_MAX;
genesis               462         for (int i = 0; i < vin.size(); i++)
genesis               463         {
genesis               464             if (vin[i].nSequence != old.vin[i].nSequence)
genesis               465             {
genesis               466                 if (vin[i].nSequence <= nLowest)
genesis               467                 {
genesis               468                     fNewer = false;
genesis               469                     nLowest = vin[i].nSequence;
genesis               470                 }
genesis               471                 if (old.vin[i].nSequence < nLowest)
genesis               472                 {
genesis               473                     fNewer = true;
genesis               474                     nLowest = old.vin[i].nSequence;
genesis               475                 }
genesis               476             }
genesis               477         }
genesis               478         return fNewer;
genesis               479     }
genesis               480 
genesis               481     bool IsCoinBase() const
genesis               482     {
genesis               483         return (vin.size() == 1 && vin[0].prevout.IsNull());
genesis               484     }
genesis               485 
genesis               486     int GetSigOpCount() const
genesis               487     {
genesis               488         int n = 0;
genesis               489         BOOST_FOREACH(const CTxIn& txin, vin)
genesis               490             n += txin.scriptSig.GetSigOpCount();
genesis               491         BOOST_FOREACH(const CTxOut& txout, vout)
genesis               492             n += txout.scriptPubKey.GetSigOpCount();
genesis               493         return n;
genesis               494     }
genesis               495 
genesis               496     bool IsStandard() const
genesis               497     {
genesis               498         BOOST_FOREACH(const CTxIn& txin, vin)
genesis               499             if (!txin.scriptSig.IsPushOnly())
genesis               500                 return error("nonstandard txin: %s", txin.scriptSig.ToString().c_str());
genesis               501         BOOST_FOREACH(const CTxOut& txout, vout)
genesis               502             if (!::IsStandard(txout.scriptPubKey))
genesis               503                 return error("nonstandard txout: %s", txout.scriptPubKey.ToString().c_str());
genesis               504         return true;
genesis               505     }
genesis               506 
genesis               507     int64 GetValueOut() const
genesis               508     {
genesis               509         int64 nValueOut = 0;
genesis               510         BOOST_FOREACH(const CTxOut& txout, vout)
genesis               511         {
genesis               512             nValueOut += txout.nValue;
genesis               513             if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
genesis               514                 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
genesis               515         }
genesis               516         return nValueOut;
genesis               517     }
genesis               518 
genesis               519     static bool AllowFree(double dPriority)
genesis               520     {
genesis               521         // Large (in bytes) low-priority (new, small-coin) transactions
genesis               522         // need a fee.
genesis               523         return dPriority > COIN * 144 / 250;
genesis               524     }
genesis               525 
genesis               526     int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=true, bool fForRelay=false) const
genesis               527     {
genesis               528         // Base fee is either MIN_TX_FEE or MIN_RELAY_TX_FEE
genesis               529         int64 nBaseFee = fForRelay ? MIN_RELAY_TX_FEE : MIN_TX_FEE;
genesis               530 
genesis               531         unsigned int nBytes = ::GetSerializeSize(*this, SER_NETWORK);
genesis               532         unsigned int nNewBlockSize = nBlockSize + nBytes;
genesis               533         int64 nMinFee = (1 + (int64)nBytes / 1000) * nBaseFee;
genesis               534 
genesis               535         if (fAllowFree)
genesis               536         {
genesis               537             if (nBlockSize == 1)
genesis               538             {
genesis               539                 // Transactions under 10K are free
genesis               540                 // (about 4500bc if made of 50bc inputs)
genesis               541                 if (nBytes < 10000)
genesis               542                     nMinFee = 0;
genesis               543             }
genesis               544             else
genesis               545             {
genesis               546                 // Free transaction area
genesis               547                 if (nNewBlockSize < 27000)
genesis               548                     nMinFee = 0;
genesis               549             }
genesis               550         }
genesis               551 
genesis               552         // To limit dust spam, require MIN_TX_FEE/MIN_RELAY_TX_FEE if any output is less than 0.01
genesis               553         if (nMinFee < nBaseFee)
genesis               554             BOOST_FOREACH(const CTxOut& txout, vout)
genesis               555                 if (txout.nValue < CENT)
genesis               556                     nMinFee = nBaseFee;
genesis               557 
genesis               558         // Raise the price as the block approaches full
genesis               559         if (nBlockSize != 1 && nNewBlockSize >= MAX_BLOCK_SIZE_GEN/2)
genesis               560         {
genesis               561             if (nNewBlockSize >= MAX_BLOCK_SIZE_GEN)
genesis               562                 return MAX_MONEY;
genesis               563             nMinFee *= MAX_BLOCK_SIZE_GEN / (MAX_BLOCK_SIZE_GEN - nNewBlockSize);
genesis               564         }
genesis               565 
genesis               566         if (!MoneyRange(nMinFee))
genesis               567             nMinFee = MAX_MONEY;
genesis               568         return nMinFee;
genesis               569     }
genesis               570 
genesis               571 
genesis               572     bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
genesis               573     {
genesis               574         CAutoFile filein = OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb");
genesis               575         if (!filein)
genesis               576             return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
genesis               577 
genesis               578         // Read transaction
genesis               579         if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
genesis               580             return error("CTransaction::ReadFromDisk() : fseek failed");
genesis               581         filein >> *this;
genesis               582 
genesis               583         // Return file pointer
genesis               584         if (pfileRet)
genesis               585         {
genesis               586             if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
genesis               587                 return error("CTransaction::ReadFromDisk() : second fseek failed");
genesis               588             *pfileRet = filein.release();
genesis               589         }
genesis               590         return true;
genesis               591     }
genesis               592 
genesis               593     friend bool operator==(const CTransaction& a, const CTransaction& b)
genesis               594     {
genesis               595         return (a.nVersion  == b.nVersion &&
genesis               596                 a.vin       == b.vin &&
genesis               597                 a.vout      == b.vout &&
genesis               598                 a.nLockTime == b.nLockTime);
genesis               599     }
genesis               600 
genesis               601     friend bool operator!=(const CTransaction& a, const CTransaction& b)
genesis               602     {
genesis               603         return !(a == b);
genesis               604     }
genesis               605 
genesis               606 
genesis               607     std::string ToString() const
genesis               608     {
genesis               609         std::string str;
genesis               610         str += strprintf("CTransaction(hash=%s, ver=%d, vin.size=%d, vout.size=%d, nLockTime=%d)\n",
ben_vulpes_excise...  611             GetHash().ToString().c_str(),
genesis               612             nVersion,
genesis               613             vin.size(),
genesis               614             vout.size(),
genesis               615             nLockTime);
genesis               616         for (int i = 0; i < vin.size(); i++)
genesis               617             str += "    " + vin[i].ToString() + "\n";
genesis               618         for (int i = 0; i < vout.size(); i++)
genesis               619             str += "    " + vout[i].ToString() + "\n";
genesis               620         return str;
genesis               621     }
genesis               622 
genesis               623     void print() const
genesis               624     {
genesis               625         printf("%s", ToString().c_str());
genesis               626     }
genesis               627 
genesis               628 
genesis               629     bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
genesis               630     bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
genesis               631     bool ReadFromDisk(COutPoint prevout);
genesis               632     bool DisconnectInputs(CTxDB& txdb);
genesis               633     bool ConnectInputs(CTxDB& txdb, std::map<uint256, CTxIndex>& mapTestPool, CDiskTxPos posThisTx,
genesis               634                        CBlockIndex* pindexBlock, int64& nFees, bool fBlock, bool fMiner, int64 nMinFee,
genesis               635                        bool& fInvalid);
genesis               636     bool ClientConnectInputs();
genesis               637     bool CheckTransaction() const;
genesis               638     bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
genesis               639     bool AcceptToMemoryPool(bool fCheckInputs=true, bool* pfMissingInputs=NULL);
genesis               640 protected:
genesis               641     bool AddToMemoryPoolUnchecked();
genesis               642 public:
genesis               643     bool RemoveFromMemoryPool();
genesis               644 };
genesis               645 
genesis               646 
genesis               647 
genesis               648 
genesis               649 
genesis               650 //
genesis               651 // A transaction with a merkle branch linking it to the block chain
genesis               652 //
genesis               653 class CMerkleTx : public CTransaction
genesis               654 {
genesis               655 public:
genesis               656     uint256 hashBlock;
genesis               657     std::vector<uint256> vMerkleBranch;
genesis               658     int nIndex;
genesis               659 
genesis               660     // memory only
genesis               661     mutable char fMerkleVerified;
genesis               662 
genesis               663 
genesis               664     CMerkleTx()
genesis               665     {
genesis               666         Init();
genesis               667     }
genesis               668 
genesis               669     CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
genesis               670     {
genesis               671         Init();
genesis               672     }
genesis               673 
genesis               674     void Init()
genesis               675     {
genesis               676         hashBlock = 0;
genesis               677         nIndex = -1;
genesis               678         fMerkleVerified = false;
genesis               679     }
genesis               680 
genesis               681 
genesis               682     IMPLEMENT_SERIALIZE
genesis               683     (
genesis               684         nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
genesis               685         nVersion = this->nVersion;
genesis               686         READWRITE(hashBlock);
genesis               687         READWRITE(vMerkleBranch);
genesis               688         READWRITE(nIndex);
genesis               689     )
genesis               690 
genesis               691 
genesis               692     int SetMerkleBranch(const CBlock* pblock=NULL);
genesis               693     int GetDepthInMainChain(int& nHeightRet) const;
genesis               694     int GetDepthInMainChain() const { int nHeight; return GetDepthInMainChain(nHeight); }
genesis               695     bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
genesis               696     int GetBlocksToMaturity() const;
genesis               697     bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
genesis               698     bool AcceptToMemoryPool();
genesis               699 };
genesis               700 
genesis               701 
genesis               702 
genesis               703 
genesis               704 //
genesis               705 // A txdb record that contains the disk location of a transaction and the
genesis               706 // locations of transactions that spend its outputs.  vSpent is really only
genesis               707 // used as a flag, but having the location is very helpful for debugging.
genesis               708 //
genesis               709 class CTxIndex
genesis               710 {
genesis               711 public:
genesis               712     CDiskTxPos pos;
genesis               713     std::vector<CDiskTxPos> vSpent;
genesis               714 
genesis               715     CTxIndex()
genesis               716     {
genesis               717         SetNull();
genesis               718     }
genesis               719 
genesis               720     CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
genesis               721     {
genesis               722         pos = posIn;
genesis               723         vSpent.resize(nOutputs);
genesis               724     }
genesis               725 
genesis               726     IMPLEMENT_SERIALIZE
genesis               727     (
genesis               728         if (!(nType & SER_GETHASH))
genesis               729             READWRITE(nVersion);
genesis               730         READWRITE(pos);
genesis               731         READWRITE(vSpent);
genesis               732     )
genesis               733 
genesis               734     void SetNull()
genesis               735     {
genesis               736         pos.SetNull();
genesis               737         vSpent.clear();
genesis               738     }
genesis               739 
genesis               740     bool IsNull()
genesis               741     {
genesis               742         return pos.IsNull();
genesis               743     }
genesis               744 
genesis               745     friend bool operator==(const CTxIndex& a, const CTxIndex& b)
genesis               746     {
genesis               747         return (a.pos    == b.pos &&
genesis               748                 a.vSpent == b.vSpent);
genesis               749     }
genesis               750 
genesis               751     friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
genesis               752     {
genesis               753         return !(a == b);
genesis               754     }
genesis               755     int GetDepthInMainChain() const;
genesis               756 };
genesis               757 
genesis               758 
genesis               759 
genesis               760 
genesis               761 
genesis               762 //
genesis               763 // Nodes collect new transactions into a block, hash them into a hash tree,
genesis               764 // and scan through nonce values to make the block's hash satisfy proof-of-work
genesis               765 // requirements.  When they solve the proof-of-work, they broadcast the block
genesis               766 // to everyone and the block is added to the block chain.  The first transaction
genesis               767 // in the block is a special one that creates a new coin owned by the creator
genesis               768 // of the block.
genesis               769 //
genesis               770 // Blocks are appended to blk0001.dat files on disk.  Their location on disk
genesis               771 // is indexed by CBlockIndex objects in memory.
genesis               772 //
genesis               773 class CBlock
genesis               774 {
genesis               775 public:
genesis               776     // header
genesis               777     int nVersion;
genesis               778     uint256 hashPrevBlock;
genesis               779     uint256 hashMerkleRoot;
genesis               780     unsigned int nTime;
genesis               781     unsigned int nBits;
genesis               782     unsigned int nNonce;
genesis               783 
genesis               784     // network and disk
genesis               785     std::vector<CTransaction> vtx;
genesis               786 
genesis               787     // memory only
genesis               788     mutable std::vector<uint256> vMerkleTree;
genesis               789 
genesis               790     // Denial-of-service detection:
genesis               791     mutable int nDoS;
genesis               792     bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
genesis               793 
genesis               794     CBlock()
genesis               795     {
genesis               796         SetNull();
genesis               797     }
genesis               798 
genesis               799     IMPLEMENT_SERIALIZE
genesis               800     (
genesis               801         READWRITE(this->nVersion);
genesis               802         nVersion = this->nVersion;
genesis               803         READWRITE(hashPrevBlock);
genesis               804         READWRITE(hashMerkleRoot);
genesis               805         READWRITE(nTime);
genesis               806         READWRITE(nBits);
genesis               807         READWRITE(nNonce);
genesis               808 
genesis               809         // ConnectBlock depends on vtx being last so it can calculate offset
genesis               810         if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
genesis               811             READWRITE(vtx);
genesis               812         else if (fRead)
genesis               813             const_cast<CBlock*>(this)->vtx.clear();
genesis               814     )
genesis               815 
genesis               816     void SetNull()
genesis               817     {
genesis               818         nVersion = 1;
genesis               819         hashPrevBlock = 0;
genesis               820         hashMerkleRoot = 0;
genesis               821         nTime = 0;
genesis               822         nBits = 0;
genesis               823         nNonce = 0;
genesis               824         vtx.clear();
genesis               825         vMerkleTree.clear();
genesis               826         nDoS = 0;
genesis               827     }
genesis               828 
genesis               829     bool IsNull() const
genesis               830     {
genesis               831         return (nBits == 0);
genesis               832     }
genesis               833 
genesis               834     uint256 GetHash() const
genesis               835     {
genesis               836         return Hash(BEGIN(nVersion), END(nNonce));
genesis               837     }
genesis               838 
genesis               839     int64 GetBlockTime() const
genesis               840     {
genesis               841         return (int64)nTime;
genesis               842     }
genesis               843 
genesis               844     int GetSigOpCount() const
genesis               845     {
genesis               846         int n = 0;
genesis               847         BOOST_FOREACH(const CTransaction& tx, vtx)
genesis               848             n += tx.GetSigOpCount();
genesis               849         return n;
genesis               850     }
genesis               851 
genesis               852 
genesis               853     uint256 BuildMerkleTree() const
genesis               854     {
genesis               855         vMerkleTree.clear();
genesis               856         BOOST_FOREACH(const CTransaction& tx, vtx)
genesis               857             vMerkleTree.push_back(tx.GetHash());
genesis               858         int j = 0;
genesis               859         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
genesis               860         {
genesis               861             for (int i = 0; i < nSize; i += 2)
genesis               862             {
genesis               863                 int i2 = std::min(i+1, nSize-1);
genesis               864                 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]),  END(vMerkleTree[j+i]),
genesis               865                                            BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
genesis               866             }
genesis               867             j += nSize;
genesis               868         }
genesis               869         return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
genesis               870     }
genesis               871 
genesis               872     std::vector<uint256> GetMerkleBranch(int nIndex) const
genesis               873     {
genesis               874         if (vMerkleTree.empty())
genesis               875             BuildMerkleTree();
genesis               876         std::vector<uint256> vMerkleBranch;
genesis               877         int j = 0;
genesis               878         for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
genesis               879         {
genesis               880             int i = std::min(nIndex^1, nSize-1);
genesis               881             vMerkleBranch.push_back(vMerkleTree[j+i]);
genesis               882             nIndex >>= 1;
genesis               883             j += nSize;
genesis               884         }
genesis               885         return vMerkleBranch;
genesis               886     }
genesis               887 
genesis               888     static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
genesis               889     {
genesis               890         if (nIndex == -1)
genesis               891             return 0;
genesis               892         BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
genesis               893         {
genesis               894             if (nIndex & 1)
genesis               895                 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
genesis               896             else
genesis               897                 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
genesis               898             nIndex >>= 1;
genesis               899         }
genesis               900         return hash;
genesis               901     }
genesis               902 
genesis               903 
genesis               904     bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
genesis               905     {
genesis               906         // Open history file to append
genesis               907         CAutoFile fileout = AppendBlockFile(nFileRet);
genesis               908         if (!fileout)
genesis               909             return error("CBlock::WriteToDisk() : AppendBlockFile failed");
genesis               910 
genesis               911         // Write index header
genesis               912         unsigned int nSize = fileout.GetSerializeSize(*this);
genesis               913         fileout << FLATDATA(pchMessageStart) << nSize;
genesis               914 
genesis               915         // Write block
genesis               916         nBlockPosRet = ftell(fileout);
genesis               917         if (nBlockPosRet == -1)
genesis               918             return error("CBlock::WriteToDisk() : ftell failed");
genesis               919         fileout << *this;
genesis               920 
genesis               921         // Flush stdio buffers and commit to disk before returning
genesis               922         fflush(fileout);
genesis               923         if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
genesis               924         {
genesis               925             fsync(fileno(fileout));
genesis               926         }
genesis               927 
genesis               928         return true;
genesis               929     }
genesis               930 
genesis               931     bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
genesis               932     {
genesis               933         SetNull();
genesis               934 
genesis               935         // Open history file to read
genesis               936         CAutoFile filein = OpenBlockFile(nFile, nBlockPos, "rb");
genesis               937         if (!filein)
genesis               938             return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
genesis               939         if (!fReadTransactions)
genesis               940             filein.nType |= SER_BLOCKHEADERONLY;
genesis               941 
genesis               942         // Read block
genesis               943         filein >> *this;
genesis               944 
genesis               945         // Check the header
genesis               946         if (!CheckProofOfWork(GetHash(), nBits))
genesis               947             return error("CBlock::ReadFromDisk() : errors in block header");
genesis               948 
genesis               949         return true;
genesis               950     }
genesis               951 
genesis               952 
genesis               953 
genesis               954     void print() const
genesis               955     {
genesis               956         printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%d)\n",
ben_vulpes_excise...  957             GetHash().ToString().c_str(),
genesis               958             nVersion,
ben_vulpes_excise...  959             hashPrevBlock.ToString().c_str(),
ben_vulpes_excise...  960             hashMerkleRoot.ToString().c_str(),
genesis               961             nTime, nBits, nNonce,
genesis               962             vtx.size());
genesis               963         for (int i = 0; i < vtx.size(); i++)
genesis               964         {
genesis               965             printf("  ");
genesis               966             vtx[i].print();
genesis               967         }
genesis               968         printf("  vMerkleTree: ");
genesis               969         for (int i = 0; i < vMerkleTree.size(); i++)
ben_vulpes_excise...  970             printf("%s ", vMerkleTree[i].ToString().c_str());
genesis               971         printf("\n");
genesis               972     }
genesis               973 
genesis               974 
genesis               975     bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
genesis               976     bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex);
genesis               977     bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
genesis               978     bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
genesis               979     bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
genesis               980     bool CheckBlock() const;
genesis               981     bool AcceptBlock();
genesis               982 };
genesis               983 
genesis               984 
genesis               985 
genesis               986 
genesis               987 
genesis               988 
genesis               989 //
genesis               990 // The block chain is a tree shaped structure starting with the
genesis               991 // genesis block at the root, with each block potentially having multiple
genesis               992 // candidates to be the next block.  pprev and pnext link a path through the
genesis               993 // main/longest chain.  A blockindex may have multiple pprev pointing back
genesis               994 // to it, but pnext will only point forward to the longest branch, or will
genesis               995 // be null if the block is not part of the longest chain.
genesis               996 //
genesis               997 class CBlockIndex
genesis               998 {
genesis               999 public:
genesis              1000     const uint256* phashBlock;
genesis              1001     CBlockIndex* pprev;
genesis              1002     CBlockIndex* pnext;
genesis              1003     unsigned int nFile;
genesis              1004     unsigned int nBlockPos;
genesis              1005     int nHeight;
genesis              1006     CBigNum bnChainWork;
genesis              1007 
genesis              1008     // block header
genesis              1009     int nVersion;
genesis              1010     uint256 hashMerkleRoot;
genesis              1011     unsigned int nTime;
genesis              1012     unsigned int nBits;
genesis              1013     unsigned int nNonce;
genesis              1014 
genesis              1015 
genesis              1016     CBlockIndex()
genesis              1017     {
genesis              1018         phashBlock = NULL;
genesis              1019         pprev = NULL;
genesis              1020         pnext = NULL;
genesis              1021         nFile = 0;
genesis              1022         nBlockPos = 0;
genesis              1023         nHeight = 0;
genesis              1024         bnChainWork = 0;
genesis              1025 
genesis              1026         nVersion       = 0;
genesis              1027         hashMerkleRoot = 0;
genesis              1028         nTime          = 0;
genesis              1029         nBits          = 0;
genesis              1030         nNonce         = 0;
genesis              1031     }
genesis              1032 
genesis              1033     CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
genesis              1034     {
genesis              1035         phashBlock = NULL;
genesis              1036         pprev = NULL;
genesis              1037         pnext = NULL;
genesis              1038         nFile = nFileIn;
genesis              1039         nBlockPos = nBlockPosIn;
genesis              1040         nHeight = 0;
genesis              1041         bnChainWork = 0;
genesis              1042 
genesis              1043         nVersion       = block.nVersion;
genesis              1044         hashMerkleRoot = block.hashMerkleRoot;
genesis              1045         nTime          = block.nTime;
genesis              1046         nBits          = block.nBits;
genesis              1047         nNonce         = block.nNonce;
genesis              1048     }
genesis              1049 
genesis              1050     CBlock GetBlockHeader() const
genesis              1051     {
genesis              1052         CBlock block;
genesis              1053         block.nVersion       = nVersion;
genesis              1054         if (pprev)
genesis              1055             block.hashPrevBlock = pprev->GetBlockHash();
genesis              1056         block.hashMerkleRoot = hashMerkleRoot;
genesis              1057         block.nTime          = nTime;
genesis              1058         block.nBits          = nBits;
genesis              1059         block.nNonce         = nNonce;
genesis              1060         return block;
genesis              1061     }
genesis              1062 
genesis              1063     uint256 GetBlockHash() const
genesis              1064     {
genesis              1065         return *phashBlock;
genesis              1066     }
genesis              1067 
genesis              1068     int64 GetBlockTime() const
genesis              1069     {
genesis              1070         return (int64)nTime;
genesis              1071     }
genesis              1072 
genesis              1073     CBigNum GetBlockWork() const
genesis              1074     {
genesis              1075         CBigNum bnTarget;
genesis              1076         bnTarget.SetCompact(nBits);
genesis              1077         if (bnTarget <= 0)
genesis              1078             return 0;
genesis              1079         return (CBigNum(1)<<256) / (bnTarget+1);
genesis              1080     }
genesis              1081 
genesis              1082     bool IsInMainChain() const
genesis              1083     {
genesis              1084         return (pnext || this == pindexBest);
genesis              1085     }
genesis              1086 
genesis              1087     bool CheckIndex() const
genesis              1088     {
genesis              1089         return CheckProofOfWork(GetBlockHash(), nBits);
genesis              1090     }
genesis              1091 
genesis              1092     bool EraseBlockFromDisk()
genesis              1093     {
genesis              1094         // Open history file
genesis              1095         CAutoFile fileout = OpenBlockFile(nFile, nBlockPos, "rb+");
genesis              1096         if (!fileout)
genesis              1097             return false;
genesis              1098 
genesis              1099         // Overwrite with empty null block
genesis              1100         CBlock block;
genesis              1101         block.SetNull();
genesis              1102         fileout << block;
genesis              1103 
genesis              1104         return true;
genesis              1105     }
genesis              1106 
genesis              1107     enum { nMedianTimeSpan=11 };
genesis              1108 
genesis              1109     int64 GetMedianTimePast() const
genesis              1110     {
genesis              1111         int64 pmedian[nMedianTimeSpan];
genesis              1112         int64* pbegin = &pmedian[nMedianTimeSpan];
genesis              1113         int64* pend = &pmedian[nMedianTimeSpan];
genesis              1114 
genesis              1115         const CBlockIndex* pindex = this;
genesis              1116         for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
genesis              1117             *(--pbegin) = pindex->GetBlockTime();
genesis              1118 
genesis              1119         std::sort(pbegin, pend);
genesis              1120         return pbegin[(pend - pbegin)/2];
genesis              1121     }
genesis              1122 
genesis              1123     int64 GetMedianTime() const
genesis              1124     {
genesis              1125         const CBlockIndex* pindex = this;
genesis              1126         for (int i = 0; i < nMedianTimeSpan/2; i++)
genesis              1127         {
genesis              1128             if (!pindex->pnext)
genesis              1129                 return GetBlockTime();
genesis              1130             pindex = pindex->pnext;
genesis              1131         }
genesis              1132         return pindex->GetMedianTimePast();
genesis              1133     }
genesis              1134 
genesis              1135 
genesis              1136 
genesis              1137     std::string ToString() const
genesis              1138     {
genesis              1139         return strprintf("CBlockIndex(nprev=%08x, pnext=%08x, nFile=%d, nBlockPos=%-6d nHeight=%d, merkle=%s, hashBlock=%s)",
genesis              1140             pprev, pnext, nFile, nBlockPos, nHeight,
ben_vulpes_excise... 1141             hashMerkleRoot.ToString().c_str(),
ben_vulpes_excise... 1142             GetBlockHash().ToString().c_str());
genesis              1143     }
genesis              1144 
genesis              1145     void print() const
genesis              1146     {
genesis              1147         printf("%s\n", ToString().c_str());
genesis              1148     }
genesis              1149 };
genesis              1150 
genesis              1151 
genesis              1152 
genesis              1153 //
genesis              1154 // Used to marshal pointers into hashes for db storage.
genesis              1155 //
genesis              1156 class CDiskBlockIndex : public CBlockIndex
genesis              1157 {
genesis              1158 public:
genesis              1159     uint256 hashPrev;
genesis              1160     uint256 hashNext;
genesis              1161 
genesis              1162     CDiskBlockIndex()
genesis              1163     {
genesis              1164         hashPrev = 0;
genesis              1165         hashNext = 0;
genesis              1166     }
genesis              1167 
genesis              1168     explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
genesis              1169     {
genesis              1170         hashPrev = (pprev ? pprev->GetBlockHash() : 0);
genesis              1171         hashNext = (pnext ? pnext->GetBlockHash() : 0);
genesis              1172     }
genesis              1173 
genesis              1174     IMPLEMENT_SERIALIZE
genesis              1175     (
genesis              1176         if (!(nType & SER_GETHASH))
genesis              1177             READWRITE(nVersion);
genesis              1178 
genesis              1179         READWRITE(hashNext);
genesis              1180         READWRITE(nFile);
genesis              1181         READWRITE(nBlockPos);
genesis              1182         READWRITE(nHeight);
genesis              1183 
genesis              1184         // block header
genesis              1185         READWRITE(this->nVersion);
genesis              1186         READWRITE(hashPrev);
genesis              1187         READWRITE(hashMerkleRoot);
genesis              1188         READWRITE(nTime);
genesis              1189         READWRITE(nBits);
genesis              1190         READWRITE(nNonce);
genesis              1191     )
genesis              1192 
genesis              1193     uint256 GetBlockHash() const
genesis              1194     {
genesis              1195         CBlock block;
genesis              1196         block.nVersion        = nVersion;
genesis              1197         block.hashPrevBlock   = hashPrev;
genesis              1198         block.hashMerkleRoot  = hashMerkleRoot;
genesis              1199         block.nTime           = nTime;
genesis              1200         block.nBits           = nBits;
genesis              1201         block.nNonce          = nNonce;
genesis              1202         return block.GetHash();
genesis              1203     }
genesis              1204 
genesis              1205 
genesis              1206     std::string ToString() const
genesis              1207     {
genesis              1208         std::string str = "CDiskBlockIndex(";
genesis              1209         str += CBlockIndex::ToString();
genesis              1210         str += strprintf("\n                hashBlock=%s, hashPrev=%s, hashNext=%s)",
genesis              1211             GetBlockHash().ToString().c_str(),
ben_vulpes_excise... 1212             hashPrev.ToString().c_str(),
ben_vulpes_excise... 1213             hashNext.ToString().c_str());
genesis              1214         return str;
genesis              1215     }
genesis              1216 
genesis              1217     void print() const
genesis              1218     {
genesis              1219         printf("%s\n", ToString().c_str());
genesis              1220     }
genesis              1221 };
genesis              1222 
genesis              1223 
genesis              1224 
genesis              1225 
genesis              1226 
genesis              1227 
genesis              1228 
genesis              1229 
genesis              1230 //
genesis              1231 // Describes a place in the block chain to another node such that if the
genesis              1232 // other node doesn't have the same branch, it can find a recent common trunk.
genesis              1233 // The further back it is, the further before the fork it may be.
genesis              1234 //
genesis              1235 class CBlockLocator
genesis              1236 {
genesis              1237 protected:
genesis              1238     std::vector<uint256> vHave;
genesis              1239 public:
genesis              1240 
genesis              1241     CBlockLocator()
genesis              1242     {
genesis              1243     }
genesis              1244 
genesis              1245     explicit CBlockLocator(const CBlockIndex* pindex)
genesis              1246     {
genesis              1247         Set(pindex);
genesis              1248     }
genesis              1249 
genesis              1250     explicit CBlockLocator(uint256 hashBlock)
genesis              1251     {
genesis              1252         std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
genesis              1253         if (mi != mapBlockIndex.end())
genesis              1254             Set((*mi).second);
genesis              1255     }
genesis              1256 
genesis              1257     IMPLEMENT_SERIALIZE
genesis              1258     (
genesis              1259         if (!(nType & SER_GETHASH))
genesis              1260             READWRITE(nVersion);
genesis              1261         READWRITE(vHave);
genesis              1262     )
genesis              1263 
genesis              1264     void SetNull()
genesis              1265     {
genesis              1266         vHave.clear();
genesis              1267     }
genesis              1268 
genesis              1269     bool IsNull()
genesis              1270     {
genesis              1271         return vHave.empty();
genesis              1272     }
genesis              1273 
genesis              1274     void Set(const CBlockIndex* pindex)
genesis              1275     {
genesis              1276         vHave.clear();
genesis              1277         int nStep = 1;
genesis              1278         while (pindex)
genesis              1279         {
genesis              1280             vHave.push_back(pindex->GetBlockHash());
genesis              1281 
genesis              1282             // Exponentially larger steps back
genesis              1283             for (int i = 0; pindex && i < nStep; i++)
genesis              1284                 pindex = pindex->pprev;
genesis              1285             if (vHave.size() > 10)
genesis              1286                 nStep *= 2;
genesis              1287         }
genesis              1288         vHave.push_back(hashGenesisBlock);
genesis              1289     }
genesis              1290 
genesis              1291     int GetDistanceBack()
genesis              1292     {
genesis              1293         // Retrace how far back it was in the sender's branch
genesis              1294         int nDistance = 0;
genesis              1295         int nStep = 1;
genesis              1296         BOOST_FOREACH(const uint256& hash, vHave)
genesis              1297         {
genesis              1298             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
genesis              1299             if (mi != mapBlockIndex.end())
genesis              1300             {
genesis              1301                 CBlockIndex* pindex = (*mi).second;
genesis              1302                 if (pindex->IsInMainChain())
genesis              1303                     return nDistance;
genesis              1304             }
genesis              1305             nDistance += nStep;
genesis              1306             if (nDistance > 10)
genesis              1307                 nStep *= 2;
genesis              1308         }
genesis              1309         return nDistance;
genesis              1310     }
genesis              1311 
genesis              1312     CBlockIndex* GetBlockIndex()
genesis              1313     {
genesis              1314         // Find the first block the caller has in the main chain
genesis              1315         BOOST_FOREACH(const uint256& hash, vHave)
genesis              1316         {
genesis              1317             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
genesis              1318             if (mi != mapBlockIndex.end())
genesis              1319             {
genesis              1320                 CBlockIndex* pindex = (*mi).second;
genesis              1321                 if (pindex->IsInMainChain())
genesis              1322                     return pindex;
genesis              1323             }
genesis              1324         }
genesis              1325         return pindexGenesisBlock;
genesis              1326     }
genesis              1327 
genesis              1328     uint256 GetBlockHash()
genesis              1329     {
genesis              1330         // Find the first block the caller has in the main chain
genesis              1331         BOOST_FOREACH(const uint256& hash, vHave)
genesis              1332         {
genesis              1333             std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
genesis              1334             if (mi != mapBlockIndex.end())
genesis              1335             {
genesis              1336                 CBlockIndex* pindex = (*mi).second;
genesis              1337                 if (pindex->IsInMainChain())
genesis              1338                     return hash;
genesis              1339             }
genesis              1340         }
genesis              1341         return hashGenesisBlock;
genesis              1342     }
genesis              1343 
genesis              1344     int GetHeight()
genesis              1345     {
genesis              1346         CBlockIndex* pindex = GetBlockIndex();
genesis              1347         if (!pindex)
genesis              1348             return 0;
genesis              1349         return pindex->nHeight;
genesis              1350     }
genesis              1351 };
genesis              1352 
genesis              1353 #endif