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.
8 #include "timestamps.h"
14 #include "zerocoin/Zerocoin.h"
27 class CRequestTracker;
29 class CBlockIndexTrustComparator;
31 static const unsigned int MAX_BLOCK_SIZE = 1000000;
32 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
33 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
34 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
35 static const unsigned int MAX_INV_SZ = 50000;
37 static const unsigned int MAX_BLOCKFILE_SIZE = 0x8000000; // 128 MiB
38 static const unsigned int BLOCKFILE_CHUNK_SIZE = 0x1000000; // 16 MiB
39 static const unsigned int UNDOFILE_CHUNK_SIZE = 0x100000; // 1 MiB
40 static const unsigned int MEMPOOL_HEIGHT = 0x7FFFFFFF;
42 static const int64 MIN_TX_FEE = CENT / 20;
43 static const int64 MIN_RELAY_TX_FEE = CENT / 50;
45 static const int64 MAX_MONEY = 2000000000 * COIN;
46 static const int64 MAX_MINT_PROOF_OF_WORK = 100 * COIN;
47 static const int64 MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
48 static const int64 MIN_TXOUT_AMOUNT = CENT / 100;
50 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
51 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
52 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
55 static const int fHaveUPnP = true;
57 static const int fHaveUPnP = false;
60 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
61 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
63 inline int64 PastDrift(int64 nTime) { return nTime - 2 * 60 * 60; } // up to 2 hours from the past
64 inline int64 FutureDrift(int64 nTime) { return nTime + 2 * 60 * 60; } // up to 2 hours from the future
66 extern libzerocoin::Params* ZCParams;
67 extern CScript COINBASE_FLAGS;
68 extern CCriticalSection cs_main;
69 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
70 extern std::set<CBlockIndex*, CBlockIndexTrustComparator> setBlockIndexValid;
71 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
72 extern CBlockIndex* pindexGenesisBlock;
73 extern unsigned int nStakeMinAge;
74 extern unsigned int nNodeLifespan;
75 extern int nCoinbaseMaturity;
76 extern int nBestHeight;
77 extern uint256 nBestChainTrust;
78 extern uint256 nBestInvalidTrust;
79 extern uint256 hashBestChain;
80 extern CBlockIndex* pindexBest;
81 extern unsigned int nTransactionsUpdated;
82 extern uint64 nLastBlockTx;
83 extern uint64 nLastBlockSize;
84 extern int64 nLastCoinStakeSearchInterval;
85 extern const std::string strMessageMagic;
86 extern int64 nTimeBestReceived;
87 extern CCriticalSection cs_setpwalletRegistered;
88 extern std::set<CWallet*> setpwalletRegistered;
89 extern unsigned char pchMessageStart[4];
90 extern std::map<uint256, CBlock*> mapOrphanBlocks;
93 extern int64 nTransactionFee;
94 extern int64 nMinimumInputValue;
95 extern bool fUseFastIndex;
96 extern unsigned int nDerivationMethodIndex;
97 extern bool fEnforceCanonical;
99 // Minimum disk space required - used in CheckDiskSpace()
100 static const uint64 nMinDiskSpace = 52428800;
109 class CCoinsViewCache;
111 void RegisterWallet(CWallet* pwalletIn);
112 void UnregisterWallet(CWallet* pwalletIn);
113 void SyncWithWallets(const uint256 &hash, const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
114 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
115 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
116 FILE* OpenBlockFile(const CDiskBlockPos &pos, bool fReadOnly = false);
117 FILE* OpenUndoFile(const CDiskBlockPos &pos, bool fReadOnly = false);
118 bool LoadBlockIndex(bool fAllowNew=true);
119 void PrintBlockTree();
120 CBlockIndex* FindBlockByHeight(int nHeight);
121 bool ProcessMessages(CNode* pfrom);
122 bool SendMessages(CNode* pto, bool fSendTrickle);
123 bool LoadExternalBlockFile(FILE* fileIn);
125 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
126 unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, bool fProofOfStake);
127 int64 GetProofOfWorkReward(unsigned int nBits);
128 int64 GetProofOfStakeReward(int64 nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly=false);
129 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
130 unsigned int ComputeMinStake(unsigned int nBase, int64 nTime, unsigned int nBlockTime);
131 int GetNumBlocksOfPeers();
132 bool IsInitialBlockDownload();
133 std::string GetWarnings(std::string strFor);
134 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock, bool fAllowSlow);
135 bool SetBestChain(CBlockIndex* pindexNew);
136 bool ConnectBestBlock();
137 CBlockIndex * InsertBlockIndex(uint256 hash);
138 uint256 WantedByOrphan(const CBlock* pblockOrphan);
139 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
140 void StakeMiner(CWallet *pwallet);
141 void ResendWalletTransactions(bool fForce=false);
143 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
152 READWRITE(VARINT(nFile));
153 READWRITE(VARINT(nPos));
156 friend bool operator==(const CDiskBlockPos &a, const CDiskBlockPos &b) {
157 return (a.nFile == b.nFile && a.nPos == b.nPos);
160 friend bool operator!=(const CDiskBlockPos &a, const CDiskBlockPos &b) {
164 void SetNull() { nFile = -1; nPos = 0; }
165 bool IsNull() const { return (nFile == -1); }
169 /** An inpoint - a combination of a transaction and an index n into its vin */
176 CInPoint() { SetNull(); }
177 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
178 void SetNull() { ptx = NULL; n = (unsigned int) -1; }
179 bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
184 /** An outpoint - a combination of a transaction hash and an index n into its vout */
191 COutPoint() { SetNull(); }
192 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
193 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
194 void SetNull() { hash = 0; n = (unsigned int) -1; }
195 bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
197 friend bool operator<(const COutPoint& a, const COutPoint& b)
199 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
202 friend bool operator==(const COutPoint& a, const COutPoint& b)
204 return (a.hash == b.hash && a.n == b.n);
207 friend bool operator!=(const COutPoint& a, const COutPoint& b)
212 std::string ToString() const
214 return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
219 printf("%s\n", ToString().c_str());
226 /** An input of a transaction. It contains the location of the previous
227 * transaction's output that it claims and a signature that matches the
228 * output's public key.
235 unsigned int nSequence;
239 nSequence = std::numeric_limits<unsigned int>::max();
242 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
245 scriptSig = scriptSigIn;
246 nSequence = nSequenceIn;
249 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
251 prevout = COutPoint(hashPrevTx, nOut);
252 scriptSig = scriptSigIn;
253 nSequence = nSequenceIn;
259 READWRITE(scriptSig);
260 READWRITE(nSequence);
265 return (nSequence == std::numeric_limits<unsigned int>::max());
268 friend bool operator==(const CTxIn& a, const CTxIn& b)
270 return (a.prevout == b.prevout &&
271 a.scriptSig == b.scriptSig &&
272 a.nSequence == b.nSequence);
275 friend bool operator!=(const CTxIn& a, const CTxIn& b)
280 std::string ToStringShort() const
282 return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
285 std::string ToString() const
289 str += prevout.ToString();
290 if (prevout.IsNull())
291 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
293 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
294 if (nSequence != std::numeric_limits<unsigned int>::max())
295 str += strprintf(", nSequence=%u", nSequence);
302 printf("%s\n", ToString().c_str());
309 /** An output of a transaction. It contains the public key that the next input
310 * must be able to sign with to claim it.
316 CScript scriptPubKey;
323 CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
326 scriptPubKey = scriptPubKeyIn;
332 READWRITE(scriptPubKey);
338 scriptPubKey.clear();
343 return (nValue == -1);
349 scriptPubKey.clear();
354 return (nValue == 0 && scriptPubKey.empty());
357 uint256 GetHash() const
359 return SerializeHash(*this);
362 friend bool operator==(const CTxOut& a, const CTxOut& b)
364 return (a.nValue == b.nValue &&
365 a.scriptPubKey == b.scriptPubKey);
368 friend bool operator!=(const CTxOut& a, const CTxOut& b)
373 std::string ToStringShort() const
375 return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString().substr(0, 10).c_str());
378 std::string ToString() const
380 if (IsEmpty()) return "CTxOut(empty)";
381 if (scriptPubKey.size() < 6)
382 return "CTxOut(error)";
383 return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
388 printf("%s\n", ToString().c_str());
402 // Modes for script/signature checking
405 CS_NEVER, // never validate scripts
406 CS_AFTER_CHECKPOINT, // validate scripts after the last checkpoint
407 CS_ALWAYS // always validate scripts
410 /** The basic transaction that is broadcasted on the network and contained in
411 * blocks. A transaction can contain multiple inputs and outputs.
416 static const int CURRENT_VERSION=1;
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;
439 READWRITE(nLockTime);
444 nVersion = CTransaction::CURRENT_VERSION;
445 nTime = GetAdjustedTime();
449 nDoS = 0; // Denial-of-service prevention
454 return (vin.empty() && vout.empty());
457 uint256 GetHash() const
459 return SerializeHash(*this);
462 uint256 GetMetaHash() const
464 return SignatureHash(CScript(), *this, 0, SIGHASH_ALL);
467 bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
469 // Time based nLockTime implemented in 0.1.6
472 if (nBlockHeight == 0)
473 nBlockHeight = nBestHeight;
475 nBlockTime = GetAdjustedTime();
476 if ((int64)nLockTime < ((int64)nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
478 BOOST_FOREACH(const CTxIn& txin, vin)
484 bool IsNewerThan(const CTransaction& old) const
486 if (vin.size() != old.vin.size())
488 for (unsigned int i = 0; i < vin.size(); i++)
489 if (vin[i].prevout != old.vin[i].prevout)
493 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
494 for (unsigned int i = 0; i < vin.size(); i++)
496 if (vin[i].nSequence != old.vin[i].nSequence)
498 if (vin[i].nSequence <= nLowest)
501 nLowest = vin[i].nSequence;
503 if (old.vin[i].nSequence < nLowest)
506 nLowest = old.vin[i].nSequence;
513 bool IsCoinBase() const
515 return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
518 bool IsCoinStake() const
520 // ppcoin: the coin stake transaction is marked with the first output empty
521 return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
524 /** Check for standard transaction types
525 @return True if all outputs (scriptPubKeys) use only standard transaction forms
527 bool IsStandard() const;
529 /** Check for standard transaction types
530 @param[in] mapInputs Map of previous transactions that have outputs we're spending
531 @return True if all inputs (scriptSigs) use only standard transaction forms
532 @see CTransaction::FetchInputs
534 bool AreInputsStandard(CCoinsViewCache& mapInputs) const;
536 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
537 @return number of sigops this transaction's outputs will produce when spent
538 @see CTransaction::FetchInputs
540 unsigned int GetLegacySigOpCount() const;
542 /** Count ECDSA signature operations in pay-to-script-hash inputs.
544 @param[in] mapInputs Map of previous transactions that have outputs we're spending
545 @return maximum number of sigops required to validate this transaction's inputs
546 @see CTransaction::FetchInputs
548 unsigned int GetP2SHSigOpCount(CCoinsViewCache& mapInputs) const;
550 /** Amount of bitcoins spent by this transaction.
551 @return sum of all outputs (note: does not include fees)
553 int64 GetValueOut() const
556 BOOST_FOREACH(const CTxOut& txout, vout)
558 nValueOut += txout.nValue;
559 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
560 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
565 /** Amount of bitcoins coming in to this transaction
566 Note that lightweight clients may not know anything besides the hash of previous transactions,
567 so may not be able to calculate this.
569 @param[in] mapInputs Map of previous transactions that have outputs we're spending
570 @return Sum of value of all inputs (scriptSigs)
571 @see CTransaction::FetchInputs
573 int64 GetValueIn(CCoinsViewCache& mapInputs) const;
575 static bool AllowFree(double dPriority)
577 // Large (in bytes) low-priority (new, small-coin) transactions
579 return dPriority > COIN * 144 / 250;
582 int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK, unsigned int nBytes = 0, int64 nMinTxFee = MIN_TX_FEE, int64 nMinRelayTxFee = MIN_RELAY_TX_FEE) const;
584 friend bool operator==(const CTransaction& a, const CTransaction& b)
586 return (a.nVersion == b.nVersion &&
587 a.nTime == b.nTime &&
590 a.nLockTime == b.nLockTime);
593 friend bool operator!=(const CTransaction& a, const CTransaction& b)
598 std::string ToStringShort() const
601 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
605 std::string ToString() const
608 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
609 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%"PRIszu", vout.size=%"PRIszu", nLockTime=%d)\n",
610 GetHash().ToString().substr(0,10).c_str(),
616 for (unsigned int i = 0; i < vin.size(); i++)
617 str += " " + vin[i].ToString() + "\n";
618 for (unsigned int i = 0; i < vout.size(); i++)
619 str += " " + vout[i].ToString() + "\n";
625 printf("%s", ToString().c_str());
629 // Do all possible client-mode checks
630 bool ClientCheckInputs() const;
632 // Check whether all prevouts of this transaction are present in the UTXO set represented by view
633 bool HaveInputs(CCoinsViewCache &view) const;
635 // Check whether all inputs of this transaction are valid (no double spends, scripts & sigs, amounts)
636 // This does not modify the UTXO set
637 bool CheckInputs(CCoinsViewCache &view, enum CheckSig_mode csmode, bool fStrictPayToScriptHash=true, bool fStrictEncodings=true, CBlock *pblock=NULL) const;
639 // Apply the effects of this transaction on the UTXO set represented by view
640 bool UpdateCoins(CCoinsViewCache &view, CTxUndo &txundo, int nHeight, unsigned int nBlockTime, const uint256 &txhash) const;
642 // Context-independent validity checks
643 bool CheckTransaction() const;
645 // Try to accept this transaction into the memory pool
646 bool AcceptToMemoryPool(bool fCheckInputs=true, bool* pfMissingInputs=NULL);
647 bool GetCoinAge(uint64& nCoinAge) const; // Get transaction coin age
649 static const CTxOut &GetOutputFor(const CTxIn& input, CCoinsViewCache& mapInputs);
653 /** wrapper for CTxOut that provides a more compact serialization */
654 class CTxOutCompressor
660 static uint64 CompressAmount(uint64 nAmount);
661 static uint64 DecompressAmount(uint64 nAmount);
663 CTxOutCompressor(CTxOut &txoutIn) : txout(txoutIn) { }
665 IMPLEMENT_SERIALIZE(({
667 uint64 nVal = CompressAmount(txout.nValue);
668 READWRITE(VARINT(nVal));
671 READWRITE(VARINT(nVal));
672 txout.nValue = DecompressAmount(nVal);
674 CScriptCompressor cscript(REF(txout.scriptPubKey));
679 /** Undo information for a CTxIn
681 * Contains the prevout's CTxOut being spent, and if this was the
682 * last output of the affected transaction, its metadata as well
683 * (coinbase or not, height, transaction version)
688 CTxOut txout; // the txout data before being spent
689 bool fCoinBase; // if the outpoint was the last unspent: whether it belonged to a coinbase
690 bool fCoinStake; // if the outpoint was the last unspent: whether it belonged to a coinstake
691 unsigned int nHeight; // if the outpoint was the last unspent: its height
692 int nVersion; // if the outpoint was the last unspent: its version
693 unsigned int nTime; // if the outpoint was the last unspent: its timestamp
694 unsigned int nBlockTime; // if the outpoint was the last unspent: its block timestamp
696 CTxInUndo() : txout(), fCoinBase(false), fCoinStake(false), nHeight(0), nVersion(0), nTime(0), nBlockTime(0) {}
697 CTxInUndo(const CTxOut &txoutIn, bool fCoinBaseIn = false, bool fCoinStakeIn = false, unsigned int nHeightIn = 0, int nVersionIn = 0, int nTimeIn = 0, int nBlockTimeIn = 0) : txout(txoutIn), fCoinBase(fCoinBaseIn), fCoinStake(fCoinStakeIn), nHeight(nHeightIn), nVersion(nVersionIn), nTime(nTimeIn), nBlockTime(nBlockTimeIn) { }
699 unsigned int GetSerializeSize(int nType, int nVersion) const {
700 return ::GetSerializeSize(VARINT(nHeight*2+(fCoinBase ? 1 : 0)), nType, nVersion) +
701 ::GetSerializeSize(VARINT(nTime*2+(fCoinStake ? 1 : 0)), nType, nVersion) +
702 ::GetSerializeSize(VARINT(nBlockTime), nType, nVersion) +
703 (nHeight > 0 ? ::GetSerializeSize(VARINT(this->nVersion), nType, nVersion) : 0) +
704 ::GetSerializeSize(CTxOutCompressor(REF(txout)), nType, nVersion);
707 template<typename Stream>
708 void Serialize(Stream &s, int nType, int nVersion) const {
709 ::Serialize(s, VARINT(nHeight*2+(fCoinBase ? 1 : 0)), nType, nVersion);
710 ::Serialize(s, VARINT(nTime*2+(fCoinStake ? 1 : 0)), nType, nVersion);
711 ::Serialize(s, VARINT(nBlockTime), nType, nVersion);
713 ::Serialize(s, VARINT(this->nVersion), nType, nVersion);
714 ::Serialize(s, CTxOutCompressor(REF(txout)), nType, nVersion);
717 template<typename Stream>
718 void Unserialize(Stream &s, int nType, int nVersion) {
719 unsigned int nCodeHeight = 0, nCodeTime = 0;
720 ::Unserialize(s, VARINT(nCodeHeight), nType, nVersion);
721 nHeight = nCodeHeight / 2;
722 fCoinBase = nCodeHeight & 1;
723 ::Unserialize(s, VARINT(nCodeTime), nType, nVersion);
724 nTime = nCodeTime / 2;
725 fCoinStake = nCodeTime & 1;
726 ::Unserialize(s, VARINT(nBlockTime), nType, nVersion);
728 ::Unserialize(s, VARINT(this->nVersion), nType, nVersion);
729 ::Unserialize(s, REF(CTxOutCompressor(REF(txout))), nType, nVersion);
733 /** Undo information for a CTransaction */
737 // undo information for all txins
738 std::vector<CTxInUndo> vprevout;
745 /** Undo information for a CBlock */
749 std::vector<CTxUndo> vtxundo; // for all but the coinbase
755 bool WriteToDisk(CDiskBlockPos &pos)
757 // Open history file to append
758 CAutoFile fileout = CAutoFile(OpenUndoFile(pos), SER_DISK, CLIENT_VERSION);
760 return error("CBlockUndo::WriteToDisk() : OpenUndoFile failed");
762 // Write index header
763 unsigned int nSize = fileout.GetSerializeSize(*this);
764 fileout << FLATDATA(pchMessageStart) << nSize;
767 long fileOutPos = ftell(fileout);
769 return error("CBlockUndo::WriteToDisk() : ftell failed");
770 pos.nPos = (unsigned int)fileOutPos;
773 // Flush stdio buffers and commit to disk before returning
775 if (!IsInitialBlockDownload())
783 /** pruned version of CTransaction: only retains metadata and unspent transaction outputs
789 * - unspentness bitvector, for vout[2] and further; least significant byte first
790 * - the non-spent CTxOuts (via CTxOutCompressor)
792 * - VARINT(nTime + is_coinstake)
793 * - VARINT(nBlockTime)
795 * The nFlag value consists of:
796 * - bit 1: is coinbase
797 * - bit 2: is coinstake
800 * The nCode value consists of:
801 * - bit 2: vout[0] is not spent
802 * - bit 4: vout[1] is not spent
803 * - The higher bits encode N, the number of non-zero bytes in the following bitvector.
804 * - In case both bit 2 and bit 4 are unset, they encode N-1, as there must be at
805 * least one non-spent output).
807 * Example: 010004835800816115944e077fe7c803cfa57f29b36bf87c1d358bb85e40f1d75240f1d752
808 * <><><><--------------------------------------------><----><------><------>
810 * version | code vout[1] height timestamp block timestamp
815 * - code = 4 (vout[1] is not spent, and 0 non-zero bytes of bitvector follow)
816 * - unspentness bitvector: as 0 non-zero bytes follow, it has length 0
817 * - vout[1]: 835800816115944e077fe7c803cfa57f29b36bf87c1d35
818 * * 8358: compact amount representation for 60000000000 (600 BTC)
819 * * 00: special txout type pay-to-pubkey-hash
820 * * 816115944e077fe7c803cfa57f29b36bf87c1d35: address uint160
822 * - time = 1389883712
825 * - block time = 1389883712
828 * Example: 010508044086ef97d5790061b01caab50f1b8e9c50a5057eb43c2d9563a4eebbd123008c988f1a4a4de2161e0f50aac7f17e7f9555caa486af3b40f1d75240f1d752
829 * <><><><--><--------------------------------------------------><----------------------------------------------><----><------><------>
831 * version | code unspentness vout[4] vout[16] height timestamp block timestamp
836 * - code = 8 (neither vout[0] or vout[1] are unspent,
837 * 2 (1, +1 because both bit 2 and bit 4 are unset) non-zero bitvector bytes follow)
838 * - unspentness bitvector: bits 2 (0x04) and 14 (0x4000) are set, so vout[2+2] and vout[14+2] are unspent
839 * - vout[4]: 86ef97d5790061b01caab50f1b8e9c50a5057eb43c2d9563a4ee
840 * * 86ef97d579: compact amount representation for 234925952 (2.35 BTC)
841 * * 00: special txout type pay-to-pubkey-hash
842 * * 61b01caab50f1b8e9c50a5057eb43c2d9563a4ee: address uint160
843 * - vout[16]: bbd123008c988f1a4a4de2161e0f50aac7f17e7f9555caa4
844 * * bbd123: compact amount representation for 110397 (0.001 BTC)
845 * * 00: special txout type pay-to-pubkey-hash
846 * * 8c988f1a4a4de2161e0f50aac7f17e7f9555caa4: address uint160
848 * - time = 1389883712
851 * - block time = 1389883712
853 * Example: 010686af3b40f1d75240f1d752
854 * <><><----><------><------>
856 * version flags height timestamp block timestamp
859 * - flags = 6 (00000110)
861 * - time = 1389883712
864 * - block time = 1389883712
869 // whether transaction is a coinbase
872 // whether transaction is a coinstake
875 // unspent transaction outputs; spent outputs are .IsNull(); spent outputs at the end of the array are dropped
876 std::vector<CTxOut> vout;
878 // at which height this transaction was included in the active blockchain
881 // version of the CTransaction; accesses to this value should probably check for nHeight as well,
882 // as new tx version will probably only be introduced at certain heights
885 // transaction timestamp + coinstake flag
889 unsigned int nBlockTime;
891 // construct a CCoins from a CTransaction, at a given height/timestamp
892 CCoins(const CTransaction &tx, int nHeightIn, int nBlockTimeIn) : fCoinBase(tx.IsCoinBase()), fCoinStake(tx.IsCoinStake()), vout(tx.vout), nHeight(nHeightIn), nVersion(tx.nVersion), nTime(tx.nTime), nBlockTime(nBlockTimeIn) { }
895 CCoins() : fCoinBase(false), fCoinStake(false), vout(0), nHeight(0), nVersion(0), nTime(0), nBlockTime(0) { }
897 // remove spent outputs at the end of vout
899 while (vout.size() > 0 && (vout.back().IsNull() || vout.back().IsEmpty()))
904 friend bool operator==(const CCoins &a, const CCoins &b) {
905 return a.fCoinBase == b.fCoinBase &&
906 a.fCoinStake == b.fCoinStake &&
907 a.nHeight == b.nHeight &&
908 a.nVersion == b.nVersion &&
909 a.nTime == b.nTime &&
910 a.nBlockTime == b.nBlockTime &&
913 friend bool operator!=(const CCoins &a, const CCoins &b) {
917 // calculate number of bytes for the bitmask, and its number of non-zero bytes
918 // each bit in the bitmask represents the availability of one output, but the
919 // availabilities of the first two outputs are encoded separately
920 void CalcMaskSize(unsigned int &nBytes, unsigned int &nNonzeroBytes) const {
921 unsigned int nLastUsedByte = 0;
922 for (unsigned int b = 0; 2+b*8 < vout.size(); b++) {
924 for (unsigned int i = 0; i < 8 && 2+b*8+i < vout.size(); i++) {
925 if (!vout[2+b*8+i].IsNull()) {
931 nLastUsedByte = b + 1;
935 nBytes += nLastUsedByte;
938 bool IsCoinBase() const {
942 bool IsCoinStake() const {
946 unsigned int GetSerializeSize(int nType, int nVersion) const {
947 unsigned int nSize = 0;
948 bool fPruned = IsPruned();
951 nSize += ::GetSerializeSize(VARINT(this->nVersion), nType, nVersion);
952 unsigned char nFlags = 0;
953 // coinbase, coinstake and prune flags
954 nFlags = (fCoinBase ? 1 : 0)<<0 | (fCoinStake ? 1 : 0)<<1 | (fPruned ? 1 : 0)<<2;
956 nSize += ::GetSerializeSize(VARINT(nFlags), nType, nVersion);
959 unsigned int nMaskSize = 0, nMaskCode = 0;
960 CalcMaskSize(nMaskSize, nMaskCode);
961 bool fFirst = vout.size() > 0 && !vout[0].IsNull();
962 bool fSecond = vout.size() > 1 && !vout[1].IsNull();
964 assert(fFirst || fSecond || nMaskCode);
965 unsigned int nCode = 8*(nMaskCode - (fFirst || fSecond ? 0 : 1)) + (fFirst ? 2 : 0) + (fSecond ? 4 : 0);
966 // size of header code
967 nSize += ::GetSerializeSize(VARINT(nCode), nType, nVersion);
971 for (unsigned int i = 0; i < vout.size(); i++)
972 if (!vout[i].IsNull())
973 nSize += ::GetSerializeSize(CTxOutCompressor(REF(vout[i])), nType, nVersion);
975 nSize += ::GetSerializeSize(VARINT(nHeight), nType, nVersion);
976 // timestamp and coinstake flag
977 nSize += ::GetSerializeSize(VARINT(nTime), nType, nVersion);
979 nSize += ::GetSerializeSize(VARINT(nBlockTime), nType, nVersion);
983 nSize += ::GetSerializeSize(VARINT(nHeight), nType, nVersion);
985 nSize += ::GetSerializeSize(VARINT(nTime), nType, nVersion);
986 // size of block timestamp
987 nSize += ::GetSerializeSize(VARINT(nBlockTime), nType, nVersion);
993 template<typename Stream>
994 void Serialize(Stream &s, int nType, int nVersion) const {
995 bool fPruned = IsPruned();
996 unsigned char nFlags = 0;
997 nFlags = (fCoinBase ? 1 : 0)<<0 | (fCoinStake ? 1 : 0)<<1 | (fPruned ? 1 : 0)<<2;
1000 ::Serialize(s, VARINT(this->nVersion), nType, nVersion);
1002 ::Serialize(s, VARINT(nFlags), nType, nVersion);
1005 unsigned int nMaskSize = 0, nMaskCode = 0;
1006 CalcMaskSize(nMaskSize, nMaskCode);
1007 bool fFirst = vout.size() > 0 && !vout[0].IsNull();
1008 bool fSecond = vout.size() > 1 && !vout[1].IsNull();
1010 assert(fFirst || fSecond || nMaskCode);
1012 unsigned int nCode = 8*(nMaskCode - (fFirst || fSecond ? 0 : 1)) + (fFirst ? 2 : 0) + (fSecond ? 4 : 0);
1015 ::Serialize(s, VARINT(nCode), nType, nVersion);
1016 // spentness bitmask
1017 for (unsigned int b = 0; b<nMaskSize; b++) {
1018 unsigned char chAvail = 0;
1019 for (unsigned int i = 0; i < 8 && 2+b*8+i < vout.size(); i++)
1020 if (!vout[2+b*8+i].IsNull())
1021 chAvail |= (1 << i);
1022 ::Serialize(s, chAvail, nType, nVersion);
1025 for (unsigned int i = 0; i < vout.size(); i++) {
1026 if (!vout[i].IsNull())
1027 ::Serialize(s, CTxOutCompressor(REF(vout[i])), nType, nVersion);
1030 ::Serialize(s, VARINT(nHeight), nType, nVersion);
1031 // transaction timestamp and coinstake flag
1032 ::Serialize(s, VARINT(nTime), nType, nVersion);
1034 ::Serialize(s, VARINT(nBlockTime), nType, nVersion);
1038 ::Serialize(s, VARINT(nHeight), nType, nVersion);
1039 // transaction timestamp
1040 ::Serialize(s, VARINT(nTime), nType, nVersion);
1042 ::Serialize(s, VARINT(nBlockTime), nType, nVersion);
1046 template<typename Stream>
1047 void Unserialize(Stream &s, int nType, int nVersion) {
1048 unsigned char nFlags = 0;
1051 ::Unserialize(s, VARINT(this->nVersion), nType, nVersion);
1052 // coinbase and coinstake flags
1053 ::Unserialize(s, VARINT(nFlags), nType, nVersion);
1055 fCoinBase = nFlags & (1<<0);
1056 fCoinStake = nFlags & (1<<1);
1057 bool fPruned = nFlags & (1<<2);
1060 unsigned int nCode = 0;
1062 ::Unserialize(s, VARINT(nCode), nType, nVersion);
1063 std::vector<bool> vAvail(2, false);
1064 vAvail[0] = nCode & 2;
1065 vAvail[1] = nCode & 4;
1066 unsigned int nMaskCode = (nCode / 8) + ((nCode & 6) != 0 ? 0 : 1);
1067 // spentness bitmask
1068 while (nMaskCode > 0) {
1069 unsigned char chAvail = 0;
1070 ::Unserialize(s, chAvail, nType, nVersion);
1071 for (unsigned int p = 0; p < 8; p++) {
1072 bool f = (chAvail & (1 << p)) != 0;
1073 vAvail.push_back(f);
1079 vout.assign(vAvail.size(), CTxOut());
1080 for (unsigned int i = 0; i < vAvail.size(); i++) {
1082 ::Unserialize(s, REF(CTxOutCompressor(vout[i])), nType, nVersion);
1085 ::Unserialize(s, VARINT(nHeight), nType, nVersion);
1086 // transaction timestamp
1087 ::Unserialize(s, VARINT(nTime), nType, nVersion);
1090 ::Unserialize(s, VARINT(nBlockTime), nType, nVersion);
1094 ::Unserialize(s, VARINT(nHeight), nType, nVersion);
1095 // transaction timestamp
1096 ::Unserialize(s, VARINT(nTime), nType, nVersion);
1098 ::Unserialize(s, VARINT(nBlockTime), nType, nVersion);
1103 // mark an outpoint spent, and construct undo information
1104 bool Spend(const COutPoint &out, CTxInUndo &undo) {
1105 if (out.n >= vout.size())
1107 if (vout[out.n].IsNull())
1109 undo = CTxInUndo(vout[out.n]);
1110 vout[out.n].SetNull();
1112 if (vout.size() == 0) {
1113 undo.nHeight = nHeight;
1115 undo.nBlockTime = nBlockTime;
1116 undo.fCoinBase = fCoinBase;
1117 undo.fCoinStake = fCoinStake;
1118 undo.nVersion = this->nVersion;
1123 // mark a vout spent
1124 bool Spend(int nPos) {
1126 COutPoint out(0, nPos);
1127 return Spend(out, undo);
1130 // check whether a particular output is still available
1131 bool IsAvailable(unsigned int nPos) const {
1132 return (nPos < vout.size() && !vout[nPos].IsNull());
1135 // check whether the entire CCoins is spent
1136 // note that only !IsPruned() CCoins can be serialized
1137 bool IsPruned() const {
1138 if (vout.size() == 0)
1141 BOOST_FOREACH(const CTxOut &out, vout)
1152 /** A transaction with a merkle branch linking it to the block chain. */
1153 class CMerkleTx : public CTransaction
1157 std::vector<uint256> vMerkleBranch;
1161 mutable bool fMerkleVerified;
1169 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
1178 fMerkleVerified = false;
1184 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
1185 nVersion = this->nVersion;
1186 READWRITE(hashBlock);
1187 READWRITE(vMerkleBranch);
1192 int SetMerkleBranch(const CBlock* pblock=NULL);
1193 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
1194 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
1195 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
1196 int GetBlocksToMaturity() const;
1197 bool AcceptToMemoryPool(bool fCheckInputs=true);
1202 /** Nodes collect new transactions into a block, hash them into a hash tree,
1203 * and scan through nonce values to make the block's hash satisfy proof-of-work
1204 * requirements. When they solve the proof-of-work, they broadcast the block
1205 * to everyone and the block is added to the block chain. The first transaction
1206 * in the block is a special one that creates a new coin owned by the creator
1213 static const int CURRENT_VERSION=6;
1215 uint256 hashPrevBlock;
1216 uint256 hashMerkleRoot;
1219 unsigned int nNonce;
1222 std::vector<CTransaction> vtx;
1224 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
1225 std::vector<unsigned char> vchBlockSig;
1228 mutable std::vector<uint256> vMerkleTree;
1230 // Denial-of-service detection:
1232 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
1241 READWRITE(this->nVersion);
1242 nVersion = this->nVersion;
1243 READWRITE(hashPrevBlock);
1244 READWRITE(hashMerkleRoot);
1249 // ConnectBlock depends on vtx following header to generate CDiskTxPos
1250 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
1253 READWRITE(vchBlockSig);
1257 const_cast<CBlock*>(this)->vtx.clear();
1258 const_cast<CBlock*>(this)->vchBlockSig.clear();
1264 nVersion = CBlock::CURRENT_VERSION;
1271 vchBlockSig.clear();
1272 vMerkleTree.clear();
1278 return (nBits == 0);
1281 uint256 GetHash() const
1283 return scrypt_blockhash(CVOIDBEGIN(nVersion));
1286 int64 GetBlockTime() const
1288 return (int64)nTime;
1291 void UpdateTime(const CBlockIndex* pindexPrev);
1293 unsigned int GetStakeEntropyBit(unsigned int nTime) const;
1295 // two types of block: proof-of-work or proof-of-stake
1296 bool IsProofOfStake() const
1298 return (vtx.size() > 1 && vtx[1].IsCoinStake());
1301 bool IsProofOfWork() const
1303 return !IsProofOfStake();
1306 std::pair<COutPoint, unsigned int> GetProofOfStake() const
1308 return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
1311 // get max transaction timestamp
1312 int64 GetMaxTransactionTime() const
1314 int64 maxTransactionTime = 0;
1315 BOOST_FOREACH(const CTransaction& tx, vtx)
1316 maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
1317 return maxTransactionTime;
1320 uint256 BuildMerkleTree() const
1322 vMerkleTree.clear();
1323 BOOST_FOREACH(const CTransaction& tx, vtx)
1324 vMerkleTree.push_back(tx.GetHash());
1326 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1328 for (int i = 0; i < nSize; i += 2)
1330 int i2 = std::min(i+1, nSize-1);
1331 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
1332 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
1336 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
1339 const uint256 &GetTxHash(unsigned int nIndex) const {
1340 assert(vMerkleTree.size() > 0); // BuildMerkleTree must have been called first
1341 assert(nIndex < vtx.size());
1342 return vMerkleTree[nIndex];
1345 std::vector<uint256> GetMerkleBranch(int nIndex) const
1347 if (vMerkleTree.empty())
1349 std::vector<uint256> vMerkleBranch;
1351 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1353 int i = std::min(nIndex^1, nSize-1);
1354 vMerkleBranch.push_back(vMerkleTree[j+i]);
1358 return vMerkleBranch;
1361 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1365 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1368 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1370 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1376 bool WriteToDisk(CDiskBlockPos &pos)
1378 // Open history file to append
1379 CAutoFile fileout = CAutoFile(OpenBlockFile(pos), SER_DISK, CLIENT_VERSION);
1381 return error("CBlock::WriteToDisk() : OpenBlockFile failed");
1383 // Write index header
1384 unsigned int nSize = fileout.GetSerializeSize(*this);
1385 fileout << FLATDATA(pchMessageStart) << nSize;
1388 long fileOutPos = ftell(fileout);
1390 return error("CBlock::WriteToDisk() : ftell failed");
1391 pos.nPos = (unsigned int)fileOutPos;
1394 // Flush stdio buffers and commit to disk before returning
1396 if (!IsInitialBlockDownload())
1397 FileCommit(fileout);
1402 bool ReadFromDisk(const CDiskBlockPos &pos, bool fReadTransactions = true)
1406 // Open history file to read
1407 CAutoFile filein = CAutoFile(OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION);
1409 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1410 if (!fReadTransactions)
1411 filein.nType |= SER_BLOCKHEADERONLY;
1417 catch (std::exception &e) {
1418 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1422 if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1423 return error("CBlock::ReadFromDisk() : errors in block header");
1430 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu", vchBlockSig=%s)\n",
1431 GetHash().ToString().c_str(),
1433 hashPrevBlock.ToString().c_str(),
1434 hashMerkleRoot.ToString().c_str(),
1435 nTime, nBits, nNonce,
1437 HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1438 for (unsigned int i = 0; i < vtx.size(); i++)
1443 printf(" vMerkleTree: ");
1444 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1445 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1449 // Undo the effects of this block (with given index) on the UTXO set represented by coins
1450 bool DisconnectBlock(CBlockIndex *pindex, CCoinsViewCache &coins);
1452 // Apply the effects of this block (with given index) on the UTXO set represented by coins
1453 bool ConnectBlock(CBlockIndex *pindex, CCoinsViewCache &coins, bool fJustCheck=false);
1455 // Read a block from disk
1456 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1458 // Add this block to the block index, and if necessary, switch the active block chain to this
1459 bool AddToBlockIndex(const CDiskBlockPos &pos);
1461 // Context-independent validity checks
1462 bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=false) const;
1464 // Store block on disk
1467 // Get total coinage consumed
1468 bool GetCoinAge(uint64& nCoinAge) const;
1470 // Generate proof-of-stake block signature
1471 bool SignBlock(CWallet& keystore);
1473 // Get generator key
1474 bool GetGenerator(CKey& GeneratorKey) const;
1476 // Validate proof-of-stake block signature
1477 bool CheckSignature(bool& fFatal, uint256& hashProofOfStake) const;
1479 // Legacy proof-of-work signature
1480 bool CheckLegacySignature() const;
1484 class CBlockFileInfo
1487 unsigned int nBlocks; // number of blocks stored in file
1488 unsigned int nSize; // number of used bytes of block file
1489 unsigned int nUndoSize; // number of used bytes in the undo file
1490 unsigned int nHeightFirst; // lowest height of block in file
1491 unsigned int nHeightLast; // highest height of block in file
1492 uint64 nTimeFirst; // earliest time of block in file
1493 uint64 nTimeLast; // latest time of block in file
1495 IMPLEMENT_SERIALIZE(
1496 READWRITE(VARINT(nBlocks));
1497 READWRITE(VARINT(nSize));
1498 READWRITE(VARINT(nUndoSize));
1499 READWRITE(VARINT(nHeightFirst));
1500 READWRITE(VARINT(nHeightLast));
1501 READWRITE(VARINT(nTimeFirst));
1502 READWRITE(VARINT(nTimeLast));
1519 std::string ToString() const {
1520 return strprintf("CBlockFileInfo(blocks=%u, size=%u, heights=%u..%u, time=%s..%s)", nBlocks, nSize, nHeightFirst, nHeightLast, DateTimeStrFormat("%Y-%m-%d", nTimeFirst).c_str(), DateTimeStrFormat("%Y-%m-%d", nTimeLast).c_str());
1523 // update statistics (does not update nSize)
1524 void AddBlock(unsigned int nHeightIn, uint64 nTimeIn) {
1525 if (nBlocks==0 || nHeightFirst > nHeightIn)
1526 nHeightFirst = nHeightIn;
1527 if (nBlocks==0 || nTimeFirst > nTimeIn)
1528 nTimeFirst = nTimeIn;
1530 if (nHeightIn > nHeightFirst)
1531 nHeightLast = nHeightIn;
1532 if (nTimeIn > nTimeLast)
1533 nTimeLast = nTimeIn;
1538 extern CCriticalSection cs_LastBlockFile;
1539 extern CBlockFileInfo infoLastBlockFile;
1540 extern int nLastBlockFile;
1543 BLOCK_VALID_UNKNOWN = 0,
1544 BLOCK_VALID_HEADER = 1, // parsed, version ok, hash satisfies claimed PoW, 1 <= vtx count <= max, timestamp not in future
1545 BLOCK_VALID_TREE = 2, // parent found, difficulty matches, timestamp >= median previous, checkpoint
1546 BLOCK_VALID_TRANSACTIONS = 3, // only first tx is coinbase, 2 <= coinbase input script length <= 100, transactions valid, no duplicate txids, sigops, size, merkle root
1547 BLOCK_VALID_CHAIN = 4, // outputs do not overspend inputs, no double spends, coinbase output ok, immature coinbase spends, BIP30
1548 BLOCK_VALID_SCRIPTS = 5, // scripts/signatures ok
1549 BLOCK_VALID_MASK = 7,
1551 BLOCK_HAVE_DATA = 8, // full block available in blk*.dat
1552 BLOCK_HAVE_UNDO = 16, // undo data available in rev*.dat
1553 BLOCK_HAVE_MASK = 24,
1555 BLOCK_FAILED_VALID = 32, // stage after last reached validness failed
1556 BLOCK_FAILED_CHILD = 64, // descends from failed block
1557 BLOCK_FAILED_MASK = 96
1560 /** The block chain is a tree shaped structure starting with the
1561 * genesis block at the root, with each block potentially having multiple
1562 * candidates to be the next block. pprev and pnext link a path through the
1563 * main/longest chain. A blockindex may have multiple pprev pointing back
1564 * to it, but pnext will only point forward to the longest branch, or will
1565 * be null if the block is not part of the longest chain.
1570 // pointer to the hash of the block, if any. memory is owned by this CBlockIndex
1571 const uint256* phashBlock;
1573 // pointer to the index of the predecessor of this block
1576 // (memory only) pointer to the index of the *active* successor of this block
1579 // height of the entry in the chain. The genesis block has height 0
1582 // Which # file this block is stored in (blk?????.dat)
1585 // Byte offset within blk?????.dat where this block's data is stored
1586 unsigned int nDataPos;
1588 // Byte offset within rev?????.dat where this block's undo data is stored
1589 unsigned int nUndoPos;
1591 // (memory only) Trust score of block chain up to and including this block
1592 uint256 nChainTrust;
1594 // Number of transactions in this block.
1597 // (memory only) Number of transactions in the chain up to and including this block
1598 unsigned int nChainTx;
1600 // Verification status of this block. See enum BlockStatus for detailed info
1601 unsigned int nStatus;
1603 // Coins amount created by this block
1606 // Total coins created in this block chain up to and including this block
1610 unsigned int nFlags;
1613 // is proof-of-stake block
1614 BLOCK_PROOF_OF_STAKE = (1 << 0),
1615 // entropy bit for stake modifier
1616 BLOCK_STAKE_ENTROPY = (1 << 1),
1617 // regenerated stake modifier
1618 BLOCK_STAKE_MODIFIER = (1 << 2),
1621 // Hash modifier for proof-of-stake kernel
1622 uint64 nStakeModifier;
1624 // Checksum of index in-memory only
1625 unsigned int nStakeModifierChecksum;
1627 // Predecessor of coinstake transaction
1628 COutPoint prevoutStake;
1630 // Timestamp of coinstake transaction
1631 unsigned int nStakeTime;
1634 uint256 hashProofOfStake;
1638 uint256 hashMerkleRoot;
1641 unsigned int nNonce;
1660 nStakeModifierChecksum = 0;
1661 hashProofOfStake = 0;
1662 prevoutStake.SetNull();
1672 CBlockIndex(CBlock& block)
1689 nStakeModifierChecksum = 0;
1690 hashProofOfStake = 0;
1691 if (block.IsProofOfStake())
1694 prevoutStake = block.vtx[1].vin[0].prevout;
1695 nStakeTime = block.vtx[1].nTime;
1699 prevoutStake.SetNull();
1703 nVersion = block.nVersion;
1704 hashMerkleRoot = block.hashMerkleRoot;
1705 nTime = block.nTime;
1706 nBits = block.nBits;
1707 nNonce = block.nNonce;
1710 CDiskBlockPos GetBlockPos() const {
1712 if (nStatus & BLOCK_HAVE_DATA) {
1714 ret.nPos = nDataPos;
1720 CDiskBlockPos GetUndoPos() const {
1722 if (nStatus & BLOCK_HAVE_UNDO) {
1724 ret.nPos = nUndoPos;
1730 CBlock GetBlockHeader() const
1733 block.nVersion = nVersion;
1735 block.hashPrevBlock = pprev->GetBlockHash();
1736 block.hashMerkleRoot = hashMerkleRoot;
1737 block.nTime = nTime;
1738 block.nBits = nBits;
1739 block.nNonce = nNonce;
1743 uint256 GetBlockHash() const
1748 int64 GetBlockTime() const
1750 return (int64)nTime;
1753 uint256 GetBlockTrust() const;
1755 bool IsInMainChain() const
1757 return (pnext || this == pindexBest);
1760 bool CheckIndex() const
1765 enum { nMedianTimeSpan=11 };
1767 int64 GetMedianTimePast() const
1769 int64 pmedian[nMedianTimeSpan];
1770 int64* pbegin = &pmedian[nMedianTimeSpan];
1771 int64* pend = &pmedian[nMedianTimeSpan];
1773 const CBlockIndex* pindex = this;
1774 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1775 *(--pbegin) = pindex->GetBlockTime();
1777 std::sort(pbegin, pend);
1778 return pbegin[(pend - pbegin)/2];
1781 int64 GetMedianTime() const
1783 const CBlockIndex* pindex = this;
1784 for (int i = 0; i < nMedianTimeSpan/2; i++)
1787 return GetBlockTime();
1788 pindex = pindex->pnext;
1790 return pindex->GetMedianTimePast();
1794 * Returns true if there are nRequired or more blocks of minVersion or above
1795 * in the last nToCheck blocks, starting at pstart and going backwards.
1797 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1798 unsigned int nRequired, unsigned int nToCheck);
1800 bool IsProofOfWork() const
1802 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1805 bool IsProofOfStake() const
1807 return (nFlags & BLOCK_PROOF_OF_STAKE);
1810 void SetProofOfStake()
1812 nFlags |= BLOCK_PROOF_OF_STAKE;
1815 unsigned int GetStakeEntropyBit() const
1817 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1820 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1822 if (nEntropyBit > 1)
1824 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1828 bool GeneratedStakeModifier() const
1830 return (nFlags & BLOCK_STAKE_MODIFIER);
1833 void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1835 nStakeModifier = nModifier;
1836 if (fGeneratedStakeModifier)
1837 nFlags |= BLOCK_STAKE_MODIFIER;
1840 std::string ToString() const
1842 return strprintf("CBlockIndex(nprev=%p, pnext=%p nHeight=%d, nMint=%s, nMoneySupply=%s, nFlags=(%s)(%d)(%s), nStakeModifier=%016"PRI64x", nStakeModifierChecksum=%08x, hashProofOfStake=%s, prevoutStake=(%s), nStakeTime=%d merkle=%s, hashBlock=%s)",
1843 pprev, pnext, nHeight,
1844 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1845 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1846 nStakeModifier, nStakeModifierChecksum,
1847 hashProofOfStake.ToString().c_str(),
1848 prevoutStake.ToString().c_str(), nStakeTime,
1849 hashMerkleRoot.ToString().c_str(),
1850 GetBlockHash().ToString().c_str());
1856 printf("%s\n", ToString().c_str());
1860 struct CBlockIndexTrustComparator
1862 bool operator()(CBlockIndex *pa, CBlockIndex *pb) {
1863 if (pa->nChainTrust > pb->nChainTrust) return false;
1864 if (pa->nChainTrust < pb->nChainTrust) return true;
1866 return false; // identical blocks
1870 /** Used to marshal pointers into hashes for db storage. */
1871 class CDiskBlockIndex : public CBlockIndex
1883 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex) {
1884 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1889 if (!(nType & SER_GETHASH))
1890 READWRITE(VARINT(nVersion));
1892 READWRITE(VARINT(nHeight));
1893 READWRITE(VARINT(nStatus));
1894 READWRITE(VARINT(nTx));
1895 if (nStatus & (BLOCK_HAVE_DATA | BLOCK_HAVE_UNDO))
1896 READWRITE(VARINT(nFile));
1897 if (nStatus & BLOCK_HAVE_DATA)
1898 READWRITE(VARINT(nDataPos));
1899 if (nStatus & BLOCK_HAVE_UNDO)
1900 READWRITE(VARINT(nUndoPos));
1902 READWRITE(nMoneySupply);
1904 READWRITE(nStakeModifier);
1905 if (IsProofOfStake())
1907 READWRITE(prevoutStake);
1908 READWRITE(nStakeTime);
1909 READWRITE(hashProofOfStake);
1913 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1914 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1915 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1917 READWRITE(blockHash);
1920 READWRITE(this->nVersion);
1921 READWRITE(hashPrev);
1922 READWRITE(hashMerkleRoot);
1928 uint256 GetBlockHash() const
1930 if (fUseFastIndex && (nTime < GetAdjustedTime() - 24 * 60 * 60) && blockHash != 0)
1934 block.nVersion = nVersion;
1935 block.hashPrevBlock = hashPrev;
1936 block.hashMerkleRoot = hashMerkleRoot;
1937 block.nTime = nTime;
1938 block.nBits = nBits;
1939 block.nNonce = nNonce;
1941 const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1947 std::string ToString() const
1949 std::string str = "CDiskBlockIndex(";
1950 str += CBlockIndex::ToString();
1951 str += strprintf("\n hashBlock=%s, hashPrev=%s)",
1952 GetBlockHash().ToString().c_str(),
1953 hashPrev.ToString().substr(0,20).c_str());
1959 printf("%s\n", ToString().c_str());
1964 /** Describes a place in the block chain to another node such that if the
1965 * other node doesn't have the same branch, it can find a recent common trunk.
1966 * The further back it is, the further before the fork it may be.
1971 std::vector<uint256> vHave;
1978 explicit CBlockLocator(const CBlockIndex* pindex)
1983 explicit CBlockLocator(uint256 hashBlock)
1985 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1986 if (mi != mapBlockIndex.end())
1990 CBlockLocator(const std::vector<uint256>& vHaveIn)
1997 if (!(nType & SER_GETHASH))
1998 READWRITE(nVersion);
2009 return vHave.empty();
2012 void Set(const CBlockIndex* pindex)
2018 vHave.push_back(pindex->GetBlockHash());
2020 // Exponentially larger steps back
2021 for (int i = 0; pindex && i < nStep; i++)
2022 pindex = pindex->pprev;
2023 if (vHave.size() > 10)
2026 vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
2029 int GetDistanceBack()
2031 // Retrace how far back it was in the sender's branch
2034 BOOST_FOREACH(const uint256& hash, vHave)
2036 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
2037 if (mi != mapBlockIndex.end())
2039 CBlockIndex* pindex = (*mi).second;
2040 if (pindex->IsInMainChain())
2050 CBlockIndex* GetBlockIndex()
2052 // Find the first block the caller has in the main chain
2053 BOOST_FOREACH(const uint256& hash, vHave)
2055 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
2056 if (mi != mapBlockIndex.end())
2058 CBlockIndex* pindex = (*mi).second;
2059 if (pindex->IsInMainChain())
2063 return pindexGenesisBlock;
2066 uint256 GetBlockHash()
2068 // Find the first block the caller has in the main chain
2069 BOOST_FOREACH(const uint256& hash, vHave)
2071 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
2072 if (mi != mapBlockIndex.end())
2074 CBlockIndex* pindex = (*mi).second;
2075 if (pindex->IsInMainChain())
2079 return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
2084 CBlockIndex* pindex = GetBlockIndex();
2087 return pindex->nHeight;
2098 mutable CCriticalSection cs;
2099 std::map<uint256, CTransaction> mapTx;
2100 std::map<COutPoint, CInPoint> mapNextTx;
2102 bool accept(CTransaction &tx, bool fCheckInputs, bool* pfMissingInputs);
2103 bool addUnchecked(const uint256& hash, CTransaction &tx);
2104 bool remove(CTransaction &tx);
2106 void queryHashes(std::vector<uint256>& vtxid);
2107 void pruneSpent(const uint256& hash, CCoins &coins);
2109 unsigned long size()
2112 return mapTx.size();
2115 bool exists(uint256 hash)
2117 return (mapTx.count(hash) != 0);
2120 CTransaction& lookup(uint256 hash)
2126 extern CTxMemPool mempool;
2131 uint64 nTransactions;
2132 uint64 nPrunedTransactions;
2133 uint64 nTransactionOutputs;
2134 uint64 nSerializedSize;
2136 CCoinsStats() : nHeight(0), nTransactions(0), nPrunedTransactions(0), nTransactionOutputs(0), nSerializedSize(0) {}
2139 /** Abstract view on the open txout dataset. */
2143 // Retrieve the CCoins (unspent transaction outputs) for a given txid
2144 virtual bool GetCoins(uint256 txid, CCoins &coins);
2146 // Modify the CCoins for a given txid
2147 virtual bool SetCoins(uint256 txid, const CCoins &coins);
2149 // Just check whether we have data for a given txid.
2150 // This may (but cannot always) return true for fully spent transactions
2151 virtual bool HaveCoins(uint256 txid);
2153 // Retrieve the block index whose state this CCoinsView currently represents
2154 virtual CBlockIndex *GetBestBlock();
2156 // Modify the currently active block index
2157 virtual bool SetBestBlock(CBlockIndex *pindex);
2158 virtual bool BatchWrite(const std::map<uint256, CCoins> &mapCoins, CBlockIndex *pindex);
2159 virtual bool GetStats(CCoinsStats &stats);
2162 /** CCoinsView backed by another CCoinsView */
2163 class CCoinsViewBacked : public CCoinsView
2169 CCoinsViewBacked(CCoinsView &viewIn);
2170 bool GetCoins(uint256 txid, CCoins &coins);
2171 bool SetCoins(uint256 txid, const CCoins &coins);
2172 bool HaveCoins(uint256 txid);
2173 CBlockIndex *GetBestBlock();
2174 bool SetBestBlock(CBlockIndex *pindex);
2175 void SetBackend(CCoinsView &viewIn);
2176 bool BatchWrite(const std::map<uint256, CCoins> &mapCoins, CBlockIndex *pindex);
2177 bool GetStats(CCoinsStats &stats);
2180 /** CCoinsView that adds a memory cache for transactions to another CCoinsView */
2181 class CCoinsViewCache : public CCoinsViewBacked
2184 CBlockIndex *pindexTip;
2185 std::map<uint256,CCoins> cacheCoins;
2186 std::map<uint256,CCoins> cacheCoinsReadOnly;
2189 CCoinsViewCache(CCoinsView &baseIn, bool fDummy = false);
2190 bool GetCoins(uint256 txid, CCoins &coins);
2191 bool GetCoinsReadOnly(uint256 txid, CCoins &coins);
2192 bool SetCoins(uint256 txid, const CCoins &coins);
2193 bool HaveCoins(uint256 txid);
2194 CCoins &GetCoins(uint256 txid);
2195 CBlockIndex *GetBestBlock();
2196 bool SetBestBlock(CBlockIndex *pindex);
2197 bool BatchWrite(const std::map<uint256, CCoins> &mapCoins, CBlockIndex *pindex);
2199 unsigned int GetCacheSize();
2201 std::map<uint256,CCoins>::iterator FetchCoins(uint256 txid);
2204 /** CCoinsView that brings transactions from a memorypool into view.
2205 It does not check for spendings by memory pool transactions. */
2206 class CCoinsViewMemPool : public CCoinsViewBacked
2209 CTxMemPool &mempool;
2212 CCoinsViewMemPool(CCoinsView &baseIn, CTxMemPool &mempoolIn);
2213 bool GetCoins(uint256 txid, CCoins &coins);
2214 bool HaveCoins(uint256 txid);
2217 /** Global variable that points to the active CCoinsView (protected by cs_main) */
2218 extern CCoinsViewCache *pcoinsTip;
2220 /** Global variable that points to the active block tree (protected by cs_main) */
2221 extern CBlockTreeDB *pblocktree;