1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2011 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;
29 static const int CLIENT_VERSION = 60000;
30 static const bool VERSION_IS_BETA = true;
31 extern const std::string CLIENT_NAME;
33 static const unsigned int MAX_BLOCK_SIZE = 1000000;
34 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
35 static const int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
36 static const int64 COIN = 100000000;
37 static const int64 CENT = 1000000;
38 static const int64 MIN_TX_FEE = 50000;
39 static const int64 MIN_RELAY_TX_FEE = 10000;
40 static const int64 MAX_MONEY = 21000000 * COIN;
41 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
42 static const int COINBASE_MATURITY = 100;
43 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
44 static const int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
46 static const int fHaveUPnP = true;
48 static const int fHaveUPnP = false;
52 extern CScript COINBASE_FLAGS;
59 extern CCriticalSection cs_main;
60 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
61 extern uint256 hashGenesisBlock;
62 extern CBlockIndex* pindexGenesisBlock;
63 extern int nBestHeight;
64 extern CBigNum bnBestChainWork;
65 extern CBigNum bnBestInvalidWork;
66 extern uint256 hashBestChain;
67 extern CBlockIndex* pindexBest;
68 extern uint64 nPooledTx;
69 extern unsigned int nTransactionsUpdated;
70 extern uint64 nLastBlockTx;
71 extern uint64 nLastBlockSize;
72 extern const std::string strMessageMagic;
73 extern double dHashesPerSec;
74 extern int64 nHPSTimerStart;
75 extern int64 nTimeBestReceived;
76 extern CCriticalSection cs_setpwalletRegistered;
77 extern std::set<CWallet*> setpwalletRegistered;
80 extern int fGenerateBitcoins;
81 extern int64 nTransactionFee;
82 extern int fLimitProcessors;
83 extern int nLimitProcessors;
84 extern int fMinimizeToTray;
85 extern int fMinimizeOnClose;
96 void RegisterWallet(CWallet* pwalletIn);
97 void UnregisterWallet(CWallet* pwalletIn);
98 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
99 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
100 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
101 FILE* AppendBlockFile(unsigned int& nFileRet);
102 bool LoadBlockIndex(bool fAllowNew=true);
103 void PrintBlockTree();
104 bool ProcessMessages(CNode* pfrom);
105 bool SendMessages(CNode* pto, bool fSendTrickle);
106 void GenerateBitcoins(bool fGenerate, CWallet* pwallet);
107 CBlock* CreateNewBlock(CReserveKey& reservekey);
108 void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
109 void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
110 bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
111 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
112 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
113 int GetNumBlocksOfPeers();
114 bool IsInitialBlockDownload();
115 std::string GetWarnings(std::string strFor);
128 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
131 bool WriteSetting(const std::string& strKey, const T& value)
134 BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
136 std::string strWalletFile;
137 if (!GetWalletFile(pwallet, strWalletFile))
139 fOk |= CWalletDB(strWalletFile).WriteSetting(strKey, value);
149 unsigned int nBlockPos;
157 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
160 nBlockPos = nBlockPosIn;
164 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
165 void SetNull() { nFile = -1; nBlockPos = 0; nTxPos = 0; }
166 bool IsNull() const { return (nFile == -1); }
168 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
170 return (a.nFile == b.nFile &&
171 a.nBlockPos == b.nBlockPos &&
172 a.nTxPos == b.nTxPos);
175 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
180 std::string ToString() const
183 return strprintf("null");
185 return strprintf("(nFile=%d, nBlockPos=%d, nTxPos=%d)", nFile, nBlockPos, nTxPos);
190 printf("%s", ToString().c_str());
203 CInPoint() { SetNull(); }
204 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
205 void SetNull() { ptx = NULL; n = -1; }
206 bool IsNull() const { return (ptx == NULL && n == -1); }
218 COutPoint() { SetNull(); }
219 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
220 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
221 void SetNull() { hash = 0; n = -1; }
222 bool IsNull() const { return (hash == 0 && n == -1); }
224 friend bool operator<(const COutPoint& a, const COutPoint& b)
226 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
229 friend bool operator==(const COutPoint& a, const COutPoint& b)
231 return (a.hash == b.hash && a.n == b.n);
234 friend bool operator!=(const COutPoint& a, const COutPoint& b)
239 std::string ToString() const
241 return strprintf("COutPoint(%s, %d)", hash.ToString().substr(0,10).c_str(), n);
246 printf("%s\n", ToString().c_str());
254 // An input of a transaction. It contains the location of the previous
255 // transaction's output that it claims and a signature that matches the
256 // output's public key.
263 unsigned int nSequence;
267 nSequence = std::numeric_limits<unsigned int>::max();
270 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
273 scriptSig = scriptSigIn;
274 nSequence = nSequenceIn;
277 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
279 prevout = COutPoint(hashPrevTx, nOut);
280 scriptSig = scriptSigIn;
281 nSequence = nSequenceIn;
287 READWRITE(scriptSig);
288 READWRITE(nSequence);
293 return (nSequence == std::numeric_limits<unsigned int>::max());
296 friend bool operator==(const CTxIn& a, const CTxIn& b)
298 return (a.prevout == b.prevout &&
299 a.scriptSig == b.scriptSig &&
300 a.nSequence == b.nSequence);
303 friend bool operator!=(const CTxIn& a, const CTxIn& b)
308 std::string ToString() const
311 str += strprintf("CTxIn(");
312 str += prevout.ToString();
313 if (prevout.IsNull())
314 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
316 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
317 if (nSequence != std::numeric_limits<unsigned int>::max())
318 str += strprintf(", nSequence=%u", nSequence);
325 printf("%s\n", ToString().c_str());
333 // An output of a transaction. It contains the public key that the next input
334 // must be able to sign with to claim it.
340 CScript scriptPubKey;
347 CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
350 scriptPubKey = scriptPubKeyIn;
356 READWRITE(scriptPubKey);
362 scriptPubKey.clear();
367 return (nValue == -1);
370 uint256 GetHash() const
372 return SerializeHash(*this);
375 friend bool operator==(const CTxOut& a, const CTxOut& b)
377 return (a.nValue == b.nValue &&
378 a.scriptPubKey == b.scriptPubKey);
381 friend bool operator!=(const CTxOut& a, const CTxOut& b)
386 std::string ToString() const
388 if (scriptPubKey.size() < 6)
389 return "CTxOut(error)";
390 return strprintf("CTxOut(nValue=%"PRI64d".%08"PRI64d", scriptPubKey=%s)", nValue / COIN, nValue % COIN, scriptPubKey.ToString().substr(0,30).c_str());
395 printf("%s\n", ToString().c_str());
409 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
412 // The basic transaction that is broadcasted on the network and contained in
413 // blocks. A transaction can contain multiple inputs and outputs.
419 std::vector<CTxIn> vin;
420 std::vector<CTxOut> vout;
421 unsigned int nLockTime;
423 // Denial-of-service detection:
425 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
434 READWRITE(this->nVersion);
435 nVersion = this->nVersion;
438 READWRITE(nLockTime);
447 nDoS = 0; // Denial-of-service prevention
452 return (vin.empty() && vout.empty());
455 uint256 GetHash() const
457 return SerializeHash(*this);
460 bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
462 // Time based nLockTime implemented in 0.1.6
465 if (nBlockHeight == 0)
466 nBlockHeight = nBestHeight;
468 nBlockTime = GetAdjustedTime();
469 if ((int64)nLockTime < (nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
471 BOOST_FOREACH(const CTxIn& txin, vin)
477 bool IsNewerThan(const CTransaction& old) const
479 if (vin.size() != old.vin.size())
481 for (int i = 0; i < vin.size(); i++)
482 if (vin[i].prevout != old.vin[i].prevout)
486 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
487 for (int i = 0; i < vin.size(); i++)
489 if (vin[i].nSequence != old.vin[i].nSequence)
491 if (vin[i].nSequence <= nLowest)
494 nLowest = vin[i].nSequence;
496 if (old.vin[i].nSequence < nLowest)
499 nLowest = old.vin[i].nSequence;
506 bool IsCoinBase() const
508 return (vin.size() == 1 && vin[0].prevout.IsNull());
511 /** Check for standard transaction types
512 @return True if all outputs (scriptPubKeys) use only standard transaction forms
514 bool IsStandard() const;
516 /** Check for standard transaction types
517 @param[in] mapInputs Map of previous transactions that have outputs we're spending
518 @return True if all inputs (scriptSigs) use only standard transaction forms
519 @see CTransaction::FetchInputs
521 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
523 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
524 @return number of sigops this transaction's outputs will produce when spent
525 @see CTransaction::FetchInputs
527 int GetLegacySigOpCount() const;
529 /** Count ECDSA signature operations in pay-to-script-hash inputs.
531 @param[in] mapInputs Map of previous transactions that have outputs we're spending
532 @return maximum number of sigops required to validate this transaction's inputs
533 @see CTransaction::FetchInputs
535 int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
537 /** Amount of bitcoins spent by this transaction.
538 @return sum of all outputs (note: does not include fees)
540 int64 GetValueOut() const
543 BOOST_FOREACH(const CTxOut& txout, vout)
545 nValueOut += txout.nValue;
546 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
547 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
552 /** Amount of bitcoins coming in to this transaction
553 Note that lightweight clients may not know anything besides the hash of previous transactions,
554 so may not be able to calculate this.
556 @param[in] mapInputs Map of previous transactions that have outputs we're spending
557 @return Sum of value of all inputs (scriptSigs)
558 @see CTransaction::FetchInputs
560 int64 GetValueIn(const MapPrevTx& mapInputs) const;
562 static bool AllowFree(double dPriority)
564 // Large (in bytes) low-priority (new, small-coin) transactions
566 return dPriority > COIN * 144 / 250;
569 int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=true, enum GetMinFee_mode mode=GMF_BLOCK) const
571 // Base fee is either MIN_TX_FEE or MIN_RELAY_TX_FEE
572 int64 nBaseFee = (mode == GMF_RELAY) ? MIN_RELAY_TX_FEE : MIN_TX_FEE;
574 unsigned int nBytes = ::GetSerializeSize(*this, SER_NETWORK);
575 unsigned int nNewBlockSize = nBlockSize + nBytes;
576 int64 nMinFee = (1 + (int64)nBytes / 1000) * nBaseFee;
582 // Transactions under 10K are free
583 // (about 4500bc if made of 50bc inputs)
589 // Free transaction area
590 if (nNewBlockSize < 27000)
595 // To limit dust spam, require MIN_TX_FEE/MIN_RELAY_TX_FEE if any output is less than 0.01
596 if (nMinFee < nBaseFee)
597 BOOST_FOREACH(const CTxOut& txout, vout)
598 if (txout.nValue < CENT)
601 // Raise the price as the block approaches full
602 if (nBlockSize != 1 && nNewBlockSize >= MAX_BLOCK_SIZE_GEN/2)
604 if (nNewBlockSize >= MAX_BLOCK_SIZE_GEN)
606 nMinFee *= MAX_BLOCK_SIZE_GEN / (MAX_BLOCK_SIZE_GEN - nNewBlockSize);
609 if (!MoneyRange(nMinFee))
615 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
617 CAutoFile filein = OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb");
619 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
622 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
623 return error("CTransaction::ReadFromDisk() : fseek failed");
626 // Return file pointer
629 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
630 return error("CTransaction::ReadFromDisk() : second fseek failed");
631 *pfileRet = filein.release();
636 friend bool operator==(const CTransaction& a, const CTransaction& b)
638 return (a.nVersion == b.nVersion &&
641 a.nLockTime == b.nLockTime);
644 friend bool operator!=(const CTransaction& a, const CTransaction& b)
650 std::string ToString() const
653 str += strprintf("CTransaction(hash=%s, ver=%d, vin.size=%d, vout.size=%d, nLockTime=%d)\n",
654 GetHash().ToString().substr(0,10).c_str(),
659 for (int i = 0; i < vin.size(); i++)
660 str += " " + vin[i].ToString() + "\n";
661 for (int i = 0; i < vout.size(); i++)
662 str += " " + vout[i].ToString() + "\n";
668 printf("%s", ToString().c_str());
672 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
673 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
674 bool ReadFromDisk(COutPoint prevout);
675 bool DisconnectInputs(CTxDB& txdb);
677 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
679 @param[in] txdb Transaction database
680 @param[in] mapTestPool List of pending changes to the transaction index database
681 @param[in] fBlock True if being called to add a new best-block to the chain
682 @param[in] fMiner True if being called by CreateNewBlock
683 @param[out] inputsRet Pointers to this transaction's inputs
684 @param[out] fInvalid returns true if transaction is invalid
685 @return Returns true if all inputs are in txdb or mapTestPool
687 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
688 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
690 /** Sanity check previous transactions, then, if all checks succeed,
691 mark them as spent by this transaction.
693 @param[in] inputs Previous transactions (from FetchInputs)
694 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
695 @param[in] posThisTx Position of this transaction on disk
696 @param[in] pindexBlock
697 @param[in] fBlock true if called from ConnectBlock
698 @param[in] fMiner true if called from CreateNewBlock
699 @param[in] fStrictPayToScriptHash true if fully validating p2sh transactions
700 @return Returns true if all checks succeed
702 bool ConnectInputs(MapPrevTx inputs,
703 std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
704 const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash=true);
705 bool ClientConnectInputs();
706 bool CheckTransaction() const;
707 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
708 bool AcceptToMemoryPool(bool fCheckInputs=true, bool* pfMissingInputs=NULL);
711 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
712 bool AddToMemoryPoolUnchecked();
714 bool RemoveFromMemoryPool();
722 // A transaction with a merkle branch linking it to the block chain
724 class CMerkleTx : public CTransaction
728 std::vector<uint256> vMerkleBranch;
732 mutable char fMerkleVerified;
740 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
749 fMerkleVerified = false;
755 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
756 nVersion = this->nVersion;
757 READWRITE(hashBlock);
758 READWRITE(vMerkleBranch);
763 int SetMerkleBranch(const CBlock* pblock=NULL);
764 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
765 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
766 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
767 int GetBlocksToMaturity() const;
768 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
769 bool AcceptToMemoryPool();
776 // A txdb record that contains the disk location of a transaction and the
777 // locations of transactions that spend its outputs. vSpent is really only
778 // used as a flag, but having the location is very helpful for debugging.
784 std::vector<CDiskTxPos> vSpent;
791 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
794 vSpent.resize(nOutputs);
799 if (!(nType & SER_GETHASH))
816 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
818 return (a.pos == b.pos &&
819 a.vSpent == b.vSpent);
822 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
826 int GetDepthInMainChain() const;
835 // Nodes collect new transactions into a block, hash them into a hash tree,
836 // and scan through nonce values to make the block's hash satisfy proof-of-work
837 // requirements. When they solve the proof-of-work, they broadcast the block
838 // to everyone and the block is added to the block chain. The first transaction
839 // in the block is a special one that creates a new coin owned by the creator
842 // Blocks are appended to blk0001.dat files on disk. Their location on disk
843 // is indexed by CBlockIndex objects in memory.
850 uint256 hashPrevBlock;
851 uint256 hashMerkleRoot;
857 std::vector<CTransaction> vtx;
860 mutable std::vector<uint256> vMerkleTree;
862 // Denial-of-service detection:
864 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
873 READWRITE(this->nVersion);
874 nVersion = this->nVersion;
875 READWRITE(hashPrevBlock);
876 READWRITE(hashMerkleRoot);
881 // ConnectBlock depends on vtx being last so it can calculate offset
882 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
885 const_cast<CBlock*>(this)->vtx.clear();
906 uint256 GetHash() const
908 return Hash(BEGIN(nVersion), END(nNonce));
911 int64 GetBlockTime() const
918 uint256 BuildMerkleTree() const
921 BOOST_FOREACH(const CTransaction& tx, vtx)
922 vMerkleTree.push_back(tx.GetHash());
924 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
926 for (int i = 0; i < nSize; i += 2)
928 int i2 = std::min(i+1, nSize-1);
929 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
930 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
934 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
937 std::vector<uint256> GetMerkleBranch(int nIndex) const
939 if (vMerkleTree.empty())
941 std::vector<uint256> vMerkleBranch;
943 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
945 int i = std::min(nIndex^1, nSize-1);
946 vMerkleBranch.push_back(vMerkleTree[j+i]);
950 return vMerkleBranch;
953 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
957 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
960 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
962 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
969 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
971 // Open history file to append
972 CAutoFile fileout = AppendBlockFile(nFileRet);
974 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
976 // Write index header
977 unsigned int nSize = fileout.GetSerializeSize(*this);
978 fileout << FLATDATA(pchMessageStart) << nSize;
981 nBlockPosRet = ftell(fileout);
982 if (nBlockPosRet == -1)
983 return error("CBlock::WriteToDisk() : ftell failed");
986 // Flush stdio buffers and commit to disk before returning
988 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
991 _commit(_fileno(fileout));
993 fsync(fileno(fileout));
1000 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1004 // Open history file to read
1005 CAutoFile filein = OpenBlockFile(nFile, nBlockPos, "rb");
1007 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1008 if (!fReadTransactions)
1009 filein.nType |= SER_BLOCKHEADERONLY;
1015 if (!CheckProofOfWork(GetHash(), nBits))
1016 return error("CBlock::ReadFromDisk() : errors in block header");
1025 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%d)\n",
1026 GetHash().ToString().substr(0,20).c_str(),
1028 hashPrevBlock.ToString().substr(0,20).c_str(),
1029 hashMerkleRoot.ToString().substr(0,10).c_str(),
1030 nTime, nBits, nNonce,
1032 for (int i = 0; i < vtx.size(); i++)
1037 printf(" vMerkleTree: ");
1038 for (int i = 0; i < vMerkleTree.size(); i++)
1039 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1044 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1045 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1046 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1047 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1048 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1049 bool CheckBlock() const;
1059 // The block chain is a tree shaped structure starting with the
1060 // genesis block at the root, with each block potentially having multiple
1061 // candidates to be the next block. pprev and pnext link a path through the
1062 // main/longest chain. A blockindex may have multiple pprev pointing back
1063 // to it, but pnext will only point forward to the longest branch, or will
1064 // be null if the block is not part of the longest chain.
1069 const uint256* phashBlock;
1073 unsigned int nBlockPos;
1075 CBigNum bnChainWork;
1079 uint256 hashMerkleRoot;
1082 unsigned int nNonce;
1102 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1108 nBlockPos = nBlockPosIn;
1112 nVersion = block.nVersion;
1113 hashMerkleRoot = block.hashMerkleRoot;
1114 nTime = block.nTime;
1115 nBits = block.nBits;
1116 nNonce = block.nNonce;
1119 CBlock GetBlockHeader() const
1122 block.nVersion = nVersion;
1124 block.hashPrevBlock = pprev->GetBlockHash();
1125 block.hashMerkleRoot = hashMerkleRoot;
1126 block.nTime = nTime;
1127 block.nBits = nBits;
1128 block.nNonce = nNonce;
1132 uint256 GetBlockHash() const
1137 int64 GetBlockTime() const
1139 return (int64)nTime;
1142 CBigNum GetBlockWork() const
1145 bnTarget.SetCompact(nBits);
1148 return (CBigNum(1)<<256) / (bnTarget+1);
1151 bool IsInMainChain() const
1153 return (pnext || this == pindexBest);
1156 bool CheckIndex() const
1158 return CheckProofOfWork(GetBlockHash(), nBits);
1161 bool EraseBlockFromDisk()
1163 // Open history file
1164 CAutoFile fileout = OpenBlockFile(nFile, nBlockPos, "rb+");
1168 // Overwrite with empty null block
1176 enum { nMedianTimeSpan=11 };
1178 int64 GetMedianTimePast() const
1180 int64 pmedian[nMedianTimeSpan];
1181 int64* pbegin = &pmedian[nMedianTimeSpan];
1182 int64* pend = &pmedian[nMedianTimeSpan];
1184 const CBlockIndex* pindex = this;
1185 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1186 *(--pbegin) = pindex->GetBlockTime();
1188 std::sort(pbegin, pend);
1189 return pbegin[(pend - pbegin)/2];
1192 int64 GetMedianTime() const
1194 const CBlockIndex* pindex = this;
1195 for (int i = 0; i < nMedianTimeSpan/2; i++)
1198 return GetBlockTime();
1199 pindex = pindex->pnext;
1201 return pindex->GetMedianTimePast();
1206 std::string ToString() const
1208 return strprintf("CBlockIndex(nprev=%08x, pnext=%08x, nFile=%d, nBlockPos=%-6d nHeight=%d, merkle=%s, hashBlock=%s)",
1209 pprev, pnext, nFile, nBlockPos, nHeight,
1210 hashMerkleRoot.ToString().substr(0,10).c_str(),
1211 GetBlockHash().ToString().substr(0,20).c_str());
1216 printf("%s\n", ToString().c_str());
1223 // Used to marshal pointers into hashes for db storage.
1225 class CDiskBlockIndex : public CBlockIndex
1237 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1239 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1240 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1245 if (!(nType & SER_GETHASH))
1246 READWRITE(nVersion);
1248 READWRITE(hashNext);
1250 READWRITE(nBlockPos);
1254 READWRITE(this->nVersion);
1255 READWRITE(hashPrev);
1256 READWRITE(hashMerkleRoot);
1262 uint256 GetBlockHash() const
1265 block.nVersion = nVersion;
1266 block.hashPrevBlock = hashPrev;
1267 block.hashMerkleRoot = hashMerkleRoot;
1268 block.nTime = nTime;
1269 block.nBits = nBits;
1270 block.nNonce = nNonce;
1271 return block.GetHash();
1275 std::string ToString() const
1277 std::string str = "CDiskBlockIndex(";
1278 str += CBlockIndex::ToString();
1279 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1280 GetBlockHash().ToString().c_str(),
1281 hashPrev.ToString().substr(0,20).c_str(),
1282 hashNext.ToString().substr(0,20).c_str());
1288 printf("%s\n", ToString().c_str());
1300 // Describes a place in the block chain to another node such that if the
1301 // other node doesn't have the same branch, it can find a recent common trunk.
1302 // The further back it is, the further before the fork it may be.
1307 std::vector<uint256> vHave;
1314 explicit CBlockLocator(const CBlockIndex* pindex)
1319 explicit CBlockLocator(uint256 hashBlock)
1321 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1322 if (mi != mapBlockIndex.end())
1326 CBlockLocator(const std::vector<uint256>& vHaveIn)
1333 if (!(nType & SER_GETHASH))
1334 READWRITE(nVersion);
1345 return vHave.empty();
1348 void Set(const CBlockIndex* pindex)
1354 vHave.push_back(pindex->GetBlockHash());
1356 // Exponentially larger steps back
1357 for (int i = 0; pindex && i < nStep; i++)
1358 pindex = pindex->pprev;
1359 if (vHave.size() > 10)
1362 vHave.push_back(hashGenesisBlock);
1365 int GetDistanceBack()
1367 // Retrace how far back it was in the sender's branch
1370 BOOST_FOREACH(const uint256& hash, vHave)
1372 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1373 if (mi != mapBlockIndex.end())
1375 CBlockIndex* pindex = (*mi).second;
1376 if (pindex->IsInMainChain())
1386 CBlockIndex* GetBlockIndex()
1388 // Find the first block the caller has in the main chain
1389 BOOST_FOREACH(const uint256& hash, vHave)
1391 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1392 if (mi != mapBlockIndex.end())
1394 CBlockIndex* pindex = (*mi).second;
1395 if (pindex->IsInMainChain())
1399 return pindexGenesisBlock;
1402 uint256 GetBlockHash()
1404 // Find the first block the caller has in the main chain
1405 BOOST_FOREACH(const uint256& hash, vHave)
1407 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1408 if (mi != mapBlockIndex.end())
1410 CBlockIndex* pindex = (*mi).second;
1411 if (pindex->IsInMainChain())
1415 return hashGenesisBlock;
1420 CBlockIndex* pindex = GetBlockIndex();
1423 return pindex->nHeight;
1436 // Alerts are for notifying old versions if they become too obsolete and
1437 // need to upgrade. The message is displayed in the status bar.
1438 // Alert messages are broadcast as a vector of signed data. Unserializing may
1439 // not read the entire buffer if the alert is for a newer version, but older
1440 // versions can still relay the original data.
1442 class CUnsignedAlert
1446 int64 nRelayUntil; // when newer nodes stop relaying to newer nodes
1450 std::set<int> setCancel;
1451 int nMinVer; // lowest version inclusive
1452 int nMaxVer; // highest version inclusive
1453 std::set<std::string> setSubVer; // empty matches all
1457 std::string strComment;
1458 std::string strStatusBar;
1459 std::string strReserved;
1463 READWRITE(this->nVersion);
1464 nVersion = this->nVersion;
1465 READWRITE(nRelayUntil);
1466 READWRITE(nExpiration);
1469 READWRITE(setCancel);
1472 READWRITE(setSubVer);
1473 READWRITE(nPriority);
1475 READWRITE(strComment);
1476 READWRITE(strStatusBar);
1477 READWRITE(strReserved);
1494 strStatusBar.clear();
1495 strReserved.clear();
1498 std::string ToString() const
1500 std::string strSetCancel;
1501 BOOST_FOREACH(int n, setCancel)
1502 strSetCancel += strprintf("%d ", n);
1503 std::string strSetSubVer;
1504 BOOST_FOREACH(std::string str, setSubVer)
1505 strSetSubVer += "\"" + str + "\" ";
1509 " nRelayUntil = %"PRI64d"\n"
1510 " nExpiration = %"PRI64d"\n"
1518 " strComment = \"%s\"\n"
1519 " strStatusBar = \"%s\"\n"
1526 strSetCancel.c_str(),
1529 strSetSubVer.c_str(),
1532 strStatusBar.c_str());
1537 printf("%s", ToString().c_str());
1541 class CAlert : public CUnsignedAlert
1544 std::vector<unsigned char> vchMsg;
1545 std::vector<unsigned char> vchSig;
1560 CUnsignedAlert::SetNull();
1567 return (nExpiration == 0);
1570 uint256 GetHash() const
1572 return SerializeHash(*this);
1575 bool IsInEffect() const
1577 return (GetAdjustedTime() < nExpiration);
1580 bool Cancels(const CAlert& alert) const
1583 return false; // this was a no-op before 31403
1584 return (alert.nID <= nCancel || setCancel.count(alert.nID));
1587 bool AppliesTo(int nVersion, std::string strSubVerIn) const
1589 // TODO: rework for client-version-embedded-in-strSubVer ?
1590 return (IsInEffect() &&
1591 nMinVer <= nVersion && nVersion <= nMaxVer &&
1592 (setSubVer.empty() || setSubVer.count(strSubVerIn)));
1595 bool AppliesToMe() const
1597 return AppliesTo(PROTOCOL_VERSION, FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, std::vector<std::string>()));
1600 bool RelayTo(CNode* pnode) const
1604 // returns true if wasn't already contained in the set
1605 if (pnode->setKnown.insert(GetHash()).second)
1607 if (AppliesTo(pnode->nVersion, pnode->strSubVer) ||
1609 GetAdjustedTime() < nRelayUntil)
1611 pnode->PushMessage("alert", *this);
1618 bool CheckSignature()
1621 if (!key.SetPubKey(ParseHex("04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284")))
1622 return error("CAlert::CheckSignature() : SetPubKey failed");
1623 if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig))
1624 return error("CAlert::CheckSignature() : verify signature failed");
1626 // Now unserialize the data
1627 CDataStream sMsg(vchMsg);
1628 sMsg >> *(CUnsignedAlert*)this;
1632 bool ProcessAlert();