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.
10 #include "timestamps.h"
30 class CRequestTracker;
37 static const unsigned int MAX_BLOCK_SIZE = 1000000;
38 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
39 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
40 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
41 static const unsigned int MAX_INV_SZ = 50000;
43 static const int64_t MIN_TX_FEE = CENT/10;
44 static const int64_t MIN_RELAY_TX_FEE = CENT/50;
46 static const int64_t MAX_MONEY = std::numeric_limits<int64_t>::max();
47 static const int64_t MAX_MINT_PROOF_OF_WORK = 100 * COIN;
48 static const int64_t MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
49 static const int64_t MIN_TXOUT_AMOUNT = CENT/100;
52 inline bool MoneyRange(int64_t nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
53 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
54 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
55 // Maximum number of script-checking threads allowed
56 static const int MAX_SCRIPTCHECK_THREADS = 16;
58 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
59 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
61 inline int64_t PastDrift(int64_t nTime) { return nTime - 2 * nOneHour; } // up to 2 hours from the past
62 inline int64_t FutureDrift(int64_t nTime) { return nTime + 2 * nOneHour; } // up to 2 hours from the future
64 extern CScript COINBASE_FLAGS;
65 extern CCriticalSection cs_main;
66 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
67 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
68 extern CBlockIndex* pindexGenesisBlock;
69 extern unsigned int nNodeLifespan;
70 extern unsigned int nStakeMinAge;
71 extern int nCoinbaseMaturity;
72 extern int nBestHeight;
73 extern uint256 nBestChainTrust;
74 extern uint256 nBestInvalidTrust;
75 extern uint256 hashBestChain;
76 extern CBlockIndex* pindexBest;
77 extern unsigned int nTransactionsUpdated;
78 extern uint64_t nLastBlockTx;
79 extern uint64_t nLastBlockSize;
80 extern uint32_t nLastCoinStakeSearchInterval;
81 extern const std::string strMessageMagic;
82 extern int64_t nTimeBestReceived;
83 extern CCriticalSection cs_setpwalletRegistered;
84 extern std::set<CWallet*> setpwalletRegistered;
85 extern unsigned char pchMessageStart[4];
86 extern std::map<uint256, CBlock*> mapOrphanBlocks;
89 extern int64_t nTransactionFee;
90 extern int64_t nMinimumInputValue;
91 extern bool fUseFastIndex;
92 extern int nScriptCheckThreads;
93 extern const uint256 entropyStore[38];
95 // Minimum disk space required - used in CheckDiskSpace()
96 static const uint64_t nMinDiskSpace = 52428800;
103 void RegisterWallet(CWallet* pwalletIn);
104 void UnregisterWallet(CWallet* pwalletIn);
105 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
106 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
107 bool CheckDiskSpace(uint64_t nAdditionalBytes=0);
108 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
109 FILE* AppendBlockFile(unsigned int& nFileRet);
111 void UnloadBlockIndex();
112 bool LoadBlockIndex(bool fAllowNew=true);
113 void PrintBlockTree();
114 CBlockIndex* FindBlockByHeight(int nHeight);
115 bool ProcessMessages(CNode* pfrom);
116 bool SendMessages(CNode* pto, bool fSendTrickle);
117 bool LoadExternalBlockFile(FILE* fileIn);
119 // Run an instance of the script checking thread
120 void ThreadScriptCheck(void* parg);
121 // Stop the script checking threads
122 void ThreadScriptCheckQuit();
124 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
125 unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, bool fProofOfStake);
126 int64_t GetProofOfWorkReward(unsigned int nBits, int64_t nFees=0);
127 int64_t GetProofOfStakeReward(int64_t nCoinAge, unsigned int nBits, int64_t nTime, bool bCoinYearOnly=false);
128 unsigned int ComputeMinWork(unsigned int nBase, int64_t nTime);
129 unsigned int ComputeMinStake(unsigned int nBase, int64_t nTime, unsigned int nBlockTime);
130 int GetNumBlocksOfPeers();
131 bool IsInitialBlockDownload();
132 std::string GetWarnings(std::string strFor);
133 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
134 uint256 WantedByOrphan(const CBlock* pblockOrphan);
135 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
136 void ResendWalletTransactions(bool fForceResend=false);
138 bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType);
146 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
148 /** Position on disk for a particular transaction. */
161 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
164 nBlockPos = nBlockPosIn;
168 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
169 void SetNull() { nFile = std::numeric_limits<uint32_t>::max(); nBlockPos = 0; nTxPos = 0; }
170 bool IsNull() const { return (nFile == std::numeric_limits<uint32_t>::max()); }
172 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
174 return (a.nFile == b.nFile &&
175 a.nBlockPos == b.nBlockPos &&
176 a.nTxPos == b.nTxPos);
179 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
185 std::string ToString() const
190 return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
195 printf("%s", ToString().c_str());
201 /** An inpoint - a combination of a transaction and an index n into its vin */
208 CInPoint() { SetNull(); }
209 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
210 void SetNull() { ptx = NULL; n = std::numeric_limits<uint32_t>::max(); }
211 bool IsNull() const { return (ptx == NULL && n == std::numeric_limits<uint32_t>::max()); }
216 /** An outpoint - a combination of a transaction hash and an index n into its vout */
223 COutPoint() { SetNull(); }
224 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
225 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
226 void SetNull() { hash = 0; n = std::numeric_limits<uint32_t>::max(); }
227 bool IsNull() const { return (hash == 0 && n == std::numeric_limits<uint32_t>::max()); }
229 friend bool operator<(const COutPoint& a, const COutPoint& b)
231 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
234 friend bool operator==(const COutPoint& a, const COutPoint& b)
236 return (a.hash == b.hash && a.n == b.n);
239 friend bool operator!=(const COutPoint& a, const COutPoint& b)
244 std::string ToString() const
246 return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
251 printf("%s\n", ToString().c_str());
258 /** An input of a transaction. It contains the location of the previous
259 * transaction's output that it claims and a signature that matches the
260 * output's public key.
271 nSequence = std::numeric_limits<unsigned int>::max();
274 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
277 scriptSig = scriptSigIn;
278 nSequence = nSequenceIn;
281 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
283 prevout = COutPoint(hashPrevTx, nOut);
284 scriptSig = scriptSigIn;
285 nSequence = nSequenceIn;
291 READWRITE(scriptSig);
292 READWRITE(nSequence);
297 return (nSequence == std::numeric_limits<unsigned int>::max());
300 friend bool operator==(const CTxIn& a, const CTxIn& b)
302 return (a.prevout == b.prevout &&
303 a.scriptSig == b.scriptSig &&
304 a.nSequence == b.nSequence);
307 friend bool operator!=(const CTxIn& a, const CTxIn& b)
312 std::string ToStringShort() const
314 return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
317 std::string ToString() const
321 str += prevout.ToString();
322 if (prevout.IsNull())
323 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
325 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
326 if (nSequence != std::numeric_limits<unsigned int>::max())
327 str += strprintf(", nSequence=%u", nSequence);
334 printf("%s\n", ToString().c_str());
341 /** An output of a transaction. It contains the public key that the next input
342 * must be able to sign with to claim it.
348 CScript scriptPubKey;
355 CTxOut(int64_t nValueIn, CScript scriptPubKeyIn)
358 scriptPubKey = scriptPubKeyIn;
364 READWRITE(scriptPubKey);
370 scriptPubKey.clear();
375 return (nValue == -1);
381 scriptPubKey.clear();
386 return (nValue == 0 && scriptPubKey.empty());
389 uint256 GetHash() const
391 return SerializeHash(*this);
394 friend bool operator==(const CTxOut& a, const CTxOut& b)
396 return (a.nValue == b.nValue &&
397 a.scriptPubKey == b.scriptPubKey);
400 friend bool operator!=(const CTxOut& a, const CTxOut& b)
405 std::string ToStringShort() const
407 return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
410 std::string ToString() const
412 if (IsEmpty()) return "CTxOut(empty)";
413 if (scriptPubKey.size() < 6)
414 return "CTxOut(error)";
415 return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
420 printf("%s\n", ToString().c_str());
434 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
436 /** The basic transaction that is broadcasted on the network and contained in
437 * blocks. A transaction can contain multiple inputs and outputs.
442 static const int CURRENT_VERSION=1;
445 std::vector<CTxIn> vin;
446 std::vector<CTxOut> vout;
449 // Denial-of-service detection:
451 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
460 READWRITE(this->nVersion);
461 nVersion = this->nVersion;
465 READWRITE(nLockTime);
470 nVersion = CTransaction::CURRENT_VERSION;
471 nTime = (uint32_t) GetAdjustedTime();
475 nDoS = 0; // Denial-of-service prevention
480 return (vin.empty() && vout.empty());
483 uint256 GetHash() const
485 return SerializeHash(*this);
488 bool IsFinal(int nBlockHeight=0, int64_t nBlockTime=0) const
490 // Time based nLockTime implemented in 0.1.6
493 if (nBlockHeight == 0)
494 nBlockHeight = nBestHeight;
496 nBlockTime = GetAdjustedTime();
497 if ((int64_t)nLockTime < ((int64_t)nLockTime < LOCKTIME_THRESHOLD ? (int64_t)nBlockHeight : nBlockTime))
499 BOOST_FOREACH(const CTxIn& txin, vin)
505 bool IsNewerThan(const CTransaction& old) const
507 if (vin.size() != old.vin.size())
509 for (unsigned int i = 0; i < vin.size(); i++)
510 if (vin[i].prevout != old.vin[i].prevout)
514 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
515 for (unsigned int i = 0; i < vin.size(); i++)
517 if (vin[i].nSequence != old.vin[i].nSequence)
519 if (vin[i].nSequence <= nLowest)
522 nLowest = vin[i].nSequence;
524 if (old.vin[i].nSequence < nLowest)
527 nLowest = old.vin[i].nSequence;
534 bool IsCoinBase() const
536 return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
539 bool IsCoinStake() const
541 // ppcoin: the coin stake transaction is marked with the first output empty
542 return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
545 /** Check for standard transaction types
546 @return True if all outputs (scriptPubKeys) use only standard transaction forms
548 bool IsStandard(std::string& strReason) const;
549 bool IsStandard() const
551 std::string strReason;
552 return IsStandard(strReason);
555 /** Check for standard transaction types
556 @param[in] mapInputs Map of previous transactions that have outputs we're spending
557 @return True if all inputs (scriptSigs) use only standard transaction forms
558 @see CTransaction::FetchInputs
560 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
562 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
563 @return number of sigops this transaction's outputs will produce when spent
564 @see CTransaction::FetchInputs
566 unsigned int GetLegacySigOpCount() const;
568 /** Count ECDSA signature operations in pay-to-script-hash inputs.
570 @param[in] mapInputs Map of previous transactions that have outputs we're spending
571 @return maximum number of sigops required to validate this transaction's inputs
572 @see CTransaction::FetchInputs
574 unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
576 /** Amount of bitcoins spent by this transaction.
577 @return sum of all outputs (note: does not include fees)
579 int64_t GetValueOut() const
581 int64_t nValueOut = 0;
582 BOOST_FOREACH(const CTxOut& txout, vout)
584 nValueOut += txout.nValue;
585 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
586 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
591 /** Amount of bitcoins coming in to this transaction
592 Note that lightweight clients may not know anything besides the hash of previous transactions,
593 so may not be able to calculate this.
595 @param[in] mapInputs Map of previous transactions that have outputs we're spending
596 @return Sum of value of all inputs (scriptSigs)
597 @see CTransaction::FetchInputs
599 int64_t GetValueIn(const MapPrevTx& mapInputs) const;
601 static bool AllowFree(double dPriority)
603 // Large (in bytes) low-priority (new, small-coin) transactions
605 return dPriority > COIN * 144 / 250;
608 int64_t GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK, unsigned int nBytes = 0) const;
610 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
612 CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
614 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
617 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
618 return error("CTransaction::ReadFromDisk() : fseek failed");
623 catch (std::exception &e) {
625 return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
628 // Return file pointer
631 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
632 return error("CTransaction::ReadFromDisk() : second fseek failed");
633 *pfileRet = filein.release();
638 friend bool operator==(const CTransaction& a, const CTransaction& b)
640 return (a.nVersion == b.nVersion &&
641 a.nTime == b.nTime &&
644 a.nLockTime == b.nLockTime);
647 friend bool operator!=(const CTransaction& a, const CTransaction& b)
652 std::string ToStringShort() const
655 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
659 std::string ToString() const
662 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
663 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%" PRIszu ", vout.size=%" PRIszu ", nLockTime=%d)\n",
664 GetHash().ToString().substr(0,10).c_str(),
670 for (unsigned int i = 0; i < vin.size(); i++)
671 str += " " + vin[i].ToString() + "\n";
672 for (unsigned int i = 0; i < vout.size(); i++)
673 str += " " + vout[i].ToString() + "\n";
679 printf("%s", ToString().c_str());
683 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
684 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
685 bool ReadFromDisk(COutPoint prevout);
686 bool DisconnectInputs(CTxDB& txdb);
688 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
690 @param[in] txdb Transaction database
691 @param[in] mapTestPool List of pending changes to the transaction index database
692 @param[in] fBlock True if being called to add a new best-block to the chain
693 @param[in] fMiner True if being called by CreateNewBlock
694 @param[out] inputsRet Pointers to this transaction's inputs
695 @param[out] fInvalid returns true if transaction is invalid
696 @return Returns true if all inputs are in txdb or mapTestPool
698 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
699 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
701 /** Sanity check previous transactions, then, if all checks succeed,
702 mark them as spent by this transaction.
704 @param[in] inputs Previous transactions (from FetchInputs)
705 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
706 @param[in] posThisTx Position of this transaction on disk
707 @param[in] pindexBlock
708 @param[in] fBlock true if called from ConnectBlock
709 @param[in] fMiner true if called from CreateNewBlock
710 @param[in] fScriptChecks enable scripts validation?
711 @param[in] flags STRICT_FLAGS script validation flags
712 @param[in] pvChecks NULL If pvChecks is not NULL, script checks are pushed onto it instead of being performed inline.
713 @return Returns true if all checks succeed
715 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs, std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx, const CBlockIndex* pindexBlock,
716 bool fBlock, bool fMiner, bool fScriptChecks=true,
717 unsigned int flags=STRICT_FLAGS, std::vector<CScriptCheck> *pvChecks = NULL);
718 bool ClientConnectInputs();
719 bool CheckTransaction() const;
720 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
721 bool GetCoinAge(CTxDB& txdb, uint64_t& nCoinAge) const; // ppcoin: get transaction coin age
724 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
727 /** Closure representing one script verification
728 * Note that this stores references to the spending transaction */
732 CScript scriptPubKey;
733 const CTransaction *ptxTo;
740 CScriptCheck(const CTransaction& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, int nHashTypeIn) :
741 scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey),
742 ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), nHashType(nHashTypeIn) { }
744 bool operator()() const;
746 void swap(CScriptCheck &check) {
747 scriptPubKey.swap(check.scriptPubKey);
748 std::swap(ptxTo, check.ptxTo);
749 std::swap(nIn, check.nIn);
750 std::swap(nFlags, check.nFlags);
751 std::swap(nHashType, check.nHashType);
758 /** A transaction with a merkle branch linking it to the block chain. */
759 class CMerkleTx : public CTransaction
763 std::vector<uint256> vMerkleBranch;
767 mutable bool fMerkleVerified;
775 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
784 fMerkleVerified = false;
790 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
791 nVersion = this->nVersion;
792 READWRITE(hashBlock);
793 READWRITE(vMerkleBranch);
798 int SetMerkleBranch(const CBlock* pblock=NULL);
799 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
800 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
801 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
802 int GetBlocksToMaturity() const;
803 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
804 bool AcceptToMemoryPool();
810 /** A txdb record that contains the disk location of a transaction and the
811 * locations of transactions that spend its outputs. vSpent is really only
812 * used as a flag, but having the location is very helpful for debugging.
818 std::vector<CDiskTxPos> vSpent;
825 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
828 vSpent.resize(nOutputs);
833 if (!(nType & SER_GETHASH))
850 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
852 return (a.pos == b.pos &&
853 a.vSpent == b.vSpent);
856 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
860 int GetDepthInMainChain() const;
865 /** Nodes collect new transactions into a block, hash them into a hash tree,
866 * and scan through nonce values to make the block's hash satisfy proof-of-work
867 * requirements. When they solve the proof-of-work, they broadcast the block
868 * to everyone and the block is added to the block chain. The first transaction
869 * in the block is a special one that creates a new coin owned by the creator
872 * Blocks are appended to blk0001.dat files on disk. Their location on disk
873 * is indexed by CBlockIndex objects in memory.
879 static const int CURRENT_VERSION=6;
881 uint256 hashPrevBlock;
882 uint256 hashMerkleRoot;
888 std::vector<CTransaction> vtx;
890 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
891 std::vector<unsigned char> vchBlockSig;
894 mutable std::vector<uint256> vMerkleTree;
896 // Denial-of-service detection:
898 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
907 READWRITE(this->nVersion);
908 nVersion = this->nVersion;
909 READWRITE(hashPrevBlock);
910 READWRITE(hashMerkleRoot);
915 // ConnectBlock depends on vtx following header to generate CDiskTxPos
916 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
919 READWRITE(vchBlockSig);
923 const_cast<CBlock*>(this)->vtx.clear();
924 const_cast<CBlock*>(this)->vchBlockSig.clear();
930 nVersion = CBlock::CURRENT_VERSION;
947 uint256 GetHash() const
949 return scrypt_blockhash((const uint8_t*)&nVersion);
952 int64_t GetBlockTime() const
954 return (int64_t)nTime;
957 void UpdateTime(const CBlockIndex* pindexPrev);
959 // ppcoin: entropy bit for stake modifier if chosen by modifier
960 unsigned int GetStakeEntropyBit(unsigned int nHeight) const
962 // Protocol switch to support p2pool at novacoin block #9689
963 if (nHeight >= 9689 || fTestNet)
965 // Take last bit of block hash as entropy bit
966 unsigned int nEntropyBit = (GetHash().Get64()) & (uint64_t)1;
967 if (fDebug && GetBoolArg("-printstakemodifier"))
968 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
972 // Before novacoin block #9689 - get from pregenerated table
973 int nBitNum = nHeight & 0xFF;
974 int nItemNum = nHeight / 0xFF;
976 unsigned int nEntropyBit = (unsigned int) ((entropyStore[nItemNum] & (uint256(1) << nBitNum)) >> nBitNum).Get64();
977 if (fDebug && GetBoolArg("-printstakemodifier"))
978 printf("GetStakeEntropyBit: from pregenerated table, nHeight=%d nEntropyBit=%u\n", nHeight, nEntropyBit);
982 // ppcoin: two types of block: proof-of-work or proof-of-stake
983 bool IsProofOfStake() const
985 return (vtx.size() > 1 && vtx[1].IsCoinStake());
988 bool IsProofOfWork() const
990 return !IsProofOfStake();
993 std::pair<COutPoint, unsigned int> GetProofOfStake() const
995 return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
998 // ppcoin: get max transaction timestamp
999 int64_t GetMaxTransactionTime() const
1001 int64_t maxTransactionTime = 0;
1002 BOOST_FOREACH(const CTransaction& tx, vtx)
1003 maxTransactionTime = std::max(maxTransactionTime, (int64_t)tx.nTime);
1004 return maxTransactionTime;
1007 uint256 BuildMerkleTree() const
1009 vMerkleTree.clear();
1010 BOOST_FOREACH(const CTransaction& tx, vtx)
1011 vMerkleTree.push_back(tx.GetHash());
1013 for (int nSize = (int)vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1015 for (int i = 0; i < nSize; i += 2)
1017 int i2 = std::min(i+1, nSize-1);
1018 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
1019 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
1023 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
1026 std::vector<uint256> GetMerkleBranch(int nIndex) const
1028 if (vMerkleTree.empty())
1030 std::vector<uint256> vMerkleBranch;
1032 for (int nSize = (int)vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1034 int i = std::min(nIndex^1, nSize-1);
1035 vMerkleBranch.push_back(vMerkleTree[j+i]);
1039 return vMerkleBranch;
1042 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1046 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1049 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1051 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1058 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1060 // Open history file to append
1061 CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1063 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1065 // Write index header
1066 unsigned int nSize = fileout.GetSerializeSize(*this);
1067 fileout << FLATDATA(pchMessageStart) << nSize;
1070 long fileOutPos = ftell(fileout);
1072 return error("CBlock::WriteToDisk() : ftell failed");
1073 nBlockPosRet = fileOutPos;
1076 // Flush stdio buffers and commit to disk before returning
1078 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1079 FileCommit(fileout);
1084 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1088 // Open history file to read
1089 CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1091 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1092 if (!fReadTransactions)
1093 filein.nType |= SER_BLOCKHEADERONLY;
1099 catch (std::exception &e) {
1101 return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
1105 if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1106 return error("CBlock::ReadFromDisk() : errors in block header");
1115 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%" PRIszu ", vchBlockSig=%s)\n",
1116 GetHash().ToString().c_str(),
1118 hashPrevBlock.ToString().c_str(),
1119 hashMerkleRoot.ToString().c_str(),
1120 nTime, nBits, nNonce,
1122 HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1123 for (unsigned int i = 0; i < vtx.size(); i++)
1128 printf(" vMerkleTree: ");
1129 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1130 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1135 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1136 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1137 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1138 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1139 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1140 bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1142 bool GetCoinAge(uint64_t& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1143 bool CheckBlockSignature() const;
1146 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1154 /** The block chain is a tree shaped structure starting with the
1155 * genesis block at the root, with each block potentially having multiple
1156 * candidates to be the next block. pprev and pnext link a path through the
1157 * main/longest chain. A blockindex may have multiple pprev pointing back
1158 * to it, but pnext will only point forward to the longest branch, or will
1159 * be null if the block is not part of the longest chain.
1164 const uint256* phashBlock;
1169 uint256 nChainTrust; // ppcoin: trust score of block chain
1173 int64_t nMoneySupply;
1175 uint32_t nFlags; // ppcoin: block index flags
1178 BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1179 BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
1180 BLOCK_STAKE_MODIFIER = (1 << 2) // regenerated stake modifier
1183 uint64_t nStakeModifier; // hash modifier for proof-of-stake
1184 uint32_t nStakeModifierChecksum; // checksum of index; in-memeory only
1186 // proof-of-stake specific fields
1187 COutPoint prevoutStake;
1188 uint32_t nStakeTime;
1189 uint256 hashProofOfStake;
1193 uint256 hashMerkleRoot;
1211 nStakeModifierChecksum = 0;
1212 hashProofOfStake = 0;
1213 prevoutStake.SetNull();
1223 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1229 nBlockPos = nBlockPosIn;
1236 nStakeModifierChecksum = 0;
1237 hashProofOfStake = 0;
1238 if (block.IsProofOfStake())
1241 prevoutStake = block.vtx[1].vin[0].prevout;
1242 nStakeTime = block.vtx[1].nTime;
1246 prevoutStake.SetNull();
1250 nVersion = block.nVersion;
1251 hashMerkleRoot = block.hashMerkleRoot;
1252 nTime = block.nTime;
1253 nBits = block.nBits;
1254 nNonce = block.nNonce;
1257 CBlock GetBlockHeader() const
1260 block.nVersion = nVersion;
1262 block.hashPrevBlock = pprev->GetBlockHash();
1263 block.hashMerkleRoot = hashMerkleRoot;
1264 block.nTime = nTime;
1265 block.nBits = nBits;
1266 block.nNonce = nNonce;
1270 uint256 GetBlockHash() const
1275 int64_t GetBlockTime() const
1277 return (int64_t)nTime;
1280 uint256 GetBlockTrust() const;
1282 bool IsInMainChain() const
1284 return (pnext || this == pindexBest);
1287 bool CheckIndex() const
1292 enum { nMedianTimeSpan=11 };
1294 int64_t GetMedianTimePast() const
1296 int64_t pmedian[nMedianTimeSpan];
1297 int64_t* pbegin = &pmedian[nMedianTimeSpan];
1298 int64_t* pend = &pmedian[nMedianTimeSpan];
1300 const CBlockIndex* pindex = this;
1301 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1302 *(--pbegin) = pindex->GetBlockTime();
1304 std::sort(pbegin, pend);
1305 return pbegin[(pend - pbegin)/2];
1308 int64_t GetMedianTime() const
1310 const CBlockIndex* pindex = this;
1311 for (int i = 0; i < nMedianTimeSpan/2; i++)
1314 return GetBlockTime();
1315 pindex = pindex->pnext;
1317 return pindex->GetMedianTimePast();
1321 * Returns true if there are nRequired or more blocks of minVersion or above
1322 * in the last nToCheck blocks, starting at pstart and going backwards.
1324 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1325 unsigned int nRequired, unsigned int nToCheck);
1328 bool IsProofOfWork() const
1330 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1333 bool IsProofOfStake() const
1335 return (nFlags & BLOCK_PROOF_OF_STAKE);
1338 void SetProofOfStake()
1340 nFlags |= BLOCK_PROOF_OF_STAKE;
1343 unsigned int GetStakeEntropyBit() const
1345 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1348 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1350 if (nEntropyBit > 1)
1352 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1356 bool GeneratedStakeModifier() const
1358 return (nFlags & BLOCK_STAKE_MODIFIER) != 0;
1361 void SetStakeModifier(uint64_t nModifier, bool fGeneratedStakeModifier)
1363 nStakeModifier = nModifier;
1364 if (fGeneratedStakeModifier)
1365 nFlags |= BLOCK_STAKE_MODIFIER;
1368 std::string ToString() const
1370 return strprintf("CBlockIndex(nprev=%p, pnext=%p, nFile=%u, nBlockPos=%-6d nHeight=%d, nMint=%s, nMoneySupply=%s, nFlags=(%s)(%d)(%s), nStakeModifier=%016" PRIx64 ", nStakeModifierChecksum=%08x, hashProofOfStake=%s, prevoutStake=(%s), nStakeTime=%d merkle=%s, hashBlock=%s)",
1371 (const void*)pprev, (const void*)pnext, nFile, nBlockPos, nHeight,
1372 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1373 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1374 nStakeModifier, nStakeModifierChecksum,
1375 hashProofOfStake.ToString().c_str(),
1376 prevoutStake.ToString().c_str(), nStakeTime,
1377 hashMerkleRoot.ToString().c_str(),
1378 GetBlockHash().ToString().c_str());
1383 printf("%s\n", ToString().c_str());
1389 /** Used to marshal pointers into hashes for db storage. */
1390 class CDiskBlockIndex : public CBlockIndex
1406 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1408 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1409 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1414 if (!(nType & SER_GETHASH))
1415 READWRITE(nVersion);
1417 READWRITE(hashNext);
1419 READWRITE(nBlockPos);
1422 READWRITE(nMoneySupply);
1424 READWRITE(nStakeModifier);
1425 if (IsProofOfStake())
1427 READWRITE(prevoutStake);
1428 READWRITE(nStakeTime);
1429 READWRITE(hashProofOfStake);
1433 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1434 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1435 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1439 READWRITE(this->nVersion);
1440 READWRITE(hashPrev);
1441 READWRITE(hashMerkleRoot);
1445 READWRITE(blockHash);
1448 uint256 GetBlockHash() const
1450 if (fUseFastIndex && (nTime < GetAdjustedTime() - nOneDay) && blockHash != 0)
1454 block.nVersion = nVersion;
1455 block.hashPrevBlock = hashPrev;
1456 block.hashMerkleRoot = hashMerkleRoot;
1457 block.nTime = nTime;
1458 block.nBits = nBits;
1459 block.nNonce = nNonce;
1461 const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1466 std::string ToString() const
1468 std::string str = "CDiskBlockIndex(";
1469 str += CBlockIndex::ToString();
1470 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1471 GetBlockHash().ToString().c_str(),
1472 hashPrev.ToString().c_str(),
1473 hashNext.ToString().c_str());
1479 printf("%s\n", ToString().c_str());
1490 /** Describes a place in the block chain to another node such that if the
1491 * other node doesn't have the same branch, it can find a recent common trunk.
1492 * The further back it is, the further before the fork it may be.
1497 std::vector<uint256> vHave;
1504 explicit CBlockLocator(const CBlockIndex* pindex)
1509 explicit CBlockLocator(uint256 hashBlock)
1511 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1512 if (mi != mapBlockIndex.end())
1516 CBlockLocator(const std::vector<uint256>& vHaveIn)
1523 if (!(nType & SER_GETHASH))
1524 READWRITE(nVersion);
1535 return vHave.empty();
1538 void Set(const CBlockIndex* pindex)
1544 vHave.push_back(pindex->GetBlockHash());
1546 // Exponentially larger steps back
1547 for (int i = 0; pindex && i < nStep; i++)
1548 pindex = pindex->pprev;
1549 if (vHave.size() > 10)
1552 vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1555 int GetDistanceBack()
1557 // Retrace how far back it was in the sender's branch
1560 BOOST_FOREACH(const uint256& hash, vHave)
1562 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1563 if (mi != mapBlockIndex.end())
1565 CBlockIndex* pindex = (*mi).second;
1566 if (pindex->IsInMainChain())
1576 CBlockIndex* GetBlockIndex()
1578 // Find the first block the caller has in the main chain
1579 BOOST_FOREACH(const uint256& hash, vHave)
1581 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1582 if (mi != mapBlockIndex.end())
1584 CBlockIndex* pindex = (*mi).second;
1585 if (pindex->IsInMainChain())
1589 return pindexGenesisBlock;
1592 uint256 GetBlockHash()
1594 // Find the first block the caller has in the main chain
1595 BOOST_FOREACH(const uint256& hash, vHave)
1597 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1598 if (mi != mapBlockIndex.end())
1600 CBlockIndex* pindex = (*mi).second;
1601 if (pindex->IsInMainChain())
1605 return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1610 CBlockIndex* pindex = GetBlockIndex();
1613 return pindex->nHeight;
1627 mutable CCriticalSection cs;
1628 std::map<uint256, CTransaction> mapTx;
1629 std::map<COutPoint, CInPoint> mapNextTx;
1631 bool accept(CTxDB& txdb, CTransaction &tx,
1632 bool fCheckInputs, bool* pfMissingInputs);
1633 bool addUnchecked(const uint256& hash, CTransaction &tx);
1634 bool remove(CTransaction &tx);
1636 void queryHashes(std::vector<uint256>& vtxid);
1641 return mapTx.size();
1644 bool exists(uint256 hash)
1646 return (mapTx.count(hash) != 0);
1649 CTransaction& lookup(uint256 hash)
1655 extern CTxMemPool mempool;