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.
16 #include <io.h> /* for _commit */
31 class CRequestTracker;
34 static const unsigned int MAX_BLOCK_SIZE = 1000000;
35 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
36 static const int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
37 static const int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
38 static const int64 COIN = 100000000;
39 static const int64 CENT = 1000000;
40 static const int64 MIN_TX_FEE = 50000;
41 static const int64 MIN_RELAY_TX_FEE = 10000;
42 static const int64 MAX_MONEY = 21000000 * COIN;
43 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
44 static const int COINBASE_MATURITY = 100;
45 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
46 static const int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
48 static const int fHaveUPnP = true;
50 static const int fHaveUPnP = false;
54 extern CScript COINBASE_FLAGS;
61 extern CCriticalSection cs_main;
62 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
63 extern uint256 hashGenesisBlock;
64 extern CBlockIndex* pindexGenesisBlock;
65 extern int nBestHeight;
66 extern CBigNum bnBestChainWork;
67 extern CBigNum bnBestInvalidWork;
68 extern uint256 hashBestChain;
69 extern CBlockIndex* pindexBest;
70 extern unsigned int nTransactionsUpdated;
71 extern uint64 nLastBlockTx;
72 extern uint64 nLastBlockSize;
73 extern const std::string strMessageMagic;
74 extern double dHashesPerSec;
75 extern int64 nHPSTimerStart;
76 extern int64 nTimeBestReceived;
77 extern CCriticalSection cs_setpwalletRegistered;
78 extern std::set<CWallet*> setpwalletRegistered;
81 extern int64 nTransactionFee;
91 void RegisterWallet(CWallet* pwalletIn);
92 void UnregisterWallet(CWallet* pwalletIn);
93 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
94 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
95 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
96 FILE* AppendBlockFile(unsigned int& nFileRet);
97 bool LoadBlockIndex(bool fAllowNew=true);
98 void PrintBlockTree();
99 bool ProcessMessages(CNode* pfrom);
100 bool SendMessages(CNode* pto, bool fSendTrickle);
101 void GenerateBitcoins(bool fGenerate, CWallet* pwallet);
102 CBlock* CreateNewBlock(CReserveKey& reservekey);
103 void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
104 void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
105 bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
106 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
107 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
108 int GetNumBlocksOfPeers();
109 bool IsInitialBlockDownload();
110 std::string GetWarnings(std::string strFor);
123 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
125 /** Position on disk for a particular transaction. */
130 unsigned int nBlockPos;
138 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
141 nBlockPos = nBlockPosIn;
145 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
146 void SetNull() { nFile = -1; nBlockPos = 0; nTxPos = 0; }
147 bool IsNull() const { return (nFile == -1); }
149 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
151 return (a.nFile == b.nFile &&
152 a.nBlockPos == b.nBlockPos &&
153 a.nTxPos == b.nTxPos);
156 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
161 std::string ToString() const
166 return strprintf("(nFile=%d, nBlockPos=%d, nTxPos=%d)", nFile, nBlockPos, nTxPos);
171 printf("%s", ToString().c_str());
177 /** An inpoint - a combination of a transaction and an index n into its vin */
184 CInPoint() { SetNull(); }
185 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
186 void SetNull() { ptx = NULL; n = -1; }
187 bool IsNull() const { return (ptx == NULL && n == -1); }
192 /** An outpoint - a combination of a transaction hash and an index n into its vout */
199 COutPoint() { SetNull(); }
200 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
201 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
202 void SetNull() { hash = 0; n = -1; }
203 bool IsNull() const { return (hash == 0 && n == -1); }
205 friend bool operator<(const COutPoint& a, const COutPoint& b)
207 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
210 friend bool operator==(const COutPoint& a, const COutPoint& b)
212 return (a.hash == b.hash && a.n == b.n);
215 friend bool operator!=(const COutPoint& a, const COutPoint& b)
220 std::string ToString() const
222 return strprintf("COutPoint(%s, %d)", hash.ToString().substr(0,10).c_str(), n);
227 printf("%s\n", ToString().c_str());
234 /** An input of a transaction. It contains the location of the previous
235 * transaction's output that it claims and a signature that matches the
236 * output's public key.
243 unsigned int nSequence;
247 nSequence = std::numeric_limits<unsigned int>::max();
250 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
253 scriptSig = scriptSigIn;
254 nSequence = nSequenceIn;
257 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
259 prevout = COutPoint(hashPrevTx, nOut);
260 scriptSig = scriptSigIn;
261 nSequence = nSequenceIn;
267 READWRITE(scriptSig);
268 READWRITE(nSequence);
273 return (nSequence == std::numeric_limits<unsigned int>::max());
276 friend bool operator==(const CTxIn& a, const CTxIn& b)
278 return (a.prevout == b.prevout &&
279 a.scriptSig == b.scriptSig &&
280 a.nSequence == b.nSequence);
283 friend bool operator!=(const CTxIn& a, const CTxIn& b)
288 std::string ToString() const
292 str += prevout.ToString();
293 if (prevout.IsNull())
294 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
296 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
297 if (nSequence != std::numeric_limits<unsigned int>::max())
298 str += strprintf(", nSequence=%u", nSequence);
305 printf("%s\n", ToString().c_str());
312 /** An output of a transaction. It contains the public key that the next input
313 * must be able to sign with to claim it.
319 CScript scriptPubKey;
326 CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
329 scriptPubKey = scriptPubKeyIn;
335 READWRITE(scriptPubKey);
341 scriptPubKey.clear();
346 return (nValue == -1);
349 uint256 GetHash() const
351 return SerializeHash(*this);
354 friend bool operator==(const CTxOut& a, const CTxOut& b)
356 return (a.nValue == b.nValue &&
357 a.scriptPubKey == b.scriptPubKey);
360 friend bool operator!=(const CTxOut& a, const CTxOut& b)
365 std::string ToString() const
367 if (scriptPubKey.size() < 6)
368 return "CTxOut(error)";
369 return strprintf("CTxOut(nValue=%"PRI64d".%08"PRI64d", scriptPubKey=%s)", nValue / COIN, nValue % COIN, scriptPubKey.ToString().substr(0,30).c_str());
374 printf("%s\n", ToString().c_str());
388 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
390 /** The basic transaction that is broadcasted on the network and contained in
391 * blocks. A transaction can contain multiple inputs and outputs.
397 std::vector<CTxIn> vin;
398 std::vector<CTxOut> vout;
399 unsigned int nLockTime;
401 // Denial-of-service detection:
403 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
412 READWRITE(this->nVersion);
413 nVersion = this->nVersion;
416 READWRITE(nLockTime);
425 nDoS = 0; // Denial-of-service prevention
430 return (vin.empty() && vout.empty());
433 uint256 GetHash() const
435 return SerializeHash(*this);
438 bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
440 // Time based nLockTime implemented in 0.1.6
443 if (nBlockHeight == 0)
444 nBlockHeight = nBestHeight;
446 nBlockTime = GetAdjustedTime();
447 if ((int64)nLockTime < (nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
449 BOOST_FOREACH(const CTxIn& txin, vin)
455 bool IsNewerThan(const CTransaction& old) const
457 if (vin.size() != old.vin.size())
459 for (int i = 0; i < vin.size(); i++)
460 if (vin[i].prevout != old.vin[i].prevout)
464 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
465 for (int i = 0; i < vin.size(); i++)
467 if (vin[i].nSequence != old.vin[i].nSequence)
469 if (vin[i].nSequence <= nLowest)
472 nLowest = vin[i].nSequence;
474 if (old.vin[i].nSequence < nLowest)
477 nLowest = old.vin[i].nSequence;
484 bool IsCoinBase() const
486 return (vin.size() == 1 && vin[0].prevout.IsNull());
489 /** Check for standard transaction types
490 @return True if all outputs (scriptPubKeys) use only standard transaction forms
492 bool IsStandard() const;
494 /** Check for standard transaction types
495 @param[in] mapInputs Map of previous transactions that have outputs we're spending
496 @return True if all inputs (scriptSigs) use only standard transaction forms
497 @see CTransaction::FetchInputs
499 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
501 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
502 @return number of sigops this transaction's outputs will produce when spent
503 @see CTransaction::FetchInputs
505 int GetLegacySigOpCount() const;
507 /** Count ECDSA signature operations in pay-to-script-hash inputs.
509 @param[in] mapInputs Map of previous transactions that have outputs we're spending
510 @return maximum number of sigops required to validate this transaction's inputs
511 @see CTransaction::FetchInputs
513 int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
515 /** Amount of bitcoins spent by this transaction.
516 @return sum of all outputs (note: does not include fees)
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] mapInputs Map of previous transactions that have outputs we're spending
535 @return Sum 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, enum GetMinFee_mode mode=GMF_BLOCK) const
549 // Base fee is either MIN_TX_FEE or MIN_RELAY_TX_FEE
550 int64 nBaseFee = (mode == GMF_RELAY) ? 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] inputs Previous transactions (from FetchInputs)
674 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
675 @param[in] posThisTx Position 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);
690 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
697 /** A transaction with a merkle branch linking it to the block chain. */
698 class CMerkleTx : public CTransaction
702 std::vector<uint256> vMerkleBranch;
706 mutable char fMerkleVerified;
714 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
723 fMerkleVerified = false;
729 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
730 nVersion = this->nVersion;
731 READWRITE(hashBlock);
732 READWRITE(vMerkleBranch);
737 int SetMerkleBranch(const CBlock* pblock=NULL);
738 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
739 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
740 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
741 int GetBlocksToMaturity() const;
742 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
743 bool AcceptToMemoryPool();
749 /** A txdb record that contains the disk location of a transaction and the
750 * locations of transactions that spend its outputs. vSpent is really only
751 * used as a flag, but having the location is very helpful for debugging.
757 std::vector<CDiskTxPos> vSpent;
764 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
767 vSpent.resize(nOutputs);
772 if (!(nType & SER_GETHASH))
789 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
791 return (a.pos == b.pos &&
792 a.vSpent == b.vSpent);
795 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
799 int GetDepthInMainChain() const;
807 /** Nodes collect new transactions into a block, hash them into a hash tree,
808 * and scan through nonce values to make the block's hash satisfy proof-of-work
809 * requirements. When they solve the proof-of-work, they broadcast the block
810 * to everyone and the block is added to the block chain. The first transaction
811 * in the block is a special one that creates a new coin owned by the creator
814 * Blocks are appended to blk0001.dat files on disk. Their location on disk
815 * is indexed by CBlockIndex objects in memory.
822 uint256 hashPrevBlock;
823 uint256 hashMerkleRoot;
829 std::vector<CTransaction> vtx;
832 mutable std::vector<uint256> vMerkleTree;
834 // Denial-of-service detection:
836 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
845 READWRITE(this->nVersion);
846 nVersion = this->nVersion;
847 READWRITE(hashPrevBlock);
848 READWRITE(hashMerkleRoot);
853 // ConnectBlock depends on vtx being last so it can calculate offset
854 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
857 const_cast<CBlock*>(this)->vtx.clear();
878 uint256 GetHash() const
880 return Hash(BEGIN(nVersion), END(nNonce));
883 int64 GetBlockTime() const
888 void UpdateTime(const CBlockIndex* pindexPrev);
891 uint256 BuildMerkleTree() const
894 BOOST_FOREACH(const CTransaction& tx, vtx)
895 vMerkleTree.push_back(tx.GetHash());
897 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
899 for (int i = 0; i < nSize; i += 2)
901 int i2 = std::min(i+1, nSize-1);
902 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
903 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
907 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
910 std::vector<uint256> GetMerkleBranch(int nIndex) const
912 if (vMerkleTree.empty())
914 std::vector<uint256> vMerkleBranch;
916 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
918 int i = std::min(nIndex^1, nSize-1);
919 vMerkleBranch.push_back(vMerkleTree[j+i]);
923 return vMerkleBranch;
926 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
930 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
933 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
935 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
942 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
944 // Open history file to append
945 CAutoFile fileout = AppendBlockFile(nFileRet);
947 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
949 // Write index header
950 unsigned int nSize = fileout.GetSerializeSize(*this);
951 fileout << FLATDATA(pchMessageStart) << nSize;
954 nBlockPosRet = ftell(fileout);
955 if (nBlockPosRet == -1)
956 return error("CBlock::WriteToDisk() : ftell failed");
959 // Flush stdio buffers and commit to disk before returning
961 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
964 _commit(_fileno(fileout));
966 fsync(fileno(fileout));
973 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
977 // Open history file to read
978 CAutoFile filein = OpenBlockFile(nFile, nBlockPos, "rb");
980 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
981 if (!fReadTransactions)
982 filein.nType |= SER_BLOCKHEADERONLY;
988 if (!CheckProofOfWork(GetHash(), nBits))
989 return error("CBlock::ReadFromDisk() : errors in block header");
998 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%d)\n",
999 GetHash().ToString().substr(0,20).c_str(),
1001 hashPrevBlock.ToString().substr(0,20).c_str(),
1002 hashMerkleRoot.ToString().substr(0,10).c_str(),
1003 nTime, nBits, nNonce,
1005 for (int i = 0; i < vtx.size(); i++)
1010 printf(" vMerkleTree: ");
1011 for (int i = 0; i < vMerkleTree.size(); i++)
1012 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1017 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1018 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1019 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1020 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1021 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1022 bool CheckBlock() const;
1026 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1034 /** The block chain is a tree shaped structure starting with the
1035 * genesis block at the root, with each block potentially having multiple
1036 * candidates to be the next block. pprev and pnext link a path through the
1037 * main/longest chain. A blockindex may have multiple pprev pointing back
1038 * to it, but pnext will only point forward to the longest branch, or will
1039 * be null if the block is not part of the longest chain.
1044 const uint256* phashBlock;
1048 unsigned int nBlockPos;
1050 CBigNum bnChainWork;
1054 uint256 hashMerkleRoot;
1057 unsigned int nNonce;
1077 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1083 nBlockPos = nBlockPosIn;
1087 nVersion = block.nVersion;
1088 hashMerkleRoot = block.hashMerkleRoot;
1089 nTime = block.nTime;
1090 nBits = block.nBits;
1091 nNonce = block.nNonce;
1094 CBlock GetBlockHeader() const
1097 block.nVersion = nVersion;
1099 block.hashPrevBlock = pprev->GetBlockHash();
1100 block.hashMerkleRoot = hashMerkleRoot;
1101 block.nTime = nTime;
1102 block.nBits = nBits;
1103 block.nNonce = nNonce;
1107 uint256 GetBlockHash() const
1112 int64 GetBlockTime() const
1114 return (int64)nTime;
1117 CBigNum GetBlockWork() const
1120 bnTarget.SetCompact(nBits);
1123 return (CBigNum(1)<<256) / (bnTarget+1);
1126 bool IsInMainChain() const
1128 return (pnext || this == pindexBest);
1131 bool CheckIndex() const
1133 return CheckProofOfWork(GetBlockHash(), nBits);
1136 bool EraseBlockFromDisk()
1138 // Open history file
1139 CAutoFile fileout = OpenBlockFile(nFile, nBlockPos, "rb+");
1143 // Overwrite with empty null block
1151 enum { nMedianTimeSpan=11 };
1153 int64 GetMedianTimePast() const
1155 int64 pmedian[nMedianTimeSpan];
1156 int64* pbegin = &pmedian[nMedianTimeSpan];
1157 int64* pend = &pmedian[nMedianTimeSpan];
1159 const CBlockIndex* pindex = this;
1160 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1161 *(--pbegin) = pindex->GetBlockTime();
1163 std::sort(pbegin, pend);
1164 return pbegin[(pend - pbegin)/2];
1167 int64 GetMedianTime() const
1169 const CBlockIndex* pindex = this;
1170 for (int i = 0; i < nMedianTimeSpan/2; i++)
1173 return GetBlockTime();
1174 pindex = pindex->pnext;
1176 return pindex->GetMedianTimePast();
1181 std::string ToString() const
1183 return strprintf("CBlockIndex(nprev=%08x, pnext=%08x, nFile=%d, nBlockPos=%-6d nHeight=%d, merkle=%s, hashBlock=%s)",
1184 pprev, pnext, nFile, nBlockPos, nHeight,
1185 hashMerkleRoot.ToString().substr(0,10).c_str(),
1186 GetBlockHash().ToString().substr(0,20).c_str());
1191 printf("%s\n", ToString().c_str());
1197 /** Used to marshal pointers into hashes for db storage. */
1198 class CDiskBlockIndex : public CBlockIndex
1210 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1212 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1213 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1218 if (!(nType & SER_GETHASH))
1219 READWRITE(nVersion);
1221 READWRITE(hashNext);
1223 READWRITE(nBlockPos);
1227 READWRITE(this->nVersion);
1228 READWRITE(hashPrev);
1229 READWRITE(hashMerkleRoot);
1235 uint256 GetBlockHash() const
1238 block.nVersion = nVersion;
1239 block.hashPrevBlock = hashPrev;
1240 block.hashMerkleRoot = hashMerkleRoot;
1241 block.nTime = nTime;
1242 block.nBits = nBits;
1243 block.nNonce = nNonce;
1244 return block.GetHash();
1248 std::string ToString() const
1250 std::string str = "CDiskBlockIndex(";
1251 str += CBlockIndex::ToString();
1252 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1253 GetBlockHash().ToString().c_str(),
1254 hashPrev.ToString().substr(0,20).c_str(),
1255 hashNext.ToString().substr(0,20).c_str());
1261 printf("%s\n", ToString().c_str());
1272 /** Describes a place in the block chain to another node such that if the
1273 * other node doesn't have the same branch, it can find a recent common trunk.
1274 * The further back it is, the further before the fork it may be.
1279 std::vector<uint256> vHave;
1286 explicit CBlockLocator(const CBlockIndex* pindex)
1291 explicit CBlockLocator(uint256 hashBlock)
1293 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1294 if (mi != mapBlockIndex.end())
1298 CBlockLocator(const std::vector<uint256>& vHaveIn)
1305 if (!(nType & SER_GETHASH))
1306 READWRITE(nVersion);
1317 return vHave.empty();
1320 void Set(const CBlockIndex* pindex)
1326 vHave.push_back(pindex->GetBlockHash());
1328 // Exponentially larger steps back
1329 for (int i = 0; pindex && i < nStep; i++)
1330 pindex = pindex->pprev;
1331 if (vHave.size() > 10)
1334 vHave.push_back(hashGenesisBlock);
1337 int GetDistanceBack()
1339 // Retrace how far back it was in the sender's branch
1342 BOOST_FOREACH(const uint256& hash, vHave)
1344 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1345 if (mi != mapBlockIndex.end())
1347 CBlockIndex* pindex = (*mi).second;
1348 if (pindex->IsInMainChain())
1358 CBlockIndex* GetBlockIndex()
1360 // Find the first block the caller has in the main chain
1361 BOOST_FOREACH(const uint256& hash, vHave)
1363 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1364 if (mi != mapBlockIndex.end())
1366 CBlockIndex* pindex = (*mi).second;
1367 if (pindex->IsInMainChain())
1371 return pindexGenesisBlock;
1374 uint256 GetBlockHash()
1376 // Find the first block the caller has in the main chain
1377 BOOST_FOREACH(const uint256& hash, vHave)
1379 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1380 if (mi != mapBlockIndex.end())
1382 CBlockIndex* pindex = (*mi).second;
1383 if (pindex->IsInMainChain())
1387 return hashGenesisBlock;
1392 CBlockIndex* pindex = GetBlockIndex();
1395 return pindex->nHeight;
1407 /** Alerts are for notifying old versions if they become too obsolete and
1408 * need to upgrade. The message is displayed in the status bar.
1409 * Alert messages are broadcast as a vector of signed data. Unserializing may
1410 * not read the entire buffer if the alert is for a newer version, but older
1411 * versions can still relay the original data.
1413 class CUnsignedAlert
1417 int64 nRelayUntil; // when newer nodes stop relaying to newer nodes
1421 std::set<int> setCancel;
1422 int nMinVer; // lowest version inclusive
1423 int nMaxVer; // highest version inclusive
1424 std::set<std::string> setSubVer; // empty matches all
1428 std::string strComment;
1429 std::string strStatusBar;
1430 std::string strReserved;
1434 READWRITE(this->nVersion);
1435 nVersion = this->nVersion;
1436 READWRITE(nRelayUntil);
1437 READWRITE(nExpiration);
1440 READWRITE(setCancel);
1443 READWRITE(setSubVer);
1444 READWRITE(nPriority);
1446 READWRITE(strComment);
1447 READWRITE(strStatusBar);
1448 READWRITE(strReserved);
1465 strStatusBar.clear();
1466 strReserved.clear();
1469 std::string ToString() const
1471 std::string strSetCancel;
1472 BOOST_FOREACH(int n, setCancel)
1473 strSetCancel += strprintf("%d ", n);
1474 std::string strSetSubVer;
1475 BOOST_FOREACH(std::string str, setSubVer)
1476 strSetSubVer += "\"" + str + "\" ";
1480 " nRelayUntil = %"PRI64d"\n"
1481 " nExpiration = %"PRI64d"\n"
1489 " strComment = \"%s\"\n"
1490 " strStatusBar = \"%s\"\n"
1497 strSetCancel.c_str(),
1500 strSetSubVer.c_str(),
1503 strStatusBar.c_str());
1508 printf("%s", ToString().c_str());
1512 /** An alert is a combination of a serialized CUnsignedAlert and a signature. */
1513 class CAlert : public CUnsignedAlert
1516 std::vector<unsigned char> vchMsg;
1517 std::vector<unsigned char> vchSig;
1532 CUnsignedAlert::SetNull();
1539 return (nExpiration == 0);
1542 uint256 GetHash() const
1544 return SerializeHash(*this);
1547 bool IsInEffect() const
1549 return (GetAdjustedTime() < nExpiration);
1552 bool Cancels(const CAlert& alert) const
1555 return false; // this was a no-op before 31403
1556 return (alert.nID <= nCancel || setCancel.count(alert.nID));
1559 bool AppliesTo(int nVersion, std::string strSubVerIn) const
1561 // TODO: rework for client-version-embedded-in-strSubVer ?
1562 return (IsInEffect() &&
1563 nMinVer <= nVersion && nVersion <= nMaxVer &&
1564 (setSubVer.empty() || setSubVer.count(strSubVerIn)));
1567 bool AppliesToMe() const
1569 return AppliesTo(PROTOCOL_VERSION, FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, std::vector<std::string>()));
1572 bool RelayTo(CNode* pnode) const
1576 // returns true if wasn't already contained in the set
1577 if (pnode->setKnown.insert(GetHash()).second)
1579 if (AppliesTo(pnode->nVersion, pnode->strSubVer) ||
1581 GetAdjustedTime() < nRelayUntil)
1583 pnode->PushMessage("alert", *this);
1590 bool CheckSignature()
1593 if (!key.SetPubKey(ParseHex("04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284")))
1594 return error("CAlert::CheckSignature() : SetPubKey failed");
1595 if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig))
1596 return error("CAlert::CheckSignature() : verify signature failed");
1598 // Now unserialize the data
1599 CDataStream sMsg(vchMsg);
1600 sMsg >> *(CUnsignedAlert*)this;
1604 bool ProcessAlert();
1610 mutable CCriticalSection cs;
1611 std::map<uint256, CTransaction> mapTx;
1612 std::map<COutPoint, CInPoint> mapNextTx;
1614 bool accept(CTxDB& txdb, CTransaction &tx,
1615 bool fCheckInputs, bool* pfMissingInputs);
1616 bool addUnchecked(CTransaction &tx);
1617 bool remove(CTransaction &tx);
1619 unsigned long size()
1622 return mapTx.size();
1626 extern CTxMemPool mempool;