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 int64_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 unsigned int nDerivationMethodIndex;
97 extern int nScriptCheckThreads;
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);
114 bool LoadBlockIndex(bool fAllowNew=true);
115 void PrintBlockTree();
116 CBlockIndex* FindBlockByHeight(int nHeight);
117 bool ProcessMessages(CNode* pfrom);
118 bool SendMessages(CNode* pto, bool fSendTrickle);
119 bool LoadExternalBlockFile(FILE* fileIn);
121 // Run an instance of the script checking thread
122 void ThreadScriptCheck(void* parg);
123 // Stop the script checking threads
124 void ThreadScriptCheckQuit();
126 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
127 unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, bool fProofOfStake);
128 int64_t GetProofOfWorkReward(unsigned int nBits, int64_t nFees=0);
129 int64_t GetProofOfStakeReward(int64_t nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly=false);
130 unsigned int ComputeMinWork(unsigned int nBase, int64_t nTime);
131 unsigned int ComputeMinStake(unsigned int nBase, int64_t nTime, unsigned int nBlockTime);
132 int GetNumBlocksOfPeers();
133 bool IsInitialBlockDownload();
134 std::string GetWarnings(std::string strFor);
135 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
136 uint256 WantedByOrphan(const CBlock* pblockOrphan);
137 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
138 void StakeMiner(CWallet *pwallet);
139 void ResendWalletTransactions();
141 bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType);
149 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
151 /** Position on disk for a particular transaction. */
156 unsigned int nBlockPos;
164 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
167 nBlockPos = nBlockPosIn;
171 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
172 void SetNull() { nFile = (unsigned int) -1; nBlockPos = 0; nTxPos = 0; }
173 bool IsNull() const { return (nFile == (unsigned int) -1); }
175 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
177 return (a.nFile == b.nFile &&
178 a.nBlockPos == b.nBlockPos &&
179 a.nTxPos == b.nTxPos);
182 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
188 std::string ToString() const
193 return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
198 printf("%s", ToString().c_str());
204 /** An inpoint - a combination of a transaction and an index n into its vin */
211 CInPoint() { SetNull(); }
212 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
213 void SetNull() { ptx = NULL; n = (unsigned int) -1; }
214 bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
219 /** An outpoint - a combination of a transaction hash and an index n into its vout */
226 COutPoint() { SetNull(); }
227 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
228 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
229 void SetNull() { hash = 0; n = (unsigned int) -1; }
230 bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
232 friend bool operator<(const COutPoint& a, const COutPoint& b)
234 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
237 friend bool operator==(const COutPoint& a, const COutPoint& b)
239 return (a.hash == b.hash && a.n == b.n);
242 friend bool operator!=(const COutPoint& a, const COutPoint& b)
247 std::string ToString() const
249 return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
254 printf("%s\n", ToString().c_str());
261 /** An input of a transaction. It contains the location of the previous
262 * transaction's output that it claims and a signature that matches the
263 * output's public key.
270 unsigned int nSequence;
274 nSequence = std::numeric_limits<unsigned int>::max();
277 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
280 scriptSig = scriptSigIn;
281 nSequence = nSequenceIn;
284 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
286 prevout = COutPoint(hashPrevTx, nOut);
287 scriptSig = scriptSigIn;
288 nSequence = nSequenceIn;
294 READWRITE(scriptSig);
295 READWRITE(nSequence);
300 return (nSequence == std::numeric_limits<unsigned int>::max());
303 friend bool operator==(const CTxIn& a, const CTxIn& b)
305 return (a.prevout == b.prevout &&
306 a.scriptSig == b.scriptSig &&
307 a.nSequence == b.nSequence);
310 friend bool operator!=(const CTxIn& a, const CTxIn& b)
315 std::string ToStringShort() const
317 return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
320 std::string ToString() const
324 str += prevout.ToString();
325 if (prevout.IsNull())
326 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
328 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
329 if (nSequence != std::numeric_limits<unsigned int>::max())
330 str += strprintf(", nSequence=%u", nSequence);
337 printf("%s\n", ToString().c_str());
344 /** An output of a transaction. It contains the public key that the next input
345 * must be able to sign with to claim it.
351 CScript scriptPubKey;
358 CTxOut(int64_t nValueIn, CScript scriptPubKeyIn)
361 scriptPubKey = scriptPubKeyIn;
367 READWRITE(scriptPubKey);
373 scriptPubKey.clear();
378 return (nValue == -1);
384 scriptPubKey.clear();
389 return (nValue == 0 && scriptPubKey.empty());
392 uint256 GetHash() const
394 return SerializeHash(*this);
397 friend bool operator==(const CTxOut& a, const CTxOut& b)
399 return (a.nValue == b.nValue &&
400 a.scriptPubKey == b.scriptPubKey);
403 friend bool operator!=(const CTxOut& a, const CTxOut& b)
408 std::string ToStringShort() const
410 return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
413 std::string ToString() const
415 if (IsEmpty()) return "CTxOut(empty)";
416 if (scriptPubKey.size() < 6)
417 return "CTxOut(error)";
418 return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
423 printf("%s\n", ToString().c_str());
437 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
439 /** The basic transaction that is broadcasted on the network and contained in
440 * blocks. A transaction can contain multiple inputs and outputs.
445 static const int CURRENT_VERSION=1;
448 std::vector<CTxIn> vin;
449 std::vector<CTxOut> vout;
450 unsigned int nLockTime;
452 // Denial-of-service detection:
454 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
463 READWRITE(this->nVersion);
464 nVersion = this->nVersion;
468 READWRITE(nLockTime);
473 nVersion = CTransaction::CURRENT_VERSION;
474 nTime = GetAdjustedTime();
478 nDoS = 0; // Denial-of-service prevention
483 return (vin.empty() && vout.empty());
486 uint256 GetHash() const
488 return SerializeHash(*this);
491 bool IsFinal(int nBlockHeight=0, int64_t nBlockTime=0) const
493 // Time based nLockTime implemented in 0.1.6
496 if (nBlockHeight == 0)
497 nBlockHeight = nBestHeight;
499 nBlockTime = GetAdjustedTime();
500 if ((int64_t)nLockTime < ((int64_t)nLockTime < LOCKTIME_THRESHOLD ? (int64_t)nBlockHeight : nBlockTime))
502 BOOST_FOREACH(const CTxIn& txin, vin)
508 bool IsNewerThan(const CTransaction& old) const
510 if (vin.size() != old.vin.size())
512 for (unsigned int i = 0; i < vin.size(); i++)
513 if (vin[i].prevout != old.vin[i].prevout)
517 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
518 for (unsigned int i = 0; i < vin.size(); i++)
520 if (vin[i].nSequence != old.vin[i].nSequence)
522 if (vin[i].nSequence <= nLowest)
525 nLowest = vin[i].nSequence;
527 if (old.vin[i].nSequence < nLowest)
530 nLowest = old.vin[i].nSequence;
537 bool IsCoinBase() const
539 return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
542 bool IsCoinStake() const
544 // ppcoin: the coin stake transaction is marked with the first output empty
545 return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
548 /** Check for standard transaction types
549 @return True if all outputs (scriptPubKeys) use only standard transaction forms
551 bool IsStandard() const;
553 /** Check for standard transaction types
554 @param[in] mapInputs Map of previous transactions that have outputs we're spending
555 @return True if all inputs (scriptSigs) use only standard transaction forms
556 @see CTransaction::FetchInputs
558 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
560 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
561 @return number of sigops this transaction's outputs will produce when spent
562 @see CTransaction::FetchInputs
564 unsigned int GetLegacySigOpCount() const;
566 /** Count ECDSA signature operations in pay-to-script-hash inputs.
568 @param[in] mapInputs Map of previous transactions that have outputs we're spending
569 @return maximum number of sigops required to validate this transaction's inputs
570 @see CTransaction::FetchInputs
572 unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
574 /** Amount of bitcoins spent by this transaction.
575 @return sum of all outputs (note: does not include fees)
577 int64_t GetValueOut() const
579 int64_t nValueOut = 0;
580 BOOST_FOREACH(const CTxOut& txout, vout)
582 nValueOut += txout.nValue;
583 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
584 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
589 /** Amount of bitcoins coming in to this transaction
590 Note that lightweight clients may not know anything besides the hash of previous transactions,
591 so may not be able to calculate this.
593 @param[in] mapInputs Map of previous transactions that have outputs we're spending
594 @return Sum of value of all inputs (scriptSigs)
595 @see CTransaction::FetchInputs
597 int64_t GetValueIn(const MapPrevTx& mapInputs) const;
599 static bool AllowFree(double dPriority)
601 // Large (in bytes) low-priority (new, small-coin) transactions
603 return dPriority > COIN * 144 / 250;
606 int64_t GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK, unsigned int nBytes = 0) const;
608 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
610 CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
612 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
615 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
616 return error("CTransaction::ReadFromDisk() : fseek failed");
621 catch (std::exception &e) {
622 return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
625 // Return file pointer
628 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
629 return error("CTransaction::ReadFromDisk() : second fseek failed");
630 *pfileRet = filein.release();
635 friend bool operator==(const CTransaction& a, const CTransaction& b)
637 return (a.nVersion == b.nVersion &&
638 a.nTime == b.nTime &&
641 a.nLockTime == b.nLockTime);
644 friend bool operator!=(const CTransaction& a, const CTransaction& b)
649 std::string ToStringShort() const
652 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
656 std::string ToString() const
659 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
660 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%" PRIszu ", vout.size=%" PRIszu ", nLockTime=%d)\n",
661 GetHash().ToString().substr(0,10).c_str(),
667 for (unsigned int i = 0; i < vin.size(); i++)
668 str += " " + vin[i].ToString() + "\n";
669 for (unsigned int i = 0; i < vout.size(); i++)
670 str += " " + vout[i].ToString() + "\n";
676 printf("%s", ToString().c_str());
680 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
681 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
682 bool ReadFromDisk(COutPoint prevout);
683 bool DisconnectInputs(CTxDB& txdb);
685 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
687 @param[in] txdb Transaction database
688 @param[in] mapTestPool List of pending changes to the transaction index database
689 @param[in] fBlock True if being called to add a new best-block to the chain
690 @param[in] fMiner True if being called by CreateNewBlock
691 @param[out] inputsRet Pointers to this transaction's inputs
692 @param[out] fInvalid returns true if transaction is invalid
693 @return Returns true if all inputs are in txdb or mapTestPool
695 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
696 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
698 /** Sanity check previous transactions, then, if all checks succeed,
699 mark them as spent by this transaction.
701 @param[in] inputs Previous transactions (from FetchInputs)
702 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
703 @param[in] posThisTx Position of this transaction on disk
704 @param[in] pindexBlock
705 @param[in] fBlock true if called from ConnectBlock
706 @param[in] fMiner true if called from CreateNewBlock
707 @param[in] fScriptChecks enable scripts validation?
708 @param[in] flags STRICT_FLAGS script validation flags
709 @param[in] pvChecks NULL If pvChecks is not NULL, script checks are pushed onto it instead of being performed inline.
710 @return Returns true if all checks succeed
712 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs, std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx, const CBlockIndex* pindexBlock,
713 bool fBlock, bool fMiner, bool fScriptChecks=true,
714 unsigned int flags=STRICT_FLAGS, std::vector<CScriptCheck> *pvChecks = NULL);
715 bool ClientConnectInputs();
716 bool CheckTransaction() const;
717 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
718 bool GetCoinAge(CTxDB& txdb, uint64_t& nCoinAge) const; // ppcoin: get transaction coin age
721 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
724 /** Closure representing one script verification
725 * Note that this stores references to the spending transaction */
729 CScript scriptPubKey;
730 const CTransaction *ptxTo;
737 CScriptCheck(const CTransaction& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, int nHashTypeIn) :
738 scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey),
739 ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), nHashType(nHashTypeIn) { }
741 bool operator()() const;
743 void swap(CScriptCheck &check) {
744 scriptPubKey.swap(check.scriptPubKey);
745 std::swap(ptxTo, check.ptxTo);
746 std::swap(nIn, check.nIn);
747 std::swap(nFlags, check.nFlags);
748 std::swap(nHashType, check.nHashType);
755 /** A transaction with a merkle branch linking it to the block chain. */
756 class CMerkleTx : public CTransaction
760 std::vector<uint256> vMerkleBranch;
764 mutable bool fMerkleVerified;
772 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
781 fMerkleVerified = false;
787 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
788 nVersion = this->nVersion;
789 READWRITE(hashBlock);
790 READWRITE(vMerkleBranch);
795 int SetMerkleBranch(const CBlock* pblock=NULL);
796 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
797 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
798 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
799 int GetBlocksToMaturity() const;
800 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
801 bool AcceptToMemoryPool();
807 /** A txdb record that contains the disk location of a transaction and the
808 * locations of transactions that spend its outputs. vSpent is really only
809 * used as a flag, but having the location is very helpful for debugging.
815 std::vector<CDiskTxPos> vSpent;
822 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
825 vSpent.resize(nOutputs);
830 if (!(nType & SER_GETHASH))
847 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
849 return (a.pos == b.pos &&
850 a.vSpent == b.vSpent);
853 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
857 int GetDepthInMainChain() const;
865 /** Nodes collect new transactions into a block, hash them into a hash tree,
866 * and scan through nonce values to make the block's hash satisfy proof-of-work
867 * requirements. When they solve the proof-of-work, they broadcast the block
868 * to everyone and the block is added to the block chain. The first transaction
869 * in the block is a special one that creates a new coin owned by the creator
872 * Blocks are appended to blk0001.dat files on disk. Their location on disk
873 * is indexed by CBlockIndex objects in memory.
879 static const int CURRENT_VERSION=6;
881 uint256 hashPrevBlock;
882 uint256 hashMerkleRoot;
888 std::vector<CTransaction> vtx;
890 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
891 std::vector<unsigned char> vchBlockSig;
894 mutable std::vector<uint256> vMerkleTree;
896 // Denial-of-service detection:
898 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
907 READWRITE(this->nVersion);
908 nVersion = this->nVersion;
909 READWRITE(hashPrevBlock);
910 READWRITE(hashMerkleRoot);
915 // ConnectBlock depends on vtx following header to generate CDiskTxPos
916 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
919 READWRITE(vchBlockSig);
923 const_cast<CBlock*>(this)->vtx.clear();
924 const_cast<CBlock*>(this)->vchBlockSig.clear();
930 nVersion = CBlock::CURRENT_VERSION;
947 uint256 GetHash() const
949 return scrypt_blockhash(CVOIDBEGIN(nVersion));
952 int64_t GetBlockTime() const
954 return (int64_t)nTime;
957 void UpdateTime(const CBlockIndex* pindexPrev);
959 // ppcoin: entropy bit for stake modifier if chosen by modifier
960 unsigned int GetStakeEntropyBit(unsigned int nTime) const
962 // Protocol switch to support p2pool at novacoin block #9689
963 if (nTime >= ENTROPY_SWITCH_TIME || fTestNet)
965 // Take last bit of block hash as entropy bit
966 unsigned int nEntropyBit = ((GetHash().Get64()) & 1ULL);
967 if (fDebug && GetBoolArg("-printstakemodifier"))
968 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
971 // Before novacoin block #9689 - old protocol
972 uint160 hashSig = Hash160(vchBlockSig);
973 if (fDebug && GetBoolArg("-printstakemodifier"))
974 printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
975 hashSig >>= 159; // take the first bit of the hash
976 if (fDebug && GetBoolArg("-printstakemodifier"))
977 printf(" entropybit=%" PRId64 "\n", hashSig.Get64());
978 return hashSig.Get64();
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 = 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 = 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 (std::exception &e) {
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 SignBlock(CWallet& keystore);
1142 bool CheckBlockSignature(bool fProofOfStake) const;
1145 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1153 /** The block chain is a tree shaped structure starting with the
1154 * genesis block at the root, with each block potentially having multiple
1155 * candidates to be the next block. pprev and pnext link a path through the
1156 * main/longest chain. A blockindex may have multiple pprev pointing back
1157 * to it, but pnext will only point forward to the longest branch, or will
1158 * be null if the block is not part of the longest chain.
1163 const uint256* phashBlock;
1167 unsigned int nBlockPos;
1168 uint256 nChainTrust; // ppcoin: trust score of block chain
1172 int64_t nMoneySupply;
1174 unsigned int nFlags; // ppcoin: block index flags
1177 BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1178 BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
1179 BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1182 uint64_t nStakeModifier; // hash modifier for proof-of-stake
1183 unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1185 // proof-of-stake specific fields
1186 COutPoint prevoutStake;
1187 unsigned int nStakeTime;
1188 uint256 hashProofOfStake;
1192 uint256 hashMerkleRoot;
1195 unsigned int nNonce;
1210 nStakeModifierChecksum = 0;
1211 hashProofOfStake = 0;
1212 prevoutStake.SetNull();
1222 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1228 nBlockPos = nBlockPosIn;
1235 nStakeModifierChecksum = 0;
1236 hashProofOfStake = 0;
1237 if (block.IsProofOfStake())
1240 prevoutStake = block.vtx[1].vin[0].prevout;
1241 nStakeTime = block.vtx[1].nTime;
1245 prevoutStake.SetNull();
1249 nVersion = block.nVersion;
1250 hashMerkleRoot = block.hashMerkleRoot;
1251 nTime = block.nTime;
1252 nBits = block.nBits;
1253 nNonce = block.nNonce;
1256 CBlock GetBlockHeader() const
1259 block.nVersion = nVersion;
1261 block.hashPrevBlock = pprev->GetBlockHash();
1262 block.hashMerkleRoot = hashMerkleRoot;
1263 block.nTime = nTime;
1264 block.nBits = nBits;
1265 block.nNonce = nNonce;
1269 uint256 GetBlockHash() const
1274 int64_t GetBlockTime() const
1276 return (int64_t)nTime;
1279 uint256 GetBlockTrust() const;
1281 bool IsInMainChain() const
1283 return (pnext || this == pindexBest);
1286 bool CheckIndex() const
1291 enum { nMedianTimeSpan=11 };
1293 int64_t GetMedianTimePast() const
1295 int64_t pmedian[nMedianTimeSpan];
1296 int64_t* pbegin = &pmedian[nMedianTimeSpan];
1297 int64_t* pend = &pmedian[nMedianTimeSpan];
1299 const CBlockIndex* pindex = this;
1300 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1301 *(--pbegin) = pindex->GetBlockTime();
1303 std::sort(pbegin, pend);
1304 return pbegin[(pend - pbegin)/2];
1307 int64_t GetMedianTime() const
1309 const CBlockIndex* pindex = this;
1310 for (int i = 0; i < nMedianTimeSpan/2; i++)
1313 return GetBlockTime();
1314 pindex = pindex->pnext;
1316 return pindex->GetMedianTimePast();
1320 * Returns true if there are nRequired or more blocks of minVersion or above
1321 * in the last nToCheck blocks, starting at pstart and going backwards.
1323 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1324 unsigned int nRequired, unsigned int nToCheck);
1327 bool IsProofOfWork() const
1329 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1332 bool IsProofOfStake() const
1334 return (nFlags & BLOCK_PROOF_OF_STAKE);
1337 void SetProofOfStake()
1339 nFlags |= BLOCK_PROOF_OF_STAKE;
1342 unsigned int GetStakeEntropyBit() const
1344 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1347 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1349 if (nEntropyBit > 1)
1351 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1355 bool GeneratedStakeModifier() const
1357 return (nFlags & BLOCK_STAKE_MODIFIER);
1360 void SetStakeModifier(uint64_t nModifier, bool fGeneratedStakeModifier)
1362 nStakeModifier = nModifier;
1363 if (fGeneratedStakeModifier)
1364 nFlags |= BLOCK_STAKE_MODIFIER;
1367 std::string ToString() const
1369 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)",
1370 pprev, pnext, nFile, nBlockPos, nHeight,
1371 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1372 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1373 nStakeModifier, nStakeModifierChecksum,
1374 hashProofOfStake.ToString().c_str(),
1375 prevoutStake.ToString().c_str(), nStakeTime,
1376 hashMerkleRoot.ToString().c_str(),
1377 GetBlockHash().ToString().c_str());
1382 printf("%s\n", ToString().c_str());
1388 /** Used to marshal pointers into hashes for db storage. */
1389 class CDiskBlockIndex : public CBlockIndex
1405 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1407 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1408 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1413 if (!(nType & SER_GETHASH))
1414 READWRITE(nVersion);
1416 READWRITE(hashNext);
1418 READWRITE(nBlockPos);
1421 READWRITE(nMoneySupply);
1423 READWRITE(nStakeModifier);
1424 if (IsProofOfStake())
1426 READWRITE(prevoutStake);
1427 READWRITE(nStakeTime);
1428 READWRITE(hashProofOfStake);
1432 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1433 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1434 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1438 READWRITE(this->nVersion);
1439 READWRITE(hashPrev);
1440 READWRITE(hashMerkleRoot);
1444 READWRITE(blockHash);
1447 uint256 GetBlockHash() const
1449 if (fUseFastIndex && (nTime < GetAdjustedTime() - 24 * 60 * 60) && blockHash != 0)
1453 block.nVersion = nVersion;
1454 block.hashPrevBlock = hashPrev;
1455 block.hashMerkleRoot = hashMerkleRoot;
1456 block.nTime = nTime;
1457 block.nBits = nBits;
1458 block.nNonce = nNonce;
1460 const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1465 std::string ToString() const
1467 std::string str = "CDiskBlockIndex(";
1468 str += CBlockIndex::ToString();
1469 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1470 GetBlockHash().ToString().c_str(),
1471 hashPrev.ToString().c_str(),
1472 hashNext.ToString().c_str());
1478 printf("%s\n", ToString().c_str());
1489 /** Describes a place in the block chain to another node such that if the
1490 * other node doesn't have the same branch, it can find a recent common trunk.
1491 * The further back it is, the further before the fork it may be.
1496 std::vector<uint256> vHave;
1503 explicit CBlockLocator(const CBlockIndex* pindex)
1508 explicit CBlockLocator(uint256 hashBlock)
1510 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1511 if (mi != mapBlockIndex.end())
1515 CBlockLocator(const std::vector<uint256>& vHaveIn)
1522 if (!(nType & SER_GETHASH))
1523 READWRITE(nVersion);
1534 return vHave.empty();
1537 void Set(const CBlockIndex* pindex)
1543 vHave.push_back(pindex->GetBlockHash());
1545 // Exponentially larger steps back
1546 for (int i = 0; pindex && i < nStep; i++)
1547 pindex = pindex->pprev;
1548 if (vHave.size() > 10)
1551 vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1554 int GetDistanceBack()
1556 // Retrace how far back it was in the sender's branch
1559 BOOST_FOREACH(const uint256& hash, vHave)
1561 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1562 if (mi != mapBlockIndex.end())
1564 CBlockIndex* pindex = (*mi).second;
1565 if (pindex->IsInMainChain())
1575 CBlockIndex* GetBlockIndex()
1577 // Find the first block the caller has in the main chain
1578 BOOST_FOREACH(const uint256& hash, vHave)
1580 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1581 if (mi != mapBlockIndex.end())
1583 CBlockIndex* pindex = (*mi).second;
1584 if (pindex->IsInMainChain())
1588 return pindexGenesisBlock;
1591 uint256 GetBlockHash()
1593 // Find the first block the caller has in the main chain
1594 BOOST_FOREACH(const uint256& hash, vHave)
1596 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1597 if (mi != mapBlockIndex.end())
1599 CBlockIndex* pindex = (*mi).second;
1600 if (pindex->IsInMainChain())
1604 return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1609 CBlockIndex* pindex = GetBlockIndex();
1612 return pindex->nHeight;
1626 mutable CCriticalSection cs;
1627 std::map<uint256, CTransaction> mapTx;
1628 std::map<COutPoint, CInPoint> mapNextTx;
1630 bool accept(CTxDB& txdb, CTransaction &tx,
1631 bool fCheckInputs, bool* pfMissingInputs);
1632 bool addUnchecked(const uint256& hash, CTransaction &tx);
1633 bool remove(CTransaction &tx);
1635 void queryHashes(std::vector<uint256>& vtxid);
1637 unsigned long size()
1640 return mapTx.size();
1643 bool exists(uint256 hash)
1645 return (mapTx.count(hash) != 0);
1648 CTransaction& lookup(uint256 hash)
1654 extern CTxMemPool mempool;