1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Copyright (c) 2009-2012 The Bitcoin developers
3 // Distributed under the MIT/X11 software license, see the accompanying
4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
10 #include "timestamps.h"
29 class CRequestTracker;
36 static const unsigned int MAX_BLOCK_SIZE = 1000000;
37 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
38 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
39 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
40 static const unsigned int MAX_INV_SZ = 50000;
42 static const int64_t MIN_TX_FEE = CENT/10;
43 static const int64_t MIN_RELAY_TX_FEE = CENT/50;
45 static const int64_t MAX_MONEY = 2000000000 * COIN;
46 static const int64_t MAX_MINT_PROOF_OF_WORK = 100 * COIN;
47 static const int64_t MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
48 static const int64_t MIN_TXOUT_AMOUNT = CENT/100;
50 inline bool MoneyRange(int64_t nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
51 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
52 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
53 // Maximum number of script-checking threads allowed
54 static const int MAX_SCRIPTCHECK_THREADS = 16;
57 static const int fHaveUPnP = true;
59 static const int fHaveUPnP = false;
62 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
63 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
65 inline int64_t PastDrift(int64_t nTime) { return nTime - 2 * 60 * 60; } // up to 2 hours from the past
66 inline int64_t FutureDrift(int64_t nTime) { return nTime + 2 * 60 * 60; } // up to 2 hours from the future
68 extern CScript COINBASE_FLAGS;
69 extern CCriticalSection cs_main;
70 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
71 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
72 extern CBlockIndex* pindexGenesisBlock;
73 extern unsigned int nNodeLifespan;
74 extern unsigned int nStakeMinAge;
75 extern int nCoinbaseMaturity;
76 extern int nBestHeight;
77 extern uint256 nBestChainTrust;
78 extern uint256 nBestInvalidTrust;
79 extern uint256 hashBestChain;
80 extern CBlockIndex* pindexBest;
81 extern unsigned int nTransactionsUpdated;
82 extern uint64_t nLastBlockTx;
83 extern uint64_t nLastBlockSize;
84 extern uint32_t nLastCoinStakeSearchInterval;
85 extern const std::string strMessageMagic;
86 extern int64_t nTimeBestReceived;
87 extern CCriticalSection cs_setpwalletRegistered;
88 extern std::set<CWallet*> setpwalletRegistered;
89 extern unsigned char pchMessageStart[4];
90 extern std::map<uint256, CBlock*> mapOrphanBlocks;
93 extern int64_t nTransactionFee;
94 extern int64_t nMinimumInputValue;
95 extern bool fUseFastIndex;
96 extern 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, bool fSendTrickle);
121 bool LoadExternalBlockFile(FILE* fileIn);
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 std::string GetWarnings(std::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 StakeMiner(CWallet *pwallet);
141 void ResendWalletTransactions();
143 bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType);
151 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
153 /** Position on disk for a particular transaction. */
166 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
169 nBlockPos = nBlockPosIn;
173 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
174 void SetNull() { nFile = (unsigned int) -1; nBlockPos = 0; nTxPos = 0; }
175 bool IsNull() const { return (nFile == (unsigned int) -1); }
177 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
179 return (a.nFile == b.nFile &&
180 a.nBlockPos == b.nBlockPos &&
181 a.nTxPos == b.nTxPos);
184 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
190 std::string ToString() const
195 return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
200 printf("%s", ToString().c_str());
206 /** An inpoint - a combination of a transaction and an index n into its vin */
213 CInPoint() { SetNull(); }
214 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
215 void SetNull() { ptx = NULL; n = (unsigned int) -1; }
216 bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
221 /** An outpoint - a combination of a transaction hash and an index n into its vout */
228 COutPoint() { SetNull(); }
229 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
230 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
231 void SetNull() { hash = 0; n = (unsigned int) -1; }
232 bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
234 friend bool operator<(const COutPoint& a, const COutPoint& b)
236 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
239 friend bool operator==(const COutPoint& a, const COutPoint& b)
241 return (a.hash == b.hash && a.n == b.n);
244 friend bool operator!=(const COutPoint& a, const COutPoint& b)
249 std::string ToString() const
251 return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
256 printf("%s\n", ToString().c_str());
263 /** An input of a transaction. It contains the location of the previous
264 * transaction's output that it claims and a signature that matches the
265 * output's public key.
276 nSequence = std::numeric_limits<unsigned int>::max();
279 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
282 scriptSig = scriptSigIn;
283 nSequence = nSequenceIn;
286 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
288 prevout = COutPoint(hashPrevTx, nOut);
289 scriptSig = scriptSigIn;
290 nSequence = nSequenceIn;
296 READWRITE(scriptSig);
297 READWRITE(nSequence);
302 return (nSequence == std::numeric_limits<unsigned int>::max());
305 friend bool operator==(const CTxIn& a, const CTxIn& b)
307 return (a.prevout == b.prevout &&
308 a.scriptSig == b.scriptSig &&
309 a.nSequence == b.nSequence);
312 friend bool operator!=(const CTxIn& a, const CTxIn& b)
317 std::string ToStringShort() const
319 return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
322 std::string ToString() const
326 str += prevout.ToString();
327 if (prevout.IsNull())
328 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
330 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
331 if (nSequence != std::numeric_limits<unsigned int>::max())
332 str += strprintf(", nSequence=%u", nSequence);
339 printf("%s\n", ToString().c_str());
346 /** An output of a transaction. It contains the public key that the next input
347 * must be able to sign with to claim it.
353 CScript scriptPubKey;
360 CTxOut(int64_t nValueIn, CScript scriptPubKeyIn)
363 scriptPubKey = scriptPubKeyIn;
369 READWRITE(scriptPubKey);
375 scriptPubKey.clear();
380 return (nValue == -1);
386 scriptPubKey.clear();
391 return (nValue == 0 && scriptPubKey.empty());
394 uint256 GetHash() const
396 return SerializeHash(*this);
399 friend bool operator==(const CTxOut& a, const CTxOut& b)
401 return (a.nValue == b.nValue &&
402 a.scriptPubKey == b.scriptPubKey);
405 friend bool operator!=(const CTxOut& a, const CTxOut& b)
410 std::string ToStringShort() const
412 return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
415 std::string ToString() const
417 if (IsEmpty()) return "CTxOut(empty)";
418 if (scriptPubKey.size() < 6)
419 return "CTxOut(error)";
420 return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
425 printf("%s\n", ToString().c_str());
439 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
441 /** The basic transaction that is broadcasted on the network and contained in
442 * blocks. A transaction can contain multiple inputs and outputs.
447 static const int CURRENT_VERSION=1;
450 std::vector<CTxIn> vin;
451 std::vector<CTxOut> vout;
454 // Denial-of-service detection:
456 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
465 READWRITE(this->nVersion);
466 nVersion = this->nVersion;
470 READWRITE(nLockTime);
475 nVersion = CTransaction::CURRENT_VERSION;
476 nTime = (uint32_t) GetAdjustedTime();
480 nDoS = 0; // Denial-of-service prevention
485 return (vin.empty() && vout.empty());
488 uint256 GetHash() const
490 return SerializeHash(*this);
493 bool IsFinal(int nBlockHeight=0, int64_t nBlockTime=0) const
495 // Time based nLockTime implemented in 0.1.6
498 if (nBlockHeight == 0)
499 nBlockHeight = nBestHeight;
501 nBlockTime = GetAdjustedTime();
502 if ((int64_t)nLockTime < ((int64_t)nLockTime < LOCKTIME_THRESHOLD ? (int64_t)nBlockHeight : nBlockTime))
504 BOOST_FOREACH(const CTxIn& txin, vin)
510 bool IsNewerThan(const CTransaction& old) const
512 if (vin.size() != old.vin.size())
514 for (unsigned int i = 0; i < vin.size(); i++)
515 if (vin[i].prevout != old.vin[i].prevout)
519 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
520 for (unsigned int i = 0; i < vin.size(); i++)
522 if (vin[i].nSequence != old.vin[i].nSequence)
524 if (vin[i].nSequence <= nLowest)
527 nLowest = vin[i].nSequence;
529 if (old.vin[i].nSequence < nLowest)
532 nLowest = old.vin[i].nSequence;
539 bool IsCoinBase() const
541 return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
544 bool IsCoinStake() const
546 // ppcoin: the coin stake transaction is marked with the first output empty
547 return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
550 /** Check for standard transaction types
551 @return True if all outputs (scriptPubKeys) use only standard transaction forms
553 bool IsStandard(std::string& strReason) const;
554 bool IsStandard() const
556 std::string strReason;
557 return IsStandard(strReason);
560 /** Check for standard transaction types
561 @param[in] mapInputs Map of previous transactions that have outputs we're spending
562 @return True if all inputs (scriptSigs) use only standard transaction forms
563 @see CTransaction::FetchInputs
565 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
567 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
568 @return number of sigops this transaction's outputs will produce when spent
569 @see CTransaction::FetchInputs
571 unsigned int GetLegacySigOpCount() const;
573 /** Count ECDSA signature operations in pay-to-script-hash inputs.
575 @param[in] mapInputs Map of previous transactions that have outputs we're spending
576 @return maximum number of sigops required to validate this transaction's inputs
577 @see CTransaction::FetchInputs
579 unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
581 /** Amount of bitcoins spent by this transaction.
582 @return sum of all outputs (note: does not include fees)
584 int64_t GetValueOut() const
586 int64_t nValueOut = 0;
587 BOOST_FOREACH(const CTxOut& txout, vout)
589 nValueOut += txout.nValue;
590 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
591 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
596 /** Amount of bitcoins coming in to this transaction
597 Note that lightweight clients may not know anything besides the hash of previous transactions,
598 so may not be able to calculate this.
600 @param[in] mapInputs Map of previous transactions that have outputs we're spending
601 @return Sum of value of all inputs (scriptSigs)
602 @see CTransaction::FetchInputs
604 int64_t GetValueIn(const MapPrevTx& mapInputs) const;
606 static bool AllowFree(double dPriority)
608 // Large (in bytes) low-priority (new, small-coin) transactions
610 return dPriority > COIN * 144 / 250;
613 int64_t GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK, unsigned int nBytes = 0) const;
615 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
617 CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
619 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
622 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
623 return error("CTransaction::ReadFromDisk() : fseek failed");
628 catch (std::exception &e) {
630 return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
633 // Return file pointer
636 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
637 return error("CTransaction::ReadFromDisk() : second fseek failed");
638 *pfileRet = filein.release();
643 friend bool operator==(const CTransaction& a, const CTransaction& b)
645 return (a.nVersion == b.nVersion &&
646 a.nTime == b.nTime &&
649 a.nLockTime == b.nLockTime);
652 friend bool operator!=(const CTransaction& a, const CTransaction& b)
657 std::string ToStringShort() const
660 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
664 std::string ToString() const
667 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
668 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%" PRIszu ", vout.size=%" PRIszu ", nLockTime=%d)\n",
669 GetHash().ToString().substr(0,10).c_str(),
675 for (unsigned int i = 0; i < vin.size(); i++)
676 str += " " + vin[i].ToString() + "\n";
677 for (unsigned int i = 0; i < vout.size(); i++)
678 str += " " + vout[i].ToString() + "\n";
684 printf("%s", ToString().c_str());
688 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
689 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
690 bool ReadFromDisk(COutPoint prevout);
691 bool DisconnectInputs(CTxDB& txdb);
693 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
695 @param[in] txdb Transaction database
696 @param[in] mapTestPool List of pending changes to the transaction index database
697 @param[in] fBlock True if being called to add a new best-block to the chain
698 @param[in] fMiner True if being called by CreateNewBlock
699 @param[out] inputsRet Pointers to this transaction's inputs
700 @param[out] fInvalid returns true if transaction is invalid
701 @return Returns true if all inputs are in txdb or mapTestPool
703 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
704 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
706 /** Sanity check previous transactions, then, if all checks succeed,
707 mark them as spent by this transaction.
709 @param[in] inputs Previous transactions (from FetchInputs)
710 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
711 @param[in] posThisTx Position of this transaction on disk
712 @param[in] pindexBlock
713 @param[in] fBlock true if called from ConnectBlock
714 @param[in] fMiner true if called from CreateNewBlock
715 @param[in] fScriptChecks enable scripts validation?
716 @param[in] flags STRICT_FLAGS script validation flags
717 @param[in] pvChecks NULL If pvChecks is not NULL, script checks are pushed onto it instead of being performed inline.
718 @return Returns true if all checks succeed
720 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs, std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx, const CBlockIndex* pindexBlock,
721 bool fBlock, bool fMiner, bool fScriptChecks=true,
722 unsigned int flags=STRICT_FLAGS, std::vector<CScriptCheck> *pvChecks = NULL);
723 bool ClientConnectInputs();
724 bool CheckTransaction() const;
725 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
726 bool GetCoinAge(CTxDB& txdb, uint64_t& nCoinAge) const; // ppcoin: get transaction coin age
729 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
732 /** Closure representing one script verification
733 * Note that this stores references to the spending transaction */
737 CScript scriptPubKey;
738 const CTransaction *ptxTo;
745 CScriptCheck(const CTransaction& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, int nHashTypeIn) :
746 scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey),
747 ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), nHashType(nHashTypeIn) { }
749 bool operator()() const;
751 void swap(CScriptCheck &check) {
752 scriptPubKey.swap(check.scriptPubKey);
753 std::swap(ptxTo, check.ptxTo);
754 std::swap(nIn, check.nIn);
755 std::swap(nFlags, check.nFlags);
756 std::swap(nHashType, check.nHashType);
763 /** A transaction with a merkle branch linking it to the block chain. */
764 class CMerkleTx : public CTransaction
768 std::vector<uint256> vMerkleBranch;
772 mutable bool fMerkleVerified;
780 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
789 fMerkleVerified = false;
795 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
796 nVersion = this->nVersion;
797 READWRITE(hashBlock);
798 READWRITE(vMerkleBranch);
803 int SetMerkleBranch(const CBlock* pblock=NULL);
804 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
805 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
806 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
807 int GetBlocksToMaturity() const;
808 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
809 bool AcceptToMemoryPool();
815 /** A txdb record that contains the disk location of a transaction and the
816 * locations of transactions that spend its outputs. vSpent is really only
817 * used as a flag, but having the location is very helpful for debugging.
823 std::vector<CDiskTxPos> vSpent;
830 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
833 vSpent.resize(nOutputs);
838 if (!(nType & SER_GETHASH))
855 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
857 return (a.pos == b.pos &&
858 a.vSpent == b.vSpent);
861 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
865 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((const uint8_t*)&nVersion);
957 int64_t GetBlockTime() const
959 return (int64_t)nTime;
962 void UpdateTime(const CBlockIndex* pindexPrev);
964 // ppcoin: entropy bit for stake modifier if chosen by modifier
965 unsigned int GetStakeEntropyBit(unsigned int nHeight) const
967 // Protocol switch to support p2pool at novacoin block #9689
968 if (nHeight >= 9689 || fTestNet)
970 // Take last bit of block hash as entropy bit
971 unsigned int nEntropyBit = ((GetHash().Get64()) & 1ULL);
972 if (fDebug && GetBoolArg("-printstakemodifier"))
973 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
977 // Before novacoin block #9689 - get from pregenerated table
978 int nBitNum = nHeight & 0xFF;
979 int nItemNum = nHeight / 0xFF;
981 unsigned int nEntropyBit = (unsigned int) ((entropyStore[nItemNum] & (uint256(1) << nBitNum)) >> nBitNum).Get64();
982 if (fDebug && GetBoolArg("-printstakemodifier"))
983 printf("GetStakeEntropyBit: from pregenerated table, nHeight=%d nEntropyBit=%u\n", nHeight, nEntropyBit);
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_t GetMaxTransactionTime() const
1006 int64_t maxTransactionTime = 0;
1007 BOOST_FOREACH(const CTransaction& tx, vtx)
1008 maxTransactionTime = std::max(maxTransactionTime, (int64_t)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 = (int)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 = (int)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) {
1106 return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
1110 if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1111 return error("CBlock::ReadFromDisk() : errors in block header");
1120 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%" PRIszu ", vchBlockSig=%s)\n",
1121 GetHash().ToString().c_str(),
1123 hashPrevBlock.ToString().c_str(),
1124 hashMerkleRoot.ToString().c_str(),
1125 nTime, nBits, nNonce,
1127 HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1128 for (unsigned int i = 0; i < vtx.size(); i++)
1133 printf(" vMerkleTree: ");
1134 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1135 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1140 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1141 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1142 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1143 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1144 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1145 bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1147 bool GetCoinAge(uint64_t& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1148 bool SignBlock(CWallet& keystore);
1149 bool CheckBlockSignature() const;
1152 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1160 /** The block chain is a tree shaped structure starting with the
1161 * genesis block at the root, with each block potentially having multiple
1162 * candidates to be the next block. pprev and pnext link a path through the
1163 * main/longest chain. A blockindex may have multiple pprev pointing back
1164 * to it, but pnext will only point forward to the longest branch, or will
1165 * be null if the block is not part of the longest chain.
1170 const uint256* phashBlock;
1175 uint256 nChainTrust; // ppcoin: trust score of block chain
1179 int64_t nMoneySupply;
1181 uint32_t nFlags; // ppcoin: block index flags
1184 BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1185 BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
1186 BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1189 uint64_t nStakeModifier; // hash modifier for proof-of-stake
1190 uint32_t nStakeModifierChecksum; // checksum of index; in-memeory only
1192 // proof-of-stake specific fields
1193 COutPoint prevoutStake;
1194 uint32_t nStakeTime;
1195 uint256 hashProofOfStake;
1199 uint256 hashMerkleRoot;
1217 nStakeModifierChecksum = 0;
1218 hashProofOfStake = 0;
1219 prevoutStake.SetNull();
1229 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1235 nBlockPos = nBlockPosIn;
1242 nStakeModifierChecksum = 0;
1243 hashProofOfStake = 0;
1244 if (block.IsProofOfStake())
1247 prevoutStake = block.vtx[1].vin[0].prevout;
1248 nStakeTime = block.vtx[1].nTime;
1252 prevoutStake.SetNull();
1256 nVersion = block.nVersion;
1257 hashMerkleRoot = block.hashMerkleRoot;
1258 nTime = block.nTime;
1259 nBits = block.nBits;
1260 nNonce = block.nNonce;
1263 CBlock GetBlockHeader() const
1266 block.nVersion = nVersion;
1268 block.hashPrevBlock = pprev->GetBlockHash();
1269 block.hashMerkleRoot = hashMerkleRoot;
1270 block.nTime = nTime;
1271 block.nBits = nBits;
1272 block.nNonce = nNonce;
1276 uint256 GetBlockHash() const
1281 int64_t GetBlockTime() const
1283 return (int64_t)nTime;
1286 uint256 GetBlockTrust() const;
1288 bool IsInMainChain() const
1290 return (pnext || this == pindexBest);
1293 bool CheckIndex() const
1298 enum { nMedianTimeSpan=11 };
1300 int64_t GetMedianTimePast() const
1302 int64_t pmedian[nMedianTimeSpan];
1303 int64_t* pbegin = &pmedian[nMedianTimeSpan];
1304 int64_t* pend = &pmedian[nMedianTimeSpan];
1306 const CBlockIndex* pindex = this;
1307 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1308 *(--pbegin) = pindex->GetBlockTime();
1310 std::sort(pbegin, pend);
1311 return pbegin[(pend - pbegin)/2];
1314 int64_t GetMedianTime() const
1316 const CBlockIndex* pindex = this;
1317 for (int i = 0; i < nMedianTimeSpan/2; i++)
1320 return GetBlockTime();
1321 pindex = pindex->pnext;
1323 return pindex->GetMedianTimePast();
1327 * Returns true if there are nRequired or more blocks of minVersion or above
1328 * in the last nToCheck blocks, starting at pstart and going backwards.
1330 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1331 unsigned int nRequired, unsigned int nToCheck);
1334 bool IsProofOfWork() const
1336 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1339 bool IsProofOfStake() const
1341 return (nFlags & BLOCK_PROOF_OF_STAKE);
1344 void SetProofOfStake()
1346 nFlags |= BLOCK_PROOF_OF_STAKE;
1349 unsigned int GetStakeEntropyBit() const
1351 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1354 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1356 if (nEntropyBit > 1)
1358 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1362 bool GeneratedStakeModifier() const
1364 return (nFlags & BLOCK_STAKE_MODIFIER) != 0;
1367 void SetStakeModifier(uint64_t nModifier, bool fGeneratedStakeModifier)
1369 nStakeModifier = nModifier;
1370 if (fGeneratedStakeModifier)
1371 nFlags |= BLOCK_STAKE_MODIFIER;
1374 std::string ToString() const
1376 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)",
1377 pprev, pnext, nFile, nBlockPos, nHeight,
1378 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1379 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1380 nStakeModifier, nStakeModifierChecksum,
1381 hashProofOfStake.ToString().c_str(),
1382 prevoutStake.ToString().c_str(), nStakeTime,
1383 hashMerkleRoot.ToString().c_str(),
1384 GetBlockHash().ToString().c_str());
1389 printf("%s\n", ToString().c_str());
1395 /** Used to marshal pointers into hashes for db storage. */
1396 class CDiskBlockIndex : public CBlockIndex
1412 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1414 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1415 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1420 if (!(nType & SER_GETHASH))
1421 READWRITE(nVersion);
1423 READWRITE(hashNext);
1425 READWRITE(nBlockPos);
1428 READWRITE(nMoneySupply);
1430 READWRITE(nStakeModifier);
1431 if (IsProofOfStake())
1433 READWRITE(prevoutStake);
1434 READWRITE(nStakeTime);
1435 READWRITE(hashProofOfStake);
1439 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1440 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1441 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1445 READWRITE(this->nVersion);
1446 READWRITE(hashPrev);
1447 READWRITE(hashMerkleRoot);
1451 READWRITE(blockHash);
1454 uint256 GetBlockHash() const
1456 if (fUseFastIndex && (nTime < GetAdjustedTime() - 24 * 60 * 60) && blockHash != 0)
1460 block.nVersion = nVersion;
1461 block.hashPrevBlock = hashPrev;
1462 block.hashMerkleRoot = hashMerkleRoot;
1463 block.nTime = nTime;
1464 block.nBits = nBits;
1465 block.nNonce = nNonce;
1467 const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1472 std::string ToString() const
1474 std::string str = "CDiskBlockIndex(";
1475 str += CBlockIndex::ToString();
1476 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1477 GetBlockHash().ToString().c_str(),
1478 hashPrev.ToString().c_str(),
1479 hashNext.ToString().c_str());
1485 printf("%s\n", ToString().c_str());
1496 /** Describes a place in the block chain to another node such that if the
1497 * other node doesn't have the same branch, it can find a recent common trunk.
1498 * The further back it is, the further before the fork it may be.
1503 std::vector<uint256> vHave;
1510 explicit CBlockLocator(const CBlockIndex* pindex)
1515 explicit CBlockLocator(uint256 hashBlock)
1517 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1518 if (mi != mapBlockIndex.end())
1522 CBlockLocator(const std::vector<uint256>& vHaveIn)
1529 if (!(nType & SER_GETHASH))
1530 READWRITE(nVersion);
1541 return vHave.empty();
1544 void Set(const CBlockIndex* pindex)
1550 vHave.push_back(pindex->GetBlockHash());
1552 // Exponentially larger steps back
1553 for (int i = 0; pindex && i < nStep; i++)
1554 pindex = pindex->pprev;
1555 if (vHave.size() > 10)
1558 vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1561 int GetDistanceBack()
1563 // Retrace how far back it was in the sender's branch
1566 BOOST_FOREACH(const uint256& hash, vHave)
1568 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1569 if (mi != mapBlockIndex.end())
1571 CBlockIndex* pindex = (*mi).second;
1572 if (pindex->IsInMainChain())
1582 CBlockIndex* GetBlockIndex()
1584 // Find the first block the caller has in the main chain
1585 BOOST_FOREACH(const uint256& hash, vHave)
1587 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1588 if (mi != mapBlockIndex.end())
1590 CBlockIndex* pindex = (*mi).second;
1591 if (pindex->IsInMainChain())
1595 return pindexGenesisBlock;
1598 uint256 GetBlockHash()
1600 // Find the first block the caller has in the main chain
1601 BOOST_FOREACH(const uint256& hash, vHave)
1603 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1604 if (mi != mapBlockIndex.end())
1606 CBlockIndex* pindex = (*mi).second;
1607 if (pindex->IsInMainChain())
1611 return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1616 CBlockIndex* pindex = GetBlockIndex();
1619 return pindex->nHeight;
1633 mutable CCriticalSection cs;
1634 std::map<uint256, CTransaction> mapTx;
1635 std::map<COutPoint, CInPoint> mapNextTx;
1637 bool accept(CTxDB& txdb, CTransaction &tx,
1638 bool fCheckInputs, bool* pfMissingInputs);
1639 bool addUnchecked(const uint256& hash, CTransaction &tx);
1640 bool remove(CTransaction &tx);
1642 void queryHashes(std::vector<uint256>& vtxid);
1647 return mapTx.size();
1650 bool exists(uint256 hash)
1652 return (mapTx.count(hash) != 0);
1655 CTransaction& lookup(uint256 hash)
1661 extern CTxMemPool mempool;