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 (unsigned int i = 0; i < vin.size(); i++)
459 if (vin[i].prevout != old.vin[i].prevout)
463 unsigned int nLowest = UINT_MAX;
464 for (unsigned 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 (unsigned int i = 0; i < vin.size(); i++)
640 str += " " + vin[i].ToString() + "\n";
641 for (unsigned 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 long fileOutPos = ftell(fileout);
966 return error("CBlock::WriteToDisk() : ftell failed");
967 nBlockPosRet = fileOutPos;
970 // Flush stdio buffers and commit to disk before returning
972 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
975 _commit(_fileno(fileout));
977 fsync(fileno(fileout));
984 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
988 // Open history file to read
989 CAutoFile filein = OpenBlockFile(nFile, nBlockPos, "rb");
991 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
992 if (!fReadTransactions)
993 filein.nType |= SER_BLOCKHEADERONLY;
999 if (!CheckProofOfWork(GetHash(), nBits))
1000 return error("CBlock::ReadFromDisk() : errors in block header");
1009 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%d)\n",
1010 GetHash().ToString().substr(0,20).c_str(),
1012 hashPrevBlock.ToString().substr(0,20).c_str(),
1013 hashMerkleRoot.ToString().substr(0,10).c_str(),
1014 nTime, nBits, nNonce,
1016 for (unsigned int i = 0; i < vtx.size(); i++)
1021 printf(" vMerkleTree: ");
1022 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1023 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1028 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1029 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1030 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1031 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1032 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1033 bool CheckBlock() const;
1043 // The block chain is a tree shaped structure starting with the
1044 // genesis block at the root, with each block potentially having multiple
1045 // candidates to be the next block. pprev and pnext link a path through the
1046 // main/longest chain. A blockindex may have multiple pprev pointing back
1047 // to it, but pnext will only point forward to the longest branch, or will
1048 // be null if the block is not part of the longest chain.
1053 const uint256* phashBlock;
1057 unsigned int nBlockPos;
1059 CBigNum bnChainWork;
1063 uint256 hashMerkleRoot;
1066 unsigned int nNonce;
1086 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1092 nBlockPos = nBlockPosIn;
1096 nVersion = block.nVersion;
1097 hashMerkleRoot = block.hashMerkleRoot;
1098 nTime = block.nTime;
1099 nBits = block.nBits;
1100 nNonce = block.nNonce;
1103 CBlock GetBlockHeader() const
1106 block.nVersion = nVersion;
1108 block.hashPrevBlock = pprev->GetBlockHash();
1109 block.hashMerkleRoot = hashMerkleRoot;
1110 block.nTime = nTime;
1111 block.nBits = nBits;
1112 block.nNonce = nNonce;
1116 uint256 GetBlockHash() const
1121 int64 GetBlockTime() const
1123 return (int64)nTime;
1126 CBigNum GetBlockWork() const
1129 bnTarget.SetCompact(nBits);
1132 return (CBigNum(1)<<256) / (bnTarget+1);
1135 bool IsInMainChain() const
1137 return (pnext || this == pindexBest);
1140 bool CheckIndex() const
1142 return CheckProofOfWork(GetBlockHash(), nBits);
1145 bool EraseBlockFromDisk()
1147 // Open history file
1148 CAutoFile fileout = OpenBlockFile(nFile, nBlockPos, "rb+");
1152 // Overwrite with empty null block
1160 enum { nMedianTimeSpan=11 };
1162 int64 GetMedianTimePast() const
1164 int64 pmedian[nMedianTimeSpan];
1165 int64* pbegin = &pmedian[nMedianTimeSpan];
1166 int64* pend = &pmedian[nMedianTimeSpan];
1168 const CBlockIndex* pindex = this;
1169 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1170 *(--pbegin) = pindex->GetBlockTime();
1172 std::sort(pbegin, pend);
1173 return pbegin[(pend - pbegin)/2];
1176 int64 GetMedianTime() const
1178 const CBlockIndex* pindex = this;
1179 for (int i = 0; i < nMedianTimeSpan/2; i++)
1182 return GetBlockTime();
1183 pindex = pindex->pnext;
1185 return pindex->GetMedianTimePast();
1190 std::string ToString() const
1192 return strprintf("CBlockIndex(nprev=%08x, pnext=%08x, nFile=%d, nBlockPos=%-6d nHeight=%d, merkle=%s, hashBlock=%s)",
1193 pprev, pnext, nFile, nBlockPos, nHeight,
1194 hashMerkleRoot.ToString().substr(0,10).c_str(),
1195 GetBlockHash().ToString().substr(0,20).c_str());
1200 printf("%s\n", ToString().c_str());
1207 // Used to marshal pointers into hashes for db storage.
1209 class CDiskBlockIndex : public CBlockIndex
1221 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1223 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1224 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1229 if (!(nType & SER_GETHASH))
1230 READWRITE(nVersion);
1232 READWRITE(hashNext);
1234 READWRITE(nBlockPos);
1238 READWRITE(this->nVersion);
1239 READWRITE(hashPrev);
1240 READWRITE(hashMerkleRoot);
1246 uint256 GetBlockHash() const
1249 block.nVersion = nVersion;
1250 block.hashPrevBlock = hashPrev;
1251 block.hashMerkleRoot = hashMerkleRoot;
1252 block.nTime = nTime;
1253 block.nBits = nBits;
1254 block.nNonce = nNonce;
1255 return block.GetHash();
1259 std::string ToString() const
1261 std::string str = "CDiskBlockIndex(";
1262 str += CBlockIndex::ToString();
1263 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1264 GetBlockHash().ToString().c_str(),
1265 hashPrev.ToString().substr(0,20).c_str(),
1266 hashNext.ToString().substr(0,20).c_str());
1272 printf("%s\n", ToString().c_str());
1284 // Describes a place in the block chain to another node such that if the
1285 // other node doesn't have the same branch, it can find a recent common trunk.
1286 // The further back it is, the further before the fork it may be.
1291 std::vector<uint256> vHave;
1298 explicit CBlockLocator(const CBlockIndex* pindex)
1303 explicit CBlockLocator(uint256 hashBlock)
1305 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1306 if (mi != mapBlockIndex.end())
1312 if (!(nType & SER_GETHASH))
1313 READWRITE(nVersion);
1324 return vHave.empty();
1327 void Set(const CBlockIndex* pindex)
1333 vHave.push_back(pindex->GetBlockHash());
1335 // Exponentially larger steps back
1336 for (int i = 0; pindex && i < nStep; i++)
1337 pindex = pindex->pprev;
1338 if (vHave.size() > 10)
1341 vHave.push_back(hashGenesisBlock);
1344 int GetDistanceBack()
1346 // Retrace how far back it was in the sender's branch
1349 BOOST_FOREACH(const uint256& hash, vHave)
1351 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1352 if (mi != mapBlockIndex.end())
1354 CBlockIndex* pindex = (*mi).second;
1355 if (pindex->IsInMainChain())
1365 CBlockIndex* GetBlockIndex()
1367 // Find the first block the caller has in the main chain
1368 BOOST_FOREACH(const uint256& hash, vHave)
1370 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1371 if (mi != mapBlockIndex.end())
1373 CBlockIndex* pindex = (*mi).second;
1374 if (pindex->IsInMainChain())
1378 return pindexGenesisBlock;
1381 uint256 GetBlockHash()
1383 // Find the first block the caller has in the main chain
1384 BOOST_FOREACH(const uint256& hash, vHave)
1386 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1387 if (mi != mapBlockIndex.end())
1389 CBlockIndex* pindex = (*mi).second;
1390 if (pindex->IsInMainChain())
1394 return hashGenesisBlock;
1399 CBlockIndex* pindex = GetBlockIndex();
1402 return pindex->nHeight;
1415 // Alerts are for notifying old versions if they become too obsolete and
1416 // need to upgrade. The message is displayed in the status bar.
1417 // Alert messages are broadcast as a vector of signed data. Unserializing may
1418 // not read the entire buffer if the alert is for a newer version, but older
1419 // versions can still relay the original data.
1421 class CUnsignedAlert
1425 int64 nRelayUntil; // when newer nodes stop relaying to newer nodes
1429 std::set<int> setCancel;
1430 int nMinVer; // lowest version inclusive
1431 int nMaxVer; // highest version inclusive
1432 std::set<std::string> setSubVer; // empty matches all
1436 std::string strComment;
1437 std::string strStatusBar;
1438 std::string strReserved;
1442 READWRITE(this->nVersion);
1443 nVersion = this->nVersion;
1444 READWRITE(nRelayUntil);
1445 READWRITE(nExpiration);
1448 READWRITE(setCancel);
1451 READWRITE(setSubVer);
1452 READWRITE(nPriority);
1454 READWRITE(strComment);
1455 READWRITE(strStatusBar);
1456 READWRITE(strReserved);
1473 strStatusBar.clear();
1474 strReserved.clear();
1477 std::string ToString() const
1479 std::string strSetCancel;
1480 BOOST_FOREACH(int n, setCancel)
1481 strSetCancel += strprintf("%d ", n);
1482 std::string strSetSubVer;
1483 BOOST_FOREACH(std::string str, setSubVer)
1484 strSetSubVer += "\"" + str + "\" ";
1488 " nRelayUntil = %"PRI64d"\n"
1489 " nExpiration = %"PRI64d"\n"
1497 " strComment = \"%s\"\n"
1498 " strStatusBar = \"%s\"\n"
1505 strSetCancel.c_str(),
1508 strSetSubVer.c_str(),
1511 strStatusBar.c_str());
1516 printf("%s", ToString().c_str());
1520 class CAlert : public CUnsignedAlert
1523 std::vector<unsigned char> vchMsg;
1524 std::vector<unsigned char> vchSig;
1539 CUnsignedAlert::SetNull();
1546 return (nExpiration == 0);
1549 uint256 GetHash() const
1551 return SerializeHash(*this);
1554 bool IsInEffect() const
1556 return (GetAdjustedTime() < nExpiration);
1559 bool Cancels(const CAlert& alert) const
1562 return false; // this was a no-op before 31403
1563 return (alert.nID <= nCancel || setCancel.count(alert.nID));
1566 bool AppliesTo(int nVersion, std::string strSubVerIn) const
1568 return (IsInEffect() &&
1569 nMinVer <= nVersion && nVersion <= nMaxVer &&
1570 (setSubVer.empty() || setSubVer.count(strSubVerIn)));
1573 bool AppliesToMe() const
1575 return AppliesTo(VERSION, ::pszSubVer);
1578 bool RelayTo(CNode* pnode) const
1582 // returns true if wasn't already contained in the set
1583 if (pnode->setKnown.insert(GetHash()).second)
1585 if (AppliesTo(pnode->nVersion, pnode->strSubVer) ||
1587 GetAdjustedTime() < nRelayUntil)
1589 pnode->PushMessage("alert", *this);
1596 bool CheckSignature()
1599 if (!key.SetPubKey(ParseHex("04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284")))
1600 return error("CAlert::CheckSignature() : SetPubKey failed");
1601 if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig))
1602 return error("CAlert::CheckSignature() : verify signature failed");
1604 // Now unserialize the data
1605 CDataStream sMsg(vchMsg);
1606 sMsg >> *(CUnsignedAlert*)this;
1610 bool ProcessAlert();