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"
29 class CRequestTracker;
36 static const unsigned int MAX_BLOCK_SIZE = 1000000;
37 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
38 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
39 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
40 static const unsigned int MAX_INV_SZ = 50000;
42 static const int64_t MIN_TX_FEE = CENT/10;
43 static const int64_t MIN_RELAY_TX_FEE = CENT/50;
45 static const int64_t MAX_MONEY = 2000000000 * COIN;
46 static const int64_t MAX_MINT_PROOF_OF_WORK = 100 * COIN;
47 static const int64_t MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
48 static const int64_t MIN_TXOUT_AMOUNT = CENT/100;
50 inline bool MoneyRange(int64_t 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
53 // Maximum number of script-checking threads allowed
54 static const int MAX_SCRIPTCHECK_THREADS = 16;
57 static const int fHaveUPnP = true;
59 static const int fHaveUPnP = false;
62 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
63 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
65 inline int64_t PastDrift(int64_t nTime) { return nTime - 2 * 60 * 60; } // up to 2 hours from the past
66 inline int64_t FutureDrift(int64_t nTime) { return nTime + 2 * 60 * 60; } // up to 2 hours from the future
68 extern CScript COINBASE_FLAGS;
69 extern CCriticalSection cs_main;
70 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
71 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
72 extern CBlockIndex* pindexGenesisBlock;
73 extern unsigned int nNodeLifespan;
74 extern unsigned int nStakeMinAge;
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_t nLastBlockTx;
83 extern uint64_t nLastBlockSize;
84 extern int64_t nLastCoinStakeSearchInterval;
85 extern const std::string strMessageMagic;
86 extern int64_t 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_t nTransactionFee;
94 extern int64_t nMinimumInputValue;
95 extern bool fUseFastIndex;
96 extern unsigned int nDerivationMethodIndex;
97 extern int nScriptCheckThreads;
99 // Minimum disk space required - used in CheckDiskSpace()
100 static const uint64_t nMinDiskSpace = 52428800;
107 void RegisterWallet(CWallet* pwalletIn);
108 void UnregisterWallet(CWallet* pwalletIn);
109 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
110 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
111 bool CheckDiskSpace(uint64_t nAdditionalBytes=0);
112 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
113 FILE* AppendBlockFile(unsigned int& nFileRet);
114 bool LoadBlockIndex(bool fAllowNew=true);
115 void PrintBlockTree();
116 CBlockIndex* FindBlockByHeight(int nHeight);
117 bool ProcessMessages(CNode* pfrom);
118 bool SendMessages(CNode* pto, bool fSendTrickle);
119 bool LoadExternalBlockFile(FILE* fileIn);
121 // Run an instance of the script checking thread
122 void ThreadScriptCheck(void* parg);
123 // Stop the script checking threads
124 void ThreadScriptCheckQuit();
126 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
127 unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, bool fProofOfStake);
128 int64_t GetProofOfWorkReward(unsigned int nBits, int64_t nFees=0);
129 int64_t GetProofOfStakeReward(int64_t nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly=false);
130 unsigned int ComputeMinWork(unsigned int nBase, int64_t nTime);
131 unsigned int ComputeMinStake(unsigned int nBase, int64_t nTime, unsigned int nBlockTime);
132 int GetNumBlocksOfPeers();
133 bool IsInitialBlockDownload();
134 std::string GetWarnings(std::string strFor);
135 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
136 uint256 WantedByOrphan(const CBlock* pblockOrphan);
137 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
138 void StakeMiner(CWallet *pwallet);
139 void ResendWalletTransactions();
141 bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType);
149 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
151 /** Position on disk for a particular transaction. */
164 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
167 nBlockPos = nBlockPosIn;
171 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
172 void SetNull() { nFile = (unsigned int) -1; nBlockPos = 0; nTxPos = 0; }
173 bool IsNull() const { return (nFile == (unsigned int) -1); }
175 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
177 return (a.nFile == b.nFile &&
178 a.nBlockPos == b.nBlockPos &&
179 a.nTxPos == b.nTxPos);
182 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
188 std::string ToString() const
193 return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
198 printf("%s", ToString().c_str());
204 /** An inpoint - a combination of a transaction and an index n into its vin */
211 CInPoint() { SetNull(); }
212 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
213 void SetNull() { ptx = NULL; n = (unsigned int) -1; }
214 bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
219 /** An outpoint - a combination of a transaction hash and an index n into its vout */
226 COutPoint() { SetNull(); }
227 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
228 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
229 void SetNull() { hash = 0; n = (unsigned int) -1; }
230 bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
232 friend bool operator<(const COutPoint& a, const COutPoint& b)
234 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
237 friend bool operator==(const COutPoint& a, const COutPoint& b)
239 return (a.hash == b.hash && a.n == b.n);
242 friend bool operator!=(const COutPoint& a, const COutPoint& b)
247 std::string ToString() const
249 return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
254 printf("%s\n", ToString().c_str());
261 /** An input of a transaction. It contains the location of the previous
262 * transaction's output that it claims and a signature that matches the
263 * output's public key.
274 nSequence = std::numeric_limits<unsigned int>::max();
277 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
280 scriptSig = scriptSigIn;
281 nSequence = nSequenceIn;
284 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
286 prevout = COutPoint(hashPrevTx, nOut);
287 scriptSig = scriptSigIn;
288 nSequence = nSequenceIn;
294 READWRITE(scriptSig);
295 READWRITE(nSequence);
300 return (nSequence == std::numeric_limits<unsigned int>::max());
303 friend bool operator==(const CTxIn& a, const CTxIn& b)
305 return (a.prevout == b.prevout &&
306 a.scriptSig == b.scriptSig &&
307 a.nSequence == b.nSequence);
310 friend bool operator!=(const CTxIn& a, const CTxIn& b)
315 std::string ToStringShort() const
317 return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
320 std::string ToString() const
324 str += prevout.ToString();
325 if (prevout.IsNull())
326 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
328 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
329 if (nSequence != std::numeric_limits<unsigned int>::max())
330 str += strprintf(", nSequence=%u", nSequence);
337 printf("%s\n", ToString().c_str());
344 /** An output of a transaction. It contains the public key that the next input
345 * must be able to sign with to claim it.
351 CScript scriptPubKey;
358 CTxOut(int64_t nValueIn, CScript scriptPubKeyIn)
361 scriptPubKey = scriptPubKeyIn;
367 READWRITE(scriptPubKey);
373 scriptPubKey.clear();
378 return (nValue == -1);
384 scriptPubKey.clear();
389 return (nValue == 0 && scriptPubKey.empty());
392 uint256 GetHash() const
394 return SerializeHash(*this);
397 friend bool operator==(const CTxOut& a, const CTxOut& b)
399 return (a.nValue == b.nValue &&
400 a.scriptPubKey == b.scriptPubKey);
403 friend bool operator!=(const CTxOut& a, const CTxOut& b)
408 std::string ToStringShort() const
410 return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
413 std::string ToString() const
415 if (IsEmpty()) return "CTxOut(empty)";
416 if (scriptPubKey.size() < 6)
417 return "CTxOut(error)";
418 return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
423 printf("%s\n", ToString().c_str());
437 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
439 /** The basic transaction that is broadcasted on the network and contained in
440 * blocks. A transaction can contain multiple inputs and outputs.
445 static const int CURRENT_VERSION=1;
448 std::vector<CTxIn> vin;
449 std::vector<CTxOut> vout;
452 // Denial-of-service detection:
454 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
463 READWRITE(this->nVersion);
464 nVersion = this->nVersion;
468 READWRITE(nLockTime);
473 nVersion = CTransaction::CURRENT_VERSION;
474 nTime = (uint32_t) GetAdjustedTime();
478 nDoS = 0; // Denial-of-service prevention
483 return (vin.empty() && vout.empty());
486 uint256 GetHash() const
488 return SerializeHash(*this);
491 bool IsFinal(int nBlockHeight=0, int64_t nBlockTime=0) const
493 // Time based nLockTime implemented in 0.1.6
496 if (nBlockHeight == 0)
497 nBlockHeight = nBestHeight;
499 nBlockTime = GetAdjustedTime();
500 if ((int64_t)nLockTime < ((int64_t)nLockTime < LOCKTIME_THRESHOLD ? (int64_t)nBlockHeight : nBlockTime))
502 BOOST_FOREACH(const CTxIn& txin, vin)
508 bool IsNewerThan(const CTransaction& old) const
510 if (vin.size() != old.vin.size())
512 for (unsigned int i = 0; i < vin.size(); i++)
513 if (vin[i].prevout != old.vin[i].prevout)
517 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
518 for (unsigned int i = 0; i < vin.size(); i++)
520 if (vin[i].nSequence != old.vin[i].nSequence)
522 if (vin[i].nSequence <= nLowest)
525 nLowest = vin[i].nSequence;
527 if (old.vin[i].nSequence < nLowest)
530 nLowest = old.vin[i].nSequence;
537 bool IsCoinBase() const
539 return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
542 bool IsCoinStake() const
544 // ppcoin: the coin stake transaction is marked with the first output empty
545 return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
548 /** Check for standard transaction types
549 @return True if all outputs (scriptPubKeys) use only standard transaction forms
551 bool IsStandard() const;
553 /** Check for standard transaction types
554 @param[in] mapInputs Map of previous transactions that have outputs we're spending
555 @return True if all inputs (scriptSigs) use only standard transaction forms
556 @see CTransaction::FetchInputs
558 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
560 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
561 @return number of sigops this transaction's outputs will produce when spent
562 @see CTransaction::FetchInputs
564 unsigned int GetLegacySigOpCount() const;
566 /** Count ECDSA signature operations in pay-to-script-hash inputs.
568 @param[in] mapInputs Map of previous transactions that have outputs we're spending
569 @return maximum number of sigops required to validate this transaction's inputs
570 @see CTransaction::FetchInputs
572 unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
574 /** Amount of bitcoins spent by this transaction.
575 @return sum of all outputs (note: does not include fees)
577 int64_t GetValueOut() const
579 int64_t nValueOut = 0;
580 BOOST_FOREACH(const CTxOut& txout, vout)
582 nValueOut += txout.nValue;
583 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
584 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
589 /** Amount of bitcoins coming in to this transaction
590 Note that lightweight clients may not know anything besides the hash of previous transactions,
591 so may not be able to calculate this.
593 @param[in] mapInputs Map of previous transactions that have outputs we're spending
594 @return Sum of value of all inputs (scriptSigs)
595 @see CTransaction::FetchInputs
597 int64_t GetValueIn(const MapPrevTx& mapInputs) const;
599 static bool AllowFree(double dPriority)
601 // Large (in bytes) low-priority (new, small-coin) transactions
603 return dPriority > COIN * 144 / 250;
606 int64_t GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK, unsigned int nBytes = 0) const;
608 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
610 CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
612 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
615 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
616 return error("CTransaction::ReadFromDisk() : fseek failed");
621 catch (std::exception &e) {
623 return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
626 // Return file pointer
629 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
630 return error("CTransaction::ReadFromDisk() : second fseek failed");
631 *pfileRet = filein.release();
636 friend bool operator==(const CTransaction& a, const CTransaction& b)
638 return (a.nVersion == b.nVersion &&
639 a.nTime == b.nTime &&
642 a.nLockTime == b.nLockTime);
645 friend bool operator!=(const CTransaction& a, const CTransaction& b)
650 std::string ToStringShort() const
653 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
657 std::string ToString() const
660 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
661 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%" PRIszu ", vout.size=%" PRIszu ", nLockTime=%d)\n",
662 GetHash().ToString().substr(0,10).c_str(),
668 for (unsigned int i = 0; i < vin.size(); i++)
669 str += " " + vin[i].ToString() + "\n";
670 for (unsigned int i = 0; i < vout.size(); i++)
671 str += " " + vout[i].ToString() + "\n";
677 printf("%s", ToString().c_str());
681 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
682 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
683 bool ReadFromDisk(COutPoint prevout);
684 bool DisconnectInputs(CTxDB& txdb);
686 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
688 @param[in] txdb Transaction database
689 @param[in] mapTestPool List of pending changes to the transaction index database
690 @param[in] fBlock True if being called to add a new best-block to the chain
691 @param[in] fMiner True if being called by CreateNewBlock
692 @param[out] inputsRet Pointers to this transaction's inputs
693 @param[out] fInvalid returns true if transaction is invalid
694 @return Returns true if all inputs are in txdb or mapTestPool
696 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
697 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
699 /** Sanity check previous transactions, then, if all checks succeed,
700 mark them as spent by this transaction.
702 @param[in] inputs Previous transactions (from FetchInputs)
703 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
704 @param[in] posThisTx Position of this transaction on disk
705 @param[in] pindexBlock
706 @param[in] fBlock true if called from ConnectBlock
707 @param[in] fMiner true if called from CreateNewBlock
708 @param[in] fScriptChecks enable scripts validation?
709 @param[in] flags STRICT_FLAGS script validation flags
710 @param[in] pvChecks NULL If pvChecks is not NULL, script checks are pushed onto it instead of being performed inline.
711 @return Returns true if all checks succeed
713 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs, std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx, const CBlockIndex* pindexBlock,
714 bool fBlock, bool fMiner, bool fScriptChecks=true,
715 unsigned int flags=STRICT_FLAGS, std::vector<CScriptCheck> *pvChecks = NULL);
716 bool ClientConnectInputs();
717 bool CheckTransaction() const;
718 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
719 bool GetCoinAge(CTxDB& txdb, uint64_t& nCoinAge) const; // ppcoin: get transaction coin age
722 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
725 /** Closure representing one script verification
726 * Note that this stores references to the spending transaction */
730 CScript scriptPubKey;
731 const CTransaction *ptxTo;
738 CScriptCheck(const CTransaction& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, int nHashTypeIn) :
739 scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey),
740 ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), nHashType(nHashTypeIn) { }
742 bool operator()() const;
744 void swap(CScriptCheck &check) {
745 scriptPubKey.swap(check.scriptPubKey);
746 std::swap(ptxTo, check.ptxTo);
747 std::swap(nIn, check.nIn);
748 std::swap(nFlags, check.nFlags);
749 std::swap(nHashType, check.nHashType);
756 /** A transaction with a merkle branch linking it to the block chain. */
757 class CMerkleTx : public CTransaction
761 std::vector<uint256> vMerkleBranch;
765 mutable bool fMerkleVerified;
773 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
782 fMerkleVerified = false;
788 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
789 nVersion = this->nVersion;
790 READWRITE(hashBlock);
791 READWRITE(vMerkleBranch);
796 int SetMerkleBranch(const CBlock* pblock=NULL);
797 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
798 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
799 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
800 int GetBlocksToMaturity() const;
801 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
802 bool AcceptToMemoryPool();
808 /** A txdb record that contains the disk location of a transaction and the
809 * locations of transactions that spend its outputs. vSpent is really only
810 * used as a flag, but having the location is very helpful for debugging.
816 std::vector<CDiskTxPos> vSpent;
823 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
826 vSpent.resize(nOutputs);
831 if (!(nType & SER_GETHASH))
848 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
850 return (a.pos == b.pos &&
851 a.vSpent == b.vSpent);
854 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
858 int GetDepthInMainChain() const;
866 /** Nodes collect new transactions into a block, hash them into a hash tree,
867 * and scan through nonce values to make the block's hash satisfy proof-of-work
868 * requirements. When they solve the proof-of-work, they broadcast the block
869 * to everyone and the block is added to the block chain. The first transaction
870 * in the block is a special one that creates a new coin owned by the creator
873 * Blocks are appended to blk0001.dat files on disk. Their location on disk
874 * is indexed by CBlockIndex objects in memory.
880 static const int CURRENT_VERSION=6;
882 uint256 hashPrevBlock;
883 uint256 hashMerkleRoot;
889 std::vector<CTransaction> vtx;
891 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
892 std::vector<unsigned char> vchBlockSig;
895 mutable std::vector<uint256> vMerkleTree;
897 // Denial-of-service detection:
899 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
908 READWRITE(this->nVersion);
909 nVersion = this->nVersion;
910 READWRITE(hashPrevBlock);
911 READWRITE(hashMerkleRoot);
916 // ConnectBlock depends on vtx following header to generate CDiskTxPos
917 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
920 READWRITE(vchBlockSig);
924 const_cast<CBlock*>(this)->vtx.clear();
925 const_cast<CBlock*>(this)->vchBlockSig.clear();
931 nVersion = CBlock::CURRENT_VERSION;
948 uint256 GetHash() const
950 return scrypt_blockhash(CVOIDBEGIN(nVersion));
953 int64_t GetBlockTime() const
955 return (int64_t)nTime;
958 void UpdateTime(const CBlockIndex* pindexPrev);
960 // ppcoin: entropy bit for stake modifier if chosen by modifier
961 unsigned int GetStakeEntropyBit(unsigned int nTime) const
963 // Protocol switch to support p2pool at novacoin block #9689
964 if (nTime >= ENTROPY_SWITCH_TIME || fTestNet)
966 // Take last bit of block hash as entropy bit
967 unsigned int nEntropyBit = ((GetHash().Get64()) & 1ULL);
968 if (fDebug && GetBoolArg("-printstakemodifier"))
969 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
972 // Before novacoin block #9689 - old protocol
973 uint160 hashSig = Hash160(vchBlockSig);
974 if (fDebug && GetBoolArg("-printstakemodifier"))
975 printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
976 hashSig >>= 159; // take the first bit of the hash
977 if (fDebug && GetBoolArg("-printstakemodifier"))
978 printf(" entropybit=%" PRId64 "\n", hashSig.Get64());
979 return (unsigned int)hashSig.Get64();
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 SignBlock(CWallet& keystore);
1144 bool CheckBlockSignature(bool fProofOfStake) const;
1147 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1155 /** The block chain is a tree shaped structure starting with the
1156 * genesis block at the root, with each block potentially having multiple
1157 * candidates to be the next block. pprev and pnext link a path through the
1158 * main/longest chain. A blockindex may have multiple pprev pointing back
1159 * to it, but pnext will only point forward to the longest branch, or will
1160 * be null if the block is not part of the longest chain.
1165 const uint256* phashBlock;
1170 uint256 nChainTrust; // ppcoin: trust score of block chain
1174 int64_t nMoneySupply;
1176 uint32_t nFlags; // ppcoin: block index flags
1179 BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1180 BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
1181 BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1184 uint64_t nStakeModifier; // hash modifier for proof-of-stake
1185 uint32_t nStakeModifierChecksum; // checksum of index; in-memeory only
1187 // proof-of-stake specific fields
1188 COutPoint prevoutStake;
1189 uint32_t nStakeTime;
1190 uint256 hashProofOfStake;
1194 uint256 hashMerkleRoot;
1212 nStakeModifierChecksum = 0;
1213 hashProofOfStake = 0;
1214 prevoutStake.SetNull();
1224 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1230 nBlockPos = nBlockPosIn;
1237 nStakeModifierChecksum = 0;
1238 hashProofOfStake = 0;
1239 if (block.IsProofOfStake())
1242 prevoutStake = block.vtx[1].vin[0].prevout;
1243 nStakeTime = block.vtx[1].nTime;
1247 prevoutStake.SetNull();
1251 nVersion = block.nVersion;
1252 hashMerkleRoot = block.hashMerkleRoot;
1253 nTime = block.nTime;
1254 nBits = block.nBits;
1255 nNonce = block.nNonce;
1258 CBlock GetBlockHeader() const
1261 block.nVersion = nVersion;
1263 block.hashPrevBlock = pprev->GetBlockHash();
1264 block.hashMerkleRoot = hashMerkleRoot;
1265 block.nTime = nTime;
1266 block.nBits = nBits;
1267 block.nNonce = nNonce;
1271 uint256 GetBlockHash() const
1276 int64_t GetBlockTime() const
1278 return (int64_t)nTime;
1281 uint256 GetBlockTrust() const;
1283 bool IsInMainChain() const
1285 return (pnext || this == pindexBest);
1288 bool CheckIndex() const
1293 enum { nMedianTimeSpan=11 };
1295 int64_t GetMedianTimePast() const
1297 int64_t pmedian[nMedianTimeSpan];
1298 int64_t* pbegin = &pmedian[nMedianTimeSpan];
1299 int64_t* pend = &pmedian[nMedianTimeSpan];
1301 const CBlockIndex* pindex = this;
1302 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1303 *(--pbegin) = pindex->GetBlockTime();
1305 std::sort(pbegin, pend);
1306 return pbegin[(pend - pbegin)/2];
1309 int64_t GetMedianTime() const
1311 const CBlockIndex* pindex = this;
1312 for (int i = 0; i < nMedianTimeSpan/2; i++)
1315 return GetBlockTime();
1316 pindex = pindex->pnext;
1318 return pindex->GetMedianTimePast();
1322 * Returns true if there are nRequired or more blocks of minVersion or above
1323 * in the last nToCheck blocks, starting at pstart and going backwards.
1325 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1326 unsigned int nRequired, unsigned int nToCheck);
1329 bool IsProofOfWork() const
1331 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1334 bool IsProofOfStake() const
1336 return (nFlags & BLOCK_PROOF_OF_STAKE);
1339 void SetProofOfStake()
1341 nFlags |= BLOCK_PROOF_OF_STAKE;
1344 unsigned int GetStakeEntropyBit() const
1346 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1349 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1351 if (nEntropyBit > 1)
1353 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1357 bool GeneratedStakeModifier() const
1359 return (nFlags & BLOCK_STAKE_MODIFIER) != 0;
1362 void SetStakeModifier(uint64_t nModifier, bool fGeneratedStakeModifier)
1364 nStakeModifier = nModifier;
1365 if (fGeneratedStakeModifier)
1366 nFlags |= BLOCK_STAKE_MODIFIER;
1369 std::string ToString() const
1371 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)",
1372 pprev, pnext, nFile, nBlockPos, nHeight,
1373 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1374 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1375 nStakeModifier, nStakeModifierChecksum,
1376 hashProofOfStake.ToString().c_str(),
1377 prevoutStake.ToString().c_str(), nStakeTime,
1378 hashMerkleRoot.ToString().c_str(),
1379 GetBlockHash().ToString().c_str());
1384 printf("%s\n", ToString().c_str());
1390 /** Used to marshal pointers into hashes for db storage. */
1391 class CDiskBlockIndex : public CBlockIndex
1407 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1409 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1410 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1415 if (!(nType & SER_GETHASH))
1416 READWRITE(nVersion);
1418 READWRITE(hashNext);
1420 READWRITE(nBlockPos);
1423 READWRITE(nMoneySupply);
1425 READWRITE(nStakeModifier);
1426 if (IsProofOfStake())
1428 READWRITE(prevoutStake);
1429 READWRITE(nStakeTime);
1430 READWRITE(hashProofOfStake);
1434 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1435 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1436 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1440 READWRITE(this->nVersion);
1441 READWRITE(hashPrev);
1442 READWRITE(hashMerkleRoot);
1446 READWRITE(blockHash);
1449 uint256 GetBlockHash() const
1451 if (fUseFastIndex && (nTime < GetAdjustedTime() - 24 * 60 * 60) && blockHash != 0)
1455 block.nVersion = nVersion;
1456 block.hashPrevBlock = hashPrev;
1457 block.hashMerkleRoot = hashMerkleRoot;
1458 block.nTime = nTime;
1459 block.nBits = nBits;
1460 block.nNonce = nNonce;
1462 const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1467 std::string ToString() const
1469 std::string str = "CDiskBlockIndex(";
1470 str += CBlockIndex::ToString();
1471 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1472 GetBlockHash().ToString().c_str(),
1473 hashPrev.ToString().c_str(),
1474 hashNext.ToString().c_str());
1480 printf("%s\n", ToString().c_str());
1491 /** Describes a place in the block chain to another node such that if the
1492 * other node doesn't have the same branch, it can find a recent common trunk.
1493 * The further back it is, the further before the fork it may be.
1498 std::vector<uint256> vHave;
1505 explicit CBlockLocator(const CBlockIndex* pindex)
1510 explicit CBlockLocator(uint256 hashBlock)
1512 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1513 if (mi != mapBlockIndex.end())
1517 CBlockLocator(const std::vector<uint256>& vHaveIn)
1524 if (!(nType & SER_GETHASH))
1525 READWRITE(nVersion);
1536 return vHave.empty();
1539 void Set(const CBlockIndex* pindex)
1545 vHave.push_back(pindex->GetBlockHash());
1547 // Exponentially larger steps back
1548 for (int i = 0; pindex && i < nStep; i++)
1549 pindex = pindex->pprev;
1550 if (vHave.size() > 10)
1553 vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1556 int GetDistanceBack()
1558 // Retrace how far back it was in the sender's branch
1561 BOOST_FOREACH(const uint256& hash, vHave)
1563 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1564 if (mi != mapBlockIndex.end())
1566 CBlockIndex* pindex = (*mi).second;
1567 if (pindex->IsInMainChain())
1577 CBlockIndex* GetBlockIndex()
1579 // Find the first block the caller has in the main chain
1580 BOOST_FOREACH(const uint256& hash, vHave)
1582 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1583 if (mi != mapBlockIndex.end())
1585 CBlockIndex* pindex = (*mi).second;
1586 if (pindex->IsInMainChain())
1590 return pindexGenesisBlock;
1593 uint256 GetBlockHash()
1595 // Find the first block the caller has in the main chain
1596 BOOST_FOREACH(const uint256& hash, vHave)
1598 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1599 if (mi != mapBlockIndex.end())
1601 CBlockIndex* pindex = (*mi).second;
1602 if (pindex->IsInMainChain())
1606 return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1611 CBlockIndex* pindex = GetBlockIndex();
1614 return pindex->nHeight;
1628 mutable CCriticalSection cs;
1629 std::map<uint256, CTransaction> mapTx;
1630 std::map<COutPoint, CInPoint> mapNextTx;
1632 bool accept(CTxDB& txdb, CTransaction &tx,
1633 bool fCheckInputs, bool* pfMissingInputs);
1634 bool addUnchecked(const uint256& hash, CTransaction &tx);
1635 bool remove(CTransaction &tx);
1637 void queryHashes(std::vector<uint256>& vtxid);
1642 return mapTx.size();
1645 bool exists(uint256 hash)
1647 return (mapTx.count(hash) != 0);
1650 CTransaction& lookup(uint256 hash)
1656 extern CTxMemPool mempool;