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;
98 extern const uint256 entropyStore[38];
100 // Minimum disk space required - used in CheckDiskSpace()
101 static const uint64_t nMinDiskSpace = 52428800;
108 void RegisterWallet(CWallet* pwalletIn);
109 void UnregisterWallet(CWallet* pwalletIn);
110 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
111 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
112 bool CheckDiskSpace(uint64_t nAdditionalBytes=0);
113 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
114 FILE* AppendBlockFile(unsigned int& nFileRet);
115 bool LoadBlockIndex(bool fAllowNew=true);
116 void PrintBlockTree();
117 CBlockIndex* FindBlockByHeight(int nHeight);
118 bool ProcessMessages(CNode* pfrom);
119 bool SendMessages(CNode* pto, bool fSendTrickle);
120 bool LoadExternalBlockFile(FILE* fileIn);
122 // Run an instance of the script checking thread
123 void ThreadScriptCheck(void* parg);
124 // Stop the script checking threads
125 void ThreadScriptCheckQuit();
127 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
128 unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, bool fProofOfStake);
129 int64_t GetProofOfWorkReward(unsigned int nBits, int64_t nFees=0);
130 int64_t GetProofOfStakeReward(int64_t nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly=false);
131 unsigned int ComputeMinWork(unsigned int nBase, int64_t nTime);
132 unsigned int ComputeMinStake(unsigned int nBase, int64_t nTime, unsigned int nBlockTime);
133 int GetNumBlocksOfPeers();
134 bool IsInitialBlockDownload();
135 std::string GetWarnings(std::string strFor);
136 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
137 uint256 WantedByOrphan(const CBlock* pblockOrphan);
138 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
139 void StakeMiner(CWallet *pwallet);
140 void ResendWalletTransactions();
142 bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType);
150 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
152 /** Position on disk for a particular transaction. */
165 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
168 nBlockPos = nBlockPosIn;
172 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
173 void SetNull() { nFile = (unsigned int) -1; nBlockPos = 0; nTxPos = 0; }
174 bool IsNull() const { return (nFile == (unsigned int) -1); }
176 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
178 return (a.nFile == b.nFile &&
179 a.nBlockPos == b.nBlockPos &&
180 a.nTxPos == b.nTxPos);
183 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
189 std::string ToString() const
194 return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
199 printf("%s", ToString().c_str());
205 /** An inpoint - a combination of a transaction and an index n into its vin */
212 CInPoint() { SetNull(); }
213 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
214 void SetNull() { ptx = NULL; n = (unsigned int) -1; }
215 bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
220 /** An outpoint - a combination of a transaction hash and an index n into its vout */
227 COutPoint() { SetNull(); }
228 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
229 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
230 void SetNull() { hash = 0; n = (unsigned int) -1; }
231 bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
233 friend bool operator<(const COutPoint& a, const COutPoint& b)
235 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
238 friend bool operator==(const COutPoint& a, const COutPoint& b)
240 return (a.hash == b.hash && a.n == b.n);
243 friend bool operator!=(const COutPoint& a, const COutPoint& b)
248 std::string ToString() const
250 return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
255 printf("%s\n", ToString().c_str());
262 /** An input of a transaction. It contains the location of the previous
263 * transaction's output that it claims and a signature that matches the
264 * output's public key.
275 nSequence = std::numeric_limits<unsigned int>::max();
278 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
281 scriptSig = scriptSigIn;
282 nSequence = nSequenceIn;
285 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
287 prevout = COutPoint(hashPrevTx, nOut);
288 scriptSig = scriptSigIn;
289 nSequence = nSequenceIn;
295 READWRITE(scriptSig);
296 READWRITE(nSequence);
301 return (nSequence == std::numeric_limits<unsigned int>::max());
304 friend bool operator==(const CTxIn& a, const CTxIn& b)
306 return (a.prevout == b.prevout &&
307 a.scriptSig == b.scriptSig &&
308 a.nSequence == b.nSequence);
311 friend bool operator!=(const CTxIn& a, const CTxIn& b)
316 std::string ToStringShort() const
318 return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
321 std::string ToString() const
325 str += prevout.ToString();
326 if (prevout.IsNull())
327 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
329 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
330 if (nSequence != std::numeric_limits<unsigned int>::max())
331 str += strprintf(", nSequence=%u", nSequence);
338 printf("%s\n", ToString().c_str());
345 /** An output of a transaction. It contains the public key that the next input
346 * must be able to sign with to claim it.
352 CScript scriptPubKey;
359 CTxOut(int64_t nValueIn, CScript scriptPubKeyIn)
362 scriptPubKey = scriptPubKeyIn;
368 READWRITE(scriptPubKey);
374 scriptPubKey.clear();
379 return (nValue == -1);
385 scriptPubKey.clear();
390 return (nValue == 0 && scriptPubKey.empty());
393 uint256 GetHash() const
395 return SerializeHash(*this);
398 friend bool operator==(const CTxOut& a, const CTxOut& b)
400 return (a.nValue == b.nValue &&
401 a.scriptPubKey == b.scriptPubKey);
404 friend bool operator!=(const CTxOut& a, const CTxOut& b)
409 std::string ToStringShort() const
411 return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
414 std::string ToString() const
416 if (IsEmpty()) return "CTxOut(empty)";
417 if (scriptPubKey.size() < 6)
418 return "CTxOut(error)";
419 return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
424 printf("%s\n", ToString().c_str());
438 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
440 /** The basic transaction that is broadcasted on the network and contained in
441 * blocks. A transaction can contain multiple inputs and outputs.
446 static const int CURRENT_VERSION=1;
449 std::vector<CTxIn> vin;
450 std::vector<CTxOut> vout;
453 // Denial-of-service detection:
455 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
464 READWRITE(this->nVersion);
465 nVersion = this->nVersion;
469 READWRITE(nLockTime);
474 nVersion = CTransaction::CURRENT_VERSION;
475 nTime = (uint32_t) GetAdjustedTime();
479 nDoS = 0; // Denial-of-service prevention
484 return (vin.empty() && vout.empty());
487 uint256 GetHash() const
489 return SerializeHash(*this);
492 bool IsFinal(int nBlockHeight=0, int64_t nBlockTime=0) const
494 // Time based nLockTime implemented in 0.1.6
497 if (nBlockHeight == 0)
498 nBlockHeight = nBestHeight;
500 nBlockTime = GetAdjustedTime();
501 if ((int64_t)nLockTime < ((int64_t)nLockTime < LOCKTIME_THRESHOLD ? (int64_t)nBlockHeight : nBlockTime))
503 BOOST_FOREACH(const CTxIn& txin, vin)
509 bool IsNewerThan(const CTransaction& old) const
511 if (vin.size() != old.vin.size())
513 for (unsigned int i = 0; i < vin.size(); i++)
514 if (vin[i].prevout != old.vin[i].prevout)
518 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
519 for (unsigned int i = 0; i < vin.size(); i++)
521 if (vin[i].nSequence != old.vin[i].nSequence)
523 if (vin[i].nSequence <= nLowest)
526 nLowest = vin[i].nSequence;
528 if (old.vin[i].nSequence < nLowest)
531 nLowest = old.vin[i].nSequence;
538 bool IsCoinBase() const
540 return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
543 bool IsCoinStake() const
545 // ppcoin: the coin stake transaction is marked with the first output empty
546 return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
549 /** Check for standard transaction types
550 @return True if all outputs (scriptPubKeys) use only standard transaction forms
552 bool IsStandard(std::string& strReason) const;
553 bool IsStandard() const
555 std::string strReason;
556 return IsStandard(strReason);
559 /** Check for standard transaction types
560 @param[in] mapInputs Map of previous transactions that have outputs we're spending
561 @return True if all inputs (scriptSigs) use only standard transaction forms
562 @see CTransaction::FetchInputs
564 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
566 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
567 @return number of sigops this transaction's outputs will produce when spent
568 @see CTransaction::FetchInputs
570 unsigned int GetLegacySigOpCount() const;
572 /** Count ECDSA signature operations in pay-to-script-hash inputs.
574 @param[in] mapInputs Map of previous transactions that have outputs we're spending
575 @return maximum number of sigops required to validate this transaction's inputs
576 @see CTransaction::FetchInputs
578 unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
580 /** Amount of bitcoins spent by this transaction.
581 @return sum of all outputs (note: does not include fees)
583 int64_t GetValueOut() const
585 int64_t nValueOut = 0;
586 BOOST_FOREACH(const CTxOut& txout, vout)
588 nValueOut += txout.nValue;
589 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
590 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
595 /** Amount of bitcoins coming in to this transaction
596 Note that lightweight clients may not know anything besides the hash of previous transactions,
597 so may not be able to calculate this.
599 @param[in] mapInputs Map of previous transactions that have outputs we're spending
600 @return Sum of value of all inputs (scriptSigs)
601 @see CTransaction::FetchInputs
603 int64_t GetValueIn(const MapPrevTx& mapInputs) const;
605 static bool AllowFree(double dPriority)
607 // Large (in bytes) low-priority (new, small-coin) transactions
609 return dPriority > COIN * 144 / 250;
612 int64_t GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK, unsigned int nBytes = 0) const;
614 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
616 CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
618 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
621 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
622 return error("CTransaction::ReadFromDisk() : fseek failed");
627 catch (std::exception &e) {
629 return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
632 // Return file pointer
635 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
636 return error("CTransaction::ReadFromDisk() : second fseek failed");
637 *pfileRet = filein.release();
642 friend bool operator==(const CTransaction& a, const CTransaction& b)
644 return (a.nVersion == b.nVersion &&
645 a.nTime == b.nTime &&
648 a.nLockTime == b.nLockTime);
651 friend bool operator!=(const CTransaction& a, const CTransaction& b)
656 std::string ToStringShort() const
659 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
663 std::string ToString() const
666 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
667 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%" PRIszu ", vout.size=%" PRIszu ", nLockTime=%d)\n",
668 GetHash().ToString().substr(0,10).c_str(),
674 for (unsigned int i = 0; i < vin.size(); i++)
675 str += " " + vin[i].ToString() + "\n";
676 for (unsigned int i = 0; i < vout.size(); i++)
677 str += " " + vout[i].ToString() + "\n";
683 printf("%s", ToString().c_str());
687 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
688 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
689 bool ReadFromDisk(COutPoint prevout);
690 bool DisconnectInputs(CTxDB& txdb);
692 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
694 @param[in] txdb Transaction database
695 @param[in] mapTestPool List of pending changes to the transaction index database
696 @param[in] fBlock True if being called to add a new best-block to the chain
697 @param[in] fMiner True if being called by CreateNewBlock
698 @param[out] inputsRet Pointers to this transaction's inputs
699 @param[out] fInvalid returns true if transaction is invalid
700 @return Returns true if all inputs are in txdb or mapTestPool
702 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
703 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
705 /** Sanity check previous transactions, then, if all checks succeed,
706 mark them as spent by this transaction.
708 @param[in] inputs Previous transactions (from FetchInputs)
709 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
710 @param[in] posThisTx Position of this transaction on disk
711 @param[in] pindexBlock
712 @param[in] fBlock true if called from ConnectBlock
713 @param[in] fMiner true if called from CreateNewBlock
714 @param[in] fScriptChecks enable scripts validation?
715 @param[in] flags STRICT_FLAGS script validation flags
716 @param[in] pvChecks NULL If pvChecks is not NULL, script checks are pushed onto it instead of being performed inline.
717 @return Returns true if all checks succeed
719 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs, std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx, const CBlockIndex* pindexBlock,
720 bool fBlock, bool fMiner, bool fScriptChecks=true,
721 unsigned int flags=STRICT_FLAGS, std::vector<CScriptCheck> *pvChecks = NULL);
722 bool ClientConnectInputs();
723 bool CheckTransaction() const;
724 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
725 bool GetCoinAge(CTxDB& txdb, uint64_t& nCoinAge) const; // ppcoin: get transaction coin age
728 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
731 /** Closure representing one script verification
732 * Note that this stores references to the spending transaction */
736 CScript scriptPubKey;
737 const CTransaction *ptxTo;
744 CScriptCheck(const CTransaction& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, int nHashTypeIn) :
745 scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey),
746 ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), nHashType(nHashTypeIn) { }
748 bool operator()() const;
750 void swap(CScriptCheck &check) {
751 scriptPubKey.swap(check.scriptPubKey);
752 std::swap(ptxTo, check.ptxTo);
753 std::swap(nIn, check.nIn);
754 std::swap(nFlags, check.nFlags);
755 std::swap(nHashType, check.nHashType);
762 /** A transaction with a merkle branch linking it to the block chain. */
763 class CMerkleTx : public CTransaction
767 std::vector<uint256> vMerkleBranch;
771 mutable bool fMerkleVerified;
779 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
788 fMerkleVerified = false;
794 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
795 nVersion = this->nVersion;
796 READWRITE(hashBlock);
797 READWRITE(vMerkleBranch);
802 int SetMerkleBranch(const CBlock* pblock=NULL);
803 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
804 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
805 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
806 int GetBlocksToMaturity() const;
807 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
808 bool AcceptToMemoryPool();
814 /** A txdb record that contains the disk location of a transaction and the
815 * locations of transactions that spend its outputs. vSpent is really only
816 * used as a flag, but having the location is very helpful for debugging.
822 std::vector<CDiskTxPos> vSpent;
829 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
832 vSpent.resize(nOutputs);
837 if (!(nType & SER_GETHASH))
854 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
856 return (a.pos == b.pos &&
857 a.vSpent == b.vSpent);
860 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
864 int GetDepthInMainChain() const;
869 /** Nodes collect new transactions into a block, hash them into a hash tree,
870 * and scan through nonce values to make the block's hash satisfy proof-of-work
871 * requirements. When they solve the proof-of-work, they broadcast the block
872 * to everyone and the block is added to the block chain. The first transaction
873 * in the block is a special one that creates a new coin owned by the creator
876 * Blocks are appended to blk0001.dat files on disk. Their location on disk
877 * is indexed by CBlockIndex objects in memory.
883 static const int CURRENT_VERSION=6;
885 uint256 hashPrevBlock;
886 uint256 hashMerkleRoot;
892 std::vector<CTransaction> vtx;
894 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
895 std::vector<unsigned char> vchBlockSig;
898 mutable std::vector<uint256> vMerkleTree;
900 // Denial-of-service detection:
902 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
911 READWRITE(this->nVersion);
912 nVersion = this->nVersion;
913 READWRITE(hashPrevBlock);
914 READWRITE(hashMerkleRoot);
919 // ConnectBlock depends on vtx following header to generate CDiskTxPos
920 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
923 READWRITE(vchBlockSig);
927 const_cast<CBlock*>(this)->vtx.clear();
928 const_cast<CBlock*>(this)->vchBlockSig.clear();
934 nVersion = CBlock::CURRENT_VERSION;
951 uint256 GetHash() const
953 return scrypt_blockhash((const uint8_t*)&nVersion);
956 int64_t GetBlockTime() const
958 return (int64_t)nTime;
961 void UpdateTime(const CBlockIndex* pindexPrev);
963 // ppcoin: entropy bit for stake modifier if chosen by modifier
964 unsigned int GetStakeEntropyBit(unsigned int nHeight) const
966 // Protocol switch to support p2pool at novacoin block #9689
967 if (nHeight >= 9689 || fTestNet)
969 // Take last bit of block hash as entropy bit
970 unsigned int nEntropyBit = ((GetHash().Get64()) & 1ULL);
971 if (fDebug && GetBoolArg("-printstakemodifier"))
972 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
976 // Before novacoin block #9689 - get from pregenerated table
977 int nBitNum = nHeight & 0xFF;
978 int nItemNum = nHeight / 0xFF;
980 unsigned int nEntropyBit = (unsigned int) ((entropyStore[nItemNum] & (uint256(1) << nBitNum)) >> nBitNum).Get64();
981 if (fDebug && GetBoolArg("-printstakemodifier"))
982 printf("GetStakeEntropyBit: from pregenerated table, nHeight=%d nEntropyBit=%u\n", nHeight, nEntropyBit);
986 // ppcoin: two types of block: proof-of-work or proof-of-stake
987 bool IsProofOfStake() const
989 return (vtx.size() > 1 && vtx[1].IsCoinStake());
992 bool IsProofOfWork() const
994 return !IsProofOfStake();
997 std::pair<COutPoint, unsigned int> GetProofOfStake() const
999 return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
1002 // ppcoin: get max transaction timestamp
1003 int64_t GetMaxTransactionTime() const
1005 int64_t maxTransactionTime = 0;
1006 BOOST_FOREACH(const CTransaction& tx, vtx)
1007 maxTransactionTime = std::max(maxTransactionTime, (int64_t)tx.nTime);
1008 return maxTransactionTime;
1011 uint256 BuildMerkleTree() const
1013 vMerkleTree.clear();
1014 BOOST_FOREACH(const CTransaction& tx, vtx)
1015 vMerkleTree.push_back(tx.GetHash());
1017 for (int nSize = (int)vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1019 for (int i = 0; i < nSize; i += 2)
1021 int i2 = std::min(i+1, nSize-1);
1022 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
1023 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
1027 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
1030 std::vector<uint256> GetMerkleBranch(int nIndex) const
1032 if (vMerkleTree.empty())
1034 std::vector<uint256> vMerkleBranch;
1036 for (int nSize = (int)vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1038 int i = std::min(nIndex^1, nSize-1);
1039 vMerkleBranch.push_back(vMerkleTree[j+i]);
1043 return vMerkleBranch;
1046 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1050 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1053 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1055 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1062 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1064 // Open history file to append
1065 CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1067 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1069 // Write index header
1070 unsigned int nSize = fileout.GetSerializeSize(*this);
1071 fileout << FLATDATA(pchMessageStart) << nSize;
1074 long fileOutPos = ftell(fileout);
1076 return error("CBlock::WriteToDisk() : ftell failed");
1077 nBlockPosRet = fileOutPos;
1080 // Flush stdio buffers and commit to disk before returning
1082 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1083 FileCommit(fileout);
1088 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1092 // Open history file to read
1093 CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1095 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1096 if (!fReadTransactions)
1097 filein.nType |= SER_BLOCKHEADERONLY;
1103 catch (std::exception &e) {
1105 return error("%s() : deserialize or I/O error", BOOST_CURRENT_FUNCTION);
1109 if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1110 return error("CBlock::ReadFromDisk() : errors in block header");
1119 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%" PRIszu ", vchBlockSig=%s)\n",
1120 GetHash().ToString().c_str(),
1122 hashPrevBlock.ToString().c_str(),
1123 hashMerkleRoot.ToString().c_str(),
1124 nTime, nBits, nNonce,
1126 HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1127 for (unsigned int i = 0; i < vtx.size(); i++)
1132 printf(" vMerkleTree: ");
1133 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1134 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1139 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1140 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1141 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1142 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1143 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1144 bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1146 bool GetCoinAge(uint64_t& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1147 bool SignBlock(CWallet& keystore);
1148 bool CheckBlockSignature() const;
1151 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1159 /** The block chain is a tree shaped structure starting with the
1160 * genesis block at the root, with each block potentially having multiple
1161 * candidates to be the next block. pprev and pnext link a path through the
1162 * main/longest chain. A blockindex may have multiple pprev pointing back
1163 * to it, but pnext will only point forward to the longest branch, or will
1164 * be null if the block is not part of the longest chain.
1169 const uint256* phashBlock;
1174 uint256 nChainTrust; // ppcoin: trust score of block chain
1178 int64_t nMoneySupply;
1180 uint32_t nFlags; // ppcoin: block index flags
1183 BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1184 BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
1185 BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1188 uint64_t nStakeModifier; // hash modifier for proof-of-stake
1189 uint32_t nStakeModifierChecksum; // checksum of index; in-memeory only
1191 // proof-of-stake specific fields
1192 COutPoint prevoutStake;
1193 uint32_t nStakeTime;
1194 uint256 hashProofOfStake;
1198 uint256 hashMerkleRoot;
1216 nStakeModifierChecksum = 0;
1217 hashProofOfStake = 0;
1218 prevoutStake.SetNull();
1228 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1234 nBlockPos = nBlockPosIn;
1241 nStakeModifierChecksum = 0;
1242 hashProofOfStake = 0;
1243 if (block.IsProofOfStake())
1246 prevoutStake = block.vtx[1].vin[0].prevout;
1247 nStakeTime = block.vtx[1].nTime;
1251 prevoutStake.SetNull();
1255 nVersion = block.nVersion;
1256 hashMerkleRoot = block.hashMerkleRoot;
1257 nTime = block.nTime;
1258 nBits = block.nBits;
1259 nNonce = block.nNonce;
1262 CBlock GetBlockHeader() const
1265 block.nVersion = nVersion;
1267 block.hashPrevBlock = pprev->GetBlockHash();
1268 block.hashMerkleRoot = hashMerkleRoot;
1269 block.nTime = nTime;
1270 block.nBits = nBits;
1271 block.nNonce = nNonce;
1275 uint256 GetBlockHash() const
1280 int64_t GetBlockTime() const
1282 return (int64_t)nTime;
1285 uint256 GetBlockTrust() const;
1287 bool IsInMainChain() const
1289 return (pnext || this == pindexBest);
1292 bool CheckIndex() const
1297 enum { nMedianTimeSpan=11 };
1299 int64_t GetMedianTimePast() const
1301 int64_t pmedian[nMedianTimeSpan];
1302 int64_t* pbegin = &pmedian[nMedianTimeSpan];
1303 int64_t* pend = &pmedian[nMedianTimeSpan];
1305 const CBlockIndex* pindex = this;
1306 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1307 *(--pbegin) = pindex->GetBlockTime();
1309 std::sort(pbegin, pend);
1310 return pbegin[(pend - pbegin)/2];
1313 int64_t GetMedianTime() const
1315 const CBlockIndex* pindex = this;
1316 for (int i = 0; i < nMedianTimeSpan/2; i++)
1319 return GetBlockTime();
1320 pindex = pindex->pnext;
1322 return pindex->GetMedianTimePast();
1326 * Returns true if there are nRequired or more blocks of minVersion or above
1327 * in the last nToCheck blocks, starting at pstart and going backwards.
1329 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1330 unsigned int nRequired, unsigned int nToCheck);
1333 bool IsProofOfWork() const
1335 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1338 bool IsProofOfStake() const
1340 return (nFlags & BLOCK_PROOF_OF_STAKE);
1343 void SetProofOfStake()
1345 nFlags |= BLOCK_PROOF_OF_STAKE;
1348 unsigned int GetStakeEntropyBit() const
1350 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1353 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1355 if (nEntropyBit > 1)
1357 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1361 bool GeneratedStakeModifier() const
1363 return (nFlags & BLOCK_STAKE_MODIFIER) != 0;
1366 void SetStakeModifier(uint64_t nModifier, bool fGeneratedStakeModifier)
1368 nStakeModifier = nModifier;
1369 if (fGeneratedStakeModifier)
1370 nFlags |= BLOCK_STAKE_MODIFIER;
1373 std::string ToString() const
1375 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)",
1376 pprev, pnext, nFile, nBlockPos, nHeight,
1377 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1378 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1379 nStakeModifier, nStakeModifierChecksum,
1380 hashProofOfStake.ToString().c_str(),
1381 prevoutStake.ToString().c_str(), nStakeTime,
1382 hashMerkleRoot.ToString().c_str(),
1383 GetBlockHash().ToString().c_str());
1388 printf("%s\n", ToString().c_str());
1394 /** Used to marshal pointers into hashes for db storage. */
1395 class CDiskBlockIndex : public CBlockIndex
1411 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1413 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1414 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1419 if (!(nType & SER_GETHASH))
1420 READWRITE(nVersion);
1422 READWRITE(hashNext);
1424 READWRITE(nBlockPos);
1427 READWRITE(nMoneySupply);
1429 READWRITE(nStakeModifier);
1430 if (IsProofOfStake())
1432 READWRITE(prevoutStake);
1433 READWRITE(nStakeTime);
1434 READWRITE(hashProofOfStake);
1438 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1439 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1440 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1444 READWRITE(this->nVersion);
1445 READWRITE(hashPrev);
1446 READWRITE(hashMerkleRoot);
1450 READWRITE(blockHash);
1453 uint256 GetBlockHash() const
1455 if (fUseFastIndex && (nTime < GetAdjustedTime() - 24 * 60 * 60) && blockHash != 0)
1459 block.nVersion = nVersion;
1460 block.hashPrevBlock = hashPrev;
1461 block.hashMerkleRoot = hashMerkleRoot;
1462 block.nTime = nTime;
1463 block.nBits = nBits;
1464 block.nNonce = nNonce;
1466 const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1471 std::string ToString() const
1473 std::string str = "CDiskBlockIndex(";
1474 str += CBlockIndex::ToString();
1475 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1476 GetBlockHash().ToString().c_str(),
1477 hashPrev.ToString().c_str(),
1478 hashNext.ToString().c_str());
1484 printf("%s\n", ToString().c_str());
1495 /** Describes a place in the block chain to another node such that if the
1496 * other node doesn't have the same branch, it can find a recent common trunk.
1497 * The further back it is, the further before the fork it may be.
1502 std::vector<uint256> vHave;
1509 explicit CBlockLocator(const CBlockIndex* pindex)
1514 explicit CBlockLocator(uint256 hashBlock)
1516 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1517 if (mi != mapBlockIndex.end())
1521 CBlockLocator(const std::vector<uint256>& vHaveIn)
1528 if (!(nType & SER_GETHASH))
1529 READWRITE(nVersion);
1540 return vHave.empty();
1543 void Set(const CBlockIndex* pindex)
1549 vHave.push_back(pindex->GetBlockHash());
1551 // Exponentially larger steps back
1552 for (int i = 0; pindex && i < nStep; i++)
1553 pindex = pindex->pprev;
1554 if (vHave.size() > 10)
1557 vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1560 int GetDistanceBack()
1562 // Retrace how far back it was in the sender's branch
1565 BOOST_FOREACH(const uint256& hash, vHave)
1567 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1568 if (mi != mapBlockIndex.end())
1570 CBlockIndex* pindex = (*mi).second;
1571 if (pindex->IsInMainChain())
1581 CBlockIndex* GetBlockIndex()
1583 // Find the first block the caller has in the main chain
1584 BOOST_FOREACH(const uint256& hash, vHave)
1586 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1587 if (mi != mapBlockIndex.end())
1589 CBlockIndex* pindex = (*mi).second;
1590 if (pindex->IsInMainChain())
1594 return pindexGenesisBlock;
1597 uint256 GetBlockHash()
1599 // Find the first block the caller has in the main chain
1600 BOOST_FOREACH(const uint256& hash, vHave)
1602 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1603 if (mi != mapBlockIndex.end())
1605 CBlockIndex* pindex = (*mi).second;
1606 if (pindex->IsInMainChain())
1610 return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1615 CBlockIndex* pindex = GetBlockIndex();
1618 return pindex->nHeight;
1632 mutable CCriticalSection cs;
1633 std::map<uint256, CTransaction> mapTx;
1634 std::map<COutPoint, CInPoint> mapNextTx;
1636 bool accept(CTxDB& txdb, CTransaction &tx,
1637 bool fCheckInputs, bool* pfMissingInputs);
1638 bool addUnchecked(const uint256& hash, CTransaction &tx);
1639 bool remove(CTransaction &tx);
1641 void queryHashes(std::vector<uint256>& vtxid);
1646 return mapTx.size();
1649 bool exists(uint256 hash)
1651 return (mapTx.count(hash) != 0);
1654 CTransaction& lookup(uint256 hash)
1660 extern CTxMemPool mempool;