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 uint64 nPooledTx;
71 extern unsigned int nTransactionsUpdated;
72 extern uint64 nLastBlockTx;
73 extern uint64 nLastBlockSize;
74 extern const std::string strMessageMagic;
75 extern double dHashesPerSec;
76 extern int64 nHPSTimerStart;
77 extern int64 nTimeBestReceived;
78 extern CCriticalSection cs_setpwalletRegistered;
79 extern std::set<CWallet*> setpwalletRegistered;
82 extern int64 nTransactionFee;
92 void RegisterWallet(CWallet* pwalletIn);
93 void UnregisterWallet(CWallet* pwalletIn);
94 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
95 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
96 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
97 FILE* AppendBlockFile(unsigned int& nFileRet);
98 bool LoadBlockIndex(bool fAllowNew=true);
99 void PrintBlockTree();
100 bool ProcessMessages(CNode* pfrom);
101 bool SendMessages(CNode* pto, bool fSendTrickle);
102 void GenerateBitcoins(bool fGenerate, CWallet* pwallet);
103 CBlock* CreateNewBlock(CReserveKey& reservekey);
104 void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
105 void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
106 bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
107 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
108 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
109 int GetNumBlocksOfPeers();
110 bool IsInitialBlockDownload();
111 std::string GetWarnings(std::string strFor);
124 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
126 /** Position on disk for a particular transaction. */
131 unsigned int nBlockPos;
139 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
142 nBlockPos = nBlockPosIn;
146 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
147 void SetNull() { nFile = -1; nBlockPos = 0; nTxPos = 0; }
148 bool IsNull() const { return (nFile == -1); }
150 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
152 return (a.nFile == b.nFile &&
153 a.nBlockPos == b.nBlockPos &&
154 a.nTxPos == b.nTxPos);
157 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
162 std::string ToString() const
167 return strprintf("(nFile=%d, nBlockPos=%d, nTxPos=%d)", nFile, nBlockPos, nTxPos);
172 printf("%s", ToString().c_str());
178 /** An inpoint - a combination of a transaction and an index n into its vin */
185 CInPoint() { SetNull(); }
186 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
187 void SetNull() { ptx = NULL; n = -1; }
188 bool IsNull() const { return (ptx == NULL && n == -1); }
193 /** An outpoint - a combination of a transaction hash and an index n into its vout */
200 COutPoint() { SetNull(); }
201 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
202 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
203 void SetNull() { hash = 0; n = -1; }
204 bool IsNull() const { return (hash == 0 && n == -1); }
206 friend bool operator<(const COutPoint& a, const COutPoint& b)
208 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
211 friend bool operator==(const COutPoint& a, const COutPoint& b)
213 return (a.hash == b.hash && a.n == b.n);
216 friend bool operator!=(const COutPoint& a, const COutPoint& b)
221 std::string ToString() const
223 return strprintf("COutPoint(%s, %d)", hash.ToString().substr(0,10).c_str(), n);
228 printf("%s\n", ToString().c_str());
235 /** An input of a transaction. It contains the location of the previous
236 * transaction's output that it claims and a signature that matches the
237 * output's public key.
244 unsigned int nSequence;
248 nSequence = std::numeric_limits<unsigned int>::max();
251 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
254 scriptSig = scriptSigIn;
255 nSequence = nSequenceIn;
258 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
260 prevout = COutPoint(hashPrevTx, nOut);
261 scriptSig = scriptSigIn;
262 nSequence = nSequenceIn;
268 READWRITE(scriptSig);
269 READWRITE(nSequence);
274 return (nSequence == std::numeric_limits<unsigned int>::max());
277 friend bool operator==(const CTxIn& a, const CTxIn& b)
279 return (a.prevout == b.prevout &&
280 a.scriptSig == b.scriptSig &&
281 a.nSequence == b.nSequence);
284 friend bool operator!=(const CTxIn& a, const CTxIn& b)
289 std::string ToString() const
293 str += prevout.ToString();
294 if (prevout.IsNull())
295 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
297 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
298 if (nSequence != std::numeric_limits<unsigned int>::max())
299 str += strprintf(", nSequence=%u", nSequence);
306 printf("%s\n", ToString().c_str());
313 /** An output of a transaction. It contains the public key that the next input
314 * must be able to sign with to claim it.
320 CScript scriptPubKey;
327 CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
330 scriptPubKey = scriptPubKeyIn;
336 READWRITE(scriptPubKey);
342 scriptPubKey.clear();
347 return (nValue == -1);
350 uint256 GetHash() const
352 return SerializeHash(*this);
355 friend bool operator==(const CTxOut& a, const CTxOut& b)
357 return (a.nValue == b.nValue &&
358 a.scriptPubKey == b.scriptPubKey);
361 friend bool operator!=(const CTxOut& a, const CTxOut& b)
366 std::string ToString() const
368 if (scriptPubKey.size() < 6)
369 return "CTxOut(error)";
370 return strprintf("CTxOut(nValue=%"PRI64d".%08"PRI64d", scriptPubKey=%s)", nValue / COIN, nValue % COIN, scriptPubKey.ToString().substr(0,30).c_str());
375 printf("%s\n", ToString().c_str());
389 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
391 /** The basic transaction that is broadcasted on the network and contained in
392 * blocks. A transaction can contain multiple inputs and outputs.
398 std::vector<CTxIn> vin;
399 std::vector<CTxOut> vout;
400 unsigned int nLockTime;
402 // Denial-of-service detection:
404 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
413 READWRITE(this->nVersion);
414 nVersion = this->nVersion;
417 READWRITE(nLockTime);
426 nDoS = 0; // Denial-of-service prevention
431 return (vin.empty() && vout.empty());
434 uint256 GetHash() const
436 return SerializeHash(*this);
439 bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
441 // Time based nLockTime implemented in 0.1.6
444 if (nBlockHeight == 0)
445 nBlockHeight = nBestHeight;
447 nBlockTime = GetAdjustedTime();
448 if ((int64)nLockTime < (nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
450 BOOST_FOREACH(const CTxIn& txin, vin)
456 bool IsNewerThan(const CTransaction& old) const
458 if (vin.size() != old.vin.size())
460 for (int i = 0; i < vin.size(); i++)
461 if (vin[i].prevout != old.vin[i].prevout)
465 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
466 for (int i = 0; i < vin.size(); i++)
468 if (vin[i].nSequence != old.vin[i].nSequence)
470 if (vin[i].nSequence <= nLowest)
473 nLowest = vin[i].nSequence;
475 if (old.vin[i].nSequence < nLowest)
478 nLowest = old.vin[i].nSequence;
485 bool IsCoinBase() const
487 return (vin.size() == 1 && vin[0].prevout.IsNull());
490 /** Check for standard transaction types
491 @return True if all outputs (scriptPubKeys) use only standard transaction forms
493 bool IsStandard() const;
495 /** Check for standard transaction types
496 @param[in] mapInputs Map of previous transactions that have outputs we're spending
497 @return True if all inputs (scriptSigs) use only standard transaction forms
498 @see CTransaction::FetchInputs
500 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
502 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
503 @return number of sigops this transaction's outputs will produce when spent
504 @see CTransaction::FetchInputs
506 int GetLegacySigOpCount() const;
508 /** Count ECDSA signature operations in pay-to-script-hash inputs.
510 @param[in] mapInputs Map of previous transactions that have outputs we're spending
511 @return maximum number of sigops required to validate this transaction's inputs
512 @see CTransaction::FetchInputs
514 int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
516 /** Amount of bitcoins spent by this transaction.
517 @return sum of all outputs (note: does not include fees)
519 int64 GetValueOut() const
522 BOOST_FOREACH(const CTxOut& txout, vout)
524 nValueOut += txout.nValue;
525 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
526 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
531 /** Amount of bitcoins coming in to this transaction
532 Note that lightweight clients may not know anything besides the hash of previous transactions,
533 so may not be able to calculate this.
535 @param[in] mapInputs Map of previous transactions that have outputs we're spending
536 @return Sum of value of all inputs (scriptSigs)
537 @see CTransaction::FetchInputs
539 int64 GetValueIn(const MapPrevTx& mapInputs) const;
541 static bool AllowFree(double dPriority)
543 // Large (in bytes) low-priority (new, small-coin) transactions
545 return dPriority > COIN * 144 / 250;
548 int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=true, enum GetMinFee_mode mode=GMF_BLOCK) const
550 // Base fee is either MIN_TX_FEE or MIN_RELAY_TX_FEE
551 int64 nBaseFee = (mode == GMF_RELAY) ? MIN_RELAY_TX_FEE : MIN_TX_FEE;
553 unsigned int nBytes = ::GetSerializeSize(*this, SER_NETWORK);
554 unsigned int nNewBlockSize = nBlockSize + nBytes;
555 int64 nMinFee = (1 + (int64)nBytes / 1000) * nBaseFee;
561 // Transactions under 10K are free
562 // (about 4500bc if made of 50bc inputs)
568 // Free transaction area
569 if (nNewBlockSize < 27000)
574 // To limit dust spam, require MIN_TX_FEE/MIN_RELAY_TX_FEE if any output is less than 0.01
575 if (nMinFee < nBaseFee)
576 BOOST_FOREACH(const CTxOut& txout, vout)
577 if (txout.nValue < CENT)
580 // Raise the price as the block approaches full
581 if (nBlockSize != 1 && nNewBlockSize >= MAX_BLOCK_SIZE_GEN/2)
583 if (nNewBlockSize >= MAX_BLOCK_SIZE_GEN)
585 nMinFee *= MAX_BLOCK_SIZE_GEN / (MAX_BLOCK_SIZE_GEN - nNewBlockSize);
588 if (!MoneyRange(nMinFee))
594 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
596 CAutoFile filein = OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb");
598 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
601 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
602 return error("CTransaction::ReadFromDisk() : fseek failed");
605 // Return file pointer
608 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
609 return error("CTransaction::ReadFromDisk() : second fseek failed");
610 *pfileRet = filein.release();
615 friend bool operator==(const CTransaction& a, const CTransaction& b)
617 return (a.nVersion == b.nVersion &&
620 a.nLockTime == b.nLockTime);
623 friend bool operator!=(const CTransaction& a, const CTransaction& b)
629 std::string ToString() const
632 str += strprintf("CTransaction(hash=%s, ver=%d, vin.size=%d, vout.size=%d, nLockTime=%d)\n",
633 GetHash().ToString().substr(0,10).c_str(),
638 for (int i = 0; i < vin.size(); i++)
639 str += " " + vin[i].ToString() + "\n";
640 for (int i = 0; i < vout.size(); i++)
641 str += " " + vout[i].ToString() + "\n";
647 printf("%s", ToString().c_str());
651 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
652 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
653 bool ReadFromDisk(COutPoint prevout);
654 bool DisconnectInputs(CTxDB& txdb);
656 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
658 @param[in] txdb Transaction database
659 @param[in] mapTestPool List of pending changes to the transaction index database
660 @param[in] fBlock True if being called to add a new best-block to the chain
661 @param[in] fMiner True if being called by CreateNewBlock
662 @param[out] inputsRet Pointers to this transaction's inputs
663 @param[out] fInvalid returns true if transaction is invalid
664 @return Returns true if all inputs are in txdb or mapTestPool
666 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
667 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
669 /** Sanity check previous transactions, then, if all checks succeed,
670 mark them as spent by this transaction.
672 @param[in] inputs Previous transactions (from FetchInputs)
673 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
674 @param[in] posThisTx Position of this transaction on disk
675 @param[in] pindexBlock
676 @param[in] fBlock true if called from ConnectBlock
677 @param[in] fMiner true if called from CreateNewBlock
678 @param[in] fStrictPayToScriptHash true if fully validating p2sh transactions
679 @return Returns true if all checks succeed
681 bool ConnectInputs(MapPrevTx inputs,
682 std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
683 const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fStrictPayToScriptHash=true);
684 bool ClientConnectInputs();
685 bool CheckTransaction() const;
686 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
687 bool AcceptToMemoryPool(bool fCheckInputs=true, bool* pfMissingInputs=NULL);
690 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
691 bool AddToMemoryPoolUnchecked();
693 bool RemoveFromMemoryPool();
700 /** A transaction with a merkle branch linking it to the block chain. */
701 class CMerkleTx : public CTransaction
705 std::vector<uint256> vMerkleBranch;
709 mutable char fMerkleVerified;
717 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
726 fMerkleVerified = false;
732 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
733 nVersion = this->nVersion;
734 READWRITE(hashBlock);
735 READWRITE(vMerkleBranch);
740 int SetMerkleBranch(const CBlock* pblock=NULL);
741 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
742 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
743 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
744 int GetBlocksToMaturity() const;
745 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
746 bool AcceptToMemoryPool();
752 /** A txdb record that contains the disk location of a transaction and the
753 * locations of transactions that spend its outputs. vSpent is really only
754 * used as a flag, but having the location is very helpful for debugging.
760 std::vector<CDiskTxPos> vSpent;
767 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
770 vSpent.resize(nOutputs);
775 if (!(nType & SER_GETHASH))
792 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
794 return (a.pos == b.pos &&
795 a.vSpent == b.vSpent);
798 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
802 int GetDepthInMainChain() const;
810 /** Nodes collect new transactions into a block, hash them into a hash tree,
811 * and scan through nonce values to make the block's hash satisfy proof-of-work
812 * requirements. When they solve the proof-of-work, they broadcast the block
813 * to everyone and the block is added to the block chain. The first transaction
814 * in the block is a special one that creates a new coin owned by the creator
817 * Blocks are appended to blk0001.dat files on disk. Their location on disk
818 * is indexed by CBlockIndex objects in memory.
825 uint256 hashPrevBlock;
826 uint256 hashMerkleRoot;
832 std::vector<CTransaction> vtx;
835 mutable std::vector<uint256> vMerkleTree;
837 // Denial-of-service detection:
839 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
848 READWRITE(this->nVersion);
849 nVersion = this->nVersion;
850 READWRITE(hashPrevBlock);
851 READWRITE(hashMerkleRoot);
856 // ConnectBlock depends on vtx being last so it can calculate offset
857 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
860 const_cast<CBlock*>(this)->vtx.clear();
881 uint256 GetHash() const
883 return Hash(BEGIN(nVersion), END(nNonce));
886 int64 GetBlockTime() const
891 void UpdateTime(const CBlockIndex* pindexPrev);
894 uint256 BuildMerkleTree() const
897 BOOST_FOREACH(const CTransaction& tx, vtx)
898 vMerkleTree.push_back(tx.GetHash());
900 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
902 for (int i = 0; i < nSize; i += 2)
904 int i2 = std::min(i+1, nSize-1);
905 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
906 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
910 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
913 std::vector<uint256> GetMerkleBranch(int nIndex) const
915 if (vMerkleTree.empty())
917 std::vector<uint256> vMerkleBranch;
919 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
921 int i = std::min(nIndex^1, nSize-1);
922 vMerkleBranch.push_back(vMerkleTree[j+i]);
926 return vMerkleBranch;
929 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
933 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
936 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
938 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
945 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
947 // Open history file to append
948 CAutoFile fileout = AppendBlockFile(nFileRet);
950 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
952 // Write index header
953 unsigned int nSize = fileout.GetSerializeSize(*this);
954 fileout << FLATDATA(pchMessageStart) << nSize;
957 nBlockPosRet = ftell(fileout);
958 if (nBlockPosRet == -1)
959 return error("CBlock::WriteToDisk() : ftell failed");
962 // Flush stdio buffers and commit to disk before returning
964 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
967 _commit(_fileno(fileout));
969 fsync(fileno(fileout));
976 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
980 // Open history file to read
981 CAutoFile filein = OpenBlockFile(nFile, nBlockPos, "rb");
983 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
984 if (!fReadTransactions)
985 filein.nType |= SER_BLOCKHEADERONLY;
991 if (!CheckProofOfWork(GetHash(), nBits))
992 return error("CBlock::ReadFromDisk() : errors in block header");
1001 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%d)\n",
1002 GetHash().ToString().substr(0,20).c_str(),
1004 hashPrevBlock.ToString().substr(0,20).c_str(),
1005 hashMerkleRoot.ToString().substr(0,10).c_str(),
1006 nTime, nBits, nNonce,
1008 for (int i = 0; i < vtx.size(); i++)
1013 printf(" vMerkleTree: ");
1014 for (int i = 0; i < vMerkleTree.size(); i++)
1015 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1020 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1021 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1022 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1023 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1024 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1025 bool CheckBlock() const;
1029 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1037 /** The block chain is a tree shaped structure starting with the
1038 * genesis block at the root, with each block potentially having multiple
1039 * candidates to be the next block. pprev and pnext link a path through the
1040 * main/longest chain. A blockindex may have multiple pprev pointing back
1041 * to it, but pnext will only point forward to the longest branch, or will
1042 * be null if the block is not part of the longest chain.
1047 const uint256* phashBlock;
1051 unsigned int nBlockPos;
1053 CBigNum bnChainWork;
1057 uint256 hashMerkleRoot;
1060 unsigned int nNonce;
1080 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1086 nBlockPos = nBlockPosIn;
1090 nVersion = block.nVersion;
1091 hashMerkleRoot = block.hashMerkleRoot;
1092 nTime = block.nTime;
1093 nBits = block.nBits;
1094 nNonce = block.nNonce;
1097 CBlock GetBlockHeader() const
1100 block.nVersion = nVersion;
1102 block.hashPrevBlock = pprev->GetBlockHash();
1103 block.hashMerkleRoot = hashMerkleRoot;
1104 block.nTime = nTime;
1105 block.nBits = nBits;
1106 block.nNonce = nNonce;
1110 uint256 GetBlockHash() const
1115 int64 GetBlockTime() const
1117 return (int64)nTime;
1120 CBigNum GetBlockWork() const
1123 bnTarget.SetCompact(nBits);
1126 return (CBigNum(1)<<256) / (bnTarget+1);
1129 bool IsInMainChain() const
1131 return (pnext || this == pindexBest);
1134 bool CheckIndex() const
1136 return CheckProofOfWork(GetBlockHash(), nBits);
1139 bool EraseBlockFromDisk()
1141 // Open history file
1142 CAutoFile fileout = OpenBlockFile(nFile, nBlockPos, "rb+");
1146 // Overwrite with empty null block
1154 enum { nMedianTimeSpan=11 };
1156 int64 GetMedianTimePast() const
1158 int64 pmedian[nMedianTimeSpan];
1159 int64* pbegin = &pmedian[nMedianTimeSpan];
1160 int64* pend = &pmedian[nMedianTimeSpan];
1162 const CBlockIndex* pindex = this;
1163 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1164 *(--pbegin) = pindex->GetBlockTime();
1166 std::sort(pbegin, pend);
1167 return pbegin[(pend - pbegin)/2];
1170 int64 GetMedianTime() const
1172 const CBlockIndex* pindex = this;
1173 for (int i = 0; i < nMedianTimeSpan/2; i++)
1176 return GetBlockTime();
1177 pindex = pindex->pnext;
1179 return pindex->GetMedianTimePast();
1184 std::string ToString() const
1186 return strprintf("CBlockIndex(nprev=%08x, pnext=%08x, nFile=%d, nBlockPos=%-6d nHeight=%d, merkle=%s, hashBlock=%s)",
1187 pprev, pnext, nFile, nBlockPos, nHeight,
1188 hashMerkleRoot.ToString().substr(0,10).c_str(),
1189 GetBlockHash().ToString().substr(0,20).c_str());
1194 printf("%s\n", ToString().c_str());
1200 /** Used to marshal pointers into hashes for db storage. */
1201 class CDiskBlockIndex : public CBlockIndex
1213 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1215 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1216 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1221 if (!(nType & SER_GETHASH))
1222 READWRITE(nVersion);
1224 READWRITE(hashNext);
1226 READWRITE(nBlockPos);
1230 READWRITE(this->nVersion);
1231 READWRITE(hashPrev);
1232 READWRITE(hashMerkleRoot);
1238 uint256 GetBlockHash() const
1241 block.nVersion = nVersion;
1242 block.hashPrevBlock = hashPrev;
1243 block.hashMerkleRoot = hashMerkleRoot;
1244 block.nTime = nTime;
1245 block.nBits = nBits;
1246 block.nNonce = nNonce;
1247 return block.GetHash();
1251 std::string ToString() const
1253 std::string str = "CDiskBlockIndex(";
1254 str += CBlockIndex::ToString();
1255 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1256 GetBlockHash().ToString().c_str(),
1257 hashPrev.ToString().substr(0,20).c_str(),
1258 hashNext.ToString().substr(0,20).c_str());
1264 printf("%s\n", ToString().c_str());
1275 /** Describes a place in the block chain to another node such that if the
1276 * other node doesn't have the same branch, it can find a recent common trunk.
1277 * The further back it is, the further before the fork it may be.
1282 std::vector<uint256> vHave;
1289 explicit CBlockLocator(const CBlockIndex* pindex)
1294 explicit CBlockLocator(uint256 hashBlock)
1296 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1297 if (mi != mapBlockIndex.end())
1301 CBlockLocator(const std::vector<uint256>& vHaveIn)
1308 if (!(nType & SER_GETHASH))
1309 READWRITE(nVersion);
1320 return vHave.empty();
1323 void Set(const CBlockIndex* pindex)
1329 vHave.push_back(pindex->GetBlockHash());
1331 // Exponentially larger steps back
1332 for (int i = 0; pindex && i < nStep; i++)
1333 pindex = pindex->pprev;
1334 if (vHave.size() > 10)
1337 vHave.push_back(hashGenesisBlock);
1340 int GetDistanceBack()
1342 // Retrace how far back it was in the sender's branch
1345 BOOST_FOREACH(const uint256& hash, vHave)
1347 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1348 if (mi != mapBlockIndex.end())
1350 CBlockIndex* pindex = (*mi).second;
1351 if (pindex->IsInMainChain())
1361 CBlockIndex* GetBlockIndex()
1363 // Find the first block the caller has in the main chain
1364 BOOST_FOREACH(const uint256& hash, vHave)
1366 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1367 if (mi != mapBlockIndex.end())
1369 CBlockIndex* pindex = (*mi).second;
1370 if (pindex->IsInMainChain())
1374 return pindexGenesisBlock;
1377 uint256 GetBlockHash()
1379 // Find the first block the caller has in the main chain
1380 BOOST_FOREACH(const uint256& hash, vHave)
1382 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1383 if (mi != mapBlockIndex.end())
1385 CBlockIndex* pindex = (*mi).second;
1386 if (pindex->IsInMainChain())
1390 return hashGenesisBlock;
1395 CBlockIndex* pindex = GetBlockIndex();
1398 return pindex->nHeight;
1410 /** Alerts are for notifying old versions if they become too obsolete and
1411 * need to upgrade. The message is displayed in the status bar.
1412 * Alert messages are broadcast as a vector of signed data. Unserializing may
1413 * not read the entire buffer if the alert is for a newer version, but older
1414 * versions can still relay the original data.
1416 class CUnsignedAlert
1420 int64 nRelayUntil; // when newer nodes stop relaying to newer nodes
1424 std::set<int> setCancel;
1425 int nMinVer; // lowest version inclusive
1426 int nMaxVer; // highest version inclusive
1427 std::set<std::string> setSubVer; // empty matches all
1431 std::string strComment;
1432 std::string strStatusBar;
1433 std::string strReserved;
1437 READWRITE(this->nVersion);
1438 nVersion = this->nVersion;
1439 READWRITE(nRelayUntil);
1440 READWRITE(nExpiration);
1443 READWRITE(setCancel);
1446 READWRITE(setSubVer);
1447 READWRITE(nPriority);
1449 READWRITE(strComment);
1450 READWRITE(strStatusBar);
1451 READWRITE(strReserved);
1468 strStatusBar.clear();
1469 strReserved.clear();
1472 std::string ToString() const
1474 std::string strSetCancel;
1475 BOOST_FOREACH(int n, setCancel)
1476 strSetCancel += strprintf("%d ", n);
1477 std::string strSetSubVer;
1478 BOOST_FOREACH(std::string str, setSubVer)
1479 strSetSubVer += "\"" + str + "\" ";
1483 " nRelayUntil = %"PRI64d"\n"
1484 " nExpiration = %"PRI64d"\n"
1492 " strComment = \"%s\"\n"
1493 " strStatusBar = \"%s\"\n"
1500 strSetCancel.c_str(),
1503 strSetSubVer.c_str(),
1506 strStatusBar.c_str());
1511 printf("%s", ToString().c_str());
1515 /** An alert is a combination of a serialized CUnsignedAlert and a signature. */
1516 class CAlert : public CUnsignedAlert
1519 std::vector<unsigned char> vchMsg;
1520 std::vector<unsigned char> vchSig;
1535 CUnsignedAlert::SetNull();
1542 return (nExpiration == 0);
1545 uint256 GetHash() const
1547 return SerializeHash(*this);
1550 bool IsInEffect() const
1552 return (GetAdjustedTime() < nExpiration);
1555 bool Cancels(const CAlert& alert) const
1558 return false; // this was a no-op before 31403
1559 return (alert.nID <= nCancel || setCancel.count(alert.nID));
1562 bool AppliesTo(int nVersion, std::string strSubVerIn) const
1564 // TODO: rework for client-version-embedded-in-strSubVer ?
1565 return (IsInEffect() &&
1566 nMinVer <= nVersion && nVersion <= nMaxVer &&
1567 (setSubVer.empty() || setSubVer.count(strSubVerIn)));
1570 bool AppliesToMe() const
1572 return AppliesTo(PROTOCOL_VERSION, FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, std::vector<std::string>()));
1575 bool RelayTo(CNode* pnode) const
1579 // returns true if wasn't already contained in the set
1580 if (pnode->setKnown.insert(GetHash()).second)
1582 if (AppliesTo(pnode->nVersion, pnode->strSubVer) ||
1584 GetAdjustedTime() < nRelayUntil)
1586 pnode->PushMessage("alert", *this);
1593 bool CheckSignature()
1596 if (!key.SetPubKey(ParseHex("04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284")))
1597 return error("CAlert::CheckSignature() : SetPubKey failed");
1598 if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig))
1599 return error("CAlert::CheckSignature() : verify signature failed");
1601 // Now unserialize the data
1602 CDataStream sMsg(vchMsg);
1603 sMsg >> *(CUnsignedAlert*)this;
1607 bool ProcessAlert();