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.
8 #include "timestamps.h"
14 #include "zerocoin/Zerocoin.h"
27 class CRequestTracker;
30 static const unsigned int MAX_BLOCK_SIZE = 1000000;
31 static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
32 static const unsigned int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
33 static const unsigned int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
34 static const unsigned int MAX_INV_SZ = 50000;
36 static const int64 MIN_TX_FEE = CENT/10;
37 static const int64 MIN_RELAY_TX_FEE = CENT/50;
39 static const int64 MAX_MONEY = 2000000000 * COIN;
40 static const int64 MAX_MINT_PROOF_OF_WORK = 100 * COIN;
41 static const int64 MAX_MINT_PROOF_OF_STAKE = 1 * COIN;
42 static const int64 MIN_TXOUT_AMOUNT = CENT/100;
44 inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
45 // Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
46 static const unsigned int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
47 // Maximum number of script-checking threads allowed
48 static const int MAX_SCRIPTCHECK_THREADS = 16;
51 static const int fHaveUPnP = true;
53 static const int fHaveUPnP = false;
56 static const uint256 hashGenesisBlock("0x00000a060336cbb72fe969666d337b87198b1add2abaa59cca226820b32933a4");
57 static const uint256 hashGenesisBlockTestNet("0x000c763e402f2436da9ed36c7286f62c3f6e5dbafce9ff289bd43d7459327eb");
59 inline int64 PastDrift(int64 nTime) { return nTime - 2 * 60 * 60; } // up to 2 hours from the past
60 inline int64 FutureDrift(int64 nTime) { return nTime + 2 * 60 * 60; } // up to 2 hours from the future
62 extern libzerocoin::Params* ZCParams;
63 extern CScript COINBASE_FLAGS;
64 extern CCriticalSection cs_main;
65 extern std::map<uint256, CBlockIndex*> mapBlockIndex;
66 extern std::set<std::pair<COutPoint, unsigned int> > setStakeSeen;
67 extern CBlockIndex* pindexGenesisBlock;
68 extern unsigned int nStakeMinAge;
69 extern unsigned int nNodeLifespan;
70 extern int nCoinbaseMaturity;
71 extern int nBestHeight;
72 extern uint256 nBestChainTrust;
73 extern uint256 nBestInvalidTrust;
74 extern uint256 hashBestChain;
75 extern CBlockIndex* pindexBest;
76 extern unsigned int nTransactionsUpdated;
77 extern uint64 nLastBlockTx;
78 extern uint64 nLastBlockSize;
79 extern int64 nLastCoinStakeSearchInterval;
80 extern const std::string strMessageMagic;
81 extern int64 nTimeBestReceived;
82 extern CCriticalSection cs_setpwalletRegistered;
83 extern std::set<CWallet*> setpwalletRegistered;
84 extern unsigned char pchMessageStart[4];
85 extern std::map<uint256, CBlock*> mapOrphanBlocks;
88 extern int64 nTransactionFee;
89 extern int64 nMinimumInputValue;
90 extern bool fUseFastIndex;
91 extern unsigned int nDerivationMethodIndex;
92 extern int nScriptCheckThreads;
94 // Minimum disk space required - used in CheckDiskSpace()
95 static const uint64 nMinDiskSpace = 52428800;
102 void RegisterWallet(CWallet* pwalletIn);
103 void UnregisterWallet(CWallet* pwalletIn);
104 void SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false, bool fConnect = true);
105 bool ProcessBlock(CNode* pfrom, CBlock* pblock);
106 bool CheckDiskSpace(uint64 nAdditionalBytes=0);
107 FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
108 FILE* AppendBlockFile(unsigned int& nFileRet);
109 bool LoadBlockIndex(bool fAllowNew=true);
110 void PrintBlockTree();
111 CBlockIndex* FindBlockByHeight(int nHeight);
112 bool ProcessMessages(CNode* pfrom);
113 bool SendMessages(CNode* pto, bool fSendTrickle);
114 bool LoadExternalBlockFile(FILE* fileIn);
116 // Run an instance of the script checking thread
117 void ThreadScriptCheck(void* parg);
118 // Stop the script checking threads
119 void ThreadScriptCheckQuit();
121 bool CheckProofOfWork(uint256 hash, unsigned int nBits);
122 unsigned int GetNextTargetRequired(const CBlockIndex* pindexLast, bool fProofOfStake);
123 int64 GetProofOfWorkReward(unsigned int nBits, int64 nFees=0);
124 int64 GetProofOfStakeReward(int64 nCoinAge, unsigned int nBits, unsigned int nTime, bool bCoinYearOnly=false);
125 unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
126 unsigned int ComputeMinStake(unsigned int nBase, int64 nTime, unsigned int nBlockTime);
127 int GetNumBlocksOfPeers();
128 bool IsInitialBlockDownload();
129 std::string GetWarnings(std::string strFor);
130 bool GetTransaction(const uint256 &hash, CTransaction &tx, uint256 &hashBlock);
131 uint256 WantedByOrphan(const CBlock* pblockOrphan);
132 const CBlockIndex* GetLastBlockIndex(const CBlockIndex* pindex, bool fProofOfStake);
133 void StakeMiner(CWallet *pwallet);
134 void ResendWalletTransactions();
136 bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType);
144 bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
146 /** Position on disk for a particular transaction. */
151 unsigned int nBlockPos;
159 CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
162 nBlockPos = nBlockPosIn;
166 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
167 void SetNull() { nFile = (unsigned int) -1; nBlockPos = 0; nTxPos = 0; }
168 bool IsNull() const { return (nFile == (unsigned int) -1); }
170 friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
172 return (a.nFile == b.nFile &&
173 a.nBlockPos == b.nBlockPos &&
174 a.nTxPos == b.nTxPos);
177 friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
183 std::string ToString() const
188 return strprintf("(nFile=%u, nBlockPos=%u, nTxPos=%u)", nFile, nBlockPos, nTxPos);
193 printf("%s", ToString().c_str());
199 /** An inpoint - a combination of a transaction and an index n into its vin */
206 CInPoint() { SetNull(); }
207 CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
208 void SetNull() { ptx = NULL; n = (unsigned int) -1; }
209 bool IsNull() const { return (ptx == NULL && n == (unsigned int) -1); }
214 /** An outpoint - a combination of a transaction hash and an index n into its vout */
221 COutPoint() { SetNull(); }
222 COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
223 IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
224 void SetNull() { hash = 0; n = (unsigned int) -1; }
225 bool IsNull() const { return (hash == 0 && n == (unsigned int) -1); }
227 friend bool operator<(const COutPoint& a, const COutPoint& b)
229 return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
232 friend bool operator==(const COutPoint& a, const COutPoint& b)
234 return (a.hash == b.hash && a.n == b.n);
237 friend bool operator!=(const COutPoint& a, const COutPoint& b)
242 std::string ToString() const
244 return strprintf("COutPoint(%s, %u)", hash.ToString().substr(0,10).c_str(), n);
249 printf("%s\n", ToString().c_str());
256 /** An input of a transaction. It contains the location of the previous
257 * transaction's output that it claims and a signature that matches the
258 * output's public key.
265 unsigned int nSequence;
269 nSequence = std::numeric_limits<unsigned int>::max();
272 explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
275 scriptSig = scriptSigIn;
276 nSequence = nSequenceIn;
279 CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=std::numeric_limits<unsigned int>::max())
281 prevout = COutPoint(hashPrevTx, nOut);
282 scriptSig = scriptSigIn;
283 nSequence = nSequenceIn;
289 READWRITE(scriptSig);
290 READWRITE(nSequence);
295 return (nSequence == std::numeric_limits<unsigned int>::max());
298 friend bool operator==(const CTxIn& a, const CTxIn& b)
300 return (a.prevout == b.prevout &&
301 a.scriptSig == b.scriptSig &&
302 a.nSequence == b.nSequence);
305 friend bool operator!=(const CTxIn& a, const CTxIn& b)
310 std::string ToStringShort() const
312 return strprintf(" %s %d", prevout.hash.ToString().c_str(), prevout.n);
315 std::string ToString() const
319 str += prevout.ToString();
320 if (prevout.IsNull())
321 str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
323 str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
324 if (nSequence != std::numeric_limits<unsigned int>::max())
325 str += strprintf(", nSequence=%u", nSequence);
332 printf("%s\n", ToString().c_str());
339 /** An output of a transaction. It contains the public key that the next input
340 * must be able to sign with to claim it.
346 CScript scriptPubKey;
353 CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
356 scriptPubKey = scriptPubKeyIn;
362 READWRITE(scriptPubKey);
368 scriptPubKey.clear();
373 return (nValue == -1);
379 scriptPubKey.clear();
384 return (nValue == 0 && scriptPubKey.empty());
387 uint256 GetHash() const
389 return SerializeHash(*this);
392 friend bool operator==(const CTxOut& a, const CTxOut& b)
394 return (a.nValue == b.nValue &&
395 a.scriptPubKey == b.scriptPubKey);
398 friend bool operator!=(const CTxOut& a, const CTxOut& b)
403 std::string ToStringShort() const
405 return strprintf(" out %s %s", FormatMoney(nValue).c_str(), scriptPubKey.ToString(true).c_str());
408 std::string ToString() const
410 if (IsEmpty()) return "CTxOut(empty)";
411 if (scriptPubKey.size() < 6)
412 return "CTxOut(error)";
413 return strprintf("CTxOut(nValue=%s, scriptPubKey=%s)", FormatMoney(nValue).c_str(), scriptPubKey.ToString().c_str());
418 printf("%s\n", ToString().c_str());
432 typedef std::map<uint256, std::pair<CTxIndex, CTransaction> > MapPrevTx;
434 /** The basic transaction that is broadcasted on the network and contained in
435 * blocks. A transaction can contain multiple inputs and outputs.
440 static const int CURRENT_VERSION=1;
443 std::vector<CTxIn> vin;
444 std::vector<CTxOut> vout;
445 unsigned int nLockTime;
447 // Denial-of-service detection:
449 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
458 READWRITE(this->nVersion);
459 nVersion = this->nVersion;
463 READWRITE(nLockTime);
468 nVersion = CTransaction::CURRENT_VERSION;
469 nTime = GetAdjustedTime();
473 nDoS = 0; // Denial-of-service prevention
478 return (vin.empty() && vout.empty());
481 uint256 GetHash() const
483 return SerializeHash(*this);
486 bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
488 // Time based nLockTime implemented in 0.1.6
491 if (nBlockHeight == 0)
492 nBlockHeight = nBestHeight;
494 nBlockTime = GetAdjustedTime();
495 if ((int64)nLockTime < ((int64)nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
497 BOOST_FOREACH(const CTxIn& txin, vin)
503 bool IsNewerThan(const CTransaction& old) const
505 if (vin.size() != old.vin.size())
507 for (unsigned int i = 0; i < vin.size(); i++)
508 if (vin[i].prevout != old.vin[i].prevout)
512 unsigned int nLowest = std::numeric_limits<unsigned int>::max();
513 for (unsigned int i = 0; i < vin.size(); i++)
515 if (vin[i].nSequence != old.vin[i].nSequence)
517 if (vin[i].nSequence <= nLowest)
520 nLowest = vin[i].nSequence;
522 if (old.vin[i].nSequence < nLowest)
525 nLowest = old.vin[i].nSequence;
532 bool IsCoinBase() const
534 return (vin.size() == 1 && vin[0].prevout.IsNull() && vout.size() >= 1);
537 bool IsCoinStake() const
539 // ppcoin: the coin stake transaction is marked with the first output empty
540 return (vin.size() > 0 && (!vin[0].prevout.IsNull()) && vout.size() >= 2 && vout[0].IsEmpty());
543 /** Check for standard transaction types
544 @return True if all outputs (scriptPubKeys) use only standard transaction forms
546 bool IsStandard() const;
548 /** Check for standard transaction types
549 @param[in] mapInputs Map of previous transactions that have outputs we're spending
550 @return True if all inputs (scriptSigs) use only standard transaction forms
551 @see CTransaction::FetchInputs
553 bool AreInputsStandard(const MapPrevTx& mapInputs) const;
555 /** Count ECDSA signature operations the old-fashioned (pre-0.6) way
556 @return number of sigops this transaction's outputs will produce when spent
557 @see CTransaction::FetchInputs
559 unsigned int GetLegacySigOpCount() const;
561 /** Count ECDSA signature operations in pay-to-script-hash inputs.
563 @param[in] mapInputs Map of previous transactions that have outputs we're spending
564 @return maximum number of sigops required to validate this transaction's inputs
565 @see CTransaction::FetchInputs
567 unsigned int GetP2SHSigOpCount(const MapPrevTx& mapInputs) const;
569 /** Amount of bitcoins spent by this transaction.
570 @return sum of all outputs (note: does not include fees)
572 int64 GetValueOut() const
575 BOOST_FOREACH(const CTxOut& txout, vout)
577 nValueOut += txout.nValue;
578 if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
579 throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
584 /** Amount of bitcoins coming in to this transaction
585 Note that lightweight clients may not know anything besides the hash of previous transactions,
586 so may not be able to calculate this.
588 @param[in] mapInputs Map of previous transactions that have outputs we're spending
589 @return Sum of value of all inputs (scriptSigs)
590 @see CTransaction::FetchInputs
592 int64 GetValueIn(const MapPrevTx& mapInputs) const;
594 static bool AllowFree(double dPriority)
596 // Large (in bytes) low-priority (new, small-coin) transactions
598 return dPriority > COIN * 144 / 250;
601 int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=false, enum GetMinFee_mode mode=GMF_BLOCK, unsigned int nBytes = 0) const;
603 bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
605 CAutoFile filein = CAutoFile(OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb"), SER_DISK, CLIENT_VERSION);
607 return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
610 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
611 return error("CTransaction::ReadFromDisk() : fseek failed");
616 catch (std::exception &e) {
617 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
620 // Return file pointer
623 if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
624 return error("CTransaction::ReadFromDisk() : second fseek failed");
625 *pfileRet = filein.release();
630 friend bool operator==(const CTransaction& a, const CTransaction& b)
632 return (a.nVersion == b.nVersion &&
633 a.nTime == b.nTime &&
636 a.nLockTime == b.nLockTime);
639 friend bool operator!=(const CTransaction& a, const CTransaction& b)
644 std::string ToStringShort() const
647 str += strprintf("%s %s", GetHash().ToString().c_str(), IsCoinBase()? "base" : (IsCoinStake()? "stake" : "user"));
651 std::string ToString() const
654 str += IsCoinBase()? "Coinbase" : (IsCoinStake()? "Coinstake" : "CTransaction");
655 str += strprintf("(hash=%s, nTime=%d, ver=%d, vin.size=%"PRIszu", vout.size=%"PRIszu", nLockTime=%d)\n",
656 GetHash().ToString().substr(0,10).c_str(),
662 for (unsigned int i = 0; i < vin.size(); i++)
663 str += " " + vin[i].ToString() + "\n";
664 for (unsigned int i = 0; i < vout.size(); i++)
665 str += " " + vout[i].ToString() + "\n";
671 printf("%s", ToString().c_str());
675 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
676 bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
677 bool ReadFromDisk(COutPoint prevout);
678 bool DisconnectInputs(CTxDB& txdb);
680 /** Fetch from memory and/or disk. inputsRet keys are transaction hashes.
682 @param[in] txdb Transaction database
683 @param[in] mapTestPool List of pending changes to the transaction index database
684 @param[in] fBlock True if being called to add a new best-block to the chain
685 @param[in] fMiner True if being called by CreateNewBlock
686 @param[out] inputsRet Pointers to this transaction's inputs
687 @param[out] fInvalid returns true if transaction is invalid
688 @return Returns true if all inputs are in txdb or mapTestPool
690 bool FetchInputs(CTxDB& txdb, const std::map<uint256, CTxIndex>& mapTestPool,
691 bool fBlock, bool fMiner, MapPrevTx& inputsRet, bool& fInvalid);
693 /** Sanity check previous transactions, then, if all checks succeed,
694 mark them as spent by this transaction.
696 @param[in] inputs Previous transactions (from FetchInputs)
697 @param[out] mapTestPool Keeps track of inputs that need to be updated on disk
698 @param[in] posThisTx Position of this transaction on disk
699 @param[in] pindexBlock
700 @param[in] fBlock true if called from ConnectBlock
701 @param[in] fMiner true if called from CreateNewBlock
702 @param[in] fScriptChecks enable scripts validation?
703 @param[in] flags STRICT_FLAGS script validation flags
704 @param[in] pvChecks NULL If pvChecks is not NULL, script checks are pushed onto it instead of being performed inline.
705 @return Returns true if all checks succeed
707 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs, std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx, const CBlockIndex* pindexBlock,
708 bool fBlock, bool fMiner, bool fScriptChecks=true,
709 unsigned int flags=STRICT_FLAGS, std::vector<CScriptCheck> *pvChecks = NULL);
710 bool ClientConnectInputs();
711 bool CheckTransaction() const;
712 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
713 bool GetCoinAge(CTxDB& txdb, uint64& nCoinAge) const; // ppcoin: get transaction coin age
716 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
719 /** Closure representing one script verification
720 * Note that this stores references to the spending transaction */
724 CScript scriptPubKey;
725 const CTransaction *ptxTo;
732 CScriptCheck(const CTransaction& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, int nHashTypeIn) :
733 scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey),
734 ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), nHashType(nHashTypeIn) { }
736 bool operator()() const;
738 void swap(CScriptCheck &check) {
739 scriptPubKey.swap(check.scriptPubKey);
740 std::swap(ptxTo, check.ptxTo);
741 std::swap(nIn, check.nIn);
742 std::swap(nFlags, check.nFlags);
743 std::swap(nHashType, check.nHashType);
750 /** A transaction with a merkle branch linking it to the block chain. */
751 class CMerkleTx : public CTransaction
755 std::vector<uint256> vMerkleBranch;
759 mutable bool fMerkleVerified;
767 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
776 fMerkleVerified = false;
782 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
783 nVersion = this->nVersion;
784 READWRITE(hashBlock);
785 READWRITE(vMerkleBranch);
790 int SetMerkleBranch(const CBlock* pblock=NULL);
791 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
792 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
793 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
794 int GetBlocksToMaturity() const;
795 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
796 bool AcceptToMemoryPool();
802 /** A txdb record that contains the disk location of a transaction and the
803 * locations of transactions that spend its outputs. vSpent is really only
804 * used as a flag, but having the location is very helpful for debugging.
810 std::vector<CDiskTxPos> vSpent;
817 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
820 vSpent.resize(nOutputs);
825 if (!(nType & SER_GETHASH))
842 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
844 return (a.pos == b.pos &&
845 a.vSpent == b.vSpent);
848 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
852 int GetDepthInMainChain() const;
860 /** Nodes collect new transactions into a block, hash them into a hash tree,
861 * and scan through nonce values to make the block's hash satisfy proof-of-work
862 * requirements. When they solve the proof-of-work, they broadcast the block
863 * to everyone and the block is added to the block chain. The first transaction
864 * in the block is a special one that creates a new coin owned by the creator
867 * Blocks are appended to blk0001.dat files on disk. Their location on disk
868 * is indexed by CBlockIndex objects in memory.
874 static const int CURRENT_VERSION=6;
876 uint256 hashPrevBlock;
877 uint256 hashMerkleRoot;
883 std::vector<CTransaction> vtx;
885 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
886 std::vector<unsigned char> vchBlockSig;
889 mutable std::vector<uint256> vMerkleTree;
891 // Denial-of-service detection:
893 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
902 READWRITE(this->nVersion);
903 nVersion = this->nVersion;
904 READWRITE(hashPrevBlock);
905 READWRITE(hashMerkleRoot);
910 // ConnectBlock depends on vtx following header to generate CDiskTxPos
911 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
914 READWRITE(vchBlockSig);
918 const_cast<CBlock*>(this)->vtx.clear();
919 const_cast<CBlock*>(this)->vchBlockSig.clear();
925 nVersion = CBlock::CURRENT_VERSION;
942 uint256 GetHash() const
944 return scrypt_blockhash(CVOIDBEGIN(nVersion));
947 int64 GetBlockTime() const
952 void UpdateTime(const CBlockIndex* pindexPrev);
954 // ppcoin: entropy bit for stake modifier if chosen by modifier
955 unsigned int GetStakeEntropyBit(unsigned int nTime) const
957 // Protocol switch to support p2pool at novacoin block #9689
958 if (nTime >= ENTROPY_SWITCH_TIME || fTestNet)
960 // Take last bit of block hash as entropy bit
961 unsigned int nEntropyBit = ((GetHash().Get64()) & 1llu);
962 if (fDebug && GetBoolArg("-printstakemodifier"))
963 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
966 // Before novacoin block #9689 - old protocol
967 uint160 hashSig = Hash160(vchBlockSig);
968 if (fDebug && GetBoolArg("-printstakemodifier"))
969 printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
970 hashSig >>= 159; // take the first bit of the hash
971 if (fDebug && GetBoolArg("-printstakemodifier"))
972 printf(" entropybit=%"PRI64d"\n", hashSig.Get64());
973 return hashSig.Get64();
976 // ppcoin: two types of block: proof-of-work or proof-of-stake
977 bool IsProofOfStake() const
979 return (vtx.size() > 1 && vtx[1].IsCoinStake());
982 bool IsProofOfWork() const
984 return !IsProofOfStake();
987 std::pair<COutPoint, unsigned int> GetProofOfStake() const
989 return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
992 // ppcoin: get max transaction timestamp
993 int64 GetMaxTransactionTime() const
995 int64 maxTransactionTime = 0;
996 BOOST_FOREACH(const CTransaction& tx, vtx)
997 maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
998 return maxTransactionTime;
1001 uint256 BuildMerkleTree() const
1003 vMerkleTree.clear();
1004 BOOST_FOREACH(const CTransaction& tx, vtx)
1005 vMerkleTree.push_back(tx.GetHash());
1007 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1009 for (int i = 0; i < nSize; i += 2)
1011 int i2 = std::min(i+1, nSize-1);
1012 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
1013 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
1017 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
1020 std::vector<uint256> GetMerkleBranch(int nIndex) const
1022 if (vMerkleTree.empty())
1024 std::vector<uint256> vMerkleBranch;
1026 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1028 int i = std::min(nIndex^1, nSize-1);
1029 vMerkleBranch.push_back(vMerkleTree[j+i]);
1033 return vMerkleBranch;
1036 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1040 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1043 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1045 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1052 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1054 // Open history file to append
1055 CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1057 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1059 // Write index header
1060 unsigned int nSize = fileout.GetSerializeSize(*this);
1061 fileout << FLATDATA(pchMessageStart) << nSize;
1064 long fileOutPos = ftell(fileout);
1066 return error("CBlock::WriteToDisk() : ftell failed");
1067 nBlockPosRet = fileOutPos;
1070 // Flush stdio buffers and commit to disk before returning
1072 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1073 FileCommit(fileout);
1078 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1082 // Open history file to read
1083 CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1085 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1086 if (!fReadTransactions)
1087 filein.nType |= SER_BLOCKHEADERONLY;
1093 catch (std::exception &e) {
1094 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1098 if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1099 return error("CBlock::ReadFromDisk() : errors in block header");
1108 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu", vchBlockSig=%s)\n",
1109 GetHash().ToString().c_str(),
1111 hashPrevBlock.ToString().c_str(),
1112 hashMerkleRoot.ToString().c_str(),
1113 nTime, nBits, nNonce,
1115 HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1116 for (unsigned int i = 0; i < vtx.size(); i++)
1121 printf(" vMerkleTree: ");
1122 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1123 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1128 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1129 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1130 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1131 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1132 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1133 bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1135 bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1136 bool SignBlock(CWallet& keystore);
1137 bool CheckBlockSignature(bool fProofOfStake) const;
1140 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1148 /** The block chain is a tree shaped structure starting with the
1149 * genesis block at the root, with each block potentially having multiple
1150 * candidates to be the next block. pprev and pnext link a path through the
1151 * main/longest chain. A blockindex may have multiple pprev pointing back
1152 * to it, but pnext will only point forward to the longest branch, or will
1153 * be null if the block is not part of the longest chain.
1158 const uint256* phashBlock;
1162 unsigned int nBlockPos;
1163 uint256 nChainTrust; // ppcoin: trust score of block chain
1169 unsigned int nFlags; // ppcoin: block index flags
1172 BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1173 BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
1174 BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1177 uint64 nStakeModifier; // hash modifier for proof-of-stake
1178 unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1180 // proof-of-stake specific fields
1181 COutPoint prevoutStake;
1182 unsigned int nStakeTime;
1183 uint256 hashProofOfStake;
1187 uint256 hashMerkleRoot;
1190 unsigned int nNonce;
1205 nStakeModifierChecksum = 0;
1206 hashProofOfStake = 0;
1207 prevoutStake.SetNull();
1217 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1223 nBlockPos = nBlockPosIn;
1230 nStakeModifierChecksum = 0;
1231 hashProofOfStake = 0;
1232 if (block.IsProofOfStake())
1235 prevoutStake = block.vtx[1].vin[0].prevout;
1236 nStakeTime = block.vtx[1].nTime;
1240 prevoutStake.SetNull();
1244 nVersion = block.nVersion;
1245 hashMerkleRoot = block.hashMerkleRoot;
1246 nTime = block.nTime;
1247 nBits = block.nBits;
1248 nNonce = block.nNonce;
1251 CBlock GetBlockHeader() const
1254 block.nVersion = nVersion;
1256 block.hashPrevBlock = pprev->GetBlockHash();
1257 block.hashMerkleRoot = hashMerkleRoot;
1258 block.nTime = nTime;
1259 block.nBits = nBits;
1260 block.nNonce = nNonce;
1264 uint256 GetBlockHash() const
1269 int64 GetBlockTime() const
1271 return (int64)nTime;
1274 uint256 GetBlockTrust() const;
1276 bool IsInMainChain() const
1278 return (pnext || this == pindexBest);
1281 bool CheckIndex() const
1286 enum { nMedianTimeSpan=11 };
1288 int64 GetMedianTimePast() const
1290 int64 pmedian[nMedianTimeSpan];
1291 int64* pbegin = &pmedian[nMedianTimeSpan];
1292 int64* pend = &pmedian[nMedianTimeSpan];
1294 const CBlockIndex* pindex = this;
1295 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1296 *(--pbegin) = pindex->GetBlockTime();
1298 std::sort(pbegin, pend);
1299 return pbegin[(pend - pbegin)/2];
1302 int64 GetMedianTime() const
1304 const CBlockIndex* pindex = this;
1305 for (int i = 0; i < nMedianTimeSpan/2; i++)
1308 return GetBlockTime();
1309 pindex = pindex->pnext;
1311 return pindex->GetMedianTimePast();
1315 * Returns true if there are nRequired or more blocks of minVersion or above
1316 * in the last nToCheck blocks, starting at pstart and going backwards.
1318 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1319 unsigned int nRequired, unsigned int nToCheck);
1322 bool IsProofOfWork() const
1324 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1327 bool IsProofOfStake() const
1329 return (nFlags & BLOCK_PROOF_OF_STAKE);
1332 void SetProofOfStake()
1334 nFlags |= BLOCK_PROOF_OF_STAKE;
1337 unsigned int GetStakeEntropyBit() const
1339 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1342 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1344 if (nEntropyBit > 1)
1346 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1350 bool GeneratedStakeModifier() const
1352 return (nFlags & BLOCK_STAKE_MODIFIER);
1355 void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1357 nStakeModifier = nModifier;
1358 if (fGeneratedStakeModifier)
1359 nFlags |= BLOCK_STAKE_MODIFIER;
1362 std::string ToString() const
1364 return strprintf("CBlockIndex(nprev=%p, pnext=%p, nFile=%u, nBlockPos=%-6d nHeight=%d, nMint=%s, nMoneySupply=%s, nFlags=(%s)(%d)(%s), nStakeModifier=%016"PRI64x", nStakeModifierChecksum=%08x, hashProofOfStake=%s, prevoutStake=(%s), nStakeTime=%d merkle=%s, hashBlock=%s)",
1365 pprev, pnext, nFile, nBlockPos, nHeight,
1366 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1367 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1368 nStakeModifier, nStakeModifierChecksum,
1369 hashProofOfStake.ToString().c_str(),
1370 prevoutStake.ToString().c_str(), nStakeTime,
1371 hashMerkleRoot.ToString().c_str(),
1372 GetBlockHash().ToString().c_str());
1377 printf("%s\n", ToString().c_str());
1383 /** Used to marshal pointers into hashes for db storage. */
1384 class CDiskBlockIndex : public CBlockIndex
1400 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1402 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1403 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1408 if (!(nType & SER_GETHASH))
1409 READWRITE(nVersion);
1411 READWRITE(hashNext);
1413 READWRITE(nBlockPos);
1416 READWRITE(nMoneySupply);
1418 READWRITE(nStakeModifier);
1419 if (IsProofOfStake())
1421 READWRITE(prevoutStake);
1422 READWRITE(nStakeTime);
1423 READWRITE(hashProofOfStake);
1427 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1428 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1429 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1433 READWRITE(this->nVersion);
1434 READWRITE(hashPrev);
1435 READWRITE(hashMerkleRoot);
1439 READWRITE(blockHash);
1442 uint256 GetBlockHash() const
1444 if (fUseFastIndex && (nTime < GetAdjustedTime() - 24 * 60 * 60) && blockHash != 0)
1448 block.nVersion = nVersion;
1449 block.hashPrevBlock = hashPrev;
1450 block.hashMerkleRoot = hashMerkleRoot;
1451 block.nTime = nTime;
1452 block.nBits = nBits;
1453 block.nNonce = nNonce;
1455 const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1460 std::string ToString() const
1462 std::string str = "CDiskBlockIndex(";
1463 str += CBlockIndex::ToString();
1464 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1465 GetBlockHash().ToString().c_str(),
1466 hashPrev.ToString().c_str(),
1467 hashNext.ToString().c_str());
1473 printf("%s\n", ToString().c_str());
1484 /** Describes a place in the block chain to another node such that if the
1485 * other node doesn't have the same branch, it can find a recent common trunk.
1486 * The further back it is, the further before the fork it may be.
1491 std::vector<uint256> vHave;
1498 explicit CBlockLocator(const CBlockIndex* pindex)
1503 explicit CBlockLocator(uint256 hashBlock)
1505 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1506 if (mi != mapBlockIndex.end())
1510 CBlockLocator(const std::vector<uint256>& vHaveIn)
1517 if (!(nType & SER_GETHASH))
1518 READWRITE(nVersion);
1529 return vHave.empty();
1532 void Set(const CBlockIndex* pindex)
1538 vHave.push_back(pindex->GetBlockHash());
1540 // Exponentially larger steps back
1541 for (int i = 0; pindex && i < nStep; i++)
1542 pindex = pindex->pprev;
1543 if (vHave.size() > 10)
1546 vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1549 int GetDistanceBack()
1551 // Retrace how far back it was in the sender's branch
1554 BOOST_FOREACH(const uint256& hash, vHave)
1556 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1557 if (mi != mapBlockIndex.end())
1559 CBlockIndex* pindex = (*mi).second;
1560 if (pindex->IsInMainChain())
1570 CBlockIndex* GetBlockIndex()
1572 // Find the first block the caller has in the main chain
1573 BOOST_FOREACH(const uint256& hash, vHave)
1575 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1576 if (mi != mapBlockIndex.end())
1578 CBlockIndex* pindex = (*mi).second;
1579 if (pindex->IsInMainChain())
1583 return pindexGenesisBlock;
1586 uint256 GetBlockHash()
1588 // Find the first block the caller has in the main chain
1589 BOOST_FOREACH(const uint256& hash, vHave)
1591 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1592 if (mi != mapBlockIndex.end())
1594 CBlockIndex* pindex = (*mi).second;
1595 if (pindex->IsInMainChain())
1599 return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1604 CBlockIndex* pindex = GetBlockIndex();
1607 return pindex->nHeight;
1621 mutable CCriticalSection cs;
1622 std::map<uint256, CTransaction> mapTx;
1623 std::map<COutPoint, CInPoint> mapNextTx;
1625 bool accept(CTxDB& txdb, CTransaction &tx,
1626 bool fCheckInputs, bool* pfMissingInputs);
1627 bool addUnchecked(const uint256& hash, CTransaction &tx);
1628 bool remove(CTransaction &tx);
1630 void queryHashes(std::vector<uint256>& vtxid);
1632 unsigned long size()
1635 return mapTx.size();
1638 bool exists(uint256 hash)
1640 return (mapTx.count(hash) != 0);
1643 CTransaction& lookup(uint256 hash)
1649 extern CTxMemPool mempool;