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 license.txt or http://www.opensource.org/licenses/mit-license.php.
26 class CRequestTracker;
30 static const unsigned int MAX_BLOCK_SIZE = 1000000;
31 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
32 static const int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
33 static const int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
34 static const int64 COIN = 100000000;
35 static const int64 CENT = 1000000;
36 static const int64 MIN_TX_FEE = 50000;
37 static const int64 MIN_RELAY_TX_FEE = 10000;
38 static const int64 MAX_MONEY = 21000000 * COIN;
39 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
40 static const int COINBASE_MATURITY = 100;
41 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
42 static const int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
44 static const int fHaveUPnP = true;
46 static const int fHaveUPnP = false;
54 extern CCriticalSection cs_main;
55 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
56 extern uint256 hashGenesisBlock;
57 extern CBlockIndex* pindexGenesisBlock;
58 extern int nBestHeight;
59 extern CBigNum bnBestChainWork;
60 extern CBigNum bnBestInvalidWork;
61 extern uint256 hashBestChain;
62 extern CBlockIndex* pindexBest;
63 extern unsigned int nTransactionsUpdated;
64 extern double dHashesPerSec;
65 extern int64 nHPSTimerStart;
66 extern int64 nTimeBestReceived;
67 extern CCriticalSection cs_setpwalletRegistered;
68 extern std::set<CWallet*> setpwalletRegistered;
71 extern int fGenerateBitcoins;
72 extern int64 nTransactionFee;
73 extern int fLimitProcessors;
74 extern int nLimitProcessors;
75 extern int fMinimizeToTray;
76 extern int fMinimizeOnClose;
87 void RegisterWallet(CWallet* pwalletIn);
88 void UnregisterWallet(CWallet* pwalletIn);
89 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
90 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
91 FILE* AppendBlockFile(unsigned int& nFileRet);
92 bool LoadBlockIndex(bool fAllowNew=true);
93 void PrintBlockTree();
94 bool ProcessMessages(CNode* pfrom);
95 bool SendMessages(CNode* pto, bool fSendTrickle);
96 void GenerateBitcoins(bool fGenerate, CWallet* pwallet);
97 CBlock* CreateNewBlock(CReserveKey& reservekey);
98 void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
99 void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
100 bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
101 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
102 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
103 bool IsInitialBlockDownload();
104 std::string GetWarnings(std::string strFor);
117 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
120 bool WriteSetting(const std::string& strKey, const T& value)
123 BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
125 std::string strWalletFile;
126 if (!GetWalletFile(pwallet, strWalletFile))
128 fOk |= CWalletDB(strWalletFile).WriteSetting(strKey, value);
138 unsigned int nBlockPos;
146 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
149 nBlockPos = nBlockPosIn;
153 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
154 void SetNull() { nFile = -1; nBlockPos = 0; nTxPos = 0; }
155 bool IsNull() const { return (nFile == -1); }
157 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
159 return (a.nFile == b.nFile &&
160 a.nBlockPos == b.nBlockPos &&
161 a.nTxPos == b.nTxPos);
164 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
169 std::string ToString() const
172 return strprintf("null");
174 return strprintf("(nFile=%d, nBlockPos=%d, nTxPos=%d)", nFile, nBlockPos, nTxPos);
179 printf("%s", ToString().c_str());
192 CInPoint() { SetNull(); }
193 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
194 void SetNull() { ptx = NULL; n = -1; }
195 bool IsNull() const { return (ptx == NULL && n == -1); }
207 COutPoint() { SetNull(); }
208 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
209 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
210 void SetNull() { hash = 0; n = -1; }
211 bool IsNull() const { return (hash == 0 && n == -1); }
213 friend bool operator<(const COutPoint& a, const COutPoint& b)
215 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
218 friend bool operator==(const COutPoint& a, const COutPoint& b)
220 return (a.hash == b.hash && a.n == b.n);
223 friend bool operator!=(const COutPoint& a, const COutPoint& b)
228 std::string ToString() const
230 return strprintf("COutPoint(%s, %d)", hash.ToString().substr(0,10).c_str(), n);
235 printf("%s\n", ToString().c_str());
243 // An input of a transaction. It contains the location of the previous
244 // transaction's output that it claims and a signature that matches the
245 // output's public key.
252 unsigned int nSequence;
256 nSequence = UINT_MAX;
259 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=UINT_MAX)
262 scriptSig = scriptSigIn;
263 nSequence = nSequenceIn;
266 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=UINT_MAX)
268 prevout = COutPoint(hashPrevTx, nOut);
269 scriptSig = scriptSigIn;
270 nSequence = nSequenceIn;
276 READWRITE(scriptSig);
277 READWRITE(nSequence);
282 return (nSequence == UINT_MAX);
285 friend bool operator==(const CTxIn& a, const CTxIn& b)
287 return (a.prevout == b.prevout &&
288 a.scriptSig == b.scriptSig &&
289 a.nSequence == b.nSequence);
292 friend bool operator!=(const CTxIn& a, const CTxIn& b)
297 std::string ToString() const
300 str += strprintf("CTxIn(");
301 str += prevout.ToString();
302 if (prevout.IsNull())
303 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
305 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
306 if (nSequence != UINT_MAX)
307 str += strprintf(", nSequence=%u", nSequence);
314 printf("%s\n", ToString().c_str());
322 // An output of a transaction. It contains the public key that the next input
323 // must be able to sign with to claim it.
329 CScript scriptPubKey;
336 CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
339 scriptPubKey = scriptPubKeyIn;
345 READWRITE(scriptPubKey);
351 scriptPubKey.clear();
356 return (nValue == -1);
359 uint256 GetHash() const
361 return SerializeHash(*this);
364 friend bool operator==(const CTxOut& a, const CTxOut& b)
366 return (a.nValue == b.nValue &&
367 a.scriptPubKey == b.scriptPubKey);
370 friend bool operator!=(const CTxOut& a, const CTxOut& b)
375 std::string ToString() const
377 if (scriptPubKey.size() < 6)
378 return "CTxOut(error)";
379 return strprintf("CTxOut(nValue=%"PRI64d".%08"PRI64d", scriptPubKey=%s)", nValue / COIN, nValue % COIN, scriptPubKey.ToString().substr(0,30).c_str());
384 printf("%s\n", ToString().c_str());
389 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
393 // The basic transaction that is broadcasted on the network and contained in
394 // blocks. A transaction can contain multiple inputs and outputs.
400 std::vector<CTxIn> vin;
401 std::vector<CTxOut> vout;
402 unsigned int nLockTime;
412 READWRITE(this->nVersion);
413 nVersion = this->nVersion;
416 READWRITE(nLockTime);
429 return (vin.empty() && vout.empty());
432 uint256 GetHash() const
434 return SerializeHash(*this);
437 bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
439 // Time based nLockTime implemented in 0.1.6
442 if (nBlockHeight == 0)
443 nBlockHeight = nBestHeight;
445 nBlockTime = GetAdjustedTime();
446 if ((int64)nLockTime < (nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
448 BOOST_FOREACH(const CTxIn& txin, vin)
454 bool IsNewerThan(const CTransaction& old) const
456 if (vin.size() != old.vin.size())
458 for (int i = 0; i < vin.size(); i++)
459 if (vin[i].prevout != old.vin[i].prevout)
463 unsigned int nLowest = UINT_MAX;
464 for (int i = 0; i < vin.size(); i++)
466 if (vin[i].nSequence != old.vin[i].nSequence)
468 if (vin[i].nSequence <= nLowest)
471 nLowest = vin[i].nSequence;
473 if (old.vin[i].nSequence < nLowest)
476 nLowest = old.vin[i].nSequence;
483 bool IsCoinBase() const
485 return (vin.size() == 1 && vin[0].prevout.IsNull());
488 int GetSigOpCount() const
491 BOOST_FOREACH(const CTxIn& txin, vin)
492 n += txin.scriptSig.GetSigOpCount();
493 BOOST_FOREACH(const CTxOut& txout, vout)
494 n += txout.scriptPubKey.GetSigOpCount();
498 /** Count ECDSA signature operations in pay-to-script-hash inputs.
499 This is a better measure of how expensive it is to process this transaction.
501 @param[in] mapInputsMap of previous transactions that have outputs we're spending
502 @return maximum number of sigops required to validate this transaction's inputs
503 @see CTransaction::FetchInputs
505 int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
507 bool IsStandard() const
509 BOOST_FOREACH(const CTxIn& txin, vin)
510 if (!txin.scriptSig.IsPushOnly())
511 return error("nonstandard txin: %s", txin.scriptSig.ToString().c_str());
512 BOOST_FOREACH(const CTxOut& txout, vout)
513 if (!::IsStandard(txout.scriptPubKey))
514 return error("nonstandard txout: %s", txout.scriptPubKey.ToString().c_str());
518 int64 GetValueOut() const
521 BOOST_FOREACH(const CTxOut& txout, vout)
523 nValueOut += txout.nValue;
524 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
525 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
530 /** Amount of bitcoins coming in to this transaction
531 Note that lightweight clients may not know anything besides the hash of previous transactions,
532 so may not be able to calculate this.
534 @param[in] mapInputsMap of previous transactions that have outputs we're spending
535 @returnSum of value of all inputs (scriptSigs)
536 @see CTransaction::FetchInputs
538 int64 GetValueIn(const MapPrevTx& mapInputs) const;
540 static bool AllowFree(double dPriority)
542 // Large (in bytes) low-priority (new, small-coin) transactions
544 return dPriority > COIN * 144 / 250;
547 int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=true, bool fForRelay=false) const
549 // Base fee is either MIN_TX_FEE or MIN_RELAY_TX_FEE
550 int64 nBaseFee = fForRelay ? MIN_RELAY_TX_FEE : MIN_TX_FEE;
552 unsigned int nBytes = ::GetSerializeSize(*this, SER_NETWORK);
553 unsigned int nNewBlockSize = nBlockSize + nBytes;
554 int64 nMinFee = (1 + (int64)nBytes / 1000) * nBaseFee;
560 // Transactions under 10K are free
561 // (about 4500bc if made of 50bc inputs)
567 // Free transaction area
568 if (nNewBlockSize < 27000)
573 // To limit dust spam, require MIN_TX_FEE/MIN_RELAY_TX_FEE if any output is less than 0.01
574 if (nMinFee < nBaseFee)
576 BOOST_FOREACH(const CTxOut& txout, vout)
577 if (txout.nValue < CENT)
581 // Raise the price as the block approaches full
582 if (nBlockSize != 1 && nNewBlockSize >= MAX_BLOCK_SIZE_GEN/2)
584 if (nNewBlockSize >= MAX_BLOCK_SIZE_GEN)
586 nMinFee *= MAX_BLOCK_SIZE_GEN / (MAX_BLOCK_SIZE_GEN - nNewBlockSize);
589 if (!MoneyRange(nMinFee))
595 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
597 CAutoFile filein = OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb");
599 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
602 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
603 return error("CTransaction::ReadFromDisk() : fseek failed");
606 // Return file pointer
609 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
610 return error("CTransaction::ReadFromDisk() : second fseek failed");
611 *pfileRet = filein.release();
616 friend bool operator==(const CTransaction& a, const CTransaction& b)
618 return (a.nVersion == b.nVersion &&
621 a.nLockTime == b.nLockTime);
624 friend bool operator!=(const CTransaction& a, const CTransaction& b)
630 std::string ToString() const
633 str += strprintf("CTransaction(hash=%s, ver=%d, vin.size=%d, vout.size=%d, nLockTime=%d)\n",
634 GetHash().ToString().substr(0,10).c_str(),
639 for (int i = 0; i < vin.size(); i++)
640 str += " " + vin[i].ToString() + "\n";
641 for (int i = 0; i < vout.size(); i++)
642 str += " " + vout[i].ToString() + "\n";
648 printf("%s", ToString().c_str());
652 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
653 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
654 bool ReadFromDisk(COutPoint prevout);
655 bool DisconnectInputs(CTxDB& txdb);
657 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
659 @param[in] txdb Transaction database
660 @param[in] mapTestPool List of pending changes to the transaction index database
661 @param[in] fBlock True if being called to add a new best-block to the chain
662 @param[in] fMiner True if being called by CreateNewBlock
663 @param[out] inputsRet Pointers to this transaction's inputs
664 @param[out] fInvalid returns true if transaction is invalid
665 @return Returns true if all inputs are in txdb or mapTestPool
667 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
668 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
670 /** Sanity check previous transactions, then, if all checks succeed,
671 mark them as spent by this transaction.
673 @param[in] inputsPrevious transactions (from FetchInputs)
674 @param[out] mapTestPoolKeeps track of inputs that need to be updated on disk
675 @param[in] posThisTxPosition of this transaction on disk
676 @param[in] pindexBlock
677 @param[in] fBlock true if called from ConnectBlock
678 @param[in] fMiner true if called from CreateNewBlock
679 @param[in] fStrictPayToScriptHash true if fully validating p2sh transactions
680 @return Returns true if all checks succeed
682 bool ConnectInputs(MapPrevTx inputs,
683 std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
684 const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash=true);
685 bool ClientConnectInputs();
686 bool CheckTransaction() const;
687 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
688 bool AcceptToMemoryPool(bool fCheckInputs=true, bool* pfMissingInputs=NULL);
690 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
691 bool AddToMemoryPoolUnchecked();
693 bool RemoveFromMemoryPool();
701 // A transaction with a merkle branch linking it to the block chain
703 class CMerkleTx : public CTransaction
707 std::vector<uint256> vMerkleBranch;
711 mutable char fMerkleVerified;
719 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
728 fMerkleVerified = false;
734 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
735 nVersion = this->nVersion;
736 READWRITE(hashBlock);
737 READWRITE(vMerkleBranch);
742 int SetMerkleBranch(const CBlock* pblock=NULL);
743 int GetDepthInMainChain(int& nHeightRet) const;
744 int GetDepthInMainChain() const { int nHeight; return GetDepthInMainChain(nHeight); }
745 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
746 int GetBlocksToMaturity() const;
747 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
748 bool AcceptToMemoryPool();
755 // A txdb record that contains the disk location of a transaction and the
756 // locations of transactions that spend its outputs. vSpent is really only
757 // used as a flag, but having the location is very helpful for debugging.
763 std::vector<CDiskTxPos> vSpent;
770 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
773 vSpent.resize(nOutputs);
778 if (!(nType & SER_GETHASH))
795 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
797 return (a.pos == b.pos &&
798 a.vSpent == b.vSpent);
801 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
805 int GetDepthInMainChain() const;
813 // Nodes collect new transactions into a block, hash them into a hash tree,
814 // and scan through nonce values to make the block's hash satisfy proof-of-work
815 // requirements. When they solve the proof-of-work, they broadcast the block
816 // to everyone and the block is added to the block chain. The first transaction
817 // in the block is a special one that creates a new coin owned by the creator
820 // Blocks are appended to blk0001.dat files on disk. Their location on disk
821 // is indexed by CBlockIndex objects in memory.
828 uint256 hashPrevBlock;
829 uint256 hashMerkleRoot;
835 std::vector<CTransaction> vtx;
838 mutable std::vector<uint256> vMerkleTree;
848 READWRITE(this->nVersion);
849 nVersion = this->nVersion;
850 READWRITE(hashPrevBlock);
851 READWRITE(hashMerkleRoot);
856 // ConnectBlock depends on vtx being last so it can calculate offset
857 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
860 const_cast<CBlock*>(this)->vtx.clear();
880 uint256 GetHash() const
882 return Hash(BEGIN(nVersion), END(nNonce));
885 int64 GetBlockTime() const
890 int GetSigOpCount() const
893 BOOST_FOREACH(const CTransaction& tx, vtx)
894 n += tx.GetSigOpCount();
898 void UpdateTime(const CBlockIndex* pindexPrev);
901 uint256 BuildMerkleTree() const
904 BOOST_FOREACH(const CTransaction& tx, vtx)
905 vMerkleTree.push_back(tx.GetHash());
907 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
909 for (int i = 0; i < nSize; i += 2)
911 int i2 = std::min(i+1, nSize-1);
912 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
913 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
917 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
920 std::vector<uint256> GetMerkleBranch(int nIndex) const
922 if (vMerkleTree.empty())
924 std::vector<uint256> vMerkleBranch;
926 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
928 int i = std::min(nIndex^1, nSize-1);
929 vMerkleBranch.push_back(vMerkleTree[j+i]);
933 return vMerkleBranch;
936 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
940 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
943 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
945 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
952 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
954 // Open history file to append
955 CAutoFile fileout = AppendBlockFile(nFileRet);
957 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
959 // Write index header
960 unsigned int nSize = fileout.GetSerializeSize(*this);
961 fileout << FLATDATA(pchMessageStart) << nSize;
964 nBlockPosRet = ftell(fileout);
965 if (nBlockPosRet == -1)
966 return error("CBlock::WriteToDisk() : ftell failed");
969 // Flush stdio buffers and commit to disk before returning
971 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
974 _commit(_fileno(fileout));
976 fsync(fileno(fileout));
983 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
987 // Open history file to read
988 CAutoFile filein = OpenBlockFile(nFile, nBlockPos, "rb");
990 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
991 if (!fReadTransactions)
992 filein.nType |= SER_BLOCKHEADERONLY;
998 if (!CheckProofOfWork(GetHash(), nBits))
999 return error("CBlock::ReadFromDisk() : errors in block header");
1008 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%d)\n",
1009 GetHash().ToString().substr(0,20).c_str(),
1011 hashPrevBlock.ToString().substr(0,20).c_str(),
1012 hashMerkleRoot.ToString().substr(0,10).c_str(),
1013 nTime, nBits, nNonce,
1015 for (int i = 0; i < vtx.size(); i++)
1020 printf(" vMerkleTree: ");
1021 for (int i = 0; i < vMerkleTree.size(); i++)
1022 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1027 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1028 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1029 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1030 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1031 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1032 bool CheckBlock() const;
1042 // The block chain is a tree shaped structure starting with the
1043 // genesis block at the root, with each block potentially having multiple
1044 // candidates to be the next block. pprev and pnext link a path through the
1045 // main/longest chain. A blockindex may have multiple pprev pointing back
1046 // to it, but pnext will only point forward to the longest branch, or will
1047 // be null if the block is not part of the longest chain.
1052 const uint256* phashBlock;
1056 unsigned int nBlockPos;
1058 CBigNum bnChainWork;
1062 uint256 hashMerkleRoot;
1065 unsigned int nNonce;
1085 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1091 nBlockPos = nBlockPosIn;
1095 nVersion = block.nVersion;
1096 hashMerkleRoot = block.hashMerkleRoot;
1097 nTime = block.nTime;
1098 nBits = block.nBits;
1099 nNonce = block.nNonce;
1102 CBlock GetBlockHeader() const
1105 block.nVersion = nVersion;
1107 block.hashPrevBlock = pprev->GetBlockHash();
1108 block.hashMerkleRoot = hashMerkleRoot;
1109 block.nTime = nTime;
1110 block.nBits = nBits;
1111 block.nNonce = nNonce;
1115 uint256 GetBlockHash() const
1120 int64 GetBlockTime() const
1122 return (int64)nTime;
1125 CBigNum GetBlockWork() const
1128 bnTarget.SetCompact(nBits);
1131 return (CBigNum(1)<<256) / (bnTarget+1);
1134 bool IsInMainChain() const
1136 return (pnext || this == pindexBest);
1139 bool CheckIndex() const
1141 return CheckProofOfWork(GetBlockHash(), nBits);
1144 bool EraseBlockFromDisk()
1146 // Open history file
1147 CAutoFile fileout = OpenBlockFile(nFile, nBlockPos, "rb+");
1151 // Overwrite with empty null block
1159 enum { nMedianTimeSpan=11 };
1161 int64 GetMedianTimePast() const
1163 int64 pmedian[nMedianTimeSpan];
1164 int64* pbegin = &pmedian[nMedianTimeSpan];
1165 int64* pend = &pmedian[nMedianTimeSpan];
1167 const CBlockIndex* pindex = this;
1168 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1169 *(--pbegin) = pindex->GetBlockTime();
1171 std::sort(pbegin, pend);
1172 return pbegin[(pend - pbegin)/2];
1175 int64 GetMedianTime() const
1177 const CBlockIndex* pindex = this;
1178 for (int i = 0; i < nMedianTimeSpan/2; i++)
1181 return GetBlockTime();
1182 pindex = pindex->pnext;
1184 return pindex->GetMedianTimePast();
1189 std::string ToString() const
1191 return strprintf("CBlockIndex(nprev=%08x, pnext=%08x, nFile=%d, nBlockPos=%-6d nHeight=%d, merkle=%s, hashBlock=%s)",
1192 pprev, pnext, nFile, nBlockPos, nHeight,
1193 hashMerkleRoot.ToString().substr(0,10).c_str(),
1194 GetBlockHash().ToString().substr(0,20).c_str());
1199 printf("%s\n", ToString().c_str());
1206 // Used to marshal pointers into hashes for db storage.
1208 class CDiskBlockIndex : public CBlockIndex
1220 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1222 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1223 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1228 if (!(nType & SER_GETHASH))
1229 READWRITE(nVersion);
1231 READWRITE(hashNext);
1233 READWRITE(nBlockPos);
1237 READWRITE(this->nVersion);
1238 READWRITE(hashPrev);
1239 READWRITE(hashMerkleRoot);
1245 uint256 GetBlockHash() const
1248 block.nVersion = nVersion;
1249 block.hashPrevBlock = hashPrev;
1250 block.hashMerkleRoot = hashMerkleRoot;
1251 block.nTime = nTime;
1252 block.nBits = nBits;
1253 block.nNonce = nNonce;
1254 return block.GetHash();
1258 std::string ToString() const
1260 std::string str = "CDiskBlockIndex(";
1261 str += CBlockIndex::ToString();
1262 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1263 GetBlockHash().ToString().c_str(),
1264 hashPrev.ToString().substr(0,20).c_str(),
1265 hashNext.ToString().substr(0,20).c_str());
1271 printf("%s\n", ToString().c_str());
1283 // Describes a place in the block chain to another node such that if the
1284 // other node doesn't have the same branch, it can find a recent common trunk.
1285 // The further back it is, the further before the fork it may be.
1290 std::vector<uint256> vHave;
1297 explicit CBlockLocator(const CBlockIndex* pindex)
1302 explicit CBlockLocator(uint256 hashBlock)
1304 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1305 if (mi != mapBlockIndex.end())
1311 if (!(nType & SER_GETHASH))
1312 READWRITE(nVersion);
1323 return vHave.empty();
1326 void Set(const CBlockIndex* pindex)
1332 vHave.push_back(pindex->GetBlockHash());
1334 // Exponentially larger steps back
1335 for (int i = 0; pindex && i < nStep; i++)
1336 pindex = pindex->pprev;
1337 if (vHave.size() > 10)
1340 vHave.push_back(hashGenesisBlock);
1343 int GetDistanceBack()
1345 // Retrace how far back it was in the sender's branch
1348 BOOST_FOREACH(const uint256& hash, vHave)
1350 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1351 if (mi != mapBlockIndex.end())
1353 CBlockIndex* pindex = (*mi).second;
1354 if (pindex->IsInMainChain())
1364 CBlockIndex* GetBlockIndex()
1366 // Find the first block the caller has in the main chain
1367 BOOST_FOREACH(const uint256& hash, vHave)
1369 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1370 if (mi != mapBlockIndex.end())
1372 CBlockIndex* pindex = (*mi).second;
1373 if (pindex->IsInMainChain())
1377 return pindexGenesisBlock;
1380 uint256 GetBlockHash()
1382 // Find the first block the caller has in the main chain
1383 BOOST_FOREACH(const uint256& hash, vHave)
1385 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1386 if (mi != mapBlockIndex.end())
1388 CBlockIndex* pindex = (*mi).second;
1389 if (pindex->IsInMainChain())
1393 return hashGenesisBlock;
1398 CBlockIndex* pindex = GetBlockIndex();
1401 return pindex->nHeight;
1414 // Alerts are for notifying old versions if they become too obsolete and
1415 // need to upgrade. The message is displayed in the status bar.
1416 // Alert messages are broadcast as a vector of signed data. Unserializing may
1417 // not read the entire buffer if the alert is for a newer version, but older
1418 // versions can still relay the original data.
1420 class CUnsignedAlert
1424 int64 nRelayUntil; // when newer nodes stop relaying to newer nodes
1428 std::set<int> setCancel;
1429 int nMinVer; // lowest version inclusive
1430 int nMaxVer; // highest version inclusive
1431 std::set<std::string> setSubVer; // empty matches all
1435 std::string strComment;
1436 std::string strStatusBar;
1437 std::string strReserved;
1441 READWRITE(this->nVersion);
1442 nVersion = this->nVersion;
1443 READWRITE(nRelayUntil);
1444 READWRITE(nExpiration);
1447 READWRITE(setCancel);
1450 READWRITE(setSubVer);
1451 READWRITE(nPriority);
1453 READWRITE(strComment);
1454 READWRITE(strStatusBar);
1455 READWRITE(strReserved);
1472 strStatusBar.clear();
1473 strReserved.clear();
1476 std::string ToString() const
1478 std::string strSetCancel;
1479 BOOST_FOREACH(int n, setCancel)
1480 strSetCancel += strprintf("%d ", n);
1481 std::string strSetSubVer;
1482 BOOST_FOREACH(std::string str, setSubVer)
1483 strSetSubVer += "\"" + str + "\" ";
1487 " nRelayUntil = %"PRI64d"\n"
1488 " nExpiration = %"PRI64d"\n"
1496 " strComment = \"%s\"\n"
1497 " strStatusBar = \"%s\"\n"
1504 strSetCancel.c_str(),
1507 strSetSubVer.c_str(),
1510 strStatusBar.c_str());
1515 printf("%s", ToString().c_str());
1519 class CAlert : public CUnsignedAlert
1522 std::vector<unsigned char> vchMsg;
1523 std::vector<unsigned char> vchSig;
1538 CUnsignedAlert::SetNull();
1545 return (nExpiration == 0);
1548 uint256 GetHash() const
1550 return SerializeHash(*this);
1553 bool IsInEffect() const
1555 return (GetAdjustedTime() < nExpiration);
1558 bool Cancels(const CAlert& alert) const
1561 return false; // this was a no-op before 31403
1562 return (alert.nID <= nCancel || setCancel.count(alert.nID));
1565 bool AppliesTo(int nVersion, std::string strSubVerIn) const
1567 return (IsInEffect() &&
1568 nMinVer <= nVersion && nVersion <= nMaxVer &&
1569 (setSubVer.empty() || setSubVer.count(strSubVerIn)));
1572 bool AppliesToMe() const
1574 return AppliesTo(VERSION, ::pszSubVer);
1577 bool RelayTo(CNode* pnode) const
1581 // returns true if wasn't already contained in the set
1582 if (pnode->setKnown.insert(GetHash()).second)
1584 if (AppliesTo(pnode->nVersion, pnode->strSubVer) ||
1586 GetAdjustedTime() < nRelayUntil)
1588 pnode->PushMessage("alert", *this);
1595 bool CheckSignature()
1598 if (!key.SetPubKey(ParseHex("04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284")))
1599 return error("CAlert::CheckSignature() : SetPubKey failed");
1600 if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig))
1601 return error("CAlert::CheckSignature() : verify signature failed");
1603 // Now unserialize the data
1604 CDataStream sMsg(vchMsg);
1605 sMsg >> *(CUnsignedAlert*)this;
1609 bool ProcessAlert();