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 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");
614 catch (std::exception &e) {
615 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
618 // Return file pointer
621 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
622 return error("CTransaction::ReadFromDisk() : second fseek failed");
623 *pfileRet = filein.release();
628 friend bool operator==(const CTransaction& a, const CTransaction& b)
630 return (a.nVersion == b.nVersion &&
633 a.nLockTime == b.nLockTime);
636 friend bool operator!=(const CTransaction& a, const CTransaction& b)
642 std::string ToString() const
645 str += strprintf("CTransaction(hash=%s, ver=%d, vin.size=%d, vout.size=%d, nLockTime=%d)\n",
646 GetHash().ToString().substr(0,10).c_str(),
651 for (unsigned int i = 0; i < vin.size(); i++)
652 str += " " + vin[i].ToString() + "\n";
653 for (unsigned int i = 0; i < vout.size(); i++)
654 str += " " + vout[i].ToString() + "\n";
660 printf("%s", ToString().c_str());
664 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
665 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
666 bool ReadFromDisk(COutPoint prevout);
667 bool DisconnectInputs(CTxDB& txdb);
669 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
671 @param[in] txdb Transaction database
672 @param[in] mapTestPool List of pending changes to the transaction index database
673 @param[in] fBlock True if being called to add a new best-block to the chain
674 @param[in] fMiner True if being called by CreateNewBlock
675 @param[out] inputsRet Pointers to this transaction's inputs
676 @param[out] fInvalid returns true if transaction is invalid
677 @return Returns true if all inputs are in txdb or mapTestPool
679 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
680 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
682 /** Sanity check previous transactions, then, if all checks succeed,
683 mark them as spent by this transaction.
685 @param[in] inputsPrevious transactions (from FetchInputs)
686 @param[out] mapTestPoolKeeps track of inputs that need to be updated on disk
687 @param[in] posThisTxPosition of this transaction on disk
688 @param[in] pindexBlock
689 @param[in] fBlock true if called from ConnectBlock
690 @param[in] fMiner true if called from CreateNewBlock
691 @param[in] fStrictPayToScriptHash true if fully validating p2sh transactions
692 @return Returns true if all checks succeed
694 bool ConnectInputs(MapPrevTx inputs,
695 std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
696 const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash=true);
697 bool ClientConnectInputs();
698 bool CheckTransaction() const;
699 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
700 bool AcceptToMemoryPool(bool fCheckInputs=true, bool* pfMissingInputs=NULL);
702 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
703 bool AddToMemoryPoolUnchecked();
705 bool RemoveFromMemoryPool();
713 // A transaction with a merkle branch linking it to the block chain
715 class CMerkleTx : public CTransaction
719 std::vector<uint256> vMerkleBranch;
723 mutable char fMerkleVerified;
731 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
740 fMerkleVerified = false;
746 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
747 nVersion = this->nVersion;
748 READWRITE(hashBlock);
749 READWRITE(vMerkleBranch);
754 int SetMerkleBranch(const CBlock* pblock=NULL);
755 int GetDepthInMainChain(int& nHeightRet) const;
756 int GetDepthInMainChain() const { int nHeight; return GetDepthInMainChain(nHeight); }
757 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
758 int GetBlocksToMaturity() const;
759 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
760 bool AcceptToMemoryPool();
767 // A txdb record that contains the disk location of a transaction and the
768 // locations of transactions that spend its outputs. vSpent is really only
769 // used as a flag, but having the location is very helpful for debugging.
775 std::vector<CDiskTxPos> vSpent;
782 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
785 vSpent.resize(nOutputs);
790 if (!(nType & SER_GETHASH))
807 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
809 return (a.pos == b.pos &&
810 a.vSpent == b.vSpent);
813 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
817 int GetDepthInMainChain() const;
825 // Nodes collect new transactions into a block, hash them into a hash tree,
826 // and scan through nonce values to make the block's hash satisfy proof-of-work
827 // requirements. When they solve the proof-of-work, they broadcast the block
828 // to everyone and the block is added to the block chain. The first transaction
829 // in the block is a special one that creates a new coin owned by the creator
832 // Blocks are appended to blk0001.dat files on disk. Their location on disk
833 // is indexed by CBlockIndex objects in memory.
840 uint256 hashPrevBlock;
841 uint256 hashMerkleRoot;
847 std::vector<CTransaction> vtx;
850 mutable std::vector<uint256> vMerkleTree;
852 // Denial-of-service detection:
854 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
863 READWRITE(this->nVersion);
864 nVersion = this->nVersion;
865 READWRITE(hashPrevBlock);
866 READWRITE(hashMerkleRoot);
871 // ConnectBlock depends on vtx being last so it can calculate offset
872 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
875 const_cast<CBlock*>(this)->vtx.clear();
896 uint256 GetHash() const
898 return Hash(BEGIN(nVersion), END(nNonce));
901 int64 GetBlockTime() const
906 int GetSigOpCount() const
909 BOOST_FOREACH(const CTransaction& tx, vtx)
910 n += tx.GetSigOpCount();
914 void UpdateTime(const CBlockIndex* pindexPrev);
917 uint256 BuildMerkleTree() const
920 BOOST_FOREACH(const CTransaction& tx, vtx)
921 vMerkleTree.push_back(tx.GetHash());
923 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
925 for (int i = 0; i < nSize; i += 2)
927 int i2 = std::min(i+1, nSize-1);
928 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
929 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
933 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
936 std::vector<uint256> GetMerkleBranch(int nIndex) const
938 if (vMerkleTree.empty())
940 std::vector<uint256> vMerkleBranch;
942 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
944 int i = std::min(nIndex^1, nSize-1);
945 vMerkleBranch.push_back(vMerkleTree[j+i]);
949 return vMerkleBranch;
952 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
956 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
959 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
961 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
968 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
970 // Open history file to append
971 CAutoFile fileout = AppendBlockFile(nFileRet);
973 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
975 // Write index header
976 unsigned int nSize = fileout.GetSerializeSize(*this);
977 fileout << FLATDATA(pchMessageStart) << nSize;
980 long fileOutPos = ftell(fileout);
982 return error("CBlock::WriteToDisk() : ftell failed");
983 nBlockPosRet = fileOutPos;
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 catch (std::exception &e) {
1016 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1020 if (!CheckProofOfWork(GetHash(), nBits))
1021 return error("CBlock::ReadFromDisk() : errors in block header");
1030 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%d)\n",
1031 GetHash().ToString().substr(0,20).c_str(),
1033 hashPrevBlock.ToString().substr(0,20).c_str(),
1034 hashMerkleRoot.ToString().substr(0,10).c_str(),
1035 nTime, nBits, nNonce,
1037 for (unsigned int i = 0; i < vtx.size(); i++)
1042 printf(" vMerkleTree: ");
1043 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1044 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1049 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1050 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1051 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1052 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1053 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1054 bool CheckBlock() const;
1064 // The block chain is a tree shaped structure starting with the
1065 // genesis block at the root, with each block potentially having multiple
1066 // candidates to be the next block. pprev and pnext link a path through the
1067 // main/longest chain. A blockindex may have multiple pprev pointing back
1068 // to it, but pnext will only point forward to the longest branch, or will
1069 // be null if the block is not part of the longest chain.
1074 const uint256* phashBlock;
1078 unsigned int nBlockPos;
1080 CBigNum bnChainWork;
1084 uint256 hashMerkleRoot;
1087 unsigned int nNonce;
1107 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1113 nBlockPos = nBlockPosIn;
1117 nVersion = block.nVersion;
1118 hashMerkleRoot = block.hashMerkleRoot;
1119 nTime = block.nTime;
1120 nBits = block.nBits;
1121 nNonce = block.nNonce;
1124 CBlock GetBlockHeader() const
1127 block.nVersion = nVersion;
1129 block.hashPrevBlock = pprev->GetBlockHash();
1130 block.hashMerkleRoot = hashMerkleRoot;
1131 block.nTime = nTime;
1132 block.nBits = nBits;
1133 block.nNonce = nNonce;
1137 uint256 GetBlockHash() const
1142 int64 GetBlockTime() const
1144 return (int64)nTime;
1147 CBigNum GetBlockWork() const
1150 bnTarget.SetCompact(nBits);
1153 return (CBigNum(1)<<256) / (bnTarget+1);
1156 bool IsInMainChain() const
1158 return (pnext || this == pindexBest);
1161 bool CheckIndex() const
1163 return CheckProofOfWork(GetBlockHash(), nBits);
1166 bool EraseBlockFromDisk()
1168 // Open history file
1169 CAutoFile fileout = OpenBlockFile(nFile, nBlockPos, "rb+");
1173 // Overwrite with empty null block
1181 enum { nMedianTimeSpan=11 };
1183 int64 GetMedianTimePast() const
1185 int64 pmedian[nMedianTimeSpan];
1186 int64* pbegin = &pmedian[nMedianTimeSpan];
1187 int64* pend = &pmedian[nMedianTimeSpan];
1189 const CBlockIndex* pindex = this;
1190 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1191 *(--pbegin) = pindex->GetBlockTime();
1193 std::sort(pbegin, pend);
1194 return pbegin[(pend - pbegin)/2];
1197 int64 GetMedianTime() const
1199 const CBlockIndex* pindex = this;
1200 for (int i = 0; i < nMedianTimeSpan/2; i++)
1203 return GetBlockTime();
1204 pindex = pindex->pnext;
1206 return pindex->GetMedianTimePast();
1211 std::string ToString() const
1213 return strprintf("CBlockIndex(nprev=%08x, pnext=%08x, nFile=%d, nBlockPos=%-6d nHeight=%d, merkle=%s, hashBlock=%s)",
1214 pprev, pnext, nFile, nBlockPos, nHeight,
1215 hashMerkleRoot.ToString().substr(0,10).c_str(),
1216 GetBlockHash().ToString().substr(0,20).c_str());
1221 printf("%s\n", ToString().c_str());
1228 // Used to marshal pointers into hashes for db storage.
1230 class CDiskBlockIndex : public CBlockIndex
1242 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1244 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1245 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1250 if (!(nType & SER_GETHASH))
1251 READWRITE(nVersion);
1253 READWRITE(hashNext);
1255 READWRITE(nBlockPos);
1259 READWRITE(this->nVersion);
1260 READWRITE(hashPrev);
1261 READWRITE(hashMerkleRoot);
1267 uint256 GetBlockHash() const
1270 block.nVersion = nVersion;
1271 block.hashPrevBlock = hashPrev;
1272 block.hashMerkleRoot = hashMerkleRoot;
1273 block.nTime = nTime;
1274 block.nBits = nBits;
1275 block.nNonce = nNonce;
1276 return block.GetHash();
1280 std::string ToString() const
1282 std::string str = "CDiskBlockIndex(";
1283 str += CBlockIndex::ToString();
1284 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1285 GetBlockHash().ToString().c_str(),
1286 hashPrev.ToString().substr(0,20).c_str(),
1287 hashNext.ToString().substr(0,20).c_str());
1293 printf("%s\n", ToString().c_str());
1305 // Describes a place in the block chain to another node such that if the
1306 // other node doesn't have the same branch, it can find a recent common trunk.
1307 // The further back it is, the further before the fork it may be.
1312 std::vector<uint256> vHave;
1319 explicit CBlockLocator(const CBlockIndex* pindex)
1324 explicit CBlockLocator(uint256 hashBlock)
1326 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1327 if (mi != mapBlockIndex.end())
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 return (IsInEffect() &&
1590 nMinVer <= nVersion && nVersion <= nMaxVer &&
1591 (setSubVer.empty() || setSubVer.count(strSubVerIn)));
1594 bool AppliesToMe() const
1596 return AppliesTo(VERSION, ::pszSubVer);
1599 bool RelayTo(CNode* pnode) const
1603 // returns true if wasn't already contained in the set
1604 if (pnode->setKnown.insert(GetHash()).second)
1606 if (AppliesTo(pnode->nVersion, pnode->strSubVer) ||
1608 GetAdjustedTime() < nRelayUntil)
1610 pnode->PushMessage("alert", *this);
1617 bool CheckSignature()
1620 if (!key.SetPubKey(ParseHex("04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284")))
1621 return error("CAlert::CheckSignature() : SetPubKey failed");
1622 if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig))
1623 return error("CAlert::CheckSignature() : verify signature failed");
1625 // Now unserialize the data
1626 CDataStream sMsg(vchMsg);
1627 sMsg >> *(CUnsignedAlert*)this;
1631 bool ProcessAlert();