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 MIN_TX_FEE = CENT/10;
43 static const int64 MIN_RELAY_TX_FEE = CENT/50;
45 static const int64 MAX_MONEY = 2000000000 * COIN;
46 static const int64 MAX_MINT_PROOF_OF_WORK = 100 * COIN;
47 static const int64 MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
48 static const int64 MIN_TXOUT_AMOUNT = CENT/100;
50 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
51 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
52 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
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 PastDrift(int64 nTime) { return nTime - 2 * 60 * 60; } // up to 2 hours from the past
66 inline int64 FutureDrift(int64 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 nLastBlockTx;
83 extern uint64 nLastBlockSize;
84 extern int64 nLastCoinStakeSearchInterval;
85 extern const std::string strMessageMagic;
86 extern int64 nTimeBestReceived;
87 extern CCriticalSection cs_setpwalletRegistered;
88 extern std::set<CWallet*> setpwalletRegistered;
89 extern unsigned char pchMessageStart[4];
90 extern std::map<uint256, CBlock*> mapOrphanBlocks;
93 extern int64 nTransactionFee;
94 extern int64 nMinimumInputValue;
95 extern bool fUseFastIndex;
96 extern unsigned int nDerivationMethodIndex;
97 extern int nScriptCheckThreads;
99 // Minimum disk space required - used in CheckDiskSpace()
100 static const uint64 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 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 GetProofOfWorkReward(unsigned int nBits, int64 nFees=0);
129 int64 GetProofOfStakeReward(int64 nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly=false);
130 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
131 unsigned int ComputeMinStake(unsigned int nBase, int64 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. */
156 unsigned int nBlockPos;
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.
270 unsigned int nSequence;
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 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;
450 unsigned int nLockTime;
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 = 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 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)nLockTime < ((int64)nLockTime < LOCKTIME_THRESHOLD ? (int64)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 GetValueOut() const
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 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 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) {
622 return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
625 // Return file pointer
628 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
629 return error("CTransaction::ReadFromDisk() : second fseek failed");
630 *pfileRet = filein.release();
635 friend bool operator==(const CTransaction& a, const CTransaction& b)
637 return (a.nVersion == b.nVersion &&
638 a.nTime == b.nTime &&
641 a.nLockTime == b.nLockTime);
644 friend bool operator!=(const CTransaction& a, const CTransaction& b)
649 std::string ToStringShort() const
652 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
656 std::string ToString() const
659 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
660 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%" PRIszu ", vout.size=%" PRIszu ", nLockTime=%d)\n",
661 GetHash().ToString().substr(0,10).c_str(),
667 for (unsigned int i = 0; i < vin.size(); i++)
668 str += " " + vin[i].ToString() + "\n";
669 for (unsigned int i = 0; i < vout.size(); i++)
670 str += " " + vout[i].ToString() + "\n";
676 printf("%s", ToString().c_str());
680 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
681 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
682 bool ReadFromDisk(COutPoint prevout);
683 bool DisconnectInputs(CTxDB& txdb);
685 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
687 @param[in] txdb Transaction database
688 @param[in] mapTestPool List of pending changes to the transaction index database
689 @param[in] fBlock True if being called to add a new best-block to the chain
690 @param[in] fMiner True if being called by CreateNewBlock
691 @param[out] inputsRet Pointers to this transaction's inputs
692 @param[out] fInvalid returns true if transaction is invalid
693 @return Returns true if all inputs are in txdb or mapTestPool
695 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
696 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
698 /** Sanity check previous transactions, then, if all checks succeed,
699 mark them as spent by this transaction.
701 @param[in] inputs Previous transactions (from FetchInputs)
702 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
703 @param[in] posThisTx Position of this transaction on disk
704 @param[in] pindexBlock
705 @param[in] fBlock true if called from ConnectBlock
706 @param[in] fMiner true if called from CreateNewBlock
707 @param[in] fScriptChecks enable scripts validation?
708 @param[in] flags STRICT_FLAGS script validation flags
709 @param[in] pvChecks NULL If pvChecks is not NULL, script checks are pushed onto it instead of being performed inline.
710 @return Returns true if all checks succeed
712 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs, std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx, const CBlockIndex* pindexBlock,
713 bool fBlock, bool fMiner, bool fScriptChecks=true,
714 unsigned int flags=STRICT_FLAGS, std::vector<CScriptCheck> *pvChecks = NULL);
715 bool ClientConnectInputs();
716 bool CheckTransaction() const;
717 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
718 bool GetCoinAge(CTxDB& txdb, uint64& nCoinAge) const; // ppcoin: get transaction coin age
721 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
724 /** Closure representing one script verification
725 * Note that this stores references to the spending transaction */
729 CScript scriptPubKey;
730 const CTransaction *ptxTo;
737 CScriptCheck(const CTransaction& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, int nHashTypeIn) :
738 scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey),
739 ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), nHashType(nHashTypeIn) { }
741 bool operator()() const;
743 void swap(CScriptCheck &check) {
744 scriptPubKey.swap(check.scriptPubKey);
745 std::swap(ptxTo, check.ptxTo);
746 std::swap(nIn, check.nIn);
747 std::swap(nFlags, check.nFlags);
748 std::swap(nHashType, check.nHashType);
755 /** A transaction with a merkle branch linking it to the block chain. */
756 class CMerkleTx : public CTransaction
760 std::vector<uint256> vMerkleBranch;
764 mutable bool fMerkleVerified;
772 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
781 fMerkleVerified = false;
787 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
788 nVersion = this->nVersion;
789 READWRITE(hashBlock);
790 READWRITE(vMerkleBranch);
795 int SetMerkleBranch(const CBlock* pblock=NULL);
796 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
797 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
798 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
799 int GetBlocksToMaturity() const;
800 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
801 bool AcceptToMemoryPool();
807 /** A txdb record that contains the disk location of a transaction and the
808 * locations of transactions that spend its outputs. vSpent is really only
809 * used as a flag, but having the location is very helpful for debugging.
815 std::vector<CDiskTxPos> vSpent;
822 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
825 vSpent.resize(nOutputs);
830 if (!(nType & SER_GETHASH))
847 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
849 return (a.pos == b.pos &&
850 a.vSpent == b.vSpent);
853 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
857 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(CVOIDBEGIN(nVersion));
952 int64 GetBlockTime() const
957 void UpdateTime(const CBlockIndex* pindexPrev);
959 // ppcoin: entropy bit for stake modifier if chosen by modifier
960 unsigned int GetStakeEntropyBit(unsigned int nTime) const
962 // Protocol switch to support p2pool at novacoin block #9689
963 if (nTime >= ENTROPY_SWITCH_TIME || fTestNet)
965 // Take last bit of block hash as entropy bit
966 unsigned int nEntropyBit = ((GetHash().Get64()) & 1ULL);
967 //unsigned int nEntropyBit = 1;
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=%" PRI64d "\n", hashSig.Get64());
979 return 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 GetMaxTransactionTime() const
1001 int64 maxTransactionTime = 0;
1002 BOOST_FOREACH(const CTransaction& tx, vtx)
1003 maxTransactionTime = std::max(maxTransactionTime, (int64)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 = 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 = 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) {
1100 return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
1104 if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1105 return error("CBlock::ReadFromDisk() : errors in block header");
1114 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%" PRIszu ", vchBlockSig=%s)\n",
1115 GetHash().ToString().c_str(),
1117 hashPrevBlock.ToString().c_str(),
1118 hashMerkleRoot.ToString().c_str(),
1119 nTime, nBits, nNonce,
1121 HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1122 for (unsigned int i = 0; i < vtx.size(); i++)
1127 printf(" vMerkleTree: ");
1128 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1129 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1134 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1135 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1136 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1137 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1138 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1139 bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1141 bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1142 bool SignBlock(CWallet& keystore);
1143 bool CheckBlockSignature(bool fProofOfStake) 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;
1168 unsigned int nBlockPos;
1169 uint256 nChainTrust; // ppcoin: trust score of block chain
1175 unsigned int 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 nStakeModifier; // hash modifier for proof-of-stake
1184 unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1186 // proof-of-stake specific fields
1187 COutPoint prevoutStake;
1188 unsigned int nStakeTime;
1189 uint256 hashProofOfStake;
1193 uint256 hashMerkleRoot;
1196 unsigned int nNonce;
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 GetBlockTime() const
1277 return (int64)nTime;
1280 uint256 GetBlockTrust() const;
1282 bool IsInMainChain() const
1284 return (pnext || this == pindexBest);
1287 bool CheckIndex() const
1292 enum { nMedianTimeSpan=11 };
1294 int64 GetMedianTimePast() const
1296 int64 pmedian[nMedianTimeSpan];
1297 int64* pbegin = &pmedian[nMedianTimeSpan];
1298 int64* 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 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);
1361 void SetStakeModifier(uint64 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" PRI64x ", nStakeModifierChecksum=%08x, hashProofOfStake=%s, prevoutStake=(%s), nStakeTime=%d merkle=%s, hashBlock=%s)",
1371 pprev, 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() - 24 * 60 * 60) && 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);
1638 unsigned long size()
1641 return mapTx.size();
1644 bool exists(uint256 hash)
1646 return (mapTx.count(hash) != 0);
1649 CTransaction& lookup(uint256 hash)
1655 extern CTxMemPool mempool;