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"
30 class CRequestTracker;
37 static const unsigned int MAX_BLOCK_SIZE = 1000000;
38 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
39 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
40 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
41 static const unsigned int MAX_INV_SZ = 50000;
43 static const int64_t MIN_TX_FEE = CENT/10;
44 static const int64_t MIN_RELAY_TX_FEE = CENT/50;
46 static const int64_t MAX_MONEY = std::numeric_limits<int64_t>::max();
47 static const int64_t MAX_MINT_PROOF_OF_WORK = 100 * COIN;
48 static const int64_t MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
49 static const int64_t MIN_TXOUT_AMOUNT = CENT/100;
52 inline bool MoneyRange(int64_t nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
53 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
54 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
55 // Maximum number of script-checking threads allowed
56 static const int MAX_SCRIPTCHECK_THREADS = 16;
58 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
59 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
61 inline int64_t PastDrift(int64_t nTime) { return nTime - 2 * nOneHour; } // up to 2 hours from the past
62 inline int64_t FutureDrift(int64_t nTime) { return nTime + 2 * nOneHour; } // up to 2 hours from the future
64 extern CScript COINBASE_FLAGS;
65 extern CCriticalSection cs_main;
66 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
67 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
68 extern CBlockIndex* pindexGenesisBlock;
69 extern unsigned int nNodeLifespan;
70 extern unsigned int nStakeMinAge;
71 extern int nCoinbaseMaturity;
72 extern int nBestHeight;
73 extern uint256 nBestChainTrust;
74 extern uint256 nBestInvalidTrust;
75 extern uint256 hashBestChain;
76 extern CBlockIndex* pindexBest;
77 extern unsigned int nTransactionsUpdated;
78 extern uint64_t nLastBlockTx;
79 extern uint64_t nLastBlockSize;
80 extern uint32_t nLastCoinStakeSearchInterval;
81 extern const std::string strMessageMagic;
82 extern int64_t nTimeBestReceived;
83 extern CCriticalSection cs_setpwalletRegistered;
84 extern std::set<CWallet*> setpwalletRegistered;
85 extern unsigned char pchMessageStart[4];
86 extern std::map<uint256, CBlock*> mapOrphanBlocks;
89 extern int64_t nTransactionFee;
90 extern int64_t nMinimumInputValue;
91 extern bool fUseFastIndex;
92 extern int nScriptCheckThreads;
93 extern const uint256 entropyStore[38];
95 // Minimum disk space required - used in CheckDiskSpace()
96 static const uint64_t nMinDiskSpace = 52428800;
103 void RegisterWallet(CWallet* pwalletIn);
104 void UnregisterWallet(CWallet* pwalletIn);
105 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
106 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
107 bool CheckDiskSpace(uint64_t nAdditionalBytes=0);
108 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
109 FILE* AppendBlockFile(unsigned int& nFileRet);
111 void UnloadBlockIndex();
112 bool LoadBlockIndex(bool fAllowNew=true);
113 void PrintBlockTree();
114 CBlockIndex* FindBlockByHeight(int nHeight);
115 bool ProcessMessages(CNode* pfrom);
116 bool SendMessages(CNode* pto);
117 bool LoadExternalBlockFile(FILE* fileIn);
119 // Run an instance of the script checking thread
120 void ThreadScriptCheck(void* parg);
121 // Stop the script checking threads
122 void ThreadScriptCheckQuit();
124 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
125 unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, bool fProofOfStake);
126 int64_t GetProofOfWorkReward(unsigned int nBits, int64_t nFees=0);
127 int64_t GetProofOfStakeReward(int64_t nCoinAge, unsigned int nBits, int64_t nTime, bool bCoinYearOnly=false);
128 unsigned int ComputeMinWork(unsigned int nBase, int64_t nTime);
129 unsigned int ComputeMinStake(unsigned int nBase, int64_t nTime, unsigned int nBlockTime);
130 int GetNumBlocksOfPeers();
131 bool IsInitialBlockDownload();
132 std::string GetWarnings(std::string strFor);
133 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
134 uint256 WantedByOrphan(const CBlock* pblockOrphan);
135 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
136 void ResendWalletTransactions(bool fForceResend=false);
138 bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType);
146 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
148 /** Position on disk for a particular transaction. */
161 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
164 nBlockPos = nBlockPosIn;
168 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
169 void SetNull() { nFile = std::numeric_limits<uint32_t>::max(); nBlockPos = 0; nTxPos = 0; }
170 bool IsNull() const { return (nFile == std::numeric_limits<uint32_t>::max()); }
172 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
174 return (a.nFile == b.nFile &&
175 a.nBlockPos == b.nBlockPos &&
176 a.nTxPos == b.nTxPos);
179 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
185 std::string ToString() const
190 return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
195 printf("%s", ToString().c_str());
201 /** An inpoint - a combination of a transaction and an index n into its vin */
208 CInPoint() { SetNull(); }
209 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
210 void SetNull() { ptx = NULL; n = std::numeric_limits<uint32_t>::max(); }
211 bool IsNull() const { return (ptx == NULL && n == std::numeric_limits<uint32_t>::max()); }
216 /** An outpoint - a combination of a transaction hash and an index n into its vout */
223 COutPoint() { SetNull(); }
224 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
225 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
226 void SetNull() { hash = 0; n = std::numeric_limits<uint32_t>::max(); }
227 bool IsNull() const { return (hash == 0 && n == std::numeric_limits<uint32_t>::max()); }
229 friend bool operator<(const COutPoint& a, const COutPoint& b)
231 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
234 friend bool operator==(const COutPoint& a, const COutPoint& b)
236 return (a.hash == b.hash && a.n == b.n);
239 friend bool operator!=(const COutPoint& a, const COutPoint& b)
244 std::string ToString() const
246 return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
251 printf("%s\n", ToString().c_str());
258 /** An input of a transaction. It contains the location of the previous
259 * transaction's output that it claims and a signature that matches the
260 * output's public key.
271 nSequence = std::numeric_limits<unsigned int>::max();
274 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
277 scriptSig = scriptSigIn;
278 nSequence = nSequenceIn;
281 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
283 prevout = COutPoint(hashPrevTx, nOut);
284 scriptSig = scriptSigIn;
285 nSequence = nSequenceIn;
291 READWRITE(scriptSig);
292 READWRITE(nSequence);
297 return (nSequence == std::numeric_limits<unsigned int>::max());
300 friend bool operator==(const CTxIn& a, const CTxIn& b)
302 return (a.prevout == b.prevout &&
303 a.scriptSig == b.scriptSig &&
304 a.nSequence == b.nSequence);
307 friend bool operator!=(const CTxIn& a, const CTxIn& b)
312 std::string ToStringShort() const
314 return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
317 std::string ToString() const
321 str += prevout.ToString();
322 if (prevout.IsNull())
323 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
325 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
326 if (nSequence != std::numeric_limits<unsigned int>::max())
327 str += strprintf(", nSequence=%u", nSequence);
334 printf("%s\n", ToString().c_str());
341 /** An output of a transaction. It contains the public key that the next input
342 * must be able to sign with to claim it.
348 CScript scriptPubKey;
355 CTxOut(int64_t nValueIn, CScript scriptPubKeyIn)
358 scriptPubKey = scriptPubKeyIn;
364 READWRITE(scriptPubKey);
370 scriptPubKey.clear();
375 return (nValue == -1);
381 scriptPubKey.clear();
386 return (nValue == 0 && scriptPubKey.empty());
389 uint256 GetHash() const
391 return SerializeHash(*this);
394 friend bool operator==(const CTxOut& a, const CTxOut& b)
396 return (a.nValue == b.nValue &&
397 a.scriptPubKey == b.scriptPubKey);
400 friend bool operator!=(const CTxOut& a, const CTxOut& b)
405 std::string ToStringShort() const
407 return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
410 std::string ToString() const
412 if (IsEmpty()) return "CTxOut(empty)";
413 if (scriptPubKey.size() < 6)
414 return "CTxOut(error)";
415 return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
420 printf("%s\n", ToString().c_str());
434 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
436 /** The basic transaction that is broadcasted on the network and contained in
437 * blocks. A transaction can contain multiple inputs and outputs.
442 static const int CURRENT_VERSION=1;
445 std::vector<CTxIn> vin;
446 std::vector<CTxOut> vout;
449 // Denial-of-service detection:
451 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
460 READWRITE(this->nVersion);
461 nVersion = this->nVersion;
465 READWRITE(nLockTime);
470 nVersion = CTransaction::CURRENT_VERSION;
471 nTime = (uint32_t) GetAdjustedTime();
475 nDoS = 0; // Denial-of-service prevention
480 return (vin.empty() && vout.empty());
483 uint256 GetHash() const
485 return SerializeHash(*this);
488 bool IsFinal(int nBlockHeight=0, int64_t nBlockTime=0) const
490 // Time based nLockTime implemented in 0.1.6
493 if (nBlockHeight == 0)
494 nBlockHeight = nBestHeight;
496 nBlockTime = GetAdjustedTime();
497 if ((int64_t)nLockTime < ((int64_t)nLockTime < LOCKTIME_THRESHOLD ? (int64_t)nBlockHeight : nBlockTime))
499 BOOST_FOREACH(const CTxIn& txin, vin)
505 bool IsNewerThan(const CTransaction& old) const
507 if (vin.size() != old.vin.size())
509 for (unsigned int i = 0; i < vin.size(); i++)
510 if (vin[i].prevout != old.vin[i].prevout)
514 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
515 for (unsigned int i = 0; i < vin.size(); i++)
517 if (vin[i].nSequence != old.vin[i].nSequence)
519 if (vin[i].nSequence <= nLowest)
522 nLowest = vin[i].nSequence;
524 if (old.vin[i].nSequence < nLowest)
527 nLowest = old.vin[i].nSequence;
534 bool IsCoinBase() const
536 return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
539 bool IsCoinStake() const
541 // ppcoin: the coin stake transaction is marked with the first output empty
542 return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
545 /** Check for standard transaction types
546 @return True if all outputs (scriptPubKeys) use only standard transaction forms
548 bool IsStandard(std::string& strReason) const;
549 bool IsStandard() const
551 std::string strReason;
552 return IsStandard(strReason);
555 /** Check for standard transaction types
556 @param[in] mapInputs Map of previous transactions that have outputs we're spending
557 @return True if all inputs (scriptSigs) use only standard transaction forms
558 @see CTransaction::FetchInputs
560 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
562 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
563 @return number of sigops this transaction's outputs will produce when spent
564 @see CTransaction::FetchInputs
566 unsigned int GetLegacySigOpCount() const;
568 /** Count ECDSA signature operations in pay-to-script-hash inputs.
570 @param[in] mapInputs Map of previous transactions that have outputs we're spending
571 @return maximum number of sigops required to validate this transaction's inputs
572 @see CTransaction::FetchInputs
574 unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
576 /** Amount of bitcoins spent by this transaction.
577 @return sum of all outputs (note: does not include fees)
579 int64_t GetValueOut() const
581 int64_t nValueOut = 0;
582 BOOST_FOREACH(const CTxOut& txout, vout)
584 nValueOut += txout.nValue;
585 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
586 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
591 /** Amount of bitcoins coming in to this transaction
592 Note that lightweight clients may not know anything besides the hash of previous transactions,
593 so may not be able to calculate this.
595 @param[in] mapInputs Map of previous transactions that have outputs we're spending
596 @return Sum of value of all inputs (scriptSigs)
597 @see CTransaction::FetchInputs
599 int64_t GetValueIn(const MapPrevTx& mapInputs) const;
601 static bool AllowFree(double dPriority)
603 // Large (in bytes) low-priority (new, small-coin) transactions
605 return dPriority > COIN * 144 / 250;
608 int64_t GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK, unsigned int nBytes = 0) const;
610 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
612 CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
614 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
617 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
618 return error("CTransaction::ReadFromDisk() : fseek failed");
623 catch (const std::exception&) {
624 return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
627 // Return file pointer
630 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
631 return error("CTransaction::ReadFromDisk() : second fseek failed");
632 *pfileRet = filein.release();
637 friend bool operator==(const CTransaction& a, const CTransaction& b)
639 return (a.nVersion == b.nVersion &&
640 a.nTime == b.nTime &&
643 a.nLockTime == b.nLockTime);
646 friend bool operator!=(const CTransaction& a, const CTransaction& b)
651 std::string ToStringShort() const
654 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
658 std::string ToString() const
661 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
662 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%" PRIszu ", vout.size=%" PRIszu ", nLockTime=%d)\n",
663 GetHash().ToString().substr(0,10).c_str(),
669 for (unsigned int i = 0; i < vin.size(); i++)
670 str += " " + vin[i].ToString() + "\n";
671 for (unsigned int i = 0; i < vout.size(); i++)
672 str += " " + vout[i].ToString() + "\n";
678 printf("%s", ToString().c_str());
682 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
683 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
684 bool ReadFromDisk(COutPoint prevout);
685 bool DisconnectInputs(CTxDB& txdb);
687 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
689 @param[in] txdb Transaction database
690 @param[in] mapTestPool List of pending changes to the transaction index database
691 @param[in] fBlock True if being called to add a new best-block to the chain
692 @param[in] fMiner True if being called by CreateNewBlock
693 @param[out] inputsRet Pointers to this transaction's inputs
694 @param[out] fInvalid returns true if transaction is invalid
695 @return Returns true if all inputs are in txdb or mapTestPool
697 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
698 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
700 /** Sanity check previous transactions, then, if all checks succeed,
701 mark them as spent by this transaction.
703 @param[in] inputs Previous transactions (from FetchInputs)
704 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
705 @param[in] posThisTx Position of this transaction on disk
706 @param[in] pindexBlock
707 @param[in] fBlock true if called from ConnectBlock
708 @param[in] fMiner true if called from CreateNewBlock
709 @param[in] fScriptChecks enable scripts validation?
710 @param[in] flags STRICT_FLAGS script validation flags
711 @param[in] pvChecks NULL If pvChecks is not NULL, script checks are pushed onto it instead of being performed inline.
712 @return Returns true if all checks succeed
714 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs, std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx, const CBlockIndex* pindexBlock,
715 bool fBlock, bool fMiner, bool fScriptChecks=true,
716 unsigned int flags=STRICT_FLAGS, std::vector<CScriptCheck> *pvChecks = NULL);
717 bool ClientConnectInputs();
718 bool CheckTransaction() const;
719 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
720 bool GetCoinAge(CTxDB& txdb, uint64_t& nCoinAge) const; // ppcoin: get transaction coin age
723 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
726 /** Closure representing one script verification
727 * Note that this stores references to the spending transaction */
731 CScript scriptPubKey;
732 const CTransaction *ptxTo;
739 CScriptCheck(const CTransaction& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, int nHashTypeIn) :
740 scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey),
741 ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), nHashType(nHashTypeIn) { }
743 bool operator()() const;
745 void swap(CScriptCheck &check) {
746 scriptPubKey.swap(check.scriptPubKey);
747 std::swap(ptxTo, check.ptxTo);
748 std::swap(nIn, check.nIn);
749 std::swap(nFlags, check.nFlags);
750 std::swap(nHashType, check.nHashType);
757 /** A transaction with a merkle branch linking it to the block chain. */
758 class CMerkleTx : public CTransaction
762 std::vector<uint256> vMerkleBranch;
766 mutable bool fMerkleVerified;
774 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
783 fMerkleVerified = false;
789 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
790 nVersion = this->nVersion;
791 READWRITE(hashBlock);
792 READWRITE(vMerkleBranch);
797 int SetMerkleBranch(const CBlock* pblock);
798 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
799 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
800 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
801 int GetBlocksToMaturity() const;
802 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
803 bool AcceptToMemoryPool();
809 /** A txdb record that contains the disk location of a transaction and the
810 * locations of transactions that spend its outputs. vSpent is really only
811 * used as a flag, but having the location is very helpful for debugging.
817 std::vector<CDiskTxPos> vSpent;
824 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
827 vSpent.resize(nOutputs);
832 if (!(nType & SER_GETHASH))
849 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
851 return (a.pos == b.pos &&
852 a.vSpent == b.vSpent);
855 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
859 int GetDepthInMainChain() const;
864 /** Nodes collect new transactions into a block, hash them into a hash tree,
865 * and scan through nonce values to make the block's hash satisfy proof-of-work
866 * requirements. When they solve the proof-of-work, they broadcast the block
867 * to everyone and the block is added to the block chain. The first transaction
868 * in the block is a special one that creates a new coin owned by the creator
871 * Blocks are appended to blk0001.dat files on disk. Their location on disk
872 * is indexed by CBlockIndex objects in memory.
878 static const int CURRENT_VERSION=6;
880 uint256 hashPrevBlock;
881 uint256 hashMerkleRoot;
887 std::vector<CTransaction> vtx;
889 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
890 std::vector<unsigned char> vchBlockSig;
893 mutable std::vector<uint256> vMerkleTree;
895 // Denial-of-service detection:
897 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
906 READWRITE(this->nVersion);
907 nVersion = this->nVersion;
908 READWRITE(hashPrevBlock);
909 READWRITE(hashMerkleRoot);
914 // ConnectBlock depends on vtx following header to generate CDiskTxPos
915 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
918 READWRITE(vchBlockSig);
922 const_cast<CBlock*>(this)->vtx.clear();
923 const_cast<CBlock*>(this)->vchBlockSig.clear();
929 nVersion = CBlock::CURRENT_VERSION;
946 uint256 GetHash() const
948 return scrypt_blockhash((const uint8_t*)&nVersion);
951 int64_t GetBlockTime() const
953 return (int64_t)nTime;
956 void UpdateTime(const CBlockIndex* pindexPrev);
958 // ppcoin: entropy bit for stake modifier if chosen by modifier
959 unsigned int GetStakeEntropyBit(unsigned int nHeight) const
961 // Protocol switch to support p2pool at novacoin block #9689
962 if (nHeight >= 9689 || fTestNet)
964 // Take last bit of block hash as entropy bit
965 unsigned int nEntropyBit = (GetHash().Get64()) & (uint64_t)1;
966 if (fDebug && GetBoolArg("-printstakemodifier"))
967 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
971 // Before novacoin block #9689 - get from pregenerated table
972 int nBitNum = nHeight & 0xFF;
973 int nItemNum = nHeight / 0xFF;
975 unsigned int nEntropyBit = (unsigned int) ((entropyStore[nItemNum] & (uint256(1) << nBitNum)) >> nBitNum).Get64();
976 if (fDebug && GetBoolArg("-printstakemodifier"))
977 printf("GetStakeEntropyBit: from pregenerated table, nHeight=%d nEntropyBit=%u\n", nHeight, nEntropyBit);
981 // ppcoin: two types of block: proof-of-work or proof-of-stake
982 bool IsProofOfStake() const
984 return (vtx.size() > 1 && vtx[1].IsCoinStake());
987 bool IsProofOfWork() const
989 return !IsProofOfStake();
992 std::pair<COutPoint, unsigned int> GetProofOfStake() const
994 return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
997 // ppcoin: get max transaction timestamp
998 int64_t GetMaxTransactionTime() const
1000 int64_t maxTransactionTime = 0;
1001 BOOST_FOREACH(const CTransaction& tx, vtx)
1002 maxTransactionTime = std::max(maxTransactionTime, (int64_t)tx.nTime);
1003 return maxTransactionTime;
1006 uint256 BuildMerkleTree() const
1008 vMerkleTree.clear();
1009 BOOST_FOREACH(const CTransaction& tx, vtx)
1010 vMerkleTree.push_back(tx.GetHash());
1012 for (int nSize = (int)vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1014 for (int i = 0; i < nSize; i += 2)
1016 int i2 = std::min(i+1, nSize-1);
1017 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
1018 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
1022 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
1025 std::vector<uint256> GetMerkleBranch(int nIndex) const
1027 if (vMerkleTree.empty())
1029 std::vector<uint256> vMerkleBranch;
1031 for (int nSize = (int)vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1033 int i = std::min(nIndex^1, nSize-1);
1034 vMerkleBranch.push_back(vMerkleTree[j+i]);
1038 return vMerkleBranch;
1041 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1045 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1048 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1050 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1057 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1059 // Open history file to append
1060 CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1062 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1064 // Write index header
1065 unsigned int nSize = fileout.GetSerializeSize(*this);
1066 fileout << FLATDATA(pchMessageStart) << nSize;
1069 long fileOutPos = ftell(fileout);
1071 return error("CBlock::WriteToDisk() : ftell failed");
1072 nBlockPosRet = fileOutPos;
1075 // Flush stdio buffers and commit to disk before returning
1077 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1078 FileCommit(fileout);
1083 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1087 // Open history file to read
1088 CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1090 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1091 if (!fReadTransactions)
1092 filein.nType |= SER_BLOCKHEADERONLY;
1098 catch (const std::exception&) {
1099 return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
1103 if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1104 return error("CBlock::ReadFromDisk() : errors in block header");
1113 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%" PRIszu ", vchBlockSig=%s)\n",
1114 GetHash().ToString().c_str(),
1116 hashPrevBlock.ToString().c_str(),
1117 hashMerkleRoot.ToString().c_str(),
1118 nTime, nBits, nNonce,
1120 HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1121 for (unsigned int i = 0; i < vtx.size(); i++)
1126 printf(" vMerkleTree: ");
1127 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1128 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1133 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1134 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1135 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1136 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1137 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1138 bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1140 bool GetCoinAge(uint64_t& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1141 bool CheckBlockSignature() const;
1144 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1152 /** The block chain is a tree shaped structure starting with the
1153 * genesis block at the root, with each block potentially having multiple
1154 * candidates to be the next block. pprev and pnext link a path through the
1155 * main/longest chain. A blockindex may have multiple pprev pointing back
1156 * to it, but pnext will only point forward to the longest branch, or will
1157 * be null if the block is not part of the longest chain.
1162 const uint256* phashBlock;
1167 uint256 nChainTrust; // ppcoin: trust score of block chain
1171 int64_t nMoneySupply;
1173 uint32_t nFlags; // ppcoin: block index flags
1176 BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1177 BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
1178 BLOCK_STAKE_MODIFIER = (1 << 2) // regenerated stake modifier
1181 uint64_t nStakeModifier; // hash modifier for proof-of-stake
1182 uint32_t nStakeModifierChecksum; // checksum of index; in-memeory only
1184 // proof-of-stake specific fields
1185 COutPoint prevoutStake;
1186 uint32_t nStakeTime;
1187 uint256 hashProofOfStake;
1191 uint256 hashMerkleRoot;
1209 nStakeModifierChecksum = 0;
1210 hashProofOfStake = 0;
1211 prevoutStake.SetNull();
1221 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1227 nBlockPos = nBlockPosIn;
1234 nStakeModifierChecksum = 0;
1235 hashProofOfStake = 0;
1236 if (block.IsProofOfStake())
1239 prevoutStake = block.vtx[1].vin[0].prevout;
1240 nStakeTime = block.vtx[1].nTime;
1244 prevoutStake.SetNull();
1248 nVersion = block.nVersion;
1249 hashMerkleRoot = block.hashMerkleRoot;
1250 nTime = block.nTime;
1251 nBits = block.nBits;
1252 nNonce = block.nNonce;
1255 CBlock GetBlockHeader() const
1258 block.nVersion = nVersion;
1260 block.hashPrevBlock = pprev->GetBlockHash();
1261 block.hashMerkleRoot = hashMerkleRoot;
1262 block.nTime = nTime;
1263 block.nBits = nBits;
1264 block.nNonce = nNonce;
1268 uint256 GetBlockHash() const
1273 int64_t GetBlockTime() const
1275 return (int64_t)nTime;
1278 uint256 GetBlockTrust() const;
1280 bool IsInMainChain() const
1282 return (pnext || this == pindexBest);
1285 bool CheckIndex() const
1290 enum { nMedianTimeSpan=11 };
1292 int64_t GetMedianTimePast() const
1294 int64_t pmedian[nMedianTimeSpan];
1295 int64_t* pbegin = &pmedian[nMedianTimeSpan];
1296 int64_t* pend = &pmedian[nMedianTimeSpan];
1298 const CBlockIndex* pindex = this;
1299 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1300 *(--pbegin) = pindex->GetBlockTime();
1302 std::sort(pbegin, pend);
1303 return pbegin[(pend - pbegin)/2];
1306 int64_t GetMedianTime() const
1308 const CBlockIndex* pindex = this;
1309 for (int i = 0; i < nMedianTimeSpan/2; i++)
1312 return GetBlockTime();
1313 pindex = pindex->pnext;
1315 return pindex->GetMedianTimePast();
1319 * Returns true if there are nRequired or more blocks of minVersion or above
1320 * in the last nToCheck blocks, starting at pstart and going backwards.
1322 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1323 unsigned int nRequired, unsigned int nToCheck);
1326 bool IsProofOfWork() const
1328 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1331 bool IsProofOfStake() const
1333 return (nFlags & BLOCK_PROOF_OF_STAKE);
1336 void SetProofOfStake()
1338 nFlags |= BLOCK_PROOF_OF_STAKE;
1341 unsigned int GetStakeEntropyBit() const
1343 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1346 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1348 if (nEntropyBit > 1)
1350 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1354 bool GeneratedStakeModifier() const
1356 return (nFlags & BLOCK_STAKE_MODIFIER) != 0;
1359 void SetStakeModifier(uint64_t nModifier, bool fGeneratedStakeModifier)
1361 nStakeModifier = nModifier;
1362 if (fGeneratedStakeModifier)
1363 nFlags |= BLOCK_STAKE_MODIFIER;
1366 std::string ToString() const
1368 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)",
1369 (const void*)pprev, (const void*)pnext, nFile, nBlockPos, nHeight,
1370 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1371 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1372 nStakeModifier, nStakeModifierChecksum,
1373 hashProofOfStake.ToString().c_str(),
1374 prevoutStake.ToString().c_str(), nStakeTime,
1375 hashMerkleRoot.ToString().c_str(),
1376 GetBlockHash().ToString().c_str());
1381 printf("%s\n", ToString().c_str());
1387 /** Used to marshal pointers into hashes for db storage. */
1388 class CDiskBlockIndex : public CBlockIndex
1404 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1406 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1407 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1412 if (!(nType & SER_GETHASH))
1413 READWRITE(nVersion);
1415 READWRITE(hashNext);
1417 READWRITE(nBlockPos);
1420 READWRITE(nMoneySupply);
1422 READWRITE(nStakeModifier);
1423 if (IsProofOfStake())
1425 READWRITE(prevoutStake);
1426 READWRITE(nStakeTime);
1427 READWRITE(hashProofOfStake);
1431 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1432 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1433 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1437 READWRITE(this->nVersion);
1438 READWRITE(hashPrev);
1439 READWRITE(hashMerkleRoot);
1443 READWRITE(blockHash);
1446 uint256 GetBlockHash() const
1448 if (fUseFastIndex && (nTime < GetAdjustedTime() - nOneDay) && blockHash != 0)
1452 block.nVersion = nVersion;
1453 block.hashPrevBlock = hashPrev;
1454 block.hashMerkleRoot = hashMerkleRoot;
1455 block.nTime = nTime;
1456 block.nBits = nBits;
1457 block.nNonce = nNonce;
1459 const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1464 std::string ToString() const
1466 std::string str = "CDiskBlockIndex(";
1467 str += CBlockIndex::ToString();
1468 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1469 GetBlockHash().ToString().c_str(),
1470 hashPrev.ToString().c_str(),
1471 hashNext.ToString().c_str());
1477 printf("%s\n", ToString().c_str());
1488 /** Describes a place in the block chain to another node such that if the
1489 * other node doesn't have the same branch, it can find a recent common trunk.
1490 * The further back it is, the further before the fork it may be.
1495 std::vector<uint256> vHave;
1502 explicit CBlockLocator(const CBlockIndex* pindex)
1507 explicit CBlockLocator(uint256 hashBlock)
1509 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1510 if (mi != mapBlockIndex.end())
1514 CBlockLocator(const std::vector<uint256>& vHaveIn)
1521 if (!(nType & SER_GETHASH))
1522 READWRITE(nVersion);
1533 return vHave.empty();
1536 void Set(const CBlockIndex* pindex)
1542 vHave.push_back(pindex->GetBlockHash());
1544 // Exponentially larger steps back
1545 for (int i = 0; pindex && i < nStep; i++)
1546 pindex = pindex->pprev;
1547 if (vHave.size() > 10)
1550 vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1553 int GetDistanceBack()
1555 // Retrace how far back it was in the sender's branch
1558 BOOST_FOREACH(const uint256& hash, vHave)
1560 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1561 if (mi != mapBlockIndex.end())
1563 CBlockIndex* pindex = (*mi).second;
1564 if (pindex->IsInMainChain())
1574 CBlockIndex* GetBlockIndex()
1576 // Find the first block the caller has in the main chain
1577 BOOST_FOREACH(const uint256& hash, vHave)
1579 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1580 if (mi != mapBlockIndex.end())
1582 CBlockIndex* pindex = (*mi).second;
1583 if (pindex->IsInMainChain())
1587 return pindexGenesisBlock;
1590 uint256 GetBlockHash()
1592 // Find the first block the caller has in the main chain
1593 BOOST_FOREACH(const uint256& hash, vHave)
1595 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1596 if (mi != mapBlockIndex.end())
1598 CBlockIndex* pindex = (*mi).second;
1599 if (pindex->IsInMainChain())
1603 return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1608 CBlockIndex* pindex = GetBlockIndex();
1611 return pindex->nHeight;
1625 mutable CCriticalSection cs;
1626 std::map<uint256, CTransaction> mapTx;
1627 std::map<COutPoint, CInPoint> mapNextTx;
1629 bool accept(CTxDB& txdb, CTransaction &tx,
1630 bool fCheckInputs, bool* pfMissingInputs);
1631 bool addUnchecked(const uint256& hash, CTransaction &tx);
1632 bool remove(CTransaction &tx);
1634 void queryHashes(std::vector<uint256>& vtxid);
1639 return mapTx.size();
1642 bool exists(uint256 hash)
1644 return (mapTx.count(hash) != 0);
1647 CTransaction& lookup(uint256 hash)
1653 extern CTxMemPool mempool;