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] fStrictPayToScriptHash true if fully validating p2sh transactions
703 @return Returns true if all checks succeed
705 bool ConnectInputs(CTxDB& txdb, MapPrevTx inputs,
706 std::map<uint256, CTxIndex>& mapTestPool, const CDiskTxPos& posThisTx,
707 const CBlockIndex* pindexBlock, bool fBlock, bool fMiner, bool fScriptChecks=true, unsigned int flags=STANDARD_SCRIPT_VERIFY_FLAGS, std::vector<CScriptCheck> *pvChecks = NULL);
708 bool ClientConnectInputs();
709 bool CheckTransaction() const;
710 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
711 bool GetCoinAge(CTxDB& txdb, uint64& nCoinAge) const; // ppcoin: get transaction coin age
714 const CTxOut& GetOutputFor(const CTxIn& input, const MapPrevTx& inputs) const;
717 /** Closure representing one script verification
718 * Note that this stores references to the spending transaction */
722 CScript scriptPubKey;
723 const CTransaction *ptxTo;
730 CScriptCheck(const CTransaction& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, int nHashTypeIn) :
731 scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey),
732 ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), nHashType(nHashTypeIn) { }
734 bool operator()() const;
736 void swap(CScriptCheck &check) {
737 scriptPubKey.swap(check.scriptPubKey);
738 std::swap(ptxTo, check.ptxTo);
739 std::swap(nIn, check.nIn);
740 std::swap(nFlags, check.nFlags);
741 std::swap(nHashType, check.nHashType);
748 /** A transaction with a merkle branch linking it to the block chain. */
749 class CMerkleTx : public CTransaction
753 std::vector<uint256> vMerkleBranch;
757 mutable bool fMerkleVerified;
765 CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
774 fMerkleVerified = false;
780 nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
781 nVersion = this->nVersion;
782 READWRITE(hashBlock);
783 READWRITE(vMerkleBranch);
788 int SetMerkleBranch(const CBlock* pblock=NULL);
789 int GetDepthInMainChain(CBlockIndex* &pindexRet) const;
790 int GetDepthInMainChain() const { CBlockIndex *pindexRet; return GetDepthInMainChain(pindexRet); }
791 bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
792 int GetBlocksToMaturity() const;
793 bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
794 bool AcceptToMemoryPool();
800 /** A txdb record that contains the disk location of a transaction and the
801 * locations of transactions that spend its outputs. vSpent is really only
802 * used as a flag, but having the location is very helpful for debugging.
808 std::vector<CDiskTxPos> vSpent;
815 CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
818 vSpent.resize(nOutputs);
823 if (!(nType & SER_GETHASH))
840 friend bool operator==(const CTxIndex& a, const CTxIndex& b)
842 return (a.pos == b.pos &&
843 a.vSpent == b.vSpent);
846 friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
850 int GetDepthInMainChain() const;
858 /** Nodes collect new transactions into a block, hash them into a hash tree,
859 * and scan through nonce values to make the block's hash satisfy proof-of-work
860 * requirements. When they solve the proof-of-work, they broadcast the block
861 * to everyone and the block is added to the block chain. The first transaction
862 * in the block is a special one that creates a new coin owned by the creator
865 * Blocks are appended to blk0001.dat files on disk. Their location on disk
866 * is indexed by CBlockIndex objects in memory.
872 static const int CURRENT_VERSION=6;
874 uint256 hashPrevBlock;
875 uint256 hashMerkleRoot;
881 std::vector<CTransaction> vtx;
883 // ppcoin: block signature - signed by one of the coin base txout[N]'s owner
884 std::vector<unsigned char> vchBlockSig;
887 mutable std::vector<uint256> vMerkleTree;
889 // Denial-of-service detection:
891 bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
900 READWRITE(this->nVersion);
901 nVersion = this->nVersion;
902 READWRITE(hashPrevBlock);
903 READWRITE(hashMerkleRoot);
908 // ConnectBlock depends on vtx following header to generate CDiskTxPos
909 if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
912 READWRITE(vchBlockSig);
916 const_cast<CBlock*>(this)->vtx.clear();
917 const_cast<CBlock*>(this)->vchBlockSig.clear();
923 nVersion = CBlock::CURRENT_VERSION;
940 uint256 GetHash() const
942 return scrypt_blockhash(CVOIDBEGIN(nVersion));
945 int64 GetBlockTime() const
950 void UpdateTime(const CBlockIndex* pindexPrev);
952 // ppcoin: entropy bit for stake modifier if chosen by modifier
953 unsigned int GetStakeEntropyBit(unsigned int nTime) const
955 // Protocol switch to support p2pool at novacoin block #9689
956 if (nTime >= ENTROPY_SWITCH_TIME || fTestNet)
958 // Take last bit of block hash as entropy bit
959 unsigned int nEntropyBit = ((GetHash().Get64()) & 1llu);
960 if (fDebug && GetBoolArg("-printstakemodifier"))
961 printf("GetStakeEntropyBit: nTime=%u hashBlock=%s nEntropyBit=%u\n", nTime, GetHash().ToString().c_str(), nEntropyBit);
964 // Before novacoin block #9689 - old protocol
965 uint160 hashSig = Hash160(vchBlockSig);
966 if (fDebug && GetBoolArg("-printstakemodifier"))
967 printf("GetStakeEntropyBit: hashSig=%s", hashSig.ToString().c_str());
968 hashSig >>= 159; // take the first bit of the hash
969 if (fDebug && GetBoolArg("-printstakemodifier"))
970 printf(" entropybit=%"PRI64d"\n", hashSig.Get64());
971 return hashSig.Get64();
974 // ppcoin: two types of block: proof-of-work or proof-of-stake
975 bool IsProofOfStake() const
977 return (vtx.size() > 1 && vtx[1].IsCoinStake());
980 bool IsProofOfWork() const
982 return !IsProofOfStake();
985 std::pair<COutPoint, unsigned int> GetProofOfStake() const
987 return IsProofOfStake()? std::make_pair(vtx[1].vin[0].prevout, vtx[1].nTime) : std::make_pair(COutPoint(), (unsigned int)0);
990 // ppcoin: get max transaction timestamp
991 int64 GetMaxTransactionTime() const
993 int64 maxTransactionTime = 0;
994 BOOST_FOREACH(const CTransaction& tx, vtx)
995 maxTransactionTime = std::max(maxTransactionTime, (int64)tx.nTime);
996 return maxTransactionTime;
999 uint256 BuildMerkleTree() const
1001 vMerkleTree.clear();
1002 BOOST_FOREACH(const CTransaction& tx, vtx)
1003 vMerkleTree.push_back(tx.GetHash());
1005 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1007 for (int i = 0; i < nSize; i += 2)
1009 int i2 = std::min(i+1, nSize-1);
1010 vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
1011 BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
1015 return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
1018 std::vector<uint256> GetMerkleBranch(int nIndex) const
1020 if (vMerkleTree.empty())
1022 std::vector<uint256> vMerkleBranch;
1024 for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
1026 int i = std::min(nIndex^1, nSize-1);
1027 vMerkleBranch.push_back(vMerkleTree[j+i]);
1031 return vMerkleBranch;
1034 static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
1038 BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
1041 hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
1043 hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
1050 bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
1052 // Open history file to append
1053 CAutoFile fileout = CAutoFile(AppendBlockFile(nFileRet), SER_DISK, CLIENT_VERSION);
1055 return error("CBlock::WriteToDisk() : AppendBlockFile failed");
1057 // Write index header
1058 unsigned int nSize = fileout.GetSerializeSize(*this);
1059 fileout << FLATDATA(pchMessageStart) << nSize;
1062 long fileOutPos = ftell(fileout);
1064 return error("CBlock::WriteToDisk() : ftell failed");
1065 nBlockPosRet = fileOutPos;
1068 // Flush stdio buffers and commit to disk before returning
1070 if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
1071 FileCommit(fileout);
1076 bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
1080 // Open history file to read
1081 CAutoFile filein = CAutoFile(OpenBlockFile(nFile, nBlockPos, "rb"), SER_DISK, CLIENT_VERSION);
1083 return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
1084 if (!fReadTransactions)
1085 filein.nType |= SER_BLOCKHEADERONLY;
1091 catch (std::exception &e) {
1092 return error("%s() : deserialize or I/O error", __PRETTY_FUNCTION__);
1096 if (fReadTransactions && IsProofOfWork() && !CheckProofOfWork(GetHash(), nBits))
1097 return error("CBlock::ReadFromDisk() : errors in block header");
1106 printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%"PRIszu", vchBlockSig=%s)\n",
1107 GetHash().ToString().c_str(),
1109 hashPrevBlock.ToString().c_str(),
1110 hashMerkleRoot.ToString().c_str(),
1111 nTime, nBits, nNonce,
1113 HexStr(vchBlockSig.begin(), vchBlockSig.end()).c_str());
1114 for (unsigned int i = 0; i < vtx.size(); i++)
1119 printf(" vMerkleTree: ");
1120 for (unsigned int i = 0; i < vMerkleTree.size(); i++)
1121 printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
1126 bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
1127 bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex, bool fJustCheck=false);
1128 bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
1129 bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
1130 bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
1131 bool CheckBlock(bool fCheckPOW=true, bool fCheckMerkleRoot=true, bool fCheckSig=true) const;
1133 bool GetCoinAge(uint64& nCoinAge) const; // ppcoin: calculate total coin age spent in block
1134 bool SignBlock(CWallet& keystore);
1135 bool CheckBlockSignature(bool fProofOfStake) const;
1138 bool SetBestChainInner(CTxDB& txdb, CBlockIndex *pindexNew);
1146 /** The block chain is a tree shaped structure starting with the
1147 * genesis block at the root, with each block potentially having multiple
1148 * candidates to be the next block. pprev and pnext link a path through the
1149 * main/longest chain. A blockindex may have multiple pprev pointing back
1150 * to it, but pnext will only point forward to the longest branch, or will
1151 * be null if the block is not part of the longest chain.
1156 const uint256* phashBlock;
1160 unsigned int nBlockPos;
1161 uint256 nChainTrust; // ppcoin: trust score of block chain
1167 unsigned int nFlags; // ppcoin: block index flags
1170 BLOCK_PROOF_OF_STAKE = (1 << 0), // is proof-of-stake block
1171 BLOCK_STAKE_ENTROPY = (1 << 1), // entropy bit for stake modifier
1172 BLOCK_STAKE_MODIFIER = (1 << 2), // regenerated stake modifier
1175 uint64 nStakeModifier; // hash modifier for proof-of-stake
1176 unsigned int nStakeModifierChecksum; // checksum of index; in-memeory only
1178 // proof-of-stake specific fields
1179 COutPoint prevoutStake;
1180 unsigned int nStakeTime;
1181 uint256 hashProofOfStake;
1185 uint256 hashMerkleRoot;
1188 unsigned int nNonce;
1203 nStakeModifierChecksum = 0;
1204 hashProofOfStake = 0;
1205 prevoutStake.SetNull();
1215 CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
1221 nBlockPos = nBlockPosIn;
1228 nStakeModifierChecksum = 0;
1229 hashProofOfStake = 0;
1230 if (block.IsProofOfStake())
1233 prevoutStake = block.vtx[1].vin[0].prevout;
1234 nStakeTime = block.vtx[1].nTime;
1238 prevoutStake.SetNull();
1242 nVersion = block.nVersion;
1243 hashMerkleRoot = block.hashMerkleRoot;
1244 nTime = block.nTime;
1245 nBits = block.nBits;
1246 nNonce = block.nNonce;
1249 CBlock GetBlockHeader() const
1252 block.nVersion = nVersion;
1254 block.hashPrevBlock = pprev->GetBlockHash();
1255 block.hashMerkleRoot = hashMerkleRoot;
1256 block.nTime = nTime;
1257 block.nBits = nBits;
1258 block.nNonce = nNonce;
1262 uint256 GetBlockHash() const
1267 int64 GetBlockTime() const
1269 return (int64)nTime;
1272 uint256 GetBlockTrust() const;
1274 bool IsInMainChain() const
1276 return (pnext || this == pindexBest);
1279 bool CheckIndex() const
1284 enum { nMedianTimeSpan=11 };
1286 int64 GetMedianTimePast() const
1288 int64 pmedian[nMedianTimeSpan];
1289 int64* pbegin = &pmedian[nMedianTimeSpan];
1290 int64* pend = &pmedian[nMedianTimeSpan];
1292 const CBlockIndex* pindex = this;
1293 for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
1294 *(--pbegin) = pindex->GetBlockTime();
1296 std::sort(pbegin, pend);
1297 return pbegin[(pend - pbegin)/2];
1300 int64 GetMedianTime() const
1302 const CBlockIndex* pindex = this;
1303 for (int i = 0; i < nMedianTimeSpan/2; i++)
1306 return GetBlockTime();
1307 pindex = pindex->pnext;
1309 return pindex->GetMedianTimePast();
1313 * Returns true if there are nRequired or more blocks of minVersion or above
1314 * in the last nToCheck blocks, starting at pstart and going backwards.
1316 static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart,
1317 unsigned int nRequired, unsigned int nToCheck);
1320 bool IsProofOfWork() const
1322 return !(nFlags & BLOCK_PROOF_OF_STAKE);
1325 bool IsProofOfStake() const
1327 return (nFlags & BLOCK_PROOF_OF_STAKE);
1330 void SetProofOfStake()
1332 nFlags |= BLOCK_PROOF_OF_STAKE;
1335 unsigned int GetStakeEntropyBit() const
1337 return ((nFlags & BLOCK_STAKE_ENTROPY) >> 1);
1340 bool SetStakeEntropyBit(unsigned int nEntropyBit)
1342 if (nEntropyBit > 1)
1344 nFlags |= (nEntropyBit? BLOCK_STAKE_ENTROPY : 0);
1348 bool GeneratedStakeModifier() const
1350 return (nFlags & BLOCK_STAKE_MODIFIER);
1353 void SetStakeModifier(uint64 nModifier, bool fGeneratedStakeModifier)
1355 nStakeModifier = nModifier;
1356 if (fGeneratedStakeModifier)
1357 nFlags |= BLOCK_STAKE_MODIFIER;
1360 std::string ToString() const
1362 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)",
1363 pprev, pnext, nFile, nBlockPos, nHeight,
1364 FormatMoney(nMint).c_str(), FormatMoney(nMoneySupply).c_str(),
1365 GeneratedStakeModifier() ? "MOD" : "-", GetStakeEntropyBit(), IsProofOfStake()? "PoS" : "PoW",
1366 nStakeModifier, nStakeModifierChecksum,
1367 hashProofOfStake.ToString().c_str(),
1368 prevoutStake.ToString().c_str(), nStakeTime,
1369 hashMerkleRoot.ToString().c_str(),
1370 GetBlockHash().ToString().c_str());
1375 printf("%s\n", ToString().c_str());
1381 /** Used to marshal pointers into hashes for db storage. */
1382 class CDiskBlockIndex : public CBlockIndex
1398 explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
1400 hashPrev = (pprev ? pprev->GetBlockHash() : 0);
1401 hashNext = (pnext ? pnext->GetBlockHash() : 0);
1406 if (!(nType & SER_GETHASH))
1407 READWRITE(nVersion);
1409 READWRITE(hashNext);
1411 READWRITE(nBlockPos);
1414 READWRITE(nMoneySupply);
1416 READWRITE(nStakeModifier);
1417 if (IsProofOfStake())
1419 READWRITE(prevoutStake);
1420 READWRITE(nStakeTime);
1421 READWRITE(hashProofOfStake);
1425 const_cast<CDiskBlockIndex*>(this)->prevoutStake.SetNull();
1426 const_cast<CDiskBlockIndex*>(this)->nStakeTime = 0;
1427 const_cast<CDiskBlockIndex*>(this)->hashProofOfStake = 0;
1431 READWRITE(this->nVersion);
1432 READWRITE(hashPrev);
1433 READWRITE(hashMerkleRoot);
1437 READWRITE(blockHash);
1440 uint256 GetBlockHash() const
1442 if (fUseFastIndex && (nTime < GetAdjustedTime() - 24 * 60 * 60) && blockHash != 0)
1446 block.nVersion = nVersion;
1447 block.hashPrevBlock = hashPrev;
1448 block.hashMerkleRoot = hashMerkleRoot;
1449 block.nTime = nTime;
1450 block.nBits = nBits;
1451 block.nNonce = nNonce;
1453 const_cast<CDiskBlockIndex*>(this)->blockHash = block.GetHash();
1458 std::string ToString() const
1460 std::string str = "CDiskBlockIndex(";
1461 str += CBlockIndex::ToString();
1462 str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
1463 GetBlockHash().ToString().c_str(),
1464 hashPrev.ToString().c_str(),
1465 hashNext.ToString().c_str());
1471 printf("%s\n", ToString().c_str());
1482 /** Describes a place in the block chain to another node such that if the
1483 * other node doesn't have the same branch, it can find a recent common trunk.
1484 * The further back it is, the further before the fork it may be.
1489 std::vector<uint256> vHave;
1496 explicit CBlockLocator(const CBlockIndex* pindex)
1501 explicit CBlockLocator(uint256 hashBlock)
1503 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
1504 if (mi != mapBlockIndex.end())
1508 CBlockLocator(const std::vector<uint256>& vHaveIn)
1515 if (!(nType & SER_GETHASH))
1516 READWRITE(nVersion);
1527 return vHave.empty();
1530 void Set(const CBlockIndex* pindex)
1536 vHave.push_back(pindex->GetBlockHash());
1538 // Exponentially larger steps back
1539 for (int i = 0; pindex && i < nStep; i++)
1540 pindex = pindex->pprev;
1541 if (vHave.size() > 10)
1544 vHave.push_back((!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet));
1547 int GetDistanceBack()
1549 // Retrace how far back it was in the sender's branch
1552 BOOST_FOREACH(const uint256& hash, vHave)
1554 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1555 if (mi != mapBlockIndex.end())
1557 CBlockIndex* pindex = (*mi).second;
1558 if (pindex->IsInMainChain())
1568 CBlockIndex* GetBlockIndex()
1570 // Find the first block the caller has in the main chain
1571 BOOST_FOREACH(const uint256& hash, vHave)
1573 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1574 if (mi != mapBlockIndex.end())
1576 CBlockIndex* pindex = (*mi).second;
1577 if (pindex->IsInMainChain())
1581 return pindexGenesisBlock;
1584 uint256 GetBlockHash()
1586 // Find the first block the caller has in the main chain
1587 BOOST_FOREACH(const uint256& hash, vHave)
1589 std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
1590 if (mi != mapBlockIndex.end())
1592 CBlockIndex* pindex = (*mi).second;
1593 if (pindex->IsInMainChain())
1597 return (!fTestNet ? hashGenesisBlock : hashGenesisBlockTestNet);
1602 CBlockIndex* pindex = GetBlockIndex();
1605 return pindex->nHeight;
1619 mutable CCriticalSection cs;
1620 std::map<uint256, CTransaction> mapTx;
1621 std::map<COutPoint, CInPoint> mapNextTx;
1623 bool accept(CTxDB& txdb, CTransaction &tx,
1624 bool fCheckInputs, bool* pfMissingInputs);
1625 bool addUnchecked(const uint256& hash, CTransaction &tx);
1626 bool remove(CTransaction &tx);
1628 void queryHashes(std::vector<uint256>& vtxid);
1630 unsigned long size()
1633 return mapTx.size();
1636 bool exists(uint256 hash)
1638 return (mapTx.count(hash) != 0);
1641 CTransaction& lookup(uint256 hash)
1647 extern CTxMemPool mempool;