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 ProcessBlock(CNode* pfrom, CBlock* pblock);
90 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
91 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
92 FILE* AppendBlockFile(unsigned int& nFileRet);
93 bool LoadBlockIndex(bool fAllowNew=true);
94 void PrintBlockTree();
95 bool ProcessMessages(CNode* pfrom);
96 bool SendMessages(CNode* pto, bool fSendTrickle);
97 void GenerateBitcoins(bool fGenerate, CWallet* pwallet);
98 CBlock* CreateNewBlock(CReserveKey& reservekey);
99 void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
100 void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
101 bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
102 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
103 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
104 int GetNumBlocksOfPeers();
105 bool IsInitialBlockDownload();
106 std::string GetWarnings(std::string strFor);
119 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
122 bool WriteSetting(const std::string& strKey, const T& value)
125 BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
127 std::string strWalletFile;
128 if (!GetWalletFile(pwallet, strWalletFile))
130 fOk |= CWalletDB(strWalletFile).WriteSetting(strKey, value);
140 unsigned int nBlockPos;
148 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
151 nBlockPos = nBlockPosIn;
155 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
156 void SetNull() { nFile = -1; nBlockPos = 0; nTxPos = 0; }
157 bool IsNull() const { return (nFile == -1); }
159 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
161 return (a.nFile == b.nFile &&
162 a.nBlockPos == b.nBlockPos &&
163 a.nTxPos == b.nTxPos);
166 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
171 std::string ToString() const
174 return strprintf("null");
176 return strprintf("(nFile=%d, nBlockPos=%d, nTxPos=%d)", nFile, nBlockPos, nTxPos);
181 printf("%s", ToString().c_str());
194 CInPoint() { SetNull(); }
195 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
196 void SetNull() { ptx = NULL; n = -1; }
197 bool IsNull() const { return (ptx == NULL && n == -1); }
209 COutPoint() { SetNull(); }
210 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
211 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
212 void SetNull() { hash = 0; n = -1; }
213 bool IsNull() const { return (hash == 0 && n == -1); }
215 friend bool operator<(const COutPoint& a, const COutPoint& b)
217 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
220 friend bool operator==(const COutPoint& a, const COutPoint& b)
222 return (a.hash == b.hash && a.n == b.n);
225 friend bool operator!=(const COutPoint& a, const COutPoint& b)
230 std::string ToString() const
232 return strprintf("COutPoint(%s, %d)", hash.ToString().substr(0,10).c_str(), n);
237 printf("%s\n", ToString().c_str());
245 // An input of a transaction. It contains the location of the previous
246 // transaction's output that it claims and a signature that matches the
247 // output's public key.
254 unsigned int nSequence;
258 nSequence = UINT_MAX;
261 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=UINT_MAX)
264 scriptSig = scriptSigIn;
265 nSequence = nSequenceIn;
268 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=UINT_MAX)
270 prevout = COutPoint(hashPrevTx, nOut);
271 scriptSig = scriptSigIn;
272 nSequence = nSequenceIn;
278 READWRITE(scriptSig);
279 READWRITE(nSequence);
284 return (nSequence == UINT_MAX);
287 friend bool operator==(const CTxIn& a, const CTxIn& b)
289 return (a.prevout == b.prevout &&
290 a.scriptSig == b.scriptSig &&
291 a.nSequence == b.nSequence);
294 friend bool operator!=(const CTxIn& a, const CTxIn& b)
299 std::string ToString() const
302 str += strprintf("CTxIn(");
303 str += prevout.ToString();
304 if (prevout.IsNull())
305 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
307 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
308 if (nSequence != UINT_MAX)
309 str += strprintf(", nSequence=%u", nSequence);
316 printf("%s\n", ToString().c_str());
324 // An output of a transaction. It contains the public key that the next input
325 // must be able to sign with to claim it.
331 CScript scriptPubKey;
338 CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
341 scriptPubKey = scriptPubKeyIn;
347 READWRITE(scriptPubKey);
353 scriptPubKey.clear();
358 return (nValue == -1);
361 uint256 GetHash() const
363 return SerializeHash(*this);
366 friend bool operator==(const CTxOut& a, const CTxOut& b)
368 return (a.nValue == b.nValue &&
369 a.scriptPubKey == b.scriptPubKey);
372 friend bool operator!=(const CTxOut& a, const CTxOut& b)
377 std::string ToString() const
379 if (scriptPubKey.size() < 6)
380 return "CTxOut(error)";
381 return strprintf("CTxOut(nValue=%"PRI64d".%08"PRI64d", scriptPubKey=%s)", nValue / COIN, nValue % COIN, scriptPubKey.ToString().substr(0,30).c_str());
386 printf("%s\n", ToString().c_str());
391 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
395 // The basic transaction that is broadcasted on the network and contained in
396 // blocks. A transaction can contain multiple inputs and outputs.
402 std::vector<CTxIn> vin;
403 std::vector<CTxOut> vout;
404 unsigned int nLockTime;
406 // Denial-of-service detection:
408 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
417 READWRITE(this->nVersion);
418 nVersion = this->nVersion;
421 READWRITE(nLockTime);
430 nDoS = 0; // Denial-of-service prevention
435 return (vin.empty() && vout.empty());
438 uint256 GetHash() const
440 return SerializeHash(*this);
443 bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
445 // Time based nLockTime implemented in 0.1.6
448 if (nBlockHeight == 0)
449 nBlockHeight = nBestHeight;
451 nBlockTime = GetAdjustedTime();
452 if ((int64)nLockTime < (nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
454 BOOST_FOREACH(const CTxIn& txin, vin)
460 bool IsNewerThan(const CTransaction& old) const
462 if (vin.size() != old.vin.size())
464 for (unsigned int i = 0; i < vin.size(); i++)
465 if (vin[i].prevout != old.vin[i].prevout)
469 unsigned int nLowest = UINT_MAX;
470 for (unsigned int i = 0; i < vin.size(); i++)
472 if (vin[i].nSequence != old.vin[i].nSequence)
474 if (vin[i].nSequence <= nLowest)
477 nLowest = vin[i].nSequence;
479 if (old.vin[i].nSequence < nLowest)
482 nLowest = old.vin[i].nSequence;
489 bool IsCoinBase() const
491 return (vin.size() == 1 && vin[0].prevout.IsNull());
494 int GetSigOpCount() const
497 BOOST_FOREACH(const CTxIn& txin, vin)
498 n += txin.scriptSig.GetSigOpCount();
499 BOOST_FOREACH(const CTxOut& txout, vout)
500 n += txout.scriptPubKey.GetSigOpCount();
504 /** Count ECDSA signature operations in pay-to-script-hash inputs.
505 This is a better measure of how expensive it is to process this transaction.
507 @param[in] mapInputsMap of previous transactions that have outputs we're spending
508 @return maximum number of sigops required to validate this transaction's inputs
509 @see CTransaction::FetchInputs
511 int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
513 bool IsStandard() const
515 BOOST_FOREACH(const CTxIn& txin, vin)
516 if (!txin.scriptSig.IsPushOnly())
517 return error("nonstandard txin: %s", txin.scriptSig.ToString().c_str());
518 BOOST_FOREACH(const CTxOut& txout, vout)
519 if (!::IsStandard(txout.scriptPubKey))
520 return error("nonstandard txout: %s", txout.scriptPubKey.ToString().c_str());
524 int64 GetValueOut() const
527 BOOST_FOREACH(const CTxOut& txout, vout)
529 nValueOut += txout.nValue;
530 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
531 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
536 /** Amount of bitcoins coming in to this transaction
537 Note that lightweight clients may not know anything besides the hash of previous transactions,
538 so may not be able to calculate this.
540 @param[in] mapInputsMap of previous transactions that have outputs we're spending
541 @returnSum of value of all inputs (scriptSigs)
542 @see CTransaction::FetchInputs
544 int64 GetValueIn(const MapPrevTx& mapInputs) const;
546 static bool AllowFree(double dPriority)
548 // Large (in bytes) low-priority (new, small-coin) transactions
550 return dPriority > COIN * 144 / 250;
553 int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=true, bool fForRelay=false) const
555 // Base fee is either MIN_TX_FEE or MIN_RELAY_TX_FEE
556 int64 nBaseFee = fForRelay ? MIN_RELAY_TX_FEE : MIN_TX_FEE;
558 unsigned int nBytes = ::GetSerializeSize(*this, SER_NETWORK);
559 unsigned int nNewBlockSize = nBlockSize + nBytes;
560 int64 nMinFee = (1 + (int64)nBytes / 1000) * nBaseFee;
566 // Transactions under 10K are free
567 // (about 4500bc if made of 50bc inputs)
573 // Free transaction area
574 if (nNewBlockSize < 27000)
579 // To limit dust spam, require MIN_TX_FEE/MIN_RELAY_TX_FEE if any output is less than 0.01
580 if (nMinFee < nBaseFee)
582 BOOST_FOREACH(const CTxOut& txout, vout)
583 if (txout.nValue < CENT)
587 // Raise the price as the block approaches full
588 if (nBlockSize != 1 && nNewBlockSize >= MAX_BLOCK_SIZE_GEN/2)
590 if (nNewBlockSize >= MAX_BLOCK_SIZE_GEN)
592 nMinFee *= MAX_BLOCK_SIZE_GEN / (MAX_BLOCK_SIZE_GEN - nNewBlockSize);
595 if (!MoneyRange(nMinFee))
601 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
603 CAutoFile filein = OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb");
605 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
608 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
609 return error("CTransaction::ReadFromDisk() : fseek failed");
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;
846 // Denial-of-service detection:
848 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
857 READWRITE(this->nVersion);
858 nVersion = this->nVersion;
859 READWRITE(hashPrevBlock);
860 READWRITE(hashMerkleRoot);
865 // ConnectBlock depends on vtx being last so it can calculate offset
866 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
869 const_cast<CBlock*>(this)->vtx.clear();
890 uint256 GetHash() const
892 return Hash(BEGIN(nVersion), END(nNonce));
895 int64 GetBlockTime() const
900 int GetSigOpCount() const
903 BOOST_FOREACH(const CTransaction& tx, vtx)
904 n += tx.GetSigOpCount();
908 void UpdateTime(const CBlockIndex* pindexPrev);
911 uint256 BuildMerkleTree() const
914 BOOST_FOREACH(const CTransaction& tx, vtx)
915 vMerkleTree.push_back(tx.GetHash());
917 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
919 for (int i = 0; i < nSize; i += 2)
921 int i2 = std::min(i+1, nSize-1);
922 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
923 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
927 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
930 std::vector<uint256> GetMerkleBranch(int nIndex) const
932 if (vMerkleTree.empty())
934 std::vector<uint256> vMerkleBranch;
936 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
938 int i = std::min(nIndex^1, nSize-1);
939 vMerkleBranch.push_back(vMerkleTree[j+i]);
943 return vMerkleBranch;
946 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
950 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
953 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
955 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
962 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
964 // Open history file to append
965 CAutoFile fileout = AppendBlockFile(nFileRet);
967 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
969 // Write index header
970 unsigned int nSize = fileout.GetSerializeSize(*this);
971 fileout << FLATDATA(pchMessageStart) << nSize;
974 long fileOutPos = ftell(fileout);
976 return error("CBlock::WriteToDisk() : ftell failed");
977 nBlockPosRet = fileOutPos;
980 // Flush stdio buffers and commit to disk before returning
982 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
985 _commit(_fileno(fileout));
987 fsync(fileno(fileout));
994 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
998 // Open history file to read
999 CAutoFile filein = OpenBlockFile(nFile, nBlockPos, "rb");
1001 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1002 if (!fReadTransactions)
1003 filein.nType |= SER_BLOCKHEADERONLY;
1009 if (!CheckProofOfWork(GetHash(), nBits))
1010 return error("CBlock::ReadFromDisk() : errors in block header");
1019 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%d)\n",
1020 GetHash().ToString().substr(0,20).c_str(),
1022 hashPrevBlock.ToString().substr(0,20).c_str(),
1023 hashMerkleRoot.ToString().substr(0,10).c_str(),
1024 nTime, nBits, nNonce,
1026 for (unsigned int i = 0; i < vtx.size(); i++)
1031 printf(" vMerkleTree: ");
1032 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1033 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1038 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1039 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1040 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1041 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1042 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1043 bool CheckBlock() const;
1053 // The block chain is a tree shaped structure starting with the
1054 // genesis block at the root, with each block potentially having multiple
1055 // candidates to be the next block. pprev and pnext link a path through the
1056 // main/longest chain. A blockindex may have multiple pprev pointing back
1057 // to it, but pnext will only point forward to the longest branch, or will
1058 // be null if the block is not part of the longest chain.
1063 const uint256* phashBlock;
1067 unsigned int nBlockPos;
1069 CBigNum bnChainWork;
1073 uint256 hashMerkleRoot;
1076 unsigned int nNonce;
1096 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1102 nBlockPos = nBlockPosIn;
1106 nVersion = block.nVersion;
1107 hashMerkleRoot = block.hashMerkleRoot;
1108 nTime = block.nTime;
1109 nBits = block.nBits;
1110 nNonce = block.nNonce;
1113 CBlock GetBlockHeader() const
1116 block.nVersion = nVersion;
1118 block.hashPrevBlock = pprev->GetBlockHash();
1119 block.hashMerkleRoot = hashMerkleRoot;
1120 block.nTime = nTime;
1121 block.nBits = nBits;
1122 block.nNonce = nNonce;
1126 uint256 GetBlockHash() const
1131 int64 GetBlockTime() const
1133 return (int64)nTime;
1136 CBigNum GetBlockWork() const
1139 bnTarget.SetCompact(nBits);
1142 return (CBigNum(1)<<256) / (bnTarget+1);
1145 bool IsInMainChain() const
1147 return (pnext || this == pindexBest);
1150 bool CheckIndex() const
1152 return CheckProofOfWork(GetBlockHash(), nBits);
1155 bool EraseBlockFromDisk()
1157 // Open history file
1158 CAutoFile fileout = OpenBlockFile(nFile, nBlockPos, "rb+");
1162 // Overwrite with empty null block
1170 enum { nMedianTimeSpan=11 };
1172 int64 GetMedianTimePast() const
1174 int64 pmedian[nMedianTimeSpan];
1175 int64* pbegin = &pmedian[nMedianTimeSpan];
1176 int64* pend = &pmedian[nMedianTimeSpan];
1178 const CBlockIndex* pindex = this;
1179 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1180 *(--pbegin) = pindex->GetBlockTime();
1182 std::sort(pbegin, pend);
1183 return pbegin[(pend - pbegin)/2];
1186 int64 GetMedianTime() const
1188 const CBlockIndex* pindex = this;
1189 for (int i = 0; i < nMedianTimeSpan/2; i++)
1192 return GetBlockTime();
1193 pindex = pindex->pnext;
1195 return pindex->GetMedianTimePast();
1200 std::string ToString() const
1202 return strprintf("CBlockIndex(nprev=%08x, pnext=%08x, nFile=%d, nBlockPos=%-6d nHeight=%d, merkle=%s, hashBlock=%s)",
1203 pprev, pnext, nFile, nBlockPos, nHeight,
1204 hashMerkleRoot.ToString().substr(0,10).c_str(),
1205 GetBlockHash().ToString().substr(0,20).c_str());
1210 printf("%s\n", ToString().c_str());
1217 // Used to marshal pointers into hashes for db storage.
1219 class CDiskBlockIndex : public CBlockIndex
1231 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1233 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1234 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1239 if (!(nType & SER_GETHASH))
1240 READWRITE(nVersion);
1242 READWRITE(hashNext);
1244 READWRITE(nBlockPos);
1248 READWRITE(this->nVersion);
1249 READWRITE(hashPrev);
1250 READWRITE(hashMerkleRoot);
1256 uint256 GetBlockHash() const
1259 block.nVersion = nVersion;
1260 block.hashPrevBlock = hashPrev;
1261 block.hashMerkleRoot = hashMerkleRoot;
1262 block.nTime = nTime;
1263 block.nBits = nBits;
1264 block.nNonce = nNonce;
1265 return block.GetHash();
1269 std::string ToString() const
1271 std::string str = "CDiskBlockIndex(";
1272 str += CBlockIndex::ToString();
1273 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1274 GetBlockHash().ToString().c_str(),
1275 hashPrev.ToString().substr(0,20).c_str(),
1276 hashNext.ToString().substr(0,20).c_str());
1282 printf("%s\n", ToString().c_str());
1294 // Describes a place in the block chain to another node such that if the
1295 // other node doesn't have the same branch, it can find a recent common trunk.
1296 // The further back it is, the further before the fork it may be.
1301 std::vector<uint256> vHave;
1308 explicit CBlockLocator(const CBlockIndex* pindex)
1313 explicit CBlockLocator(uint256 hashBlock)
1315 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1316 if (mi != mapBlockIndex.end())
1322 if (!(nType & SER_GETHASH))
1323 READWRITE(nVersion);
1334 return vHave.empty();
1337 void Set(const CBlockIndex* pindex)
1343 vHave.push_back(pindex->GetBlockHash());
1345 // Exponentially larger steps back
1346 for (int i = 0; pindex && i < nStep; i++)
1347 pindex = pindex->pprev;
1348 if (vHave.size() > 10)
1351 vHave.push_back(hashGenesisBlock);
1354 int GetDistanceBack()
1356 // Retrace how far back it was in the sender's branch
1359 BOOST_FOREACH(const uint256& hash, vHave)
1361 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1362 if (mi != mapBlockIndex.end())
1364 CBlockIndex* pindex = (*mi).second;
1365 if (pindex->IsInMainChain())
1375 CBlockIndex* GetBlockIndex()
1377 // Find the first block the caller has in the main chain
1378 BOOST_FOREACH(const uint256& hash, vHave)
1380 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1381 if (mi != mapBlockIndex.end())
1383 CBlockIndex* pindex = (*mi).second;
1384 if (pindex->IsInMainChain())
1388 return pindexGenesisBlock;
1391 uint256 GetBlockHash()
1393 // Find the first block the caller has in the main chain
1394 BOOST_FOREACH(const uint256& hash, vHave)
1396 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1397 if (mi != mapBlockIndex.end())
1399 CBlockIndex* pindex = (*mi).second;
1400 if (pindex->IsInMainChain())
1404 return hashGenesisBlock;
1409 CBlockIndex* pindex = GetBlockIndex();
1412 return pindex->nHeight;
1425 // Alerts are for notifying old versions if they become too obsolete and
1426 // need to upgrade. The message is displayed in the status bar.
1427 // Alert messages are broadcast as a vector of signed data. Unserializing may
1428 // not read the entire buffer if the alert is for a newer version, but older
1429 // versions can still relay the original data.
1431 class CUnsignedAlert
1435 int64 nRelayUntil; // when newer nodes stop relaying to newer nodes
1439 std::set<int> setCancel;
1440 int nMinVer; // lowest version inclusive
1441 int nMaxVer; // highest version inclusive
1442 std::set<std::string> setSubVer; // empty matches all
1446 std::string strComment;
1447 std::string strStatusBar;
1448 std::string strReserved;
1452 READWRITE(this->nVersion);
1453 nVersion = this->nVersion;
1454 READWRITE(nRelayUntil);
1455 READWRITE(nExpiration);
1458 READWRITE(setCancel);
1461 READWRITE(setSubVer);
1462 READWRITE(nPriority);
1464 READWRITE(strComment);
1465 READWRITE(strStatusBar);
1466 READWRITE(strReserved);
1483 strStatusBar.clear();
1484 strReserved.clear();
1487 std::string ToString() const
1489 std::string strSetCancel;
1490 BOOST_FOREACH(int n, setCancel)
1491 strSetCancel += strprintf("%d ", n);
1492 std::string strSetSubVer;
1493 BOOST_FOREACH(std::string str, setSubVer)
1494 strSetSubVer += "\"" + str + "\" ";
1498 " nRelayUntil = %"PRI64d"\n"
1499 " nExpiration = %"PRI64d"\n"
1507 " strComment = \"%s\"\n"
1508 " strStatusBar = \"%s\"\n"
1515 strSetCancel.c_str(),
1518 strSetSubVer.c_str(),
1521 strStatusBar.c_str());
1526 printf("%s", ToString().c_str());
1530 class CAlert : public CUnsignedAlert
1533 std::vector<unsigned char> vchMsg;
1534 std::vector<unsigned char> vchSig;
1549 CUnsignedAlert::SetNull();
1556 return (nExpiration == 0);
1559 uint256 GetHash() const
1561 return SerializeHash(*this);
1564 bool IsInEffect() const
1566 return (GetAdjustedTime() < nExpiration);
1569 bool Cancels(const CAlert& alert) const
1572 return false; // this was a no-op before 31403
1573 return (alert.nID <= nCancel || setCancel.count(alert.nID));
1576 bool AppliesTo(int nVersion, std::string strSubVerIn) const
1578 return (IsInEffect() &&
1579 nMinVer <= nVersion && nVersion <= nMaxVer &&
1580 (setSubVer.empty() || setSubVer.count(strSubVerIn)));
1583 bool AppliesToMe() const
1585 return AppliesTo(VERSION, ::pszSubVer);
1588 bool RelayTo(CNode* pnode) const
1592 // returns true if wasn't already contained in the set
1593 if (pnode->setKnown.insert(GetHash()).second)
1595 if (AppliesTo(pnode->nVersion, pnode->strSubVer) ||
1597 GetAdjustedTime() < nRelayUntil)
1599 pnode->PushMessage("alert", *this);
1606 bool CheckSignature()
1609 if (!key.SetPubKey(ParseHex("04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284")))
1610 return error("CAlert::CheckSignature() : SetPubKey failed");
1611 if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig))
1612 return error("CAlert::CheckSignature() : verify signature failed");
1614 // Now unserialize the data
1615 CDataStream sMsg(vchMsg);
1616 sMsg >> *(CUnsignedAlert*)this;
1620 bool ProcessAlert();