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;
35 static const unsigned int nStakeMinAge = 60 * 60 * 24 * 30; // 30 days as zero time weight
36 static const unsigned int nStakeMaxAge = 60 * 60 * 24 * 90; // 90 days as full weight
37 static const unsigned int nStakeTargetSpacing = 10 * 60; // 10-minute stakes spacing
38 static const unsigned int nModifierInterval = 6 * 60 * 60; // time to elapse before new modifier is computed
40 static const int nCoinbaseMaturity = 500;
43 static const unsigned int MAX_BLOCK_SIZE = 1000000;
44 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
45 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
46 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
47 static const unsigned int MAX_INV_SZ = 50000;
49 static const int64 MIN_TX_FEE = CENT/10;
50 static const int64 MIN_RELAY_TX_FEE = CENT/50;
52 static const int64 MAX_MONEY = 2000000000 * COIN;
53 static const int64 MAX_MINT_PROOF_OF_WORK = 100 * COIN;
54 static const int64 MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
55 static const int64 MIN_TXOUT_AMOUNT = CENT/100;
57 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
58 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
59 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
60 // Maximum number of script-checking threads allowed
61 static const int MAX_SCRIPTCHECK_THREADS = 16;
64 static const int fHaveUPnP = true;
66 static const int fHaveUPnP = false;
69 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
70 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
72 inline int64 PastDrift(int64 nTime) { return nTime - 2 * 60 * 60; } // up to 2 hours from the past
73 inline int64 FutureDrift(int64 nTime) { return nTime + 2 * 60 * 60; } // up to 2 hours from the future
75 extern CScript COINBASE_FLAGS;
76 extern CCriticalSection cs_main;
77 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
78 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
79 extern CBlockIndex* pindexGenesisBlock;
80 extern unsigned int nNodeLifespan;
81 extern int nBestHeight;
82 extern uint256 nBestChainTrust;
83 extern uint256 nBestInvalidTrust;
84 extern uint256 hashBestChain;
85 extern CBlockIndex* pindexBest;
86 extern unsigned int nTransactionsUpdated;
87 extern uint64 nLastBlockTx;
88 extern uint64 nLastBlockSize;
89 extern int64 nLastCoinStakeSearchInterval;
90 extern const std::string strMessageMagic;
91 extern int64 nTimeBestReceived;
92 extern CCriticalSection cs_setpwalletRegistered;
93 extern std::set<CWallet*> setpwalletRegistered;
94 extern unsigned char pchMessageStart[4];
95 extern std::map<uint256, CBlock*> mapOrphanBlocks;
98 extern int64 nTransactionFee;
99 extern int64 nMinimumInputValue;
100 extern bool fUseFastIndex;
101 extern unsigned int nDerivationMethodIndex;
102 extern int nScriptCheckThreads;
104 // Minimum disk space required - used in CheckDiskSpace()
105 static const uint64 nMinDiskSpace = 52428800;
112 void RegisterWallet(CWallet* pwalletIn);
113 void UnregisterWallet(CWallet* pwalletIn);
114 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
115 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
116 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
117 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
118 FILE* AppendBlockFile(unsigned int& nFileRet);
119 bool LoadBlockIndex(bool fAllowNew=true);
120 void PrintBlockTree();
121 CBlockIndex* FindBlockByHeight(int nHeight);
122 bool ProcessMessages(CNode* pfrom);
123 bool SendMessages(CNode* pto, bool fSendTrickle);
124 bool LoadExternalBlockFile(FILE* fileIn);
126 // Run an instance of the script checking thread
127 void ThreadScriptCheck(void* parg);
128 // Stop the script checking threads
129 void ThreadScriptCheckQuit();
131 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
132 unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, bool fProofOfStake);
133 int64 GetProofOfWorkReward(unsigned int nBits, int64 nFees=0);
134 int64 GetProofOfStakeReward(int64 nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly=false);
135 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
136 unsigned int ComputeMinStake(unsigned int nBase, int64 nTime, unsigned int nBlockTime);
137 int GetNumBlocksOfPeers();
138 bool IsInitialBlockDownload();
139 std::string GetWarnings(std::string strFor);
140 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
141 uint256 WantedByOrphan(const CBlock* pblockOrphan);
142 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
143 void StakeMiner(CWallet *pwallet);
144 void ResendWalletTransactions();
146 bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType);
154 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
156 /** Position on disk for a particular transaction. */
161 unsigned int nBlockPos;
169 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
172 nBlockPos = nBlockPosIn;
176 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
177 void SetNull() { nFile = (unsigned int) -1; nBlockPos = 0; nTxPos = 0; }
178 bool IsNull() const { return (nFile == (unsigned int) -1); }
180 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
182 return (a.nFile == b.nFile &&
183 a.nBlockPos == b.nBlockPos &&
184 a.nTxPos == b.nTxPos);
187 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
193 std::string ToString() const
198 return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
203 printf("%s", ToString().c_str());
209 /** An inpoint - a combination of a transaction and an index n into its vin */
216 CInPoint() { SetNull(); }
217 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
218 void SetNull() { ptx = NULL; n = (unsigned int) -1; }
219 bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
224 /** An outpoint - a combination of a transaction hash and an index n into its vout */
231 COutPoint() { SetNull(); }
232 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
233 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
234 void SetNull() { hash = 0; n = (unsigned int) -1; }
235 bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
237 friend bool operator<(const COutPoint& a, const COutPoint& b)
239 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
242 friend bool operator==(const COutPoint& a, const COutPoint& b)
244 return (a.hash == b.hash && a.n == b.n);
247 friend bool operator!=(const COutPoint& a, const COutPoint& b)
252 std::string ToString() const
254 return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
259 printf("%s\n", ToString().c_str());
266 /** An input of a transaction. It contains the location of the previous
267 * transaction's output that it claims and a signature that matches the
268 * output's public key.
275 unsigned int nSequence;
279 nSequence = std::numeric_limits<unsigned int>::max();
282 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
285 scriptSig = scriptSigIn;
286 nSequence = nSequenceIn;
289 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
291 prevout = COutPoint(hashPrevTx, nOut);
292 scriptSig = scriptSigIn;
293 nSequence = nSequenceIn;
299 READWRITE(scriptSig);
300 READWRITE(nSequence);
305 return (nSequence == std::numeric_limits<unsigned int>::max());
308 friend bool operator==(const CTxIn& a, const CTxIn& b)
310 return (a.prevout == b.prevout &&
311 a.scriptSig == b.scriptSig &&
312 a.nSequence == b.nSequence);
315 friend bool operator!=(const CTxIn& a, const CTxIn& b)
320 std::string ToStringShort() const
322 return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
325 std::string ToString() const
329 str += prevout.ToString();
330 if (prevout.IsNull())
331 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
333 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
334 if (nSequence != std::numeric_limits<unsigned int>::max())
335 str += strprintf(", nSequence=%u", nSequence);
342 printf("%s\n", ToString().c_str());
349 /** An output of a transaction. It contains the public key that the next input
350 * must be able to sign with to claim it.
356 CScript scriptPubKey;
363 CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
366 scriptPubKey = scriptPubKeyIn;
372 READWRITE(scriptPubKey);
378 scriptPubKey.clear();
383 return (nValue == -1);
389 scriptPubKey.clear();
394 return (nValue == 0 && scriptPubKey.empty());
397 uint256 GetHash() const
399 return SerializeHash(*this);
402 friend bool operator==(const CTxOut& a, const CTxOut& b)
404 return (a.nValue == b.nValue &&
405 a.scriptPubKey == b.scriptPubKey);
408 friend bool operator!=(const CTxOut& a, const CTxOut& b)
413 std::string ToStringShort() const
415 return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
418 std::string ToString() const
420 if (IsEmpty()) return "CTxOut(empty)";
421 if (scriptPubKey.size() < 6)
422 return "CTxOut(error)";
423 return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
428 printf("%s\n", ToString().c_str());
442 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
444 /** The basic transaction that is broadcasted on the network and contained in
445 * blocks. A transaction can contain multiple inputs and outputs.
450 static const int CURRENT_VERSION=1;
453 std::vector<CTxIn> vin;
454 std::vector<CTxOut> vout;
455 unsigned int nLockTime;
457 // Denial-of-service detection:
459 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
468 READWRITE(this->nVersion);
469 nVersion = this->nVersion;
473 READWRITE(nLockTime);
478 nVersion = CTransaction::CURRENT_VERSION;
479 nTime = GetAdjustedTime();
483 nDoS = 0; // Denial-of-service prevention
488 return (vin.empty() && vout.empty());
491 uint256 GetHash() const
493 return SerializeHash(*this);
496 bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
498 // Time based nLockTime implemented in 0.1.6
501 if (nBlockHeight == 0)
502 nBlockHeight = nBestHeight;
504 nBlockTime = GetAdjustedTime();
505 if ((int64)nLockTime < ((int64)nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
507 BOOST_FOREACH(const CTxIn& txin, vin)
513 bool IsNewerThan(const CTransaction& old) const
515 if (vin.size() != old.vin.size())
517 for (unsigned int i = 0; i < vin.size(); i++)
518 if (vin[i].prevout != old.vin[i].prevout)
522 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
523 for (unsigned int i = 0; i < vin.size(); i++)
525 if (vin[i].nSequence != old.vin[i].nSequence)
527 if (vin[i].nSequence <= nLowest)
530 nLowest = vin[i].nSequence;
532 if (old.vin[i].nSequence < nLowest)
535 nLowest = old.vin[i].nSequence;
542 bool IsCoinBase() const
544 return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
547 bool IsCoinStake() const
549 // ppcoin: the coin stake transaction is marked with the first output empty
550 return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
553 /** Check for standard transaction types
554 @return True if all outputs (scriptPubKeys) use only standard transaction forms
556 bool IsStandard() const;
558 /** Check for standard transaction types
559 @param[in] mapInputs Map of previous transactions that have outputs we're spending
560 @return True if all inputs (scriptSigs) use only standard transaction forms
561 @see CTransaction::FetchInputs
563 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
565 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
566 @return number of sigops this transaction's outputs will produce when spent
567 @see CTransaction::FetchInputs
569 unsigned int GetLegacySigOpCount() const;
571 /** Count ECDSA signature operations in pay-to-script-hash inputs.
573 @param[in] mapInputs Map of previous transactions that have outputs we're spending
574 @return maximum number of sigops required to validate this transaction's inputs
575 @see CTransaction::FetchInputs
577 unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
579 /** Amount of bitcoins spent by this transaction.
580 @return sum of all outputs (note: does not include fees)
582 int64 GetValueOut() const
585 BOOST_FOREACH(const CTxOut& txout, vout)
587 nValueOut += txout.nValue;
588 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
589 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
594 /** Amount of bitcoins coming in to this transaction
595 Note that lightweight clients may not know anything besides the hash of previous transactions,
596 so may not be able to calculate this.
598 @param[in] mapInputs Map of previous transactions that have outputs we're spending
599 @return Sum of value of all inputs (scriptSigs)
600 @see CTransaction::FetchInputs
602 int64 GetValueIn(const MapPrevTx& mapInputs) const;
604 static bool AllowFree(double dPriority)
606 // Large (in bytes) low-priority (new, small-coin) transactions
608 return dPriority > COIN * 144 / 250;
611 int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK, unsigned int nBytes = 0) const;
613 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
615 CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
617 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
620 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
621 return error("CTransaction::ReadFromDisk() : fseek failed");
626 catch (std::exception &e) {
627 return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
630 // Return file pointer
633 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
634 return error("CTransaction::ReadFromDisk() : second fseek failed");
635 *pfileRet = filein.release();
640 friend bool operator==(const CTransaction& a, const CTransaction& b)
642 return (a.nVersion == b.nVersion &&
643 a.nTime == b.nTime &&
646 a.nLockTime == b.nLockTime);
649 friend bool operator!=(const CTransaction& a, const CTransaction& b)
654 std::string ToStringShort() const
657 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
661 std::string ToString() const
664 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
665 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%"PRIszu", vout.size=%"PRIszu", nLockTime=%d)\n",
666 GetHash().ToString().substr(0,10).c_str(),
672 for (unsigned int i = 0; i < vin.size(); i++)
673 str += " " + vin[i].ToString() + "\n";
674 for (unsigned int i = 0; i < vout.size(); i++)
675 str += " " + vout[i].ToString() + "\n";
681 printf("%s", ToString().c_str());
685 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
686 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
687 bool ReadFromDisk(COutPoint prevout);
688 bool DisconnectInputs(CTxDB& txdb);
690 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
692 @param[in] txdb Transaction database
693 @param[in] mapTestPool List of pending changes to the transaction index database
694 @param[in] fBlock True if being called to add a new best-block to the chain
695 @param[in] fMiner True if being called by CreateNewBlock
696 @param[out] inputsRet Pointers to this transaction's inputs
697 @param[out] fInvalid returns true if transaction is invalid
698 @return Returns true if all inputs are in txdb or mapTestPool
700 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
701 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
703 /** Sanity check previous transactions, then, if all checks succeed,
704 mark them as spent by this transaction.
706 @param[in] inputs Previous transactions (from FetchInputs)
707 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
708 @param[in] posThisTx Position of this transaction on disk
709 @param[in] pindexBlock
710 @param[in] fBlock true if called from ConnectBlock
711 @param[in] fMiner true if called from CreateNewBlock
712 @param[in] fScriptChecks enable scripts validation?
713 @param[in] flags STRICT_FLAGS script validation flags
714 @param[in] pvChecks NULL If pvChecks is not NULL, script checks are pushed onto it instead of being performed inline.
715 @return Returns true if all checks succeed
717 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs, std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx, const CBlockIndex* pindexBlock,
718 bool fBlock, bool fMiner, bool fScriptChecks=true,
719 unsigned int flags=STRICT_FLAGS, std::vector<CScriptCheck> *pvChecks = NULL);
720 bool ClientConnectInputs();
721 bool CheckTransaction() const;
722 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
723 bool GetCoinAge(CTxDB& txdb, uint64& nCoinAge) const; // ppcoin: get transaction coin age
726 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
729 /** Closure representing one script verification
730 * Note that this stores references to the spending transaction */
734 CScript scriptPubKey;
735 const CTransaction *ptxTo;
742 CScriptCheck(const CTransaction& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, int nHashTypeIn) :
743 scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey),
744 ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), nHashType(nHashTypeIn) { }
746 bool operator()() const;
748 void swap(CScriptCheck &check) {
749 scriptPubKey.swap(check.scriptPubKey);
750 std::swap(ptxTo, check.ptxTo);
751 std::swap(nIn, check.nIn);
752 std::swap(nFlags, check.nFlags);
753 std::swap(nHashType, check.nHashType);
760 /** A transaction with a merkle branch linking it to the block chain. */
761 class CMerkleTx : public CTransaction
765 std::vector<uint256> vMerkleBranch;
769 mutable bool fMerkleVerified;
777 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
786 fMerkleVerified = false;
792 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
793 nVersion = this->nVersion;
794 READWRITE(hashBlock);
795 READWRITE(vMerkleBranch);
800 int SetMerkleBranch(const CBlock* pblock=NULL);
801 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
802 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
803 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
804 int GetBlocksToMaturity() const;
805 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
806 bool AcceptToMemoryPool();
812 /** A txdb record that contains the disk location of a transaction and the
813 * locations of transactions that spend its outputs. vSpent is really only
814 * used as a flag, but having the location is very helpful for debugging.
820 std::vector<CDiskTxPos> vSpent;
827 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
830 vSpent.resize(nOutputs);
835 if (!(nType & SER_GETHASH))
852 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
854 return (a.pos == b.pos &&
855 a.vSpent == b.vSpent);
858 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
862 int GetDepthInMainChain() const;
870 /** Nodes collect new transactions into a block, hash them into a hash tree,
871 * and scan through nonce values to make the block's hash satisfy proof-of-work
872 * requirements. When they solve the proof-of-work, they broadcast the block
873 * to everyone and the block is added to the block chain. The first transaction
874 * in the block is a special one that creates a new coin owned by the creator
877 * Blocks are appended to blk0001.dat files on disk. Their location on disk
878 * is indexed by CBlockIndex objects in memory.
884 static const int CURRENT_VERSION=6;
886 uint256 hashPrevBlock;
887 uint256 hashMerkleRoot;
893 std::vector<CTransaction> vtx;
895 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
896 std::vector<unsigned char> vchBlockSig;
899 mutable std::vector<uint256> vMerkleTree;
901 // Denial-of-service detection:
903 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
912 READWRITE(this->nVersion);
913 nVersion = this->nVersion;
914 READWRITE(hashPrevBlock);
915 READWRITE(hashMerkleRoot);
920 // ConnectBlock depends on vtx following header to generate CDiskTxPos
921 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
924 READWRITE(vchBlockSig);
928 const_cast<CBlock*>(this)->vtx.clear();
929 const_cast<CBlock*>(this)->vchBlockSig.clear();
935 nVersion = CBlock::CURRENT_VERSION;
952 uint256 GetHash() const
954 return scrypt_blockhash(CVOIDBEGIN(nVersion));
957 int64 GetBlockTime() const
962 void UpdateTime(const CBlockIndex* pindexPrev);
964 // ppcoin: entropy bit for stake modifier if chosen by modifier
965 unsigned int GetStakeEntropyBit(unsigned int nTime) const
967 // Protocol switch to support p2pool at novacoin block #9689
968 if (nTime >= ENTROPY_SWITCH_TIME || fTestNet)
970 // Take last bit of block hash as entropy bit
971 unsigned int nEntropyBit = ((GetHash().Get64()) & 1ULL);
972 //unsigned int nEntropyBit = 1;
973 if (fDebug && GetBoolArg("-printstakemodifier"))
974 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
977 // Before novacoin block #9689 - old protocol
978 uint160 hashSig = Hash160(vchBlockSig);
979 if (fDebug && GetBoolArg("-printstakemodifier"))
980 printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
981 hashSig >>= 159; // take the first bit of the hash
982 if (fDebug && GetBoolArg("-printstakemodifier"))
983 printf(" entropybit=%"PRI64d"\n", hashSig.Get64());
984 return hashSig.Get64();
987 // ppcoin: two types of block: proof-of-work or proof-of-stake
988 bool IsProofOfStake() const
990 return (vtx.size() > 1 && vtx[1].IsCoinStake());
993 bool IsProofOfWork() const
995 return !IsProofOfStake();
998 std::pair<COutPoint, unsigned int> GetProofOfStake() const
1000 return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
1003 // ppcoin: get max transaction timestamp
1004 int64 GetMaxTransactionTime() const
1006 int64 maxTransactionTime = 0;
1007 BOOST_FOREACH(const CTransaction& tx, vtx)
1008 maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
1009 return maxTransactionTime;
1012 uint256 BuildMerkleTree() const
1014 vMerkleTree.clear();
1015 BOOST_FOREACH(const CTransaction& tx, vtx)
1016 vMerkleTree.push_back(tx.GetHash());
1018 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1020 for (int i = 0; i < nSize; i += 2)
1022 int i2 = std::min(i+1, nSize-1);
1023 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
1024 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
1028 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
1031 std::vector<uint256> GetMerkleBranch(int nIndex) const
1033 if (vMerkleTree.empty())
1035 std::vector<uint256> vMerkleBranch;
1037 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1039 int i = std::min(nIndex^1, nSize-1);
1040 vMerkleBranch.push_back(vMerkleTree[j+i]);
1044 return vMerkleBranch;
1047 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1051 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1054 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1056 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1063 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1065 // Open history file to append
1066 CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1068 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1070 // Write index header
1071 unsigned int nSize = fileout.GetSerializeSize(*this);
1072 fileout << FLATDATA(pchMessageStart) << nSize;
1075 long fileOutPos = ftell(fileout);
1077 return error("CBlock::WriteToDisk() : ftell failed");
1078 nBlockPosRet = fileOutPos;
1081 // Flush stdio buffers and commit to disk before returning
1083 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1084 FileCommit(fileout);
1089 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1093 // Open history file to read
1094 CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1096 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1097 if (!fReadTransactions)
1098 filein.nType |= SER_BLOCKHEADERONLY;
1104 catch (std::exception &e) {
1105 return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
1109 if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1110 return error("CBlock::ReadFromDisk() : errors in block header");
1119 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu", vchBlockSig=%s)\n",
1120 GetHash().ToString().c_str(),
1122 hashPrevBlock.ToString().c_str(),
1123 hashMerkleRoot.ToString().c_str(),
1124 nTime, nBits, nNonce,
1126 HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1127 for (unsigned int i = 0; i < vtx.size(); i++)
1132 printf(" vMerkleTree: ");
1133 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1134 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1139 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1140 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1141 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1142 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1143 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1144 bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1146 bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1147 bool SignBlock(CWallet& keystore);
1148 bool CheckBlockSignature(bool fProofOfStake) const;
1151 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1159 /** The block chain is a tree shaped structure starting with the
1160 * genesis block at the root, with each block potentially having multiple
1161 * candidates to be the next block. pprev and pnext link a path through the
1162 * main/longest chain. A blockindex may have multiple pprev pointing back
1163 * to it, but pnext will only point forward to the longest branch, or will
1164 * be null if the block is not part of the longest chain.
1169 const uint256* phashBlock;
1173 unsigned int nBlockPos;
1174 uint256 nChainTrust; // ppcoin: trust score of block chain
1180 unsigned int nFlags; // ppcoin: block index flags
1183 BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1184 BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
1185 BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1188 uint64 nStakeModifier; // hash modifier for proof-of-stake
1189 unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1191 // proof-of-stake specific fields
1192 COutPoint prevoutStake;
1193 unsigned int nStakeTime;
1194 uint256 hashProofOfStake;
1198 uint256 hashMerkleRoot;
1201 unsigned int nNonce;
1216 nStakeModifierChecksum = 0;
1217 hashProofOfStake = 0;
1218 prevoutStake.SetNull();
1228 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1234 nBlockPos = nBlockPosIn;
1241 nStakeModifierChecksum = 0;
1242 hashProofOfStake = 0;
1243 if (block.IsProofOfStake())
1246 prevoutStake = block.vtx[1].vin[0].prevout;
1247 nStakeTime = block.vtx[1].nTime;
1251 prevoutStake.SetNull();
1255 nVersion = block.nVersion;
1256 hashMerkleRoot = block.hashMerkleRoot;
1257 nTime = block.nTime;
1258 nBits = block.nBits;
1259 nNonce = block.nNonce;
1262 CBlock GetBlockHeader() const
1265 block.nVersion = nVersion;
1267 block.hashPrevBlock = pprev->GetBlockHash();
1268 block.hashMerkleRoot = hashMerkleRoot;
1269 block.nTime = nTime;
1270 block.nBits = nBits;
1271 block.nNonce = nNonce;
1275 uint256 GetBlockHash() const
1280 int64 GetBlockTime() const
1282 return (int64)nTime;
1285 uint256 GetBlockTrust() const;
1287 bool IsInMainChain() const
1289 return (pnext || this == pindexBest);
1292 bool CheckIndex() const
1297 enum { nMedianTimeSpan=11 };
1299 int64 GetMedianTimePast() const
1301 int64 pmedian[nMedianTimeSpan];
1302 int64* pbegin = &pmedian[nMedianTimeSpan];
1303 int64* pend = &pmedian[nMedianTimeSpan];
1305 const CBlockIndex* pindex = this;
1306 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1307 *(--pbegin) = pindex->GetBlockTime();
1309 std::sort(pbegin, pend);
1310 return pbegin[(pend - pbegin)/2];
1313 int64 GetMedianTime() const
1315 const CBlockIndex* pindex = this;
1316 for (int i = 0; i < nMedianTimeSpan/2; i++)
1319 return GetBlockTime();
1320 pindex = pindex->pnext;
1322 return pindex->GetMedianTimePast();
1326 * Returns true if there are nRequired or more blocks of minVersion or above
1327 * in the last nToCheck blocks, starting at pstart and going backwards.
1329 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1330 unsigned int nRequired, unsigned int nToCheck);
1333 bool IsProofOfWork() const
1335 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1338 bool IsProofOfStake() const
1340 return (nFlags & BLOCK_PROOF_OF_STAKE);
1343 void SetProofOfStake()
1345 nFlags |= BLOCK_PROOF_OF_STAKE;
1348 unsigned int GetStakeEntropyBit() const
1350 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1353 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1355 if (nEntropyBit > 1)
1357 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1361 bool GeneratedStakeModifier() const
1363 return (nFlags & BLOCK_STAKE_MODIFIER);
1366 void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1368 nStakeModifier = nModifier;
1369 if (fGeneratedStakeModifier)
1370 nFlags |= BLOCK_STAKE_MODIFIER;
1373 std::string ToString() const
1375 return strprintf("CBlockIndex(nprev=%p, pnext=%p, nFile=%u, nBlockPos=%-6d 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)",
1376 pprev, pnext, nFile, nBlockPos, nHeight,
1377 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1378 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1379 nStakeModifier, nStakeModifierChecksum,
1380 hashProofOfStake.ToString().c_str(),
1381 prevoutStake.ToString().c_str(), nStakeTime,
1382 hashMerkleRoot.ToString().c_str(),
1383 GetBlockHash().ToString().c_str());
1388 printf("%s\n", ToString().c_str());
1394 /** Used to marshal pointers into hashes for db storage. */
1395 class CDiskBlockIndex : public CBlockIndex
1411 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1413 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1414 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1419 if (!(nType & SER_GETHASH))
1420 READWRITE(nVersion);
1422 READWRITE(hashNext);
1424 READWRITE(nBlockPos);
1427 READWRITE(nMoneySupply);
1429 READWRITE(nStakeModifier);
1430 if (IsProofOfStake())
1432 READWRITE(prevoutStake);
1433 READWRITE(nStakeTime);
1434 READWRITE(hashProofOfStake);
1438 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1439 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1440 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1444 READWRITE(this->nVersion);
1445 READWRITE(hashPrev);
1446 READWRITE(hashMerkleRoot);
1450 READWRITE(blockHash);
1453 uint256 GetBlockHash() const
1455 if (fUseFastIndex && (nTime < GetAdjustedTime() - 24 * 60 * 60) && blockHash != 0)
1459 block.nVersion = nVersion;
1460 block.hashPrevBlock = hashPrev;
1461 block.hashMerkleRoot = hashMerkleRoot;
1462 block.nTime = nTime;
1463 block.nBits = nBits;
1464 block.nNonce = nNonce;
1466 const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1471 std::string ToString() const
1473 std::string str = "CDiskBlockIndex(";
1474 str += CBlockIndex::ToString();
1475 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1476 GetBlockHash().ToString().c_str(),
1477 hashPrev.ToString().c_str(),
1478 hashNext.ToString().c_str());
1484 printf("%s\n", ToString().c_str());
1495 /** Describes a place in the block chain to another node such that if the
1496 * other node doesn't have the same branch, it can find a recent common trunk.
1497 * The further back it is, the further before the fork it may be.
1502 std::vector<uint256> vHave;
1509 explicit CBlockLocator(const CBlockIndex* pindex)
1514 explicit CBlockLocator(uint256 hashBlock)
1516 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1517 if (mi != mapBlockIndex.end())
1521 CBlockLocator(const std::vector<uint256>& vHaveIn)
1528 if (!(nType & SER_GETHASH))
1529 READWRITE(nVersion);
1540 return vHave.empty();
1543 void Set(const CBlockIndex* pindex)
1549 vHave.push_back(pindex->GetBlockHash());
1551 // Exponentially larger steps back
1552 for (int i = 0; pindex && i < nStep; i++)
1553 pindex = pindex->pprev;
1554 if (vHave.size() > 10)
1557 vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1560 int GetDistanceBack()
1562 // Retrace how far back it was in the sender's branch
1565 BOOST_FOREACH(const uint256& hash, vHave)
1567 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1568 if (mi != mapBlockIndex.end())
1570 CBlockIndex* pindex = (*mi).second;
1571 if (pindex->IsInMainChain())
1581 CBlockIndex* GetBlockIndex()
1583 // Find the first block the caller has in the main chain
1584 BOOST_FOREACH(const uint256& hash, vHave)
1586 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1587 if (mi != mapBlockIndex.end())
1589 CBlockIndex* pindex = (*mi).second;
1590 if (pindex->IsInMainChain())
1594 return pindexGenesisBlock;
1597 uint256 GetBlockHash()
1599 // Find the first block the caller has in the main chain
1600 BOOST_FOREACH(const uint256& hash, vHave)
1602 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1603 if (mi != mapBlockIndex.end())
1605 CBlockIndex* pindex = (*mi).second;
1606 if (pindex->IsInMainChain())
1610 return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1615 CBlockIndex* pindex = GetBlockIndex();
1618 return pindex->nHeight;
1632 mutable CCriticalSection cs;
1633 std::map<uint256, CTransaction> mapTx;
1634 std::map<COutPoint, CInPoint> mapNextTx;
1636 bool accept(CTxDB& txdb, CTransaction &tx,
1637 bool fCheckInputs, bool* pfMissingInputs);
1638 bool addUnchecked(const uint256& hash, CTransaction &tx);
1639 bool remove(CTransaction &tx);
1641 void queryHashes(std::vector<uint256>& vtxid);
1643 unsigned long size()
1646 return mapTx.size();
1649 bool exists(uint256 hash)
1651 return (mapTx.count(hash) != 0);
1654 CTransaction& lookup(uint256 hash)
1660 extern CTxMemPool mempool;