1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2012 The Bitcoin developers
3 // Distributed under the MIT/X11 software license, see the accompanying
4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
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");
608 catch (std::exception &e) {
609 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
612 // Return file pointer
615 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
616 return error("CTransaction::ReadFromDisk() : second fseek failed");
617 *pfileRet = filein.release();
622 friend bool operator==(const CTransaction& a, const CTransaction& b)
624 return (a.nVersion == b.nVersion &&
627 a.nLockTime == b.nLockTime);
630 friend bool operator!=(const CTransaction& a, const CTransaction& b)
636 std::string ToString() const
639 str += strprintf("CTransaction(hash=%s, ver=%d, vin.size=%d, vout.size=%d, nLockTime=%d)\n",
640 GetHash().ToString().substr(0,10).c_str(),
645 for (unsigned int i = 0; i < vin.size(); i++)
646 str += " " + vin[i].ToString() + "\n";
647 for (unsigned int i = 0; i < vout.size(); i++)
648 str += " " + vout[i].ToString() + "\n";
654 printf("%s", ToString().c_str());
658 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
659 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
660 bool ReadFromDisk(COutPoint prevout);
661 bool DisconnectInputs(CTxDB& txdb);
663 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
665 @param[in] txdb Transaction database
666 @param[in] mapTestPool List of pending changes to the transaction index database
667 @param[in] fBlock True if being called to add a new best-block to the chain
668 @param[in] fMiner True if being called by CreateNewBlock
669 @param[out] inputsRet Pointers to this transaction's inputs
670 @param[out] fInvalid returns true if transaction is invalid
671 @return Returns true if all inputs are in txdb or mapTestPool
673 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
674 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
676 /** Sanity check previous transactions, then, if all checks succeed,
677 mark them as spent by this transaction.
679 @param[in] inputsPrevious transactions (from FetchInputs)
680 @param[out] mapTestPoolKeeps track of inputs that need to be updated on disk
681 @param[in] posThisTxPosition of this transaction on disk
682 @param[in] pindexBlock
683 @param[in] fBlock true if called from ConnectBlock
684 @param[in] fMiner true if called from CreateNewBlock
685 @param[in] fStrictPayToScriptHash true if fully validating p2sh transactions
686 @return Returns true if all checks succeed
688 bool ConnectInputs(MapPrevTx inputs,
689 std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
690 const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash=true);
691 bool ClientConnectInputs();
692 bool CheckTransaction() const;
693 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
694 bool AcceptToMemoryPool(bool fCheckInputs=true, bool* pfMissingInputs=NULL);
696 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
697 bool AddToMemoryPoolUnchecked();
699 bool RemoveFromMemoryPool();
707 // A transaction with a merkle branch linking it to the block chain
709 class CMerkleTx : public CTransaction
713 std::vector<uint256> vMerkleBranch;
717 mutable char fMerkleVerified;
725 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
734 fMerkleVerified = false;
740 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
741 nVersion = this->nVersion;
742 READWRITE(hashBlock);
743 READWRITE(vMerkleBranch);
748 int SetMerkleBranch(const CBlock* pblock=NULL);
749 int GetDepthInMainChain(int& nHeightRet) const;
750 int GetDepthInMainChain() const { int nHeight; return GetDepthInMainChain(nHeight); }
751 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
752 int GetBlocksToMaturity() const;
753 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
754 bool AcceptToMemoryPool();
761 // A txdb record that contains the disk location of a transaction and the
762 // locations of transactions that spend its outputs. vSpent is really only
763 // used as a flag, but having the location is very helpful for debugging.
769 std::vector<CDiskTxPos> vSpent;
776 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
779 vSpent.resize(nOutputs);
784 if (!(nType & SER_GETHASH))
801 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
803 return (a.pos == b.pos &&
804 a.vSpent == b.vSpent);
807 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
811 int GetDepthInMainChain() const;
819 // Nodes collect new transactions into a block, hash them into a hash tree,
820 // and scan through nonce values to make the block's hash satisfy proof-of-work
821 // requirements. When they solve the proof-of-work, they broadcast the block
822 // to everyone and the block is added to the block chain. The first transaction
823 // in the block is a special one that creates a new coin owned by the creator
826 // Blocks are appended to blk0001.dat files on disk. Their location on disk
827 // is indexed by CBlockIndex objects in memory.
834 uint256 hashPrevBlock;
835 uint256 hashMerkleRoot;
841 std::vector<CTransaction> vtx;
844 mutable std::vector<uint256> vMerkleTree;
854 READWRITE(this->nVersion);
855 nVersion = this->nVersion;
856 READWRITE(hashPrevBlock);
857 READWRITE(hashMerkleRoot);
862 // ConnectBlock depends on vtx being last so it can calculate offset
863 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
866 const_cast<CBlock*>(this)->vtx.clear();
886 uint256 GetHash() const
888 return Hash(BEGIN(nVersion), END(nNonce));
891 int64 GetBlockTime() const
896 int GetSigOpCount() const
899 BOOST_FOREACH(const CTransaction& tx, vtx)
900 n += tx.GetSigOpCount();
904 void UpdateTime(const CBlockIndex* pindexPrev);
907 uint256 BuildMerkleTree() const
910 BOOST_FOREACH(const CTransaction& tx, vtx)
911 vMerkleTree.push_back(tx.GetHash());
913 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
915 for (int i = 0; i < nSize; i += 2)
917 int i2 = std::min(i+1, nSize-1);
918 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
919 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
923 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
926 std::vector<uint256> GetMerkleBranch(int nIndex) const
928 if (vMerkleTree.empty())
930 std::vector<uint256> vMerkleBranch;
932 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
934 int i = std::min(nIndex^1, nSize-1);
935 vMerkleBranch.push_back(vMerkleTree[j+i]);
939 return vMerkleBranch;
942 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
946 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
949 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
951 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
958 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
960 // Open history file to append
961 CAutoFile fileout = AppendBlockFile(nFileRet);
963 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
965 // Write index header
966 unsigned int nSize = fileout.GetSerializeSize(*this);
967 fileout << FLATDATA(pchMessageStart) << nSize;
970 long fileOutPos = ftell(fileout);
972 return error("CBlock::WriteToDisk() : ftell failed");
973 nBlockPosRet = fileOutPos;
976 // Flush stdio buffers and commit to disk before returning
978 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
981 _commit(_fileno(fileout));
983 fsync(fileno(fileout));
990 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
994 // Open history file to read
995 CAutoFile filein = OpenBlockFile(nFile, nBlockPos, "rb");
997 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
998 if (!fReadTransactions)
999 filein.nType |= SER_BLOCKHEADERONLY;
1005 catch (std::exception &e) {
1006 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1010 if (!CheckProofOfWork(GetHash(), nBits))
1011 return error("CBlock::ReadFromDisk() : errors in block header");
1020 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%d)\n",
1021 GetHash().ToString().substr(0,20).c_str(),
1023 hashPrevBlock.ToString().substr(0,20).c_str(),
1024 hashMerkleRoot.ToString().substr(0,10).c_str(),
1025 nTime, nBits, nNonce,
1027 for (unsigned int i = 0; i < vtx.size(); i++)
1032 printf(" vMerkleTree: ");
1033 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1034 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1039 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1040 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1041 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1042 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1043 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1044 bool CheckBlock() const;
1054 // The block chain is a tree shaped structure starting with the
1055 // genesis block at the root, with each block potentially having multiple
1056 // candidates to be the next block. pprev and pnext link a path through the
1057 // main/longest chain. A blockindex may have multiple pprev pointing back
1058 // to it, but pnext will only point forward to the longest branch, or will
1059 // be null if the block is not part of the longest chain.
1064 const uint256* phashBlock;
1068 unsigned int nBlockPos;
1070 CBigNum bnChainWork;
1074 uint256 hashMerkleRoot;
1077 unsigned int nNonce;
1097 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1103 nBlockPos = nBlockPosIn;
1107 nVersion = block.nVersion;
1108 hashMerkleRoot = block.hashMerkleRoot;
1109 nTime = block.nTime;
1110 nBits = block.nBits;
1111 nNonce = block.nNonce;
1114 CBlock GetBlockHeader() const
1117 block.nVersion = nVersion;
1119 block.hashPrevBlock = pprev->GetBlockHash();
1120 block.hashMerkleRoot = hashMerkleRoot;
1121 block.nTime = nTime;
1122 block.nBits = nBits;
1123 block.nNonce = nNonce;
1127 uint256 GetBlockHash() const
1132 int64 GetBlockTime() const
1134 return (int64)nTime;
1137 CBigNum GetBlockWork() const
1140 bnTarget.SetCompact(nBits);
1143 return (CBigNum(1)<<256) / (bnTarget+1);
1146 bool IsInMainChain() const
1148 return (pnext || this == pindexBest);
1151 bool CheckIndex() const
1153 return CheckProofOfWork(GetBlockHash(), nBits);
1156 bool EraseBlockFromDisk()
1158 // Open history file
1159 CAutoFile fileout = OpenBlockFile(nFile, nBlockPos, "rb+");
1163 // Overwrite with empty null block
1171 enum { nMedianTimeSpan=11 };
1173 int64 GetMedianTimePast() const
1175 int64 pmedian[nMedianTimeSpan];
1176 int64* pbegin = &pmedian[nMedianTimeSpan];
1177 int64* pend = &pmedian[nMedianTimeSpan];
1179 const CBlockIndex* pindex = this;
1180 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1181 *(--pbegin) = pindex->GetBlockTime();
1183 std::sort(pbegin, pend);
1184 return pbegin[(pend - pbegin)/2];
1187 int64 GetMedianTime() const
1189 const CBlockIndex* pindex = this;
1190 for (int i = 0; i < nMedianTimeSpan/2; i++)
1193 return GetBlockTime();
1194 pindex = pindex->pnext;
1196 return pindex->GetMedianTimePast();
1201 std::string ToString() const
1203 return strprintf("CBlockIndex(nprev=%08x, pnext=%08x, nFile=%d, nBlockPos=%-6d nHeight=%d, merkle=%s, hashBlock=%s)",
1204 pprev, pnext, nFile, nBlockPos, nHeight,
1205 hashMerkleRoot.ToString().substr(0,10).c_str(),
1206 GetBlockHash().ToString().substr(0,20).c_str());
1211 printf("%s\n", ToString().c_str());
1218 // Used to marshal pointers into hashes for db storage.
1220 class CDiskBlockIndex : public CBlockIndex
1232 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1234 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1235 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1240 if (!(nType & SER_GETHASH))
1241 READWRITE(nVersion);
1243 READWRITE(hashNext);
1245 READWRITE(nBlockPos);
1249 READWRITE(this->nVersion);
1250 READWRITE(hashPrev);
1251 READWRITE(hashMerkleRoot);
1257 uint256 GetBlockHash() const
1260 block.nVersion = nVersion;
1261 block.hashPrevBlock = hashPrev;
1262 block.hashMerkleRoot = hashMerkleRoot;
1263 block.nTime = nTime;
1264 block.nBits = nBits;
1265 block.nNonce = nNonce;
1266 return block.GetHash();
1270 std::string ToString() const
1272 std::string str = "CDiskBlockIndex(";
1273 str += CBlockIndex::ToString();
1274 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1275 GetBlockHash().ToString().c_str(),
1276 hashPrev.ToString().substr(0,20).c_str(),
1277 hashNext.ToString().substr(0,20).c_str());
1283 printf("%s\n", ToString().c_str());
1295 // Describes a place in the block chain to another node such that if the
1296 // other node doesn't have the same branch, it can find a recent common trunk.
1297 // The further back it is, the further before the fork it may be.
1302 std::vector<uint256> vHave;
1309 explicit CBlockLocator(const CBlockIndex* pindex)
1314 explicit CBlockLocator(uint256 hashBlock)
1316 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1317 if (mi != mapBlockIndex.end())
1323 if (!(nType & SER_GETHASH))
1324 READWRITE(nVersion);
1335 return vHave.empty();
1338 void Set(const CBlockIndex* pindex)
1344 vHave.push_back(pindex->GetBlockHash());
1346 // Exponentially larger steps back
1347 for (int i = 0; pindex && i < nStep; i++)
1348 pindex = pindex->pprev;
1349 if (vHave.size() > 10)
1352 vHave.push_back(hashGenesisBlock);
1355 int GetDistanceBack()
1357 // Retrace how far back it was in the sender's branch
1360 BOOST_FOREACH(const uint256& hash, vHave)
1362 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1363 if (mi != mapBlockIndex.end())
1365 CBlockIndex* pindex = (*mi).second;
1366 if (pindex->IsInMainChain())
1376 CBlockIndex* GetBlockIndex()
1378 // Find the first block the caller has in the main chain
1379 BOOST_FOREACH(const uint256& hash, vHave)
1381 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1382 if (mi != mapBlockIndex.end())
1384 CBlockIndex* pindex = (*mi).second;
1385 if (pindex->IsInMainChain())
1389 return pindexGenesisBlock;
1392 uint256 GetBlockHash()
1394 // Find the first block the caller has in the main chain
1395 BOOST_FOREACH(const uint256& hash, vHave)
1397 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1398 if (mi != mapBlockIndex.end())
1400 CBlockIndex* pindex = (*mi).second;
1401 if (pindex->IsInMainChain())
1405 return hashGenesisBlock;
1410 CBlockIndex* pindex = GetBlockIndex();
1413 return pindex->nHeight;
1426 // Alerts are for notifying old versions if they become too obsolete and
1427 // need to upgrade. The message is displayed in the status bar.
1428 // Alert messages are broadcast as a vector of signed data. Unserializing may
1429 // not read the entire buffer if the alert is for a newer version, but older
1430 // versions can still relay the original data.
1432 class CUnsignedAlert
1436 int64 nRelayUntil; // when newer nodes stop relaying to newer nodes
1440 std::set<int> setCancel;
1441 int nMinVer; // lowest version inclusive
1442 int nMaxVer; // highest version inclusive
1443 std::set<std::string> setSubVer; // empty matches all
1447 std::string strComment;
1448 std::string strStatusBar;
1449 std::string strReserved;
1453 READWRITE(this->nVersion);
1454 nVersion = this->nVersion;
1455 READWRITE(nRelayUntil);
1456 READWRITE(nExpiration);
1459 READWRITE(setCancel);
1462 READWRITE(setSubVer);
1463 READWRITE(nPriority);
1465 READWRITE(strComment);
1466 READWRITE(strStatusBar);
1467 READWRITE(strReserved);
1484 strStatusBar.clear();
1485 strReserved.clear();
1488 std::string ToString() const
1490 std::string strSetCancel;
1491 BOOST_FOREACH(int n, setCancel)
1492 strSetCancel += strprintf("%d ", n);
1493 std::string strSetSubVer;
1494 BOOST_FOREACH(std::string str, setSubVer)
1495 strSetSubVer += "\"" + str + "\" ";
1499 " nRelayUntil = %"PRI64d"\n"
1500 " nExpiration = %"PRI64d"\n"
1508 " strComment = \"%s\"\n"
1509 " strStatusBar = \"%s\"\n"
1516 strSetCancel.c_str(),
1519 strSetSubVer.c_str(),
1522 strStatusBar.c_str());
1527 printf("%s", ToString().c_str());
1531 class CAlert : public CUnsignedAlert
1534 std::vector<unsigned char> vchMsg;
1535 std::vector<unsigned char> vchSig;
1550 CUnsignedAlert::SetNull();
1557 return (nExpiration == 0);
1560 uint256 GetHash() const
1562 return SerializeHash(*this);
1565 bool IsInEffect() const
1567 return (GetAdjustedTime() < nExpiration);
1570 bool Cancels(const CAlert& alert) const
1573 return false; // this was a no-op before 31403
1574 return (alert.nID <= nCancel || setCancel.count(alert.nID));
1577 bool AppliesTo(int nVersion, std::string strSubVerIn) const
1579 return (IsInEffect() &&
1580 nMinVer <= nVersion && nVersion <= nMaxVer &&
1581 (setSubVer.empty() || setSubVer.count(strSubVerIn)));
1584 bool AppliesToMe() const
1586 return AppliesTo(VERSION, ::pszSubVer);
1589 bool RelayTo(CNode* pnode) const
1593 // returns true if wasn't already contained in the set
1594 if (pnode->setKnown.insert(GetHash()).second)
1596 if (AppliesTo(pnode->nVersion, pnode->strSubVer) ||
1598 GetAdjustedTime() < nRelayUntil)
1600 pnode->PushMessage("alert", *this);
1607 bool CheckSignature()
1610 if (!key.SetPubKey(ParseHex("04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284")))
1611 return error("CAlert::CheckSignature() : SetPubKey failed");
1612 if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig))
1613 return error("CAlert::CheckSignature() : verify signature failed");
1615 // Now unserialize the data
1616 CDataStream sMsg(vchMsg);
1617 sMsg >> *(CUnsignedAlert*)this;
1621 bool ProcessAlert();