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"
16 #include "ui_interface.h"
33 class CRequestTracker;
40 static const unsigned int MAX_BLOCK_SIZE = 1000000;
41 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
42 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
43 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
44 static const unsigned int MAX_INV_SZ = 50000;
46 static const int64_t MIN_TX_FEE = CENT/10;
47 static const int64_t MIN_RELAY_TX_FEE = CENT/50;
49 static const int64_t MAX_MONEY = numeric_limits<int64_t>::max();
50 static const int64_t MAX_MINT_PROOF_OF_WORK = 100 * COIN;
51 static const int64_t MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
52 static const int64_t MIN_TXOUT_AMOUNT = CENT/100;
55 inline bool MoneyRange(int64_t nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
56 inline bool MoneyRange(CBigNum nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
57 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
58 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
59 // Maximum number of script-checking threads allowed
60 static const int MAX_SCRIPTCHECK_THREADS = 16;
62 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
63 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
65 inline int64_t PastDrift(int64_t nTime) { return nTime - 2 * nOneHour; } // up to 2 hours from the past
66 inline int64_t FutureDrift(int64_t nTime) { return nTime + 2 * nOneHour; } // up to 2 hours from the future
68 extern CScript COINBASE_FLAGS;
69 extern CCriticalSection cs_main;
70 extern map<uint256, CBlockIndex*> mapBlockIndex;
71 extern set<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 uint32_t nLastCoinStakeSearchInterval;
85 extern const string strMessageMagic;
86 extern int64_t nTimeBestReceived;
87 extern CCriticalSection cs_setpwalletRegistered;
88 extern set<CWallet*> setpwalletRegistered;
89 extern uint32_t nNetworkID;
90 extern map<uint256, CBlock*> mapOrphanBlocks;
93 extern int64_t nTransactionFee;
94 extern int64_t nMinimumInputValue;
95 extern bool fUseFastIndex;
96 extern int nScriptCheckThreads;
97 extern const uint256 entropyStore[38];
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);
115 void UnloadBlockIndex();
116 bool LoadBlockIndex(bool fAllowNew=true);
117 void PrintBlockTree();
118 CBlockIndex* FindBlockByHeight(int nHeight);
119 bool ProcessMessages(CNode* pfrom);
120 bool SendMessages(CNode* pto);
121 bool LoadExternalBlockFile(FILE* fileIn, CClientUIInterface& uiInterface);
123 // Run an instance of the script checking thread
124 void ThreadScriptCheck(void* parg);
125 // Stop the script checking threads
126 void ThreadScriptCheckQuit();
128 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
129 unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, bool fProofOfStake);
130 int64_t GetProofOfWorkReward(unsigned int nBits, int64_t nFees=0);
131 int64_t GetProofOfStakeReward(int64_t nCoinAge, unsigned int nBits, int64_t nTime, bool bCoinYearOnly=false);
132 unsigned int ComputeMinWork(unsigned int nBase, int64_t nTime);
133 unsigned int ComputeMinStake(unsigned int nBase, int64_t nTime, unsigned int nBlockTime);
134 int GetNumBlocksOfPeers();
135 bool IsInitialBlockDownload();
136 string GetWarnings(string strFor);
137 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
138 uint256 WantedByOrphan(const CBlock* pblockOrphan);
139 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
140 void ResendWalletTransactions(bool fForceResend=false);
142 bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, uint32_t nIn, unsigned int flags, int nHashType);
150 bool GetWalletFile(CWallet* pwallet, string &strWalletFileOut);
152 /** Position on disk for a particular transaction. */
165 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
168 nBlockPos = nBlockPosIn;
172 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
173 void SetNull() { nFile = numeric_limits<uint32_t>::max(); nBlockPos = 0; nTxPos = 0; }
174 bool IsNull() const { return (nFile == numeric_limits<uint32_t>::max()); }
176 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
178 return (a.nFile == b.nFile &&
179 a.nBlockPos == b.nBlockPos &&
180 a.nTxPos == b.nTxPos);
183 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
189 string ToString() const
194 return strprintf("(nFile=%" PRIu32 ", nBlockPos=%" PRIu32 ", nTxPos=%" PRIu32 ")", nFile, nBlockPos, nTxPos);
199 printf("%s", ToString().c_str());
205 /** An inpoint - a combination of a transaction and an index n into its vin */
212 CInPoint() { SetNull(); }
213 CInPoint(CTransaction* ptxIn, uint32_t nIn) { ptx = ptxIn; n = nIn; }
214 void SetNull() { ptx = NULL; n = numeric_limits<uint32_t>::max(); }
215 bool IsNull() const { return (ptx == NULL && n == numeric_limits<uint32_t>::max()); }
220 /** An outpoint - a combination of a transaction hash and an index n into its vout */
227 COutPoint() { SetNull(); }
228 COutPoint(uint256 hashIn, uint32_t nIn) { hash = hashIn; n = nIn; }
229 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
230 void SetNull() { hash = 0; n = numeric_limits<uint32_t>::max(); }
231 bool IsNull() const { return (hash == 0 && n == numeric_limits<uint32_t>::max()); }
233 friend bool operator<(const COutPoint& a, const COutPoint& b)
235 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
238 friend bool operator==(const COutPoint& a, const COutPoint& b)
240 return (a.hash == b.hash && a.n == b.n);
243 friend bool operator!=(const COutPoint& a, const COutPoint& b)
248 string ToString() const
250 return strprintf("COutPoint(%s, %" PRIu32 ")", hash.ToString().substr(0,10).c_str(), n);
255 printf("%s\n", ToString().c_str());
262 /** An input of a transaction. It contains the location of the previous
263 * transaction's output that it claims and a signature that matches the
264 * output's public key.
275 nSequence = numeric_limits<unsigned int>::max();
278 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=numeric_limits<unsigned int>::max())
281 scriptSig = scriptSigIn;
282 nSequence = nSequenceIn;
285 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=numeric_limits<unsigned int>::max())
287 prevout = COutPoint(hashPrevTx, nOut);
288 scriptSig = scriptSigIn;
289 nSequence = nSequenceIn;
295 READWRITE(scriptSig);
296 READWRITE(nSequence);
301 return (nSequence == numeric_limits<unsigned int>::max());
304 friend bool operator==(const CTxIn& a, const CTxIn& b)
306 return (a.prevout == b.prevout &&
307 a.scriptSig == b.scriptSig &&
308 a.nSequence == b.nSequence);
311 friend bool operator!=(const CTxIn& a, const CTxIn& b)
316 string ToStringShort() const
318 return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
321 string ToString() const
325 str += prevout.ToString();
326 if (prevout.IsNull())
327 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
329 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
330 if (nSequence != numeric_limits<unsigned int>::max())
331 str += strprintf(", nSequence=%" PRIu32, nSequence);
338 printf("%s\n", ToString().c_str());
345 /** An output of a transaction. It contains the public key that the next input
346 * must be able to sign with to claim it.
352 CScript scriptPubKey;
359 CTxOut(int64_t nValueIn, CScript scriptPubKeyIn)
362 scriptPubKey = scriptPubKeyIn;
368 READWRITE(scriptPubKey);
374 scriptPubKey.clear();
379 return (nValue == -1);
385 scriptPubKey.clear();
390 return (nValue == 0 && scriptPubKey.empty());
393 uint256 GetHash() const
395 return SerializeHash(*this);
398 friend bool operator==(const CTxOut& a, const CTxOut& b)
400 return (a.nValue == b.nValue &&
401 a.scriptPubKey == b.scriptPubKey);
404 friend bool operator!=(const CTxOut& a, const CTxOut& b)
409 string ToStringShort() const
411 return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
414 string ToString() const
416 if (IsEmpty()) return "CTxOut(empty)";
417 if (scriptPubKey.size() < 6)
418 return "CTxOut(error)";
419 return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
424 printf("%s\n", ToString().c_str());
438 typedef map<uint256, pair<CTxIndex, CTransaction> > MapPrevTx;
440 /** The basic transaction that is broadcasted on the network and contained in
441 * blocks. A transaction can contain multiple inputs and outputs.
446 static const int CURRENT_VERSION=1;
453 // Denial-of-service detection:
455 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
464 READWRITE(this->nVersion);
465 nVersion = this->nVersion;
469 READWRITE(nLockTime);
474 nVersion = CTransaction::CURRENT_VERSION;
475 nTime = (uint32_t) GetAdjustedTime();
479 nDoS = 0; // Denial-of-service prevention
484 return (vin.empty() && vout.empty());
487 uint256 GetHash() const
489 return SerializeHash(*this);
492 bool IsFinal(int nBlockHeight=0, int64_t nBlockTime=0) const
494 // Time based nLockTime implemented in 0.1.6
497 if (nBlockHeight == 0)
498 nBlockHeight = nBestHeight;
500 nBlockTime = GetAdjustedTime();
501 if ((int64_t)nLockTime < ((int64_t)nLockTime < LOCKTIME_THRESHOLD ? (int64_t)nBlockHeight : nBlockTime))
503 for(const CTxIn& txin : vin)
509 bool IsNewerThan(const CTransaction& old) const
511 if (vin.size() != old.vin.size())
513 for (unsigned int i = 0; i < vin.size(); i++)
514 if (vin[i].prevout != old.vin[i].prevout)
518 unsigned int nLowest = numeric_limits<unsigned int>::max();
519 for (unsigned int i = 0; i < vin.size(); i++)
521 if (vin[i].nSequence != old.vin[i].nSequence)
523 if (vin[i].nSequence <= nLowest)
526 nLowest = vin[i].nSequence;
528 if (old.vin[i].nSequence < nLowest)
531 nLowest = old.vin[i].nSequence;
538 bool IsCoinBase() const
540 return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
543 bool IsCoinStake() const
545 // ppcoin: the coin stake transaction is marked with the first output empty
546 return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
549 /** Check for standard transaction types
550 @return True if all outputs (scriptPubKeys) use only standard transaction forms
552 bool IsStandard(string& strReason) const;
553 bool IsStandard() const
556 return IsStandard(strReason);
559 /** Check for standard transaction types
560 @param[in] mapInputs Map of previous transactions that have outputs we're spending
561 @return True if all inputs (scriptSigs) use only standard transaction forms
562 @see CTransaction::FetchInputs
564 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
566 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
567 @return number of sigops this transaction's outputs will produce when spent
568 @see CTransaction::FetchInputs
570 unsigned int GetLegacySigOpCount() const;
572 /** Count ECDSA signature operations in pay-to-script-hash inputs.
574 @param[in] mapInputs Map of previous transactions that have outputs we're spending
575 @return maximum number of sigops required to validate this transaction's inputs
576 @see CTransaction::FetchInputs
578 unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
580 /** Amount of bitcoins spent by this transaction.
581 @return sum of all outputs (note: does not include fees)
583 int64_t GetValueOut() const
585 CBigNum nValueOut = 0;
586 for(const auto& txout : vout)
588 nValueOut += txout.nValue;
589 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
590 throw runtime_error("CTransaction::GetValueOut() : value out of range");
592 return nValueOut.getint64();
595 /** Amount of bitcoins coming in to this transaction
596 Note that lightweight clients may not know anything besides the hash of previous transactions,
597 so may not be able to calculate this.
599 @param[in] mapInputs Map of previous transactions that have outputs we're spending
600 @return Sum of value of all inputs (scriptSigs)
601 @see CTransaction::FetchInputs
603 int64_t GetValueIn(const MapPrevTx& mapInputs) const;
605 static bool AllowFree(double dPriority)
607 // Large (in bytes) low-priority (new, small-coin) transactions
609 return dPriority > COIN * 144 / 250;
612 int64_t GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK, unsigned int nBytes = 0) const;
614 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
616 auto filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
618 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
621 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
622 return error("CTransaction::ReadFromDisk() : fseek failed");
627 catch (const exception&) {
628 return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
631 // Return file pointer
634 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
635 return error("CTransaction::ReadFromDisk() : second fseek failed");
636 *pfileRet = filein.release();
641 friend bool operator==(const CTransaction& a, const CTransaction& b)
643 return (a.nVersion == b.nVersion &&
644 a.nTime == b.nTime &&
647 a.nLockTime == b.nLockTime);
650 friend bool operator!=(const CTransaction& a, const CTransaction& b)
655 string ToStringShort() const
658 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
662 string ToString() const
665 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
666 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%" PRIszu ", vout.size=%" PRIszu ", nLockTime=%d)\n",
667 GetHash().ToString().substr(0,10).c_str(),
673 for (unsigned int i = 0; i < vin.size(); i++)
674 str += " " + vin[i].ToString() + "\n";
675 for (unsigned int i = 0; i < vout.size(); i++)
676 str += " " + vout[i].ToString() + "\n";
682 printf("%s", ToString().c_str());
686 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
687 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
688 bool ReadFromDisk(COutPoint prevout);
689 bool DisconnectInputs(CTxDB& txdb);
691 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
693 @param[in] txdb Transaction database
694 @param[in] mapTestPool List of pending changes to the transaction index database
695 @param[in] fBlock True if being called to add a new best-block to the chain
696 @param[in] fMiner True if being called by CreateNewBlock
697 @param[out] inputsRet Pointers to this transaction's inputs
698 @param[out] fInvalid returns true if transaction is invalid
699 @return Returns true if all inputs are in txdb or mapTestPool
701 bool FetchInputs(CTxDB& txdb, const map<uint256, CTxIndex>& mapTestPool,
702 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
704 /** Sanity check previous transactions, then, if all checks succeed,
705 mark them as spent by this transaction.
707 @param[in] inputs Previous transactions (from FetchInputs)
708 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
709 @param[in] posThisTx Position of this transaction on disk
710 @param[in] pindexBlock
711 @param[in] fBlock true if called from ConnectBlock
712 @param[in] fMiner true if called from CreateNewBlock
713 @param[in] fScriptChecks enable scripts validation?
714 @param[in] flags STRICT_FLAGS script validation flags
715 @param[in] pvChecks NULL If pvChecks is not NULL, script checks are pushed onto it instead of being performed inline.
716 @return Returns true if all checks succeed
718 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs, map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx, const CBlockIndex* pindexBlock,
719 bool fBlock, bool fMiner, bool fScriptChecks=true,
720 unsigned int flags=STRICT_FLAGS, vector<CScriptCheck> *pvChecks = NULL);
721 bool ClientConnectInputs();
722 bool CheckTransaction() const;
723 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
724 bool GetCoinAge(CTxDB& txdb, uint64_t& nCoinAge) const; // ppcoin: get transaction coin age
727 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
730 /** Closure representing one script verification
731 * Note that this stores references to the spending transaction */
735 CScript scriptPubKey;
736 const CTransaction *ptxTo = nullptr;
738 unsigned int nFlags = 0;
743 CScriptCheck(const CTransaction& txFromIn, const CTransaction& txToIn, uint32_t nInIn, unsigned int nFlagsIn, int nHashTypeIn) :
744 scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey),
745 ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), nHashType(nHashTypeIn) { }
747 bool operator()() const;
749 void swap(CScriptCheck &check) {
750 scriptPubKey.swap(check.scriptPubKey);
751 std::swap(ptxTo, check.ptxTo);
752 std::swap(nIn, check.nIn);
753 std::swap(nFlags, check.nFlags);
754 std::swap(nHashType, check.nHashType);
761 /** A transaction with a merkle branch linking it to the block chain. */
762 class CMerkleTx : public CTransaction
766 vector<uint256> vMerkleBranch;
770 mutable bool fMerkleVerified;
778 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
787 fMerkleVerified = false;
793 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
794 nVersion = this->nVersion;
795 READWRITE(hashBlock);
796 READWRITE(vMerkleBranch);
801 int SetMerkleBranch(const CBlock* pblock=NULL);
802 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
803 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
804 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
805 int GetBlocksToMaturity() const;
806 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
807 bool AcceptToMemoryPool();
813 /** A txdb record that contains the disk location of a transaction and the
814 * locations of transactions that spend its outputs. vSpent is really only
815 * used as a flag, but having the location is very helpful for debugging.
821 vector<CDiskTxPos> vSpent;
828 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
831 vSpent.resize(nOutputs);
836 if (!(nType & SER_GETHASH))
853 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
855 return (a.pos == b.pos &&
856 a.vSpent == b.vSpent);
859 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
863 int GetDepthInMainChain() const;
868 /** Nodes collect new transactions into a block, hash them into a hash tree,
869 * and scan through nonce values to make the block's hash satisfy proof-of-work
870 * requirements. When they solve the proof-of-work, they broadcast the block
871 * to everyone and the block is added to the block chain. The first transaction
872 * in the block is a special one that creates a new coin owned by the creator
875 * Blocks are appended to blk0001.dat files on disk. Their location on disk
876 * is indexed by CBlockIndex objects in memory.
882 static const int CURRENT_VERSION=6;
884 uint256 hashPrevBlock;
885 uint256 hashMerkleRoot;
891 vector<CTransaction> vtx;
893 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
894 vector<unsigned char> vchBlockSig;
897 mutable vector<uint256> vMerkleTree;
899 // Denial-of-service detection:
901 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
910 READWRITE(this->nVersion);
911 nVersion = this->nVersion;
912 READWRITE(hashPrevBlock);
913 READWRITE(hashMerkleRoot);
918 // ConnectBlock depends on vtx following header to generate CDiskTxPos
919 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
922 READWRITE(vchBlockSig);
926 const_cast<CBlock*>(this)->vtx.clear();
927 const_cast<CBlock*>(this)->vchBlockSig.clear();
933 nVersion = CBlock::CURRENT_VERSION;
950 uint256 GetHash() const
952 return scrypt_blockhash((const uint8_t*)&nVersion);
955 int64_t GetBlockTime() const
957 return (int64_t)nTime;
960 void UpdateTime(const CBlockIndex* pindexPrev);
962 // ppcoin: entropy bit for stake modifier if chosen by modifier
963 unsigned int GetStakeEntropyBit(unsigned int nHeight) const
965 // Protocol switch to support p2pool at novacoin block #9689
966 if (nHeight >= 9689 || fTestNet)
968 // Take last bit of block hash as entropy bit
969 auto nEntropyBit = (GetHash().Get32()) & (uint32_t)1;
970 if (fDebug && GetBoolArg("-printstakemodifier"))
971 printf("GetStakeEntropyBit: nTime=%" PRIu32 " hashBlock=%s nEntropyBit=%" PRIu32 "\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
975 // Before novacoin block #9689 - get from pregenerated table
976 int nBitNum = nHeight & 0xFF;
977 int nItemNum = nHeight / 0xFF;
979 auto nEntropyBit = ((entropyStore[nItemNum] & (uint256(1) << nBitNum)) >> nBitNum).Get32();
980 if (fDebug && GetBoolArg("-printstakemodifier"))
981 printf("GetStakeEntropyBit: from pregenerated table, nHeight=%" PRIu32 " nEntropyBit=%" PRIu32 "\n", nHeight, nEntropyBit);
985 // ppcoin: two types of block: proof-of-work or proof-of-stake
986 bool IsProofOfStake() const
988 return (vtx.size() > 1 && vtx[1].IsCoinStake());
991 bool IsProofOfWork() const
993 return !IsProofOfStake();
996 pair<COutPoint, unsigned int> GetProofOfStake() const
998 if (IsProofOfStake())
999 return { vtx[1].vin[0].prevout, vtx[1].nTime };
1000 return { COutPoint(), (unsigned int)0 };
1003 // ppcoin: get max transaction timestamp
1004 int64_t GetMaxTransactionTime() const
1006 int64_t maxTransactionTime = 0;
1007 for(const auto& tx : vtx)
1008 maxTransactionTime = max(maxTransactionTime, (int64_t)tx.nTime);
1009 return maxTransactionTime;
1012 uint256 BuildMerkleTree() const
1014 vMerkleTree.clear();
1015 for(const auto& tx : vtx)
1016 vMerkleTree.push_back(tx.GetHash());
1018 for (int nSize = (int)vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1020 for (int i = 0; i < nSize; i += 2)
1022 int i2 = min(i+1, nSize-1);
1023 vMerkleTree.push_back(Hash(vMerkleTree[j+i].begin(), vMerkleTree[j+i].end(),
1024 vMerkleTree[j+i2].begin(), vMerkleTree[j+i2].end()));
1028 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
1031 vector<uint256> GetMerkleBranch(int nIndex) const
1033 if (vMerkleTree.empty())
1035 vector<uint256> vMerkleBranch;
1037 for (int nSize = (int)vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1039 int i = min(nIndex^1, nSize-1);
1040 vMerkleBranch.push_back(vMerkleTree[j+i]);
1044 return vMerkleBranch;
1047 static uint256 CheckMerkleBranch(uint256 hash, const vector<uint256>& vMerkleBranch, int nIndex)
1051 for(const uint256& otherside : vMerkleBranch)
1054 hash = Hash(otherside.begin(), otherside.end(), hash.begin(), hash.end());
1056 hash = Hash(hash.begin(), hash.end(), otherside.begin(), otherside.end());
1063 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1065 // Open history file to append
1066 auto 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 << nNetworkID << 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 auto 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 (const exception&) {
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=%" PRId32 ", hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%" PRIu32 ", nBits=%08x, nNonce=%" PRIu32 ", 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_t& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1147 bool CheckBlockSignature() const;
1150 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1158 /** The block chain is a tree shaped structure starting with the
1159 * genesis block at the root, with each block potentially having multiple
1160 * candidates to be the next block. pprev and pnext link a path through the
1161 * main/longest chain. A blockindex may have multiple pprev pointing back
1162 * to it, but pnext will only point forward to the longest branch, or will
1163 * be null if the block is not part of the longest chain.
1168 const uint256* phashBlock;
1173 uint256 nChainTrust; // ppcoin: trust score of block chain
1177 int64_t nMoneySupply;
1179 uint32_t nFlags; // ppcoin: block index flags
1182 BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1183 BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
1184 BLOCK_STAKE_MODIFIER = (1 << 2) // regenerated stake modifier
1187 uint64_t nStakeModifier; // hash modifier for proof-of-stake
1188 uint32_t nStakeModifierChecksum; // checksum of index; in-memeory only
1190 // proof-of-stake specific fields
1191 COutPoint prevoutStake;
1192 uint32_t nStakeTime;
1193 uint256 hashProofOfStake;
1197 uint256 hashMerkleRoot;
1215 nStakeModifierChecksum = 0;
1216 hashProofOfStake = 0;
1217 prevoutStake.SetNull();
1227 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1233 nBlockPos = nBlockPosIn;
1240 nStakeModifierChecksum = 0;
1241 hashProofOfStake = 0;
1242 if (block.IsProofOfStake())
1245 prevoutStake = block.vtx[1].vin[0].prevout;
1246 nStakeTime = block.vtx[1].nTime;
1250 prevoutStake.SetNull();
1254 nVersion = block.nVersion;
1255 hashMerkleRoot = block.hashMerkleRoot;
1256 nTime = block.nTime;
1257 nBits = block.nBits;
1258 nNonce = block.nNonce;
1261 CBlock GetBlockHeader() const
1264 block.nVersion = nVersion;
1266 block.hashPrevBlock = pprev->GetBlockHash();
1267 block.hashMerkleRoot = hashMerkleRoot;
1268 block.nTime = nTime;
1269 block.nBits = nBits;
1270 block.nNonce = nNonce;
1274 uint256 GetBlockHash() const
1279 int64_t GetBlockTime() const
1281 return (int64_t)nTime;
1284 uint256 GetBlockTrust() const;
1286 bool IsInMainChain() const
1288 return (pnext || this == pindexBest);
1291 bool CheckIndex() const
1296 enum { nMedianTimeSpan=11 };
1298 int64_t GetMedianTimePast() const
1300 int64_t pmedian[nMedianTimeSpan];
1301 int64_t* pbegin = &pmedian[nMedianTimeSpan];
1302 int64_t* pend = &pmedian[nMedianTimeSpan];
1304 const CBlockIndex* pindex = this;
1305 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1306 *(--pbegin) = pindex->GetBlockTime();
1309 return pbegin[(pend - pbegin)/2];
1312 int64_t GetMedianTime() const
1314 const CBlockIndex* pindex = this;
1315 for (int i = 0; i < nMedianTimeSpan/2; i++)
1318 return GetBlockTime();
1319 pindex = pindex->pnext;
1321 return pindex->GetMedianTimePast();
1325 * Returns true if there are nRequired or more blocks of minVersion or above
1326 * in the last nToCheck blocks, starting at pstart and going backwards.
1328 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1329 unsigned int nRequired, unsigned int nToCheck);
1332 bool IsProofOfWork() const
1334 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1337 bool IsProofOfStake() const
1339 return (nFlags & BLOCK_PROOF_OF_STAKE);
1342 void SetProofOfStake()
1344 nFlags |= BLOCK_PROOF_OF_STAKE;
1347 unsigned int GetStakeEntropyBit() const
1349 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1352 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1354 if (nEntropyBit > 1)
1356 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1360 bool GeneratedStakeModifier() const
1362 return (nFlags & BLOCK_STAKE_MODIFIER) != 0;
1365 void SetStakeModifier(uint64_t nModifier, bool fGeneratedStakeModifier)
1367 nStakeModifier = nModifier;
1368 if (fGeneratedStakeModifier)
1369 nFlags |= BLOCK_STAKE_MODIFIER;
1372 string ToString() const
1374 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)",
1375 (const void*)pprev, (const void*)pnext, nFile, nBlockPos, nHeight,
1376 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1377 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1378 nStakeModifier, nStakeModifierChecksum,
1379 hashProofOfStake.ToString().c_str(),
1380 prevoutStake.ToString().c_str(), nStakeTime,
1381 hashMerkleRoot.ToString().c_str(),
1382 GetBlockHash().ToString().c_str());
1387 printf("%s\n", ToString().c_str());
1393 /** Used to marshal pointers into hashes for db storage. */
1394 class CDiskBlockIndex : public CBlockIndex
1410 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1412 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1413 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1418 if (!(nType & SER_GETHASH))
1419 READWRITE(nVersion);
1421 READWRITE(hashNext);
1423 READWRITE(nBlockPos);
1426 READWRITE(nMoneySupply);
1428 READWRITE(nStakeModifier);
1429 if (IsProofOfStake())
1431 READWRITE(prevoutStake);
1432 READWRITE(nStakeTime);
1433 READWRITE(hashProofOfStake);
1437 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1438 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1439 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1443 READWRITE(this->nVersion);
1444 READWRITE(hashPrev);
1445 READWRITE(hashMerkleRoot);
1449 READWRITE(blockHash);
1452 uint256 GetBlockHash() const
1454 if (fUseFastIndex && blockHash != 0)
1458 block.nVersion = nVersion;
1459 block.hashPrevBlock = hashPrev;
1460 block.hashMerkleRoot = hashMerkleRoot;
1461 block.nTime = nTime;
1462 block.nBits = nBits;
1463 block.nNonce = nNonce;
1465 const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1470 string ToString() const
1472 string str = "CDiskBlockIndex(";
1473 str += CBlockIndex::ToString();
1474 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1475 GetBlockHash().ToString().c_str(),
1476 hashPrev.ToString().c_str(),
1477 hashNext.ToString().c_str());
1483 printf("%s\n", ToString().c_str());
1494 /** Describes a place in the block chain to another node such that if the
1495 * other node doesn't have the same branch, it can find a recent common trunk.
1496 * The further back it is, the further before the fork it may be.
1501 vector<uint256> vHave;
1508 explicit CBlockLocator(const CBlockIndex* pindex)
1513 explicit CBlockLocator(uint256 hashBlock)
1515 auto mi = mapBlockIndex.find(hashBlock);
1516 if (mi != mapBlockIndex.end())
1520 CBlockLocator(const vector<uint256>& vHaveIn)
1527 if (!(nType & SER_GETHASH))
1528 READWRITE(nVersion);
1539 return vHave.empty();
1542 void Set(const CBlockIndex* pindex)
1548 vHave.push_back(pindex->GetBlockHash());
1550 // Exponentially larger steps back
1551 for (int i = 0; pindex && i < nStep; i++)
1552 pindex = pindex->pprev;
1553 if (vHave.size() > 10)
1556 vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1559 int GetDistanceBack()
1561 // Retrace how far back it was in the sender's branch
1564 for(const auto& hash : vHave)
1566 auto mi = mapBlockIndex.find(hash);
1567 if (mi != mapBlockIndex.end())
1569 auto pindex = (*mi).second;
1570 if (pindex->IsInMainChain())
1580 CBlockIndex* GetBlockIndex()
1582 // Find the first block the caller has in the main chain
1583 for(const auto& hash : vHave)
1585 auto mi = mapBlockIndex.find(hash);
1586 if (mi != mapBlockIndex.end())
1588 auto pindex = (*mi).second;
1589 if (pindex->IsInMainChain())
1593 return pindexGenesisBlock;
1596 uint256 GetBlockHash()
1598 // Find the first block the caller has in the main chain
1599 for(const uint256& hash : vHave)
1601 auto mi = mapBlockIndex.find(hash);
1602 if (mi != mapBlockIndex.end())
1604 auto pindex = (*mi).second;
1605 if (pindex->IsInMainChain())
1609 return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1614 CBlockIndex* pindex = GetBlockIndex();
1617 return pindex->nHeight;
1631 mutable CCriticalSection cs;
1632 map<uint256, CTransaction> mapTx;
1633 map<COutPoint, CInPoint> mapNextTx;
1635 bool accept(CTxDB& txdb, CTransaction &tx,
1636 bool fCheckInputs, bool* pfMissingInputs);
1637 bool addUnchecked(const uint256& hash, CTransaction &tx);
1638 bool remove(CTransaction &tx);
1640 void queryHashes(vector<uint256>& vtxid);
1645 return mapTx.size();
1648 bool exists(const uint256 &hash)
1650 return (mapTx.count(hash) != 0);
1653 CTransaction& lookup(const uint256 &hash)
1659 extern CTxMemPool mempool;